### Initialize Development Environment

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/README.md

Commands to navigate to the documentation directory, install dependencies, and start the development server. This is required to preview changes locally at http://localhost:3000.

```bash
cd docs/fumadocs
pnpm install
pnpm dev
```

--------------------------------

### SkillKit Installation in CI/CD (GitHub Actions)

Source: https://github.com/rohitg00/skillkit/blob/main/packages/cli/README.md

Example of how to install and sync skills within a GitHub Actions workflow using npx commands.

```yaml
# GitHub Actions example
- name: Setup skills
  run: |
    npx skillkit install owner/skills --skills=lint,test --yes
    npx skillkit sync --yes
```

--------------------------------

### Run Development Server

Source: https://github.com/rohitg00/skillkit/blob/main/docs/skillkit/README.md

Starts the local development server for the documentation site. Requires Node.js 20+ and installed dependencies.

```bash
npm run dev
```

--------------------------------

### SkillKit Workflow for Onboarding New Developers

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/teams.mdx

A step-by-step guide using SkillKit commands for onboarding new developers. It covers cloning the repository, installing team skills, generating project instructions with `skillkit primer`, and syncing skills to agents.

```bash
# 1. Clone repository
git clone https://github.com/company/project
cd project

# 2. Install team skills
skillkit team install

# 3. Generate project instructions
skillkit primer --all-agents

# 4. Sync to agents
skillkit sync

# ✅ Developer is ready!
```

--------------------------------

### Programmatic API - Starting the REST API Server

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Example of how to start the SkillKit REST API server programmatically.

```APIDOC
## Programmatic API - Starting the REST API Server

Start the SkillKit REST API server with custom configuration.

```typescript
import { startServer } from '@skillkit/api';

await startServer({ port: 3737, skills: [...] });
```
```

--------------------------------

### Install Skills via SkillKit CLI

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/commands.mdx

Commands to install skills from various sources like GitHub or local paths. Includes examples for interactive, CI/CD, and force-overwrite scenarios.

```bash
# Interactive installation
skillkit install anthropics/skills

# CI/CD installation (no prompts)
skillkit install anthropics/skills --skills=pdf,xlsx --agent claude --yes

# List available skills
skillkit install anthropics/skills --list

# Force overwrite
skillkit install anthropics/skills --skills=pdf --force

# Install for multiple agents
skillkit install anthropics/skills --agent claude --agent cursor
```

--------------------------------

### Discover and Install Skills

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/quickstart.mdx

Commands to get skill recommendations based on project context and install specific skills for target AI agents.

```bash
skillkit recommend
skillkit install anthropics/skills
skillkit install anthropics/skills --skills=pdf,xlsx --agent claude --yes
skillkit install vercel-labs/agent-skills --agent claude,cursor,windsurf
```

--------------------------------

### Mesh Network Setup with @skillkit/mesh

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/api-reference.mdx

Illustrates setting up a mesh network using `@skillkit/mesh`. It covers generating a `PeerIdentity`, creating a `MeshHost` with specified configuration, starting the host, sending messages to peers, and listening for incoming messages.

```typescript
import { MeshHost, PeerIdentity } from '@skillkit/mesh'

// Generate identity
const identity = await PeerIdentity.generate()

// Create mesh host
const host = new MeshHost({
  hostId: 'my-workstation',
  identity,
  security: { mode: 'secure' },
})

await host.start()

// Send message to peer
await host.send('peer-fingerprint', {
  type: 'skill-sync',
  payload: { skills: ['react-patterns'] },
})

// Listen for messages
host.on('message', (msg) => {
  console.log('Received:', msg.type, 'from', msg.from)
})
```

--------------------------------

### Setup and Use Private Skill Registries with SkillKit

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/teams.mdx

Instructions and configuration examples for setting up and using private skill registries. This includes adding a registry with authentication (e.g., GitHub token) and referencing private skills within the team manifest.

```bash
# Add private registry
skillkit registry add company-skills \
  --url https://github.com/mycompany/skills \
  --token $GITHUB_TOKEN

# Install from private registry
skillkit install company-skills/auth-patterns
```

```json
{
  "skills": [
    {
      "source": "company-skills/proprietary-skills",
      "registry": "company-skills",
      "skills": ["auth-patterns", "payment-processing"],
      "private": true
    }
  ],
  "registries": [
    {
      "name": "company-skills",
      "url": "https://github.com/mycompany/skills",
      "auth": "env:GITHUB_TOKEN"
    }
  ]
}
```

--------------------------------

### Programmatic SkillKit Installation and Management (TypeScript)

Source: https://github.com/rohitg00/skillkit/blob/main/packages/cli/README.md

Demonstrates how to use the SkillKit CLI functions programmatically in TypeScript for installing skills, listing installed skills, performing security scans, syncing skills to agents, translating skills, and getting recommendations.

```typescript
import {
  installCommand,
  listCommand,
  syncCommand,
  translateCommand,
  recommendCommand,
} from '@skillkit/cli';

// Install skills programmatically
await installCommand('anthropics/skills', {
  agent: ['claude-code', 'cursor'],
  yes: true,
});

// List installed skills
const skills = await listCommand({ json: true });

// Security scan
import { SkillScanner, formatResult } from '@skillkit/core';
const scanner = new SkillScanner({ failOnSeverity: 'high' });
const result = await scanner.scan('./my-skill');
console.log(formatResult(result, 'summary'));

// Sync to agent
await syncCommand({ all: true });

// Translate skill
await translateCommand('my-skill', {
  to: 'cursor',
  dryRun: false,
});

// Get recommendations
const recs = await recommendCommand({
  path: './my-project',
  minScore: 70,
});
```

--------------------------------

### SkillKit CLI: Generate and Install Skills

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/primer.mdx

This snippet shows the basic workflow for using SkillKit to generate base instructions with 'primer' and then install domain-specific skills. It concludes with syncing all configurations.

```bash
# 1. Generate base instructions
skillkit primer --all-agents

# 2. Install domain-specific skills
skillkit install anthropics/skills --skill pdf,xlsx

# 3. Sync everything
skillkit sync
```

--------------------------------

### SkillKit Primer Configuration File Example

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/primer.mdx

Example JSON configuration file for SkillKit Primer, allowing customization of included elements, excluded patterns, and agent-specific settings.

```json
{
  "include": {
    "techStack": true,
    "codeStyle": true,
    "testingPatterns": true,
    "customRules": [
      "Always use async/await over promises",
      "Prefer functional components in React",
      "Use Zod for runtime validation"
    ]
  },
  "exclude": {
    "directories": ["node_modules", "dist", ".next"],
    "patterns": ["*.test.ts", "*.spec.ts"]
  },
  "agents": {
    "priority": ["claude", "cursor", "windsurf"],
    "customize": {
      "claude": {
        "tone": "detailed",
        "examples": true
      },
      "cursor": {
        "tone": "concise",
        "shortcuts": true
      }
    }
  }
}
```

--------------------------------

### Installation

Source: https://github.com/rohitg00/skillkit/blob/main/packages/agents/README.md

Instructions on how to install the @skillkit/agents package using npm.

```APIDOC
## Installation

```bash
npm install @skillkit/agents
```
```

--------------------------------

### Programmatic API for Starting SkillKit Server - TypeScript

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

TypeScript example for starting the SkillKit REST API server programmatically, specifying the port and the skills to be served.

```typescript
import { startServer } from '@skillkit/api';
await startServer({ port: 3737, skills: [...] });
```

--------------------------------

### Install SkillKit CLI

Source: https://github.com/rohitg00/skillkit/blob/main/packages/cli/README.md

Instructions for installing the SkillKit CLI globally using npm.

```bash
npm install -g @skillkit/cli
npm install -g skillkit
```

--------------------------------

### Start SkillKit Server

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/rest-api.mdx

Commands to initialize and configure the SkillKit server instance.

```bash
skillkit serve
```

```bash
skillkit serve --port 8080 --host localhost --cors "http://localhost:3000"
```

--------------------------------

### Install AI Skills with SkillKit

Source: https://context7.com/rohitg00/skillkit/llms.txt

Demonstrates various ways to install AI skills using the SkillKit CLI, including from GitHub, marketplace, local paths, and specifying individual skills or multiple skills. It also covers options for global installation, listing available skills, skipping security scans, and forcing overwrites.

```bash
# Install from GitHub
skillkit install anthropics/skills

# Install from skills.sh marketplace
skillkit install skills.sh/owner/repo/skill-name

# Install from GitLab
skillkit install gitlab:owner/repo

# Install from Bitbucket
skillkit install bitbucket:owner/repo

# Install from local path
skillkit install ./my-local-skills

# Install specific skill from a repository
skillkit install owner/repo --skill=pdf

# Install multiple skills non-interactively (CI/CD)
skillkit install owner/repo --skills=pdf,xlsx,review

# Install all skills without prompts
skillkit install owner/repo --all --yes

# Install to specific agents only
skillkit install owner/repo --agent claude-code --agent cursor

# Install globally (available to all projects)
skillkit install owner/repo --global

# List available skills without installing
skillkit install owner/repo --list

# Skip security scan (not recommended)
skillkit install owner/repo --no-scan

# Force overwrite existing skills
skillkit install owner/repo --force
```

--------------------------------

### Install Options

Source: https://github.com/rohitg00/skillkit/blob/main/packages/cli/README.md

Commands and options for installing skills from various sources.

```APIDOC
## Install Options

### Description
Installs skills from GitHub repositories, GitLab repositories, or local directories, with various customization options.

### Method
CLI Command

### Endpoint
N/A

### Parameters
#### Path Parameters
- **owner/repo** (string) - Required - GitHub repository path.
- **gitlab:owner/repo** (string) - Required - GitLab repository path.
- **./local/path** (string) - Required - Local directory path.

#### Query Parameters
- **--list** - List available skills without installing.
- **--skills** (string) - Comma-separated list of specific skills to install (e.g., 'pdf,xlsx').
- **--all** - Install all discovered skills.
- **--yes** - Skip confirmation prompts.
- **--global** - Install globally.
- **--force** - Overwrite existing installations.
- **--no-scan** - Skip security scan during installation.
- **--agent** (string) - Comma-separated list of agents to install to (e.g., 'cursor,windsurf').

### Request Example
```bash
skillkit install owner/repo
skillkit install gitlab:owner/repo
skillkit install ./local/path
skillkit install owner/repo --skills=pdf,xlsx
skillkit install owner/repo --agent=cursor,windsurf
```

### Response
#### Success Response (200)
- Installation progress and confirmation.

#### Response Example
None
```

--------------------------------

### SkillKit Installation Options

Source: https://github.com/rohitg00/skillkit/blob/main/packages/cli/README.md

Install skills from various sources including GitHub repositories, GitLab, and local directories. Provides options to list, install specific or all skills, skip scans, and target specific agents.

```bash
skillkit install owner/repo              # GitHub repository
skillkit install gitlab:owner/repo       # GitLab repository
skillkit install ./local/path            # Local directory

# Options
--list                    # List available skills without installing
--skills=pdf,xlsx         # Install specific skills
--all                     # Install all discovered skills
--yes                     # Skip confirmation prompts
--global                  # Install globally
--force                   # Overwrite existing
--no-scan                 # Skip security scan
--agent=cursor,windsurf   # Install to specific agents
```

--------------------------------

### Serve Skills via API

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/index.mdx

Starts a local API server to allow AI agents to discover skills on demand. Includes an example of how to query the API using curl to find skills related to a specific topic.

```bash
skillkit serve
# Server running at http://localhost:3737
```

```bash
curl "http://localhost:3737/search?q=react+performance"
```

--------------------------------

### Launch SkillKit TUI

Source: https://github.com/rohitg00/skillkit/blob/main/packages/tui/README.md

Launches the SkillKit TUI. The first command uses Bun to start the UI, while the second shows how to launch it via pnpm in a monorepo setup.

```bash
# Launch TUI with Bun
bun skillkit ui
```

```bash
# Or via pnpm in monorepo
pnpm ui
```

--------------------------------

### Full Example: Custom Build Pipeline

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/api-reference.mdx

Provides a comprehensive example of setting up a custom build pipeline using various functions from the @skillkit/core package, including project analysis, instruction generation, skill recommendation, and translation.

```APIDOC
## Full Example: Custom Build Pipeline

This example demonstrates a complete custom build pipeline, integrating multiple SkillKit functionalities to analyze a project, generate instructions, recommend skills, and translate them for different agents.

### Setup Project Function
An asynchronous function that orchestrates the build pipeline steps.

```typescript
import { promises as fs } from 'node:fs'
import {
  analyzeProject,
  generateInstructions,
  RecommendationEngine,
  translateSkill,
} from '@skillkit/core'

async function setupProject() {
  // 1. Analyze project
  const analysis = await analyzeProject('./my-project')

  // 2. Generate base instructions
  const instructions = await generateInstructions(analysis, {
    agents: ['claude', 'cursor', 'windsurf'],
  })

  // 3. Get recommendations
  const engine = new RecommendationEngine()
  const recommendations = engine.recommend(analysis)

  // 4. Install top recommendations
  const topSkills = recommendations.slice(0, 5)
  for (const rec of topSkills) {
    console.log(`Installing ${rec.skill.name} (${rec.score}% match)`)
  }

  // 5. Translate skills to all agents
  for (const agent of ['claude', 'cursor', 'windsurf']) {
    const translated = await translateSkill(
      topSkills[0].skill.content,
      agent
    )
    await fs.writeFile(`.${agent}/skills/${translated.filename}`, translated.content)
  }

  console.log('✅ Project setup complete!')
}

setupProject()
```

### Pipeline Steps
1. **Analyze Project**: Uses `analyzeProject` to understand the project's structure, tech stack, and patterns.
2. **Generate Instructions**: Creates base instructions tailored to specified agents using `generateInstructions`.
3. **Get Recommendations**: Employs `RecommendationEngine` to suggest relevant skills based on the project analysis.
4. **Install Top Recommendations**: Selects and logs the top recommended skills.
5. **Translate Skills**: Translates the content of recommended skills for different agents and saves them to the appropriate directories.
```

--------------------------------

### Install Skills from Various Sources

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/index.mdx

Demonstrates how to install skills for AI agents from different sources, including GitHub repositories, the skills.sh registry, GitLab, and local directories. This showcases SkillKit's flexibility in skill sourcing.

```bash
skillkit install anthropics/skills              # GitHub
```

```bash
skillkit install skills.sh/owner/repo/skill     # skills.sh registry
```

```bash
skillkit install gitlab:team/skills             # GitLab
```

```bash
skillkit install ./my-local-skills              # Local
```

--------------------------------

### Serve Command

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/commands.mdx

Starts the SkillKit REST API server for runtime skill discovery.

```APIDOC
## Serve Command

Start the SkillKit REST API server for runtime skill discovery.

### Usage
```bash
skillkit serve [options]
```

### Options
| Option        | Short | Default   | Description                  |
|---------------|-------|-----------|------------------------------|
| `--port`      | `-p`  | `3737`    | Port to listen on            |
| `--host`      | `-H`  | `0.0.0.0` | Host to bind to              |
| `--cors`      | —     | `*`       | CORS allowed origin          |
| `--cache-ttl` | —     | `86400000`| Cache TTL in milliseconds    |

### Examples
```bash
# Start with defaults
skillkit serve

# Custom port and host
skillkit serve --port 8080 --host localhost

# Restricted CORS
skillkit serve --cors "http://localhost:3000"

# Short cache TTL (1 hour)
skillkit serve --cache-ttl 3600000
```

### Endpoints
| Method | Path              | Description       |
|--------|-------------------|-------------------|
| GET    | `/search?q=...`   | Search skills     |
| POST   | `/search`         | Search with filters |
| GET    | `/skills/:owner/:repo/:id` | Get specific skill |
| GET    | `/trending?limit=20`| Trending skills   |
| GET    | `/categories`     | Skill categories  |
| GET    | `/health`         | Server health     |
| GET    | `/cache/stats`    | Cache statistics  |
```

--------------------------------

### Install SkillKit CLI

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/installation.mdx

Provides options to run SkillKit without installation using npx, or to install it globally using various package managers like npm, pnpm, yarn, and bun.

```bash
npx skillkit@latest
```

```bash
npm install -g skillkit
```

```bash
pnpm add -g skillkit
```

```bash
yarn global add skillkit
```

```bash
bun add -g skillkit
```

--------------------------------

### Install SkillKit Skill Locally (Bash)

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/chrome-extension.mdx

Commands to install a downloaded SkillKit skill to the local SkillKit directory, making it available to agents. It includes options for direct installation or copying and syncing.

```bash
skillkit install ~/Downloads/skillkit-skills/my-skill
```

```bash
cp -r ~/Downloads/skillkit-skills/my-skill ~/.skillkit/skills/
skillkit sync
```

--------------------------------

### Install @skillkit/mesh

Source: https://github.com/rohitg00/skillkit/blob/main/packages/mesh/README.md

Install the package using npm.

```bash
npm install @skillkit/mesh
```

--------------------------------

### Install and Initialize SkillKit CLI

Source: https://context7.com/rohitg00/skillkit/llms.txt

Commands to install the SkillKit CLI globally or use it directly with npx, and to initialize SkillKit within a project to detect and set up skill directories for supported AI coding agents.

```bash
npm install -g skillkit

npx skillkit@latest

skillkit init
```

--------------------------------

### Install SkillKit Client

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/python-client.mdx

Installation command for the skillkit-client package using pip. Requires Python 3.10 or higher.

```bash
pip install skillkit-client
```

--------------------------------

### Full Example: Custom Build Pipeline with TypeScript

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/api-reference.mdx

This comprehensive example demonstrates a custom build pipeline using various functions from '@skillkit/core'. It covers project analysis, instruction generation, skill recommendations, and skill translation for different agents.

```typescript
import { promises as fs } from 'node:fs'
import {
  analyzeProject,
  generateInstructions,
  RecommendationEngine,
  translateSkill,
} from '@skillkit/core'

async function setupProject() {
  // 1. Analyze project
  const analysis = await analyzeProject('./my-project')

  // 2. Generate base instructions
  const instructions = await generateInstructions(analysis, {
    agents: ['claude', 'cursor', 'windsurf'],
  })

  // 3. Get recommendations
  const engine = new RecommendationEngine()
  const recommendations = engine.recommend(analysis)

  // 4. Install top recommendations
  const topSkills = recommendations.slice(0, 5)
  for (const rec of topSkills) {
    console.log(`Installing ${rec.skill.name} (${rec.score}% match)`)
  }

  // 5. Translate skills to all agents
  for (const agent of ['claude', 'cursor', 'windsurf']) {
    const translated = await translateSkill(
      topSkills[0].skill.content,
      agent
    )
    await fs.writeFile(`.${agent}/skills/${translated.filename}`, translated.content)
  }

  console.log('✅ Project setup complete!')
}

setupProject()
```

--------------------------------

### Install @skillkit/agents

Source: https://github.com/rohitg00/skillkit/blob/main/packages/agents/README.md

Install the package via npm to begin using agent adapters in your project.

```bash
npm install @skillkit/agents
```

--------------------------------

### Install Specific Skills

Source: https://github.com/rohitg00/skillkit/blob/main/skills/find-skills/SKILL.md

Advanced installation commands to target specific repositories or individual skills within a collection. Supports both interactive and non-interactive installation patterns.

```bash
npx skillkit@latest install <owner/repo>
npx skillkit@latest install owner/repo --skills skill-name
npx skillkit@latest install anthropics/skills --skills frontend-design
npx skillkit@latest install vercel-labs/agent-skills -s react-best-practices
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/rohitg00/skillkit/blob/main/docs/skillkit/README.md

Installs all required project dependencies using npm. This is a prerequisite for running the development server or building the project.

```bash
npm install
```

--------------------------------

### Install @skillkit/mcp-memory

Source: https://github.com/rohitg00/skillkit/blob/main/packages/mcp-memory/README.md

Installs the @skillkit/mcp-memory package using npm or pnpm. This is the first step to setting up the MCP memory server.

```bash
npm install @skillkit/mcp-memory
# or
pnpm add @skillkit/mcp-memory
```

--------------------------------

### Install and Translate Skills

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Commands to install skills from various sources and translate existing skills between different agent formats.

```bash
skillkit install anthropics/skills
skillkit install gitlab:team/skills
skillkit install ./my-local-skills
skillkit translate my-skill --to cursor
skillkit translate --all --to windsurf
```

--------------------------------

### Install @skillkit/memory Package

Source: https://github.com/rohitg00/skillkit/blob/main/packages/memory/README.md

Installs the @skillkit/memory package using npm. This is the first step to integrate semantic memory into your project.

```bash
npm install @skillkit/memory
```

--------------------------------

### Install SkillKit CLI

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/index.mdx

Installs the SkillKit command-line interface globally or via npx. This is the primary way to interact with SkillKit for managing AI agent skills.

```bash
npx skillkit@latest
```

```bash
npm install -g skillkit
skillkit init
skillkit install anthropics/skills
skillkit sync
```

--------------------------------

### Install @skillkit/core

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/api-reference.mdx

Installs the core @skillkit/core package using npm. This package provides the foundational business logic for skill management.

```bash
npm install @skillkit/core
```

--------------------------------

### SkillKit REST API Server

Source: https://context7.com/rohitg00/skillkit/llms.txt

Instructions on how to start the SkillKit REST API server with various configuration options.

```APIDOC
## Starting the REST API Server

Launch a local HTTP server that exposes the SkillKit skill catalog via a REST API for integration with other tools or custom UIs.

### Commands

```bash
# Start server on default port 3737
skillkit serve

# Start on custom port
skillkit serve --port 8080

# Start with specific host binding
skillkit serve --host 127.0.0.1 --port 3000

# Start with custom CORS origin
skillkit serve --cors "http://localhost:3000"
```

### Output Example

```
SkillKit API Server
Loading 342 skills from marketplace
Server running at http://0.0.0.0:3737

Endpoints:
  GET  /health          - Server health check
  GET  /search?q=...    - Search skills
  POST /search          - Search with filters
  GET  /skills/:o/:r/:id - Get specific skill
  GET  /trending        - Top skills
  GET  /categories      - Skill categories
  GET  /cache/stats     - Cache statistics
  GET  /docs            - Interactive API docs
  GET  /openapi.json    - OpenAPI specification
```
```

--------------------------------

### Start SkillKit REST API Server Programmatically

Source: https://context7.com/rohitg00/skillkit/llms.txt

Shows how to define custom skills and start the SkillKit REST API server with specific configuration options like port, CORS, and rate limiting.

```typescript
import { startServer, createApp } from '@skillkit/api';
const options = { port: 3737, host: '127.0.0.1', corsOrigin: 'http://localhost:3000', cacheTtlMs: 86400000, skills: [], rateLimitMax: 60 };
const { server, app, cache } = await startServer(options);
```

--------------------------------

### Use SkillKit Python Client

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Example of using the Python client library to search for skills programmatically.

```python
from skillkit import SkillKitClient

async with SkillKitClient() as client:
    results = await client.search("react performance", limit=5)
```

--------------------------------

### Manifest Management Commands

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/configuration.mdx

CLI commands to initialize, add, and install skills defined in the manifest file.

```bash
skillkit manifest init
skillkit manifest add <skill>
skillkit manifest install
```

--------------------------------

### Detect Installed Agents

Source: https://github.com/rohitg00/skillkit/blob/main/packages/agents/README.md

Examples for detecting installed agents, either the primary one or all available agents.

```APIDOC
## Detect Installed Agents

### Description
Detect installed agents in the current directory or a specified path.

### Methods
- `detectAgent()`: Detects the primary agent in the current directory.
- `detectAllAgents(directory?: string)`: Detects all installed agents in the specified directory or the current directory if not provided.

### Request Example
```typescript
import { detectAgent, detectAllAgents } from '@skillkit/agents';

// Detect primary agent
const primary = await detectAgent();
console.log(primary);

// Detect all installed agents
const all = await detectAllAgents();
console.log(all);

// Detect in a specific directory
const agents = await detectAllAgents('./my-project');
console.log(agents);
```

### Response
#### Success Response (200)
- **agent** (string | null) - The name of the primary detected agent, or null if none is found.
- **agents** (string[]) - An array of names of all detected agents.
```

--------------------------------

### Initialize and Search Skills

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/python-client.mdx

Demonstrates how to initialize the SkillKitClient using an async context manager and perform a basic search query.

```python
from skillkit import SkillKitClient

async with SkillKitClient() as client:
    results = await client.search("react performance", limit=5)
    for skill in results.skills:
        print(f"{skill.name}: {skill.description}")
```

--------------------------------

### Provide Code Examples

Source: https://github.com/rohitg00/skillkit/blob/main/packages/core/src/methodology/packs/meta/skill-authoring/SKILL.md

Demonstrates the preferred format for contrasting bad versus good code practices in documentation.

```typescript
// BAD
const result = doTheThing(badInput);

// GOOD
const validated = validate(input);
const result = doTheThing(validated);
```

--------------------------------

### Get Agent Adapter

Source: https://github.com/rohitg00/skillkit/blob/main/packages/agents/README.md

Example of how to retrieve an agent adapter configuration using its name.

```APIDOC
## Get Agent Adapter

### Description
Get adapter for specific agent

### Method
```typescript
getAdapter(agentName: AgentType)
```

### Parameters
#### Path Parameters
- **agentName** (AgentType) - Required - The name of the agent to retrieve the adapter for.

### Request Example
```typescript
import { getAdapter, AgentType } from '@skillkit/agents';

const adapter = getAdapter('claude-code');

console.log(adapter.name);
console.log(adapter.skillsDir);
console.log(adapter.globalSkillsDir);
console.log(adapter.configFile);
console.log(adapter.format);
```

### Response
#### Success Response (200)
- **adapter** (AgentAdapter) - An object containing the configuration details for the specified agent.

#### Response Example
```json
{
  "name": "claude-code",
  "displayName": "Claude Code",
  "format": "skill-md",
  "skillsDir": ".claude/skills/",
  "globalSkillsDir": "~/.claude/skills/",
  "configFile": "AGENTS.md"
}
```
```

--------------------------------

### Initialize SkillKit Project

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/installation.mdx

Sets up the local directory for AI agent skills. It detects existing agent configurations and creates the necessary folder structures.

```bash
cd my-project
skillkit init
```

--------------------------------

### Chrome Extension Integration

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Guide on building, installing, and using the SkillKit Chrome Extension to save webpages as skills.

```APIDOC
## Chrome Extension

Save any webpage as a skill directly from your browser.

### Installation & Usage

1. **Build**: `pnpm --filter @skillkit/extension build`
2. **Load Extension**: Go to `chrome://extensions`, click "Load unpacked", and select the `packages/extension/dist/` directory.
3. **Save Page**: Click the extension icon or right-click on a webpage and select "Save page as Skill".

The extension sends the page URL to the SkillKit API for server-side extraction. The resulting SKILL.md file downloads automatically. Install the skill using `skillkit install ~/Downloads/skillkit-skills/my-skill`.
```

--------------------------------

### Skill Tree CLI Commands

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/tree.mdx

Provides examples of using the skillkit CLI to display, generate, and export the skill tree.

```APIDOC
## Skill Tree CLI Commands

### Display Full Skill Tree

```bash
skillkit tree
```

### Navigate to a Specific Category

```bash
skillkit tree Frontend
```

### Limit Display Depth

```bash
skillkit tree --depth 2
```

### Generate Tree from Skill Index

```bash
skillkit tree --generate
```

### Export Tree to JSON

```bash
skillkit tree --json
```

### Export Tree to Markdown

```bash
skillkit tree --markdown
```

### Display Tree Statistics

```bash
skillkit tree --stats
```
```

--------------------------------

### Common SkillKit Commands

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/installation.mdx

Essential commands for project maintenance including getting recommendations, installing skills from GitHub, syncing with agents, and launching the terminal UI.

```bash
skillkit recommend
skillkit install anthropics/skills
skillkit sync
skillkit ui
```

--------------------------------

### GitLab CI Pipeline for SkillKit

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/cicd.mdx

A GitLab CI pipeline configuration to validate and test skills using SkillKit. This setup uses a Node.js Docker image to install and run SkillKit commands within the CI environment.

```yaml
validate-skills:
  image: node:20
  script:
    - npm install -g skillkit
    - skillkit validate
    - skillkit test
```

--------------------------------

### Making Hidden Test Logic Explicit

Source: https://github.com/rohitg00/skillkit/blob/main/packages/core/src/methodology/packs/testing/anti-patterns/SKILL.md

Addresses the anti-pattern of hiding assertions or complex setup logic within helper functions. The 'GOOD' example demonstrates making all assertions explicit within the test itself, improving readability and maintainability.

```typescript
// BAD - Assertions hidden in helper
function assertValidUser(user) {
  expect(user.id).toBeDefined();
  expect(user.email).toMatch(/@/);
  expect(user.createdAt).toBeInstanceOf(Date);
  // Many more hidden assertions
}

it('should create valid user', () => {
  const user = createUser(data);
  assertValidUser(user); // What is actually being tested?
});

// GOOD - Explicit assertions
it('should create user with email', () => {
  const user = createUser(data);
  expect(user.email).toBe(data.email);
});
```

--------------------------------

### Initialize and Sync SkillKit

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Commands to initialize the SkillKit environment, recommend skills based on project context, install skills from registries, and sync them to configured agents.

```bash
npx skillkit@latest init
skillkit recommend
skillkit install anthropics/skills
skillkit sync
```

--------------------------------

### Install Dependencies with pnpm

Source: https://github.com/rohitg00/skillkit/blob/main/CONTRIBUTING.md

Installs all project dependencies using the pnpm package manager. Ensure you have pnpm 8+ installed.

```bash
pnpm install
```

--------------------------------

### Example SKILL.md Format (YAML)

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/chrome-extension.mdx

Demonstrates the standard YAML frontmatter format for a SKILL.md file, including name, description, tags, and metadata like source URL and save timestamp.

```yaml
---
name: react-performance-tips
description: Optimizing React rendering with memo and useMemo
tags:
  - react
  - javascript
  - testing
metadata:
  source: https://example.com/react-performance
  savedAt: 2026-02-14T09:00:00.000Z
---

# React Performance Tips

The extracted markdown content of the page...
```

--------------------------------

### Install and Remove Skills - Bash

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Core SkillKit commands for installing skills from a source, removing installed skills, and synchronizing the agent configuration.

```bash
skillkit install <source>
skillkit remove <skills>
```

--------------------------------

### Install SkillKit CLI

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Commands to install the SkillKit package globally using different Node.js package managers or execute it directly without installation.

```bash
npm install -g skillkit
pnpm add -g skillkit
yarn global add skillkit
bun add -g skillkit
npx skillkit <command>
```

--------------------------------

### Analyze Projects and Generate Recommendations with TypeScript

Source: https://context7.com/rohitg00/skillkit/llms.txt

Demonstrates how to initialize a project context, build a skill index, and use the RecommendationEngine to fetch relevant skills based on project stack and patterns.

```typescript
import { RecommendationEngine, ContextManager, buildSkillIndex, saveIndex, loadIndex, KNOWN_SKILL_REPOS } from '@skillkit/core';
const manager = new ContextManager('./my-project');
const context = manager.init();
const profile = { name: context.project.name, type: context.project.type, stack: context.stack, patterns: context.patterns, installedSkills: context.skills?.installed || [], excludedSkills: context.skills?.excluded || [] };
const { index, errors } = await buildSkillIndex(KNOWN_SKILL_REPOS, (message) => { console.log('Progress:', message); });
saveIndex(index);
const cachedIndex = loadIndex();
const engine = new RecommendationEngine();
engine.loadIndex(cachedIndex);
const result = engine.recommend(profile, { limit: 10, minScore: 30, categories: ['security', 'testing'], excludeInstalled: true, includeReasons: true });
```

--------------------------------

### Primer Generation with @skillkit/core

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/api-reference.mdx

Demonstrates the automatic generation of instructions for different agents using `@skillkit/core`. It involves analyzing a project, generating instructions with options for agents, examples, and tone, and then writing these instructions to files.

```typescript
import { promises as fs } from 'node:fs'
import { analyzeProject, generateInstructions } from '@skillkit/core'

// Analyze project
const analysis = await analyzeProject('./my-project')
console.log(analysis.techStack)
// { framework: 'Next.js', language: 'TypeScript', styling: 'Tailwind' }

// Generate instructions for specific agents
const instructions = await generateInstructions(analysis, {
  agents: ['claude', 'cursor', 'windsurf'],
  includeExamples: true,
  tone: 'detailed',
})

// Write to files
for (const [agent, content] of Object.entries(instructions)) {
  await fs.writeFile(`.${agent}/instructions.md`, content)
}
```

--------------------------------

### Create SKILL.md File Structure - Markdown

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Example structure of a SKILL.md file, including frontmatter for metadata like name, description, and license, followed by instructions for the AI agent.

```markdown
---
name: my-skill
description: What this skill does
license: MIT
---

# My Skill

Instructions for the AI agent.

## When to Use
- Scenario 1
- Scenario 2

## Steps
1. First step
2. Second step
```

--------------------------------

### Build Documentation Project

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/README.md

Command to compile the documentation project for production deployment.

```bash
pnpm build
```

--------------------------------

### Get Smart Skill Recommendations

Source: https://context7.com/rohitg00/skillkit/llms.txt

Utilizes the SkillKit CLI to analyze a project and provide intelligent skill recommendations based on detected technologies, frameworks, and libraries. Options include limiting results, verbose output, filtering by category, searching by task description, using hybrid search, enabling LLM-based reasoning, and updating the skill index.

```bash
# Get recommendations for current project
skillkit recommend

# Show top 5 recommendations with detailed reasons
skillkit recommend --limit 5 --verbose

# Filter by category
skillkit recommend --category security

# Search for skills by task description
skillkit recommend --search "authentication"
skillkit recommend --task "form validation"

# Use hybrid search (vector + keyword)
skillkit recommend --search "react hooks" --hybrid

# Use LLM-based reasoning for recommendations
skillkit recommend --reasoning --explain

# Update skill index from known sources
skillkit recommend --update

# Build hybrid search embedding index
skillkit recommend --build-index
```

--------------------------------

### Verify SkillKit Installation

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/installation.mdx

Checks the currently installed version of the SkillKit CLI to ensure it is correctly configured.

```bash
skillkit --version
```

--------------------------------

### Install @skillkit/messaging

Source: https://github.com/rohitg00/skillkit/blob/main/packages/messaging/README.md

Installs the @skillkit/messaging package using npm. This is the first step to integrate messaging capabilities into your project.

```bash
npm install @skillkit/messaging
```

--------------------------------

### Discover Skills via API

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Start a local SkillKit server to allow agents to discover skills on demand via HTTP or MCP.

```bash
skillkit serve
curl "http://localhost:3737/search?q=react+performance"
```

--------------------------------

### GitHub Actions Workflow for Team Skill Validation and Installation

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/teams.mdx

A GitHub Actions workflow (`.github/workflows/skills.yml`) that runs on pull requests targeting changes in `.skills`. It sets up Node, installs SkillKit, validates the manifest, installs skills, and runs skill tests.

```yaml
name: Team Skills

on:
  pull_request:
    paths:
      - '.skills'

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - name: Install SkillKit
        run: npm install -g skillkit
      
      - name: Validate Team Manifest
        run: skillkit team validate
      
      - name: Install Skills
        run: skillkit team install --yes
      
      - name: Run Skill Tests
        run: skillkit test
```

--------------------------------

### Git Post-Merge Hook for Automatic Skill Installation

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/teams.mdx

A bash script to be placed in `.git/hooks/post-merge` that automatically installs team skills using `skillkit team install --yes` after a Git pull or merge, ensuring the local environment stays synchronized.

```bash
#!/bin/sh
if [ -f .skills ]; then
  echo "📦 Installing team skills..."
  skillkit team install --yes
fi
```

--------------------------------

### Initialize SkillKit Project

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/quickstart.mdx

Initializes a new SkillKit project by detecting the AI agent, creating the necessary skills directory, and saving user preferences.

```bash
npx skillkit@latest init
```

--------------------------------

### Project Context Detection and Recommendations with @skillkit/core

Source: https://github.com/rohitg00/skillkit/blob/main/packages/core/README.md

Illustrates how to detect a project's context, analyze its stack, and receive AI-powered skill recommendations using @skillkit/core. It also covers initializing and retrieving project context.

```typescript
import { ProjectDetector, RecommendationEngine, ContextManager } from '@skillkit/core';

// Detect project context
const detector = new ProjectDetector();
const profile = await detector.analyze('./my-project');
// profile.stack includes: languages, frameworks, libraries, testing tools, etc.

// Get skill recommendations
const engine = new RecommendationEngine();
const recommendations = engine.recommend(profile, availableSkills);
// Returns skills sorted by match score

// Manage project context
const ctx = new ContextManager('./my-project');
await ctx.init();
const context = ctx.getContext();
```

--------------------------------

### SkillKit CLI: Customizing Primer Configuration

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/primer.mdx

Demonstrates how to customize the output of Primer by using a 'primer-config.json' file. This allows for detailed control over tone, inclusion of examples, and custom coding rules.

```json
{
  "tone": "detailed",
  "includeExamples": true,
  "customRules": [
    "Your specific coding guidelines..."
  ]
}
```

--------------------------------

### Build SkillKit Extension from Source (Bash)

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/chrome-extension.mdx

Instructions to clone the SkillKit repository, install dependencies, and build the Chrome extension using pnpm. The output is placed in the packages/extension/dist/ directory.

```bash
git clone https://github.com/rohitg00/skillkit.git
cd skillkit
pnpm install && pnpm --filter @skillkit/extension build
```

--------------------------------

### Install SkillKit TUI

Source: https://github.com/rohitg00/skillkit/blob/main/packages/tui/README.md

Installs the SkillKit CLI globally using npm. This command is used to set up the terminal interface for managing skills.

```bash
npm install -g skillkit
```

--------------------------------

### Run MCP Server from Command Line

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/mcp-server.mdx

This command initiates the MCP server using npx, making it available to any MCP-compatible client. This is a universal method for running the server.

```bash
npx @skillkit/mcp
```

--------------------------------

### SkillKit Project Initialization and Validation

Source: https://github.com/rohitg00/skillkit/blob/main/packages/cli/README.md

Initialize a new SkillKit project, validate existing skill formats, and create new skills using the CLI. Also includes viewing and updating settings.

```bash
skillkit init                  # Initialize in project
skillkit init --agent cursor   # Initialize for specific agent
skillkit validate ./skill      # Validate skill format
skillkit create my-skill       # Create new skill
skillkit settings              # View all settings
skillkit settings --set key=value  # Update setting
```

--------------------------------

### Start SkillKit REST API Server

Source: https://context7.com/rohitg00/skillkit/llms.txt

Launches a local HTTP server to expose the SkillKit skill catalog. Supports custom ports, host binding, and CORS configuration. Provides endpoints for health checks, searching skills, retrieving specific skills, trending skills, categories, cache statistics, API documentation, and OpenAPI specifications.

```bash
# Start server on default port 3737
skillkit serve

# Start on custom port
skillkit serve --port 8080

# Start with specific host binding
skillkit serve --host 127.0.0.1 --port 3000

# Start with custom CORS origin
skillkit serve --cors "http://localhost:3000"

# Output:
# SkillKit API Server
# Loading 342 skills from marketplace
# Server running at http://0.0.0.0:3737
#
# Endpoints:
#   GET  /health          - Server health check
#   GET  /search?q=...    - Search skills
#   POST /search          - Search with filters
#   GET  /skills/:o/:r/:id - Get specific skill
#   GET  /trending        - Top skills
#   GET  /categories      - Skill categories
#   GET  /cache/stats     - Cache statistics
#   GET  /docs            - Interactive API docs
#   GET  /openapi.json    - OpenAPI specification
```

--------------------------------

### Initialize and Discover Mesh Network

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/index.mdx

Commands for setting up and discovering nodes in a SkillKit mesh network, enabling distributed agent deployment across multiple machines with encrypted P2P communication.

```bash
skillkit mesh init
```

```bash
skillkit mesh discover
```

--------------------------------

### Install and Sync Team Skills with SkillKit CLI

Source: https://github.com/rohitg00/skillkit/blob/main/docs/fumadocs/content/docs/teams.mdx

Commands for installing all team-defined skills, syncing them with the manifest, and performing a force reinstall. These are crucial for ensuring all team members have the latest skill set.

```bash
skillkit team install
skillkit team install --sync
skillkit team install --force
```

--------------------------------

### Generate and Serve Skills - Bash

Source: https://github.com/rohitg00/skillkit/blob/main/README.md

Commands for initiating an AI-powered skill generation wizard and starting a SkillKit REST API server.

```bash
skillkit generate
skillkit serve
```