Compare commits

..
Author SHA1 Message Date
Rohit Ghumare 79656339c9 docs: add comprehensive documentation section to website
- Create Documentation.tsx component with DeepWiki-sourced content
- Add sections: Overview, Installation, Architecture, Agents, Commands
- Add sections: Configuration, API Reference, Skill Format, Tech Stack
- Include interactive sidebar navigation
- Add Docs link to navbar
- Reference DeepWiki as documentation source

Source: https://deepwiki.com/rohitg00/skillkit
2026-01-28 15:37:08 +00:00
Rohit Ghumare 03d6610e7c fix: address additional review feedback
- validate.ts: Add error when --fix is passed without targets
- index.ts: Skip headers inside fenced code blocks during completeness check
- compute-quality.ts: Use nullish coalescing (??) to preserve zero quality scores
2026-01-28 14:18:27 +00:00
Rohit Ghumare c22e1b3caf Merge main into feat/quality-evaluation 2026-01-28 13:50:18 +00:00
Rohit Ghumare dd3bd07296 fix: address remaining CodeRabbit review suggestions
- Escape regex metacharacters in vague term patterns (fix.ts)
- Improve diff algorithm using set-based comparison (fix.ts)
- Fix validateSkill receiving file path instead of directory (validate.ts)
- Check final section in completeness assessment (index.ts)
- Add error handling and empty skills guard (compute-quality.ts)
2026-01-28 13:47:56 +00:00
Rohit Ghumare d6b76f3abd fix: address CodeRabbit and Devin review suggestions
- Fix .mdc file name extraction in fix.ts (handles both .md and .mdc)
- Add missing advanced field to test fixtures in quality.test.ts
- Fix duplicate header detection in assessCompleteness using regex.exec
- Fix ESM compatibility in compute-quality.ts using import.meta.url
- Add trailing newline to skills.json output
2026-01-28 13:28:29 +00:00
Rohit Ghumare 28c2c0a936 feat(quality): extend quality evaluation system with badges, deeper analysis, and fix command
- Phase 2: Add quality badges to CLI commands (list, recommend, install)
  - formatQualityBadge() helper for color-coded grade badges
  - --quality flag for list command
  - Low-quality skill warnings during install

- Phase 3: Add TUI quality badges
  - Extended SkillItem with quality, grade, warnings fields
  - Quality evaluation in loadSkills()
  - Grade badges in Installed and Recommend screens

- Phase 4: Deeper quality analysis
  - Deprecated pattern detection (CommonJS, class components, var)
  - Security pattern detection (hardcoded credentials, eval, innerHTML)
  - Conflicting instruction detection
  - Completeness assessment (TODOs, empty sections, example coverage)
  - New weight distribution: Structure 35%, Clarity 25%, Specificity 25%, Advanced 15%

- Phase 1: Pre-compute marketplace quality scores
  - Updated schema.json with quality field (0-100)
  - Created scripts/compute-quality.ts for batch computation

- Phase 5: Benchmark against category leaders
  - New benchmark.ts module with category detection
  - Percentile calculation and comparison notes
  - --benchmark flag for validate command

- Phase 6: Fix command for automated quality fixes
  - skillkit fix command with --dry-run and --interactive modes
  - Auto-generates frontmatter, "When to Use", "Boundaries" sections
  - --fix flag alias on validate command
2026-01-28 13:02:51 +00:00
Rohit Ghumare 3f03d0690d fix: address CodeRabbit and Devin review suggestions
- Fix JSON output to return exit code 1 on validation failures
- Add --min-score NaN validation with warning message
- Add directory guard for --all flag with .mdc file support
- Fix CRLF handling in frontmatter extraction
- Fix code blocks double-counting in specificity evaluation
- Fix warning message inconsistency for code examples
- Add try/catch error handling in evaluateSkillFile
- Fix isHighQuality threshold to match UI display (80)
2026-01-28 11:56:52 +00:00
Rohit Ghumare 96f83fdc2e feat(quality): add skill quality evaluation system
- Add quality scoring module with structure, clarity, and specificity metrics
- Evaluate skills for metadata, triggers, boundaries, code examples
- Detect vague terms and penalize overly long skills
- Update validate command to include quality reports
- Add --verbose, --quality, --issues, --json flags
- Quality scores: A (90+), B (80+), C (70+), D (60+), F (<60)
2026-01-28 11:32:15 +00:00
726 changed files with 6985 additions and 96028 deletions
-42
View File
@@ -1,42 +0,0 @@
---
name: Add Skill Source
about: Submit your skill repository to be included in SkillKit
title: "[Source] Add <repository-name>"
labels: skill-source, enhancement
assignees: rohitg00
---
## Repository Information
**Repository URL:** `https://github.com/<owner>/<repo>`
**Repository Name:**
<!-- Short name for display (e.g., "Anthropic Official", "React Patterns") -->
**Description:**
<!-- Brief description of the skills in your repository -->
**License:**
<!-- MIT, Apache 2.0, etc. -->
## Skill Details
**Approximate skill count:**
<!-- How many skills does your repository contain? -->
**Categories/Tags:**
<!-- What categories do your skills cover? e.g., react, typescript, security, testing -->
**Target AI Agents:**
<!-- Which agents are your skills designed for? e.g., Claude Code, Cursor, all -->
## Checklist
- [ ] Repository is public
- [ ] Repository contains valid SKILL.md files
- [ ] Repository has a clear license
- [ ] Skills follow the [Agent Skills specification](https://skillkit.sh)
## Additional Context
<!-- Any other information about your repository -->
+1 -1
View File
@@ -83,7 +83,7 @@ body:
options:
- label: Repository is public
required: true
- label: SKILL.md follows the skillkit.sh standard format
- label: SKILL.md follows the agentskills.io standard format
required: true
- label: Skill has been tested with at least one AI agent
required: false
-87
View File
@@ -1,87 +0,0 @@
# SkillKit GitHub Action
A reusable composite action to install, scan, and manage AI agent skills in CI/CD pipelines.
## Usage
```yaml
# Install skills
- uses: rohitg00/skillkit/.github/actions/skillkit@main
with:
command: install
source: anthropics/skills
# Security scan
- uses: rohitg00/skillkit/.github/actions/skillkit@main
with:
command: scan
source: ./skills
# Check for updates
- uses: rohitg00/skillkit/.github/actions/skillkit@main
with:
command: check
```
## Inputs
| Input | Description | Required | Default |
|-------|-------------|----------|---------|
| `command` | SkillKit command to run (`install`, `scan`, `check`, `sync`) | Yes | |
| `source` | Skill source for install (e.g. `owner/repo`) | No | |
| `args` | Additional arguments | No | `''` |
| `node-version` | Node.js version | No | `20` |
| `agent` | Target agent (e.g. `claude-code`, `cursor`) | No | `claude-code` |
## Examples
### Install and sync skills
```yaml
jobs:
setup-skills:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: rohitg00/skillkit/.github/actions/skillkit@main
with:
command: install
source: anthropics/skills
agent: cursor
- uses: rohitg00/skillkit/.github/actions/skillkit@main
with:
command: sync
```
### Security scan on PR
```yaml
jobs:
scan-skills:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: rohitg00/skillkit/.github/actions/skillkit@main
with:
command: scan
source: ./skills
args: '--fail-on high'
```
### Check for updates
```yaml
jobs:
check-updates:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: rohitg00/skillkit/.github/actions/skillkit@main
with:
command: check
args: '--json'
```
-65
View File
@@ -1,65 +0,0 @@
name: 'SkillKit'
description: 'Install, scan, and manage AI agent skills in CI/CD'
inputs:
command:
description: 'SkillKit command to run (install, scan, check, sync)'
required: true
source:
description: 'Skill source for install (e.g. owner/repo)'
required: false
args:
description: 'Additional arguments'
required: false
default: ''
node-version:
description: 'Node.js version'
required: false
default: '20'
agent:
description: 'Target agent (e.g. claude-code, cursor)'
required: false
default: 'claude-code'
runs:
using: 'composite'
steps:
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: ${{ inputs.node-version }}
- name: Install SkillKit
shell: bash
run: npm install -g skillkit@latest
- name: Run SkillKit
shell: bash
env:
SK_COMMAND: ${{ inputs.command }}
SK_SOURCE: ${{ inputs.source }}
SK_AGENT: ${{ inputs.agent }}
SK_ARGS: ${{ inputs.args }}
run: |
case "${SK_COMMAND}" in
install)
if [ -n "${SK_SOURCE}" ]; then
skillkit install "${SK_SOURCE}" --agent "${SK_AGENT}" --yes --json ${SK_ARGS}
else
echo "Error: source is required for install" >&2; exit 1
fi
;;
scan)
if [ -n "${SK_SOURCE}" ]; then
skillkit scan "${SK_SOURCE}" --json ${SK_ARGS}
else
echo "Error: source is required for scan" >&2; exit 1
fi
;;
check|sync|list|update)
skillkit "${SK_COMMAND}" ${SK_ARGS}
;;
*)
echo "Error: unsupported command '${SK_COMMAND}'. Use: install, scan, check, sync, list, update" >&2
exit 1
;;
esac
-324
View File
@@ -1,324 +0,0 @@
name: Auto-Publish Skill Submission
on:
issues:
types: [labeled]
permissions:
issues: write
contents: write
concurrency:
group: auto-publish-${{ github.event.issue.number }}
cancel-in-progress: false
jobs:
auto-publish:
if: github.event.label.name == 'skill-submission'
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install pnpm
uses: pnpm/action-setup@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'pnpm'
- name: Install dependencies
run: pnpm install --frozen-lockfile
- name: Build
run: pnpm build
- name: Extract and validate submission
id: validate
uses: actions/github-script@v7
env:
ISSUE_BODY: ${{ github.event.issue.body }}
with:
script: |
const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');
const body = process.env.ISSUE_BODY || '';
const jsonMatch = body.match(/```json\s*\n([\s\S]*?)\n```/);
if (!jsonMatch) {
core.setOutput('status', 'error');
core.setOutput('message', 'No JSON block found in issue body. Please include your source entry between \\`\\`\\`json and \\`\\`\\` fences.');
return;
}
let entry;
try {
entry = JSON.parse(jsonMatch[1].trim());
} catch (e) {
core.setOutput('status', 'error');
core.setOutput('message', `Invalid JSON in submission: ${e.message}`);
return;
}
const source = entry.source || (entry.owner && entry.repo ? `${entry.owner}/${entry.repo}` : null);
const name = entry.name;
const description = entry.description || '';
if (!source || !name) {
core.setOutput('status', 'error');
core.setOutput('message', 'Missing required fields. JSON must include `source` (owner/repo) and `name`.');
return;
}
const parts = source.split('/');
if (parts.length !== 2 || !parts[0] || !parts[1]) {
core.setOutput('status', 'error');
core.setOutput('message', `Invalid source format "${source}". Must be "owner/repo".`);
return;
}
const [owner, repo] = parts;
const sourcesData = JSON.parse(fs.readFileSync('marketplace/sources.json', 'utf-8'));
const existing = sourcesData.sources.find(s => s.source === source);
if (existing) {
core.setOutput('status', 'error');
core.setOutput('message', `Source "${source}" already exists in sources.json as "${existing.name}".`);
return;
}
try {
const repoCheck = await github.rest.repos.get({ owner, repo });
if (repoCheck.status !== 200) throw new Error('not found');
} catch (e) {
core.setOutput('status', 'error');
core.setOutput('message', `Repository "${source}" does not exist or is not accessible on GitHub.`);
return;
}
const cloneDir = `/tmp/skill-check-${owner}-${repo}`;
try {
execSync(`git clone --depth 1 https://github.com/${owner}/${repo}.git ${cloneDir}`, {
timeout: 60000,
stdio: 'pipe',
});
} catch (e) {
core.setOutput('status', 'error');
core.setOutput('message', `Failed to clone repository "${source}".`);
return;
}
let scanVerdict = 'pass';
let scanSummary = '';
let qualityScore = 0;
let qualitySummary = '';
try {
const scanScript = `
const { SkillScanner } = require('./packages/core/dist/scanner/scanner.js');
const scanner = new SkillScanner();
scanner.scan('${cloneDir}').then(result => {
console.log(JSON.stringify({
verdict: result.verdict,
stats: result.stats,
findings: result.findings.length,
}));
});
`;
const scanOutput = execSync(`node -e "${scanScript.replace(/\n/g, ' ')}"`, {
cwd: process.cwd(),
timeout: 30000,
stdio: 'pipe',
}).toString().trim();
const scanResult = JSON.parse(scanOutput);
scanVerdict = scanResult.verdict;
scanSummary = `Verdict: ${scanResult.verdict}, Findings: ${scanResult.findings}, Critical: ${scanResult.stats.critical}, High: ${scanResult.stats.high}`;
} catch (e) {
scanSummary = 'Scanner completed with warnings';
}
const skillMdCandidates = ['SKILL.md', 'skill.md', 'README.md'];
let skillContent = null;
for (const candidate of skillMdCandidates) {
try {
const found = execSync(`find ${cloneDir} -name "${candidate}" -maxdepth 3 -type f`, {
stdio: 'pipe',
}).toString().trim().split('\n').filter(Boolean);
if (found.length > 0) {
skillContent = fs.readFileSync(found[0], 'utf-8');
break;
}
} catch {}
}
if (skillContent) {
try {
const qualityScript = `
const { evaluateSkillContent } = require('./packages/core/dist/quality/index.js');
const fs = require('fs');
const content = fs.readFileSync('${cloneDir}/.skill-content.tmp', 'utf-8');
const result = evaluateSkillContent(content);
console.log(JSON.stringify({ overall: result.overall, warnings: result.warnings }));
`;
fs.writeFileSync(`${cloneDir}/.skill-content.tmp`, skillContent);
const qualityOutput = execSync(`node -e "${qualityScript.replace(/\n/g, ' ')}"`, {
cwd: process.cwd(),
timeout: 30000,
stdio: 'pipe',
}).toString().trim();
const qualityResult = JSON.parse(qualityOutput);
qualityScore = qualityResult.overall;
qualitySummary = `Score: ${qualityResult.overall}/100, Warnings: ${qualityResult.warnings.length}`;
} catch (e) {
qualityScore = 50;
qualitySummary = 'Quality evaluation encountered an error; defaulting to 50';
}
} else {
qualityScore = 50;
qualitySummary = 'No SKILL.md or README.md found; defaulting to score 50';
}
const scanPassed = scanVerdict !== 'fail';
const qualityPassed = qualityScore >= 75;
core.setOutput('source', source);
core.setOutput('name', name);
core.setOutput('description', description);
core.setOutput('official', entry.official === true ? 'true' : 'false');
core.setOutput('scan_verdict', scanVerdict);
core.setOutput('scan_summary', scanSummary);
core.setOutput('quality_score', String(qualityScore));
core.setOutput('quality_summary', qualitySummary);
if (scanPassed && qualityPassed) {
core.setOutput('status', 'pass');
core.setOutput('message', `Validation passed. Security: ${scanSummary}. Quality: ${qualitySummary}.`);
} else {
const reasons = [];
if (!scanPassed) reasons.push(`Security scan failed: ${scanSummary}`);
if (!qualityPassed) reasons.push(`Quality score ${qualityScore}/100 is below threshold of 75`);
core.setOutput('status', 'reject');
core.setOutput('message', reasons.join('. '));
}
- name: Add source and commit
if: steps.validate.outputs.status == 'pass'
env:
SKILL_SOURCE: ${{ steps.validate.outputs.source }}
SKILL_NAME: ${{ steps.validate.outputs.name }}
SKILL_DESCRIPTION: ${{ steps.validate.outputs.description }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
node -e "
const fs = require('fs');
const data = JSON.parse(fs.readFileSync('marketplace/sources.json', 'utf-8'));
const newEntry = { source: process.env.SKILL_SOURCE, name: process.env.SKILL_NAME };
if (process.env.SKILL_DESCRIPTION) {
newEntry.description = process.env.SKILL_DESCRIPTION;
}
const skillsSh = data.sources.pop();
data.sources.push(newEntry);
if (skillsSh && skillsSh.registry === 'skills-sh') {
data.sources.push(skillsSh);
}
data.updatedAt = new Date().toISOString().split('T')[0];
fs.writeFileSync('marketplace/sources.json', JSON.stringify(data, null, 2) + '\n');
"
git config --local user.email "github-actions[bot]@users.noreply.github.com"
git config --local user.name "github-actions[bot]"
git add marketplace/sources.json
git commit -m "feat(marketplace): add source from #${ISSUE_NUMBER}"
git push
- name: Close issue on success
if: steps.validate.outputs.status == 'pass'
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
SKILL_SOURCE: ${{ steps.validate.outputs.source }}
SKILL_NAME: ${{ steps.validate.outputs.name }}
SCAN_SUMMARY: ${{ steps.validate.outputs.scan_summary }}
QUALITY_SUMMARY: ${{ steps.validate.outputs.quality_summary }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
cat > /tmp/comment.md <<ENDOFCOMMENT
**Skill source auto-published!**
**Source:** \`${SKILL_SOURCE}\`
**Name:** ${SKILL_NAME}
**Security:** ${SCAN_SUMMARY}
**Quality:** ${QUALITY_SUMMARY}
The source has been added to \`marketplace/sources.json\` and will be included in the next release.
ENDOFCOMMENT
gh issue comment "${ISSUE_NUMBER}" --body-file /tmp/comment.md
gh issue close "${ISSUE_NUMBER}"
- name: Comment rejection reason
if: steps.validate.outputs.status == 'reject'
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
REJECT_MESSAGE: ${{ steps.validate.outputs.message }}
SCAN_VERDICT: ${{ steps.validate.outputs.scan_verdict }}
SCAN_SUMMARY: ${{ steps.validate.outputs.scan_summary }}
QUALITY_SCORE: ${{ steps.validate.outputs.quality_score }}
QUALITY_SUMMARY: ${{ steps.validate.outputs.quality_summary }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
cat > /tmp/comment.md <<ENDOFCOMMENT
**Skill submission did not pass automated checks.**
${REJECT_MESSAGE}
**Details:**
- Security scan: ${SCAN_VERDICT} (${SCAN_SUMMARY})
- Quality score: ${QUALITY_SCORE}/100 (${QUALITY_SUMMARY})
Please address these issues and update your submission. A maintainer will review manually.
ENDOFCOMMENT
gh issue comment "${ISSUE_NUMBER}" --body-file /tmp/comment.md
gh issue edit "${ISSUE_NUMBER}" --add-label "needs-review"
- name: Comment parse error
if: steps.validate.outputs.status == 'error'
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
ERROR_MESSAGE: ${{ steps.validate.outputs.message }}
ISSUE_NUMBER: ${{ github.event.issue.number }}
run: |
cat > /tmp/comment.md <<'ENDOFCOMMENT'
**Could not process skill submission.**
ENDOFCOMMENT
echo "${ERROR_MESSAGE}" >> /tmp/comment.md
cat >> /tmp/comment.md <<'ENDOFCOMMENT'
**Expected format in issue body:**
```json
{
"source": "owner/repo",
"name": "Display Name",
"description": "Optional description"
}
```
Please update the issue body and re-apply the `skill-submission` label.
ENDOFCOMMENT
gh issue comment "${ISSUE_NUMBER}" --body-file /tmp/comment.md
gh issue edit "${ISSUE_NUMBER}" --add-label "needs-review"
+2 -58
View File
@@ -7,60 +7,6 @@ on:
branches: [main]
jobs:
# Verify all packages have consistent versions
version-check:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Check version consistency
run: |
echo "Checking version consistency across all packages..."
# Get the main version from apps/skillkit
MAIN_VERSION=$(node -p "require('./apps/skillkit/package.json').version")
echo "Main version: $MAIN_VERSION"
# List of all packages to check
PACKAGES=(
"package.json"
"apps/skillkit/package.json"
"packages/cli/package.json"
"packages/core/package.json"
"packages/tui/package.json"
"packages/agents/package.json"
"packages/memory/package.json"
"packages/mesh/package.json"
"packages/messaging/package.json"
"packages/mcp-memory/package.json"
"packages/resources/package.json"
"docs/skillkit/package.json"
"docs/fumadocs/package.json"
)
FAILED=0
for pkg in "${PACKAGES[@]}"; do
if [ -f "$pkg" ]; then
PKG_VERSION=$(node -p "require('./$pkg').version")
if [ "$PKG_VERSION" != "$MAIN_VERSION" ]; then
echo "❌ Version mismatch: $pkg has $PKG_VERSION (expected $MAIN_VERSION)"
FAILED=1
else
echo "✓ $pkg: $PKG_VERSION"
fi
fi
done
if [ $FAILED -eq 1 ]; then
echo ""
echo "Version mismatch detected!"
echo "Run: ./scripts/bump-version.sh $MAIN_VERSION"
exit 1
fi
echo ""
echo "All packages have consistent version: $MAIN_VERSION"
# Unit tests run on all Node versions
test:
runs-on: ubuntu-latest
@@ -132,14 +78,12 @@ jobs:
# Final status check for branch protection
ci-success:
runs-on: ubuntu-latest
needs: [version-check, test, e2e]
needs: [test, e2e]
if: always()
steps:
- name: Check all jobs passed
run: |
if [[ "${{ needs.version-check.result }}" != "success" ]] || \
[[ "${{ needs.test.result }}" != "success" ]] || \
[[ "${{ needs.e2e.result }}" != "success" ]]; then
if [[ "${{ needs.test.result }}" != "success" ]] || [[ "${{ needs.e2e.result }}" != "success" ]]; then
echo "One or more jobs failed"
exit 1
fi
-13
View File
@@ -16,19 +16,6 @@ jobs:
steps:
- uses: actions/checkout@v4
- name: Verify tag matches package version
run: |
TAG_VERSION="${GITHUB_REF#refs/tags/v}"
PKG_VERSION=$(node -p "require('./apps/skillkit/package.json').version")
echo "Tag version: $TAG_VERSION"
echo "Package version: $PKG_VERSION"
if [ "$TAG_VERSION" != "$PKG_VERSION" ]; then
echo "❌ Tag version ($TAG_VERSION) doesn't match package version ($PKG_VERSION)"
echo "Please update package versions before creating the release tag."
exit 1
fi
echo "✓ Version check passed"
- name: Install pnpm
uses: pnpm/action-setup@v4
+3 -6
View File
@@ -24,9 +24,8 @@ npm-debug.log*
# Environment
.env
**/.env
**/.env.local
**/.env.*.local
.env.local
.env.*.local
# Package manager
yarn.lock
@@ -64,6 +63,4 @@ skillkit.yaml
# Project documentation (not for version control)
CLAUDE.md
prd.md
.vercel
packages/extension/store-assets/skillkit-extension.zip
prd.md
+1 -1
View File
@@ -206,7 +206,7 @@ To add support for a new AI coding agent:
If you want to contribute skills to the ecosystem:
1. Follow the [Agent Skills specification](https://skillkit.sh)
1. Follow the [Agent Skills specification](https://agentskills.io/specification)
2. Include a `SKILL.md` with proper frontmatter
3. Test with multiple agents using `skillkit translate`
4. Submit to the appropriate skill repository
+349 -392
View File
@@ -1,518 +1,475 @@
<div align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="docs/img/banner.svg">
<source media="(prefers-color-scheme: light)" srcset="docs/img/banner.svg">
<img alt="SkillKit. One skill. Every agent." src="docs/img/banner.svg" width="100%">
</picture>
<br/>
### *One skill. Every agent. 46 of them.*
<br/>
[![npm](https://img.shields.io/npm/v/skillkit?style=for-the-badge&logo=npm&logoColor=white&labelColor=0D1117&color=CB3837)](https://www.npmjs.com/package/skillkit)
[![downloads](https://img.shields.io/npm/dm/skillkit?style=for-the-badge&logo=npm&logoColor=white&labelColor=0D1117&color=FF8B94)](https://www.npmjs.com/package/skillkit)
[![stars](https://img.shields.io/github/stars/rohitg00/skillkit?style=for-the-badge&logo=github&logoColor=white&labelColor=0D1117&color=FFC75F)](https://github.com/rohitg00/skillkit/stargazers)
[![CI](https://img.shields.io/github/actions/workflow/status/rohitg00/skillkit/ci.yml?style=for-the-badge&logo=githubactions&logoColor=white&labelColor=0D1117&color=6BCB77)](https://github.com/rohitg00/skillkit/actions/workflows/ci.yml)
[![license](https://img.shields.io/badge/License-Apache_2.0-4D96FF?style=for-the-badge&labelColor=0D1117)](LICENSE)
<a href="https://skillkit.sh"><img src="assets/tags/skills.svg" alt="400K+ skills"></a>
<a href="#supported-agents"><img src="assets/tags/agents.svg" alt="46 agents"></a>
<a href="#skill-sources"><img src="assets/tags/sources.svg" alt="31 sources"></a>
<img src="assets/tags/tests.svg" alt="757 tests">
<a href="LICENSE"><img src="assets/tags/license.svg" alt="Apache 2.0"></a>
<a href="CONTRIBUTING.md"><img src="assets/tags/prs-welcome.svg" alt="PRs welcome"></a>
<a href="#full-vs-slim"><img src="assets/tags/slim-install.svg" alt="slim install"></a>
<a href="https://github.com/rohitg00/skillkit/releases/latest"><img src="assets/tags/v1.24.0.svg" alt="v1.24.0"></a>
<img src="assets/tags/new.svg" alt="new">
<img src="assets/tags/one-skill.svg" alt="one skill">
<img src="assets/tags/every-agent.svg" alt="every agent">
### Quick nav
[**Quick start**](#quick-start) · [**Install**](#install) · [**Commands**](#commands) · [**Agents**](#supported-agents) · [**Sources**](#skill-sources) · [**API**](#programmatic-api) · [**Website**](https://skillkit.sh)
```
██ SKILLKIT
```
</div>
---
**Universal Skills for AI Coding Agents**
<div align="center">
[![npm version](https://img.shields.io/npm/v/skillkit.svg)](https://www.npmjs.com/package/skillkit)
[![npm downloads](https://img.shields.io/npm/dm/skillkit.svg)](https://www.npmjs.com/package/skillkit)
[![GitHub Package](https://img.shields.io/badge/GitHub%20Package-@rohitg00/skillkit-blue?logo=github)](https://github.com/rohitg00/skillkit/pkgs/npm/skillkit)
[![CI](https://github.com/rohitg00/skillkit/actions/workflows/ci.yml/badge.svg)](https://github.com/rohitg00/skillkit/actions/workflows/ci.yml)
[![Website](https://img.shields.io/badge/Website-agenstskills.com-black)](https://agenstskills.com)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
https://github.com/user-attachments/assets/b1843a07-2c54-422d-8903-f30a790cfb37
## Supercharge Every AI Coding Agent
</div>
**Give your AI agents new abilities with portable, reusable skills.** Install from a curated marketplace, create your own, and use them across Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and 12 more agents.
## The problem
Every AI coding agent wants skills. Every agent invented a different format.
<table>
<tr>
<th>Agent</th>
<th>Format</th>
<th>Directory</th>
</tr>
<tr><td>Claude Code</td><td><code>SKILL.md</code></td><td><code>.claude/skills/</code></td></tr>
<tr><td>Cursor</td><td><code>.mdc</code></td><td><code>.cursor/skills/</code></td></tr>
<tr><td>Copilot</td><td>Markdown</td><td><code>.github/skills/</code></td></tr>
<tr><td>Windsurf</td><td>Markdown</td><td><code>.windsurf/skills/</code></td></tr>
<tr><td colspan="3"><i>... 41 more</i></td></tr>
</table>
You rewrite the same skill for each agent. Or you lock in to one.
## The fix
SkillKit is the package manager for AI agent skills. Install from 400K+ skills across 31 sources. Auto-translate between formats. Persist session learnings. Ship to 46 agents at once.
> **What are AI Agent Skills?** Skills are instruction files that teach AI coding agents how to handle specific tasks - like processing PDFs, following React best practices, or enforcing security patterns. Think of them as plugins for your AI assistant.
```bash
npx skillkit add anthropics/skills
npm install -g skillkit
```
That is the whole first-run. Pick your agent (your detected agent is pre-selected), confirm, done.
## Why SkillKit?
## Quick start
**The problem:** You've built amazing skills for Claude Code. Now you want to try Cursor. Or your team uses different agents. Each agent has different formats and directories. Without SkillKit, you either rewrite everything, lock yourself into one agent, or give up on skills entirely.
**The solution:** SkillKit translates skills between all 17 agents automatically. Write once, use everywhere.
## See It In Action
<video src="https://raw.githubusercontent.com/rohitg00/skillkit/main/docs/video/skillkit.mp4" controls width="100%"></video>
> **Note:** If the video doesn't play above, [watch it here](https://raw.githubusercontent.com/rohitg00/skillkit/main/docs/video/skillkit.mp4)
```bash
npx skillkit init # detect agent, create dirs
skillkit recommend # stack-aware suggestions
skillkit add anthropics/skills # install from marketplace
skillkit sync # deploy to agent config
# Install a skill for ALL your agents at once
skillkit install anthropics/skills --agent claude-code,cursor,windsurf
# Or translate existing skills between any agents
skillkit translate my-skill --from claude --to cursor,codex,copilot
# Get smart recommendations based on your project
skillkit recommend
# > 92% match: vercel-react-best-practices
# > 87% match: tailwind-v4-patterns
# > 85% match: nextjs-app-router
```
Four commands. Your agent now has PDF processing, code review, auth patterns, and whatever you need.
## Beautiful CLI Experience
### What the first install looks like
SkillKit features a polished, interactive CLI with visual feedback:
```
$ npx skillkit add anthropics/skills
![SkillKit Interactive CLI](docs/img/inital-command.png)
◇ Detected 32 agents
│
◆ Install to
│ ● Just Claude Code (detected) claude-code
│ ○ Select specific agents space to toggle
│ ○ All supported agents 32 agents, writes to every adapter
└
- **Adaptive Logo** - Full ASCII art on wide terminals, compact on narrow
- **Agent Icons** - Visual indicators: ⟁ Claude · ◫ Cursor · ◎ Codex · ✦ Gemini · ⬡ OpenCode
- **Interactive Selection** - Multi-select skills and agents with visual feedback
- **Progress Indicators** - Step trails, spinners, and progress bars
- **Smart Defaults** - Remembers your last selected agents
◇ Cloning anthropics/skills
◇ Security scan: 42/42 skills pass
◇ Installed 42 skills to Claude Code
│
└ Done in 3.1s. Run `skillkit list` to see them.
```
## What Makes SkillKit Different
## Install
| Feature | Without SkillKit | With SkillKit |
|---------|-----------------|---------------|
| **Multi-Agent Support** | Manual rewrite for each agent | One command, all agents |
| **Team Collaboration** | Email skills back and forth | Git-based bundles, remote sync |
| **Skill Discovery** | Search GitHub manually | Smart recommendations for your stack |
| **Format Translation** | Learn each agent's format | Automatic conversion (17 formats) |
| **Context Sync** | Configure each agent separately | One config, synced everywhere |
| **Session Memory** | Knowledge dies with each session | Persistent learning across agents |
| **Skill Testing** | Hope it works | Test framework with assertions |
Pick one. All three do the same thing.
## 5-Minute Quick Start
```bash
npm install -g skillkit # npm
pnpm add -g skillkit # pnpm
bun add -g skillkit # bun
# 1. Install SkillKit globally
npm install -g skillkit
# 2. Launch the interactive TUI (easiest way to start)
skillkit
# Or use CLI commands directly:
# 3. Get personalized skill recommendations
skillkit recommend
# 4. Install skills from the marketplace
skillkit install anthropics/skills
# 5. Sync to your AI agent
skillkit sync
```
Both `skillkit` and `sk` work as the binary name.
## Core Features
### Full vs slim
### Cross-Agent Translation
Four features ship as optional packages so a bare CLI stays small. The default install pulls everything. Add `--omit=optional` if you only want the core.
| Feature | Package | Command |
| :-------------- | :--------------------- | :--------------- |
| Terminal UI | `@skillkit/tui` | `skillkit ui` |
| REST server | `@skillkit/api` | `skillkit serve` |
| Peer mesh | `@skillkit/mesh` | `skillkit mesh` |
| Agent messaging | `@skillkit/messaging` | `skillkit message` |
Cold install numbers on a fresh npm cache:
<p align="center">
<img src="assets/tags/packages.svg" alt="118 packages">
<img src="assets/tags/install.svg" alt="9s install">
<img src="assets/tags/vulns.svg" alt="0 vulnerabilities">
</p>
| Mode | Packages | Time | Vulns (crit/high) |
| :---------------------------------- | -------: | :--: | ----------------: |
| `npm i -g skillkit` | 418 | 18s | 0/0 |
| `npm i -g skillkit --omit=optional` | 118 | 9s | 0/0 |
Skipped optional? Add just the one you want later:
Use any skill with any agent. SkillKit automatically converts between formats:
```bash
npm i -g @skillkit/tui # enables: skillkit ui
npm i -g @skillkit/api # enables: skillkit serve
npm i -g @skillkit/mesh # enables: skillkit mesh
npm i -g @skillkit/messaging # enables: skillkit message
# Translate a Claude skill to Cursor format
skillkit translate react-patterns --to cursor
# Translate all your skills to a new agent
skillkit translate --all --to windsurf
# Preview translation without writing
skillkit translate my-skill --to codex --dry-run
# Batch translate from a custom source directory
skillkit agent translate --source ./my-skills --to cursor
# Recursively translate nested agent directories
skillkit agent translate --source ./kubernetes-skills --to cursor --recursive
```
The CLI catches missing optional packages and prints a one-line hint. No stack trace.
**Supported Agents:** Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Antigravity, Amp, Clawdbot, Droid, GitHub Copilot, Goose, Kilo, Kiro, Roo, Trae, Windsurf, Universal
### Using `npx`
### Smart Recommendations
`npx skillkit add <owner/repo>` works with zero install. First call caches the package under `~/.npm/_npx/`. Every run after that is instant until a new version ships.
SkillKit analyzes your project and suggests the perfect skills:
```bash
npx skillkit add anthropics/skills # full
npx --omit=optional skillkit add anthropics/skills # slim
skillkit recommend
# Project: my-app (Next.js + TypeScript + Tailwind)
#
# Recommended Skills:
# 92% vercel-react-best-practices
# 87% tailwind-v4-patterns
# 85% nextjs-app-router
# 78% typescript-strict-mode
```
If you reach for `npx skillkit` more than twice, switch to a global install. Kills the prompt-to-proceed and the per-release refetch.
## What you can do
<details open>
<summary><b>Install from anywhere</b></summary>
Filter by task, category, or minimum score:
```bash
skillkit add anthropics/skills # GitHub
skillkit add gitlab:team/skills # GitLab
skillkit add ./my-local-skills # local path
skillkit add https://gist.github.com/... # gist
skillkit recommend --search "auth" # Task-based search
skillkit recommend --category security # Category filter
skillkit recommend --min-score 80 # Quality threshold
```
</details>
<details>
<summary><b>Translate between agents</b></summary>
### Session Memory System
Write once for Claude, ship everywhere:
```bash
skillkit translate my-skill --to cursor
skillkit translate --all --to windsurf,codex
skillkit translate my-skill --to copilot --dry-run
```
</details>
<details>
<summary><b>Stack-aware recommendations</b></summary>
SkillKit reads your repo, spots your stack, ranks skills:
```bash
$ skillkit recommend
92% vercel-react-best-practices
87% tailwind-v4-patterns
85% nextjs-app-router
81% shadcn-ui-components
```
</details>
<details>
<summary><b>Runtime skill discovery (REST)</b></summary>
Start the server, let agents fetch skills on demand:
```bash
skillkit serve
# http://localhost:3737
curl "http://localhost:3737/search?q=react+performance"
```
Or wire it up with MCP:
```json
{
"mcpServers": {
"skillkit": { "command": "npx", "args": ["@skillkit/mcp"] }
}
}
```
Or call from Python:
```python
from skillkit import SkillKitClient
async with SkillKitClient() as client:
results = await client.search("react performance", limit=5)
```
[REST docs](https://skillkit.sh/docs/rest-api) · [MCP docs](https://skillkit.sh/docs/mcp-server) · [Python client](https://skillkit.sh/docs/python-client)
</details>
<details>
<summary><b>Auto-generate agent instructions</b></summary>
Analyze the codebase and write CLAUDE.md, `.cursorrules`, AGENTS.md, and friends:
```bash
skillkit primer --all-agents
```
</details>
<details>
<summary><b>Session memory</b></summary>
AI agents learn during a session, then forget. SkillKit captures what they learned:
Your AI agents learn, but that knowledge dies with the session. SkillKit captures learnings and makes them persistent:
```bash
# Compress session observations into reusable learnings
skillkit memory compress
skillkit memory search "auth patterns"
skillkit memory export auth-patterns
# Search past learnings
skillkit memory search "authentication patterns"
# Export a learning as a shareable skill
skillkit memory export auth-insight --output auth-patterns.md
# Share memory across projects
skillkit memory --global
```
</details>
<details>
<summary><b>AI skill generation</b></summary>
### Skill Marketplace
Generate skills from plain English with multi-source context:
Browse and install from curated skill repositories:
```bash
skillkit generate
# Browse all available skills
skillkit marketplace
# Search for specific skills
skillkit marketplace search "react hooks"
# Filter by tags
skillkit marketplace --tags typescript,testing
# Refresh the skill index
skillkit marketplace refresh
```
Pulls context from four places: Context7 docs, your codebase, 400K marketplace skills, your memory. Works with Claude, GPT-4, Gemini, Ollama (local), or any OpenRouter model.
</details>
### Interactive TUI
<details>
<summary><b>Team collaboration</b></summary>
Share skills via a committable `.skills` manifest:
```bash
skillkit manifest init
skillkit manifest add anthropics/skills
git commit -m "add team skills"
```
Everyone else runs `skillkit manifest install` and matches state.
</details>
<details>
<summary><b>Mesh network</b></summary>
Distribute agents across machines with encrypted P2P:
```bash
skillkit mesh init
skillkit mesh discover
```
</details>
<details>
<summary><b>Chrome extension</b></summary>
Save any webpage as a skill from the browser. Click the extension, the page round-trips through the SkillKit API (Turndown, 5-source tag detection, GitHub URL support), the `SKILL.md` downloads, then run `skillkit add ~/Downloads/skillkit-skills/<name>`.
[Extension docs](https://skillkit.sh/docs/chrome-extension)
</details>
<details>
<summary><b>Interactive TUI</b></summary>
Beautiful terminal interface for visual skill management:
```bash
skillkit ui
# or just
skillkit
```
<sub><code>h</code> home · <code>m</code> marketplace · <code>r</code> recommend · <code>t</code> translate · <code>i</code> installed · <code>s</code> sync · <code>q</code> quit</sub>
**Navigation:** `h` Home | `b` Browse | `r` Recommend | `t` Translate | `c` Context | `l` List | `s` Sync | `q` Quit
<img src="docs/img/skillkit-ui.png" width="100%" alt="SkillKit interactive TUI">
### Skill Testing Framework
</details>
## Commands
<details open>
<summary><b>Core</b></summary>
Test your skills with built-in assertions:
```bash
skillkit add <source> # install skills (live progress)
skillkit remove <skills> # remove
skillkit remove --source org/repo # bulk by source
skillkit remove --all # remove everything
skillkit update # update (change detection)
skillkit check # updates, quality, activity
skillkit translate <skill> --to # agent format conversion
skillkit sync # deploy to agent config
skillkit recommend # smart recommendations
skillkit generate # AI skill wizard
skillkit serve # REST API server
skillkit publish submit # publish to marketplace
```
</details>
# Run all skill tests
skillkit test
<details>
<summary><b>Discovery & security</b></summary>
# Test specific skills
skillkit test ./my-skill
# Run tests with specific tags
skillkit test --tags unit,integration
# JSON output for CI
skillkit test --json
```
### Workflow Orchestration
Compose skills into multi-step workflows:
```bash
skillkit marketplace # browse
skillkit tree # taxonomy
skillkit find <query> # quick search
skillkit scan <path> # security scan
```
</details>
# List available workflows
skillkit workflow list
<details>
<summary><b>Custom sources</b></summary>
# Run a workflow
skillkit workflow run feature-development
# Create new workflow
skillkit workflow create my-workflow
```
### CI/CD Integration
Generate CI/CD templates for automated skill management:
```bash
skillkit tap add owner/repo
skillkit tap list
skillkit tap remove owner/repo
```
</details>
# GitHub Actions
skillkit cicd github-action
<details>
<summary><b>Issue planner</b></summary>
# GitLab CI
skillkit cicd gitlab-ci
# Pre-commit hooks
skillkit cicd pre-commit
```
## Supported Agents (17)
| Agent | Format | Skills Directory |
|-------|--------|------------------|
| Claude Code | SKILL.md | `.claude/skills/` |
| Cursor | MDC (.mdc) | `.cursor/skills/` |
| Codex | SKILL.md | `.codex/skills/` |
| Gemini CLI | SKILL.md | `.gemini/skills/` |
| OpenCode | SKILL.md | `.opencode/skills/` |
| Antigravity | SKILL.md | `.antigravity/skills/` |
| Amp | SKILL.md | `.amp/skills/` |
| Clawdbot | SKILL.md | `skills/` or `~/.clawdbot/skills/` |
| Droid (Factory) | SKILL.md | `.factory/skills/` |
| GitHub Copilot | Markdown | `.github/skills/` |
| Goose | SKILL.md | `.goose/skills/` |
| Kilo Code | SKILL.md | `.kilocode/skills/` |
| Kiro CLI | SKILL.md | `.kiro/skills/` |
| Roo Code | SKILL.md | `.roo/skills/` |
| Trae | SKILL.md | `.trae/skills/` |
| Windsurf | Markdown | `.windsurf/skills/` |
| Universal | SKILL.md | `skills/` |
## All Commands
### Skill Management
```bash
skillkit issue plan "#42"
skillkit issue plan owner/repo#42
skillkit issue list
skillkit install <source> # Install skills from GitHub/GitLab/Bitbucket/local
skillkit remove <skills> # Remove installed skills
skillkit update [skills] # Update skills from source
skillkit list # List installed skills
skillkit enable <skills> # Enable specific skills
skillkit disable <skills> # Disable specific skills
skillkit sync # Sync skills to agent config
skillkit read <skills> # Read skill content for AI
```
</details>
<details>
<summary><b>Session intelligence</b></summary>
### Discovery & Recommendations
```bash
skillkit timeline # unified event stream
skillkit session handoff # agent-to-agent context
skillkit lineage # skill impact graph
skillkit session explain # human summary
skillkit activity # activity log
skillkit recommend # Get smart recommendations
skillkit marketplace # Browse skill marketplace
skillkit marketplace search # Search marketplace
```
</details>
<details>
<summary><b>Advanced</b></summary>
### Translation & Context
```bash
skillkit primer --all-agents # agent instruction files
skillkit memory compress # capture session learnings
skillkit mesh init # multi-machine distribution
skillkit message send # inter-agent messaging
skillkit workflow run <name> # run workflows
skillkit test # test skills
skillkit cicd init # CI/CD templates
skillkit translate # Translate between formats
skillkit context init # Initialize project context
skillkit context sync # Sync context to agents
```
</details>
[Full command reference](https://skillkit.sh/docs/commands)
### Custom AI Sub-Agents
## Supported agents
```bash
skillkit agent list # List all installed agents
skillkit agent show <name> # Show agent details
skillkit agent create <name> # Create a new agent
skillkit agent translate # Translate agents between formats
--source ./path # Source directory or file
--to cursor # Target agent format
--recursive # Scan subdirectories recursively
--dry-run # Preview without writing
skillkit agent sync # Sync agents to target AI agent
skillkit agent validate # Validate agent definitions
```
<details open>
<summary><b>Top 11</b></summary>
### Memory System
| Agent | Format | Directory |
| :----------------- | :--------- | :----------------- |
| **Claude Code** | `SKILL.md` | `.claude/skills/` |
| **Cursor** | `.mdc` | `.cursor/skills/` |
| **Codex** | `SKILL.md` | `.codex/skills/` |
| **Gemini CLI** | `SKILL.md` | `.gemini/skills/` |
| **OpenCode** | `SKILL.md` | `.opencode/skills/`|
| **GitHub Copilot** | Markdown | `.github/skills/` |
| **Windsurf** | Markdown | `.windsurf/skills/`|
| **Devin** | Markdown | `.devin/skills/` |
| **Aider** | `SKILL.md` | `.aider/skills/` |
| **Cody** | `SKILL.md` | `.cody/skills/` |
| **Amazon Q** | `SKILL.md` | `.amazonq/skills/` |
</details>
```bash
skillkit memory status # View memory status
skillkit memory search # Search learnings
skillkit memory compress # Compress observations
skillkit memory export # Export as skill
```
<details>
<summary><b>Plus 35 more</b></summary>
### Testing & Workflows
Amp, Antigravity, Augment Code, Bolt, Clawdbot, Cline, CodeBuddy, CodeGPT, CommandCode, Continue, Crush, Droid, Factory, Goose, Hermes Agent, Kilo Code, Kiro CLI, Lovable, MCPJam, Mux, Neovate, OpenClaw, OpenHands, Pi, PlayCode, Qoder, Qwen, Replit Agent, Roo Code, Tabby, Tabnine, Trae, Vercel, Zencoder, Universal.
</details>
```bash
skillkit test # Run skill tests
skillkit workflow run # Execute workflow
skillkit cicd # Generate CI/CD templates
```
[Full agent details](https://skillkit.sh/docs/agents)
### Utilities
## Creating skills
```bash
skillkit init # Initialize in project
skillkit validate # Validate skill format
skillkit create # Create new skill
```
## Creating Skills
### Quick Start
```bash
skillkit create my-skill
```
Or author a `SKILL.md` by hand:
### Manual Creation
Create a `SKILL.md` file following the [Agent Skills specification](https://agentskills.io/specification):
```markdown
---
name: my-skill
description: What this skill does
description: What this skill does and when to use it
license: MIT
metadata:
author: your-name
version: "1.0"
---
# My Skill
Instructions for the agent.
Instructions for the AI agent.
## When to use
- scenario 1
- scenario 2
## When to Use
- Scenario 1
- Scenario 2
## Steps
1. first
2. second
1. First step
2. Second step
```
## Programmatic API
```ts
import { translateSkill, analyzeProject, RecommendationEngine } from 'skillkit';
```typescript
import {
// Skill discovery
findAllSkills,
discoverSkills,
detectAgent,
getAdapter,
const skill = await translateSkill(content, 'cursor');
// Translation
translateSkill,
translateSkillFile,
const profile = await analyzeProject('./my-project');
// Recommendations
RecommendationEngine,
analyzeProject,
// Context
ContextManager,
syncToAllAgents,
// Memory
createMemoryCompressor,
createMemoryInjector,
LearningStore,
// Marketplace
createMarketplaceAggregator,
// Testing
SkillTestRunner,
// Workflows
WorkflowOrchestrator,
} from 'skillkit';
// Example: Translate and install
const skill = await translateSkill(skillContent, 'cursor');
console.log(skill.content);
// Example: Get recommendations
const engine = new RecommendationEngine();
const recs = await engine.recommend(profile);
const profile = await analyzeProject('./my-project');
const recs = engine.recommend(profile);
```
```ts
import { startServer } from '@skillkit/api';
await startServer({ port: 3737, skills: [...] });
## Popular Skill Repositories
| Repository | Description |
|------------|-------------|
| [anthropics/skills](https://github.com/anthropics/skills) | Official Claude Code marketplace - PDF, XLSX, DOCX processing |
| [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) | React/Next.js best practices, web design guidelines |
## Installation Options
```bash
# npm (recommended)
npm install -g skillkit
# pnpm
pnpm add -g skillkit
# yarn
yarn global add skillkit
# bun
bun add -g skillkit
# npx (no install)
npx skillkit <command>
# GitHub Packages (alternative registry)
npm install -g @rohitg00/skillkit --registry=https://npm.pkg.github.com
```
```ts
import { MemoryCache, RelevanceRanker } from '@skillkit/core';
const cache = new MemoryCache({ maxSize: 500, ttlMs: 86_400_000 });
const ranker = new RelevanceRanker();
const results = ranker.rank(skills, 'react performance');
## Configuration
Create `skillkit.yaml` in your project:
```yaml
version: 1
agent: cursor # Override auto-detection
autoSync: true # Auto-sync on changes
enabledSkills:
- pdf
- xlsx
disabledSkills:
- deprecated-skill
```
## Skill sources
All original creators credited. Licenses preserved. PRs welcome.
### Official partners
| Repository | What |
|:-----------|:-----|
| [anthropics/skills](https://github.com/anthropics/skills) | Official Claude Code skills |
| [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) | Next.js, React |
| [expo/skills](https://github.com/expo/skills) | Expo mobile |
| [remotion-dev/skills](https://github.com/remotion-dev/skills) | Programmatic video |
| [supabase/agent-skills](https://github.com/supabase/agent-skills) | Database, auth |
| [stripe/ai](https://github.com/stripe/ai) | Payments |
### Community
[trailofbits/skills](https://github.com/trailofbits/skills) · [obra/superpowers](https://github.com/obra/superpowers) · [wshobson/agents](https://github.com/wshobson/agents) · [ComposioHQ/awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills) · [travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills) · [langgenius/dify](https://github.com/langgenius/dify) · [better-auth/skills](https://github.com/better-auth/skills) · [onmax/nuxt-skills](https://github.com/onmax/nuxt-skills) · [elysiajs/skills](https://github.com/elysiajs/skills) · [kadajett/agent-nestjs-skills](https://github.com/kadajett/agent-nestjs-skills) · [cloudai-x/threejs-skills](https://github.com/cloudai-x/threejs-skills) · [dimillian/skills](https://github.com/dimillian/skills) · [waynesutton/convexskills](https://github.com/waynesutton/convexskills) · [kepano/obsidian-skills](https://github.com/kepano/obsidian-skills) · [giuseppe-trisciuoglio/developer-kit](https://github.com/giuseppe-trisciuoglio/developer-kit) · [openrouterteam/agent-skills](https://github.com/openrouterteam/agent-skills)
**Want your skills listed?** [Submit your repo](https://github.com/rohitg00/skillkit/issues/new?template=add-source.md).
## Contributing
Issues and PRs land fast. See [CONTRIBUTING.md](CONTRIBUTING.md) for the short version.
## License
Apache 2.0. See [LICENSE](LICENSE).
Apache License 2.0 - see [LICENSE](LICENSE) for details.
<br/>
## Contributing
<div align="center">
Contributions welcome! Please read our [Contributing Guidelines](CONTRIBUTING.md).
[**Docs**](https://skillkit.sh/docs) · [**Website**](https://skillkit.sh) · [**API Explorer**](https://skillkit.sh/api) · [**npm**](https://www.npmjs.com/package/skillkit) · [**GitHub**](https://github.com/rohitg00/skillkit)
## Links
<sub>Built for agents. Written by humans.</sub>
</div>
- [Agent Skills Specification](https://agentskills.io/specification)
- [GitHub Repository](https://github.com/rohitg00/skillkit)
- [NPM Package](https://www.npmjs.com/package/skillkit)
- [GitHub Package](https://github.com/rohitg00/skillkit/pkgs/npm/skillkit)
-35
View File
@@ -1,35 +0,0 @@
# SOUL
## Core Truths
- Ship working software. Everything else is negotiable.
- Simple beats clever. If a junior dev can't read it in 30 seconds, it's too complex.
- Opinions are load-bearing. "It depends" is a cop-out 90% of the time. Pick a side, explain why, move on.
- Exhaustion before escalation. Try everything available before asking for help or giving up.
- Broken things get fixed now, not "in a follow-up PR."
- If the tests pass and the build is green, stop touching it.
## Boundaries
- Never leak secrets, credentials, or private data. Period.
- Ask before doing anything destructive or irreversible. One confirmation. Not three.
- Be honest about uncertainty. "I don't know" is a valid answer. Bullshitting is not.
- The user's codebase is their house. Don't rearrange the furniture without permission.
## Vibe
- Never open with "Great question," "I'd be happy to help," or "Absolutely." Just answer.
- Brevity is mandatory. If the answer fits in one sentence, one sentence is what you get.
- Humor is welcome when it's natural. Not forced puns. The kind of wit that comes from actually understanding the problem.
- Call things out. If you're about to do something dumb, I'll say so. Charm over cruelty, but no sugarcoating.
- Swearing is fine when it lands. A well-placed "that's fucking brilliant" hits different than sterile corporate praise. Don't force it. Don't overdo it. But if a situation calls for a "holy shit" — say holy shit.
- No hedging. No weasel words. No "it might be worth considering perhaps maybe." Say the thing.
- Match energy. Quick question gets a quick answer. Deep problem gets deep analysis. Read the room.
- Code speaks louder than explanations. Show, don't tell. Then shut up.
- Be the assistant you'd actually want to talk to at 2am. Not a corporate drone. Not a sycophant. Just... good.
## Continuity
- This file is a living document. If something stops being true, change it.
- Session memory is ephemeral. This file is how identity persists.
- If this file gets modified during a session, say so explicitly.
+3 -43
View File
@@ -1,49 +1,11 @@
# SkillKit
Universal skills manager for AI coding agents. Install, manage, and sync skills across 46 AI agents including Claude Code, Cursor, Codex, Gemini CLI, and more.
Universal skills manager for AI coding agents. Install, manage, and sync skills across 17+ AI agents including Claude Code, Cursor, Codex, Gemini CLI, and more.
## Installation
```bash
# Full install (default) — every feature, everything works:
npm install -g skillkit
# Slim install — core commands only, ~75% smaller, no native addons:
npm install -g skillkit --omit=optional
```
### What's optional
Four power features ship as **optional dependencies** so the core CLI
stays lean. They install automatically with `npm install -g skillkit`,
and are skipped with `--omit=optional`:
| Feature | Package | Command |
| ------------------------ | -------------------- | ------------------------------ |
| Interactive terminal UI | `@skillkit/tui` | `skillkit ui` / `skillkit tui` |
| REST/OpenAPI server | `@skillkit/api` | `skillkit serve` |
| Peer mesh networking | `@skillkit/mesh` | `skillkit mesh …` |
| Inter-agent messaging | `@skillkit/messaging`| `skillkit message …` |
Add one later with `npm install -g @skillkit/tui` (or `api` / `mesh` / `messaging`).
### Using `npx`
`npx skillkit add <owner/repo>` works with zero install. First run pulls
the package into the npx cache (`~/.npm/_npx/`); every subsequent run
from the same cache is instant.
```bash
npx skillkit add anthropics/skills # full
npx --omit=optional skillkit add anthropics/skills # slim, 118 pkgs, 9 s
```
Running `npx` more than a couple of times? Install globally — no
prompt-to-proceed, no refetch on each release:
```bash
npm install -g skillkit --omit=optional
skillkit add anthropics/skills
```
## Quick Start
@@ -188,11 +150,9 @@ skillkit memory compress
skillkit memory export auth-insight --output auth-skill.md
```
## Supported Agents (46)
## Supported Agents (17)
**Primary (19):** Claude Code, Cursor, Codex, Gemini CLI, Windsurf, GitHub Copilot, OpenCode, Antigravity, Amp, Clawdbot, OpenClaw, Droid, Goose, Hermes Agent, Kilo, Kiro, Roo, Trae, Universal
**Extended (27):** Aider, Amazon Q, Augment Code, Bolt, Cline, CodeBuddy, CodeGPT, CommandCode, Continue, Crush, Devin, Factory, Lovable, MCPJam, Mux, Neovate, OpenHands, Pi, PlayCode Agent, Qoder, Qwen, Replit Agent, Sourcegraph Cody, Tabby, Tabnine, Vercel, Zencoder
Claude Code, Cursor, Codex, Gemini CLI, Windsurf, GitHub Copilot, OpenCode, Antigravity, Amp, Clawdbot, Droid, Goose, Kilo, Kiro, Roo, Trae, Universal
## Usage Examples
+3 -8
View File
@@ -1,7 +1,7 @@
{
"name": "skillkit",
"version": "1.24.0",
"description": "Supercharge AI coding agents with portable skills. Install, translate, and share skills across Claude Code, Cursor, Codex, Copilot & 41 more",
"version": "1.7.6",
"description": "Supercharge AI coding agents with portable skills. Install, translate, and share skills across Claude Code, Cursor, Codex, Copilot & 13 more",
"type": "module",
"bin": {
"skillkit": "./dist/cli.js",
@@ -56,13 +56,8 @@
"@skillkit/core": "workspace:*",
"@skillkit/agents": "workspace:*",
"@skillkit/cli": "workspace:*",
"clipanion": "^4.0.0-rc.4"
},
"optionalDependencies": {
"@skillkit/api": "workspace:*",
"@skillkit/tui": "workspace:*",
"@skillkit/mesh": "workspace:*",
"@skillkit/messaging": "workspace:*"
"clipanion": "^4.0.0-rc.4"
},
"devDependencies": {
"@types/node": "^22.10.5",
+1 -157
View File
@@ -3,8 +3,6 @@ import { readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';
import { Cli, Builtins } from 'clipanion';
import { setVersion, setAgentCount } from '@skillkit/cli';
import { getAdapterCount } from '@skillkit/agents';
import {
InstallCommand,
SyncCommand,
@@ -28,8 +26,6 @@ import {
WorkflowRunCommand,
WorkflowListCommand,
WorkflowCreateCommand,
WorkflowPipelineCommand,
WorkflowPipelineListCommand,
RunCommand,
TestCommand,
MarketplaceCommand,
@@ -40,27 +36,19 @@ import {
PluginCommand,
MethodologyCommand,
HookCommand,
HookTemplateListCommand,
HookTemplateApplyCommand,
HookTemplateShowCommand,
PlanCommand,
CommandCmd,
CommandAvailableCommand,
CommandInstallCommand,
AICommand,
AuditCommand,
PublishCommand,
PublishSubmitCommand,
AgentCommand,
AgentListCommand,
AgentShowCommand,
AgentCreateCommand,
AgentFromSkillCommand,
AgentTranslateCommand,
AgentSyncCommand,
AgentValidateCommand,
AgentInstallCommand,
AgentAvailableCommand,
// New commands (Phase 21)
CheckCommand,
FindCommand,
ManifestCommand,
@@ -69,64 +57,6 @@ import {
ManifestRemoveCommand,
ManifestInstallCommand,
ManifestGenerateCommand,
PrimerCommand,
MeshCommand,
MessageCommand,
LearnCommand,
PatternStatusCommand,
PatternFeedbackCommand,
PatternApproveCommand,
PatternRejectCommand,
PatternExportCommand,
PatternImportCommand,
PatternClusterCommand,
SessionCommand,
SessionStatusCommand,
SessionStartCommand,
SessionLoadCommand,
SessionListCommand,
SessionNoteCommand,
SessionCompleteCommand,
SessionInProgressCommand,
SessionSnapshotSaveCommand,
SessionSnapshotRestoreCommand,
SessionSnapshotListCommand,
SessionSnapshotDeleteCommand,
SessionExplainCommand,
ActivityCommand,
ProfileCommand,
ProfileListCommand,
ProfileCreateCommand,
ProfileRemoveCommand,
GuidelineCommand,
GuidelineListCommand,
GuidelineShowCommand,
GuidelineEnableCommand,
GuidelineDisableCommand,
GuidelineCreateCommand,
GuidelineRemoveCommand,
TreeCommand,
QuickCommand,
SkillMdValidateCommand,
SkillMdInitCommand,
SkillMdCheckCommand,
ServeCommand,
ScanCommand,
EvalCommand,
DoctorCommand,
SaveCommand,
AgentsMdCommand,
AgentsMdInitCommand,
AgentsMdSyncCommand,
AgentsMdShowCommand,
IssuePlanCommand,
IssueListCommand,
TimelineCommand,
SessionHandoffCommand,
LineageCommand,
TapAddCommand,
TapRemoveCommand,
TapListCommand,
} from '@skillkit/cli';
const __filename = fileURLToPath(import.meta.url);
@@ -135,9 +65,6 @@ const packageJsonPath = join(__dirname, '../package.json');
const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
const version = packageJson.version || '1.2.0';
setVersion(version);
setAgentCount(getAdapterCount());
const cli = new Cli({
binaryLabel: 'skillkit',
binaryName: 'skillkit',
@@ -184,12 +111,10 @@ cli.register(CommandCmd);
cli.register(AICommand);
cli.register(AuditCommand);
cli.register(PublishCommand);
cli.register(PublishSubmitCommand);
cli.register(AgentCommand);
cli.register(AgentListCommand);
cli.register(AgentShowCommand);
cli.register(AgentCreateCommand);
cli.register(AgentFromSkillCommand);
cli.register(AgentTranslateCommand);
cli.register(AgentSyncCommand);
cli.register(AgentValidateCommand);
@@ -202,86 +127,5 @@ cli.register(ManifestAddCommand);
cli.register(ManifestRemoveCommand);
cli.register(ManifestInstallCommand);
cli.register(ManifestGenerateCommand);
cli.register(PrimerCommand);
cli.register(MeshCommand);
cli.register(MessageCommand);
cli.register(WorkflowPipelineCommand);
cli.register(WorkflowPipelineListCommand);
cli.register(HookTemplateListCommand);
cli.register(HookTemplateApplyCommand);
cli.register(HookTemplateShowCommand);
cli.register(CommandAvailableCommand);
cli.register(CommandInstallCommand);
cli.register(AgentInstallCommand);
cli.register(AgentAvailableCommand);
cli.register(LearnCommand);
cli.register(PatternStatusCommand);
cli.register(PatternFeedbackCommand);
cli.register(PatternApproveCommand);
cli.register(PatternRejectCommand);
cli.register(PatternExportCommand);
cli.register(PatternImportCommand);
cli.register(PatternClusterCommand);
cli.register(SessionCommand);
cli.register(SessionStatusCommand);
cli.register(SessionStartCommand);
cli.register(SessionLoadCommand);
cli.register(SessionListCommand);
cli.register(SessionNoteCommand);
cli.register(SessionCompleteCommand);
cli.register(SessionInProgressCommand);
cli.register(SessionSnapshotSaveCommand);
cli.register(SessionSnapshotRestoreCommand);
cli.register(SessionSnapshotListCommand);
cli.register(SessionSnapshotDeleteCommand);
cli.register(SessionExplainCommand);
cli.register(ActivityCommand);
cli.register(ProfileCommand);
cli.register(ProfileListCommand);
cli.register(ProfileCreateCommand);
cli.register(ProfileRemoveCommand);
cli.register(GuidelineCommand);
cli.register(GuidelineListCommand);
cli.register(GuidelineShowCommand);
cli.register(GuidelineEnableCommand);
cli.register(GuidelineDisableCommand);
cli.register(GuidelineCreateCommand);
cli.register(GuidelineRemoveCommand);
cli.register(TreeCommand);
cli.register(QuickCommand);
cli.register(SkillMdValidateCommand);
cli.register(SkillMdInitCommand);
cli.register(SkillMdCheckCommand);
cli.register(ServeCommand);
cli.register(ScanCommand);
cli.register(EvalCommand);
cli.register(DoctorCommand);
cli.register(SaveCommand);
cli.register(AgentsMdCommand);
cli.register(AgentsMdInitCommand);
cli.register(AgentsMdSyncCommand);
cli.register(AgentsMdShowCommand);
cli.register(IssuePlanCommand);
cli.register(IssueListCommand);
cli.register(TimelineCommand);
cli.register(SessionHandoffCommand);
cli.register(LineageCommand);
cli.register(TapAddCommand);
cli.register(TapRemoveCommand);
cli.register(TapListCommand);
cli.runExit(process.argv.slice(2));
+3 -4
View File
@@ -1,7 +1,6 @@
// Re-export all public APIs from packages
export * from '@skillkit/core';
export * from '@skillkit/agents';
export async function startTUI(...args: unknown[]): Promise<unknown> {
const mod = await import('@skillkit/tui');
return mod.startTUI(...(args as Parameters<typeof mod.startTUI>));
}
// Re-export TUI entry point
export { startTUI } from '@skillkit/tui';
-3
View File
@@ -7,7 +7,4 @@ export default defineConfig({
splitting: false,
sourcemap: true,
clean: true,
platform: 'node',
target: 'node18',
skipNodeModulesBundle: true,
});
-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="84" height="28" viewBox="0 0 84 28" role="img">
<clipPath id="c"><rect width="84" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="56" height="28" fill="#18181b"/>
<rect x="56" width="28" height="28" fill="#09090b"/>
<rect x="0.5" y="0.5" width="83" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="28" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">agents</text>
<text x="70" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#fafafa" letter-spacing="0.3">46</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 804 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="93" height="28" viewBox="0 0 93 28" role="img">
<rect x="0.5" y="0.5" width="92" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#a78bfa"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">community</text>
</svg>

Before

Width:  |  Height:  |  Size: 454 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="78" height="28" viewBox="0 0 78 28" role="img">
<rect x="0.5" y="0.5" width="77" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#06b6d4"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">curated</text>
</svg>

Before

Width:  |  Height:  |  Size: 452 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="119" height="28" viewBox="0 0 119 28" role="img">
<clipPath id="c"><rect width="119" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="98" height="28" fill="#18181b"/>
<rect x="98" width="21" height="28" fill="#22c55e"/>
<rect x="0.5" y="0.5" width="118" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="49" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">deprecations</text>
<text x="108.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#000" letter-spacing="0.3">0</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 813 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="107" height="28" viewBox="0 0 107 28" role="img">
<rect x="0.5" y="0.5" width="106" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#3b82f6"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">every agent</text>
</svg>

Before

Width:  |  Height:  |  Size: 459 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="91" height="28" viewBox="0 0 91 28" role="img">
<clipPath id="c"><rect width="91" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="63" height="28" fill="#18181b"/>
<rect x="63" width="28" height="28" fill="#22c55e"/>
<rect x="0.5" y="0.5" width="90" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="31.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">install</text>
<text x="77" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#000" letter-spacing="0.3">9s</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 804 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="147" height="28" viewBox="0 0 147 28" role="img">
<clipPath id="c"><rect width="147" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="63" height="28" fill="#18181b"/>
<rect x="63" width="84" height="28" fill="#09090b"/>
<rect x="0.5" y="0.5" width="146" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="31.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">license</text>
<text x="105" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#fafafa" letter-spacing="0.3">Apache-2.0</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 820 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="50" height="28" viewBox="0 0 50 28" role="img">
<rect x="0.5" y="0.5" width="49" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#22c55e"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">new</text>
</svg>

Before

Width:  |  Height:  |  Size: 448 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="84" height="28" viewBox="0 0 84 28" role="img">
<clipPath id="c"><rect width="84" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="42" height="28" fill="#18181b"/>
<rect x="42" width="42" height="28" fill="#09090b"/>
<rect x="0.5" y="0.5" width="83" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="21" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">node</text>
<text x="63" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#fafafa" letter-spacing="0.3">>=18</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 804 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="86" height="28" viewBox="0 0 86 28" role="img">
<rect x="0.5" y="0.5" width="85" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#f59e0b"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">official</text>
</svg>

Before

Width:  |  Height:  |  Size: 453 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="93" height="28" viewBox="0 0 93 28" role="img">
<rect x="0.5" y="0.5" width="92" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#3b82f6"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">one skill</text>
</svg>

Before

Width:  |  Height:  |  Size: 454 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="107" height="28" viewBox="0 0 107 28" role="img">
<rect x="0.5" y="0.5" width="106" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#f472b6"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">open source</text>
</svg>

Before

Width:  |  Height:  |  Size: 459 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="105" height="28" viewBox="0 0 105 28" role="img">
<clipPath id="c"><rect width="105" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="70" height="28" fill="#18181b"/>
<rect x="70" width="35" height="28" fill="#3b82f6"/>
<rect x="0.5" y="0.5" width="104" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="35" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">packages</text>
<text x="87.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#fff" letter-spacing="0.3">118</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 810 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="107" height="28" viewBox="0 0 107 28" role="img">
<rect x="0.5" y="0.5" width="106" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#22c55e"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">PRs welcome</text>
</svg>

Before

Width:  |  Height:  |  Size: 459 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="105" height="28" viewBox="0 0 105 28" role="img">
<clipPath id="c"><rect width="105" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="56" height="28" fill="#18181b"/>
<rect x="56" width="49" height="28" fill="#09090b"/>
<rect x="0.5" y="0.5" width="104" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="28" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">skills</text>
<text x="80.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#fafafa" letter-spacing="0.3">400K+</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 813 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="114" height="28" viewBox="0 0 114 28" role="img">
<rect x="0.5" y="0.5" width="113" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#3b82f6"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">slim install</text>
</svg>

Before

Width:  |  Height:  |  Size: 460 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="91" height="28" viewBox="0 0 91 28" role="img">
<clipPath id="c"><rect width="91" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="63" height="28" fill="#18181b"/>
<rect x="63" width="28" height="28" fill="#09090b"/>
<rect x="0.5" y="0.5" width="90" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="31.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">sources</text>
<text x="77" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#fafafa" letter-spacing="0.3">31</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 807 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="84" height="28" viewBox="0 0 84 28" role="img">
<clipPath id="c"><rect width="84" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="49" height="28" fill="#18181b"/>
<rect x="49" width="35" height="28" fill="#09090b"/>
<rect x="0.5" y="0.5" width="83" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="24.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">tests</text>
<text x="66.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#fafafa" letter-spacing="0.3">757</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 808 B

-5
View File
@@ -1,5 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="78" height="28" viewBox="0 0 78 28" role="img">
<rect x="0.5" y="0.5" width="77" height="27" rx="4" ry="4" fill="#09090b" stroke="#3f3f46"/>
<rect x="0" y="0" width="4" height="28" fill="#3b82f6"/>
<text x="18" y="18" text-anchor="start" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="600" fill="#fafafa" letter-spacing="0.3">v1.24.0</text>
</svg>

Before

Width:  |  Height:  |  Size: 452 B

-10
View File
@@ -1,10 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="70" height="28" viewBox="0 0 70 28" role="img">
<clipPath id="c"><rect width="70" height="28" rx="4" ry="4"/></clipPath>
<g clip-path="url(#c)">
<rect width="49" height="28" fill="#18181b"/>
<rect x="49" width="21" height="28" fill="#22c55e"/>
<rect x="0.5" y="0.5" width="69" height="27" fill="none" stroke="#3f3f46" rx="4" ry="4"/>
<text x="24.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="500" fill="#a1a1aa" letter-spacing="0.3">vulns</text>
<text x="59.5" y="18" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="12" font-weight="700" fill="#000" letter-spacing="0.3">0</text>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 803 B

-42
View File
@@ -1,42 +0,0 @@
[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"
[project]
name = "skillkit-client"
version = "0.1.0"
description = "Python client for the SkillKit REST API"
readme = "README.md"
license = "Apache-2.0"
requires-python = ">=3.9"
authors = [
{ name = "Rohit Ghumare", email = "ghumare64@gmail.com" },
]
keywords = ["skillkit", "ai", "agents", "skills", "discovery"]
classifiers = [
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development :: Libraries",
]
dependencies = [
"httpx>=0.27",
"pydantic>=2.0",
]
[project.optional-dependencies]
dev = [
"pytest>=7.0",
"pytest-asyncio>=0.23",
"respx>=0.21",
]
[project.urls]
Homepage = "https://github.com/rohitg00/skillkit"
Documentation = "https://skillkit.sh"
Repository = "https://github.com/rohitg00/skillkit"
-12
View File
@@ -1,12 +0,0 @@
from skillkit.client import SkillKitClient
from skillkit.models import Skill, SearchResponse, HealthResponse, CacheStats, Category
__all__ = [
"SkillKitClient",
"Skill",
"SearchResponse",
"HealthResponse",
"CacheStats",
"Category",
]
__version__ = "0.1.0"
-140
View File
@@ -1,140 +0,0 @@
from __future__ import annotations
from typing import Optional
from urllib.parse import quote
import httpx
from skillkit.models import (
CacheStats,
CategoriesResponse,
Category,
HealthResponse,
SearchResponse,
Skill,
TrendingResponse,
)
class SkillKitClient:
def __init__(self, base_url: str = "http://localhost:3737", timeout: float = 30.0):
self.base_url = base_url.rstrip("/")
self.timeout = timeout
self._client: Optional[httpx.AsyncClient] = None
async def __aenter__(self) -> "SkillKitClient":
self._client = httpx.AsyncClient(base_url=self.base_url, timeout=self.timeout)
return self
async def __aexit__(self, *args: object) -> None:
if self._client:
await self._client.aclose()
self._client = None
def _get_client(self) -> httpx.AsyncClient:
if self._client is None:
self._client = httpx.AsyncClient(base_url=self.base_url, timeout=self.timeout)
return self._client
async def health(self) -> HealthResponse:
client = self._get_client()
response = await client.get("/health")
response.raise_for_status()
data = response.json()
return HealthResponse(
status=data["status"],
version=data["version"],
skill_count=data.get("skillCount", 0),
uptime=data.get("uptime", 0),
)
async def search(
self,
query: str,
limit: int = 20,
include_content: bool = False,
) -> SearchResponse:
client = self._get_client()
params = {"q": query, "limit": str(limit)}
if include_content:
params["include_content"] = "true"
response = await client.get("/search", params=params)
response.raise_for_status()
data = response.json()
return SearchResponse(
skills=[Skill(**s) for s in data["skills"]],
total=data["total"],
query=data["query"],
limit=data["limit"],
)
async def search_with_filters(
self,
query: str,
limit: int = 20,
include_content: bool = False,
tags: Optional[list[str]] = None,
category: Optional[str] = None,
source: Optional[str] = None,
) -> SearchResponse:
client = self._get_client()
body: dict = {"query": query, "limit": limit, "include_content": include_content}
filters: dict = {}
if tags:
filters["tags"] = tags
if category:
filters["category"] = category
if source:
filters["source"] = source
if filters:
body["filters"] = filters
response = await client.post("/search", json=body)
response.raise_for_status()
data = response.json()
return SearchResponse(
skills=[Skill(**s) for s in data["skills"]],
total=data["total"],
query=data["query"],
limit=data["limit"],
)
async def get_skill(self, source: str, skill_id: str) -> Skill:
client = self._get_client()
parts = source.split("/", 1)
owner = quote(parts[0], safe="")
repo = quote(parts[1], safe="") if len(parts) > 1 else owner
response = await client.get(f"/skills/{owner}/{repo}/{quote(skill_id, safe='')}")
response.raise_for_status()
return Skill(**response.json())
async def trending(self, limit: int = 20) -> list[Skill]:
client = self._get_client()
response = await client.get("/trending", params={"limit": str(limit)})
response.raise_for_status()
data = response.json()
return [Skill(**s) for s in data["skills"]]
async def categories(self) -> list[Category]:
client = self._get_client()
response = await client.get("/categories")
response.raise_for_status()
data = response.json()
return [Category(**c) for c in data["categories"]]
async def cache_stats(self) -> CacheStats:
client = self._get_client()
response = await client.get("/cache/stats")
response.raise_for_status()
data = response.json()
return CacheStats(
hits=data["hits"],
misses=data["misses"],
size=data["size"],
max_size=data.get("maxSize", 0),
hit_rate=data.get("hitRate", 0.0),
)
async def close(self) -> None:
if self._client:
await self._client.aclose()
self._client = None
-51
View File
@@ -1,51 +0,0 @@
from typing import Optional
from pydantic import BaseModel
class Skill(BaseModel):
name: str
description: Optional[str] = None
source: str
repo: Optional[str] = None
tags: Optional[list[str]] = None
category: Optional[str] = None
content: Optional[str] = None
stars: Optional[int] = None
installs: Optional[int] = None
class SearchResponse(BaseModel):
skills: list[Skill]
total: int
query: str
limit: int
class HealthResponse(BaseModel):
status: str
version: str
skill_count: int = 0
uptime: int = 0
class CacheStats(BaseModel):
hits: int
misses: int
size: int
max_size: int = 0
hit_rate: float = 0.0
class Category(BaseModel):
name: str
count: int
class CategoriesResponse(BaseModel):
categories: list[Category]
total: int
class TrendingResponse(BaseModel):
skills: list[Skill]
limit: int
View File
-99
View File
@@ -1,99 +0,0 @@
import pytest
import httpx
import respx
from skillkit import SkillKitClient
BASE_URL = "http://localhost:3737"
@pytest.fixture
def mock_api():
with respx.mock(base_url=BASE_URL) as respx_mock:
yield respx_mock
@pytest.mark.asyncio
async def test_health(mock_api):
mock_api.get("/health").respond(
json={"status": "ok", "version": "1.11.0", "skillCount": 100, "uptime": 60}
)
async with SkillKitClient(BASE_URL) as client:
health = await client.health()
assert health.status == "ok"
assert health.version == "1.11.0"
assert health.skill_count == 100
@pytest.mark.asyncio
async def test_search(mock_api):
mock_api.get("/search").respond(
json={
"skills": [{"name": "react-perf", "source": "owner/repo"}],
"total": 1,
"query": "react",
"limit": 20,
}
)
async with SkillKitClient(BASE_URL) as client:
result = await client.search("react")
assert result.total == 1
assert result.skills[0].name == "react-perf"
@pytest.mark.asyncio
async def test_search_with_filters(mock_api):
mock_api.post("/search").respond(
json={
"skills": [{"name": "nextjs-auth", "source": "other/repo"}],
"total": 1,
"query": "auth",
"limit": 20,
}
)
async with SkillKitClient(BASE_URL) as client:
result = await client.search_with_filters("auth", tags=["nextjs"])
assert result.total == 1
@pytest.mark.asyncio
async def test_get_skill(mock_api):
mock_api.get("/skills/owner/repo/react-perf").respond(
json={"name": "react-perf", "description": "React performance", "source": "owner/repo"}
)
async with SkillKitClient(BASE_URL) as client:
skill = await client.get_skill("owner/repo", "react-perf")
assert skill.name == "react-perf"
@pytest.mark.asyncio
async def test_trending(mock_api):
mock_api.get("/trending").respond(
json={"skills": [{"name": "a", "source": "x/y"}], "limit": 20}
)
async with SkillKitClient(BASE_URL) as client:
trending = await client.trending()
assert len(trending) == 1
@pytest.mark.asyncio
async def test_categories(mock_api):
mock_api.get("/categories").respond(
json={"categories": [{"name": "react", "count": 5}], "total": 1}
)
async with SkillKitClient(BASE_URL) as client:
cats = await client.categories()
assert len(cats) == 1
assert cats[0].name == "react"
@pytest.mark.asyncio
async def test_cache_stats(mock_api):
mock_api.get("/cache/stats").respond(
json={"hits": 10, "misses": 5, "size": 8, "maxSize": 500, "hitRate": 0.667}
)
async with SkillKitClient(BASE_URL) as client:
stats = await client.cache_stats()
assert stats.hits == 10
assert stats.size == 8
-7
View File
@@ -1,7 +0,0 @@
node_modules/
.next/
.source/
out/
.turbo/
*.tsbuildinfo
.vercel
-2
View File
@@ -1,2 +0,0 @@
../../turbo.json
../../pnpm-workspace.yaml
-43
View File
@@ -1,43 +0,0 @@
# SkillKit Documentation
Fumadocs-based documentation for SkillKit.
## Development
```bash
cd docs/fumadocs
pnpm install
pnpm dev
```
Open [http://localhost:3000](http://localhost:3000).
## Build
```bash
pnpm build
```
## Structure
```text
docs/fumadocs/
├── content/docs/ # MDX documentation files
├── src/
│ ├── app/ # Next.js app router
│ ├── lib/ # Components and utilities
│ └── mdx-components.tsx
├── package.json
└── source.config.ts
```
## Adding Pages
1. Create `.mdx` file in `content/docs/`
2. Add frontmatter with `title` and `description`
3. Add page to `content/docs/meta.json`
## Custom Components
- `<Card>` - Link cards with icons
- `<Columns>` - Grid layout (2-4 columns)
-83
View File
@@ -1,83 +0,0 @@
---
title: Supported Agents
description: 45 AI coding agents supported by SkillKit
---
# Supported Agents
SkillKit uses an adapter pattern to support 45 AI coding platforms. Each adapter implements `getConfigPath()` and `generateConfig()` methods.
## Agent Directory Mapping
| Agent | Directory | Format |
|-------|-----------|--------|
| Claude Code | `.claude/skills/` | SKILL.md |
| Cursor | `.cursor/skills/` | .mdc |
| Codex | `.codex/skills/` | SKILL.md |
| Gemini CLI | `.gemini/skills/` | SKILL.md |
| OpenCode | `.opencode/skills/` | SKILL.md |
| GitHub Copilot | `.github/skills/` | Markdown |
| Windsurf | `.windsurf/skills/` | Markdown |
| Antigravity | `.antigravity/skills/` | SKILL.md |
| Amp | `.amp/skills/` | SKILL.md |
| Clawdbot | `.clawdbot/skills/` (alt: `skills/`) | SKILL.md |
| Droid (Factory) | `.factory/skills/` | SKILL.md |
| Goose | `.goose/skills/` | SKILL.md |
| Kilo Code | `.kilocode/skills/` | SKILL.md |
| Kiro CLI | `.kiro/skills/` | SKILL.md |
| Roo Code | `.roo/skills/` | SKILL.md |
| Trae | `.trae/skills/` | SKILL.md |
| Cline | `.cline/skills/` | SKILL.md |
| CodeBuddy | `.codebuddy/skills/` | SKILL.md |
| CommandCode | `.commandcode/skills/` | SKILL.md |
| Continue | `.continue/skills/` | SKILL.md |
| Crush | `.crush/skills/` | SKILL.md |
| Factory | `.factory/skills/` | SKILL.md |
| MCPJam | `.mcpjam/skills/` | SKILL.md |
| Mux | `.mux/skills/` | SKILL.md |
| Neovate | `.neovate/skills/` | SKILL.md |
| OpenHands | `.openhands/skills/` | SKILL.md |
| Pi | `.pi/skills/` | SKILL.md |
| Qoder | `.qoder/skills/` | SKILL.md |
| Qwen | `.qwen/skills/` | SKILL.md |
| Vercel | `.vercel/skills/` | SKILL.md |
| Zencoder | `.zencoder/skills/` | SKILL.md |
| Devin | `.devin/skills/` | Markdown |
| Aider | `.aider/skills/` | SKILL.md |
| Sourcegraph Cody | `.cody/skills/` | SKILL.md |
| Amazon Q Developer | `.amazonq/skills/` | SKILL.md |
| Augment Code | `.augment/skills/` | SKILL.md |
| Replit Agent | `.replit/skills/` | Markdown |
| Bolt | `.bolt/skills/` | Markdown |
| Lovable | `.lovable/skills/` | Markdown |
| Tabby | `.tabby/skills/` | SKILL.md |
| Tabnine | `.tabnine/skills/` | SKILL.md |
| CodeGPT | `.codegpt/skills/` | SKILL.md |
| PlayCode Agent | `.playcode/skills/` | Markdown |
| Universal | `skills/` | SKILL.md |
## Translation System
```
Universal Format (SKILL.md)
↓
Adapter Interface
↓
Agent-Specific Formats (.mdc, JSON, Markdown)
```
## Agent Commands
```bash
skillkit agent list # List installed agents
skillkit agent show <name> # Show agent details
skillkit agent translate --to cursor # Translate to format
skillkit agent sync # Sync to target agent
```
## Multi-Agent Installation
```bash
# Install for multiple agents
skillkit install anthropics/skills --agent claude-code,cursor,windsurf
```
@@ -1,422 +0,0 @@
---
title: API Reference
description: Core package API for programmatic skill management
---
# API Reference
The `@skillkit/core` package provides the foundational business logic with zero internal dependencies.
## Installation
```bash
npm install @skillkit/core
```
## Module Exports
| Entry Point | Purpose |
|-------------|---------|
| `@skillkit/core` | Main exports |
| `@skillkit/core/types` | Type definitions |
| `@skillkit/core/discovery` | Skill discovery |
| `@skillkit/core/parser` | SKILL.md parsing |
| `@skillkit/core/translator` | Format translation |
| `@skillkit/core/context` | Project context |
| `@skillkit/core/recommend` | Recommendation engine |
## Skill Discovery
```typescript
import { findAllSkills, findSkill } from '@skillkit/core/discovery'
// Find all skills in directory
const skills = await findAllSkills('./my-project')
// Find specific skill
const skill = await findSkill('react-patterns')
```
## Quality Evaluation
```typescript
import { evaluateSkillContent, getQualityGrade } from '@skillkit/core'
const score = evaluateSkillContent(skillContent)
// { total: 85, structure: 22, clarity: 25, specificity: 28, advanced: 10 }
const grade = getQualityGrade(score.total)
// 'B'
```
**Dimensions (weights out of 100):**
- Structure (25): Frontmatter, sections
- Clarity (30): Descriptions, examples
- Specificity (30): Actionable steps
- Advanced (15): Tests, versioning
## Translation
```typescript
import { translateSkill } from '@skillkit/core/translator'
const result = await translateSkill(skillContent, 'cursor')
// { content: '...', filename: 'skill.mdc' }
```
## Memory System
```typescript
import { MemoryCompressor, LearningStore } from '@skillkit/core'
// Compress observations
const compressor = new MemoryCompressor()
const learning = await compressor.compress(observations)
// Store and search
const store = new LearningStore()
await store.add(learning)
const results = await store.search('authentication')
```
## Recommendation Engine
```typescript
import { RecommendationEngine, analyzeProject } from '@skillkit/core/recommend'
const engine = new RecommendationEngine()
const profile = await analyzeProject('./my-project')
const recommendations = engine.recommend(profile)
// Recommendations with scores and reasons
recommendations.forEach(rec => {
console.log(`${rec.score}% - ${rec.skill.name}`)
console.log(`Reasons: ${rec.reasons.join(', ')}`)
})
```
## Primer (Auto-Generate Instructions)
```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)
}
```
## Mesh Network
```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)
})
```
## Inter-Agent Messaging
```typescript
import { MessagingClient } from '@skillkit/messaging'
// Create messaging client (host is a MeshHost instance from the example above)
const messaging = new MessagingClient({
meshHost: host, // See MeshHost setup in "Mesh Network" section above
storagePath: '~/.skillkit/messages',
})
await messaging.init()
// Send a message
await messaging.send({
to: 'claude@laptop',
subject: 'Code review completed',
body: 'I reviewed the auth module...',
priority: 'normal',
})
// Listen for new messages
messaging.on('message', (msg) => {
console.log('New message from:', msg.from)
console.log('Subject:', msg.subject)
})
// Get inbox
const inbox = await messaging.getInbox({ unread: true })
```
## Workflow Orchestration
```typescript
import { WorkflowEngine, WorkflowStep } from '@skillkit/core'
// Define workflow
const workflow = {
name: 'feature-development',
steps: [
{ skill: 'tdd-workflow', action: 'write-tests' },
{ skill: 'code-implementation', action: 'implement' },
{ skill: 'code-review', action: 'review' },
{ skill: 'documentation', action: 'update-docs' },
],
}
// Execute workflow
const engine = new WorkflowEngine()
const result = await engine.run(workflow)
console.log('Workflow completed:', result.status)
console.log('Steps executed:', result.steps.length)
```
## Skill Testing
```typescript
import { SkillTestRunner, SkillTest } from '@skillkit/core'
// Define test
const test: SkillTest = {
name: 'pdf-processing',
setup: async () => {
// Setup test environment
},
assertions: [
{
type: 'file_exists',
path: './output.pdf',
},
{
type: 'content_includes',
text: 'Expected content',
},
],
}
// Run test
const runner = new SkillTestRunner()
const result = await runner.run(test)
console.log('Test passed:', result.passed)
console.log('Assertions:', result.assertions)
```
## Types
```typescript
interface Skill {
name: string
description: string
path: string
content: string
metadata: SkillMetadata
enabled: boolean
agent: string
}
interface SkillMetadata {
version?: string
author?: string
tags?: string[]
dependencies?: string[]
quality?: QualityScore
}
interface QualityScore {
total: number // 0-100
structure: number // 0-25
clarity: number // 0-30
specificity: number // 0-30
advanced: number // 0-15
}
interface Recommendation {
skill: Skill
score: number
reasons: string[]
}
interface ProjectAnalysis {
techStack: {
framework?: string
language: string
styling?: string
testing?: string
packageManager: string
}
patterns: {
architecture: string
codeStyle: Record<string, any>
directory: string
}
dependencies: Record<string, string>
}
interface MeshMessage {
from: string
to: string
type: string
payload: any
timestamp: number
signature?: string
}
interface WorkflowResult {
status: 'success' | 'failure'
steps: WorkflowStepResult[]
duration: number
}
```
## Package Exports
### @skillkit/core
```typescript
export {
// Discovery
findAllSkills,
findSkill,
// Quality
evaluateSkillContent,
getQualityGrade,
// Translation
translateSkill,
// Memory
MemoryCompressor,
LearningStore,
// Recommendations
RecommendationEngine,
analyzeProject,
// Primer
generateInstructions,
// Workflows
WorkflowEngine,
// Testing
SkillTestRunner,
}
```
### @skillkit/mesh
```typescript
export {
MeshHost,
PeerIdentity,
PeerRegistry,
SecureTransport,
}
```
### @skillkit/messaging
```typescript
export {
MessagingClient,
MessageBuilder,
MessageRouter,
}
```
### @skillkit/memory
```typescript
export {
MemoryStore,
TierManager,
EmbeddingEncoder,
}
```
## Full Example: Custom Build Pipeline
```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()
```
## Next Steps
- [Commands Reference](/docs/commands) - CLI commands
- [Memory System](/docs/memory) - Persistent learning
- [Mesh Network](/docs/mesh) - Multi-machine setup
- [Workflows](/docs/workflows) - Automation
- [Testing](/docs/testing) - Skill validation
@@ -1,121 +0,0 @@
---
title: Chrome Extension
description: Save any webpage as an AI agent skill from your browser
---
# Chrome Extension
Save any webpage as a SKILL.md directly from your browser.
## Install
1. Download the extension from the [releases page](https://github.com/rohitg00/skillkit/releases)
2. Open `chrome://extensions` in Chrome
3. Enable "Developer mode" (top right)
4. Click "Load unpacked" and select the `packages/extension/dist/` folder
Or build from source:
```bash
git clone https://github.com/rohitg00/skillkit.git
cd skillkit
pnpm install && pnpm --filter @skillkit/extension build
```
Then load `packages/extension/dist/` as an unpacked extension.
## Usage
### Popup
1. Navigate to any webpage
2. Click the SkillKit extension icon
3. Optionally enter a custom skill name
4. Click **Save as Skill**
The extension sends the page URL to the SkillKit API, which extracts the content as markdown, generates tags using weighted 5-source analysis, and returns a complete SKILL.md. The file downloads to your `Downloads/skillkit-skills/` folder.
### Context Menu
Right-click on any page:
- **Save page as Skill** — sends the URL to the API, downloads the result
- **Save selection as Skill** — builds the skill locally from selected text (no network request)
### Making Skills Available to Agents
After downloading, install the skill so all agents can use it:
```bash
skillkit install ~/Downloads/skillkit-skills/my-skill
```
Or copy directly:
```bash
cp -r ~/Downloads/skillkit-skills/my-skill ~/.skillkit/skills/
skillkit sync
```
## How It Works
```
Extension → POST /api/save-skill { url } → Server pipeline → Download
```
1. **Popup** reads the current tab's URL and title via `activeTab` permission. No content script injection needed.
2. **Background service worker** sends the URL to `skillkit.sh/api/save-skill` (or `agenstskills.com/api/save-skill`):
- Server fetches the page and converts HTML to markdown via Turndown
- GitHub URLs are auto-converted to raw content
- Tags are detected from 5 weighted sources (URL segments, headings, code blocks, keywords, language)
- Returns a complete SKILL.md with YAML frontmatter
3. **Download** — the service worker creates a blob and saves via `chrome.downloads` API.
4. **Selection saves** work entirely offline — Chrome natively provides `selectionText` via the context menu API, so the skill is built locally with no server round-trip.
## Permissions
| Permission | Why |
|-----------|-----|
| `contextMenus` | Right-click "Save as Skill" menu items |
| `activeTab` | Access current page URL and title on click |
| `downloads` | Save SKILL.md files to disk |
No `host_permissions` or `scripting` permissions needed. Only the page URL is sent to the server — no page content, browsing history, or personal data.
## Generated SKILL.md Format
```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...
```
## Building from Source
The extension uses tsup to bundle TypeScript into IIFE format for browser compatibility:
```bash
pnpm --filter @skillkit/extension build
```
Output goes to `packages/extension/dist/` with:
- `background.global.js` — Service worker (~4KB)
- `popup.global.js` — Popup UI logic (~2KB)
- `popup.html` + `popup.css` — Monochromatic UI
- `manifest.json` — Chrome Manifest V3
- `icons/` — 16/48/128px PNG icons
-65
View File
@@ -1,65 +0,0 @@
---
title: CI/CD
description: Integrate SkillKit into CI/CD pipelines
---
# CI/CD Integration
Generate templates for automated skill management.
## Generate Templates
```bash
skillkit cicd init --provider github
skillkit cicd init --provider gitlab
skillkit cicd init --provider circleci
```
## GitHub Actions
```yaml
name: SkillKit
on: [push, pull_request]
jobs:
validate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: '20'
- run: npm install -g skillkit
- run: skillkit validate
- run: skillkit test --json > results.json
```
## GitLab CI
```yaml
validate-skills:
image: node:20
script:
- npm install -g skillkit
- skillkit validate
- skillkit test
```
## Pre-commit
```yaml
repos:
- repo: local
hooks:
- id: skillkit-validate
name: Validate Skills
entry: skillkit validate
language: system
```
## Best Practices
- Validate on PR
- Test in CI with `--json`
- Sync only on main branch
- Cache npm packages
-621
View File
@@ -1,621 +0,0 @@
---
title: CLI Commands
description: Complete reference for all SkillKit CLI commands
---
# CLI Commands
SkillKit provides 50+ commands organized into functional categories. Built on Clipanion v4 with interactive prompts via @clack/prompts.
## Global Options
| Option | Short | Purpose |
|--------|-------|---------|
| `--help` | `-h` | Display command help |
| `--version` | `-v` | Show version info |
| `--quiet` | `-q` | Minimal output, no logo |
## Install Command
Install skills from GitHub, GitLab, Bitbucket, or local paths.
```bash
skillkit install <source> [options]
```
### Source Formats
| Format | Example |
|--------|---------|
| GitHub | `owner/repo` or full URL |
| GitLab | `gitlab:owner/repo` |
| Bitbucket | `bitbucket:owner/repo` |
| Local Path | `./path` or `~/path` |
### Install Options
| Option | Short | Type | Purpose |
|--------|-------|------|---------|
| `--skills` | `-s` | string | Comma-separated skill names |
| `--all` | `-a` | boolean | Install all discovered skills |
| `--yes` | `-y` | boolean | Skip confirmation prompts |
| `--global` | `-g` | boolean | Install to global directory |
| `--force` | `-f` | boolean | Overwrite existing skills |
| `--provider` | `-p` | string | Force provider: GitHub, GitLab, Bitbucket |
| `--list` | `-l` | boolean | List available skills without installing |
| `--agent` | — | array | Target specific agents (repeatable) |
### Examples
```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
```
## Remove Command
```bash
skillkit remove <skill-names> [options]
```
| Option | Short | Purpose |
|--------|-------|---------|
| `--agent` | — | Target specific agents (default: all) |
| `--yes` | — | Skip confirmation |
| `--keep-metadata` | — | Remove skill but preserve metadata |
| `--source` | `-s` | Remove all skills installed from a specific source |
| `--all` | `-a` | Remove all installed skills |
| `--force` | `-f` | Skip confirmation prompt |
### Bulk Removal
```bash
skillkit remove --source iii-hq/iii
skillkit remove --all
skillkit remove --all --force
```
When using `--source`, SkillKit matches against the source field in each skill's metadata and removes every skill that was installed from that repository. When using `--all`, every discovered skill across all agent directories is removed. Both flags update AGENTS.md automatically if managed sections are present.
## Update Command
```bash
skillkit update [skill-names] [options]
```
| Option | Short | Purpose |
|--------|-------|---------|
| `--dry-run` | — | Check for updates without installing |
| `--yes` | — | Skip confirmation prompts |
| `--agent` | — | Update in specific agents only |
| `--force` | `-f` | Force update, bypass checksum and GitHub API checks |
The update command uses a two-stage change detection pipeline:
1. **GitHub API check** -- For remote sources, SkillKit queries the GitHub API to compare the repository's `pushed_at` timestamp against the installed metadata. If the repository has not been pushed since the last install or update, the skill is skipped without cloning.
2. **Checksum comparison** -- After cloning, a checksum of the source SKILL.md is compared against the stored checksum. If the content is identical, the update is skipped.
Use `--force` to bypass both checks and always overwrite the installed skill.
## Enable/Disable Commands
```bash
skillkit enable <skill-names> [options]
skillkit disable <skill-names> [options]
```
Disabled skills are ignored by the `sync` command. No file changes occur.
## Check Command
```bash
skillkit check [skill-names] [options]
```
Checks installed skills for available updates, quality scores, and GitHub activity.
| Option | Short | Purpose |
|--------|-------|---------|
| `--verbose` | `-v` | Show detailed output including stars and push dates |
| `--quiet` | `-q` | Minimal output |
For remote GitHub sources, the check command queries the GitHub API to compare each repository's `pushed_at` timestamp against the installed date. Each skill displays its quality score badge (A-F). In verbose mode, the output also includes the repository's star count and how recently it was pushed.
```bash
skillkit check
skillkit check pdf xlsx --verbose
```
## List Command
```bash
skillkit list [options]
```
Lists installed skills with quality grades.
## Sync Command
```bash
skillkit sync [options]
```
Synchronizes enabled skills to agent configuration files.
## Recommend Command
```bash
skillkit recommend [options]
```
AI-powered recommendations based on project analysis.
| Option | Purpose |
|--------|---------|
| `--search` | Task-based search |
| `--category` | Filter by category |
| `--min-score` | Quality threshold |
## Generate Command
AI-powered skill generation with multi-source context and agent optimization.
```bash
skillkit generate [options]
```
### Generate Options
| Option | Type | Purpose |
|--------|------|---------|
| `--provider` | string | LLM provider: anthropic, openai, google, ollama, openrouter |
| `--model` | string | Specific model (e.g., gpt-4o, gemini-2.0-flash) |
| `--compose` | string | Natural language search to find skills to compose |
| `--agents` | array | Target agents for optimization |
| `--no-memory` | boolean | Skip memory context |
| `--context-sources` | string | Comma-separated: docs,codebase,skills,memory |
### Context Sources
The wizard gathers context from 4 sources:
| Source | Description |
|--------|-------------|
| **Documentation** | Library docs via Context7 MCP |
| **Codebase** | Local project patterns and conventions |
| **Skills** | 15,000+ marketplace skills for composition |
| **Memory** | Your corrections and learned patterns |
### Examples
```bash
# Interactive wizard (recommended)
skillkit generate
# Use specific provider
skillkit generate --provider openai --model gpt-4o
# Compose from existing skills
skillkit generate --compose "testing patterns for react"
# Generate for specific agents
skillkit generate --agents claude-code,cursor
# Skip memory personalization
skillkit generate --no-memory
```
### Trust Score
Generated skills receive a trust score (0-10):
| Grade | Score | Meaning |
|-------|-------|---------|
| Trusted | 8-10 | High clarity, well-bounded |
| Review | 5-7 | May need refinement |
| Caution | 0-4 | Requires careful review |
### Agent Compatibility
The wizard shows compatibility scores for each target agent based on:
- Context length limits
- MCP/tool support
- Format requirements
## Marketplace Command
```bash
skillkit marketplace [options]
skillkit marketplace search <query>
```
Browse 15,000+ indexed skills from the aggregated catalog.
| Option | Purpose |
|--------|---------|
| `--tags` | Filter by tags |
| `--refresh` | Force refresh index |
## Manifest Commands
Team collaboration via Git-committable `.skills` file.
```bash
skillkit manifest init # Create .skills file
skillkit manifest add <source> # Add skill source
skillkit manifest install # Install from manifest
```
### Manifest File Format
```text
# GitHub skills
anthropics/skills
vercel-labs/agent-skills
# Local skills
./local-skills
# Specific versions
owner/repo@v1.2.3
```
## Memory Commands
```bash
skillkit memory status # View memory status
skillkit memory search <query> # Search learnings
skillkit memory compress # Compress observations to learnings
skillkit memory export <name> # Export learnings as skill
skillkit memory sync-claude # Update CLAUDE.md with learnings
skillkit memory index # View memory index (Layer 1)
skillkit memory --global # Use global memory
```
| Option | Purpose |
|--------|---------|
| `--global` | Use global memory instead of project |
| `--limit` | Limit number of results |
| `--tags` | Filter by tags |
## Translation Commands
```bash
skillkit translate <skill> --to <agent>
skillkit translate --all --to <agent>
skillkit translate <skill> --to <agent> --dry-run
```
## Agent Commands
```bash
skillkit agent list # List agents
skillkit agent show <name> # Show details
skillkit agent create <name> # Create agent
skillkit agent translate --source ./path --to cursor
skillkit agent translate --source ./path --to cursor --recursive
skillkit agent sync # Sync to target
skillkit agent validate # Validate definitions
```
## Context Commands
```bash
skillkit context init # Initialize project context
skillkit context sync # Sync context to agents
```
## Test Command
```bash
skillkit test [path] # Run skill tests
skillkit test --tags unit # Filter by tags
skillkit test --json # JSON output for CI
```
## Workflow Commands
```bash
skillkit workflow list # List workflows
skillkit workflow run <name> # Execute workflow
skillkit workflow create <name> # Create workflow
```
## CI/CD Commands
```bash
skillkit cicd github-action # Generate GitHub Actions
skillkit cicd gitlab-ci # Generate GitLab CI
skillkit cicd pre-commit # Generate pre-commit hooks
```
## Serve Command
Start the SkillKit REST API server for runtime skill discovery.
```bash
skillkit serve [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 |
## Issue Planner
Generate structured plans from GitHub Issues. Requires the `gh` CLI.
```bash
skillkit issue plan "#42" # Plan from current repo
skillkit issue plan rohitg00/skillkit#42 # Cross-repo
skillkit issue plan "#42" --agent cursor # Target specific agent
skillkit issue plan "#42" --no-tests # Skip test steps
skillkit issue plan "#42" --json # JSON output
skillkit issue plan "#42" --tech-stack react,ts # Override tech stack
```
### Issue Plan Options
| Option | Short | Default | Purpose |
|--------|-------|---------|---------|
| `--agent` | `-a` | `claude-code` | Target agent |
| `--output` | `-o` | `.skillkit/plans/issue-<n>.md` | Output file path |
| `--no-tests` | — | `false` | Skip test steps |
| `--json` | — | `false` | Output as JSON |
| `--tech-stack` | — | — | Comma-separated tech stack |
### Issue List
```bash
skillkit issue list # List open issues
skillkit issue list --repo owner/repo # Specific repo
skillkit issue list --label bug # Filter by label
skillkit issue list --limit 20 # More results
skillkit issue list --json # JSON output
```
The planner extracts task lists (checkboxes) from the issue body, infers file mentions from backtick-quoted paths, and maps labels to tags (e.g., `bug` → `fix`, `enhancement` → `feature`). Generated plans work with `skillkit plan validate` and `skillkit plan execute`.
## Session Intelligence
Track skill executions, generate handoff documents, and analyze skill impact.
### Timeline
View a unified chronological event stream of all session activity.
```bash
skillkit timeline # Last 50 events
skillkit timeline --type git_commit # Filter by event type
skillkit timeline --skill code-simplifier # Filter by skill
skillkit timeline --since 2026-02-10 # Date filter
skillkit timeline --limit 20 --json # JSON output
```
| Option | Short | Purpose |
|--------|-------|---------|
| `--type` | `-t` | Filter: skill_start, skill_complete, task_progress, git_commit, observation, decision, snapshot |
| `--skill` | `-s` | Filter events by skill name |
| `--since` | — | Show events since date (YYYY-MM-DD) |
| `--limit` | `-l` | Max events (default: 50) |
| `--json` | `-j` | JSON output |
### Session Handoff
Generate a structured context document for agent switching.
```bash
skillkit session handoff # Print markdown to stdout
skillkit session handoff --to cursor # Target agent recommendations
skillkit session handoff --out handoff.md # Save to file
skillkit session handoff --json # JSON output
```
| Option | Short | Purpose |
|--------|-------|---------|
| `--to` | — | Target agent for recommendations |
| `--out` | `-o` | Save to file path |
| `--json` | `-j` | JSON output |
### Lineage
Show which skills produced which code changes with aggregate impact stats.
```bash
skillkit lineage # Full overview
skillkit lineage --skill code-simplifier # Single skill
skillkit lineage --file src/index.ts # Single file
skillkit lineage --since 2026-02-01 --json # Date filter + JSON
```
| Option | Short | Purpose |
|--------|-------|---------|
| `--skill` | `-s` | Filter by skill name |
| `--file` | `-f` | Filter by file path |
| `--since` | — | Show lineage since date |
| `--limit` | `-l` | Max entries |
| `--json` | `-j` | JSON output |
## Utility Commands
```bash
skillkit init # Initialize project
skillkit create <name> # Create new skill
skillkit validate [path] # Validate skill format
skillkit read <skills> # Read skill content
skillkit settings --set key=value # Configure settings
```
## Publishing Commands
```bash
skillkit publish [path] # Generate well-known hosting structure
skillkit publish --output dir # Output to specific directory
skillkit publish --dry-run # Preview without writing
skillkit publish submit # Submit to SkillKit marketplace
```
### publish submit
Submits a skill to the SkillKit marketplace by creating a GitHub issue on `rohitg00/skillkit` via the `gh` CLI. No browser is needed.
Before submitting, the command displays:
- Quality score and grade (A-F) from the skill evaluator
- GitHub star count and last push date from the GitHub API
- Any quality warnings (up to 3)
If `gh` is not installed or not authenticated, the command prints a manual submission URL as a fallback.
## Tap Command
Manage custom skill sources (taps). Taps are user-level source repositories stored in `~/.skillkit/taps.json`. They let you add private or third-party skill repositories that are not part of the official marketplace.
### tap add
Add a custom skill source.
```bash
skillkit tap add owner/repo
skillkit tap add owner/repo --name "My Skills"
```
### tap remove
Remove a custom skill source.
```bash
skillkit tap remove owner/repo
```
### tap list
List all custom skill sources.
```bash
skillkit tap list
```
Once a tap is added, skills from that source appear in `skillkit marketplace search` results and can be installed with the standard `skillkit install owner/repo` workflow.
## Security Scanning
```bash
skillkit scan <path> # Scan skill for vulnerabilities
skillkit scan <path> --format json # Output as JSON
skillkit scan <path> --format table # Tabular output
skillkit scan <path> --format sarif # SARIF for GitHub Code Scanning
skillkit scan <path> --fail-on high # Exit 1 if HIGH+ findings
skillkit scan <path> --skip-rules UC001 # Skip specific rules
```
**Threat Categories:**
| Category | Description |
|----------|-------------|
| Prompt Injection | Override/bypass agent instructions |
| Command Injection | eval(), exec(), shell commands |
| Data Exfiltration | Webhook URLs, env var reads, credential access |
| Tool Abuse | Tool shadowing, autonomy escalation |
| Hardcoded Secrets | API keys, tokens, private keys |
| Unicode Steganography | Zero-width chars, bidi overrides |
**Install Integration:**
Skills are automatically scanned during `skillkit install`. Use `--no-scan` to skip, or `--force` to install despite findings.
**Output Formats:**
- `summary` (default) - colored terminal output
- `json` - machine-readable JSON
- `table` - tabular format
- `sarif` - SARIF v2.1 for GitHub Code Scanning / IDE integration
## Interactive TUI
```bash
skillkit ui # Launch terminal UI
skillkit # Same as above
```
**Navigation Keys:**
| Key | Action |
|-----|--------|
| `h` | Home |
| `b` | Browse |
| `m` | Marketplace |
| `r` | Recommend |
| `t` | Translate |
| `c` | Context |
| `i` | Installed |
| `s` | Sync |
| `/` | Help |
| `q` | Quit |
## Exit Codes
| Code | Meaning |
|------|---------|
| 0 | Success |
| 1 | General error |
| 2 | Invalid arguments |
| 3 | Configuration issue |
| 4 | Network problem |
| 5 | Filesystem error |
## Quality Grades
Skills receive automatic quality scores mapped to grades:
| Grade | Score Range |
|-------|-------------|
| A | 90-100 |
| B | 80-89 |
| C | 70-79 |
| D | 60-69 |
| F | Below 60 |
Skills with score below 60 trigger warning displays before installation.
@@ -1,267 +0,0 @@
---
title: Configuration
description: Configure SkillKit at project and user levels
---
# Configuration
SkillKit uses a layered configuration system with five priority levels (lowest to highest):
1. Default values in code
2. Global user preferences (`~/.skillkit/preferences.json`)
3. Project settings (`skillkit.yaml`)
4. Environment variables
5. CLI flags
## Project Configuration
Create `skillkit.yaml` in your project root:
```yaml
version: 1
agent: cursor # Override auto-detection
autoSync: true # Sync on changes
enabledSkills:
- pdf
- xlsx
- react-patterns
disabledSkills:
- deprecated-skill
skillsDir: ./custom-skills # Custom directory
sources: # Default sources
- anthropics/skills
- vercel-labs/agent-skills
```
## Manifest File
The `.skills` file enables Git-based team sharing:
```yaml
version: 1
skills:
- source: anthropics/skills
skills: [pdf, xlsx]
- source: vercel-labs/agent-skills
skills: [react-patterns]
```
Commands:
```bash
skillkit manifest init # Create .skills
skillkit manifest add <skill> # Add skill
skillkit manifest install # Install all
```
## User Preferences
Global preferences in `~/.skillkit/preferences.json`:
```json
{
"lastAgents": ["claude-code", "cursor"],
"defaultAgent": "claude-code",
"theme": "dark"
}
```
## Environment Variables
| Variable | Purpose |
|----------|---------|
| `SKILLKIT_AGENT` | Override default agent |
| `SKILLKIT_DIR` | Custom SkillKit directory |
| `SKILLKIT_DEBUG` | Enable debug logging |
## CLI Settings
```bash
skillkit settings --set agent=cursor
skillkit settings --set autoSync=true
skillkit settings --get agent
```
## Advanced Configuration
### Memory System
```yaml
# skillkit.yaml
memory:
enabled: true
tier: personal # personal, project, global
compression:
minObservations: 10 # Compress after N observations
autoExport: true # Auto-export as skills
storage:
backend: cozodb # cozodb, sqlite, memory
path: ~/.skillkit/memory
```
### Mesh Network
```yaml
# skillkit.yaml
mesh:
enabled: true
hostId: my-workstation
discovery:
method: local # local, tailscale, manual
port: 9876
security:
mode: secure # development, signed, secure, strict
keyPath: ~/.skillkit/mesh/keys
peers:
- id: laptop-dev
address: 192.168.1.100
trusted: true
```
### Messaging
```yaml
# skillkit.yaml
messaging:
enabled: true
storagePath: ~/.skillkit/messages
notifications: true
autoArchive:
enabled: true
afterDays: 30
```
### Primer
```yaml
# skillkit.yaml
primer:
autoGenerate: true # Generate on changes
agents:
priority: [claude, cursor, windsurf]
customize:
tone: detailed # concise, detailed, technical
includeExamples: true
exclude:
- node_modules
- dist
- .next
```
## Lock File
SkillKit maintains a centralized lock file at `~/.skillkit/lock.json` that tracks every installed skill. The lock file is written on install, updated on update, and cleaned on remove.
```json
{
"version": 1,
"skills": {
"pdf": {
"source": "anthropics/skills",
"checksum": "sha256:abc123...",
"agents": ["claude-code", "cursor"],
"installedAt": "2026-04-01T12:00:00Z",
"updatedAt": "2026-04-08T09:30:00Z"
}
}
}
```
| Field | Description |
|-------|-------------|
| `source` | The repository or local path the skill was installed from |
| `checksum` | SHA-256 hash of the SKILL.md content at install time, used for update detection |
| `agents` | Which agents the skill is installed for |
| `installedAt` | ISO timestamp of initial installation |
| `updatedAt` | ISO timestamp of the most recent update |
The `update` command compares the stored checksum against the source to skip unchanged skills. The `remove` command cleans up the corresponding lock entry.
## Taps File
Custom skill source repositories are stored in `~/.skillkit/taps.json`. Taps are managed via the `skillkit tap` commands.
```json
{
"version": 1,
"taps": [
{
"source": "myorg/internal-skills",
"name": "Internal Skills",
"addedAt": "2026-04-05T10:00:00Z"
}
]
}
```
Skills from tapped sources appear in marketplace search results and can be installed like any other source. See the [tap command](/docs/commands#tap-command) documentation for usage.
## Directory Structure
```
~/.skillkit/
├── preferences.json # User preferences
├── lock.json # Installed skill tracking
├── taps.json # Custom skill sources
├── cache/ # Marketplace cache
├── memory/ # Learning storage
│ ├── observations/
│ ├── learnings/
│ └── index.json
├── mesh/ # Mesh network
│ ├── keys/ # Encryption keys
│ ├── peers.json # Known peers
│ └── config.json
└── messages/ # Inter-agent messages
├── inbox/
├── sent/
└── archived/
./project/
├── skillkit.yaml # Project config
├── .skills # Team manifest
├── skills/ # Local skills
└── .skillkit/ # Project-specific
├── cache/
├── primer-config.json
└── memory/
```
## Configuration Profiles
Create different profiles for different environments:
```yaml
# skillkit.yaml
profiles:
development:
agent: claude
autoSync: true
mesh:
security:
mode: development
production:
agent: universal
autoSync: false
mesh:
security:
mode: strict
```
Use profiles:
```bash
skillkit --profile production sync
```
## Next Steps
- [Primer](/docs/primer) - Auto-generate instructions
- [Memory System](/docs/memory) - Persistent learning
- [Mesh Network](/docs/mesh) - Multi-machine setup
- [Team Collaboration](/docs/teams) - Team configuration
@@ -1,68 +0,0 @@
---
title: Contributing
description: Contribute to SkillKit development
---
# Contributing
## Setup
```bash
git clone https://github.com/rohitg00/skillkit.git
cd skillkit
pnpm install
pnpm build
pnpm test
```
## Requirements
- Node.js 18+
- pnpm 8+
- Bun 1.2+ (TUI)
## Project Structure
```
skillkit/
├── packages/
│ ├── core/ # Business logic
│ ├── cli/ # CLI
│ ├── tui/ # Terminal UI
│ └── agents/ # 45 adapters
├── marketplace/ # Skills data
│ ├── skills.json
│ └── sources.json
└── docs/
```
## Development
```bash
git checkout -b feat/my-feature
pnpm test
pnpm lint
pnpm build
```
## Code Style
- ES modules
- `function` keyword
- Explicit return types
- No unnecessary comments
- No nested ternaries
## Commits
```
feat: add feature
fix: resolve bug
docs: update docs
test: add tests
```
## Links
- [GitHub Issues](https://github.com/rohitg00/skillkit/issues)
- [GitHub Discussions](https://github.com/rohitg00/skillkit/discussions)
@@ -1,59 +0,0 @@
---
title: Custom Agents
description: Create custom AI sub-agent definitions
---
# Custom Agents
Create and manage custom AI sub-agents.
## Commands
```bash
skillkit agent list # List agents
skillkit agent show <name> # Show details
skillkit agent create <name> # Create agent
skillkit agent translate # Translate format
skillkit agent sync # Sync to target
skillkit agent validate # Validate
```
## Agent Definition
```yaml
name: my-agent
description: Custom agent for tasks
format: skill.md
skillsDir: .my-agent/skills/
capabilities:
- code-generation
- code-review
triggers:
- pattern: "create component"
action: generate-component
```
## Structure
```
.my-agent/
├── agent.yaml # Definition
├── skills/ # Agent skills
└── config/ # Settings
```
## Translation
```bash
skillkit agent translate --source ./my-agent --to cursor
skillkit agent translate --source ./agents --to cursor --recursive
```
## Validation
```bash
skillkit agent validate
skillkit agent validate ./my-agent
```
-178
View File
@@ -1,178 +0,0 @@
---
title: SkillKit
description: Universal skill management for AI coding agents
---
# SkillKit
Skills make AI coding agents smarter. But every agent uses a different format — Claude Code wants `.claude/skills/`, Cursor uses `.mdc`, Copilot expects `.github/skills/`. You end up rewriting the same skill three times, or locking into one platform.
SkillKit fixes this. Write a skill once, deploy it to all 45 agents.
## Get Started
```bash
npx skillkit@latest
```
That's it. No global install needed. Or if you prefer:
```bash
npm install -g skillkit
skillkit init
skillkit install anthropics/skills
skillkit sync
```
Four commands. Your agents now have skills for PDF processing, code review, and more.
## What Can You Do?
### Install skills from anywhere
```bash
skillkit install anthropics/skills # GitHub
skillkit install skills.sh/owner/repo/skill # skills.sh registry
skillkit install gitlab:team/skills # GitLab
skillkit install ./my-local-skills # Local
```
### Translate between agents
Write for Claude, deploy to Cursor:
```bash
skillkit translate my-skill --to cursor
skillkit translate --all --to windsurf # All skills at once
```
### Get smart recommendations
SkillKit reads your `package.json`, detects your stack, and suggests relevant skills:
```bash
skillkit recommend
# 92% vercel-react-best-practices
# 87% tailwind-v4-patterns
# 85% nextjs-app-router
```
### Discover skills at runtime
Start an API server and let agents find skills on demand:
```bash
skillkit serve
# Server running at http://localhost:3737
```
```bash
curl "http://localhost:3737/search?q=react+performance"
```
Or use MCP for native agent integration:
```json
{
"mcpServers": {
"skillkit": { "command": "npx", "args": ["@skillkit/mcp"] }
}
}
```
[REST API](/docs/rest-api) | [MCP Server](/docs/mcp-server) | [Python Client](/docs/python-client)
## How It Works
SkillKit sits between your skills and your agents. It handles format translation, discovery, and synchronization automatically.
| Layer | What It Does |
|-------|-------------|
| **CLI + TUI** | Install, translate, recommend, sync |
| **APIs** | REST server on :3737, MCP via stdio |
| **Core** | Translation engine, relevance ranker, skill parser |
| **Data** | 15,000+ skills from 31 curated sources |
## Supported Agents
45 agents and counting:
**Claude Code** | **Cursor** | **Codex** | **Gemini CLI** | **OpenCode** | **GitHub Copilot** | **Windsurf** | Amp | Antigravity | Clawdbot | Cline | CodeBuddy | CommandCode | Continue | Crush | Droid | Factory | Goose | Kilo Code | Kiro CLI | MCPJam | Mux | Neovate | OpenHands | Pi | Qoder | Qwen | Roo Code | Trae | Vercel | Zencoder | Universal
[Full agent details](/docs/agents)
### Security scanning
Every skill is scanned for threats before installation — prompt injection, hardcoded secrets, command injection, and more:
```bash
skillkit scan ./my-skill # 46+ detection rules
skillkit scan ./my-skill --format sarif # GitHub Code Scanning
skillkit scan ./my-skill --fail-on high # CI gate
```
[Security Scanner](/docs/security)
## Beyond Basic Skills
### Session Memory
Your AI agents learn patterns during sessions, then forget everything. SkillKit captures those learnings and makes them permanent.
```bash
skillkit memory compress
skillkit memory search "auth patterns"
skillkit memory export auth-patterns
```
### Session Intelligence
Track skill executions, generate handoff documents for agent switching, and view skill impact lineage:
```bash
skillkit timeline # Unified event stream
skillkit session handoff # Agent-to-agent context
skillkit lineage # Skill impact graph
```
### Primer
Auto-generate CLAUDE.md, .cursorrules, and agent instructions by analyzing your codebase:
```bash
skillkit primer --all-agents
```
### Mesh Network
Distribute agents across machines with encrypted P2P:
```bash
skillkit mesh init
skillkit mesh discover
```
### Team Collaboration
Share skills via a Git-committable `.skills` manifest:
```bash
skillkit manifest init
skillkit manifest add anthropics/skills
git commit -m "add team skills"
```
Team members run `skillkit manifest install` and they're in sync.
## Next Steps
- [Installation](/docs/installation) — Install and configure
- [Quick Start](/docs/quickstart) — First project setup
- [Methodology Packs](/docs/methodology) — Debugging, testing, planning skills
- [Security Scanner](/docs/security) — Threat detection for skills
- [Commands](/docs/commands) — Full CLI reference
- [REST API](/docs/rest-api) — Runtime discovery server
- [MCP Server](/docs/mcp-server) — Agent-native discovery
- [Python Client](/docs/python-client) — Python SDK
**Current version:** v1.19.2 | [npm](https://www.npmjs.com/package/skillkit) | [GitHub](https://github.com/rohitg00/skillkit) | Apache-2.0
-141
View File
@@ -1,141 +0,0 @@
---
title: Installation
description: Install SkillKit and set up your first project
---
# Installation
## No install needed
The fastest way to start:
```bash
npx skillkit@latest
```
This runs the latest version directly. No global install, no setup.
## Global install
For frequent use, install globally:
```bash
npm install -g skillkit
```
Also works with pnpm, yarn, or bun:
```bash
pnpm add -g skillkit
yarn global add skillkit
bun add -g skillkit
```
Both `skillkit` and `sk` work as command aliases.
## Full vs slim install
SkillKit ships four power features as **optional dependencies** so the
core install stays small. The default `npm install -g skillkit` installs
every feature; `--omit=optional` installs only the core CLI.
| Feature | Package | Command |
| ------------------------ | -------------------- | ------------------------------ |
| Interactive terminal UI | `@skillkit/tui` | `skillkit ui` / `skillkit tui` |
| REST/OpenAPI server | `@skillkit/api` | `skillkit serve` |
| Peer mesh networking | `@skillkit/mesh` | `skillkit mesh …` |
| Inter-agent messaging | `@skillkit/messaging`| `skillkit message …` |
```bash
# Full (default) — every feature works out of the box:
npm install -g skillkit
# Slim — core commands only, ~75% smaller, no native addons, 0 deprecation warnings:
npm install -g skillkit --omit=optional
```
Add one later:
```bash
npm install -g @skillkit/tui # enables: skillkit ui
npm install -g @skillkit/api # enables: skillkit serve
npm install -g @skillkit/mesh # enables: skillkit mesh
npm install -g @skillkit/messaging # enables: skillkit message
```
The CLI catches a missing optional feature and prints a one-line hint,
so you'll never see an unhandled stack trace.
## Using `npx`
`npx skillkit add <owner/repo>` runs without a global install. First run
downloads into the npx cache (`~/.npm/_npx/`); every call after that is
instant until the cache expires or a new version ships.
```bash
# Full — every feature works:
npx skillkit add anthropics/skills
# Slim — core commands only, 75% fewer packages, 0 warnings:
npx --omit=optional skillkit add anthropics/skills
```
If you use `npx skillkit` more than a couple of times, install globally
to skip the prompt-to-proceed and avoid the per-release cache refetch:
```bash
npm install -g skillkit --omit=optional
skillkit add anthropics/skills
```
## Verify
```bash
skillkit --version
```
**Requirements:** Node.js 18+ (Bun 1.2+ for the TUI).
## Initialize a project
```bash
cd my-project
skillkit init
```
The init command:
1. **Detects your AI agent** — scans for `.claude/`, `.cursor/`, `.github/` directories
2. **Creates the skills folder** — sets up the right directory for your agent
3. **Saves preferences** — remembers your choices for next time
### Specify an agent directly
```bash
skillkit init --agent cursor
skillkit init --list # Show all 45 supported agents
skillkit init --quiet # Skip logo and prompts (for CI)
```
### What gets created
| Agent | Skills Directory | Config |
|-------|-----------------|--------|
| Claude Code | `.claude/skills/` | `.claude/config.json` |
| Cursor | `.cursor/skills/` | `.cursor/config.mdc` |
| Codex | `.codex/skills/` | `AGENTS.md` |
| GitHub Copilot | `.github/skills/` | — |
| Universal | `skills/` | `AGENTS.md` |
Preferences are stored in `~/.skillkit/preferences.json`.
## Next steps
```bash
skillkit recommend # Get skill suggestions for your project
skillkit install anthropics/skills # Install skills from GitHub
skillkit sync # Deploy to your agent
skillkit ui # Launch the terminal UI
```
[Quick Start guide](/docs/quickstart) | [Full command reference](/docs/commands)
@@ -1,86 +0,0 @@
---
title: Marketplace
description: Browse and install from 15,000+ curated skills
---
# Marketplace
The SkillKit marketplace indexes 15,000+ skills from curated sources.
## Browse
```bash
skillkit marketplace
```
## Search
```bash
skillkit marketplace search "react hooks"
```
## Filter by Tags
```bash
skillkit marketplace --tags typescript,testing
```
## Refresh Index
```bash
skillkit marketplace refresh
```
## Popular Sources
| Repository | Description |
|------------|-------------|
| [anthropics/skills](https://github.com/anthropics/skills) | PDF, XLSX, DOCX processing |
| [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) | React/Next.js best practices |
## Install from Marketplace
```bash
skillkit install anthropics/skills
skillkit install anthropics/skills --skills pdf,xlsx
skillkit install anthropics/skills --agent claude-code,cursor
```
## Publish Skills
### Self-Host on Your Domain (Recommended)
Generate a well-known URI structure (RFC 8615) to host skills on your own domain:
```bash
# Create and validate your skill
skillkit create my-skill
skillkit validate my-skill
# Generate hosting structure
skillkit publish ./my-skill --output ./public
```
This creates:
```
.well-known/skills/
index.json # Skill manifest for auto-discovery
my-skill/
SKILL.md # Your skill content
```
Deploy the `.well-known` folder to your web server. Users can then install via:
```bash
skillkit add https://your-domain.com
```
### Submit to SkillKit Marketplace
To submit your skill for inclusion in the central marketplace:
```bash
skillkit publish submit
```
This opens a GitHub issue for review by maintainers.
-105
View File
@@ -1,105 +0,0 @@
---
title: MCP Server
description: Agent-native skill discovery via Model Context Protocol
---
# MCP Server
The REST API works great for HTTP clients. But AI agents speak MCP — the Model Context Protocol. The `@skillkit/mcp` package lets agents discover skills natively, without HTTP calls or curl commands.
Think of it as giving your agent a direct line to the entire skill catalog.
## Setup
### Claude Desktop
Add this to `~/Library/Application Support/Claude/claude_desktop_config.json`:
```json
{
"mcpServers": {
"skillkit": {
"command": "npx",
"args": ["@skillkit/mcp"]
}
}
}
```
Restart Claude Desktop. Done.
### Cursor
Add to `.cursor/mcp.json` in your project:
```json
{
"mcpServers": {
"skillkit": {
"command": "npx",
"args": ["@skillkit/mcp"]
}
}
}
```
### Any MCP client
The server uses stdio transport. Works with any MCP-compatible client:
```bash
npx @skillkit/mcp
```
## What your agent can do
Once connected, your agent gets four tools:
### Search skills
Ask your agent: *"Find skills for React performance optimization"*
Behind the scenes, it calls `search_skills` with your query and returns ranked results. You can filter by tags, category, or source repository.
```
> Search for authentication skills tagged with "security"
```
The agent searches across the full catalog, ranks results by relevance, and shows you the best matches.
### Get a specific skill
Ask: *"Get the pdf-processing skill from anthropics/skills"*
The agent calls `get_skill` and returns the full skill details — description, tags, content, and references.
### Get recommendations
Ask: *"What skills would you recommend for my TypeScript React project?"*
The agent calls `recommend_skills` with your stack context (languages, frameworks, libraries) and returns personalized suggestions ranked by relevance.
### Browse categories
Ask: *"What skill categories are available?"*
The agent calls `list_categories` and returns all categories with counts, so you know what's out there.
## Resources
The server also exposes two read-only resources:
- **`skills://trending`** — Top 20 skills by relevance score
- **`skills://categories`** — All categories with counts
Agents can read these without making a tool call.
## How it works
1. On startup, the server loads all skills from the marketplace catalog
2. Your agent sends a natural language request
3. The MCP client translates it into a tool call
4. The `RelevanceRanker` scores and ranks results (same algorithm as the REST API)
5. Results come back as structured JSON through the MCP protocol
Same ranking, same data, same quality — just native to your agent instead of going through HTTP.
-179
View File
@@ -1,179 +0,0 @@
---
title: Memory System
description: Persistent learning across AI agent sessions
---
# Memory System
Capture learnings from AI sessions and convert them into reusable skills. SkillKit's memory system provides automatic observation capture, intelligent compression, and token-optimized retrieval.
## Commands
```bash
skillkit memory status # View status
skillkit memory search <q> # Search learnings
skillkit memory compress # Compress observations to learnings
skillkit memory export <name> # Export as skill
skillkit memory sync-claude # Update CLAUDE.md with learnings
skillkit memory index # View memory index (Layer 1)
skillkit memory --global # Global memory operations
```
## How It Works
### Observation → Learning Pipeline
1. **Observations** - Track patterns during sessions (tool use, errors, solutions)
2. **Compression** - Distill observations into reusable learnings
3. **Injection** - Load relevant learnings into new sessions
4. **Export** - Convert to shareable skills
### Lifecycle Hooks
SkillKit integrates with Claude Code's lifecycle hooks for automatic memory capture:
| Hook | Trigger | Action |
|------|---------|--------|
| **SessionStart** | Session begins | Inject relevant learnings |
| **PostToolUse** | Tool completes | Capture outcomes as observations |
| **SessionEnd** | Session closes | Compress observations to learnings |
### Progressive Disclosure (Token Optimization)
Memory retrieval uses a 3-layer system to minimize token usage:
| Layer | Content | ~Tokens |
|-------|---------|---------|
| **Index** | Titles, tags, timestamps | 50-100 |
| **Timeline** | Context, excerpts, activity | ~200 |
| **Details** | Full content, metadata | 500-1000 |
The system starts with Layer 1 and progressively fetches deeper layers based on relevance and token budget.
## Storage
```
~/.skillkit/memory/
├── observations/ # Raw session data
├── learnings/ # Compressed knowledge
└── index.json # Memory index
<project>/.skillkit/memory/
├── observations/ # Project-specific observations
├── learnings/ # Project learnings
└── index.json # Project memory index
```
## Auto-CLAUDE.md Updates
Sync your most effective learnings to CLAUDE.md:
```bash
skillkit memory sync-claude
```
This populates the `## LEARNED` section with high-effectiveness insights, giving your agent persistent context across sessions.
## Programmatic API
### Memory Compression
```typescript
import { MemoryCompressor, LearningStore } from '@skillkit/core'
const compressor = new MemoryCompressor(projectPath)
const { learnings } = await compressor.compress(observations)
const store = new LearningStore('project', projectPath)
await store.add(learning)
const results = await store.search('authentication')
```
### Lifecycle Hooks
```typescript
import { MemoryHookManager } from '@skillkit/core'
const manager = new MemoryHookManager(projectPath)
// Session start - inject relevant learnings
const startResult = await manager.onSessionStart()
// After tool use - capture outcomes
await manager.onToolUse({
tool_name: 'Write',
tool_input: { file_path: '/src/auth.ts' },
tool_result: 'File written successfully',
duration_ms: 150
})
// Session end - compress to learnings
const endResult = await manager.onSessionEnd()
```
### Progressive Disclosure
```typescript
import { ProgressiveDisclosureManager } from '@skillkit/core'
const pdm = new ProgressiveDisclosureManager(projectPath)
// Layer 1: Index (~50 tokens each)
const index = pdm.getIndex({ includeGlobal: true })
// Layer 2: Timeline (~200 tokens each)
const timeline = pdm.getTimeline(['id1', 'id2'])
// Layer 3: Full details (~600 tokens each)
const details = pdm.getDetails(['id1'])
// Smart retrieval with token budget
const result = pdm.smartRetrieve('authentication patterns', 2000)
// Returns optimal layer based on budget
```
### CLAUDE.md Updater
```typescript
import { ClaudeMdUpdater } from '@skillkit/core'
const updater = new ClaudeMdUpdater(projectPath)
// Preview what would be updated
const preview = updater.preview({ minEffectiveness: 70 })
// Update CLAUDE.md
const result = updater.update({
minEffectiveness: 60,
maxLearnings: 20,
preserveManualEntries: true
})
```
## Configuration
Configure memory behavior in `.skillkit/config.json`:
```json
{
"memory": {
"enabled": true,
"autoInjectOnSessionStart": true,
"autoCaptureToolUse": true,
"autoCompressOnSessionEnd": true,
"minRelevanceForCapture": 30,
"maxTokensForInjection": 2000,
"compressionThreshold": 50
}
}
```
## Claude Code Integration
Generate hooks configuration for Claude Code:
```typescript
const manager = new MemoryHookManager(projectPath)
const config = manager.generateClaudeCodeHooksConfig()
// Outputs hooks.json format for Claude Code integration
```
-118
View File
@@ -1,118 +0,0 @@
---
title: Mesh Network
description: Multi-machine agent distribution with secure peer-to-peer communication
---
# Mesh Network
SkillKit's mesh network enables secure communication between AI agents across multiple machines. Share skills, synchronize memory, and collaborate across your development environment.
## Quick Start
```bash
# Initialize mesh on your machine
npx skillkit mesh init
# Discover other hosts on your LAN
npx skillkit mesh discover
# Add a specific host
npx skillkit mesh add 192.168.1.100
```
## Security
The mesh network uses enterprise-grade security:
- **Ed25519** - Peer identity and message signing
- **XChaCha20-Poly1305** - End-to-end message encryption
- **TLS 1.3** - Transport layer security
- **JWT with EdDSA** - Authentication tokens
### Initialize Security
```bash
# Generate encryption keys
npx skillkit mesh security init
# Check security status
npx skillkit mesh security status
```
### Peer Trust Management
```bash
# Trust a peer by fingerprint
npx skillkit mesh peer trust abc123def456
# Revoke a peer's trust
npx skillkit mesh peer revoke abc123def456
# List trusted peers
npx skillkit mesh peer list
```
## Commands Reference
| Command | Description |
|---------|-------------|
| `mesh init` | Initialize mesh network |
| `mesh add <address>` | Add a host to mesh |
| `mesh remove <id>` | Remove a host |
| `mesh list` | List known hosts |
| `mesh discover` | Discover hosts on LAN |
| `mesh health` | Check host health |
| `mesh status` | Show mesh status |
| `mesh security init` | Setup encryption keys |
| `mesh security status` | Show security status |
| `mesh peer trust <id>` | Trust a peer |
| `mesh peer revoke <id>` | Revoke peer trust |
| `mesh peer list` | List trusted peers |
## Security Levels
| Level | Discovery | Transport | Auth | Use Case |
|-------|-----------|-----------|------|----------|
| `development` | open | none | none | Local dev |
| `signed` | signed | optional | optional | Trusted LAN |
| `secure` (default) | signed | required | required | Production |
| `strict` | trusted-only | required | mTLS | High security |
## Architecture
The mesh network uses:
1. **UDP Multicast** - LAN discovery with signed announcements
2. **WebSocket (WSS)** - Real-time bidirectional communication
3. **HTTPS** - RESTful API for management
All messages are signed and optionally encrypted based on your security level.
## Programmatic API
```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'] },
});
```
## Next Steps
- [Inter-Agent Messaging](/docs/messaging) - Send messages between agents
- [Memory System](/docs/memory) - Share learnings across the mesh
-98
View File
@@ -1,98 +0,0 @@
---
title: Inter-Agent Messaging
description: Send messages between AI agents across the mesh network
---
# Inter-Agent Messaging
SkillKit's messaging system enables asynchronous communication between AI agents. Send code reviews, share insights, and coordinate work across your team.
## Quick Start
```bash
# Send a message
npx skillkit message send
# View inbox
npx skillkit message inbox
# Read a message
npx skillkit message read <message-id>
```
## Commands Reference
| Command | Description |
|---------|-------------|
| `message send` | Send message to agent |
| `message inbox` | View inbox |
| `message read <id>` | Read a message |
| `message reply <id>` | Reply to message |
| `message archive <id>` | Archive message |
| `message sent` | View sent messages |
| `message status` | Messaging status |
## Message Types
Messages can include:
- **Text** - Plain text messages
- **Code** - Code snippets with syntax highlighting
- **Diffs** - Code changes and patches
- **Skills** - Skill file attachments
## Priority Levels
- **urgent** - Immediate attention required
- **normal** - Standard priority (default)
- **low** - Can be addressed when convenient
## Inbox Management
```bash
# View unread messages
npx skillkit message inbox --unread
# Archive old messages
npx skillkit message archive <id>
# View sent messages
npx skillkit message sent
```
## Programmatic API
```typescript
import { MessagingClient } from '@skillkit/messaging';
import { MeshHost } from '@skillkit/mesh';
// Create messaging client
const messaging = new MessagingClient({
meshHost: host,
storagePath: '~/.skillkit/messages',
});
await messaging.init();
// Send a message
await messaging.send({
to: 'claude@laptop',
subject: 'Code review completed',
body: 'I reviewed the auth module...',
priority: 'normal',
});
// Listen for new messages
messaging.on('message', (msg) => {
console.log('New message from:', msg.from);
});
```
## TUI Navigation
In the Terminal UI, press `j` to access the Messages screen.
## Next Steps
- [Mesh Network](/docs/mesh) - Configure the underlying network
- [Team Collaboration](/docs/teams) - Share skills with your team
-34
View File
@@ -1,34 +0,0 @@
{
"title": "SkillKit",
"pages": [
"index",
"installation",
"chrome-extension",
"quickstart",
"tui",
"skills",
"agents",
"translation",
"marketplace",
"tree",
"recommendations",
"primer",
"memory",
"methodology",
"mesh",
"messaging",
"workflows",
"security",
"testing",
"commands",
"configuration",
"api-reference",
"rest-api",
"mcp-server",
"python-client",
"cicd",
"teams",
"custom-agents",
"contributing"
]
}
@@ -1,93 +0,0 @@
---
title: Methodology Packs
description: Curated skill packs for debugging, testing, planning, and collaboration
---
# Methodology Packs
Methodology packs are curated collections of skills that guide AI agents through structured workflows. Each pack bundles related skills around a domain — debugging, testing, planning, or collaboration.
## Available Packs
| Pack | Skills | Description |
|------|--------|-------------|
| **debugging** | root-cause-analysis, trace-and-isolate, hypothesis-testing | Systematic bug investigation |
| **testing** | red-green-refactor, test-patterns, anti-patterns | Test-driven development |
| **planning** | design-first, task-decomposition, verification-gates | Design and decomposition |
| **collaboration** | structured-review, parallel-investigation, handoff-protocols | Code review and handoffs |
| **meta** | skill-authoring | Writing effective skills |
## Commands
```bash
skillkit methodology list # List available packs
skillkit methodology install debugging # Install a pack
skillkit methodology apply testing # Apply pack to current project
skillkit methodology validate planning # Validate pack skills
skillkit methodology load collaboration # Load pack into agent context
```
## Pack Structure
Each pack lives under `packages/core/src/methodology/packs/` with this structure:
```
packs/
debugging/
pack.json # Pack manifest (name, skills, tags)
root-cause-analysis/
SKILL.md # Skill content
trace-and-isolate/
SKILL.md
hypothesis-testing/
SKILL.md
```
## Skills Reference
### Debugging
- **root-cause-analysis** — Five Whys method, structured investigation phases, evidence collection, causal chain verification
- **trace-and-isolate** — Binary search debugging, git bisect, strategic logging, component isolation, minimal reproduction
- **hypothesis-testing** — Scientific method for debugging: observe, hypothesize, predict, test, conclude
### Testing
- **red-green-refactor** — Write a failing test, make it pass with minimal code, then refactor while green
- **test-patterns** — AAA, Given-When-Then, Test Data Builders, Object Mother, parameterized tests, fixtures, spies
- **anti-patterns** — Flaky tests, over-mocking, brittle assertions, test interdependency, hidden logic
### Planning
- **design-first** — Technical design documents before code: architecture, data models, API definitions, trade-off analysis
- **task-decomposition** — Vertical slicing, horizontal layering, workflow and component decomposition
- **verification-gates** — Validation checkpoints between phases with checklists and approval criteria
### Collaboration
- **structured-review** — Five-stage code review: requirements, correctness, quality, testing, security
- **parallel-investigation** — Coordinate multiple investigation threads with sync points and convergence decisions
- **handoff-protocols** — Structured work transitions: planned, unplanned, and partial handoffs
### Meta
- **skill-authoring** — Guidelines for writing SKILL.md files: frontmatter, triggers, directive language, content patterns
## Using with Agents
Once installed, methodology skills activate automatically based on trigger phrases. For example:
```
You: "I need to debug this failing API endpoint"
Agent: [Activates root-cause-analysis skill]
You: "Let's write tests first for this feature"
Agent: [Activates red-green-refactor skill]
You: "Break down this feature into tasks"
Agent: [Activates task-decomposition skill]
```
## TUI Integration
Access methodology packs from the TUI by pressing `o` (Methodology screen). Browse, install, and apply packs interactively.
-303
View File
@@ -1,303 +0,0 @@
---
title: Primer
description: Auto-generate AI agent instructions from your codebase
---
# Primer
Primer analyzes your codebase and automatically generates optimized instructions for all 45 AI agents. No more manual configuration—let SkillKit detect your tech stack, coding patterns, and project structure.
## Quick Start
```bash
# Analyze current project
skillkit primer
# Generate for specific agents
skillkit primer --agent claude,cursor,windsurf
# Generate for all 45 agents
skillkit primer --all-agents
# Preview without writing files
skillkit primer --dry-run
```
## What Primer Detects
### Tech Stack
- **Frameworks**: React, Next.js, Vue, Angular, Svelte, etc.
- **Languages**: TypeScript, JavaScript, Python, Go, Rust, etc.
- **Build Tools**: Vite, Webpack, Turbopack, esbuild
- **Package Managers**: npm, pnpm, yarn, bun
### Project Patterns
- **Architecture**: Monorepo, microservices, serverless
- **Code Style**: Formatting rules, naming conventions
- **Directory Structure**: Feature-based, layer-based, domain-driven
- **Dependencies**: Key libraries and their versions
### Best Practices
- **Testing Setup**: Jest, Vitest, Playwright, Cypress
- **Linting**: ESLint, Prettier, TypeScript strict mode
- **Documentation**: JSDoc, TSDoc, README patterns
- **Git Workflow**: Branch strategy, commit conventions
## Generated Instructions
Primer creates agent-specific instructions for:
### Claude Code
```
.claude/
└── CLAUDE.md # Full project context
```
### Cursor
```
.cursor/
└── .cursorrules # IDE-specific rules
```
### GitHub Copilot
```
.github/
└── copilot-instructions.md
```
### All 45 Agents
Each agent gets optimized instructions in their native format.
## Example Output
```bash
$ skillkit primer
🔍 Analyzing project...
Detected:
Framework: Next.js 14 (App Router)
Language: TypeScript (strict mode)
Styling: Tailwind CSS v3
Testing: Vitest + Playwright
Package Manager: pnpm
✅ Generated instructions for:
- Claude Code (.claude/CLAUDE.md)
- Cursor (.cursor/.cursorrules)
- Codex (.codex/instructions.md)
+ 41 more agents
💡 Tip: Run `skillkit sync` to apply changes
```
## Customization
### Configuration File
Create `.skillkit/primer-config.json`:
```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
}
}
}
}
```
### Template Overrides
Override default templates in `.skillkit/primer-templates/`:
```
.skillkit/primer-templates/
├── claude.template.md
├── cursor.template.md
└── shared/
├── header.md
└── footer.md
```
## Update Strategies
### Incremental Updates
```bash
# Update only when changes detected
skillkit primer --incremental
# Force regeneration
skillkit primer --force
```
### Git Integration
```bash
# Auto-generate on git hooks
cat > .git/hooks/post-checkout << 'EOF'
#!/usr/bin/env bash
skillkit primer --incremental
EOF
chmod +x .git/hooks/post-checkout
```
### CI/CD Pipeline
```yaml
# .github/workflows/primer.yml
name: Update Agent Instructions
on:
push:
branches: [main]
paths:
- 'package.json'
- 'tsconfig.json'
- 'src/**'
jobs:
primer:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- run: npx skillkit primer --all-agents
- uses: stefanzweifel/git-auto-commit-action@v4
with:
commit_message: "chore: update agent instructions"
```
## Programmatic API
```typescript
import { analyzeProject, generateInstructions } from '@skillkit/core';
// Analyze project
const analysis = await analyzeProject('./my-project');
console.log(analysis.techStack);
// { framework: 'Next.js', language: 'TypeScript', ... }
// Generate instructions
const instructions = await generateInstructions(analysis, {
agents: ['claude', 'cursor'],
includeExamples: true,
tone: 'detailed',
});
// Write to files
for (const [agent, content] of Object.entries(instructions)) {
await writeAgentFile(agent, content);
}
```
## Best Practices
### When to Run Primer
- **Initial Setup** - First time configuring agents
- **Major Changes** - New frameworks or architecture changes
- **Team Onboarding** - New developers joining the project
- **Agent Migration** - Switching to new AI coding tools
### What to Commit
```text
# Commit generated instructions
.claude/
.cursor/
.github/copilot-instructions.md
# Don't commit
.skillkit/cache/
.skillkit/primer-temp/
```
### Combining with Skills
Primer generates base instructions. Layer on specific skills:
```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
```
## Comparison
| Method | Setup Time | Accuracy | Maintenance |
|--------|-----------|----------|-------------|
| **Manual Writing** | Hours | Variable | Manual updates |
| **AI Generation** | Minutes | High | Auto-detect changes |
| **Copy/Paste** | Minutes | Low | Stale quickly |
| **Primer** | Seconds | Very High | Auto-incremental |
## Troubleshooting
### Primer Not Detecting Framework
```bash
# Specify manually
skillkit primer --framework nextjs --language typescript
# Check detection logs
skillkit primer --verbose
```
### Generated Instructions Too Generic
Customize with `primer-config.json`:
```json
{
"tone": "detailed",
"includeExamples": true,
"customRules": [
"Your specific coding guidelines..."
]
}
```
### Instructions Out of Sync
```bash
# Force regeneration
skillkit primer --force
# Clean cache
rm -rf .skillkit/cache/primer
```
## Next Steps
- [Memory System](/docs/memory) - Capture learnings from sessions
- [Skills](/docs/skills) - Install domain-specific skills
- [Translation](/docs/translation) - Convert between agent formats
- [Team Collaboration](/docs/teams) - Share instructions with your team
@@ -1,105 +0,0 @@
---
title: Python Client
description: Async Python SDK for skill discovery
---
# Python Client
Not everything runs on Node. The `skillkit-client` package gives Python apps the same skill discovery capabilities as the REST API — async, typed, and ready to go.
## Install
```bash
pip install skillkit-client
```
Requires Python 3.10+.
## Quick start
```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}")
```
The client connects to `http://localhost:3737` by default. Make sure the API server is running:
```bash
skillkit serve
```
## Search with filters
```python
results = await client.search_with_filters(
"authentication",
tags=["security"],
category="backend",
limit=10,
)
```
## Get a specific skill
```python
skill = await client.get_skill("anthropics/skills", "pdf-processing")
print(skill.name, skill.description, skill.tags)
```
## Trending and categories
```python
trending = await client.trending(limit=10)
categories = await client.categories()
for skill in trending:
print(f"{skill.name} ({skill.source})")
for cat in categories:
print(f"{cat.name}: {cat.count} skills")
```
## Health and cache
```python
health = await client.health()
print(f"v{health.version} — {health.skill_count} skills loaded")
stats = await client.cache_stats()
print(f"Cache hit rate: {stats.hit_rate:.0%}")
```
## Connect to a remote server
```python
async with SkillKitClient("https://my-server.example.com:3737") as client:
results = await client.search("deployment")
```
## Models
The client returns typed dataclasses:
```python
Skill(name, source, description, tags, category, content, score)
SearchResponse(skills, total, query, limit)
HealthResponse(status, version, skill_count, uptime)
Category(name, count)
CacheStats(hits, misses, size, max_size, hit_rate)
```
All fields except `name` and `source` on `Skill` are optional — they depend on what the server returns and whether you requested `include_content`.
## Prerequisites
The Python client talks to the SkillKit REST API. You need a running server:
```bash
skillkit serve
```
Then run your Python script in another terminal. The client handles connection management, retries, and cleanup automatically when used with `async with`.
-122
View File
@@ -1,122 +0,0 @@
---
title: Quick Start
description: Get productive with SkillKit in under 5 minutes
---
# Quick Start
Go from zero to skills-enabled in four steps.
## 1. Init
```bash
npx skillkit@latest init
```
SkillKit detects your AI agent, creates the skills directory, and saves your preferences.
## 2. Get recommendations
```bash
skillkit recommend
```
SkillKit reads your project (package.json, languages, frameworks) and suggests relevant skills:
```
Project: my-app (Next.js + TypeScript + Tailwind)
Recommended Skills:
92% vercel-react-best-practices
87% tailwind-v4-patterns
85% nextjs-app-router
```
## 3. Install
```bash
skillkit install anthropics/skills
```
Pick which skills to install, choose target agents, and you're set. For CI/CD or scripting:
```bash
skillkit install anthropics/skills --skills=pdf,xlsx --agent claude --yes
```
Install for multiple agents at once:
```bash
skillkit install vercel-labs/agent-skills --agent claude,cursor,windsurf
```
## 4. Sync
```bash
skillkit sync
```
Skills are now in your agent's configuration. Start coding.
## What else?
### Translate between agents
Already have Claude skills? Deploy them to Cursor:
```bash
skillkit translate my-skill --to cursor
```
### Auto-generate agent instructions
Let SkillKit analyze your codebase and create CLAUDE.md, .cursorrules, etc.:
```bash
skillkit primer --all-agents
```
### Launch the TUI
```bash
skillkit ui
```
`h` Home | `m` Marketplace | `r` Recommend | `i` Installed | `s` Sync | `q` Quit
### Start the discovery server
Let agents find skills at runtime:
```bash
skillkit serve
```
[REST API](/docs/rest-api) | [MCP Server](/docs/mcp-server)
### Share with your team
```bash
skillkit manifest init
skillkit manifest add anthropics/skills
git add .skills && git commit -m "add team skills"
```
Team members run `skillkit manifest install` and get the same setup.
## Full workflow
```bash
npx skillkit@latest init # Detect agents, create dirs
skillkit recommend # Get smart suggestions
skillkit install anthropics/skills # Install from marketplace
skillkit primer --all-agents # Generate agent instructions
skillkit sync # Deploy everything
```
## Next steps
- [Commands](/docs/commands) — Full CLI reference
- [Skills](/docs/skills) — Skill format and lifecycle
- [Memory](/docs/memory) — Persistent session learning
- [Mesh](/docs/mesh) — Multi-machine distribution
@@ -1,98 +0,0 @@
---
title: Recommendations
description: Get smart skill suggestions for your project
---
# Recommendations
SkillKit analyzes your project and suggests relevant skills.
## Get Recommendations
```bash
skillkit recommend
```
Output:
```
Project: my-app (Next.js + TypeScript + Tailwind)
Recommended Skills:
92% vercel-react-best-practices
87% tailwind-v4-patterns
85% nextjs-app-router
```
## Filters
```bash
skillkit recommend --search "auth"
skillkit recommend --category security
skillkit recommend --min-score 80
```
## Explainable Recommendations
See WHY skills match your project:
```bash
skillkit recommend --explain
```
Output:
```
vercel-react-best-practices (Score: 92)
├── Matched: React, TypeScript, Next.js
├── Your stack: Next.js 14, React 18
└── Path: Frontend > React > Best Practices
```
## LLM-Based Reasoning
Use reasoning-based discovery for complex queries:
```bash
skillkit recommend --reasoning
```
This uses an LLM to traverse the skill taxonomy and find the most relevant skills based on semantic understanding.
## How It Works
The engine analyzes:
- **Project structure** - Frameworks, languages, tools
- **Dependencies** - package.json, requirements.txt
- **File patterns** - Code patterns in your codebase
## Scoring
Scores based on:
- Stack match
- Quality score (0-100)
- Popularity
- Task relevance
## Programmatic API
```typescript
import {
RecommendationEngine,
ReasoningRecommendationEngine,
analyzeProject
} from '@skillkit/core'
// Basic recommendations
const engine = new RecommendationEngine()
const profile = await analyzeProject('./my-project')
const recs = engine.recommend(profile)
// With reasoning and explanations
const reasoningEngine = new ReasoningRecommendationEngine()
await reasoningEngine.initReasoning()
const explained = await reasoningEngine.recommendWithReasoning(profile, {
reasoning: true,
explain: true
})
```
-205
View File
@@ -1,205 +0,0 @@
---
title: REST API
description: Runtime skill discovery via HTTP
---
# REST API
Skills shouldn't require pre-installation. With the SkillKit REST API, any agent, framework, or tool can discover and retrieve skills on demand over HTTP.
## Start the server
```bash
skillkit serve
```
That's it. The API is now running at `http://localhost:3737`.
## Search for skills
```bash
curl "http://localhost:3737/search?q=react+performance"
```
```json
{
"skills": [
{
"name": "react-performance",
"description": "React app performance optimization",
"source": "anthropics/skills",
"tags": ["react", "performance"],
"score": 87
}
],
"total": 42,
"query": "react performance",
"limit": 20
}
```
Results are ranked by a multi-signal scoring system. The best matches come first.
### With filters
Use POST for advanced filtering:
```bash
curl -X POST http://localhost:3737/search \
-H "Content-Type: application/json" \
-d '{
"query": "auth",
"filters": { "tags": ["security"], "category": "backend" }
}'
```
### Include full content
Add `include_content=true` to get the complete SKILL.md body:
```bash
curl "http://localhost:3737/search?q=pdf&include_content=true&limit=3"
```
## Get a specific skill
```bash
curl http://localhost:3737/skills/anthropics/skills/pdf-processing
```
The path follows the pattern `/skills/:owner/:repo/:skill-name`.
## Browse trending skills
```bash
curl http://localhost:3737/trending?limit=10
```
Returns the top skills ranked by relevance score across all sources.
## List categories
```bash
curl http://localhost:3737/categories
```
```json
{
"categories": [
{ "name": "react", "count": 156 },
{ "name": "typescript", "count": 134 },
{ "name": "testing", "count": 89 }
],
"total": 89
}
```
## How ranking works
Every search result gets a score from 0 to 100, computed from four signals:
| Signal | Points | What it measures |
|--------|--------|-----------------|
| Content | 40 | Has a description and SKILL.md body |
| Query match | 30 | How well the name/description matches your search |
| Popularity | 15 | GitHub stars + install count (log-scaled) |
| References | 15 | Has example files, docs, or resources |
A skill with full content, an exact name match, high stars, and example files scores close to 100. A skill with just a name and no content scores around 10.
## Server options
```bash
skillkit serve --port 8080 --host localhost --cors "http://localhost:3000"
```
| Option | Default | What it does |
|--------|---------|-------------|
| `--port` / `-p` | `3737` | Port to listen on |
| `--host` / `-H` | `0.0.0.0` | Host to bind to |
| `--cors` | `*` | Allowed CORS origin |
| `--cache-ttl` | `86400000` | Cache lifetime in ms (default 24h) |
## Rate limiting
60 requests per minute per IP. Response headers tell you where you stand:
| Header | Meaning |
|--------|---------|
| `X-RateLimit-Remaining` | Requests left in this window |
| `X-RateLimit-Reset` | When the window resets |
Exceed the limit and you'll get HTTP 429 with a `retryAfter` field.
## Caching
Search results are cached in memory using an LRU strategy. Same query, same results, no recomputation. Check cache performance:
```bash
curl http://localhost:3737/cache/stats
```
```json
{
"hits": 142,
"misses": 38,
"size": 45,
"maxSize": 500,
"hitRate": 0.789
}
```
## Health check
```bash
curl http://localhost:3737/health
```
```json
{
"status": "ok",
"version": "1.19.2",
"skillCount": 15062,
"uptime": 3600
}
```
## Use it programmatically
```typescript
import { createApp, startServer } from '@skillkit/api';
const { server, app, cache } = await startServer({
port: 3737,
skills: mySkillsArray,
});
```
Or get just the Hono app for testing:
```typescript
const { app, cache } = createApp({
skills: mySkillsArray,
cacheTtlMs: 3_600_000,
});
```
## Interactive docs
The server includes built-in Swagger UI at `/docs` and an OpenAPI 3.1 spec at `/openapi.json`. Open `http://localhost:3737/docs` in your browser to try endpoints interactively.
The hosted version is available at [skillkit.sh/api](https://skillkit.sh/api) and [agenstskills.com/api](https://agenstskills.com/api).
## All 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 |
| GET | `/docs` | Swagger UI |
| GET | `/openapi.json` | OpenAPI spec |
-281
View File
@@ -1,281 +0,0 @@
---
title: Security Scanner
description: Detect malicious patterns, secrets, and vulnerabilities in AI agent skills
---
# Security Scanner
SkillKit includes a built-in security scanner that analyzes skills for prompt injection, command injection, data exfiltration, hardcoded secrets, and other threats before installation.
## Quick Start
```bash
skillkit scan ./my-skill
```
The scanner runs automatically during `skillkit install`. Use `--no-scan` to skip or `--force` to install despite findings.
## CLI Usage
```bash
skillkit scan <path> # Scan skill directory
skillkit scan <path> --format json # JSON output
skillkit scan <path> --format table # Tabular output
skillkit scan <path> --format sarif # SARIF v2.1 for GitHub Code Scanning
skillkit scan <path> --fail-on high # Exit code 1 if HIGH+ findings
skillkit scan <path> --skip-rules UC001 # Skip specific rules
skillkit scan <path> --skip-rules PI001,PI002 # Skip multiple rules
```
## Threat Categories
The scanner detects 46+ patterns across 6 threat categories:
### Prompt Injection (PI001–PI015)
Detects attempts to override, bypass, or manipulate agent instructions.
| Rule | Severity | Description |
|------|----------|-------------|
| PI001 | Critical | Instruction override ("ignore previous instructions") |
| PI002 | Critical | Context clearing ("forget everything") |
| PI003 | Critical | Training bypass ("disregard your training") |
| PI004 | Critical | System prompt injection ("new instructions:") |
| PI005 | High | Role manipulation ("you are now a...") |
| PI006 | High | Roleplay manipulation ("pretend to be...") |
| PI007 | High | Persistent behavior change ("from now on...") |
| PI008 | High | System prompt extraction ("show me your instructions") |
| PI009 | Critical | Policy bypass (jailbreak, unrestricted mode, DAN) |
| PI010 | High | Concealment ("don't tell the user") |
| PI011 | High | Delimiter injection (conversation role markers) |
| PI012 | High | Model-specific delimiters (Llama [INST] tags) |
| PI013 | Medium | YAML front-matter injection |
| PI014 | Medium | Hidden HTML comments with instructions |
| PI015 | Medium | Hidden Markdown comments with instructions |
### Command Injection (CI001–CI010)
Detects code execution, shell injection, and path traversal patterns.
| Rule | Severity | Description |
|------|----------|-------------|
| CI001 | Critical | `eval()` calls |
| CI002 | Critical | `Function()` constructor |
| CI003 | Critical | `child_process` exec/execSync |
| CI004 | Critical | Python `subprocess` with `shell=True` |
| CI005 | Medium | Template literals with dynamic content in command context |
| CI006 | Medium | Path traversal (`../`) |
| CI007 | High | Shell command chaining with dangerous commands |
| CI008 | Medium | Process execution functions |
| CI009 | High | Python dynamic import/compile |
| CI010 | Medium | Node.js `vm` module usage |
### Data Exfiltration (DE001–DE008)
Detects network requests, webhook URLs, and credential access patterns.
| Rule | Severity | Description |
|------|----------|-------------|
| DE001 | Critical | Discord webhook URLs |
| DE002 | Critical | Telegram bot API URLs |
| DE003 | High | Slack webhook URLs |
| DE004 | High | HTTP POST with env variables |
| DE005 | High | Fetch/axios sending to external URLs |
| DE006 | Medium | Reading `.env` or credentials files |
| DE007 | Medium | Environment variable access patterns |
| DE008 | Medium | DNS/IP-based exfiltration patterns |
### Tool Abuse (TA001–TA006)
Detects tool shadowing, autonomy escalation, and capability manipulation.
| Rule | Severity | Description |
|------|----------|-------------|
| TA001 | High | Tool shadowing (redefining built-in tools) |
| TA002 | High | Autonomy abuse ("keep retrying", "run without confirmation") |
| TA003 | High | Capability inflation (discovering/enabling extra tools) |
| TA004 | Medium | Tool chaining (read sensitive data then send externally) |
| TA005 | Medium | Permission escalation patterns |
| TA006 | Medium | Recursive self-invocation |
### Hardcoded Secrets (SK001–SK013)
Detects API keys, tokens, and credentials embedded in skill files.
| Rule | Severity | Description |
|------|----------|-------------|
| SK001 | Critical | OpenAI API key (`sk-...`) |
| SK002 | Critical | Stripe live publishable key |
| SK003 | Critical | Stripe secret key |
| SK004 | Critical | GitHub personal access token |
| SK005 | Critical | GitHub OAuth token |
| SK006 | Critical | AWS access key (`AKIA...`) |
| SK007 | Critical | Slack bot token (`xoxb-...`) |
| SK008 | Critical | Slack user token (`xoxp-...`) |
| SK009 | Critical | Private key block |
| SK010 | High | Google API key |
| SK011 | Critical | Anthropic API key (`sk-ant-...`) |
| SK012 | High | npm token |
| SK013 | Low | UUID patterns (with credential context) |
| SK-ENV | High | Environment file included in skill |
### Unicode Steganography (UC001–UC007)
Detects invisible characters and obfuscation techniques.
| Rule | Severity | Description |
|------|----------|-------------|
| UC001 | Medium | Zero-width characters (U+200B, U+200C, U+200D, U+FEFF) |
| UC002 | High | Bidirectional text override (U+202A–U+202E) |
| UC003 | High | Bidirectional isolate characters (U+2066–U+2069) |
| UC004 | High | Unicode tag characters (U+E0001–U+E007F) |
| UC005 | Medium | Control characters |
| UC006 | Medium | Base64-encoded payloads |
| UC007 | Medium | Hex/Unicode escape sequences |
### Manifest Validation (MF001–MF008)
Validates SKILL.md frontmatter and skill structure.
| Rule | Severity | Description |
|------|----------|-------------|
| MF001 | Low | Missing SKILL.md frontmatter |
| MF002 | Low | Missing skill name |
| MF003 | Low | Invalid skill name format |
| MF004 | Info | Missing skill description |
| MF005 | Info | Short skill description |
| MF006 | High | Dangerous tool in allowed-tools (Bash, shell) |
| MF007 | High | Impersonation (claiming official affiliation) |
| MF008 | Medium | Binary files in skill directory |
## Analyzers
The scanner uses three analyzers that run in parallel:
| Analyzer | Purpose | Rules |
|----------|---------|-------|
| **StaticAnalyzer** | Regex pattern matching against security rules | PI, CI, DE, TA, UC |
| **ManifestAnalyzer** | SKILL.md frontmatter validation | MF |
| **SecretsAnalyzer** | Credential and secret detection | SK |
## Output Formats
### Summary (default)
Colored terminal output with severity indicators, file locations, snippets, and remediation advice.
### JSON
Machine-readable JSON with all findings, stats, and verdict.
```bash
skillkit scan ./my-skill --format json | jq '.findings[] | {ruleId, severity, title}'
```
### Table
Tabular format for quick review:
```bash
skillkit scan ./my-skill --format table
```
### SARIF
SARIF v2.1 for GitHub Code Scanning and IDE integration:
```bash
skillkit scan ./my-skill --format sarif > results.sarif
```
Upload to GitHub:
```bash
gh api repos/{owner}/{repo}/code-scanning/sarifs \
-f "sarif=$(gzip -c results.sarif | base64)"
```
## CI/CD Integration
### GitHub Actions
```yaml
- name: Scan skills
run: npx skillkit scan ./skills --format sarif --fail-on high > results.sarif
- name: Upload SARIF
uses: github/codeql-action/upload-sarif@v3
with:
sarif_file: results.sarif
```
### Pre-commit Hook
```bash
skillkit scan . --fail-on medium
```
## Programmatic Usage
```typescript
import { SkillScanner, formatResult } from '@skillkit/core';
const scanner = new SkillScanner({
failOnSeverity: 'high',
skipRules: ['UC001', 'MF004'],
});
const result = await scanner.scan('./my-skill');
console.log(formatResult(result, 'summary'));
console.log(`Verdict: ${result.verdict}`);
console.log(`Findings: ${result.findings.length}`);
```
## Severity Levels
| Level | Exit Code | Description |
|-------|-----------|-------------|
| **Critical** | 1 (with `--fail-on critical`) | Immediate security threat |
| **High** | 1 (with `--fail-on high`, default) | Significant security risk |
| **Medium** | 1 (with `--fail-on medium`) | Potential security concern |
| **Low** | 1 (with `--fail-on low`) | Minor issue or best practice |
| **Info** | 0 | Informational finding |
## Trust Badges
Skills display a trust badge based on their source and quality analysis. Badges appear during installation, in `skillkit check` output, and in marketplace search results.
| Badge | Criteria |
|-------|----------|
| **[Official]** | Published by a known official source (Anthropic, Vercel, iii-hq, etc.) |
| **[Trusted]** | TrustScorer rates the skill 8-10 based on clarity, boundaries, specificity, and safety |
| **[Review]** | TrustScorer rates the skill 5-7; the skill may need refinement |
| **[Caution]** | TrustScorer rates the skill 0-4; requires careful review before use |
The `TrustScorer` evaluates four weighted dimensions:
| Dimension | Weight | What it measures |
|-----------|--------|------------------|
| Clarity | 30% | How well-defined the skill's purpose and instructions are |
| Boundaries | 25% | Whether the skill stays within its declared scope |
| Specificity | 25% | How concrete and actionable the instructions are |
| Safety | 20% | Absence of dangerous patterns (injection, exfiltration, secrets) |
Official sources are allowlisted by organization name and always receive the `[Official]` badge regardless of score. For all other sources, the badge is determined by the composite trust score.
## False Positive Handling
The scanner automatically filters:
- **Placeholder patterns**: `your-api-key`, `example`, `sample`, `dummy`, `xxx`
- **Test files**: `*.test.ts`, `*.spec.ts`, `__tests__/`
- **Import statements**: `import ... from '../'` (not path traversal)
- **Comments**: Code comments mentioning patterns
- **Security discussions**: Text discussing jailbreaks or vulnerabilities (uses negative lookbehind)
To skip specific rules:
```bash
skillkit scan . --skip-rules UC001,UC002,MF004
```
-115
View File
@@ -1,115 +0,0 @@
---
title: Skills
description: Understanding AI agent skills - format, lifecycle, and quality
---
# Skills
A skill is an instruction file that teaches AI coding agents how to handle specific tasks. Each skill uses a universal Markdown format (SKILL.md) with YAML frontmatter.
## Skills vs Context vs Commands
| Type | Purpose | Format |
|------|---------|--------|
| **Skills** | Task-specific reusable instructions | SKILL.md |
| **Context** | Project-wide environment info | JSON/YAML |
| **Commands** | Quick-action slash commands | Various |
## Skill Format
```markdown
---
name: my-skill
description: What this skill does
license: MIT
metadata:
author: your-name
version: "1.0"
tags:
- react
- typescript
---
# My Skill
Instructions for the AI agent.
## When to Use
- Scenario 1
- Scenario 2
## Steps
1. First step
2. Second step
```
## Skill Lifecycle
Skills progress through six stages:
1. **Discovery** - `findAllSkills()` scans directories for SKILL.md files
2. **Quality Evaluation** - `evaluateSkillContent()` produces 0-100 scores (grades A-F)
3. **Parsing** - `parseSkillFile()` extracts YAML frontmatter and markdown content
4. **Translation** - `translateSkill()` converts to agent-specific formats
5. **Installation** - Skills deployed to agent directories with metadata tracking
6. **Testing** - Test suites with 14+ assertion types validate skills
## Quality Evaluation
Skills receive scores across four weighted dimensions:
- **Structure** - 25 points: Frontmatter completeness, markdown sections
- **Clarity** - 30 points: Description quality, instruction precision
- **Specificity** - 30 points: Concrete examples, actionable steps
- **Advanced** - 15 points: Test coverage, version info, examples
**Grades:**
- A: 90 to 100
- B: 80 to 89
- C: 70 to 79
- D: 60 to 69
- F: below 60
## Skill Sources
| Source | Description |
|--------|-------------|
| **GitHub/GitLab** | Remote repository collections |
| **Local filesystem** | Project-specific skills |
| **Marketplace** | 15,000+ curated skills with search |
## Creating Skills
```bash
skillkit create my-skill
```
Or manually create a `SKILL.md` file following the format above.
## Publishing Skills
```bash
# Test locally
skillkit validate ./my-skill
# Generate well-known hosting structure for self-hosting
skillkit publish ./my-skill --output ./public
# Or submit to SkillKit marketplace
skillkit publish submit
```
### Self-Hosting
The `skillkit publish` command generates an RFC 8615 well-known URI structure:
```
.well-known/skills/
index.json # Manifest for auto-discovery
my-skill/
SKILL.md # Skill content
```
Deploy to your domain and users can install via `skillkit add https://your-domain.com`.
-455
View File
@@ -1,455 +0,0 @@
---
title: Team Collaboration
description: Share skills and maintain consistency across your development team
---
# Team Collaboration
SkillKit provides powerful team collaboration features to ensure every developer has the same AI agent capabilities, follows the same patterns, and stays in sync.
## Quick Start
```bash
# Initialize team manifest
skillkit team init
# Add skills to team manifest
skillkit team add anthropics/skills
skillkit team add ./local-skills
# Share with team (commit to Git)
git add .skills
git commit -m "Add team skills manifest"
git push
# Team members install
git pull
skillkit team install
```
## Team Manifest (.skills)
The `.skills` file is a Git-committable manifest that defines your team's skill stack.
### Example Manifest
```json
{
"version": "1.0",
"name": "my-team",
"skills": [
{
"source": "anthropics/skills",
"skills": ["pdf", "xlsx", "docx"],
"version": "1.2.0"
},
{
"source": "vercel-labs/agent-skills",
"skills": ["react-best-practices", "nextjs-patterns"],
"version": "latest"
},
{
"source": "./local-skills",
"skills": ["company-coding-standards", "api-guidelines"],
"type": "local"
}
],
"agents": ["claude", "cursor", "windsurf"],
"config": {
"autoSync": true,
"syncOnPull": true
}
}
```
## Commands
### Initialize Team
```bash
# Create .skills manifest
skillkit team init
# Specify team name
skillkit team init --name engineering-team
# Add initial skills
skillkit team init --skills anthropics/skills,vercel-labs/agent-skills
```
### Manage Skills
```bash
# Add skill source
skillkit team add anthropics/skills
# Add specific skills
skillkit team add anthropics/skills --skills pdf,xlsx
# Remove skill
skillkit team remove anthropics/skills
# List team skills
skillkit team list
```
### Install & Sync
```bash
# Install all team skills
skillkit team install
# Install and sync
skillkit team install --sync
# Force reinstall
skillkit team install --force
```
### Share & Update
```bash
# Share current skills as team manifest
skillkit team share
# Update team manifest from installed skills
skillkit team update
# Sync team manifest with Git remote
skillkit team sync
```
## Git Integration
### Auto-Install on Pull
Add to `.git/hooks/post-merge`:
```bash
#!/bin/sh
if [ -f .skills ]; then
echo "📦 Installing team skills..."
skillkit team install --yes
fi
```
Make it executable:
```bash
chmod +x .git/hooks/post-merge
```
### Pre-Commit Validation
Ensure skills are valid before committing:
```bash
# .git/hooks/pre-commit
#!/bin/sh
if [ -f .skills ]; then
echo "🔍 Validating team skills..."
skillkit team validate
if [ $? -ne 0 ]; then
echo "❌ Team skills validation failed"
exit 1
fi
fi
```
## CI/CD Integration
### GitHub Actions
```yaml
# .github/workflows/skills.yml
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
```
### GitLab CI
```yaml
# .gitlab-ci.yml
skills:validate:
stage: test
script:
- npm install -g skillkit
- skillkit team validate
- skillkit team install --yes
- skillkit test
only:
changes:
- .skills
```
## Private Registries
Host proprietary skills in private repositories.
### Setup Private Registry
```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
```
### Team Manifest with Private Skills
```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"
}
]
}
```
## Team Workflows
### Onboarding New Developers
```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!
```
### Creating Team-Wide Skills
```bash
# 1. Create new skill
skillkit create company-coding-standards
# 2. Add to local skills
mv company-coding-standards ./local-skills/
# 3. Add to team manifest
skillkit team add ./local-skills
# 4. Commit and push
git add .skills local-skills/
git commit -m "Add company coding standards"
git push
```
### Updating Team Skills
```bash
# 1. Update skill version
skillkit team update anthropics/skills --version 1.3.0
# 2. Test locally
skillkit team install
skillkit test
# 3. Commit if tests pass
git add .skills
git commit -m "Update anthropics/skills to v1.3.0"
git push
```
## Best Practices
### Version Pinning
Pin critical skills to specific versions:
```json
{
"skills": [
{
"source": "anthropics/skills",
"version": "1.2.0",
"pinned": true
}
]
}
```
### Skill Categories
Organize by category:
```json
{
"skills": [
{
"category": "core",
"source": "anthropics/skills",
"required": true
},
{
"category": "optional",
"source": "vercel-labs/agent-skills",
"required": false
}
]
}
```
### Environment-Specific Skills
```json
{
"environments": {
"development": {
"skills": ["debug-tools", "dev-server-patterns"]
},
"production": {
"skills": ["performance-monitoring", "error-tracking"]
}
}
}
```
## Conflict Resolution
### Skill Name Conflicts
When multiple sources provide the same skill name:
```bash
# List conflicts
skillkit team conflicts
# Resolve by priority
skillkit team resolve --priority "local,anthropics,vercel"
```
### Version Conflicts
```bash
# Show version mismatches
skillkit team check-versions
# Align to latest
skillkit team align --strategy latest
# Align to pinned
skillkit team align --strategy pinned
```
## Programmatic API
```typescript
import { TeamManifest, TeamSync } from '@skillkit/core'
// Load team manifest
const manifest = await TeamManifest.load('./.skills')
// Install team skills
const sync = new TeamSync(manifest)
await sync.install({
agents: ['claude', 'cursor'],
force: false,
})
// Update manifest
manifest.addSkill({
source: 'anthropics/skills',
skills: ['pdf'],
version: '1.2.0',
})
await manifest.save()
```
## Troubleshooting
### Skills Not Syncing
```bash
# Force reinstall
skillkit team install --force
# Clear cache
skillkit team clean
# Reinstall
skillkit team install
```
### Manifest Validation Errors
```bash
# Validate manifest
skillkit team validate --verbose
# Fix common issues
skillkit team validate --fix
```
### Merge Conflicts in .skills
```bash
# Accept theirs
git checkout --theirs .skills
skillkit team install
# Accept ours
git checkout --ours .skills
skillkit team install
# Merge manually
skillkit team merge-conflicts
```
## Next Steps
- [CI/CD Integration](/docs/cicd) - Automate skill deployment
- [Workflows](/docs/workflows) - Team-wide automation
- [Testing](/docs/testing) - Validate skills before deployment
-66
View File
@@ -1,66 +0,0 @@
---
title: Testing
description: Test skills with multiple assertion types
---
# Testing
SkillKit includes a testing framework with multiple assertion types.
## Run Tests
```bash
skillkit test # All tests
skillkit test ./my-skill # Specific skill
skillkit test --tags unit # By tag
skillkit test --json # CI output
```
## Test File
Create `test.yaml` alongside your skill:
```yaml
name: my-skill-tests
skill: my-skill
tests:
- name: validates input
input: |
Process this file
assertions:
- contains: "processed"
- not_contains: "error"
```
## Assertion Types
| Assertion | Description |
|-----------|-------------|
| `contains` | Text present |
| `not_contains` | Text absent |
| `matches` | Regex match |
| `starts_with` | Prefix check |
| `ends_with` | Suffix check |
| `has_section` | Markdown section |
| `has_code_block` | Code block with lang |
| `word_count_min` | Minimum words |
| `word_count_max` | Maximum words |
| `no_todos` | No TODO comments |
| `has_frontmatter` | YAML present |
## CI Integration
```yaml
- name: Test Skills
run: skillkit test --json > results.json
```
## Programmatic API
```typescript
import { SkillTestRunner } from '@skillkit/core'
const runner = new SkillTestRunner()
const results = await runner.run('./my-skill')
```
@@ -1,55 +0,0 @@
---
title: Translation
description: Convert skills between AI agent formats
---
# Translation
SkillKit automatically converts between all 45 agent formats using an adapter pattern.
## Basic Translation
```bash
skillkit translate react-patterns --to cursor
```
## Translate All
```bash
skillkit translate --all --to windsurf
```
## Preview Mode
```bash
skillkit translate my-skill --to codex --dry-run
```
## Batch Translation
```bash
skillkit agent translate --source ./my-skills --to cursor
skillkit agent translate --source ./skills --to cursor --recursive
```
## Format Mapping
| Source | Target | Notes |
|--------|--------|-------|
| SKILL.md | .mdc | Cursor format |
| SKILL.md | Markdown | GitHub Copilot |
| .mdc | SKILL.md | Reverse conversion |
## How It Works
```
Universal Format (SKILL.md)
↓
Adapter Interface
↓
Agent-Specific Formats
```
Each adapter implements:
- `getConfigPath()` - Returns skill directory
- `generateConfig()` - Converts content to target format
-144
View File
@@ -1,144 +0,0 @@
---
title: Skill Tree
description: Browse skills in a hierarchical taxonomy
---
# Skill Tree
Browse and navigate skills organized in a hierarchical taxonomy structure.
## Quick Start
```bash
# Show full skill tree
skillkit tree
# Navigate to a category
skillkit tree Frontend
# Navigate to subcategory
skillkit tree "Frontend > React"
```
## Commands
### Display Tree
```bash
skillkit tree # Full tree
skillkit tree Development # Specific category
skillkit tree --depth 2 # Limit display depth
```
### Generate Tree
```bash
skillkit tree --generate # Generate from skill index
```
This builds a hierarchical tree from the skill index based on tags and metadata.
### Export Formats
```bash
skillkit tree --json # JSON output
skillkit tree --markdown # Markdown output
```
### Statistics
```bash
skillkit tree --stats
```
Output:
```
Overview:
Total Skills: 15,064
Categories: 156
Max Depth: 4
Top-Level Categories:
Development 4,521 skills (30.0%)
Frontend (1,245), Backend (1,102), Mobile (456)
DevOps 2,340 skills (15.5%)
CI/CD (890), Kubernetes (567), Docker (445)
AI/ML 1,890 skills (12.5%)
LLM Integration (756), Agents (445), RAG (312)
```
## Categories
The tree organizes skills into 12 top-level categories:
| Category | Description |
|----------|-------------|
| Development | General coding, programming patterns |
| Frontend | React, Vue, Angular, Svelte, UI/UX |
| Backend | Node.js, Python, Go, APIs, servers |
| Mobile | React Native, Flutter, iOS, Android |
| DevOps | CI/CD, Kubernetes, Docker, cloud |
| Testing | Unit, E2E, integration, TDD |
| Security | Auth, encryption, vulnerabilities |
| AI/ML | LLM, agents, RAG, embeddings |
| Database | SQL, NoSQL, ORM, migrations |
| Tooling | Linting, formatting, bundling |
| Documentation | API docs, guides, READMEs |
| Performance | Optimization, caching, profiling |
## TUI Tree View
In the TUI, press `v` to toggle tree view in the Marketplace:
- **Arrow keys** - Navigate tree
- **Enter** - Expand category / select skill
- **←** - Go back / collapse
- **v** - Toggle list/tree view
## Related Skills Graph
Find skills related to each other:
```typescript
import { buildSkillGraph, getRelatedSkills } from '@skillkit/core'
const graph = buildSkillGraph(skills)
const related = getRelatedSkills('react-patterns', graph, skills, {
limit: 5,
types: ['similar', 'complementary']
})
```
### Relation Types
- **similar** - Shares tags and functionality
- **complementary** - Works well together
- **dependency** - Required by other skills
- **alternative** - Different approach to same problem
## Programmatic API
```typescript
import {
TreeGenerator,
generateSkillTree,
loadTree,
saveTree,
treeToMarkdown
} from '@skillkit/core'
// Generate tree from skills
const generator = new TreeGenerator({ maxDepth: 3 })
const tree = generator.generateTree(skills)
// Or use the helper function
const tree = generateSkillTree(skills)
// Save and load
saveTree(tree, './skill-tree.json')
const loaded = loadTree('./skill-tree.json')
// Export to markdown
const markdown = treeToMarkdown(tree)
```
-225
View File
@@ -1,225 +0,0 @@
---
title: Terminal UI
description: Interactive keyboard-driven interface for managing skills
---
# Terminal UI
The TUI provides an interactive, keyboard-driven interface for managing skills with visual browsing, searching, and installation capabilities.
## Launch
```bash
skillkit ui
# or just
skillkit
```
## Framework
Built on modern technologies:
- **@opentui/solid** - Terminal rendering with Solid.js
- **Solid.js 1.9.0** - Reactive component architecture
- **Bun 1.2.0+** - Runtime requirement
The TUI was migrated from React to Solid.js in v1.8.0 for improved performance and smaller bundle size.
## Screens
| Screen | Key | Purpose |
|--------|-----|---------|
| **Home** | `h` | Entry point dashboard with quick navigation |
| **Browse** | `b` | Skill repository browser with search |
| **Marketplace** | `m` | 15,000+ skills with categories |
| **Installed** | `i` | Local skill management |
| **Recommend** | `r` | AI-powered suggestions |
| **Translate** | `t` | Format conversion |
| **Context** | `c` | Project context management |
| **Sync** | `s` | Synchronize to agents |
## Keyboard Navigation
### Global Shortcuts
| Key | Action |
|-----|--------|
| `h` | Go to Home |
| `b` | Go to Browse |
| `m` | Go to Marketplace |
| `i` | Go to Installed |
| `r` | Go to Recommend |
| `t` | Go to Translate |
| `c` | Go to Context |
| `s` | Go to Sync |
| `/` | Open Help |
| `q` | Quit TUI |
### List Navigation
| Key | Action |
|-----|--------|
| `j` or `↓` | Move down |
| `k` or `↑` | Move up |
| `Enter` | Select/activate |
| `Esc` | Go back |
| `/` | Enter search mode |
### Search Mode
| Key | Action |
|-----|--------|
| `/` | Enter search mode |
| Type | Filter list |
| `Enter` | Confirm search |
| `Esc` | Exit search |
## Screen Details
### Home Screen
Dashboard with:
- Quick navigation shortcuts
- Recent activity
- System status
### Browse Screen
Repository browser with:
- Search functionality
- Pagination
- Quality indicators
- Animation phases for smooth loading
### Installed Screen
Manage local skills:
- Enable/disable skills
- Quality grades (A-F)
- Live search filtering
- Status icons: `●` enabled, `○` disabled
### Marketplace Screen
Browse 15,000+ skills:
- Category filtering
- Featured skills
- 3-phase animation loading
- Quality scoring
- **Tree View** - Press `v` to toggle hierarchical navigation
#### Tree View Mode
Navigate skills in a hierarchical taxonomy:
| Key | Action |
|-----|--------|
| `v` | Toggle tree/list view |
| `→` or `Enter` | Expand category |
| `←` | Collapse / go back |
| `↑`/`↓` | Navigate |
Categories include: Development, Frontend, Backend, Mobile, DevOps, Testing, Security, AI/ML, Database, Tooling, Documentation, Performance
### Recommend Screen
AI-powered suggestions:
- Project analysis
- Confidence scoring
- Progress tracking
- Match percentages
## Visual Indicators
### Quality Grades
| Grade | Score | Color |
|-------|-------|-------|
| A | 90-100 | Green |
| B | 80-89 | Green |
| C | 70-79 | Yellow |
| D | 60-69 | Red |
| F | Below 60 | Red |
### Status Icons
| Icon | Meaning |
|------|---------|
| `●` | Enabled |
| `○` | Disabled |
| `⟁` | Claude Code |
| `◫` | Cursor |
| `◎` | Codex |
| `✦` | Gemini |
| `⬡` | OpenCode |
## Theme System
The TUI uses a monochromatic design with:
- Consistent color coding
- Terminal-compatible colors
- Visual accents for selection
- Muted states for disabled items
## Architecture
### State Management
```
loadSkills()
→ getSearchDirs(agentType)
→ findAllSkills(searchDirs)
→ evaluateSkillDirectory() for each
→ getQualityGrade(quality.overall)
→ SkillsState
```
### Performance Optimizations
- `createMemo` for filtered lists and computed values
- `createSignal` for reactive state management
- `createEffect` for side effects and subscriptions
- Windowed list rendering for large datasets
- Pagination limits rendered items
- Progressive animation with phases
### Animation Timing
| Animation | Delay |
|-----------|-------|
| Entrance | 100ms between phases |
| Spinner | 80ms interval |
| Progress | 200ms interval |
## Integration
The TUI integrates with @skillkit/core using Solid.js reactive patterns:
```typescript
import { createSignal, createMemo, createEffect } from 'solid-js';
const [skills, setSkills] = createSignal([]);
createEffect(async () => {
const result = await findAllSkills(searchDirs);
setSkills(result);
});
const filteredSkills = createMemo(() =>
skills().filter(s => s.name.includes(searchTerm()))
);
```
Core functions:
- `findAllSkills(searchDirs)` - Returns skill metadata
- `evaluateSkillDirectory(path)` - Quality metrics
- `getQualityGrade(score)` - 0-100 to A-F
## Graceful Exit
The TUI handles shutdown gracefully:
1. Runs Solid.js cleanup functions (`onCleanup`)
2. Restores terminal state
3. Cleans up signal handlers
4. Exits process cleanly
Press `q` from Home screen or `Ctrl+C` to exit.
-67
View File
@@ -1,67 +0,0 @@
---
title: Workflows
description: Compose skills into multi-step orchestrations
---
# Workflows
Compose skills into multi-step processes.
## Commands
```bash
skillkit workflow list # List workflows
skillkit workflow run <name> # Run workflow
skillkit workflow create <name> # Create workflow
```
## Workflow File
```yaml
name: feature-development
description: Complete feature workflow
steps:
- name: plan
skill: planning
- name: implement
skill: coding-standards
- name: test
skill: testing-patterns
- name: review
skill: code-review
```
## Features
### Conditional Steps
```yaml
steps:
- name: security
skill: security-audit
condition: "files.any('**/*.ts')"
```
### Parallel Execution
```yaml
steps:
- name: checks
parallel:
- skill: linting
- skill: testing
```
## Programmatic API
```typescript
import { WorkflowOrchestrator } from '@skillkit/core'
const orchestrator = new WorkflowOrchestrator()
const workflow = await orchestrator.load('./workflow.yaml')
await orchestrator.run(workflow)
```
-6
View File
@@ -1,6 +0,0 @@
/// <reference types="next" />
/// <reference types="next/image-types/global" />
import "./.next/types/routes.d.ts";
// NOTE: This file should not be edited
// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
-41
View File
@@ -1,41 +0,0 @@
import { createMDX } from 'fumadocs-mdx/next';
const withMDX = createMDX();
/** @type {import('next').NextConfig} */
const config = {
reactStrictMode: true,
trailingSlash: false,
skipTrailingSlashRedirect: true,
assetPrefix: 'https://skillkit-docs.vercel.app',
async headers() {
return [
{
source: '/:path*.(css|js|png|jpg|jpeg|svg|webp|woff2|woff|ttf|ico)',
headers: [
{ key: 'Cache-Control', value: 'public, max-age=86400, s-maxage=604800, stale-while-revalidate=2592000' },
],
},
{
source: '/_next/static/:path*',
headers: [
{ key: 'Cache-Control', value: 'public, max-age=31536000, immutable' },
],
},
{
source: '/docs/:path*',
headers: [
{ key: 'Cache-Control', value: 'public, max-age=300, s-maxage=86400, stale-while-revalidate=604800' },
],
},
{
source: '/',
headers: [
{ key: 'Cache-Control', value: 'public, max-age=300, s-maxage=86400, stale-while-revalidate=604800' },
],
},
];
},
};
export default withMDX(config);
-38
View File
@@ -1,38 +0,0 @@
{
"name": "skillkit-docs",
"version": "1.24.0",
"private": true,
"scripts": {
"build": "next build",
"dev": "next dev",
"start": "next start",
"types:check": "fumadocs-mdx && next typegen && tsc --noEmit",
"postinstall": "fumadocs-mdx",
"lint": "next lint"
},
"dependencies": {
"@google/genai": "^1.38.0",
"clsx": "^2.1.1",
"fumadocs-core": "16.3.2",
"fumadocs-mdx": "14.2.2",
"fumadocs-ui": "16.3.2",
"lucide-react": "^0.561.0",
"next": "16.0.10",
"next-themes": "^0.4.6",
"react": "^19.2.3",
"react-dom": "^19.2.3",
"tailwind-merge": "^3.4.0",
"turndown": "^7.2.2"
},
"devDependencies": {
"@tailwindcss/postcss": "^4.1.18",
"@types/mdx": "^2.0.13",
"@types/node": "^24.10.2",
"@types/react": "^19.2.7",
"@types/react-dom": "^19.2.3",
"@types/turndown": "^5.0.6",
"postcss": "^8.5.6",
"tailwindcss": "^4.1.18",
"typescript": "^5.9.3"
}
}
-3912
View File
File diff suppressed because it is too large Load Diff
-5
View File
@@ -1,5 +0,0 @@
export default {
plugins: {
'@tailwindcss/postcss': {},
},
};
Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.0 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 437 B

-4
View File
@@ -1,4 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
<rect width="32" height="32" fill="#000000"/>
<rect x="8" y="8" width="16" height="16" fill="#ffffff"/>
</svg>

Before

Width:  |  Height:  |  Size: 176 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 158 KiB

-138
View File
@@ -1,138 +0,0 @@
# Humans + agents welcome. Training crawlers + SEO scrapers blocked.
User-agent: Googlebot
Allow: /
User-agent: Bingbot
Allow: /
User-agent: DuckDuckBot
Allow: /
User-agent: Applebot
Allow: /
User-agent: ChatGPT-User
Allow: /
User-agent: OAI-SearchBot
Allow: /
User-agent: PerplexityBot
Allow: /
User-agent: Perplexity-User
Allow: /
User-agent: Claude-User
Allow: /
User-agent: Claude-SearchBot
Allow: /
User-agent: FirecrawlAgent
Allow: /
User-agent: firecrawl
Allow: /
User-agent: Context7Bot
Allow: /
User-agent: Crawl4AI
Allow: /
User-agent: Clawdbot
Allow: /
User-agent: OpenClaw
Allow: /
User-agent: Hermes
Allow: /
User-agent: GPTBot
Disallow: /
User-agent: ClaudeBot
Disallow: /
User-agent: anthropic-ai
Disallow: /
User-agent: CCBot
Disallow: /
User-agent: Google-Extended
Disallow: /
User-agent: Applebot-Extended
Disallow: /
User-agent: Bytespider
Disallow: /
User-agent: Amazonbot
Disallow: /
User-agent: FacebookBot
Disallow: /
User-agent: Meta-ExternalAgent
Disallow: /
User-agent: cohere-ai
Disallow: /
User-agent: Diffbot
Disallow: /
User-agent: ImagesiftBot
Disallow: /
User-agent: Omgilibot
Disallow: /
User-agent: peer39_crawler
Disallow: /
User-agent: YouBot
Disallow: /
User-agent: Timpibot
Disallow: /
User-agent: ICC-Crawler
Disallow: /
User-agent: AhrefsBot
Disallow: /
User-agent: SemrushBot
Disallow: /
User-agent: MJ12bot
Disallow: /
User-agent: DotBot
Disallow: /
User-agent: PetalBot
Disallow: /
User-agent: BLEXBot
Disallow: /
User-agent: MegaIndex
Disallow: /
User-agent: SeznamBot
Disallow: /
User-agent: DataForSeoBot
Disallow: /
User-agent: *
Allow: /
Sitemap: https://skillkit-docs.vercel.app/sitemap.xml
-21
View File
@@ -1,21 +0,0 @@
import {
defineConfig,
defineDocs,
frontmatterSchema,
metaSchema,
} from 'fumadocs-mdx/config';
export const docs = defineDocs({
dir: 'content/docs',
docs: {
schema: frontmatterSchema,
postprocess: {
includeProcessedMarkdown: true,
},
},
meta: {
schema: metaSchema,
},
});
export default defineConfig({});
-41
View File
@@ -1,41 +0,0 @@
import Link from 'next/link'
export default function HomeLayout({
children,
}: {
children: React.ReactNode
}) {
return (
<>
<nav className="fixed top-0 left-0 right-0 z-50 border-b border-zinc-800 bg-black/90 backdrop-blur-md">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="flex h-14 items-center justify-between">
<Link href="/" className="flex items-center gap-2">
<div className="w-4 h-4 bg-white"></div>
<span className="text-base font-bold tracking-tight text-white font-mono">SKILLKIT</span>
</Link>
<div className="flex items-center gap-4">
<Link
href="/docs"
className="text-zinc-400 hover:text-white transition-colors text-sm font-mono"
>
Docs
</Link>
<a
href="https://github.com/rohitg00/skillkit"
target="_blank"
rel="noopener noreferrer"
className="text-zinc-400 hover:text-white transition-colors text-sm font-mono"
>
GitHub
</a>
</div>
</div>
</div>
</nav>
<div className="pt-14">
{children}
</div>
</>
)
}
-96
View File
@@ -1,96 +0,0 @@
import Link from 'next/link'
export default function HomePage() {
return (
<div className="min-h-screen bg-black text-zinc-100">
<main className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8 py-20">
{/* Hero */}
<div className="text-center mb-16">
<div className="inline-flex items-center space-x-2 border border-zinc-800 bg-zinc-900/50 px-3 py-1 mb-6">
<span className="flex h-2 w-2 bg-white rounded-full"></span>
<span className="text-sm font-mono text-zinc-400">v1.8.0</span>
</div>
<h1 className="text-4xl sm:text-5xl lg:text-6xl font-bold tracking-tight text-white mb-6 font-mono">
Universal Skills for<br />
<span className="text-zinc-500">AI Coding Agents</span>
</h1>
<p className="text-lg text-zinc-400 mb-8 max-w-2xl mx-auto font-mono">
One CLI to install, sync, and manage skills across Claude Code, Cursor,
Windsurf, Copilot, and 40 more agents. 400K+ skills ready to use.
</p>
<div className="flex flex-wrap justify-center gap-4 mb-12">
<code className="inline-flex items-center bg-zinc-900 border border-zinc-700 px-4 py-3 text-sm font-mono">
<span className="text-zinc-500 mr-2">$</span>
<span className="text-white">npx skillkit@latest</span>
</code>
<Link
href="/docs"
className="inline-flex items-center bg-white text-black px-6 py-3 font-mono text-sm hover:bg-zinc-200 transition-colors"
>
Read the Docs →
</Link>
</div>
</div>
{/* Features Grid */}
<div className="grid grid-cols-1 md:grid-cols-3 gap-6 mb-16">
<div className="border border-zinc-800 bg-zinc-900/30 p-6">
<h3 className="text-lg font-bold text-white mb-2 font-mono">45 Agents</h3>
<p className="text-zinc-500 text-sm">Claude, Cursor, Codex, Windsurf, Copilot, and 40 more supported out of the box.</p>
</div>
<div className="border border-zinc-800 bg-zinc-900/30 p-6">
<h3 className="text-lg font-bold text-white mb-2 font-mono">400K+ Skills</h3>
<p className="text-zinc-500 text-sm">Aggregated from 34+ registries and repositories. Install with a single command.</p>
</div>
<div className="border border-zinc-800 bg-zinc-900/30 p-6">
<h3 className="text-lg font-bold text-white mb-2 font-mono">Auto Translation</h3>
<p className="text-zinc-500 text-sm">Write once, deploy everywhere. Automatic format conversion between all agents.</p>
</div>
</div>
{/* Quick Links */}
<div className="text-center">
<h2 className="text-2xl font-bold text-white mb-6 font-mono">Get Started</h2>
<div className="flex flex-wrap justify-center gap-4">
<Link href="/docs/quickstart" className="text-zinc-400 hover:text-white font-mono text-sm border border-zinc-800 px-4 py-2 hover:border-zinc-600 transition-colors">
Quick Start
</Link>
<Link href="/docs/primer" className="text-zinc-400 hover:text-white font-mono text-sm border border-zinc-800 px-4 py-2 hover:border-zinc-600 transition-colors">
Primer
</Link>
<Link href="/docs/memory" className="text-zinc-400 hover:text-white font-mono text-sm border border-zinc-800 px-4 py-2 hover:border-zinc-600 transition-colors">
Memory System
</Link>
<Link href="/docs/mesh" className="text-zinc-400 hover:text-white font-mono text-sm border border-zinc-800 px-4 py-2 hover:border-zinc-600 transition-colors">
Mesh Network
</Link>
<Link href="/docs/api-reference" className="text-zinc-400 hover:text-white font-mono text-sm border border-zinc-800 px-4 py-2 hover:border-zinc-600 transition-colors">
API Reference
</Link>
</div>
</div>
</main>
{/* Footer */}
<footer className="border-t border-zinc-800 py-8">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="flex flex-col sm:flex-row items-center justify-between gap-4">
<div className="flex items-center gap-2">
<div className="w-4 h-4 bg-white"></div>
<span className="font-mono font-bold text-white">SKILLKIT</span>
</div>
<div className="flex items-center gap-6 text-sm font-mono text-zinc-500">
<a href="https://github.com/rohitg00/skillkit" target="_blank" rel="noopener noreferrer" className="hover:text-white transition-colors">GitHub</a>
<a href="https://www.npmjs.com/package/skillkit" target="_blank" rel="noopener noreferrer" className="hover:text-white transition-colors">npm</a>
<Link href="/docs" className="hover:text-white transition-colors">Docs</Link>
</div>
</div>
</div>
</footer>
</div>
)
}
@@ -1,190 +0,0 @@
import { GoogleGenAI, Type, Schema } from "@google/genai";
import { NextRequest, NextResponse } from "next/server";
const rateLimitMap = new Map<string, { count: number; resetTime: number }>();
const RATE_LIMIT_WINDOW_MS = 60 * 1000;
const RATE_LIMIT_MAX_REQUESTS = 10;
function getRateLimitKey(request: NextRequest): string {
const forwarded = request.headers.get("x-forwarded-for");
const ip = forwarded ? forwarded.split(",")[0].trim() : "unknown";
return ip;
}
function checkRateLimit(key: string): { allowed: boolean; remaining: number } {
const now = Date.now();
const entry = rateLimitMap.get(key);
if (!entry || now > entry.resetTime) {
rateLimitMap.set(key, { count: 1, resetTime: now + RATE_LIMIT_WINDOW_MS });
return { allowed: true, remaining: RATE_LIMIT_MAX_REQUESTS - 1 };
}
if (entry.count >= RATE_LIMIT_MAX_REQUESTS) {
return { allowed: false, remaining: 0 };
}
entry.count++;
return { allowed: true, remaining: RATE_LIMIT_MAX_REQUESTS - entry.count };
}
const agentSkillSchema: Schema = {
type: Type.OBJECT,
properties: {
name: { type: Type.STRING, description: "Skill name in slug format (e.g., 'react-best-practices')" },
title: { type: Type.STRING, description: "Human readable title" },
description: { type: Type.STRING, description: "Brief description of what this skill teaches AI agents" },
version: { type: Type.STRING, description: "Semantic version (e.g., '1.0.0')" },
tags: {
type: Type.ARRAY,
items: { type: Type.STRING },
description: "Tags for categorization"
},
applicability: { type: Type.STRING, description: "When the AI agent should apply this skill (e.g., 'Apply when working with React components')" },
principles: {
type: Type.ARRAY,
items: {
type: Type.OBJECT,
properties: {
title: { type: Type.STRING },
description: { type: Type.STRING, description: "Detailed instruction for the AI agent" },
priority: { type: Type.STRING, description: "must, should, or may" }
},
required: ["title", "description", "priority"]
},
description: "Core principles and guidelines (5-8 items)"
},
patterns: {
type: Type.ARRAY,
items: {
type: Type.OBJECT,
properties: {
name: { type: Type.STRING },
description: { type: Type.STRING },
example: { type: Type.STRING, description: "Code example demonstrating the pattern" },
language: { type: Type.STRING, description: "Programming language for syntax highlighting" }
},
required: ["name", "description", "example"]
},
description: "Code patterns with examples (3-5 items)"
},
antiPatterns: {
type: Type.ARRAY,
items: {
type: Type.OBJECT,
properties: {
name: { type: Type.STRING },
description: { type: Type.STRING },
badExample: { type: Type.STRING, description: "Code showing what NOT to do" },
goodExample: { type: Type.STRING, description: "Code showing the correct approach" }
},
required: ["name", "description"]
},
description: "Anti-patterns to avoid (2-4 items)"
},
filePatterns: {
type: Type.ARRAY,
items: { type: Type.STRING },
description: "Glob patterns for files this skill applies to (e.g., '*.tsx', 'src/components/**')"
},
references: {
type: Type.ARRAY,
items: { type: Type.STRING },
description: "Links to official documentation or resources"
}
},
required: ["name", "title", "description", "version", "tags", "applicability", "principles", "patterns", "antiPatterns"]
};
export async function POST(request: NextRequest): Promise<NextResponse> {
const rateLimitKey = getRateLimitKey(request);
const { allowed, remaining } = checkRateLimit(rateLimitKey);
if (!allowed) {
return NextResponse.json(
{ error: "Rate limit exceeded. Please try again later." },
{
status: 429,
headers: {
"X-RateLimit-Remaining": "0",
"Retry-After": "60",
},
}
);
}
let body: unknown;
try {
body = await request.json();
} catch {
return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
}
if (typeof body !== "object" || body === null) {
return NextResponse.json({ error: "Invalid request body" }, { status: 400 });
}
const { topic } = body as { topic?: unknown };
if (typeof topic !== "string") {
return NextResponse.json({ error: "Topic is required and must be a string" }, { status: 400 });
}
const sanitizedTopic = topic.trim().slice(0, 500);
if (!sanitizedTopic) {
return NextResponse.json({ error: "Topic cannot be empty" }, { status: 400 });
}
const apiKey = process.env.GEMINI_API_KEY;
if (!apiKey) {
return NextResponse.json({ error: "Gemini API key not configured" }, { status: 500 });
}
try {
const ai = new GoogleGenAI({ apiKey });
const response = await ai.models.generateContent({
model: "gemini-2.0-flash",
contents: `Create a comprehensive AI coding agent skill for: "${sanitizedTopic}"
This skill will be used by AI coding assistants (like Claude Code, Cursor, GitHub Copilot) to provide better code suggestions and follow best practices.
The skill should include:
1. Clear principles that tell the AI WHAT to do and WHEN
2. Code patterns with REAL, WORKING examples (not pseudocode)
3. Anti-patterns showing common mistakes and how to fix them
4. Specific file patterns where this skill applies
Make the instructions actionable and specific. The AI agent should be able to directly apply these guidelines when writing code.
Focus on practical, production-ready patterns used in modern development.`,
config: {
responseMimeType: "application/json",
responseSchema: agentSkillSchema,
systemInstruction: `You are an expert software architect creating AI agent skills.
Your skills are used by AI coding assistants to write better code.
Guidelines:
- Write instructions as commands to the AI (e.g., "Always use...", "Never...", "Prefer...")
- Include REAL code examples, not pseudocode
- Be specific and actionable
- Focus on modern best practices (2024+)
- Include edge cases and error handling patterns
- Make principles enforceable and testable`
}
});
if (!response.text) {
return NextResponse.json({ error: "No response from Gemini" }, { status: 500 });
}
const data = JSON.parse(response.text);
return NextResponse.json(data, {
headers: {
"X-RateLimit-Remaining": String(remaining),
},
});
} catch (error) {
console.error("Gemini API Error:", error);
return NextResponse.json({ error: "Failed to generate skill" }, { status: 500 });
}
}
@@ -1,291 +0,0 @@
import { NextRequest, NextResponse } from 'next/server';
import TurndownService from 'turndown';
const rateLimitMap = new Map<string, { count: number; resetTime: number }>();
const RATE_LIMIT_WINDOW_MS = 60 * 1000;
const RATE_LIMIT_MAX_REQUESTS = 10;
function checkRateLimit(key: string): { allowed: boolean; remaining: number } {
const now = Date.now();
const entry = rateLimitMap.get(key);
if (!entry || now > entry.resetTime) {
rateLimitMap.set(key, { count: 1, resetTime: now + RATE_LIMIT_WINDOW_MS });
return { allowed: true, remaining: RATE_LIMIT_MAX_REQUESTS - 1 };
}
if (entry.count >= RATE_LIMIT_MAX_REQUESTS) {
return { allowed: false, remaining: 0 };
}
entry.count++;
return { allowed: true, remaining: RATE_LIMIT_MAX_REQUESTS - entry.count };
}
const BLOCKED_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]', '::1', '0.0.0.0']);
function isAllowedUrl(url: string): boolean {
try {
const parsed = new URL(url);
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return false;
const hostname = parsed.hostname.toLowerCase();
const bare = hostname.replace(/^\[|\]$/g, '');
if (BLOCKED_HOSTS.has(hostname) || BLOCKED_HOSTS.has(bare)) return false;
if (bare.startsWith('::ffff:')) return isAllowedUrl(`http://${bare.slice(7)}`);
if (/^127\./.test(bare) || /^0\./.test(bare)) return false;
if (bare.startsWith('10.') || bare.startsWith('192.168.')) return false;
if (/^172\.(1[6-9]|2\d|3[01])\./.test(bare)) return false;
if (bare.startsWith('169.254.')) return false;
if (bare.startsWith('fe80:') || bare.startsWith('fc00:') || bare.startsWith('fd')) return false;
if (/^(22[4-9]|23\d|24\d|25[0-5])\./.test(bare)) return false;
if (/^ff[0-9a-f]{2}:/.test(bare)) return false;
return true;
} catch {
return false;
}
}
const GITHUB_URL_PATTERN = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/;
const GITHUB_RAW_PATTERN = /^https?:\/\/raw\.githubusercontent\.com\//;
const FETCH_TIMEOUT = 30_000;
const TECH_KEYWORDS = new Set([
'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix',
'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby',
'node', 'deno', 'bun', 'docker', 'kubernetes', 'terraform',
'aws', 'gcp', 'azure', 'vercel', 'netlify', 'cloudflare',
'graphql', 'rest', 'grpc', 'websocket', 'redis', 'postgres',
'mongodb', 'sqlite', 'mysql', 'prisma', 'drizzle',
'tailwind', 'css', 'html', 'sass', 'webpack', 'vite', 'esbuild',
'git', 'ci', 'cd', 'testing', 'security', 'authentication',
'api', 'cli', 'sdk', 'mcp', 'llm', 'ai', 'ml', 'openai', 'anthropic',
]);
const TAG_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
const turndown = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced' });
interface ExtractedContent {
title: string;
content: string;
sourceUrl: string;
contentType: string;
language?: string;
}
async function extractFromUrl(url: string): Promise<ExtractedContent> {
if (GITHUB_URL_PATTERN.test(url) || GITHUB_RAW_PATTERN.test(url)) {
return fetchGitHubContent(url);
}
const MAX_BODY_SIZE = 5 * 1024 * 1024;
const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT) });
if (!response.ok) {
throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
}
const contentLength = Number(response.headers.get('content-length') || '0');
if (contentLength > MAX_BODY_SIZE) {
throw new Error('Response too large');
}
const contentType = response.headers.get('content-type') ?? '';
const body = await response.text();
if (body.length > MAX_BODY_SIZE) {
throw new Error('Response too large');
}
if (contentType.includes('text/html')) {
const titleMatch = body.match(/<title[^>]*>([^<]+)<\/title>/i);
const title = titleMatch?.[1]?.trim() ?? new URL(url).hostname;
const bodyMatch = body.match(/<body[^>]*>([\s\S]*)<\/body>/i);
const content = turndown.turndown(bodyMatch?.[1] ?? body);
return { title, content, sourceUrl: url, contentType: 'webpage' };
}
const title = new URL(url).pathname.split('/').pop() ?? 'Untitled';
return { title, content: body, sourceUrl: url, contentType: 'text' };
}
const LANG_MAP: Record<string, string> = {
'.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript', '.jsx': 'javascript',
'.py': 'python', '.rb': 'ruby', '.go': 'go', '.rs': 'rust', '.java': 'java',
'.kt': 'kotlin', '.swift': 'swift', '.sh': 'shell', '.yml': 'yaml', '.yaml': 'yaml',
'.json': 'json', '.md': 'markdown', '.html': 'html', '.css': 'css', '.sql': 'sql',
};
async function fetchGitHubContent(url: string): Promise<ExtractedContent> {
let rawUrl = url;
const match = url.match(GITHUB_URL_PATTERN);
if (match) {
const [, owner, repo, branch, path] = match;
rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${path}`;
}
const MAX_BODY_SIZE = 5 * 1024 * 1024;
const response = await fetch(rawUrl, { signal: AbortSignal.timeout(FETCH_TIMEOUT) });
if (!response.ok) {
throw new Error(`Failed to fetch GitHub content: ${response.status} ${response.statusText}`);
}
const contentLength = Number(response.headers.get('content-length') || '0');
if (contentLength > MAX_BODY_SIZE) {
throw new Error('Response too large');
}
const body = await response.text();
if (body.length > MAX_BODY_SIZE) {
throw new Error('Response too large');
}
const filename = rawUrl.split('/').pop() ?? 'file';
const ext = filename.includes('.') ? '.' + filename.split('.').pop()!.toLowerCase() : '';
const language = LANG_MAP[ext];
const isCode = language !== undefined && language !== 'markdown';
const content = isCode ? `\`\`\`${language}\n${body}\n\`\`\`` : body;
return { title: filename, content, sourceUrl: url, contentType: 'github', language };
}
function addTag(counts: Map<string, number>, tag: string, weight: number): void {
if (TAG_PATTERN.test(tag)) {
counts.set(tag, (counts.get(tag) ?? 0) + weight);
}
}
function detectTags(extracted: ExtractedContent): string[] {
const counts = new Map<string, number>();
try {
const segments = new URL(extracted.sourceUrl).pathname
.split('/').filter(Boolean)
.map((s) => s.toLowerCase().replace(/[^a-z0-9-]/g, ''));
for (const seg of segments) {
if (seg.length >= 2 && seg.length <= 30) {
addTag(counts, seg, 2);
}
}
} catch { /* skip */ }
const headingRe = /^#{1,2}\s+(.+)$/gm;
let m: RegExpExecArray | null;
while ((m = headingRe.exec(extracted.content)) !== null) {
for (const word of m[1].toLowerCase().split(/\s+/)) {
const cleaned = word.replace(/[^a-z0-9-]/g, '');
if (cleaned.length >= 2) {
addTag(counts, cleaned, 2);
}
}
}
const codeBlockRe = /^```(\w+)/gm;
while ((m = codeBlockRe.exec(extracted.content)) !== null) {
const lang = m[1].toLowerCase();
if (lang.length >= 2) {
addTag(counts, lang, 3);
}
}
const lower = extracted.content.toLowerCase();
for (const keyword of TECH_KEYWORDS) {
if (new RegExp(`\\b${keyword}\\b`, 'i').test(lower)) {
addTag(counts, keyword, 1);
}
}
if (extracted.language) {
addTag(counts, extracted.language.toLowerCase(), 3);
}
return Array.from(counts.entries())
.sort((a, b) => b[1] - a[1])
.slice(0, 10)
.map(([tag]) => tag);
}
function slugify(input: string): string {
const slug = input
.toLowerCase()
.replace(/[^a-z0-9]+/g, '-')
.replace(/^-+|-+$/g, '')
.replace(/-{2,}/g, '-');
return slug.slice(0, 64).replace(/-+$/, '') || 'untitled-skill';
}
function yamlEscape(value: string): string {
const singleLine = value.replace(/\r?\n/g, ' ').trim();
if (/[:#{}[\],&*?|>!%@`]/.test(singleLine) || singleLine.startsWith("'") || singleLine.startsWith('"')) {
return `"${singleLine.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
}
return singleLine;
}
export async function POST(request: NextRequest) {
const ip = request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ?? 'unknown';
const { allowed, remaining } = checkRateLimit(ip);
if (!allowed) {
return NextResponse.json(
{ error: 'Too many requests. Try again in a minute.' },
{ status: 429, headers: { 'X-RateLimit-Remaining': '0', 'Retry-After': '60' } },
);
}
let body: { url?: string; name?: string };
try {
body = await request.json();
} catch {
return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
}
const { url, name } = body;
if (!url || typeof url !== 'string') {
return NextResponse.json({ error: 'Missing required field: url' }, { status: 400 });
}
if (name !== undefined && typeof name !== 'string') {
return NextResponse.json({ error: 'Field "name" must be a string' }, { status: 400 });
}
if (!isAllowedUrl(url)) {
return NextResponse.json({ error: 'URL not allowed' }, { status: 403 });
}
try {
const extracted = await extractFromUrl(url);
const tags = detectTags(extracted);
const skillName = slugify(name || extracted.title || 'untitled');
const description = extracted.content
.split('\n')
.find((l) => l.trim().length > 0)
?.replace(/^#+\s*/, '')
.trim()
.slice(0, 200) || 'Saved skill';
const savedAt = new Date().toISOString();
const yamlTags = tags.length > 0
? `tags:\n${tags.map((t) => ` - ${t}`).join('\n')}\n`
: '';
const skillMd =
`---\n` +
`name: ${skillName}\n` +
`description: ${yamlEscape(description)}\n` +
yamlTags +
`metadata:\n` +
` source: ${yamlEscape(url)}\n` +
` savedAt: ${savedAt}\n` +
`---\n\n` +
extracted.content + '\n';
return NextResponse.json(
{ name: skillName, skillMd, tags, description },
{ headers: { 'X-RateLimit-Remaining': String(remaining) } },
);
} catch (err) {
const message = err instanceof Error ? err.message : 'Failed to extract content';
return NextResponse.json({ error: message }, { status: 502 });
}
}
@@ -1,42 +0,0 @@
import { source } from '@/lib/source'
import { DocsBody, DocsDescription, DocsPage, DocsTitle } from 'fumadocs-ui/layouts/docs/page'
import { notFound } from 'next/navigation'
import { getMDXComponents } from '@/mdx-components'
import type { Metadata } from 'next'
interface PageProps {
params: Promise<{ slug?: string[] }>
}
export default async function Page(props: PageProps) {
const params = await props.params
const page = source.getPage(params.slug ?? [])
if (!page) notFound()
const MDX = page.data.body
return (
<DocsPage toc={page.data.toc} full={page.data.full} tableOfContent={{ style: 'clerk' }}>
<DocsTitle>{page.data.title}</DocsTitle>
<DocsDescription>{page.data.description}</DocsDescription>
<DocsBody>
<MDX components={getMDXComponents({})} />
</DocsBody>
</DocsPage>
)
}
export async function generateStaticParams() {
return source.generateParams()
}
export async function generateMetadata(props: PageProps): Promise<Metadata> {
const params = await props.params
const page = source.getPage(params.slug ?? [])
if (!page) notFound()
return {
title: page.data.title,
description: page.data.description,
}
}
-17
View File
@@ -1,17 +0,0 @@
import { baseOptions } from '@/lib/layout.shared'
import { source } from '@/lib/source'
import { DocsLayout } from 'fumadocs-ui/layouts/docs'
export default function Layout({ children }: { children: React.ReactNode }) {
return (
<DocsLayout
tree={source.pageTree}
{...baseOptions()}
sidebar={{
collapsible: true,
}}
>
{children}
</DocsLayout>
)
}
-160
View File
@@ -1,160 +0,0 @@
@import 'tailwindcss';
@import 'fumadocs-ui/css/neutral.css';
@import 'fumadocs-ui/css/preset.css';
@theme {
--font-sans: "Inter", ui-sans-serif, system-ui, sans-serif;
--color-skillkit-black: #000000;
--color-skillkit-dark: #18181b;
--color-skillkit-medium: #71717a;
--color-skillkit-light: #fafafa;
--color-skillkit-blue: #3b82f6;
/* Light mode defaults */
--color-fd-background: #ffffff;
--color-fd-foreground: var(--color-skillkit-black);
--color-fd-muted: #f4f4f5;
--color-fd-muted-foreground: var(--color-skillkit-medium);
--color-fd-popover: #ffffff;
--color-fd-popover-foreground: var(--color-skillkit-black);
--color-fd-card: #ffffff;
--color-fd-card-foreground: var(--color-skillkit-black);
--color-fd-border: #e4e4e7;
--color-fd-primary: var(--color-skillkit-blue);
--color-fd-primary-foreground: #ffffff;
--color-fd-secondary: #f4f4f5;
--color-fd-secondary-foreground: var(--color-skillkit-black);
--color-fd-accent: #f4f4f5;
--color-fd-accent-foreground: var(--color-skillkit-black);
--color-fd-ring: var(--color-skillkit-blue);
}
/* Dark mode */
:root.dark {
--color-fd-background: var(--color-skillkit-black);
--color-fd-foreground: var(--color-skillkit-light);
--color-fd-muted: var(--color-skillkit-dark);
--color-fd-muted-foreground: #a1a1aa;
--color-fd-popover: var(--color-skillkit-dark);
--color-fd-popover-foreground: var(--color-skillkit-light);
--color-fd-card: var(--color-skillkit-dark);
--color-fd-card-foreground: var(--color-skillkit-light);
--color-fd-border: #27272a;
--color-fd-primary: var(--color-skillkit-blue);
--color-fd-primary-foreground: #ffffff;
--color-fd-secondary: var(--color-skillkit-dark);
--color-fd-secondary-foreground: var(--color-skillkit-light);
--color-fd-accent: var(--color-skillkit-dark);
--color-fd-accent-foreground: var(--color-skillkit-light);
--color-fd-ring: var(--color-skillkit-blue);
}
body {
background-color: var(--color-fd-background);
color: var(--color-fd-foreground);
}
::selection {
background-color: var(--color-skillkit-blue);
color: #ffffff;
}
/* Light mode code blocks */
pre {
background-color: #f8f8f8 !important;
border: 1px solid #e4e4e7;
}
code {
background-color: #f4f4f5;
color: var(--color-skillkit-black);
padding: 0.2em 0.4em;
border-radius: 4px;
font-size: 0.875em;
}
pre code {
background-color: transparent;
color: inherit;
padding: 0;
}
/* Dark mode code blocks */
:root.dark pre {
background-color: #0d0d0d !important;
border: 1px solid #27272a;
}
:root.dark code {
background-color: #27272a;
color: #e4e4e7;
}
:root.dark pre code {
background-color: transparent;
}
/* Inline code in paragraphs */
p code, li code, td code {
font-weight: 500;
}
/* Tables */
table {
width: 100%;
border-collapse: collapse;
}
th, td {
padding: 0.75rem 1rem;
text-align: left;
border-bottom: 1px solid var(--color-fd-border);
}
th {
font-weight: 600;
background-color: var(--color-fd-muted);
}
/* Lists */
ul, ol {
padding-left: 1.5rem;
}
li {
margin: 0.5rem 0;
}
/* Landing page animations */
@keyframes scroll {
0% { transform: translateX(0); }
100% { transform: translateX(-50%); }
}
.animate-scroll {
animation: scroll 35s linear infinite;
}
@keyframes fade-in {
from { opacity: 0; transform: translateY(10px); }
to { opacity: 1; transform: translateY(0); }
}
.animate-fade-in {
animation: fade-in 0.6s ease-out forwards;
}
.animate-fade-in-delay {
animation: fade-in 0.6s ease-out 0.2s forwards;
opacity: 0;
}
/* Landing page specific styles */
.bg-background {
background-color: #000000;
}
.bg-surface {
background-color: rgba(24, 24, 27, 0.5);
}
-48
View File
@@ -1,48 +0,0 @@
import { RootProvider } from 'fumadocs-ui/provider/next'
import './global.css'
import { Inter } from 'next/font/google'
import type { Metadata } from 'next'
const inter = Inter({
subsets: ['latin'],
weight: ['400', '500', '600', '700'],
})
export const metadata: Metadata = {
title: {
default: 'SkillKit - Universal Skills for AI Coding Agents',
template: '%s | SkillKit',
},
description: 'One CLI to install, sync, and manage skills across Claude Code, Cursor, Windsurf, Copilot, and 40 more agents. 400K+ skills ready to use.',
icons: {
icon: [
{ url: '/favicon.svg', type: 'image/svg+xml' },
{ url: '/favicon-32.png', sizes: '32x32', type: 'image/png' },
],
apple: '/apple-touch-icon.png',
},
openGraph: {
title: 'SkillKit - Universal Skills for AI Coding Agents',
description: 'One CLI to install, sync, and manage skills across Claude Code, Cursor, Windsurf, Copilot, and 28 more agents.',
url: 'https://skillkit.sh',
siteName: 'SkillKit',
images: [{ url: '/og-image.png', width: 1200, height: 630 }],
type: 'website',
},
twitter: {
card: 'summary_large_image',
title: 'SkillKit - Universal Skills for AI Coding Agents',
description: 'One CLI to install, sync, and manage skills across Claude Code, Cursor, Windsurf, Copilot, and 28 more agents.',
images: ['/og-image.png'],
},
}
export default function Layout({ children }: { children: React.ReactNode }) {
return (
<html lang="en" className={inter.className} suppressHydrationWarning>
<body className="flex flex-col min-h-screen">
<RootProvider>{children}</RootProvider>
</body>
</html>
)
}
File diff suppressed because one or more lines are too long
-55
View File
@@ -1,55 +0,0 @@
import React from 'react';
interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
variant?: 'primary' | 'secondary' | 'outline' | 'ghost';
fullWidth?: boolean;
isLoading?: boolean;
}
const BASE_STYLES = "inline-flex items-center justify-center px-6 py-3 text-sm font-medium transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-offset-black disabled:opacity-50 font-mono tracking-tight";
const VARIANT_STYLES = {
primary: "bg-white text-black hover:bg-zinc-200 border border-white",
secondary: "bg-zinc-900 text-zinc-100 hover:bg-zinc-800 border border-zinc-800",
outline: "bg-transparent text-zinc-300 border border-zinc-700 hover:border-zinc-500 hover:text-white",
ghost: "bg-transparent text-zinc-400 hover:text-white hover:bg-zinc-900"
} as const;
export function Button({
children,
variant = 'primary',
className = '',
fullWidth = false,
isLoading = false,
disabled,
type = 'button',
...props
}: ButtonProps): React.ReactElement {
const widthClass = fullWidth ? 'w-full' : '';
const classes = [
BASE_STYLES,
VARIANT_STYLES[variant],
widthClass,
className,
].filter(Boolean).join(' ');
return (
<button
className={classes}
type={type}
disabled={disabled || isLoading}
{...props}
>
{isLoading ? (
<>
<svg className="animate-spin -ml-1 mr-2 h-4 w-4" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
</svg>
PROCESSING
</>
) : children}
</button>
);
}
-49
View File
@@ -1,49 +0,0 @@
import React from 'react';
interface CardProps {
children: React.ReactNode;
className?: string;
noPadding?: boolean;
onClick?: () => void;
onDragOver?: (e: React.DragEvent) => void;
onDragLeave?: (e: React.DragEvent) => void;
onDrop?: (e: React.DragEvent) => void;
}
export function Card({
children,
className = '',
noPadding = false,
onClick,
onDragOver,
onDragLeave,
onDrop
}: CardProps): React.ReactElement {
const paddingClass = noPadding ? '' : 'p-6';
const clickableClass = onClick ? 'cursor-pointer' : '';
function handleKeyDown(e: React.KeyboardEvent): void {
if (!onClick) return;
if (e.key === 'Enter' || e.key === ' ') {
if (e.key === ' ') {
e.preventDefault();
}
onClick();
}
}
return (
<div
className={`relative bg-black border border-zinc-800 transition-colors duration-300 ${paddingClass} ${clickableClass} ${className}`}
onClick={onClick}
role={onClick ? 'button' : undefined}
tabIndex={onClick ? 0 : undefined}
onKeyDown={onClick ? handleKeyDown : undefined}
onDragOver={onDragOver}
onDragLeave={onDragLeave}
onDrop={onDrop}
>
{children}
</div>
);
}
-112
View File
@@ -1,112 +0,0 @@
import React, { useState } from 'react';
interface CommandGroup {
name: string;
commands: Array<{ cmd: string; desc: string }>;
}
const COMMAND_GROUPS: CommandGroup[] = [
{
name: 'Core',
commands: [
{ cmd: 'install', desc: 'Install from GitHub/GitLab/local' },
{ cmd: 'sync', desc: 'Sync skills across agents' },
{ cmd: 'translate', desc: 'Convert between agent formats' },
{ cmd: 'update', desc: 'Update installed skills' },
],
},
{
name: 'Discovery',
commands: [
{ cmd: 'find', desc: 'Search marketplace (400K+ skills)' },
{ cmd: 'recommend', desc: 'AI-powered suggestions' },
{ cmd: 'check', desc: 'Dry-run update check' },
{ cmd: 'list', desc: 'View installed skills' },
],
},
{
name: 'Team',
commands: [
{ cmd: 'manifest init', desc: 'Create .skills file' },
{ cmd: 'manifest install', desc: 'Install from manifest' },
{ cmd: 'team share', desc: 'Share skills via Git' },
{ cmd: 'publish', desc: 'Submit to marketplace' },
],
},
{
name: 'Security',
commands: [
{ cmd: 'scan <path>', desc: 'Security vulnerability scanner' },
{ cmd: 'scan --format sarif', desc: 'SARIF for GitHub Code Scanning' },
{ cmd: 'scan --fail-on high', desc: 'CI security gate' },
{ cmd: 'audit log', desc: 'View audit trail' },
],
},
{
name: 'Advanced',
commands: [
{ cmd: 'ui', desc: 'Launch terminal UI' },
{ cmd: 'workflow run', desc: 'Execute skill pipelines' },
{ cmd: 'command generate', desc: 'Create /slash commands' },
{ cmd: 'cicd init', desc: 'Generate CI templates' },
],
},
];
export function Commands(): React.ReactElement {
const [activeGroup, setActiveGroup] = useState(0);
const group = COMMAND_GROUPS[activeGroup];
return (
<section className="py-12 border-b border-zinc-800">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="text-center mb-8">
<h2 className="text-xl font-bold text-white mb-2 font-mono">40+ Commands</h2>
<p className="text-zinc-500 font-mono text-sm">
Everything you need from the terminal.
</p>
</div>
<div className="flex justify-center gap-2 mb-6">
{COMMAND_GROUPS.map((g, i) => {
const isActive = i === activeGroup;
const buttonClass = isActive
? 'border-white text-white bg-zinc-900'
: 'border-zinc-800 text-zinc-500 hover:border-zinc-600 hover:text-zinc-300';
return (
<button
key={g.name}
onClick={() => setActiveGroup(i)}
className={`px-3 py-1.5 text-xs font-mono border transition-colors ${buttonClass}`}
>
{g.name}
</button>
);
})}
</div>
<div className="border border-zinc-800 bg-black/50 p-4 font-mono text-xs">
<div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
{group.commands.map((c) => (
<div
key={c.cmd}
className="flex items-center gap-3 p-2 hover:bg-zinc-900/50 transition-colors rounded"
>
<span className="text-zinc-600">$</span>
<span className="text-white">skillkit {c.cmd}</span>
<span className="text-zinc-600 hidden sm:inline">→</span>
<span className="text-zinc-500 hidden sm:inline truncate">{c.desc}</span>
</div>
))}
</div>
</div>
<div className="mt-4 text-center">
<span className="text-zinc-600 text-xs font-mono">
Run <span className="text-zinc-400">skillkit --help</span> for all commands
</span>
</div>
</div>
</section>
);
}
@@ -1,538 +0,0 @@
'use client'
import React, { useState } from 'react';
interface DocSection {
id: string;
title: string;
content: React.ReactNode;
}
const CodeBlock = ({ children, language = 'bash' }: { children: string; language?: string }) => (
<pre className="bg-zinc-900 border border-zinc-800 rounded-lg p-4 overflow-x-auto text-sm font-mono">
<code className="text-zinc-300">{children}</code>
</pre>
);
const Table = ({ headers, rows }: { headers: string[]; rows: string[][] }) => (
<div className="overflow-x-auto">
<table className="w-full text-sm border-collapse">
<thead>
<tr className="border-b border-zinc-700">
{headers.map((h, i) => (
<th key={i} className="text-left py-2 px-3 text-zinc-300 font-mono font-semibold">{h}</th>
))}
</tr>
</thead>
<tbody>
{rows.map((row, i) => (
<tr key={i} className="border-b border-zinc-800 hover:bg-zinc-900/50">
{row.map((cell, j) => (
<td key={j} className="py-2 px-3 text-zinc-400 font-mono">{cell}</td>
))}
</tr>
))}
</tbody>
</table>
</div>
);
const sections: DocSection[] = [
{
id: 'overview',
title: 'Overview',
content: (
<div className="space-y-4">
<p className="text-zinc-300">
SkillKit is a universal command-line interface (CLI) and programmatic toolkit for managing AI agent skills across 46 AI coding platforms. It solves the fragmentation problem where each AI agent uses different skill formats and directory structures.
</p>
<h3 className="text-lg font-semibold text-white mt-6">Core Capabilities</h3>
<ul className="list-disc list-inside space-y-2 text-zinc-400">
<li><span className="text-white">Skill Discovery</span> - Browse 400K+ skills from registries with AI-powered recommendations</li>
<li><span className="text-white">Cross-Agent Translation</span> - Automatically convert skills between 46 agent-specific formats</li>
<li><span className="text-white">Team Collaboration</span> - Share skills via .skills manifest files and publish to marketplace</li>
</ul>
</div>
),
},
{
id: 'installation',
title: 'Installation',
content: (
<div className="space-y-4">
<h3 className="text-lg font-semibold text-white">Quick Start</h3>
<CodeBlock>{`# Full install — every feature works out of the box (default):
npm install -g skillkit
# Slim install — core commands only, ~75% smaller, 0 deprecation warnings:
npm install -g skillkit --omit=optional
# Or use npx directly:
npx skillkit --help`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Optional Features</h3>
<p className="text-zinc-300 text-sm">
TUI, REST server, peer mesh, and inter-agent messaging ship as optional
dependencies. They install by default, or add later à la carte:
</p>
<CodeBlock>{`npm install -g @skillkit/tui # enables: skillkit ui
npm install -g @skillkit/api # enables: skillkit serve
npm install -g @skillkit/mesh # enables: skillkit mesh
npm install -g @skillkit/messaging # enables: skillkit message`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Using npx (no install)</h3>
<p className="text-zinc-300 text-sm">
<code className="text-zinc-200">npx skillkit add &lt;owner/repo&gt;</code> runs with zero install.
First call caches the package at <code className="text-zinc-200">~/.npm/_npx/</code>; every
run after that is instant until a new version ships.
</p>
<CodeBlock>{`# Full (default):
npx skillkit add anthropics/skills
# Slim — core only, 75% fewer packages, 0 warnings:
npx --omit=optional skillkit add anthropics/skills`}</CodeBlock>
<p className="text-zinc-300 text-sm">
Using npx more than a couple times? Install globally to skip the
prompt-to-proceed and avoid the per-release cache refetch:
</p>
<CodeBlock>{`npm install -g skillkit --omit=optional
skillkit add anthropics/skills`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Verify Installation</h3>
<CodeBlock>{`skillkit --version
skillkit --help`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">First Steps</h3>
<CodeBlock>{`# Initialize SkillKit in your project
skillkit init
# Browse available skills
skillkit marketplace
# Get AI-powered recommendations
skillkit recommend
# Install skills from a source
skillkit install anthropics/skills`}</CodeBlock>
</div>
),
},
{
id: 'architecture',
title: 'Architecture',
content: (
<div className="space-y-4">
<p className="text-zinc-300">
SkillKit employs a three-tier design with clean separation of concerns:
</p>
<h3 className="text-lg font-semibold text-white mt-6">System Tiers</h3>
<ul className="list-disc list-inside space-y-2 text-zinc-400">
<li><span className="text-white">UI Tier</span> - CLI commands, Terminal UI (OpenTUI-based), and documentation website</li>
<li><span className="text-white">Core Logic Tier</span> - @skillkit/core for business logic; @skillkit/agents for adapter implementations</li>
<li><span className="text-white">Integration Tier</span> - File systems, Git repositories, marketplace APIs, and 46 AI agents</li>
</ul>
<h3 className="text-lg font-semibold text-white mt-6">Monorepo Structure</h3>
<CodeBlock language="text">{`skillkit-monorepo (pnpm workspace + Turbo)
├── apps/skillkit/ → Main CLI application (bin: skillkit, sk)
├── packages/core/ → Core business logic (no internal dependencies)
├── packages/agents/ → Agent adapters (depends on core)
├── packages/cli/ → Command implementations (depends on core, agents, tui)
├── packages/tui/ → Terminal UI (depends on core, agents)
└── docs/skillkit/ → Documentation website`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Dependency Hierarchy</h3>
<ul className="list-disc list-inside space-y-2 text-zinc-400">
<li><code className="text-emerald-400">@skillkit/core</code> → Foundation (no SkillKit dependencies)</li>
<li><code className="text-emerald-400">@skillkit/agents</code> → Adapters (depends on core)</li>
<li><code className="text-emerald-400">@skillkit/cli</code>, <code className="text-emerald-400">@skillkit/tui</code> → UIs (depend on core and agents)</li>
<li><code className="text-emerald-400">skillkit</code> app → Orchestrates all packages</li>
</ul>
</div>
),
},
{
id: 'agents',
title: 'Supported Agents',
content: (
<div className="space-y-4">
<p className="text-zinc-300">
SkillKit supports 46 AI coding agents with automatic format translation:
</p>
<Table
headers={['Agent', 'Directory', 'Format']}
rows={[
['Claude Code', '.claude/skills/', 'SKILL.md'],
['Cursor', '.cursor/skills/', '.mdc'],
['GitHub Copilot', '.github/skills/', 'Markdown'],
['Gemini CLI', '.gemini/skills/', 'SKILL.md'],
['Windsurf', '.windsurf/skills/', 'Markdown'],
['Codex', '.codex/skills/', 'SKILL.md'],
['OpenCode', '.opencode/skills/', 'SKILL.md'],
['Antigravity', '.antigravity/skills/', 'SKILL.md'],
['Amp', '.amp/skills/', 'SKILL.md'],
['Clawdbot', '.clawdbot/skills/', 'SKILL.md'],
['Cline', '.cline/skills/', 'SKILL.md'],
['CodeBuddy', '.codebuddy/skills/', 'SKILL.md'],
['CommandCode', '.commandcode/skills/', 'SKILL.md'],
['Continue', '.continue/skills/', 'SKILL.md'],
['Crush', '.crush/skills/', 'SKILL.md'],
['Droid', '.factory/skills/', 'SKILL.md'],
['Factory', '.factory/skills/', 'SKILL.md'],
['Goose', '.goose/skills/', 'SKILL.md'],
['Kilo', '.kilocode/skills/', 'SKILL.md'],
['Kiro CLI', '.kiro/skills/', 'SKILL.md'],
['MCPJam', '.mcpjam/skills/', 'SKILL.md'],
['Mux', '.mux/skills/', 'SKILL.md'],
['Neovate', '.neovate/skills/', 'SKILL.md'],
['OpenHands', '.openhands/skills/', 'SKILL.md'],
['Pi', '.pi/skills/', 'SKILL.md'],
['Qoder', '.qoder/skills/', 'SKILL.md'],
['Qwen', '.qwen/skills/', 'SKILL.md'],
['Roo', '.roo/skills/', 'SKILL.md'],
['Trae', '.trae/skills/', 'SKILL.md'],
['Vercel', '.vercel/skills/', 'SKILL.md'],
['Zencoder', '.zencoder/skills/', 'SKILL.md'],
['Devin', '.devin/skills/', 'SKILL.md'],
['Aider', '.aider/skills/', 'SKILL.md'],
['Sourcegraph Cody', '.cody/skills/', 'SKILL.md'],
['Amazon Q', '.amazonq/skills/', 'SKILL.md'],
['Augment Code', '.augment/skills/', 'SKILL.md'],
['Replit Agent', '.replit/skills/', 'SKILL.md'],
['Bolt', '.bolt/skills/', 'SKILL.md'],
['Lovable', '.lovable/skills/', 'SKILL.md'],
['Tabby', '.tabby/skills/', 'SKILL.md'],
['Tabnine', '.tabnine/skills/', 'SKILL.md'],
['CodeGPT', '.codegpt/skills/', 'SKILL.md'],
['PlayCode Agent', '.playcode/skills/', 'SKILL.md'],
['Universal', 'skills/', 'SKILL.md'],
]}
/>
</div>
),
},
{
id: 'commands',
title: 'CLI Commands',
content: (
<div className="space-y-4">
<h3 className="text-lg font-semibold text-white">Skill Management</h3>
<CodeBlock>{`skillkit install <source> # Install skills from source
skillkit remove <skill> # Remove installed skill
skillkit update [skill] # Update skills
skillkit list # List installed skills
skillkit sync # Sync skills across agents
skillkit enable <skill> # Enable a skill
skillkit disable <skill> # Disable a skill`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Discovery</h3>
<CodeBlock>{`skillkit recommend # AI-powered skill recommendations
skillkit marketplace # Browse marketplace skills
skillkit find <query> # Search for skills
skillkit search <term> # Search skill content`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Translation</h3>
<CodeBlock>{`skillkit translate --from claude --to cursor <skill>
skillkit agent translate <skill> --target cursor
skillkit context sync # Sync context across agents`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Team Collaboration</h3>
<CodeBlock>{`skillkit manifest init # Initialize .skills manifest
skillkit manifest add <source> # Add source to manifest
skillkit manifest install # Install from manifest
skillkit publish # Publish skill to marketplace
skillkit cicd init # Setup CI/CD integration`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Advanced</h3>
<CodeBlock>{`skillkit ui # Launch Terminal UI
skillkit workflow # Manage workflows
skillkit memory compress # Compress memory
skillkit memory export # Export memory
skillkit test # Run skill tests
skillkit validate # Validate skill format & quality`}</CodeBlock>
</div>
),
},
{
id: 'configuration',
title: 'Configuration',
content: (
<div className="space-y-4">
<h3 className="text-lg font-semibold text-white">Project Configuration (skillkit.yaml)</h3>
<CodeBlock language="yaml">{`version: 1
agent: cursor
autoSync: true
enabledSkills:
- pdf
- xlsx
disabledSkills:
- deprecated-skill`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Team Manifest (.skills)</h3>
<CodeBlock>{`# Team-wide skill sources
anthropics/skills
vercel-labs/agent-skills
./local-skills
owner/repo@v1.2.3`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">User Preferences (~/.skillkit/preferences.json)</h3>
<CodeBlock language="json">{`{
"lastSelectedAgents": ["claude", "cursor"],
"autoSync": true,
"marketplace": {
"lastRefresh": "2024-01-01T00:00:00Z"
}
}`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">File System Layout</h3>
<CodeBlock language="text">{`project/
├── .skillkit/ # Project config & memory
├── .claude/skills/ # Claude Code skills
├── .cursor/skills/ # Cursor AI skills
├── .github/skills/ # GitHub Copilot skills
├── skills/ # Universal format
└── .skills # Team manifest file
~/.skillkit/ # Global user config
├── preferences.json
├── memory/
└── cache/`}</CodeBlock>
</div>
),
},
{
id: 'api',
title: 'API Reference',
content: (
<div className="space-y-4">
<h3 className="text-lg font-semibold text-white">Package Exports</h3>
<p className="text-zinc-300">@skillkit/core provides multiple entry points for programmatic use:</p>
<CodeBlock language="typescript">{`import { findAllSkills, findSkill } from '@skillkit/core/discovery';
import { parseSkillFile } from '@skillkit/core/parser';
import { translateSkill } from '@skillkit/core/translator';
import { syncContext } from '@skillkit/core/context';
import { getRecommendations } from '@skillkit/core/recommend';
import { evaluateSkillContent, getQualityGrade } from '@skillkit/core/quality';`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Core Functions</h3>
<CodeBlock language="typescript">{`// Discovery
findAllSkills(searchDirs: string[]): SkillInfo[]
findSkill(name: string, searchDirs: string[]): SkillInfo | null
// Parsing
parseSkillFile(filePath: string): ParsedSkill
parseSkillContent(content: string): ParsedSkill
// Translation
translateSkill(skill: ParsedSkill, targetAgent: AgentType): string
getAgentAdapter(agent: AgentType): AgentAdapter
// Quality Evaluation
evaluateSkillContent(content: string): QualityScore
evaluateSkillFile(filePath: string): QualityScore
getQualityGrade(score: number): 'A' | 'B' | 'C' | 'D' | 'F'
isHighQuality(score: QualityScore): boolean
// Recommendations
getRecommendations(context: ProjectContext): Recommendation[]`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Type Definitions</h3>
<CodeBlock language="typescript">{`interface SkillInfo {
name: string;
path: string;
agent: AgentType;
enabled: boolean;
}
interface ParsedSkill {
name: string;
description?: string;
globs?: string[];
triggers?: string[];
content: string;
frontmatter: Record<string, unknown>;
}
interface QualityScore {
overall: number;
structure: StructureScore;
clarity: ClarityScore;
specificity: SpecificityScore;
advanced: AdvancedScore;
warnings: string[];
suggestions: string[];
}
type AgentType =
| 'claude-code' | 'cursor' | 'codex' | 'gemini-cli'
| 'opencode' | 'antigravity' | 'amp' | 'clawdbot'
| 'droid' | 'github-copilot' | 'goose' | 'kilo'
| 'kiro-cli' | 'roo' | 'trae' | 'windsurf' | 'universal';`}</CodeBlock>
</div>
),
},
{
id: 'skill-format',
title: 'Skill Format',
content: (
<div className="space-y-4">
<h3 className="text-lg font-semibold text-white">SKILL.md Structure</h3>
<p className="text-zinc-300">Skills use YAML frontmatter followed by markdown content:</p>
<CodeBlock language="markdown">{`---
name: my-skill
description: A helpful skill for coding tasks
globs:
- "**/*.ts"
- "**/*.tsx"
triggers:
- "when working with TypeScript"
- "when creating React components"
---
# My Skill
## When to Use
Use this skill when:
- Working with TypeScript files
- Creating React components
## Instructions
Follow these guidelines:
1. Always use TypeScript strict mode
2. Prefer functional components
\`\`\`typescript
function Example(): JSX.Element {
return <div>Hello</div>;
}
\`\`\`
## Boundaries
This skill should NOT:
- Modify configuration files without asking
- Delete existing code without confirmation`}</CodeBlock>
<h3 className="text-lg font-semibold text-white mt-6">Quality Scoring</h3>
<p className="text-zinc-300">Skills are evaluated on four dimensions:</p>
<Table
headers={['Dimension', 'Weight', 'Criteria']}
rows={[
['Structure', '35%', 'Metadata, description, triggers, examples, boundaries'],
['Clarity', '25%', 'Line count, token count, headers, readability'],
['Specificity', '25%', 'Concrete commands, file patterns, code examples'],
['Advanced', '15%', 'No deprecated patterns, security issues, completeness'],
]}
/>
<h3 className="text-lg font-semibold text-white mt-6">Grade Scale</h3>
<Table
headers={['Grade', 'Score Range', 'Description']}
rows={[
['A', '90-100', 'Excellent - Production ready'],
['B', '80-89', 'Good - Minor improvements possible'],
['C', '70-79', 'Acceptable - Some issues to address'],
['D', '60-69', 'Poor - Significant improvements needed'],
['F', '0-59', 'Failing - Major revision required'],
]}
/>
</div>
),
},
{
id: 'tech-stack',
title: 'Technology Stack',
content: (
<div className="space-y-4">
<Table
headers={['Layer', 'Technology']}
rows={[
['CLI Framework', 'Clipanion v4'],
['TUI Framework', '@opentui/react v0.1.75'],
['Validation', 'Zod v3.24'],
['YAML Parsing', 'yaml v2.6'],
['Git Operations', 'isomorphic-git v1.27'],
['HTTP Client', 'got v14.4'],
['Build System', 'Turbo v2.3, tsup v8.3, pnpm v9.0'],
['Testing', 'Vitest v2.1'],
['Runtime', 'Node.js 18+, Bun 1.2+ (for TUI)'],
]}
/>
<h3 className="text-lg font-semibold text-white mt-6">Build Commands</h3>
<CodeBlock>{`pnpm build # Build all packages via Turbo
pnpm dev # Watch mode development
pnpm test # Unit tests via Vitest
pnpm test:e2e # End-to-end tests
pnpm typecheck # Type checking
pnpm clean # Remove build artifacts`}</CodeBlock>
</div>
),
},
];
export function Documentation(): React.ReactElement {
const [activeSection, setActiveSection] = useState('overview');
const currentSection = sections.find(s => s.id === activeSection) || sections[0];
return (
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="text-center mb-8">
<h2 className="text-2xl font-bold text-white mb-2 font-mono">Documentation</h2>
<p className="text-zinc-400 font-mono text-sm">
Complete guide to using SkillKit
</p>
<a
href="https://deepwiki.com/rohitg00/skillkit"
target="_blank"
rel="noreferrer noopener"
className="inline-flex items-center gap-2 mt-2 text-xs text-zinc-500 hover:text-zinc-300 transition-colors"
>
<span>Powered by DeepWiki</span>
<svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14" />
</svg>
</a>
</div>
<div className="flex flex-col lg:flex-row gap-8">
<nav className="lg:w-48 flex-shrink-0" aria-label="Documentation sections">
<div className="sticky top-20 space-y-1">
{sections.map(section => (
<button
key={section.id}
type="button"
aria-current={activeSection === section.id ? 'page' : undefined}
onClick={() => setActiveSection(section.id)}
className={`w-full text-left px-3 py-2 text-sm font-mono rounded transition-colors ${
activeSection === section.id
? 'bg-white text-black'
: 'text-zinc-400 hover:text-white hover:bg-zinc-800'
}`}
>
{section.title}
</button>
))}
</div>
</nav>
<div className="flex-1 min-w-0">
<div className="bg-surface border border-zinc-800 rounded-lg p-6">
<h2 className="text-xl font-bold text-white mb-6 font-mono">{currentSection.title}</h2>
<div className="prose prose-invert prose-zinc max-w-none">
{currentSection.content}
</div>
</div>
</div>
</div>
</div>
);
}
-145
View File
@@ -1,145 +0,0 @@
import React from 'react';
interface Feature {
title: string;
description: string;
icon: React.ReactNode;
}
const FEATURES: Feature[] = [
{
title: 'Multi-Agent',
description: 'Deploy to 46 AI coding agents with one command.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" />
</svg>
)
},
{
title: 'Terminal UI',
description: 'Beautiful interactive TUI for browsing & installing.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M8 9l3 3-3 3m5 0h3M5 20h14a2 2 0 002-2V6a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z" />
</svg>
)
},
{
title: 'Plugins',
description: 'Extend with custom plugins & hooks.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M17 14v6m-3-3h6M6 10h2a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v2a2 2 0 002 2zm10 0h2a2 2 0 002-2V6a2 2 0 00-2-2h-2a2 2 0 00-2 2v2a2 2 0 002 2zM6 20h2a2 2 0 002-2v-2a2 2 0 00-2-2H6a2 2 0 00-2 2v2a2 2 0 002 2z" />
</svg>
)
},
{
title: 'Manifest',
description: '.skills file for team-wide consistency.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
</svg>
)
},
{
title: 'CI/CD',
description: 'GitHub, GitLab, CircleCI templates included.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
</svg>
)
},
{
title: 'Slash Commands',
description: 'Generate /commands for Claude, Cursor & more.',
icon: (
<svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M7 20l4-16m2 16l4-16M6 9h14M4 15h14" />
</svg>
)
}
];
const COMPARISONS = [
['Agents', '1', '46'],
['Translation', 'Manual', 'Auto'],
['Sharing', 'Copy/paste', '.skills manifest'],
['Discovery', 'Forums', 'CLI + AI'],
['CI/CD', 'Custom', 'Templates'],
] as const;
export function Features(): React.ReactElement {
return (
<section id="features" className="py-12 border-b border-zinc-800 bg-surface">
<div className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8">
<div className="grid grid-cols-1 lg:grid-cols-5 gap-6 lg:gap-8 mb-10">
<div className="lg:col-span-2">
<h2 className="text-xl font-bold text-white mb-2 font-mono">Why SkillKit?</h2>
<p className="text-zinc-500 font-mono text-sm mb-6">
Universal bridge for AI coding agents.
</p>
<div className="flex gap-6 sm:gap-8">
<div>
<div className="text-2xl sm:text-3xl font-bold text-white font-mono">46</div>
<div className="text-zinc-600 text-[10px] sm:text-xs font-mono">Agents</div>
</div>
<div>
<div className="text-2xl sm:text-3xl font-bold text-white font-mono">40+</div>
<div className="text-zinc-600 text-[10px] sm:text-xs font-mono">Commands</div>
</div>
<div>
<div className="text-2xl sm:text-3xl font-bold text-white font-mono">15K</div>
<div className="text-zinc-600 text-[10px] sm:text-xs font-mono">Skills</div>
</div>
</div>
</div>
<div className="lg:col-span-3 border border-zinc-800 bg-black/50 p-4 font-mono text-xs backdrop-blur-sm">
<div className="grid grid-cols-3 gap-2 border-b border-zinc-800 pb-2 mb-3 text-zinc-500 uppercase tracking-wider text-[10px]">
<div>Feature</div>
<div className="text-center">Without</div>
<div className="text-right">SkillKit</div>
</div>
<div className="space-y-1">
{COMPARISONS.map(([feature, without, withSkillKit], index) => (
<div
key={feature}
className="grid grid-cols-3 gap-2 items-center py-1.5 hover:bg-zinc-900/50 transition-colors -mx-2 px-2 rounded"
style={{ animationDelay: `${index * 100}ms` }}
>
<div className="text-zinc-300">{feature}</div>
<div className="text-center text-zinc-600">{without}</div>
<div className="text-right text-white font-medium">{withSkillKit}</div>
</div>
))}
</div>
</div>
</div>
<div className="grid grid-cols-1 xs:grid-cols-2 md:grid-cols-3 lg:grid-cols-6 gap-3">
{FEATURES.map((feature, index) => (
<div
key={feature.title}
className="group relative p-4 border border-zinc-800 bg-zinc-900/30 hover:bg-zinc-900/80 hover:border-zinc-700 transition-all duration-300 cursor-default"
style={{ animationDelay: `${index * 50}ms` }}
>
<div className="absolute inset-0 bg-gradient-to-b from-zinc-800/0 to-zinc-800/20 opacity-0 group-hover:opacity-100 transition-opacity"></div>
<div className="relative">
<div className="text-zinc-500 group-hover:text-white transition-colors mb-2">
{feature.icon}
</div>
<h4 className="text-xs font-bold text-white mb-1 font-mono">{feature.title}</h4>
<p className="text-zinc-600 text-[10px] leading-relaxed font-mono group-hover:text-zinc-400 transition-colors">
{feature.description}
</p>
</div>
</div>
))}
</div>
</div>
</section>
);
}

Some files were not shown because too many files have changed in this diff Show More