open-index/open-npm huggingface dataset:
npm package: @skill-hq/cli
Description: CLI for the SkillHQ marketplace - publish, install, and manage AI skills
Latest version: 0.1.1

# SkillHQ CLI

The official CLI for [SkillHQ](https://skillhq.dev) — the marketplace for production-ready AI skills. Search, install, publish, and manage skills for Claude Code and other AI agents directly from your terminal.

## Installation

```bash
npm install -g @skill-hq/cli
```

Requires Node.js 18 or later.

## Quick Start

```bash
# Log in to your SkillHQ account
skillhq auth login

# Search the marketplace
skillhq search "code review"

# Install a skill
skillhq install my-skill-name

# List installed skills
skillhq list
```

## Commands

### Authentication

```bash
skillhq auth login     # Log in via browser (opens OAuth flow)
skillhq auth logout    # Clear saved credentials
skillhq auth status    # Show current login status
```

### Marketplace

```bash
skillhq search <query>                        # Search for skills
skillhq search <query> --category <category>  # Filter by category
skillhq search <query> --max-price 9.99       # Filter by price
skillhq info <skill-name>                     # Show skill details and version history
```

### Installing Skills

Skills are installed to `~/.claude/skills/<name>/` by default.

```bash
skillhq install <skill-name>           # Install globally (default)
skillhq install <skill-name> --project # Install in current project (.claude/skills/)
```

### Managing Installed Skills

```bash
skillhq list                  # List all installed skills
skillhq outdated              # Check for available updates
skillhq update <skill-name>   # Update a skill to the latest version
skillhq remove <skill-name>   # Remove a skill
```

### Publishing

```bash
# Validate your skill before publishing
skillhq validate ./my-skill

# Publish to the marketplace
skillhq publish ./my-skill --price 4.99 --category productivity

# Update an existing listing
skillhq publish ./my-skill --price 4.99 --category productivity --update --changelog "Bug fixes"
```

## Creating a Skill

A skill is a directory containing a `SKILL.md` file with YAML frontmatter:

```
my-skill/
  SKILL.md        # Required — skill definition and instructions
  commands/       # Optional — additional command files
  prompts/        # Optional — prompt templates
```

**`SKILL.md` frontmatter:**

```yaml
---
name: my-skill-name
description: A short description of what your skill does (50–2000 chars)
version: 1.0.0
author: Your Name
license: MIT
tags: [productivity, code-review]
---

# My Skill

Instructions and content for your skill...
```

Run `skillhq validate ./my-skill` to check your skill is ready before publishing.

## Links

- [Marketplace](https://skillhq.dev)
- [Documentation](https://skillhq.dev/docs)
- [CLI Reference](https://skillhq.dev/docs/cli)
npm package: @skill-kit/convert
Description: Format converter for Skill Kit - convert between Claude Code, Codex CLI, Cursor, and Continue formats
Latest version: 1.0.0

# @skill-kit/convert

Format converter for Skill Kit - convert between Claude Code, Codex CLI, Cursor, and Continue formats.

## Installation

```bash
npm install @skill-kit/convert
# or
pnpm add @skill-kit/convert
```

## Usage

### CLI

```bash
# Convert a skill file to Codex format
skill-convert convert ./SKILL.md --to codex

# Convert to all formats
skill-convert convert ./SKILL.md --to all

# Detect format
skill-convert detect ./SKILL.md

# Batch convert directory
skill-convert convert ./skills/ --to cursor -r --output ./converted/
```

### Programmatic API

```typescript
import {
  parseClaudeSkill,
  convert,
  convertWithWarnings,
  detectFormat,
} from '@skill-kit/convert';

// Parse a Claude Code skill
const skill = parseClaudeSkill(content);

// Convert to Codex format
const codexContent = convert(skill, 'claude', 'codex');

// Convert with warnings
const { content, warnings } = convertWithWarnings(skill, 'claude', 'codex');

// Detect format
const result = detectFormat(content);
console.log(result.format, result.confidence);
```

## Supported Formats

| Format | Source | Target | File Pattern |
|--------|--------|--------|--------------|
| Claude Code | Yes | Yes | `SKILL.md` |
| Codex CLI | Yes | Yes | `agents/*.md` |
| Cursor | Yes | Yes | `.cursorrules` |
| Continue | Yes | Yes | `config.json` |

## Conversion Matrix

| From / To | Claude | Codex | Cursor | Continue |
|-----------|--------|-------|--------|----------|
| Claude | - | Yes | Yes | Yes |
| Codex | Yes | - | Via Claude | Via Claude |
| Cursor | Yes | Via Claude | - | Via Claude |
| Continue | Yes | Via Claude | Via Claude | - |

## Field Mapping

### Claude -> Codex

- `name` -> `name` (converted to kebab-case)
- `description` -> `description`
- `version` -> (removed, warning)
- `triggers` -> (removed, warning)
- `## Core Workflow` -> `## Workflow`

### Claude -> Cursor

- `name` -> `# Title`
- `description` -> (removed)
- `## Core Workflow` -> `## Workflow Rules`
- `## Prerequisites` -> `## Constraints`

### Claude -> Continue

- `name` -> `customCommands[].name` (kebab-case)
- `description` -> `customCommands[].description`
- All sections -> `customCommands[].prompt`

## License

MIT
npm package: @skill-kit/lint
Description: SKILL.md format linter for Skill Kit - check and fix your AI agent skills
Latest version: 1.0.0

# @skill-kit/lint

SKILL.md format linter for Skill Kit - check and fix your AI agent skills.

## Installation

```bash
npm install @skill-kit/lint
# or
pnpm add @skill-kit/lint
```

## Usage

### CLI

```bash
# Lint all SKILL.md files
skill-lint

# Lint specific files
skill-lint ./path/to/SKILL.md

# Auto-fix issues
skill-lint --fix

# Output in different formats
skill-lint --format json
skill-lint --format github  # For CI/CD
```

### Programmatic API

```typescript
import { Linter } from '@skill-kit/lint';

const linter = new Linter();

// Lint a file
const result = await linter.lint('./SKILL.md');
console.log(result.messages);

// Lint content directly
const result = await linter.lintContent(content, 'SKILL.md');

// Fix issues
const fixResult = await linter.fix('./SKILL.md');
console.log(fixResult.output);
```

## Configuration

Create a `.skilllintrc.json` file in your project root:

```json
{
  "extends": "recommended",
  "rules": {
    "frontmatter-required": "error",
    "description-format": "warn",
    "max-length": ["warn", { "max": 15000 }]
  }
}
```

### Presets

- `recommended` - Sensible defaults for most projects
- `strict` - Stricter rules for production skills

### Available Rules

#### Format Rules

| Rule | Description | Fixable |
|------|-------------|---------|
| `frontmatter-required` | Ensure frontmatter exists | No |
| `frontmatter-fields` | Ensure required fields exist | No |
| `sections-required` | Ensure required sections exist | No |
| `section-not-empty` | Ensure sections have content | No |

#### Style Rules

| Rule | Description | Fixable |
|------|-------------|---------|
| `description-format` | Ensure third-person description | Yes |

#### Best Practices Rules

| Rule | Description | Fixable |
|------|-------------|---------|
| `max-length` | Limit SKILL.md length | No |
| `examples-exist` | Ensure examples are provided | No |
| `triggers-count` | Limit trigger count | No |
| `steps-count` | Limit workflow steps | No |

#### Reference Rules

| Rule | Description | Fixable |
|------|-------------|---------|
| `no-broken-links` | Check internal links | No |

## Output Formats

### Stylish (default)

```
/path/to/SKILL.md
  1:1  error  Missing frontmatter  frontmatter-required
  2:1  warning  Description should use third-person  description-format

2 problems (1 error, 1 warning)
```

### JSON

```json
[{
  "filePath": "/path/to/SKILL.md",
  "messages": [...],
  "errorCount": 1,
  "warningCount": 1
}]
```

### GitHub Actions

```
::error file=/path/to/SKILL.md,line=1,col=1::frontmatter-required: Missing frontmatter
```

## License

MIT
npm package: @skill-kit/registry
Description: Local Skill registry and package manager for Skill Kit
Latest version: 1.0.0

# @skill-kit/registry

Local Skill registry and package manager for Skill Kit. Similar to npm for Node.js packages, this tool manages the installation, updating, and removal of Skills.

## Features

- Install Skills from local paths, GitHub repositories, or remote registry
- List all installed Skills
- Update installed Skills to newer versions
- Remove Skills
- Version management with semver support
- Symlink mode for development

## Installation

```bash
npm install @skill-kit/registry
# or
pnpm add @skill-kit/registry
```

## CLI Usage

### Install a Skill

```bash
# From local path
skill-registry install ./my-skill

# From GitHub
skill-registry install github:user/repo
skill-registry install github:user/repo@v1.0.0

# From registry
skill-registry install @user/skill-name
skill-registry install skill-name@^1.0.0

# Options
skill-registry install ./my-skill --link  # Create symlink
skill-registry install ./my-skill --force # Overwrite existing
```

### List Installed Skills

```bash
skill-registry list
skill-registry list --json
skill-registry list --filter "pattern"
```

### Update Skills

```bash
# Update all skills
skill-registry update

# Update specific skill
skill-registry update my-skill

# Update to specific version
skill-registry update my-skill --version 2.0.0
```

### Check for Outdated Skills

```bash
skill-registry outdated
```

### Uninstall a Skill

```bash
skill-registry uninstall my-skill
skill-registry rm my-skill
```

## Programmatic API

```typescript
import {
  installSkill,
  listSkills,
  updateSkill,
  uninstallSkill,
  checkOutdated,
} from '@skill-kit/registry';

// Install from local path
const result = await installSkill({
  target: './my-skill',
  link: false,
  force: false,
});

// List installed skills
const { skills, total } = await listSkills({
  filter: 'pattern',
});

// Update a skill
const updateResults = await updateSkill({
  name: 'my-skill',
  version: '2.0.0',
});

// Check for outdated skills
const outdated = await checkOutdated();

// Uninstall
const uninstallResult = await uninstallSkill({
  name: 'my-skill',
});
```

## Storage Structure

Skills are stored in `~/.skill-kit/skills/` with metadata tracked in `~/.skill-kit/installed.json`.

```
~/.skill-kit/
├── skills/
│   ├── my-skill/
│   │   └── SKILL.md
│   └── user__another-skill/
│       └── SKILL.md
├── installed.json
└── cache/
```

## Install Sources

| Source | Example | Description |
|--------|---------|-------------|
| Local | `./my-skill` | Install from local directory |
| GitHub | `github:user/repo` | Install from GitHub repository |
| GitHub URL | `https://github.com/user/repo` | Install from GitHub URL |
| Registry | `@user/skill` | Install from Skill Hub registry |
| Registry | `skill-name@1.0.0` | Install specific version |

## License

MIT
npm package: @skill-lock/ngx.core
Description: Skill Lock NGX Core
Author: Skill Lock
Latest version: 0.1.1

# @skill-lock/ngx.core
A library that consists of pipes, utilities and services to help you with development

## Getting Started

### Installation

```shell
npm install @skill-lock/ngx.core
```

### Register module

```ts
import { CoreModule } from "@skill-lock/ngx.core";

@NgModule({
    imports: [
        CoreModule
    ]
})
export class AppModule {

}
```

## Contributing to the project

#### Install Dependencies
The following process need to be executed in order to get started.

```shell
npm install
```


### Building the code

```shell
gulp build
```
In order to view all other tasks invoke `gulp` or check the gulp tasks directly.

### Running the tests

```shell
gulp test
```

### Development utils

#### Trigger gulp watch
Handles compiling of changes.
```shell
gulp watch
```


#### Running Continuous Tests
Spawns test runner and keep watching for changes.
```
gulp tdd
```

### Preparation for Release

```
gulp prepare-release --bump major|minor|patch|prerelease (default: patch) --version-suffix beta (default: rc - only applies to prerelease)
```
npm package: @skill-toolbox/cli
Description: Command-line interface for skill-toolbox
Latest version: 0.0.3

# @skill-toolbox/cli

Command-line interface for managing Claude Code skills.

## Installation

```bash
pnpm add -g @skill-toolbox/cli
```

## Usage

### Install a Skill

```bash
# From GitHub
skill-toolbox install github:user/skill-repo

# From user/repo shorthand
skill-toolbox install user/skill-repo

# From local path
skill-toolbox install ./local/skill

# Custom installation directory
skill-toolbox install user/skill-repo --dir ./my-skills
```

### List Installed Skills

```bash
skill-toolbox list

# Custom skills directory
skill-toolbox list --dir ./my-skills
```

### Validate a Skill

```bash
# Validate skill file
skill-toolbox validate ./skills/my-skill/SKILL.md

# Validate skill directory
skill-toolbox validate ./skills/my-skill
```

## Commands

- `install <source>` - Install a skill from git or local path
- `list` - List installed skills
- `validate <path>` - Validate skill format

## Options

- `-d, --dir <directory>` - Skills directory (default: ./skills)
- `-h, --help` - Show help
- `-V, --version` - Show version

## License

MIT
npm package: @skill-toolbox/filesystem-source
Description: Filesystem source adapter for skill-toolbox
Latest version: 0.0.3

# @skill-toolbox/filesystem-source

Filesystem source adapter for skill-toolbox. Enables loading skills from local directories and files.

## Installation

```bash
npm install @skill-toolbox/filesystem-source
```

## Usage

### Basic Usage

```typescript
import { FilesystemSource } from '@skill-toolbox/filesystem-source';

const source = new FilesystemSource();

// Check if source can handle a path
const canHandle = await source.canHandle('/path/to/skills');

// Resolve path to metadata
const meta = await source.resolve('/path/to/skills');

// Fetch (validates path exists)
const localPath = await source.fetch(meta);

// Discover skills
const skills = await source.discover(localPath, meta);
```

### With Custom Working Directory

```typescript
const source = new FilesystemSource({
  cwd: '/base/directory'
});

// Now relative paths are resolved from cwd
const meta = await source.resolve('./skills');
```

## Features

- **Single Skill Loading**: Load a skill from a directory containing a SKILL.md file
- **Multi-Skill Discovery**: Discover multiple skills in subdirectories
- **Direct File Loading**: Load a skill directly from a SKILL.md file
- **Relative Path Support**: Use relative paths with custom working directory

## API

### `FilesystemSource`

#### Constructor

```typescript
constructor(options?: FilesystemSourceOptions)
```

**Options:**
- `cwd` - Base directory for relative paths (default: `process.cwd()`)

#### Methods

##### `canHandle(source: string): Promise<boolean>`

Check if the source string is a valid filesystem path.

##### `resolve(source: string): Promise<SkillSourceMeta>`

Resolve the source string to metadata.

##### `fetch(meta: SkillSourceMeta, options?: FetchOptions): Promise<string>`

Validate and return the path (no actual fetching needed for filesystem).

##### `discover(localPath: string, meta: SkillSourceMeta): Promise<DiscoveredSkill[]>`

Discover skills in the given path.

## License

MIT