open-index/open-npm huggingface dataset:
npm package: @skill-vault/cli
Description: SkillVault CLI tool for interacting with the marketplace and downloading AI components directly to your workspace.
Author: SkillVault
Latest version: 1.1.2

# @skill-vault/cli

The official command-line interface for SkillVault, an open-source AI component marketplace.

This CLI allows developers to reliably and efficiently pull AI prompts, code snippets, and JSON configurations directly into their working directory.

## Usage

You don't need to install anything globally. You can run the CLI directly via `npx` (or `pnpx`, `bunx`):

```bash
npx @skill-vault/cli install <component-id>
```

### Example:

```bash
npx @skill-vault/cli install 5
```

This will:

1. Fetch component `#5` from the SkillVault API.
2. Intelligently save the payload with the correct name and file extension (e.g., `component-name.md` or `component-name.json`).
3. Increment the download tracker on the marketplace.

## Environment Variables

By default, the CLI connects to the production SkillVault instance.

You can override the target API URL by exporting:

```bash
export SKILLVAULT_API_URL="https://your-domain.com/api/v1/components"
```

## How it works

This package is a thin Node.js wrapper that natively bundles pre-compiled Go binaries for `windows`, `linux`, and `darwin` (macOS) across `amd64` and `arm64` architectures. When you run the `npx` command, it automatically detects your OS and architecture, and spawns the correct statically-linked binary, meaning you get the speed of Go with the distribution convenience of NPM.

## License

This project is open-source.
npm package: @skill4agent/mcp-server
Description: MCP Server for skill4agent - Search, view, and install AI skills
Author: skill4agent
Latest version: 0.1.4

# @skill4agent/mcp-server

[中文](https://github.com/osulivan/skill4agent-mcp-server/blob/main/README_CN.md) | English

MCP (Model Context Protocol) Server for skill4agent - Search, view, and install AI skills in AI conversations.

## Features

Provides the following capabilities through the MCP protocol:

- 🔍 **Search Skills** - Search AI skills by keyword, with optional category filtering
- 📄 **Get Details** - View complete skill documentation (SKILL.md)
- 📦 **Installation Info** - Get download links and installation commands for skills

## Installation

```bash
npm install -g @skill4agent/mcp-server
```

Or run directly with npx:

```bash
npx @skill4agent/mcp-server
```

## Usage in AI Applications (Claude Desktop, etc.)

Add the following to your Claude Desktop configuration file:

```json
{
  "mcpServers": {
    "skill4agent": {
      "command": "npx",
      "args": ["-y", "@skill4agent/mcp-server"]
    }
  }
}
```

To use a custom API endpoint, add the `env` configuration:

```json
{
  "mcpServers": {
    "skill4agent": {
      "command": "npx",
      "args": ["-y", "@skill4agent/mcp-server"],
      "env": {
        "SKILL4AGENT_API_URL": "https://your-custom-domain.com/api/mcp"
      }
    }
  }
}
```

## Available Tools

### search_skills

Search for AI skills.

**Parameters:**
- `keyword` (required): Search keyword
- `categories` (optional): Category filter, supports both English and Chinese
- `limit` (optional): Limit the number of results, default is 10, maximum is 100

**Example:**
```json
{
  "keyword": "React",
  "categories": ["Frontend Development"],
  "limit": 5
}
```

### get_skill

Get detailed information about a specific skill.

**Parameters:**
- `skillId` (required): Skill ID, obtained from the `search_skills` tool results

**Example:**
```json
{
  "skillId": "frontend-design--anthropics-skills"
}
```

### install_skill

Get installation information for a skill.

**Parameters:**
- `skillId` (required): Skill ID

**Example:**
```json
{
  "skillId": "frontend-design--anthropics-skills"
}
```

## Environment Variables

| Variable | Description | Default |
|----------|-------------|---------|
| `SKILL4AGENT_API_URL` | skill4agent API endpoint | `https://skill4agent.com/api/mcp` |

## Local Development

```bash
# Install dependencies
npm install

# Build
npm run build

# Development mode (hot reload)
npm run dev

# Run directly
node dist/index.js
```

## Project Structure

```
@skill4agent/mcp-server/
├── src/
│   ├── index.ts       # Entry point
│   ├── server.ts      # MCP Server main logic
│   ├── api/
│   │   └── client.ts  # API client
│   └── tools/
│       ├── search.ts  # search_skills tool
│       ├── detail.ts  # get_skill tool
│       └── install.ts # install_skill tool
├── package.json
├── tsconfig.json
└── README.md
```

## Related Links

- [skill4agent](https://skill4agent.com)
- [MCP Documentation](https://modelcontextprotocol.io)
- [NPM Package](https://www.npmjs.com/package/@skill4agent/mcp-server)

## License

MIT
npm package: @skillbank/cli
Description: SkillBank CLI - Discover, install, and share AI agent skills
Author: SkillBank
Latest version: 0.1.0

# @skillbank/cli

The official CLI for [SkillBank](https://skillbank.dev) - Discover, install, and share AI agent skills.

## Installation

```bash
# Using npx (no installation required)
npx @skillbank/cli --help

# Global installation
npm install -g @skillbank/cli
```

## Usage

```bash
# Search for skills
skb search git

# Install a skill
skb add git-commit

# Login to your account
skb login

# Publish a skill
skb publish

# Get help
skb --help
```

## Quick Install (Alternative)

If you prefer to install the native binary directly:

```bash
# macOS/Linux
curl -fsSL https://skillbank.dev/install.sh | bash

# Windows PowerShell
irm https://skillbank.dev/install.ps1 | iex
```

## Documentation

Visit [skillbank.dev](https://skillbank.dev) for full documentation.

## License

MIT
npm package: @skillbolt/execute
Description: Runtime execution of skills via AI agent SDKs with isolated sessions
Latest version: 1.0.0

# @skillbolt/execute

Execution engine for Skillbolt. Runs tasks via AI agent SDKs with isolated sessions, DAG orchestration, and log streaming.

## Features

- **RunContext** — Isolated run directories with skill copying, file staging, meta/result tracking
- **SkillOrchestrator** — Phase-based parallel execution with plan generation and visualization
- **AgentClient abstraction** — Pluggable agent backends (Mock, Claude, custom)
- **Prompt builders** — Isolated and direct executor prompt generation
- **Summary extraction** — Parse `<execution_summary>` tags from agent responses
- **Run management** — List, get, and clean up old runs

## Quick Start

```typescript
import { SkillOrchestrator, RunContext, MockAgentClient } from '@skillbolt/execute';

const runContext = RunContext.create('fix the login bug', { mode: 'dag' });

const orchestrator = new SkillOrchestrator({
  maxConcurrent: 6,
  nodeTimeout: 600,
  runContext,
});

const result = await orchestrator.runWithVisualizer({
  task: 'fix the login bug',
  skillNames: ['debugger', 'test-writer'],
  visualizer, // implements VisualizerProtocol
});

console.log(result.status); // 'completed' | 'partial' | 'failed'
```

## CLI

```bash
skill run "fix the login bug" --skills debugger,test-writer --mode dag
skill run "migrate database" --plan-only
skill run "generate report" --mode freestyle
```

## Execution Modes

| Mode        | Description                                        |
| ----------- | -------------------------------------------------- |
| `dag`       | Auto-generate DAG plan, execute in parallel phases |
| `freestyle` | Agent chooses which skills to use                  |
| `direct`    | Single skill execution                             |
| `baseline`  | No skills, agent works directly                    |

## API

| Export                        | Description                              |
| ----------------------------- | ---------------------------------------- |
| `SkillOrchestrator`           | Main orchestrator with plan→execute flow |
| `RunContext`                  | Isolated run directory management        |
| `RunManager`                  | List, get, cleanup runs                  |
| `MockAgentClient`             | Testing client with canned responses     |
| `ClaudeAgentClient`           | Claude Agent SDK client (stub)           |
| `buildIsolatedExecutorPrompt` | Build prompt for skill execution         |
| `buildDirectExecutorPrompt`   | Build prompt for direct execution        |
| `extractExecutionSummary`     | Parse execution results                  |

## License

MIT
npm package: @skillbolt/search
Description: Intelligent LLM-guided skill retrieval via capability tree traversal
Latest version: 1.0.0

# @skillbolt/search

Intelligent skill search for Skillbolt. Finds task-relevant skills using LLM-guided multi-level tree traversal.

## Features

- **Multi-level tree descent** — Navigates capability tree with LLM selection at each level
- **Parallel branch search** — Explores multiple branches concurrently
- **Skill pruning** — Deduplication and workflow-stage ranking
- **Early stop optimization** — Stops when enough relevant skills are found
- **Event system** — Real-time progress callbacks

## Quick Start

```typescript
import { Searcher, createSearchConfig } from '@skillbolt/search';
import { loadTree } from '@skillbolt/tree';
import { createLLMAdapter } from '@skillbolt/core';

const llm = createLLMAdapter();
const tree = await loadTree('tree.yaml');
const config = createSearchConfig({ maxSkills: 10 });
const searcher = new Searcher({ llm, tree, config });

const result = await searcher.search('create a landing page');
for (const skill of result.selectedSkills) {
  console.log(`${skill.name}: ${skill.description}`);
}
console.log(`LLM calls: ${result.llmCalls}`);
```

## CLI

```bash
skill skill-search "create a promotional video for my research paper"
skill skill-search "fix login bug" --max-skills 5 --json
```

## API

| Export               | Description                                   |
| -------------------- | --------------------------------------------- |
| `Searcher`           | Main search class with recursive tree descent |
| `createSearchConfig` | Create search configuration                   |
| `SearchResult`       | Query results with selected skills and stats  |
| `SearchEvent`        | Progress event types for real-time tracking   |
| `createEventEmitter` | Simple callback-based event system            |

## Configuration

| Option         | Default | Description                |
| -------------- | ------- | -------------------------- |
| `maxParallel`  | 4       | Concurrent branch searches |
| `pruneEnabled` | true    | Enable dedup and ranking   |
| `temperature`  | 0.3     | LLM sampling temperature   |
| `maxSkills`    | 10      | Maximum skills to return   |

## License

MIT
npm package: @skillbolt/tree
Description: LLM-powered capability tree builder for skill organization
Latest version: 1.0.0

# @skillbolt/tree

Capability tree builder for Skillbolt. Organizes skills into a hierarchical tree structure using LLM-powered classification.

## Features

- **LLM-powered categorization** — Automatically assigns skills to categories using LLM
- **Configurable branching factor** — Control tree width and depth
- **Parallel BFS building** — Queue-based breadth-first construction with `p-limit` concurrency
- **Multiple output formats** — YAML, JSON, ASCII, HTML serialization
- **Fixed root categories** — Predefined top-level categories for consistency

## Quick Start

```typescript
import { TreeBuilder, createTreeConfig, loadTree } from '@skillbolt/tree';
import { createLLMAdapter } from '@skillbolt/core';

const llm = createLLMAdapter({ model: 'gpt-4o-mini' });
const config = createTreeConfig({ branchingFactor: 8, maxDepth: 6 });
const builder = new TreeBuilder({ llm, config });

const result = await builder.build({
  skillDir: '.claude/skills',
  onProgress: (p) => console.log(p.message),
});

// Load a previously built tree
const tree = await loadTree('tree.yaml');
console.log(tree.countAllSkills());
```

## CLI

```bash
skill tree build --dir .claude/skills --verbose
skill tree show --format ascii
skill tree stats
```

## API

| Export             | Description                                        |
| ------------------ | -------------------------------------------------- |
| `TreeBuilder`      | Main builder class (queue-based BFS with LLM)      |
| `TreeNode`         | Tree node with children, skills, traversal methods |
| `createTreeConfig` | Create config with derived properties              |
| `loadTree`         | Load tree from YAML file                           |
| `renderTreeASCII`  | ASCII visualization                                |
| `saveTreeToJSON`   | JSON serialization                                 |
| `saveTreeToHTML`   | HTML visualization                                 |
| `getTreeStats`     | Node count, skill count, depth                     |

## Configuration

| Option            | Default  | Description              |
| ----------------- | -------- | ------------------------ |
| `branchingFactor` | 8        | Max children per node    |
| `maxDepth`        | 6        | Maximum tree depth       |
| `maxWorkers`      | 4        | Concurrent LLM calls     |
| `rootCategories`  | Built-in | Top-level category names |

## License

MIT
npm package: @skillbolt/web-ui
Description: Lightweight web UI server for Skill Kit
Latest version: 1.0.0

# @skillbolt/web-ui

Web GUI for Skillbolt. Visual interface for skill discovery, plan review, and execution monitoring.

## Features

- **Dark-themed UI** — Clean, modern design with CSS custom properties
- **WebSocket real-time updates** — Live state sync between server and client
- **DAG visualization** — SVG-based node graph with status colors and animations
- **Log viewer** — Auto-scrolling, level-colored log panel
- **State machine** — `idle → searching → reviewing → planning → executing → complete`
- **No framework** — Vanilla HTML/CSS/JS frontend, zero build step

## Quick Start

```bash
# Via CLI
skill gui

# With options
skill gui --port 8765 --task "fix the login bug" --skills debugger
```

```typescript
// Programmatic usage
import { startServer } from '@skillbolt/web-ui';

await startServer({
  port: 8765,
  openBrowser: true,
  task: 'fix the login bug',
  presetSkills: ['debugger', 'test-writer'],
});
```

## Architecture

- **Server**: Node.js `http` module + `ws` WebSocket
- **Frontend**: Vanilla HTML/CSS/JS served as static files
- **State**: Immutable state updates broadcast via WebSocket
- **Visualizer**: Bridges `SkillOrchestrator` events to WebSocket messages

## API

| Export               | Description                                     |
| -------------------- | ----------------------------------------------- |
| `startServer`        | Launch HTTP + WebSocket server                  |
| `UnifiedService`     | Coordinates state, search, and orchestration    |
| `WebVisualizer`      | Implements `VisualizerProtocol` for web display |
| `createInitialState` | Create default UI state                         |
| `updatePhase`        | State machine transition                        |
| `addLog`             | Append log entry to state                       |

## Components

| File                              | Description                         |
| --------------------------------- | ----------------------------------- |
| `public/index.html`               | Single-page app shell               |
| `public/style.css`                | Dark theme styles                   |
| `public/app.js`                   | WebSocket client + state management |
| `public/components/task-input.js` | Task input with textarea            |
| `public/components/dag-viewer.js` | SVG DAG visualization               |
| `public/components/log-viewer.js` | Auto-scrolling log panel            |

## License

MIT
npm package: @skillbrickai/mcp-server
Description: MCP server for discovering and installing skills from the SkillBrick AI platform
Author: SkillBrick AI
Latest version: 0.1.0

# @skillbrickai/mcp-server

MCP (Model Context Protocol) server for discovering and installing skills from the [SkillBrick AI](https://skillbrickai.com) platform. This lets AI agents like Claude search, browse, and install skills directly.

## Available Tools

| Tool | Description |
|------|-------------|
| `search_skills` | Search and browse skills by query, domain, tag, or sort order. Auto-infers domain and technology from natural language queries. |
| `get_skill` | Get full skill details including prompt content |
| `install_skill` | Install a skill (requires auth token) |
| `upload_skill` | Upload or update a skill (upsert, requires auth token) |
| `sync_skills` | Bulk-sync multiple skills in one call (requires auth token) |
| `my_skills` | List all skills owned by the authenticated user |
| `check_credits` | Check download credit balance |
| `list_collections` | Browse skill collections |
| `get_collection` | Get a collection with all its skills |
| `list_domains` | List available skill domains/categories |
| `recommend_skills` | Intelligent skill recommendations based on a task description |

## Setup

### Build

```bash
pnpm install
pnpm --filter @skillbrickai/mcp-server build
```

### Claude Desktop

Add to your Claude Desktop config file (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "skillbrickai": {
      "command": "node",
      "args": ["C:/Users/user/Documents/skillbrickai/packages/mcp-server/dist/index.js"],
      "env": {
        "SKILLBRICK_API_URL": "https://skillbrickai.com",
        "SKILLBRICK_API_TOKEN": "your-api-token-here"
      }
    }
  }
}
```

### Claude Code

```bash
claude mcp add skillbrick -- node C:/Users/user/Documents/skillbrickai/packages/mcp-server/dist/index.js
```

Or via npx (once published):

```bash
claude mcp add skillbrick -- npx @skillbrickai/mcp-server
```

### Environment Variables

| Variable | Description | Default |
|----------|-------------|---------|
| `SKILLBRICK_API_URL` | Base URL for the SkillBrick API | `https://skillbrickai.com` |
| `SKILLBRICK_API_TOKEN` | API auth token (required for `install_skill`, `upload_skill`, `sync_skills`, `my_skills`, `check_credits`) | _(none)_ |

## How the search works

1. **Intent parsing** -- extracts domain and technology tags from natural language
2. **Domain inference** -- maps casual terms ("backend", "k8s") to actual domain values
3. **Multi-pass search** -- queries by text, inferred domain, and inferred tags in parallel
4. **Relevance scoring** -- scores results by name/description/tag match + popularity signals
5. **Fallback broadening** -- if filtered search returns nothing, retries without filters