Compare commits

..
Author SHA1 Message Date
Rohit Ghumare 553a918b69 fix: handle more relative path patterns in loadPlugin
- Use isAbsolute() for cross-platform absolute path detection
- Add check for paths containing '/' (excluding @scope packages)
- Simplify pattern to source.startsWith('.') for all dot-prefixed paths
- Now correctly handles: plugins/x.js, ../foo, ./bar, .hidden
2026-01-23 22:31:26 +00:00
Rohit Ghumare 380188cef1 fix: allow scoped npm names in isValidPluginName
Update isValidPluginName to allow scoped npm package names like @scope/name
while still preventing path traversal attacks. Uses the same regex pattern
as loader.ts validatePlugin for consistency.

Valid names: my-plugin, @scope/plugin-name
Invalid names: ../evil, .hidden, name\\path, @../evil/name
2026-01-23 22:27:37 +00:00
Rohit Ghumare dcf12f6826 fix: address PR review issues - round 5
CRITICAL fixes:
- plugin.ts: Add path traversal protection in uninstallPlugin with name validation
  and resolved path checks
- bundle.ts: Fix parseSkillContent to not drop first file when content starts
  with "--- file ---" header

MAJOR fixes:
- plugin.ts: Add isValidPluginName() helper and validate plugin.metadata.name
  before using in file paths
- plugin.ts: Preserve .mjs extension for single-file ESM plugins
- bundle.ts: Use cross-platform path containment checks with relative() and sep
  instead of hardcoded '/'
- loader.ts: Add support for .mjs files (index.mjs, plugin.mjs)

MINOR fixes:
- plugin.ts: Expand tilde (~) path BEFORE calling loadPlugin
- settings.ts: Use null instead of undefined in JSON output for --get so key
  is preserved
2026-01-23 22:21:03 +00:00
Rohit Ghumare 50e8a389de fix: address PR review issues - round 4
CRITICAL fixes:
- loader.ts: Wrap statSync in try/catch in loadPluginsFromDirectory to handle
  permission denied and broken symlinks
- bundle.ts: Block path traversal attacks via skill names in importBundle by
  validating skill names don't contain / \ or start with .

MAJOR fixes:
- bundle.ts: Use dirname() instead of join('..') for output directory calculation

MINOR fixes:
- plugin.ts: Expand tilde paths (~) before existsSync for proper file operations
- settings.ts: Show defaultTimeout and marketplaceSources in default output
- bundle.ts: Prevent duplicate skill names in bundle with early error
- bundle.ts: Handle single-file skills properly in detectAgents
2026-01-23 22:03:38 +00:00
Rohit Ghumare be06956fd4 fix: address PR review feedback (round 3)
- plugin.ts: Add '../' and '~' to isLocalPath detection, use
  loader-recognized names (index.js, plugin.json) for single-file copy
- plugin.ts: Remove unused 'basename' import
- settings.ts: Change defaultTimeout validation from < 0 to <= 0
- settings.ts: Use knownKeys whitelist for unknown key detection
- loader.ts: Wrap statSync in try/catch for scanDirectory
- loader.ts: Validate required fields (name, version) before pushing
- loader.ts: Update regex to allow scoped npm names (@scope/name)
- bundle.ts: Resolve targetDir to absolute path for path containment
- Plugins.tsx: Only ignore ENOENT errors, rethrow others
- Plugins.tsx: Load plugins in togglePlugin before enable/disable
2026-01-23 21:48:24 +00:00
Rohit Ghumare 402d179c06 fix: address PR review feedback (round 2)
- Security: Add path traversal protection in bundle import
- Fix Plugins.tsx to load plugins from directory before listing
- Fix plugin.ts to persist plugin files to disk on install/uninstall
- Fix Settings.tsx auto-detect vs universal display inconsistency
- Add null check for registry in team/manager.ts sync()
- Thread TeamConfig.auth through provider clone calls
- Fix GitLab CI rules vs only conflict (use rules instead of only)
- Make loadConfig() accept global parameter for --global flag
- Fix relative path detection in plugins/loader.ts (../plugins)
2026-01-23 21:28:50 +00:00
Rohit Ghumare f3467dd5d3 fix: address PR review comments from CodeRabbit and Devin
Plugin command fixes:
- Fix double-nested .skillkit path when using --global flag

Settings command fixes:
- Add defaultTimeout to help text for available keys
- Wrap const timeout in block scope for switch case
- Fix --set flag validation to require equals sign

Core package fixes:
- Remove .ts from supported plugin extensions (runtime imports fail)
- Store skill name instead of full path in bundle manifest
- Use ESM import for execSync instead of require()
- Replace custom YAML parser with yaml library for proper nested structure handling

TUI screen fixes:
- Guard against empty plugins array in navigation
- Fix empty object pattern in Settings.tsx
- Surface config load failures in Settings screen
- Add manager.load() before sync/import in Team screen
- Guard against empty skills array in Team navigation
- Clamp selection index after skills update

CI/CD command fixes:
- Properly handle skipped workflows (not reported as success)
- Show different final message when nothing was created
- Wrap readFileSync in try/catch for GitLab CI
2026-01-23 20:55:48 +00:00
Rohit Ghumare 08ab52971e fix: address PR review comments from Devin
- Fix skill-executor.ts: handle undefined agentToUse when strategy is 'cli'
  Previously, if strategy was 'cli' but no CLI agent was available, the
  code would fall through and call executeWithAgent with undefined agent,
  causing a runtime error.

- Fix cicd.ts: prevent GitLab CI config overwrite without --force
  Previously, if .gitlab-ci.yml existed but didn't contain 'skillkit',
  it would be overwritten without checking --force. Now it properly
  returns early with a helpful message, consistent with CircleCI behavior.
2026-01-23 20:26:47 +00:00
Rohit Ghumare 56c7d02103 feat: add team collaboration and plugin system
Team Collaboration (Phase 10):
- TeamManager for skill sharing with remote registries
- Skill bundles (create, export, import)
- Team CLI commands: init, share, import, list, sync, remove, bundle-*
- Team TUI screen with navigation key 'a'

Plugin System (Phase 11):
- PluginManager with lifecycle hooks
- Plugin loader (files, npm packages, directories)
- TranslatorPlugin for custom agent formats
- ProviderPlugin for custom skill sources
- CommandPlugin for custom CLI commands
- Plugin CLI commands: list, install, uninstall, enable, disable, info
- Plugins TUI screen with navigation key 'p'

Additional:
- CI/CD command for template generation
- Settings command improvements
- Updated CLAUDE.md with all 11 phases complete
- 359 tests passing
2026-01-23 20:17:59 +00:00
144 changed files with 2041 additions and 30852 deletions
+1 -52
View File
@@ -7,7 +7,6 @@ on:
branches: [main]
jobs:
# Unit tests run on all Node versions
test:
runs-on: ubuntu-latest
@@ -36,55 +35,5 @@ jobs:
- name: Build
run: pnpm build
- name: Unit Tests
- name: Test
run: pnpm test
# E2E tests run on latest Node only (to save CI time)
e2e:
runs-on: ubuntu-latest
needs: test # Run after unit tests pass
steps:
- uses: actions/checkout@v4
- name: Install pnpm
uses: pnpm/action-setup@v4
- name: Use Node.js 22
uses: actions/setup-node@v4
with:
node-version: 22
cache: 'pnpm'
- name: Install dependencies
run: pnpm install --frozen-lockfile
- name: Build
run: pnpm build
- name: E2E Tests
run: pnpm test:e2e
- name: Upload E2E Test Results
if: failure()
uses: actions/upload-artifact@v4
with:
name: e2e-test-results
path: |
e2e/**/*.log
/tmp/skillkit-e2e-*
retention-days: 7
# Final status check for branch protection
ci-success:
runs-on: ubuntu-latest
needs: [test, e2e]
if: always()
steps:
- name: Check all jobs passed
run: |
if [[ "${{ needs.test.result }}" != "success" ]] || [[ "${{ needs.e2e.result }}" != "success" ]]; then
echo "One or more jobs failed"
exit 1
fi
echo "All CI checks passed!"
+1 -5
View File
@@ -59,8 +59,4 @@ skillkit.yaml
.skillkit/
# Turbo cache
.turbo/
# Project documentation (not for version control)
CLAUDE.md
prd.md
.turbo/
+19 -41
View File
@@ -5,23 +5,23 @@
[![CI](https://github.com/rohitg00/skillkit/actions/workflows/ci.yml/badge.svg)](https://github.com/rohitg00/skillkit/actions/workflows/ci.yml)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
## Supercharge Every AI Coding Agent
## One CLI. 17 AI Agents. Zero Lock-in.
**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.
> **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.
**Write skills once, use everywhere.** SkillKit is the universal platform that lets your AI coding skills work across Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and 12 more agents.
```bash
npm install -g skillkit
```
## Why SkillKit?
## The Problem
**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.
You've built amazing skills for Claude Code. Now you want to try Cursor. Or your team uses different agents. Your options:
**The solution:** SkillKit translates skills between all 17 agents automatically. Write once, use everywhere.
1. **Rewrite everything** - each agent has different formats, directories, and conventions
2. **Pick one agent** - lock yourself in, miss out on innovations
3. **Give up on skills** - lose the productivity gains
## See It In Action
## The Solution
```bash
# Install a skill for ALL your agents at once
@@ -44,23 +44,12 @@ skillkit recommend
| 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 |
## What's New in v1.6
- **Recursive Agent Translation**: Batch translate entire directories of agents with `--recursive` flag
- **Custom AI Sub-Agents**: Create, translate, sync, and validate custom AI sub-agents across 17 coding agents
- **Methodology Framework**: 5 ready-to-use frameworks (Agile, TDD, DevOps, Security-First, Documentation-First)
- **Hooks System**: Event-driven skill triggers - auto-activate on commits, file changes, builds
- **Agent Orchestration**: Multi-agent team coordination with leader/teammate roles
- **Plan System**: Parse, validate, and execute structured development plans
- **Slash Commands**: Generate agent-native `/commands` from natural language
## 5-Minute Quick Start
```bash
@@ -97,12 +86,6 @@ 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
```
**Supported Agents:** Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Antigravity, Amp, Clawdbot, Droid, GitHub Copilot, Goose, Kilo, Kiro, Roo, Trae, Windsurf, Universal
@@ -238,7 +221,7 @@ skillkit cicd pre-commit
| OpenCode | SKILL.md | `.opencode/skills/` |
| Antigravity | SKILL.md | `.antigravity/skills/` |
| Amp | SKILL.md | `.amp/skills/` |
| Clawdbot | SKILL.md | `skills/` or `~/.clawdbot/skills/` |
| Clawdbot | SKILL.md | `skills/` |
| Droid (Factory) | SKILL.md | `.factory/skills/` |
| GitHub Copilot | Markdown | `.github/skills/` |
| Goose | SKILL.md | `.goose/skills/` |
@@ -280,21 +263,6 @@ skillkit context init # Initialize project context
skillkit context sync # Sync context to agents
```
### Custom AI Sub-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
```
### Memory System
```bash
@@ -443,6 +411,16 @@ disabledSkills:
- deprecated-skill
```
## Why SkillKit Exists
AI coding agents are amazing, but the ecosystem is fragmented:
- **Skills don't transfer** between agents
- **Knowledge dies** when sessions end
- **No standard** for skill quality or testing
- **Manual discovery** of useful skills
SkillKit solves these problems with a universal platform that works across all major AI coding agents.
## License
Apache License 2.0 - see [LICENSE](LICENSE) for details.
+10 -170
View File
@@ -14,183 +14,23 @@ npm install -g skillkit
# Initialize skillkit in your project
skillkit init
# Install skills from GitHub
skillkit install anthropics/skills
# Install a skill
skillkit install github.com/anthropics/courses:prompt-eng/interactive-tutorial
# Get recommendations for your stack
skillkit recommend
# List installed skills
skillkit list
# Launch interactive TUI
skillkit ui
```
## Core Features
## Features
### Cross-Agent Translation
```bash
# Translate a Claude skill to Cursor format
skillkit translate react-patterns --to cursor
# Translate all skills to multiple agents
skillkit translate --all --to windsurf,codex
# Preview translation
skillkit translate my-skill --to copilot --dry-run
```
### Smart Recommendations
```bash
# Get project-aware suggestions
skillkit recommend
# Filter by task
skillkit recommend --search "authentication"
# Quality threshold
skillkit recommend --min-score 85
```
### Team Collaboration
```bash
# Initialize team
skillkit team init --name "Engineering Team"
# Create skill bundle
skillkit team bundle-create
# Share with team
skillkit team share onboarding-bundle
# Sync with remote registry
skillkit team sync
```
### Plugin System
```bash
# List installed plugins
skillkit plugin list
# Install custom plugin
skillkit plugin install @company/custom-translator
# View plugin info
skillkit plugin info my-plugin
```
### Development Methodologies
```bash
# List available methodologies
skillkit methodology list
# Load TDD methodology
skillkit methodology load tdd
# Apply to project
skillkit methodology apply agile
```
### Plan System
```bash
# Parse and validate plan
skillkit plan parse ./implementation-plan.md
skillkit plan validate ./plan.md
# Execute plan
skillkit plan execute ./feature-plan.md
# Check status
skillkit plan status
```
### Hooks & Automation
```bash
# List hooks
skillkit hook list
# Register pre-commit hook
skillkit hook register pre-commit
# Trigger manually
skillkit hook trigger pre-commit
```
### Workflow Orchestration
```bash
# List workflows
skillkit workflow list
# Run workflow
skillkit workflow run feature-development
# Create new workflow
skillkit workflow create deployment-flow
```
### Session Memory
```bash
# View learnings
skillkit memory list
# Search past sessions
skillkit memory search "error handling"
# Compress observations
skillkit memory compress
# Export learning as skill
skillkit memory export auth-insight --output auth-skill.md
```
## Supported Agents (17)
Claude Code, Cursor, Codex, Gemini CLI, Windsurf, GitHub Copilot, OpenCode, Antigravity, Amp, Clawdbot, Droid, Goose, Kilo, Kiro, Roo, Trae, Universal
## Usage Examples
### Install and Sync
```bash
# Install to multiple agents
skillkit install anthropics/skills --agent claude-code,cursor
# Sync all skills to detected agents
skillkit sync --all
```
### Context Management
```bash
# Initialize project context
skillkit context init
# View detected stack
skillkit context show
# Sync to all agents
skillkit context sync --all
```
### Testing
```bash
# Run all skill tests
skillkit test
# Test specific skills
skillkit test ./my-skill --tags unit
# CI/CD integration
skillkit cicd init
```
- **17+ Agent Support**: Claude Code, Cursor, Codex, Gemini CLI, Windsurf, GitHub Copilot, and more
- **Universal Skill Translation**: Convert skills between different agent formats
- **Smart Recommendations**: Get skill suggestions based on your project stack
- **Project Context Sync**: One config, all agents
- **Interactive TUI**: Browse, install, and manage skills visually
## Documentation
+2 -2
View File
@@ -1,7 +1,7 @@
{
"name": "skillkit",
"version": "1.6.4",
"description": "Supercharge AI coding agents with portable skills. Install, translate, and share skills across Claude Code, Cursor, Codex, Copilot & 13 more",
"version": "1.4.0",
"description": "Universal skills loader for AI coding agents - supports Claude Code, Codex, Cursor, Antigravity, OpenCode, Gemini CLI and more",
"type": "module",
"bin": {
"skillkit": "./dist/cli.js",
-26
View File
@@ -33,19 +33,6 @@ import {
CICDCommand,
TeamCommand,
PluginCommand,
MethodologyCommand,
HookCommand,
PlanCommand,
CommandCmd,
AICommand,
AuditCommand,
AgentCommand,
AgentListCommand,
AgentShowCommand,
AgentCreateCommand,
AgentTranslateCommand,
AgentSyncCommand,
AgentValidateCommand,
} from '@skillkit/cli';
const __filename = fileURLToPath(import.meta.url);
@@ -92,18 +79,5 @@ cli.register(SettingsCommand);
cli.register(CICDCommand);
cli.register(TeamCommand);
cli.register(PluginCommand);
cli.register(MethodologyCommand);
cli.register(HookCommand);
cli.register(PlanCommand);
cli.register(CommandCmd);
cli.register(AICommand);
cli.register(AuditCommand);
cli.register(AgentCommand);
cli.register(AgentListCommand);
cli.register(AgentShowCommand);
cli.register(AgentCreateCommand);
cli.register(AgentTranslateCommand);
cli.register(AgentSyncCommand);
cli.register(AgentValidateCommand);
cli.runExit(process.argv.slice(2));
-458
View File
@@ -1,458 +0,0 @@
/**
* E2E Tests: Commands, Settings, and Advanced Features
*
* Tests for: command generate/export/merge, settings, memory, audit, ai, cicd
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
import {
runCli,
createTestDir,
cleanupTestDir,
createTestSkill,
testFileExists,
} from './helpers/cli-runner.js';
describe('E2E: Slash Commands', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'commands-test', version: '1.0.0' }, null, 2)
);
mkdirSync(join(testDir, 'skills'), { recursive: true });
createTestSkill(join(testDir, 'skills'), 'command-skill', {
description: 'A skill for testing slash command generation',
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit command generate', () => {
it('should generate slash commands from skills', async () => {
const result = await runCli(['command', 'generate'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('command') ||
output.includes('generate') ||
output.includes('slash') ||
result.exitCode !== undefined
).toBe(true);
});
it('should generate commands for specific agent', async () => {
const result = await runCli(['command', 'generate', '--agent', 'claude-code'], {
cwd: testDir,
});
expect(result.exitCode).toBeDefined();
});
it('should generate from natural language prompt', async () => {
const result = await runCli(
['command', 'generate', '--prompt', 'Create a command to run tests'],
{ cwd: testDir }
);
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit command export', () => {
it('should export generated commands', async () => {
// Generate first
await runCli(['command', 'generate'], { cwd: testDir });
const outputPath = join(testDir, 'commands-export');
const result = await runCli(['command', 'export', '--output', outputPath], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should export in different formats', async () => {
await runCli(['command', 'generate'], { cwd: testDir });
const result = await runCli(['command', 'export', '--format', 'json'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit command merge', () => {
it('should merge multiple command files', async () => {
// Create two command files
mkdirSync(join(testDir, 'commands'), { recursive: true });
writeFileSync(
join(testDir, 'commands', 'cmd1.json'),
JSON.stringify({ commands: [{ name: 'test1' }] }, null, 2)
);
writeFileSync(
join(testDir, 'commands', 'cmd2.json'),
JSON.stringify({ commands: [{ name: 'test2' }] }, null, 2)
);
const result = await runCli(
[
'command',
'merge',
join(testDir, 'commands', 'cmd1.json'),
join(testDir, 'commands', 'cmd2.json'),
],
{ cwd: testDir }
);
expect(result.exitCode).toBeDefined();
});
});
});
describe('E2E: Settings Management', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'settings-test', version: '1.0.0' }, null, 2)
);
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit settings', () => {
it('should show current settings', async () => {
const result = await runCli(['settings'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('setting') ||
output.includes('config') ||
output.includes('No') ||
result.exitCode !== undefined
).toBe(true);
});
it('should set a configuration value', async () => {
const result = await runCli(['settings', '--set', 'defaultAgent=claude-code'], {
cwd: testDir,
});
expect(result.exitCode).toBeDefined();
});
it('should get a specific setting', async () => {
await runCli(['settings', '--set', 'testKey=testValue'], { cwd: testDir });
const result = await runCli(['settings', '--get', 'testKey'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should unset a configuration value', async () => {
await runCli(['settings', '--set', 'removeKey=value'], { cwd: testDir });
const result = await runCli(['settings', '--unset', 'removeKey'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should support --json output', async () => {
const result = await runCli(['settings', '--json'], { cwd: testDir });
if (result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
it('should reset all settings', async () => {
const result = await runCli(['settings', '--reset'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
});
describe('E2E: Memory System', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'memory-test', version: '1.0.0' }, null, 2)
);
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit memory', () => {
it('should show memory status', async () => {
const result = await runCli(['memory'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('memory') ||
output.includes('session') ||
output.includes('No') ||
result.exitCode !== undefined
).toBe(true);
});
it('should store observation', async () => {
const result = await runCli(['memory', 'store', '--observation', 'User prefers TypeScript'], {
cwd: testDir,
});
expect(result.exitCode).toBeDefined();
});
it('should retrieve memories', async () => {
await runCli(['memory', 'store', '--observation', 'Test observation for retrieval'], {
cwd: testDir,
});
const result = await runCli(['memory', 'retrieve'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should clear memory', async () => {
const result = await runCli(['memory', 'clear'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should compress memory', async () => {
// Store some memories
await runCli(['memory', 'store', '--observation', 'Observation 1'], { cwd: testDir });
await runCli(['memory', 'store', '--observation', 'Observation 2'], { cwd: testDir });
const result = await runCli(['memory', 'compress'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should support --json output', async () => {
const result = await runCli(['memory', '--json'], { cwd: testDir });
if (result.stdout.trim().startsWith('{') || result.stdout.trim().startsWith('[')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
});
});
describe('E2E: Audit System', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'audit-test', version: '1.0.0' }, null, 2)
);
mkdirSync(join(testDir, 'skills'), { recursive: true });
createTestSkill(join(testDir, 'skills'), 'audit-skill', {
description: 'A skill for testing audit logging',
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit audit', () => {
it('should show audit log', async () => {
// Perform some actions to generate audit entries
await runCli(['list'], { cwd: testDir });
await runCli(['sync', '--agent', 'claude-code'], { cwd: testDir });
const result = await runCli(['audit'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('audit') ||
output.includes('log') ||
output.includes('No') ||
result.exitCode !== undefined
).toBe(true);
});
it('should filter audit by date range', async () => {
const result = await runCli(['audit', '--since', '2024-01-01'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should filter audit by action type', async () => {
const result = await runCli(['audit', '--action', 'sync'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should export audit log', async () => {
const outputPath = join(testDir, 'audit-export.json');
const result = await runCli(['audit', '--export', outputPath], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should clear audit log', async () => {
const result = await runCli(['audit', '--clear'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
});
describe('E2E: AI Features', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'ai-test', version: '1.0.0' }, null, 2)
);
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit ai', () => {
it('should show AI status', async () => {
const result = await runCli(['ai'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('ai') ||
output.includes('API') ||
output.includes('status') ||
result.exitCode !== undefined
).toBe(true);
});
it('should configure AI provider', async () => {
const result = await runCli(['ai', 'configure', '--provider', 'openai'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should test AI connection', async () => {
const result = await runCli(['ai', 'test'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
});
describe('E2E: CI/CD Integration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'cicd-test', version: '1.0.0' }, null, 2)
);
mkdirSync(join(testDir, '.git'), { recursive: true });
writeFileSync(join(testDir, '.git', 'config'), '[core]');
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit cicd init', () => {
it('should generate GitHub Actions workflow', async () => {
const result = await runCli(['cicd', 'init', '--provider', 'github'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('cicd') ||
output.includes('github') ||
output.includes('workflow') ||
output.includes('created') ||
testFileExists(testDir, '.github', 'workflows') ||
result.exitCode !== undefined
).toBe(true);
});
it('should generate GitLab CI config', async () => {
const result = await runCli(['cicd', 'init', '--provider', 'gitlab'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should generate CircleCI config', async () => {
const result = await runCli(['cicd', 'init', '--provider', 'circleci'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should support --dry-run', async () => {
const result = await runCli(['cicd', 'init', '--provider', 'github', '--dry-run'], {
cwd: testDir,
});
expect(result.exitCode).toBeDefined();
});
it('should handle unknown provider gracefully', async () => {
const result = await runCli(['cicd', 'init', '--provider', 'unknown-ci'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('unknown') ||
output.includes('not supported') ||
output.includes('error') ||
!result.success ||
result.exitCode !== undefined
).toBe(true);
});
});
});
describe('E2E: Workflow Commands', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify(
{
name: 'workflow-test',
version: '1.0.0',
scripts: {
test: 'echo "test passed"',
build: 'echo "build completed"',
},
},
null,
2
)
);
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit workflow-create', () => {
it('should create a new workflow', async () => {
const result = await runCli(['workflow-create', '--name', 'test-workflow'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should create workflow with steps', async () => {
const result = await runCli(
['workflow-create', '--name', 'stepped-workflow', '--steps', 'build,test,deploy'],
{ cwd: testDir }
);
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit workflow-list', () => {
it('should list available workflows', async () => {
const result = await runCli(['workflow-list'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit workflow-run', () => {
it('should run a workflow', async () => {
await runCli(['workflow-create', '--name', 'runnable-workflow'], { cwd: testDir });
const result = await runCli(['workflow-run', 'runnable-workflow'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should run workflow with --dry-run', async () => {
const result = await runCli(['workflow-run', 'test', '--dry-run'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
});
-292
View File
@@ -1,292 +0,0 @@
/**
* E2E Tests: Core CLI Commands
*
* Tests for: init, list, install, enable, disable, remove, update, sync, read, validate
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
import {
runCli,
createTestDir,
cleanupTestDir,
createTestSkill,
createTestProject,
readTestFile,
testFileExists,
writeTestFile,
} from './helpers/cli-runner.js';
describe('E2E: Core CLI Commands', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit --version', () => {
it('should display version number', async () => {
const result = await runCli(['--version']);
expect(result.success).toBe(true);
expect(result.stdout).toMatch(/\d+\.\d+\.\d+/);
});
});
describe('skillkit --help', () => {
it('should display help information', async () => {
const result = await runCli(['--help']);
expect(result.success).toBe(true);
expect(result.stdout).toContain('skillkit');
});
it('should list available commands', async () => {
const result = await runCli(['--help']);
expect(result.stdout + result.stderr).toMatch(/init|list|install|sync/i);
});
});
describe('skillkit init', () => {
it('should initialize skillkit in a new project', async () => {
const result = await runCli(['init'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Check for concrete successful outcome - any of these directories
const hasSkillsDir = testFileExists(testDir, 'skills');
const hasSkillkitDir = testFileExists(testDir, '.skillkit');
const hasClaudeSkills = testFileExists(testDir, '.claude/skills');
const hasAgentSkills = testFileExists(testDir, '.agent/skills');
const hasAnyDir = hasSkillsDir || hasSkillkitDir || hasClaudeSkills || hasAgentSkills;
// Either a directory was created OR the command completed successfully with output
if (!hasAnyDir && result.exitCode !== 0) {
// Fail with debugging info
expect.fail(`Init failed. Exit code: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasAnyDir || result.exitCode === 0).toBe(true);
});
it('should create skills directory structure', async () => {
const result = await runCli(['init'], { cwd: testDir });
// Verify expected structure actually exists - any of these directories
const hasSkillsDir = testFileExists(testDir, 'skills');
const hasSkillkitDir = testFileExists(testDir, '.skillkit');
const hasClaudeSkills = testFileExists(testDir, '.claude/skills');
const hasAgentSkills = testFileExists(testDir, '.agent/skills');
const hasAnySkillDir = hasSkillsDir || hasSkillkitDir || hasClaudeSkills || hasAgentSkills;
// Strict assertion - init should create at least one directory
if (!hasAnySkillDir) {
const output = result.stdout + result.stderr;
expect.fail(`Init did not create expected directories.\nExit code: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasAnySkillDir).toBe(true);
});
});
describe('skillkit list', () => {
it('should list no skills in empty project', async () => {
const result = await runCli(['list'], { cwd: testDir });
// Should complete without error even if no skills
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should list discovered skills', async () => {
// Create some test skills
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'my-skill');
createTestSkill(skillsDir, 'another-skill');
const result = await runCli(['list'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should find the skills or report none
expect(output.includes('my-skill') || output.includes('skill') || output.includes('0')).toBe(
true
);
});
it('should support --json output format', async () => {
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'json-test-skill');
const result = await runCli(['list', '--json'], { cwd: testDir });
// If JSON format is supported, output should be parseable
if (result.stdout.trim().startsWith('[') || result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
});
describe('skillkit read', () => {
it('should read skill content', async () => {
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'readable-skill', {
content: 'This skill has specific content for reading.',
});
const result = await runCli(['read', 'readable-skill'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should either show the skill or report not found
expect(
output.includes('readable-skill') ||
output.includes('specific content') ||
output.includes('not found') ||
output.includes('No skill')
).toBe(true);
});
it('should handle non-existent skill gracefully', async () => {
const result = await runCli(['read', 'nonexistent-skill'], { cwd: testDir });
// Should not crash, may report error
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit validate', () => {
it('should validate a correct skill', async () => {
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
const skillPath = createTestSkill(skillsDir, 'valid-skill', {
description: 'A properly formatted skill with sufficient description length for validation',
});
const result = await runCli(['validate', skillPath], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(output.includes('valid') || output.includes('success') || result.success).toBe(true);
});
it('should report errors for invalid skill', async () => {
const skillDir = join(testDir, 'invalid-skill');
mkdirSync(skillDir, { recursive: true });
// Create skill without frontmatter
writeFileSync(join(skillDir, 'SKILL.md'), '# No Frontmatter\n\nJust content.');
const result = await runCli(['validate', skillDir], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should report validation issues
expect(
output.includes('error') ||
output.includes('invalid') ||
output.includes('missing') ||
!result.success
).toBe(true);
});
it('should validate skill with all Agent Skills spec fields', async () => {
const skillDir = join(testDir, 'full-spec-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(
join(skillDir, 'SKILL.md'),
`---
name: full-spec-skill
description: A skill that uses all Agent Skills specification fields for complete validation testing
license: MIT
compatibility: Node.js 18+, requires npm
allowed-tools: Bash(npm:*) Read Write Edit
metadata:
author: test-org
version: "1.0.0"
tags:
- testing
- e2e
---
# Full Spec Skill
This skill uses all available frontmatter fields.
`
);
const result = await runCli(['validate', skillDir], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should complete validation - either valid or show specific validation messages
expect(
result.success ||
output.includes('valid') ||
output.includes('full-spec-skill') ||
result.exitCode !== undefined
).toBe(true);
});
});
describe('skillkit enable/disable', () => {
it('should enable a skill', async () => {
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'toggle-skill');
const result = await runCli(['enable', 'toggle-skill'], { cwd: testDir });
// Command should complete
expect(result.exitCode).toBeDefined();
});
it('should disable a skill', async () => {
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'toggle-skill');
// First enable, then disable
await runCli(['enable', 'toggle-skill'], { cwd: testDir });
const result = await runCli(['disable', 'toggle-skill'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit sync', () => {
it('should sync skills to agent config', async () => {
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'sync-test-skill');
const result = await runCli(['sync', '--agent', 'claude-code'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should attempt sync operation
expect(
output.includes('sync') ||
output.includes('claude') ||
output.includes('skill') ||
result.exitCode !== undefined
).toBe(true);
});
});
describe('skillkit status', () => {
it('should show current skillkit status', async () => {
const result = await runCli(['status'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should show some status information
expect(
output.includes('status') ||
output.includes('skill') ||
output.includes('agent') ||
output.includes('No') ||
result.exitCode !== undefined
).toBe(true);
});
});
describe('skillkit remove', () => {
it('should remove an installed skill', async () => {
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'removable-skill');
// First ensure it exists
expect(testFileExists(testDir, 'skills', 'removable-skill', 'SKILL.md')).toBe(true);
const result = await runCli(['remove', 'removable-skill'], { cwd: testDir });
// Command should complete
expect(result.exitCode).toBeDefined();
});
});
});
-285
View File
@@ -1,285 +0,0 @@
/**
* E2E Test CLI Runner
* Executes skillkit CLI commands and captures output for testing
*/
import { spawn, execFileSync } from 'node:child_process';
import { join, resolve, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
import { mkdirSync, rmSync, existsSync, writeFileSync, readFileSync, mkdtempSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { randomUUID } from 'node:crypto';
// ESM-compatible __dirname equivalent
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
export interface CliResult {
stdout: string;
stderr: string;
exitCode: number;
success: boolean;
duration: number;
}
export interface RunOptions {
cwd?: string;
env?: NodeJS.ProcessEnv;
timeout?: number;
input?: string;
}
const ROOT_DIR = resolve(__dirname, '../..');
const CLI_PATH = join(ROOT_DIR, 'apps/skillkit/dist/cli.js');
/**
* Run a skillkit CLI command and capture the result
*/
export async function runCli(args: string[], options: RunOptions = {}): Promise<CliResult> {
const startTime = Date.now();
const cwd = options.cwd || ROOT_DIR;
const timeout = options.timeout || 30000;
return new Promise((resolve) => {
const child = spawn('node', [CLI_PATH, ...args], {
cwd,
env: { ...process.env, ...options.env, NO_COLOR: '1', FORCE_COLOR: '0' },
stdio: ['pipe', 'pipe', 'pipe'],
});
let stdout = '';
let stderr = '';
let killed = false;
const timeoutId = setTimeout(() => {
killed = true;
child.kill('SIGTERM');
}, timeout);
child.stdout?.on('data', (data) => {
stdout += data.toString();
});
child.stderr?.on('data', (data) => {
stderr += data.toString();
});
if (options.input) {
child.stdin?.write(options.input);
child.stdin?.end();
}
child.on('close', (code) => {
clearTimeout(timeoutId);
const duration = Date.now() - startTime;
const exitCode = killed ? -1 : (code ?? 1);
resolve({
stdout,
stderr,
exitCode,
success: exitCode === 0,
duration,
});
});
child.on('error', (err) => {
clearTimeout(timeoutId);
const duration = Date.now() - startTime;
resolve({
stdout,
stderr: stderr + err.message,
exitCode: 1,
success: false,
duration,
});
});
});
}
/**
* Run skillkit CLI synchronously (for simpler tests)
* Uses execFileSync to avoid shell injection vulnerabilities
*/
export function runCliSync(args: string[], options: RunOptions = {}): CliResult {
const startTime = Date.now();
const cwd = options.cwd || ROOT_DIR;
try {
const result = execFileSync('node', [CLI_PATH, ...args], {
cwd,
env: { ...process.env, ...options.env, NO_COLOR: '1', FORCE_COLOR: '0' },
encoding: 'utf-8',
timeout: options.timeout || 30000,
stdio: ['pipe', 'pipe', 'pipe'],
});
return {
stdout: result,
stderr: '',
exitCode: 0,
success: true,
duration: Date.now() - startTime,
};
} catch (error: any) {
return {
stdout: error.stdout || '',
stderr: error.stderr || error.message,
exitCode: error.status || 1,
success: false,
duration: Date.now() - startTime,
};
}
}
/**
* Create a temporary test directory
*/
export function createTestDir(prefix = 'skillkit-e2e-'): string {
return mkdtempSync(join(tmpdir(), prefix));
}
/**
* Clean up a test directory
*/
export function cleanupTestDir(dir: string): void {
if (existsSync(dir)) {
rmSync(dir, { recursive: true, force: true });
}
}
/**
* Create a test skill in a directory
*/
export function createTestSkill(
dir: string,
name: string,
options: {
description?: string;
content?: string;
additionalFrontmatter?: Record<string, unknown>;
} = {}
): string {
const skillDir = join(dir, name);
mkdirSync(skillDir, { recursive: true });
const frontmatter: Record<string, unknown> = {
name,
description: options.description || `Test skill: ${name} for E2E testing`,
...options.additionalFrontmatter,
};
const frontmatterStr = Object.entries(frontmatter)
.map(([key, value]) => {
if (typeof value === 'object') {
return `${key}:\n${Object.entries(value as Record<string, unknown>)
.map(([k, v]) => ` ${k}: ${JSON.stringify(v)}`)
.join('\n')}`;
}
return `${key}: ${value}`;
})
.join('\n');
const content = `---
${frontmatterStr}
---
# ${name}
${options.content || `This is a test skill named ${name}.`}
`;
writeFileSync(join(skillDir, 'SKILL.md'), content);
return skillDir;
}
/**
* Create a test project with common setup
*/
export function createTestProject(options: {
withSkills?: boolean;
skillCount?: number;
withGit?: boolean;
projectType?: 'node' | 'python' | 'rust' | 'go';
} = {}): { dir: string; cleanup: () => void } {
const dir = createTestDir();
if (options.withGit) {
mkdirSync(join(dir, '.git'), { recursive: true });
writeFileSync(join(dir, '.git', 'config'), '[core]\n\trepositoryformatversion = 0');
}
if (options.projectType === 'node') {
writeFileSync(
join(dir, 'package.json'),
JSON.stringify({ name: 'test-project', version: '1.0.0' }, null, 2)
);
} else if (options.projectType === 'python') {
writeFileSync(join(dir, 'requirements.txt'), 'pytest>=7.0.0\n');
} else if (options.projectType === 'rust') {
writeFileSync(join(dir, 'Cargo.toml'), '[package]\nname = "test"\nversion = "0.1.0"');
} else if (options.projectType === 'go') {
writeFileSync(join(dir, 'go.mod'), 'module test\n\ngo 1.21');
}
if (options.withSkills) {
const skillsDir = join(dir, 'skills');
mkdirSync(skillsDir, { recursive: true });
// Use nullish coalescing to respect explicit 0
const count = options.skillCount ?? 3;
for (let i = 1; i <= count; i++) {
createTestSkill(skillsDir, `test-skill-${i}`);
}
}
return {
dir,
cleanup: () => cleanupTestDir(dir),
};
}
/**
* Read file content from test directory
*/
export function readTestFile(dir: string, ...paths: string[]): string {
return readFileSync(join(dir, ...paths), 'utf-8');
}
/**
* Check if file exists in test directory
*/
export function testFileExists(dir: string, ...paths: string[]): boolean {
return existsSync(join(dir, ...paths));
}
/**
* Write file in test directory
*/
export function writeTestFile(dir: string, path: string, content: string): void {
const fullPath = join(dir, path);
mkdirSync(join(fullPath, '..'), { recursive: true });
writeFileSync(fullPath, content);
}
/**
* Assert CLI output contains expected text
*/
export function assertContains(result: CliResult, expected: string, message?: string): void {
const combined = result.stdout + result.stderr;
if (!combined.includes(expected)) {
throw new Error(
message || `Expected output to contain "${expected}"\nActual output:\n${combined}`
);
}
}
/**
* Assert CLI output matches regex
*/
export function assertMatches(result: CliResult, pattern: RegExp, message?: string): void {
const combined = result.stdout + result.stderr;
if (!pattern.test(combined)) {
throw new Error(
message || `Expected output to match ${pattern}\nActual output:\n${combined}`
);
}
}
-5
View File
@@ -1,5 +0,0 @@
/**
* E2E Test Helpers - Barrel Export
*/
export * from './cli-runner.js';
-400
View File
@@ -1,400 +0,0 @@
/**
* E2E Tests: Hooks System and Agent Orchestration
*
* Tests for: hook register/list/trigger/remove, orchestrator commands
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
import {
runCli,
createTestDir,
cleanupTestDir,
createTestSkill,
testFileExists,
} from './helpers/cli-runner.js';
// Available hook events
const HOOK_EVENTS = [
'pre-commit',
'post-commit',
'file-change',
'build',
'test',
'deploy',
] as const;
describe('E2E: Hooks System', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
// Create a git repo structure for commit hooks
mkdirSync(join(testDir, '.git', 'hooks'), { recursive: true });
writeFileSync(join(testDir, '.git', 'config'), '[core]\n\trepositoryformatversion = 0');
// Create project files
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'hooks-test', version: '1.0.0' }, null, 2)
);
// Create a skill that can be triggered
mkdirSync(join(testDir, 'skills'), { recursive: true });
createTestSkill(join(testDir, 'skills'), 'hookable-skill', {
description: 'A skill that can be triggered by hooks for E2E testing',
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit hook register', () => {
it('should register a pre-commit hook', async () => {
const result = await runCli(
['hook', 'register', '--event', 'pre-commit', '--skill', 'hookable-skill'],
{ cwd: testDir }
);
const output = result.stdout + result.stderr;
// Must have meaningful output about the registration
const hasRelevantOutput =
output.includes('register') ||
output.includes('hook') ||
output.includes('pre-commit') ||
output.includes('success');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Hook registration failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should register hooks for all event types', async () => {
for (const event of HOOK_EVENTS) {
const result = await runCli(
['hook', 'register', '--event', event, '--skill', 'hookable-skill'],
{ cwd: testDir }
);
// Fail explicitly on timeout (-1 exit code)
expect(result.exitCode).not.toBe(-1);
// Command should complete (exit code 0 or 1 for expected behavior)
expect(result.exitCode).toBeLessThanOrEqual(1);
}
});
it('should register hook with custom name', async () => {
const result = await runCli(
[
'hook',
'register',
'--event',
'test',
'--skill',
'hookable-skill',
'--name',
'my-test-hook',
],
{ cwd: testDir }
);
// Fail explicitly on timeout
expect(result.exitCode).not.toBe(-1);
// Command should complete successfully or with expected exit
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should register hook with condition', async () => {
const result = await runCli(
[
'hook',
'register',
'--event',
'file-change',
'--skill',
'hookable-skill',
'--pattern',
'*.ts',
],
{ cwd: testDir }
);
// Fail explicitly on timeout
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should handle invalid event gracefully', async () => {
const result = await runCli(
['hook', 'register', '--event', 'invalid-event', '--skill', 'hookable-skill'],
{ cwd: testDir }
);
const output = result.stdout + result.stderr;
// Should either fail or show an error message
const showsError =
output.includes('invalid') ||
output.includes('unknown') ||
output.includes('error') ||
!result.success;
expect(showsError).toBe(true);
});
});
describe('skillkit hook list', () => {
it('should list registered hooks', async () => {
// Register a hook first
await runCli(['hook', 'register', '--event', 'build', '--skill', 'hookable-skill'], {
cwd: testDir,
});
const result = await runCli(['hook', 'list'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should show hooks or indicate none
const hasRelevantOutput =
output.includes('hook') ||
output.includes('build') ||
output.includes('hookable-skill') ||
output.includes('No');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Hook list failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should support --json output', async () => {
const result = await runCli(['hook', 'list', '--json'], { cwd: testDir });
if (result.stdout.trim().startsWith('[') || result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
it('should filter by event type', async () => {
await runCli(['hook', 'register', '--event', 'test', '--skill', 'hookable-skill'], {
cwd: testDir,
});
const result = await runCli(['hook', 'list', '--event', 'test'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit hook trigger', () => {
it('should trigger a hook manually', async () => {
await runCli(['hook', 'register', '--event', 'test', '--skill', 'hookable-skill'], {
cwd: testDir,
});
const result = await runCli(['hook', 'trigger', 'test'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Fail explicitly on timeout
expect(result.exitCode).not.toBe(-1);
// Should show trigger-related output
const hasRelevantOutput =
output.includes('trigger') ||
output.includes('test') ||
output.includes('hook') ||
output.includes('executed');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Hook trigger failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should trigger with --dry-run', async () => {
await runCli(['hook', 'register', '--event', 'deploy', '--skill', 'hookable-skill'], {
cwd: testDir,
});
const result = await runCli(['hook', 'trigger', 'deploy', '--dry-run'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should handle missing hook gracefully', async () => {
const result = await runCli(['hook', 'trigger', 'nonexistent-event'], { cwd: testDir });
// Fail explicitly on timeout, should complete without crashing
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit hook remove', () => {
it('should remove a registered hook', async () => {
// Register then remove
await runCli(
['hook', 'register', '--event', 'build', '--skill', 'hookable-skill', '--name', 'my-hook'],
{ cwd: testDir }
);
const result = await runCli(['hook', 'remove', 'my-hook'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should show removal confirmation
const hasRelevantOutput =
output.includes('remove') ||
output.includes('my-hook') ||
output.includes('success');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Hook remove failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should remove all hooks for an event', async () => {
await runCli(['hook', 'register', '--event', 'test', '--skill', 'hookable-skill'], {
cwd: testDir,
});
const result = await runCli(['hook', 'remove', '--event', 'test', '--all'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
});
describe('E2E: Agent Orchestration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'orchestration-test', version: '1.0.0' }, null, 2)
);
mkdirSync(join(testDir, 'skills'), { recursive: true });
createTestSkill(join(testDir, 'skills'), 'orchestrated-skill', {
description: 'A skill for testing multi-agent orchestration features',
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('multi-agent sync', () => {
it('should sync to multiple agents simultaneously', async () => {
const result = await runCli(['sync', '--agents', 'claude-code,cursor,windsurf'], {
cwd: testDir,
});
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should sync to all supported agents', async () => {
const result = await runCli(['sync', '--all-agents'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('team orchestration', () => {
it('should configure team with leader and teammates', async () => {
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(
['team', 'init', '--leader', 'claude-code', '--teammates', 'cursor,windsurf'],
{ cwd: testDir }
);
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should delegate tasks to team members', async () => {
await runCli(['team', 'init', '--leader', 'claude-code'], { cwd: testDir });
// This tests the delegation feature if available
const result = await runCli(['team', 'sync', '--delegate'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('workflow integration', () => {
it('should trigger hooks during workflow execution', async () => {
// Register a build hook
await runCli(
['hook', 'register', '--event', 'build', '--skill', 'orchestrated-skill'],
{ cwd: testDir }
);
// Run workflow that triggers build
const result = await runCli(['workflow', 'run', 'build'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should chain multiple hooks in sequence', async () => {
await runCli(['hook', 'register', '--event', 'test', '--skill', 'orchestrated-skill'], {
cwd: testDir,
});
await runCli(
['hook', 'register', '--event', 'build', '--skill', 'orchestrated-skill', '--after', 'test'],
{ cwd: testDir }
);
const result = await runCli(['hook', 'trigger', 'test', '--chain'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
});
describe('E2E: Hook + Skill Integration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
mkdirSync(join(testDir, '.git', 'hooks'), { recursive: true });
writeFileSync(join(testDir, '.git', 'config'), '[core]');
mkdirSync(join(testDir, 'skills'), { recursive: true });
// Create a skill with specific trigger configuration
const skillDir = join(testDir, 'skills', 'auto-trigger-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(
join(skillDir, 'SKILL.md'),
`---
name: auto-trigger-skill
description: A skill that auto-triggers on specific events for E2E testing
triggers:
- event: pre-commit
- event: file-change
pattern: "*.ts"
---
# Auto-Trigger Skill
This skill automatically activates on:
- Pre-commit hooks
- TypeScript file changes
`
);
});
afterEach(() => {
cleanupTestDir(testDir);
});
it('should auto-register hooks from skill metadata', async () => {
const result = await runCli(['hook', 'auto-register'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should detect and apply skill triggers', async () => {
const result = await runCli(['sync', '--with-hooks'], { cwd: testDir });
expect(result.exitCode).not.toBe(-1);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
-424
View File
@@ -1,424 +0,0 @@
/**
* E2E Tests: Methodology and Plan System
*
* Tests for: methodology list/load/apply/validate, plan create/validate/execute/list/status
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
import {
runCli,
createTestDir,
cleanupTestDir,
createTestSkill,
testFileExists,
writeTestFile,
} from './helpers/cli-runner.js';
// Available methodology packs
const METHODOLOGY_PACKS = [
'agile',
'tdd',
'devops',
'security-first',
'documentation-first',
] as const;
describe('E2E: Methodology Framework', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
// Create a basic project structure
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'test-project', version: '1.0.0' }, null, 2)
);
mkdirSync(join(testDir, 'src'), { recursive: true });
writeFileSync(join(testDir, 'src', 'index.ts'), 'export const main = () => {};\n');
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit methodology list', () => {
it('should list available methodology packs', async () => {
const result = await runCli(['methodology', 'list'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Must complete successfully and show relevant output
expect(result.exitCode).toBeLessThanOrEqual(1);
// Should contain methodology-related content
const hasRelevantOutput =
output.includes('methodology') ||
output.includes('agile') ||
output.includes('tdd') ||
output.includes('No');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Methodology list failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should support --json output', async () => {
const result = await runCli(['methodology', 'list', '--json'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
if (result.stdout.trim().startsWith('[') || result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
it('should show methodology details with --verbose', async () => {
const result = await runCli(['methodology', 'list', '--verbose'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit methodology install', () => {
describe.each(METHODOLOGY_PACKS)('loading %s methodology', (pack) => {
it(`should load ${pack} methodology pack`, async () => {
const result = await runCli(['methodology', 'install', pack], { cwd: testDir });
const output = result.stdout + result.stderr;
// Command should complete
expect(result.exitCode).toBeLessThanOrEqual(1);
// Should have relevant output
const hasRelevantOutput =
output.includes(pack) ||
output.includes('installed') ||
output.includes('success') ||
output.includes('methodology');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Load ${pack} failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
});
it('should handle unknown methodology gracefully', async () => {
const result = await runCli(['methodology', 'install', 'nonexistent-methodology'], {
cwd: testDir,
});
const output = result.stdout + result.stderr;
// Should show error or fail
const showsError =
output.includes('not found') ||
output.includes('unknown') ||
output.includes('error') ||
!result.success;
expect(showsError).toBe(true);
});
it('should load multiple methodologies', async () => {
const result = await runCli(['methodology', 'install', 'tdd', 'security-first'], {
cwd: testDir,
});
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit methodology sync', () => {
it('should sync installed methodology to project', async () => {
// Install a methodology first
await runCli(['methodology', 'install', 'tdd'], { cwd: testDir });
const result = await runCli(['methodology', 'sync'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('sync') ||
output.includes('tdd') ||
output.includes('skill') ||
output.includes('success');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Sync methodology failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should sync specific methodology', async () => {
const result = await runCli(['methodology', 'sync', 'agile'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit methodology info', () => {
it('should show methodology information', async () => {
await runCli(['methodology', 'install', 'tdd'], { cwd: testDir });
const result = await runCli(['methodology', 'info', 'tdd'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('info') ||
output.includes('tdd') ||
output.includes('methodology') ||
output.includes('description');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Methodology info failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should show info for specific methodology', async () => {
const result = await runCli(['methodology', 'info', 'security-first'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
});
describe('E2E: Plan System', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'plan-test-project', version: '1.0.0' }, null, 2)
);
mkdirSync(join(testDir, 'src'), { recursive: true });
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit plan create', () => {
it('should create a new plan', async () => {
const result = await runCli(['plan', 'create', '--name', 'test-plan'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('plan') ||
output.includes('test-plan') ||
output.includes('created');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Plan create failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should create plan with description', async () => {
const result = await runCli(
['plan', 'create', '--name', 'described-plan', '--description', 'A test plan for E2E'],
{ cwd: testDir }
);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should create plan from template', async () => {
const result = await runCli(
['plan', 'create', '--name', 'template-plan', '--template', 'feature'],
{ cwd: testDir }
);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should create plan with steps', async () => {
const result = await runCli(
[
'plan',
'create',
'--name',
'stepped-plan',
'--steps',
'Step 1: Setup,Step 2: Implement,Step 3: Test',
],
{ cwd: testDir }
);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit plan templates', () => {
it('should list available plan templates', async () => {
const result = await runCli(['plan', 'templates'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('template') ||
output.includes('plan') ||
output.includes('available') ||
output.includes('No');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Plan templates failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should support --json output', async () => {
const result = await runCli(['plan', 'templates', '--json'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
if (result.stdout.trim().startsWith('[') || result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
});
describe('skillkit plan validate', () => {
it('should validate plan structure', async () => {
// Create a plan
await runCli(['plan', 'create', '--name', 'validate-plan'], { cwd: testDir });
const result = await runCli(['plan', 'validate', 'validate-plan'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('valid') ||
output.includes('validate') ||
output.includes('plan');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Plan validate failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should report validation errors', async () => {
// Create an invalid plan file manually
const plansDir = join(testDir, '.skillkit', 'plans');
mkdirSync(plansDir, { recursive: true });
writeFileSync(
join(plansDir, 'invalid-plan.json'),
JSON.stringify({ name: 'invalid' }) // Missing required fields
);
const result = await runCli(['plan', 'validate', 'invalid-plan'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit plan generate', () => {
it('should generate a plan from a template', async () => {
const result = await runCli(['plan', 'generate', '--template', 'feature'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('generate') ||
output.includes('plan') ||
output.includes('template') ||
output.includes('feature');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Plan generate failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
});
describe('skillkit plan execute', () => {
it('should execute a plan', async () => {
await runCli(['plan', 'create', '--name', 'exec-plan'], { cwd: testDir });
const result = await runCli(['plan', 'execute', 'exec-plan'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('execute') ||
output.includes('plan') ||
output.includes('exec-plan') ||
output.includes('running');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Plan execute failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should execute with --dry-run', async () => {
await runCli(['plan', 'create', '--name', 'dry-run-plan'], { cwd: testDir });
const result = await runCli(['plan', 'execute', 'dry-run-plan', '--dry-run'], {
cwd: testDir,
});
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should execute specific step', async () => {
await runCli(
['plan', 'create', '--name', 'step-plan', '--steps', 'Step1,Step2,Step3'],
{ cwd: testDir }
);
const result = await runCli(['plan', 'execute', 'step-plan', '--step', '1'], {
cwd: testDir,
});
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
});
describe('E2E: Methodology + Plan Integration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'integration-test', version: '1.0.0' }, null, 2)
);
});
afterEach(() => {
cleanupTestDir(testDir);
});
it('should create plan based on methodology', async () => {
// Load TDD methodology
await runCli(['methodology', 'install', 'tdd'], { cwd: testDir });
// Create plan using TDD approach
const result = await runCli(
['plan', 'create', '--name', 'tdd-feature-plan', '--methodology', 'tdd'],
{ cwd: testDir }
);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should validate plan against methodology constraints', async () => {
await runCli(['methodology', 'install', 'security-first'], { cwd: testDir });
await runCli(['plan', 'create', '--name', 'secure-plan'], { cwd: testDir });
const result = await runCli(['plan', 'validate', 'secure-plan', '--methodology'], {
cwd: testDir,
});
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
-397
View File
@@ -1,397 +0,0 @@
/**
* E2E Tests: Plugin System
*
* Tests for: plugin list/install/uninstall/enable/disable/info
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
import {
runCli,
createTestDir,
cleanupTestDir,
testFileExists,
writeTestFile,
} from './helpers/cli-runner.js';
describe('E2E: Plugin System', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'plugin-test', version: '1.0.0' }, null, 2)
);
// Create .skillkit directory for plugin storage
mkdirSync(join(testDir, '.skillkit', 'plugins'), { recursive: true });
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit plugin list', () => {
it('should list installed plugins', async () => {
const result = await runCli(['plugin', 'list'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('plugin') ||
output.includes('No') ||
output.includes('installed') ||
result.exitCode !== undefined
).toBe(true);
});
it('should support --json output', async () => {
const result = await runCli(['plugin', 'list', '--json'], { cwd: testDir });
if (result.stdout.trim().startsWith('[') || result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
it('should show available plugins from marketplace', async () => {
const result = await runCli(['plugin', 'list', '--available'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should filter enabled/disabled plugins', async () => {
const result = await runCli(['plugin', 'list', '--enabled'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit plugin install', () => {
it('should install plugin from local path', async () => {
// Create a mock plugin
const pluginDir = join(testDir, 'my-plugin');
mkdirSync(pluginDir, { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify(
{
name: 'my-plugin',
version: '1.0.0',
description: 'A test plugin for E2E testing',
},
null,
2
)
);
writeFileSync(join(pluginDir, 'index.js'), 'module.exports = { init: () => {} };');
const result = await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('install') ||
output.includes('my-plugin') ||
output.includes('success') ||
result.exitCode !== undefined
).toBe(true);
});
it('should install plugin from npm-style name', async () => {
// This may fail if plugin doesn't exist, but shouldn't crash
const result = await runCli(['plugin', 'install', 'skillkit-plugin-example'], {
cwd: testDir,
});
expect(result.exitCode).toBeDefined();
});
it('should handle non-existent plugin gracefully', async () => {
const result = await runCli(['plugin', 'install', 'nonexistent-plugin-12345'], {
cwd: testDir,
});
const output = result.stdout + result.stderr;
expect(
output.includes('not found') ||
output.includes('error') ||
output.includes('fail') ||
!result.success ||
result.exitCode !== undefined
).toBe(true);
});
it('should install with --force option', async () => {
const pluginDir = join(testDir, 'force-plugin');
mkdirSync(pluginDir, { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify({ name: 'force-plugin', version: '1.0.0' }, null, 2)
);
// Install twice with force
await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
const result = await runCli(['plugin', 'install', pluginDir, '--force'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit plugin uninstall', () => {
it('should uninstall an installed plugin', async () => {
// First install a plugin
const pluginDir = join(testDir, 'uninstall-plugin');
mkdirSync(pluginDir, { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify({ name: 'uninstall-plugin', version: '1.0.0' }, null, 2)
);
await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
// Then uninstall
const result = await runCli(['plugin', 'uninstall', 'uninstall-plugin'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('uninstall') ||
output.includes('remove') ||
output.includes('success') ||
result.exitCode !== undefined
).toBe(true);
});
it('should handle uninstalling non-installed plugin gracefully', async () => {
const result = await runCli(['plugin', 'uninstall', 'not-installed-plugin'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
describe('skillkit plugin enable/disable', () => {
beforeEach(async () => {
// Install a test plugin
const pluginDir = join(testDir, 'toggle-plugin');
mkdirSync(pluginDir, { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify({ name: 'toggle-plugin', version: '1.0.0' }, null, 2)
);
await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
});
it('should enable a disabled plugin', async () => {
// First disable
await runCli(['plugin', 'disable', 'toggle-plugin'], { cwd: testDir });
// Then enable
const result = await runCli(['plugin', 'enable', 'toggle-plugin'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('enable') ||
output.includes('toggle-plugin') ||
result.exitCode !== undefined
).toBe(true);
});
it('should disable an enabled plugin', async () => {
const result = await runCli(['plugin', 'disable', 'toggle-plugin'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('disable') ||
output.includes('toggle-plugin') ||
result.exitCode !== undefined
).toBe(true);
});
});
describe('skillkit plugin info', () => {
it('should show plugin information', async () => {
// Install a plugin first
const pluginDir = join(testDir, 'info-plugin');
mkdirSync(pluginDir, { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify(
{
name: 'info-plugin',
version: '2.0.0',
description: 'A plugin with detailed info for testing',
author: 'Test Author',
homepage: 'https://example.com',
},
null,
2
)
);
await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
const result = await runCli(['plugin', 'info', 'info-plugin'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('info-plugin') ||
output.includes('2.0.0') ||
output.includes('info') ||
output.includes('description') ||
result.exitCode !== undefined
).toBe(true);
});
it('should handle non-existent plugin info gracefully', async () => {
const result = await runCli(['plugin', 'info', 'nonexistent-plugin'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should support --json output', async () => {
const pluginDir = join(testDir, 'json-info-plugin');
mkdirSync(pluginDir, { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify({ name: 'json-info-plugin', version: '1.0.0' }, null, 2)
);
await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
const result = await runCli(['plugin', 'info', 'json-info-plugin', '--json'], {
cwd: testDir,
});
if (result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
});
});
describe('E2E: Plugin Integration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'plugin-integration', version: '1.0.0' }, null, 2)
);
mkdirSync(join(testDir, '.skillkit', 'plugins'), { recursive: true });
mkdirSync(join(testDir, 'skills'), { recursive: true });
});
afterEach(() => {
cleanupTestDir(testDir);
});
it('should load plugin skills into skill list', async () => {
// Create a plugin with skills
const pluginDir = join(testDir, 'skills-plugin');
mkdirSync(join(pluginDir, 'skills', 'plugin-skill'), { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify(
{
name: 'skills-plugin',
version: '1.0.0',
skills: ['skills/plugin-skill'],
},
null,
2
)
);
writeFileSync(
join(pluginDir, 'skills', 'plugin-skill', 'SKILL.md'),
`---
name: plugin-skill
description: A skill provided by a plugin for E2E testing
---
# Plugin Skill
`
);
await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
// List should include plugin skill
const result = await runCli(['list'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should handle plugin hooks', async () => {
// Create a plugin with hooks
const pluginDir = join(testDir, 'hooks-plugin');
mkdirSync(pluginDir, { recursive: true });
writeFileSync(
join(pluginDir, 'plugin.json'),
JSON.stringify(
{
name: 'hooks-plugin',
version: '1.0.0',
hooks: {
'pre-sync': 'echo "pre-sync from plugin"',
'post-sync': 'echo "post-sync from plugin"',
},
},
null,
2
)
);
await runCli(['plugin', 'install', pluginDir], { cwd: testDir });
// Sync should trigger plugin hooks
const result = await runCli(['sync', '--agent', 'claude-code'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should respect plugin priority order', async () => {
// Create two plugins with different priorities
const plugin1Dir = join(testDir, 'priority-plugin-1');
const plugin2Dir = join(testDir, 'priority-plugin-2');
mkdirSync(plugin1Dir, { recursive: true });
mkdirSync(plugin2Dir, { recursive: true });
writeFileSync(
join(plugin1Dir, 'plugin.json'),
JSON.stringify({ name: 'priority-plugin-1', version: '1.0.0', priority: 10 }, null, 2)
);
writeFileSync(
join(plugin2Dir, 'plugin.json'),
JSON.stringify({ name: 'priority-plugin-2', version: '1.0.0', priority: 20 }, null, 2)
);
await runCli(['plugin', 'install', plugin1Dir], { cwd: testDir });
await runCli(['plugin', 'install', plugin2Dir], { cwd: testDir });
const result = await runCli(['plugin', 'list'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
describe('E2E: Marketplace Integration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'marketplace-test', version: '1.0.0' }, null, 2)
);
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit marketplace', () => {
it('should list marketplace skills', async () => {
const result = await runCli(['marketplace'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('marketplace') ||
output.includes('skill') ||
output.includes('available') ||
result.exitCode !== undefined
).toBe(true);
});
it('should search marketplace', async () => {
const result = await runCli(['marketplace', '--search', 'typescript'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should filter by category', async () => {
const result = await runCli(['marketplace', '--category', 'testing'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
it('should show skill details', async () => {
const result = await runCli(['marketplace', '--info', 'some-skill'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
});
-761
View File
@@ -1,761 +0,0 @@
/**
* E2E Tests: Skill Translator
*
* End-to-end tests for cross-agent skill translation.
* Tests the complete workflow of parsing, translating, and writing skills.
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
import {
createTestDir,
cleanupTestDir,
createTestSkill,
testFileExists,
readTestFile,
} from './helpers/cli-runner.js';
import {
parseSkillToCanonical,
parseSkillContentToCanonical,
translateSkillToAgent,
translateSkillToAll,
writeTranslatedSkill,
generateSkillsConfig,
getAgentSkillsDir,
getAgentConfigFile,
AGENT_SKILL_FORMATS,
type CrossAgentSkill,
} from '@skillkit/core';
// All 17 supported agents
const SUPPORTED_AGENTS = [
'claude-code',
'cursor',
'codex',
'gemini-cli',
'opencode',
'antigravity',
'amp',
'clawdbot',
'droid',
'github-copilot',
'goose',
'kilo',
'kiro-cli',
'roo',
'trae',
'windsurf',
'universal',
] as const;
describe('E2E: Skill Translator - Parsing', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir('skillkit-translator-');
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('parseSkillToCanonical', () => {
it('should parse a complete SKILL.md with all frontmatter fields', () => {
const skillDir = join(testDir, 'complete-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: complete-skill
description: A comprehensive skill for E2E testing
version: "2.0.0"
author: SkillKit Team
tags:
- testing
- e2e
- comprehensive
allowed-tools: Read, Write, Bash(npm:*)
---
# Complete Skill
This skill tests all parsing capabilities.
## Features
- Full frontmatter parsing
- Content extraction
- Agent-specific field handling
## Usage
\`\`\`bash
skillkit read complete-skill
\`\`\`
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.name).toBe('complete-skill');
expect(result?.description).toBe('A comprehensive skill for E2E testing');
expect(result?.version).toBe('2.0.0');
expect(result?.author).toBe('SkillKit Team');
expect(result?.tags).toEqual(['testing', 'e2e', 'comprehensive']);
expect(result?.allowedTools).toEqual(['Read', 'Write', 'Bash(npm:*)']);
expect(result?.content).toContain('# Complete Skill');
expect(result?.content).toContain('## Features');
});
it('should handle SKILL.md with minimal frontmatter', () => {
const skillDir = join(testDir, 'minimal-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: minimal-skill
description: Just the basics
---
# Minimal Skill
Simple content.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.name).toBe('minimal-skill');
expect(result?.description).toBe('Just the basics');
expect(result?.version).toBeUndefined();
expect(result?.author).toBeUndefined();
});
it('should extract description from content when not in frontmatter', () => {
const skillDir = join(testDir, 'no-desc-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: no-desc-skill
---
This is the first paragraph which should become the description automatically.
## More Content
Additional content here.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.description).toContain('This is the first paragraph');
});
it('should handle SKILL.md without any frontmatter', () => {
const skillDir = join(testDir, 'no-frontmatter');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `# No Frontmatter Skill
This skill has no YAML frontmatter at all.
## Usage
Just use it directly.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
// Name should be derived from directory
expect(result?.name).toBe('no-frontmatter');
expect(result?.content).toContain('# No Frontmatter Skill');
});
it('should return null for non-existent skill directory', () => {
const result = parseSkillToCanonical(join(testDir, 'does-not-exist'));
expect(result).toBeNull();
});
it('should return null for directory without SKILL.md', () => {
const emptyDir = join(testDir, 'empty-dir');
mkdirSync(emptyDir, { recursive: true });
writeFileSync(join(emptyDir, 'README.md'), '# Not a skill');
const result = parseSkillToCanonical(emptyDir);
expect(result).toBeNull();
});
});
describe('parseSkillContentToCanonical', () => {
it('should parse content with Claude Code specific fields', () => {
const content = `---
name: claude-specific
description: Skill with Claude Code specific fields
model: opus
context: fork
disable-model-invocation: true
---
# Claude Specific Skill
Use with Claude Code for best results.
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill', 'claude-code');
expect(result?.name).toBe('claude-specific');
expect(result?.agentFields?.model).toBe('opus');
expect(result?.agentFields?.context).toBe('fork');
expect(result?.agentFields?.['disable-model-invocation']).toBe(true);
expect(result?.sourceAgent).toBe('claude-code');
});
it('should parse content with Cursor specific fields', () => {
const content = `---
name: cursor-specific
description: Skill with Cursor specific fields
globs: "**/*.ts"
alwaysApply: true
---
# Cursor Specific Skill
Optimized for Cursor.
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill', 'cursor');
expect(result?.name).toBe('cursor-specific');
expect(result?.agentFields?.globs).toBe('**/*.ts');
expect(result?.agentFields?.alwaysApply).toBe(true);
expect(result?.sourceAgent).toBe('cursor');
});
});
});
describe('E2E: Skill Translator - Translation', () => {
let testDir: string;
let testSkill: CrossAgentSkill;
beforeEach(() => {
testDir = createTestDir('skillkit-translate-');
testSkill = {
name: 'translation-test',
description: 'A skill designed for testing cross-agent translation',
content: `# Translation Test Skill
This skill is used to verify that translation works correctly across all supported agents.
## Features
- Cross-agent compatibility
- Frontmatter preservation
- Content integrity
## Usage
\`\`\`bash
skillkit read translation-test
\`\`\`
`,
frontmatter: {
name: 'translation-test',
description: 'A skill designed for testing cross-agent translation',
version: '1.0.0',
author: 'SkillKit E2E Tests',
tags: ['testing', 'translation'],
},
sourcePath: join(testDir, 'translation-test'),
sourceAgent: 'claude-code',
version: '1.0.0',
author: 'SkillKit E2E Tests',
tags: ['testing', 'translation'],
allowedTools: ['Read', 'Write', 'Bash'],
};
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('translateSkillToAgent', () => {
it.each(SUPPORTED_AGENTS)('should translate skill to %s format', (agent) => {
const result = translateSkillToAgent(testSkill, agent);
expect(result.success).toBe(true);
expect(result.targetAgent).toBe(agent);
expect(result.content).toBeTruthy();
expect(result.content).toContain('translation-test');
expect(typeof result.filename).toBe('string');
});
it('should preserve skill name and description across translations', () => {
for (const agent of SUPPORTED_AGENTS) {
const result = translateSkillToAgent(testSkill, agent);
expect(result.content).toContain('translation-test');
}
});
it('should add translation metadata when requested', () => {
const result = translateSkillToAgent(testSkill, 'cursor', { addMetadata: true });
expect(result.success).toBe(true);
expect(result.content).toContain('_translated-from: claude-code');
expect(result.content).toContain('_translated-at:');
});
it('should not add metadata by default', () => {
const result = translateSkillToAgent(testSkill, 'cursor');
expect(result.success).toBe(true);
expect(result.content).not.toContain('_translated-from');
});
it('should preserve Claude Code specific fields when translating back to Claude Code', () => {
const claudeSkill: CrossAgentSkill = {
...testSkill,
agentFields: {
model: 'opus',
context: 'fork',
'disable-model-invocation': true,
},
};
const result = translateSkillToAgent(claudeSkill, 'claude-code');
expect(result.success).toBe(true);
expect(result.content).toContain('model: opus');
expect(result.content).toContain('context: fork');
expect(result.content).toContain('disable-model-invocation: true');
});
it('should report incompatible features when translating hooks to non-Claude agents', () => {
const skillWithHooks: CrossAgentSkill = {
...testSkill,
agentFields: {
hooks: [{ type: 'PreToolUse', command: 'echo test' }],
},
};
const result = translateSkillToAgent(skillWithHooks, 'cursor');
expect(result.incompatible).toContain('hooks (only supported in Claude Code)');
});
});
describe('translateSkillToAll', () => {
it('should translate skill to all agents except source', () => {
const skillDir = join(testDir, 'all-agents-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: all-agents
description: Skill for all agents testing
version: "1.0.0"
---
# All Agents Skill
Universal skill content.
`);
const results = translateSkillToAll(skillDir, 'claude-code');
// Should have translations for all agents except source
expect(results.size).toBe(SUPPORTED_AGENTS.length - 1);
expect(results.has('claude-code')).toBe(false);
for (const agent of SUPPORTED_AGENTS) {
if (agent !== 'claude-code') {
expect(results.has(agent)).toBe(true);
const result = results.get(agent);
expect(result?.success).toBe(true);
}
}
});
it('should return empty map for non-existent skill', () => {
const results = translateSkillToAll(join(testDir, 'non-existent'));
expect(results.size).toBe(0);
});
});
});
describe('E2E: Skill Translator - Writing', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir('skillkit-write-');
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('writeTranslatedSkill', () => {
it('should write translated skill to correct location', () => {
const translationResult = {
success: true,
content: `---
name: written-skill
description: A skill that was written to disk
---
# Written Skill
Content here.
`,
filename: 'SKILL.md',
targetDir: 'written-skill',
warnings: [],
incompatible: [],
targetAgent: 'claude-code' as const,
};
const writeResult = writeTranslatedSkill(translationResult, testDir);
expect(writeResult.success).toBe(true);
expect(existsSync(writeResult.path)).toBe(true);
const writtenContent = readFileSync(writeResult.path, 'utf-8');
expect(writtenContent).toContain('name: written-skill');
expect(writtenContent).toContain('# Written Skill');
});
it('should create nested directories as needed', () => {
const translationResult = {
success: true,
content: '---\nname: nested\n---\n# Content',
filename: 'SKILL.md',
targetDir: '.cursor/skills/deeply/nested/skill',
warnings: [],
incompatible: [],
targetAgent: 'cursor' as const,
};
const writeResult = writeTranslatedSkill(translationResult, testDir);
expect(writeResult.success).toBe(true);
expect(existsSync(join(testDir, '.cursor/skills/deeply/nested/skill/SKILL.md'))).toBe(true);
});
it('should handle failed translation results gracefully', () => {
const failedResult = {
success: false,
content: '',
filename: 'SKILL.md',
targetDir: 'failed-skill',
warnings: ['Translation failed'],
incompatible: [],
targetAgent: 'cursor' as const,
};
const writeResult = writeTranslatedSkill(failedResult, testDir);
expect(writeResult.success).toBe(false);
});
});
});
describe('E2E: Skill Translator - Config Generation', () => {
const testSkills = [
{ name: 'skill-alpha', description: 'First test skill', path: '/skills/alpha', location: 'project' as const, enabled: true },
{ name: 'skill-beta', description: 'Second test skill', path: '/skills/beta', location: 'project' as const, enabled: true },
{ name: 'skill-gamma', description: 'Third test skill', path: '/skills/gamma', location: 'global' as const, enabled: true },
{ name: 'skill-disabled', description: 'Disabled skill', path: '/skills/disabled', location: 'project' as const, enabled: false },
];
describe('generateSkillsConfig', () => {
it('should generate XML config for Claude Code', () => {
const config = generateSkillsConfig(testSkills, 'claude-code');
expect(config).toContain('<skills_system');
expect(config).toContain('<name>skill-alpha</name>');
expect(config).toContain('<name>skill-beta</name>');
expect(config).toContain('<name>skill-gamma</name>');
expect(config).not.toContain('skill-disabled');
expect(config).toContain('<description>First test skill</description>');
expect(config).toContain('skillkit read');
});
it('should generate MDC config for Cursor', () => {
const config = generateSkillsConfig(testSkills, 'cursor');
expect(config).toContain('---');
expect(config).toContain('description:');
expect(config).toContain('globs:');
expect(config).toContain('alwaysApply: true');
expect(config).toContain('**skill-alpha**');
expect(config).toContain('**skill-beta**');
expect(config).not.toContain('skill-disabled');
});
it('should generate Markdown table config for Codex', () => {
const config = generateSkillsConfig(testSkills, 'codex');
expect(config).toContain('| Skill | Description | Command |');
expect(config).toContain('| skill-alpha |');
expect(config).toContain('| skill-beta |');
expect(config).toContain('First test skill');
expect(config).not.toContain('skill-disabled');
});
it('should generate JSON config for Gemini CLI', () => {
const config = generateSkillsConfig(testSkills, 'gemini-cli');
expect(config).toContain('```json');
expect(config).toContain('"name": "skill-alpha"');
expect(config).toContain('"name": "skill-beta"');
expect(config).toContain('"description": "First test skill"');
expect(config).not.toContain('skill-disabled');
});
it('should generate Markdown config for Windsurf', () => {
const config = generateSkillsConfig(testSkills, 'windsurf');
expect(config).toContain('### skill-alpha');
expect(config).toContain('### skill-beta');
expect(config).toContain('**Invoke:**');
expect(config).toContain('`skillkit read skill-alpha`');
expect(config).not.toContain('skill-disabled');
});
it('should generate XML config for Roo', () => {
const config = generateSkillsConfig(testSkills, 'roo');
expect(config).toContain('<skills_system');
expect(config).toContain('<name>skill-alpha</name>');
});
it('should generate Markdown config for Trae', () => {
const config = generateSkillsConfig(testSkills, 'trae');
expect(config).toContain('### skill-alpha');
expect(config).toContain('### skill-beta');
});
it('should generate Markdown config for GitHub Copilot', () => {
const config = generateSkillsConfig(testSkills, 'github-copilot');
expect(config).toContain('### skill-alpha');
expect(config).toContain('### skill-beta');
});
it('should return empty string when no skills are enabled', () => {
const disabledOnlySkills = [
{ name: 'disabled-1', description: 'Disabled', path: '/d1', location: 'project' as const, enabled: false },
{ name: 'disabled-2', description: 'Also disabled', path: '/d2', location: 'project' as const, enabled: false },
];
const config = generateSkillsConfig(disabledOnlySkills, 'claude-code');
expect(config).toBe('');
});
it('should exclude disabled skills from all agent configs', () => {
for (const agent of SUPPORTED_AGENTS) {
const config = generateSkillsConfig(testSkills, agent);
expect(config).not.toContain('skill-disabled');
}
});
});
});
describe('E2E: Skill Translator - Utility Functions', () => {
describe('getAgentSkillsDir', () => {
it.each(SUPPORTED_AGENTS)('should return valid skills directory for %s', (agent) => {
const dir = getAgentSkillsDir(agent);
expect(typeof dir).toBe('string');
expect(dir.length).toBeGreaterThan(0);
});
it('should return correct paths for major agents', () => {
expect(getAgentSkillsDir('claude-code')).toBe('.claude/skills');
expect(getAgentSkillsDir('cursor')).toBe('.cursor/skills');
expect(getAgentSkillsDir('windsurf')).toBe('.windsurf/skills');
expect(getAgentSkillsDir('github-copilot')).toBe('.github/skills');
expect(getAgentSkillsDir('codex')).toBe('.codex/skills');
});
});
describe('getAgentConfigFile', () => {
it.each(SUPPORTED_AGENTS)('should return valid config file for %s', (agent) => {
const file = getAgentConfigFile(agent);
expect(typeof file).toBe('string');
expect(file.length).toBeGreaterThan(0);
});
it('should return correct config files for major agents', () => {
expect(getAgentConfigFile('claude-code')).toBe('CLAUDE.md');
expect(getAgentConfigFile('cursor')).toBe('.cursor/rules/skills.mdc');
expect(getAgentConfigFile('windsurf')).toBe('.windsurf/rules/skills.md');
expect(getAgentConfigFile('github-copilot')).toBe('.github/copilot-instructions.md');
});
});
describe('AGENT_SKILL_FORMATS', () => {
it('should have configuration for all supported agents', () => {
for (const agent of SUPPORTED_AGENTS) {
expect(AGENT_SKILL_FORMATS[agent]).toBeDefined();
expect(AGENT_SKILL_FORMATS[agent].skillsDir).toBeTruthy();
expect(AGENT_SKILL_FORMATS[agent].configFile).toBeTruthy();
expect(AGENT_SKILL_FORMATS[agent].invokeCommand).toBe('skillkit read');
}
});
it('should have correct config formats for each agent', () => {
expect(AGENT_SKILL_FORMATS['claude-code'].configFormat).toBe('xml');
expect(AGENT_SKILL_FORMATS.cursor.configFormat).toBe('mdc');
expect(AGENT_SKILL_FORMATS.windsurf.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.codex.configFormat).toBe('markdown-table');
expect(AGENT_SKILL_FORMATS['gemini-cli'].configFormat).toBe('json');
expect(AGENT_SKILL_FORMATS['github-copilot'].configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.trae.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.roo.configFormat).toBe('xml');
});
});
});
describe('E2E: Skill Translator - Complete Workflow', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir('skillkit-workflow-');
});
afterEach(() => {
cleanupTestDir(testDir);
});
it('should complete full translation workflow from Claude Code to all agents', () => {
// Create a Claude Code skill
const skillDir = join(testDir, 'workflow-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: workflow-skill
description: Complete workflow test skill
version: "1.0.0"
author: E2E Test Suite
tags:
- workflow
- testing
allowed-tools: Read, Write
---
# Workflow Test Skill
This skill tests the complete translation workflow.
## Instructions
1. Parse the SKILL.md file
2. Translate to target agent format
3. Write the translated skill
4. Generate config
## Usage
Use \`skillkit read workflow-skill\` to load this skill.
`);
// Step 1: Parse to canonical format
const canonicalSkill = parseSkillToCanonical(skillDir);
expect(canonicalSkill).not.toBeNull();
expect(canonicalSkill?.name).toBe('workflow-skill');
// Step 2: Translate to all agents
const translations = translateSkillToAll(skillDir, 'claude-code');
expect(translations.size).toBeGreaterThan(0);
// Step 3: Verify translations for key agents
const cursorTranslation = translations.get('cursor');
expect(cursorTranslation?.success).toBe(true);
expect(cursorTranslation?.content).toContain('workflow-skill');
const windsurfTranslation = translations.get('windsurf');
expect(windsurfTranslation?.success).toBe(true);
expect(windsurfTranslation?.content).toContain('workflow-skill');
const copilotTranslation = translations.get('github-copilot');
expect(copilotTranslation?.success).toBe(true);
expect(copilotTranslation?.content).toContain('workflow-skill');
// Step 4: Write a translation to disk
const outputDir = join(testDir, 'output');
mkdirSync(outputDir, { recursive: true });
if (cursorTranslation) {
const writeResult = writeTranslatedSkill(cursorTranslation, outputDir);
expect(writeResult.success).toBe(true);
expect(existsSync(writeResult.path)).toBe(true);
}
// Step 5: Generate config for installed skills
const installedSkills = [
{ name: 'workflow-skill', description: 'Complete workflow test skill', path: skillDir, location: 'project' as const, enabled: true },
];
const claudeConfig = generateSkillsConfig(installedSkills, 'claude-code');
expect(claudeConfig).toContain('<name>workflow-skill</name>');
const cursorConfig = generateSkillsConfig(installedSkills, 'cursor');
expect(cursorConfig).toContain('**workflow-skill**');
});
it('should handle skill with agent-specific features during translation', () => {
// Create a CrossAgentSkill directly with hooks in agentFields
// This is more reliable than parsing from YAML
const skillWithHooks: CrossAgentSkill = {
name: 'agent-specific',
description: 'Skill with agent-specific features',
content: '# Agent Specific Skill\n\nThis skill has Claude Code specific features.',
frontmatter: { name: 'agent-specific', description: 'Skill with agent-specific features' },
sourcePath: join(testDir, 'agent-specific'),
sourceAgent: 'claude-code',
agentFields: {
model: 'opus',
context: 'fork',
hooks: [
{ type: 'PreToolUse', command: 'echo "Before tool use"' },
{ type: 'PostToolUse', command: 'echo "After tool use"' },
],
},
};
// Translate to Claude Code (should preserve features)
const claudeResult = translateSkillToAgent(skillWithHooks, 'claude-code');
expect(claudeResult.success).toBe(true);
expect(claudeResult.incompatible).toHaveLength(0);
// Translate to Cursor (should report incompatible features)
const cursorResult = translateSkillToAgent(skillWithHooks, 'cursor');
expect(cursorResult.success).toBe(true);
// Hooks are not supported in Cursor
expect(cursorResult.incompatible.some(i => i.includes('hooks'))).toBe(true);
});
it('should maintain content integrity across multiple translations', () => {
const originalContent = `## Important Section
This content must be preserved exactly.
\`\`\`typescript
const important = "code";
console.log(important);
\`\`\`
### Subsection
- Bullet point 1
- Bullet point 2
- Bullet point 3
`;
const skillDir = join(testDir, 'content-integrity');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: content-integrity
description: Tests content preservation
---
${originalContent}`);
const canonicalSkill = parseSkillToCanonical(skillDir);
expect(canonicalSkill).not.toBeNull();
// Verify content is preserved in translations
for (const agent of ['cursor', 'windsurf', 'github-copilot', 'codex'] as const) {
const result = translateSkillToAgent(canonicalSkill!, agent);
expect(result.success).toBe(true);
expect(result.content).toContain('## Important Section');
expect(result.content).toContain('const important = "code"');
expect(result.content).toContain('- Bullet point 1');
}
});
});
-333
View File
@@ -1,333 +0,0 @@
/**
* E2E Tests: Team Collaboration Features
*
* Tests for: team init, team share, team import, team list, team sync, team remove, team bundle-*
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
import {
runCli,
createTestDir,
cleanupTestDir,
createTestSkill,
testFileExists,
writeTestFile,
} from './helpers/cli-runner.js';
describe('E2E: Team Collaboration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
// Create base project structure
mkdirSync(join(testDir, 'skills'), { recursive: true });
createTestSkill(join(testDir, 'skills'), 'team-skill-one', {
description: 'First skill for team collaboration testing',
});
createTestSkill(join(testDir, 'skills'), 'team-skill-two', {
description: 'Second skill for team collaboration testing',
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit team init', () => {
it('should initialize team configuration', async () => {
const result = await runCli(['team', 'init'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Must complete successfully and show relevant output
expect(result.exitCode).toBeLessThanOrEqual(1);
// Should initialize team structure or report status
const hasRelevantOutput =
output.includes('team') ||
output.includes('init') ||
output.includes('created') ||
testFileExists(testDir, '.skillkit/team.json') ||
testFileExists(testDir, '.skillkit');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Team init failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should create team configuration file', async () => {
const result = await runCli(
['team', 'init', '--name', 'test-team', '--registry', 'local'],
{ cwd: testDir }
);
// Check for team config in various possible locations
const hasTeamConfig =
testFileExists(testDir, '.skillkit/team.json') ||
testFileExists(testDir, '.skillkit/team.yaml') ||
testFileExists(testDir, 'team.json') ||
testFileExists(testDir, '.skillkit');
// Strict assertion - either created config or command succeeded
if (!hasTeamConfig && result.exitCode !== 0) {
const output = result.stdout + result.stderr;
expect.fail(`Team init did not create config. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasTeamConfig || result.exitCode === 0).toBe(true);
});
it('should accept team name option', async () => {
const result = await runCli(['team', 'init', '--name', 'test-team'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit team list', () => {
it('should list team skills', async () => {
// Initialize team first
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(['team', 'list'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
// Should list skills or indicate none
const hasRelevantOutput =
output.includes('skill') ||
output.includes('team') ||
output.includes('No') ||
output.includes('empty');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Team list failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should support --json output', async () => {
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(['team', 'list', '--json'], { cwd: testDir });
if (result.stdout.trim().startsWith('[') || result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
});
describe('skillkit team share', () => {
it('should share a skill with team', async () => {
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(['team', 'share', 'team-skill-one'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
// Should share skill or report status
const hasRelevantOutput =
output.includes('share') ||
output.includes('team-skill-one') ||
output.includes('success') ||
output.includes('added');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Team share failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should share multiple skills', async () => {
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(['team', 'share', 'team-skill-one', 'team-skill-two'], {
cwd: testDir,
});
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should handle non-existent skill gracefully', async () => {
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(['team', 'share', 'nonexistent-skill'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should report error or warning about missing skill
const showsError =
output.includes('not found') ||
output.includes('error') ||
output.includes('No') ||
!result.success;
expect(showsError).toBe(true);
});
});
describe('skillkit team sync', () => {
it('should sync team skills', async () => {
await runCli(['team', 'init'], { cwd: testDir });
await runCli(['team', 'share', 'team-skill-one'], { cwd: testDir });
const result = await runCli(['team', 'sync'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('sync') ||
output.includes('team') ||
output.includes('success');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Team sync failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
it('should sync with specific agent', async () => {
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(['team', 'sync', '--agent', 'claude-code'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
describe('skillkit team remove', () => {
it('should remove a shared skill from team', async () => {
await runCli(['team', 'init'], { cwd: testDir });
await runCli(['team', 'share', 'team-skill-one'], { cwd: testDir });
const result = await runCli(['team', 'remove', 'team-skill-one'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('remove') ||
output.includes('team-skill-one') ||
output.includes('success');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Team remove failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
});
describe('skillkit team import', () => {
it('should import skills from team bundle', async () => {
// Create a mock team bundle
const bundleDir = join(testDir, 'team-bundle');
mkdirSync(bundleDir, { recursive: true });
createTestSkill(bundleDir, 'imported-skill', {
description: 'A skill to be imported from a team bundle file',
});
const result = await runCli(['team', 'import', bundleDir], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(result.exitCode).toBeLessThanOrEqual(1);
const hasRelevantOutput =
output.includes('import') ||
output.includes('skill') ||
output.includes('success');
if (!hasRelevantOutput && result.exitCode !== 0) {
expect.fail(`Team import failed. Exit: ${result.exitCode}\nOutput: ${output}`);
}
expect(hasRelevantOutput || result.exitCode === 0).toBe(true);
});
});
describe('skillkit team bundle-*', () => {
it('should create team bundle (bundle-create)', async () => {
await runCli(['team', 'init'], { cwd: testDir });
await runCli(['team', 'share', 'team-skill-one'], { cwd: testDir });
const bundlePath = join(testDir, 'my-bundle.skillkit');
const result = await runCli(['team', 'bundle-create', '--output', bundlePath], {
cwd: testDir,
});
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should list bundle contents (bundle-list)', async () => {
// Create a bundle first
await runCli(['team', 'init'], { cwd: testDir });
await runCli(['team', 'share', 'team-skill-one'], { cwd: testDir });
const bundlePath = join(testDir, 'test-bundle.skillkit');
await runCli(['team', 'bundle-create', '--output', bundlePath], { cwd: testDir });
// Now list it
const result = await runCli(['team', 'bundle-list', bundlePath], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should extract bundle (bundle-extract)', async () => {
// Create bundle
await runCli(['team', 'init'], { cwd: testDir });
await runCli(['team', 'share', 'team-skill-one'], { cwd: testDir });
const bundlePath = join(testDir, 'extract-bundle.skillkit');
await runCli(['team', 'bundle-create', '--output', bundlePath], { cwd: testDir });
// Extract to new location
const extractDir = join(testDir, 'extracted');
const result = await runCli(['team', 'bundle-extract', bundlePath, '--output', extractDir], {
cwd: testDir,
});
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
});
describe('E2E: Team Orchestration', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
mkdirSync(join(testDir, 'skills'), { recursive: true });
createTestSkill(join(testDir, 'skills'), 'orchestration-skill', {
description: 'A skill for testing multi-agent team orchestration features',
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
it('should configure team roles', async () => {
await runCli(['team', 'init'], { cwd: testDir });
// Configure team with roles
const result = await runCli(['team', 'init', '--role', 'leader:claude-code'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should support multi-agent configuration', async () => {
await runCli(['team', 'init'], { cwd: testDir });
const result = await runCli(
['team', 'init', '--agents', 'claude-code,cursor,github-copilot'],
{ cwd: testDir }
);
expect(result.exitCode).toBeLessThanOrEqual(1);
});
it('should handle team task delegation', async () => {
await runCli(['team', 'init'], { cwd: testDir });
// This tests the orchestration task feature if available
const result = await runCli(['team', 'sync', '--all-agents'], { cwd: testDir });
expect(result.exitCode).toBeLessThanOrEqual(1);
});
});
-345
View File
@@ -1,345 +0,0 @@
/**
* E2E Tests: Skill Translation Commands
*
* Tests for: translate, context, recommend
* Validates translation to all 17 supported agents
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
import {
runCli,
createTestDir,
cleanupTestDir,
createTestSkill,
testFileExists,
} from './helpers/cli-runner.js';
// All 17 supported agents
const SUPPORTED_AGENTS = [
'claude-code',
'cursor',
'codex',
'gemini-cli',
'opencode',
'antigravity',
'amp',
'clawdbot',
'droid',
'github-copilot',
'goose',
'kilo',
'kiro-cli',
'roo',
'trae',
'windsurf',
'universal',
] as const;
describe('E2E: Skill Translation', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
// Create a skill for translation tests
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'translation-test', {
description: 'A skill designed for testing translation across multiple AI coding agents',
content: `## Usage
Run this command to test the skill:
\`\`\`bash
npm test
\`\`\`
## Features
- Feature A: Does something useful
- Feature B: Does something else
`,
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('skillkit translate', () => {
it('should translate skill to claude-code format', async () => {
const result = await runCli(['translate', '--agent', 'claude-code'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should complete translation or show relevant output
expect(
output.includes('claude') ||
output.includes('translate') ||
output.includes('CLAUDE.md') ||
result.exitCode !== undefined
).toBe(true);
});
it('should translate skill to cursor format', async () => {
const result = await runCli(['translate', '--agent', 'cursor'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('cursor') ||
output.includes('.cursorrules') ||
output.includes('translate') ||
result.exitCode !== undefined
).toBe(true);
});
it('should translate skill to windsurf format', async () => {
const result = await runCli(['translate', '--agent', 'windsurf'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('windsurf') ||
output.includes('.windsurfrules') ||
output.includes('translate') ||
result.exitCode !== undefined
).toBe(true);
});
it('should translate skill to github-copilot format', async () => {
const result = await runCli(['translate', '--agent', 'github-copilot'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('copilot') ||
output.includes('.github') ||
output.includes('translate') ||
result.exitCode !== undefined
).toBe(true);
});
it('should support universal format for all agents', async () => {
const result = await runCli(['translate', '--agent', 'universal'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
// Test all agents can at least attempt translation
describe.each(SUPPORTED_AGENTS)('translation to %s', (agent) => {
it(`should handle translation to ${agent}`, async () => {
const result = await runCli(['translate', '--agent', agent], { cwd: testDir });
// Should not crash - either succeeds or reports error gracefully
expect(result.exitCode).toBeDefined();
expect(typeof result.stdout).toBe('string');
expect(typeof result.stderr).toBe('string');
});
});
it('should handle unknown agent gracefully', async () => {
const result = await runCli(['translate', '--agent', 'nonexistent-agent'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should report error about unknown agent
expect(
output.toLowerCase().includes('unknown') ||
output.toLowerCase().includes('not supported') ||
output.toLowerCase().includes('invalid') ||
output.toLowerCase().includes('error') ||
!result.success
).toBe(true);
});
it('should translate with --output option', async () => {
const outputPath = join(testDir, 'translated-output');
mkdirSync(outputPath, { recursive: true });
const result = await runCli(['translate', '--agent', 'claude-code', '--output', outputPath], {
cwd: testDir,
});
// Command should complete
expect(result.exitCode).toBeDefined();
});
it('should translate with --dry-run option', async () => {
const result = await runCli(['translate', '--agent', 'cursor', '--dry-run'], {
cwd: testDir,
});
const output = result.stdout + result.stderr;
// Dry run should show what would be done without making changes
expect(result.exitCode !== undefined || output.length > 0).toBe(true);
});
});
describe('skillkit context', () => {
it('should detect project context', async () => {
// Create a Node.js project
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify(
{
name: 'test-project',
version: '1.0.0',
dependencies: { express: '^4.18.0' },
},
null,
2
)
);
const result = await runCli(['context'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should detect the project type
expect(
output.includes('node') ||
output.includes('javascript') ||
output.includes('typescript') ||
output.includes('context') ||
output.includes('project') ||
result.exitCode !== undefined
).toBe(true);
});
it('should detect Python project', async () => {
// Create a Python project
writeFileSync(join(testDir, 'requirements.txt'), 'flask>=2.0.0\npytest>=7.0.0\n');
writeFileSync(join(testDir, 'main.py'), 'print("Hello")\n');
const result = await runCli(['context'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('python') || output.includes('context') || result.exitCode !== undefined
).toBe(true);
});
it('should detect Rust project', async () => {
// Create a Rust project
writeFileSync(
join(testDir, 'Cargo.toml'),
'[package]\nname = "test"\nversion = "0.1.0"\nedition = "2021"'
);
const result = await runCli(['context'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('rust') || output.includes('context') || result.exitCode !== undefined
).toBe(true);
});
it('should detect Go project', async () => {
// Create a Go project
writeFileSync(join(testDir, 'go.mod'), 'module example.com/test\n\ngo 1.21');
const result = await runCli(['context'], { cwd: testDir });
const output = result.stdout + result.stderr;
expect(
output.includes('go') || output.includes('context') || result.exitCode !== undefined
).toBe(true);
});
it('should support --json output', async () => {
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'test', version: '1.0.0' }, null, 2)
);
const result = await runCli(['context', '--json'], { cwd: testDir });
// If JSON is supported, should be parseable
if (result.stdout.trim().startsWith('{')) {
expect(() => JSON.parse(result.stdout)).not.toThrow();
}
});
});
describe('skillkit recommend', () => {
it('should recommend skills for a project', async () => {
// Create a Node.js project with common patterns
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify(
{
name: 'web-app',
version: '1.0.0',
dependencies: {
express: '^4.18.0',
typescript: '^5.0.0',
jest: '^29.0.0',
},
},
null,
2
)
);
const result = await runCli(['recommend'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Should provide recommendations or indicate none available
expect(
output.includes('recommend') ||
output.includes('skill') ||
output.includes('suggest') ||
output.includes('No') ||
result.exitCode !== undefined
).toBe(true);
});
it('should handle empty project gracefully', async () => {
const result = await runCli(['recommend'], { cwd: testDir });
// Should not crash
expect(result.exitCode).toBeDefined();
});
it('should support --limit option', async () => {
writeFileSync(
join(testDir, 'package.json'),
JSON.stringify({ name: 'test', version: '1.0.0' }, null, 2)
);
const result = await runCli(['recommend', '--limit', '5'], { cwd: testDir });
expect(result.exitCode).toBeDefined();
});
});
});
describe('E2E: Agent Config Generation', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir();
const skillsDir = join(testDir, 'skills');
mkdirSync(skillsDir, { recursive: true });
createTestSkill(skillsDir, 'config-test-skill', {
description: 'A skill for testing agent configuration generation across all agents',
additionalFrontmatter: {
'allowed-tools': 'Bash(npm:*) Read Write Edit',
},
});
});
afterEach(() => {
cleanupTestDir(testDir);
});
it('should generate valid claude-code config (CLAUDE.md)', async () => {
const result = await runCli(['sync', '--agent', 'claude-code'], { cwd: testDir });
// Check if CLAUDE.md was created or would be created
const claudeMdExists = testFileExists(testDir, 'CLAUDE.md');
expect(result.exitCode !== undefined || claudeMdExists).toBe(true);
});
it('should generate valid cursor config (.cursorrules)', async () => {
const result = await runCli(['sync', '--agent', 'cursor'], { cwd: testDir });
const cursorRulesExists = testFileExists(testDir, '.cursorrules');
expect(result.exitCode !== undefined || cursorRulesExists).toBe(true);
});
it('should generate valid windsurf config (.windsurfrules)', async () => {
const result = await runCli(['sync', '--agent', 'windsurf'], { cwd: testDir });
const windsurfRulesExists = testFileExists(testDir, '.windsurfrules');
expect(result.exitCode !== undefined || windsurfRulesExists).toBe(true);
});
it('should preserve allowed-tools in translation', async () => {
const result = await runCli(['translate', '--agent', 'claude-code'], { cwd: testDir });
const output = result.stdout + result.stderr;
// Output or generated file should mention tools
expect(
output.includes('tool') ||
output.includes('Bash') ||
output.includes('permission') ||
result.exitCode !== undefined
).toBe(true);
});
});
-19
View File
@@ -1,19 +0,0 @@
{
"compilerOptions": {
"target": "ES2022",
"module": "ESNext",
"moduleResolution": "bundler",
"esModuleInterop": true,
"strict": true,
"skipLibCheck": true,
"declaration": false,
"outDir": "./dist",
"rootDir": "./",
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"types": ["node", "vitest/globals"]
},
"include": ["**/*.ts"],
"exclude": ["node_modules", "dist"]
}
-29
View File
@@ -1,29 +0,0 @@
import { defineConfig } from 'vitest/config';
import { resolve } from 'node:path';
export default defineConfig({
test: {
globals: true,
environment: 'node',
include: ['**/*.e2e.test.ts'],
testTimeout: 60000, // E2E tests need more time
hookTimeout: 30000,
retry: 1, // Retry failed tests once for flaky network/fs operations
sequence: {
shuffle: false, // Run tests in order for debugging
},
pool: 'forks', // Use forks for better isolation
poolOptions: {
forks: {
singleFork: false,
isolate: true,
},
},
},
resolve: {
alias: {
'@skillkit/core': resolve(__dirname, '../packages/core/src/index.ts'),
'@skillkit/agents': resolve(__dirname, '../packages/agents/src/index.ts'),
},
},
});
+1822 -108
View File
File diff suppressed because it is too large Load Diff
+1 -4
View File
@@ -1,6 +1,6 @@
{
"name": "skillkit-monorepo",
"version": "1.6.4",
"version": "1.4.0",
"private": true,
"description": "Universal skills loader for AI coding agents - Monorepo",
"type": "module",
@@ -10,9 +10,6 @@
"test": "turbo run test",
"test:watch": "vitest",
"test:coverage": "vitest run --coverage",
"test:e2e": "vitest run --config e2e/vitest.config.ts",
"test:e2e:watch": "vitest --config e2e/vitest.config.ts",
"test:all": "pnpm test && pnpm test:e2e",
"typecheck": "turbo run typecheck",
"lint": "turbo run lint",
"clean": "rm -rf node_modules packages/*/node_modules apps/*/node_modules packages/*/dist apps/*/dist"
+3 -6
View File
@@ -1,6 +1,6 @@
{
"name": "@skillkit/agents",
"version": "1.6.4",
"version": "1.4.0",
"description": "Agent adapters for SkillKit - supports 17+ AI coding agents",
"type": "module",
"main": "./dist/index.js",
@@ -11,9 +11,7 @@
"types": "./dist/index.d.ts"
}
},
"files": [
"dist"
],
"files": ["dist"],
"scripts": {
"build": "tsup",
"dev": "tsup --watch",
@@ -21,8 +19,7 @@
"test": "vitest run"
},
"dependencies": {
"@skillkit/core": "workspace:*",
"minimatch": "^9.0.0"
"@skillkit/core": "workspace:*"
},
"devDependencies": {
"@types/node": "^22.10.5",
@@ -1,412 +0,0 @@
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { ClawdbotAdapter } from '../clawdbot.js';
import type { Skill } from '@skillkit/core';
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
// Mock filesystem functions
vi.mock('node:fs', () => ({
existsSync: vi.fn(),
}));
describe('ClawdbotAdapter', () => {
let adapter: ClawdbotAdapter;
const mockExistsSync = vi.mocked(existsSync);
beforeEach(() => {
adapter = new ClawdbotAdapter();
mockExistsSync.mockClear();
});
afterEach(() => {
vi.restoreAllMocks();
});
describe('configuration', () => {
it('should have correct type', () => {
expect(adapter.type).toBe('clawdbot');
});
it('should have correct name', () => {
expect(adapter.name).toBe('Clawdbot');
});
it('should have correct skillsDir', () => {
expect(adapter.skillsDir).toBe('.clawdbot/skills');
});
it('should have correct configFile', () => {
expect(adapter.configFile).toBe('AGENTS.md');
});
});
describe('generateConfig', () => {
it('should return empty string for no enabled skills', () => {
const skills: Skill[] = [
{
name: 'test-skill',
enabled: false,
path: '/path/to/skill',
content: '# Test',
},
];
const config = adapter.generateConfig(skills);
expect(config).toBe('');
});
it('should generate config with enabled skills', () => {
const skills: Skill[] = [
{
name: 'test-skill',
description: 'A test skill',
enabled: true,
path: '/path/to/skill',
content: '# Test',
},
];
const config = adapter.generateConfig(skills);
expect(config).toContain('<skills_system priority="1">');
expect(config).toContain('## Available Skills');
expect(config).toContain('<name>test-skill</name>');
expect(config).toContain('<description>A test skill</description>');
expect(config).toContain('skillkit read <skill-name>');
});
it('should generate config with multiple skills', () => {
const skills: Skill[] = [
{
name: 'skill-1',
description: 'First skill',
enabled: true,
path: '/path/to/skill1',
content: '# Skill 1',
},
{
name: 'skill-2',
description: 'Second skill',
enabled: true,
path: '/path/to/skill2',
content: '# Skill 2',
},
];
const config = adapter.generateConfig(skills);
expect(config).toContain('<name>skill-1</name>');
expect(config).toContain('<name>skill-2</name>');
expect(config).toContain('<description>First skill</description>');
expect(config).toContain('<description>Second skill</description>');
});
it('should filter out disabled skills', () => {
const skills: Skill[] = [
{
name: 'enabled-skill',
enabled: true,
path: '/path/to/enabled',
content: '# Enabled',
},
{
name: 'disabled-skill',
enabled: false,
path: '/path/to/disabled',
content: '# Disabled',
},
];
const config = adapter.generateConfig(skills);
expect(config).toContain('enabled-skill');
expect(config).not.toContain('disabled-skill');
});
it('should include usage notes', () => {
const skills: Skill[] = [
{
name: 'test-skill',
enabled: true,
path: '/path/to/skill',
content: '# Test',
},
];
const config = adapter.generateConfig(skills);
expect(config).toContain('<usage>');
expect(config).toContain('When users ask you to perform tasks');
expect(config).toContain('How to use skills:');
expect(config).toContain('- Invoke:');
expect(config).toContain('Usage notes:');
});
it('should include available_skills section', () => {
const skills: Skill[] = [
{
name: 'test-skill',
enabled: true,
path: '/path/to/skill',
content: '# Test',
},
];
const config = adapter.generateConfig(skills);
expect(config).toContain('<available_skills>');
expect(config).toContain('</available_skills>');
});
});
describe('parseConfig', () => {
it('should parse skill names from config', () => {
const config = `
<skills_system>
<available_skills>
<skill>
<name>skill-1</name>
<description>Test skill 1</description>
</skill>
<skill>
<name>skill-2</name>
<description>Test skill 2</description>
</skill>
</available_skills>
</skills_system>
`;
const skillNames = adapter.parseConfig(config);
expect(skillNames).toEqual(['skill-1', 'skill-2']);
});
it('should return empty array for no skills', () => {
const config = '<skills_system></skills_system>';
const skillNames = adapter.parseConfig(config);
expect(skillNames).toEqual([]);
});
it('should handle whitespace in skill names', () => {
const config = `
<skill>
<name> skill-with-spaces </name>
</skill>
`;
const skillNames = adapter.parseConfig(config);
expect(skillNames).toEqual(['skill-with-spaces']);
});
it('should handle multiple name tags', () => {
const config = `
<name>skill-1</name>
<name>skill-2</name>
<name>skill-3</name>
`;
const skillNames = adapter.parseConfig(config);
expect(skillNames).toEqual(['skill-1', 'skill-2', 'skill-3']);
});
});
describe('getInvokeCommand', () => {
it('should return correct invoke command', () => {
const command = adapter.getInvokeCommand('test-skill');
expect(command).toBe('skillkit read test-skill');
});
it('should work with skill names containing hyphens', () => {
const command = adapter.getInvokeCommand('my-test-skill');
expect(command).toBe('skillkit read my-test-skill');
});
it('should work with skill names containing underscores', () => {
const command = adapter.getInvokeCommand('my_test_skill');
expect(command).toBe('skillkit read my_test_skill');
});
});
describe('isDetected', () => {
it('should detect Clawdbot from workspace skills directory', async () => {
mockExistsSync.mockImplementation((path) => {
return path === join(process.cwd(), 'skills');
});
const detected = await adapter.isDetected();
expect(detected).toBe(true);
});
it('should detect Clawdbot from global directory', async () => {
mockExistsSync.mockImplementation((path) => {
return path === join(homedir(), '.clawdbot');
});
const detected = await adapter.isDetected();
expect(detected).toBe(true);
});
it('should detect Clawdbot from config file', async () => {
mockExistsSync.mockImplementation((path) => {
return path === join(process.cwd(), 'clawdbot.json');
});
const detected = await adapter.isDetected();
expect(detected).toBe(true);
});
it('should not detect Clawdbot when no indicators present', async () => {
mockExistsSync.mockReturnValue(false);
const detected = await adapter.isDetected();
expect(detected).toBe(false);
});
it('should detect when multiple indicators are present', async () => {
mockExistsSync.mockReturnValue(true);
const detected = await adapter.isDetected();
expect(detected).toBe(true);
});
it('should check all expected paths', async () => {
mockExistsSync.mockReturnValue(false);
await adapter.isDetected();
expect(mockExistsSync).toHaveBeenCalledWith(join(process.cwd(), 'skills'));
expect(mockExistsSync).toHaveBeenCalledWith(join(homedir(), '.clawdbot'));
expect(mockExistsSync).toHaveBeenCalledWith(join(process.cwd(), 'clawdbot.json'));
});
});
describe('integration', () => {
it('should work end-to-end with typical workflow', () => {
const skills: Skill[] = [
{
name: 'react-patterns',
description: 'React best practices',
enabled: true,
path: '/skills/react-patterns',
content: '# React Patterns\n\nBest practices...',
},
{
name: 'typescript-strict',
description: 'TypeScript strict mode',
enabled: true,
path: '/skills/typescript-strict',
content: '# TypeScript Strict\n\nUse strict mode...',
},
];
// Generate config
const config = adapter.generateConfig(skills);
// Parse config
const parsedSkills = adapter.parseConfig(config);
// Verify round-trip
expect(parsedSkills).toEqual(['react-patterns', 'typescript-strict']);
// Get invoke commands
const command1 = adapter.getInvokeCommand('react-patterns');
const command2 = adapter.getInvokeCommand('typescript-strict');
expect(command1).toBe('skillkit read react-patterns');
expect(command2).toBe('skillkit read typescript-strict');
});
it('should preserve skill order during generation and parsing', () => {
const skills: Skill[] = [
{ name: 'a-skill', enabled: true, path: '/a', content: '' },
{ name: 'z-skill', enabled: true, path: '/z', content: '' },
{ name: 'm-skill', enabled: true, path: '/m', content: '' },
];
const config = adapter.generateConfig(skills);
const parsed = adapter.parseConfig(config);
expect(parsed).toEqual(['a-skill', 'z-skill', 'm-skill']);
});
});
describe('edge cases', () => {
it('should handle empty skills array', () => {
const config = adapter.generateConfig([]);
expect(config).toBe('');
});
it('should handle skills without descriptions', () => {
const skills: Skill[] = [
{
name: 'no-desc-skill',
enabled: true,
path: '/path',
content: '# No description',
},
];
const config = adapter.generateConfig(skills);
expect(config).toContain('<name>no-desc-skill</name>');
expect(config).toContain('<description></description>');
});
it('should handle special characters in skill names', () => {
const command = adapter.getInvokeCommand('skill-with-special_chars.123');
expect(command).toBe('skillkit read skill-with-special_chars.123');
});
it('should handle empty config string during parsing', () => {
const parsed = adapter.parseConfig('');
expect(parsed).toEqual([]);
});
it('should handle malformed XML during parsing', () => {
const config = '<name>skill-1<name>broken</name>';
const parsed = adapter.parseConfig(config);
// Should still extract valid names
expect(parsed).toContain('broken');
});
});
describe('metadata handling', () => {
it('should include skill metadata in generated config', () => {
const skills: Skill[] = [
{
name: 'meta-skill',
description: 'Has metadata',
enabled: true,
path: '/path',
content: '# Meta',
metadata: {
version: '1.0.0',
author: 'Test Author',
},
},
];
const config = adapter.generateConfig(skills);
expect(config).toContain('<name>meta-skill</name>');
expect(config).toContain('<description>Has metadata</description>');
});
});
});
+5 -8
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.amp;
export class AmpAdapter implements AgentAdapter {
readonly type: AgentType = 'amp';
readonly name = 'Amp';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.agents/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -69,9 +66,9 @@ ${skillsXml}
}
async isDetected(): Promise<boolean> {
const projectAmp = join(process.cwd(), '.amp');
const globalAmp = join(homedir(), '.amp');
const projectAgents = join(process.cwd(), '.agents');
const globalAgents = join(homedir(), '.config', 'agents');
return existsSync(projectAmp) || existsSync(globalAmp);
return existsSync(projectAgents) || existsSync(globalAgents);
}
}
+2 -5
View File
@@ -3,15 +3,12 @@ import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.antigravity;
export class AntigravityAdapter implements AgentAdapter {
readonly type: AgentType = 'antigravity';
readonly name = 'Antigravity';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.antigravity/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+1 -2
View File
@@ -20,8 +20,7 @@ export function createSkillXml(skill: Skill): string {
</skill>`;
}
export function escapeXml(text: string | undefined): string {
if (!text) return '';
export function escapeXml(text: string): string {
return text
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
+2 -5
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['claude-code'];
export class ClaudeCodeAdapter implements AgentAdapter {
readonly type: AgentType = 'claude-code';
readonly name = 'Claude Code';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.claude/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+3 -7
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.clawdbot;
export class ClawdbotAdapter implements AgentAdapter {
readonly type: AgentType = 'clawdbot';
readonly name = 'Clawdbot';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = 'skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -71,8 +68,7 @@ ${skillsXml}
async isDetected(): Promise<boolean> {
const projectSkills = join(process.cwd(), 'skills');
const globalClawdbot = join(homedir(), '.clawdbot');
const clawdbotConfig = join(process.cwd(), 'clawdbot.json');
return existsSync(projectSkills) || existsSync(globalClawdbot) || existsSync(clawdbotConfig);
return existsSync(globalClawdbot) || (existsSync(projectSkills) && existsSync(join(process.cwd(), '.clawdbot')));
}
}
+2 -5
View File
@@ -3,15 +3,12 @@ import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.codex;
export class CodexAdapter implements AgentAdapter {
readonly type: AgentType = 'codex';
readonly name = 'OpenAI Codex CLI';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.codex/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+5 -19
View File
@@ -1,18 +1,14 @@
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.cursor;
export class CursorAdapter implements AgentAdapter {
readonly type: AgentType = 'cursor';
readonly name = 'Cursor';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.cursor/skills';
readonly configFile = '.cursorrules';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -27,12 +23,7 @@ export class CursorAdapter implements AgentAdapter {
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
return `---
description: SkillKit skills integration - provides specialized capabilities and domain knowledge
globs: "**/*"
alwaysApply: true
---
# Skills System
return `# Skills System
You have access to specialized skills that can help complete tasks. Use the skillkit CLI to load skill instructions when needed.
@@ -72,14 +63,9 @@ ${skillsXml}
}
async isDetected(): Promise<boolean> {
const cursorRules = join(process.cwd(), '.cursorrules');
const cursorDir = join(process.cwd(), '.cursor');
const cursorRulesDir = join(process.cwd(), '.cursor', 'rules');
// Legacy .cursorrules file (deprecated but still supported)
const cursorRulesFile = join(process.cwd(), '.cursorrules');
// Global Cursor config
const globalCursor = join(homedir(), '.cursor');
return existsSync(cursorDir) || existsSync(cursorRulesDir) ||
existsSync(cursorRulesFile) || existsSync(globalCursor);
return existsSync(cursorRules) || existsSync(cursorDir);
}
}
+2 -5
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.droid;
export class DroidAdapter implements AgentAdapter {
readonly type: AgentType = 'droid';
readonly name = 'Droid (Factory)';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.factory/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -1,542 +0,0 @@
/**
* Agent Features Tests
*/
import { describe, it, expect, beforeEach } from 'vitest';
import {
PermissionManager,
createPermissionManager,
isAllowed,
isDenied,
needsConfirmation,
} from '../permissions.js';
import {
GlobMatcher,
createGlobMatcher,
matchPattern,
parseGlobsFromMDC,
fromCommonPatterns,
COMMON_PATTERNS,
} from '../globs.js';
import {
BootstrapManager,
createBootstrapManager,
createBootstrapSet,
} from '../bootstrap.js';
import {
ModeManager,
createModeManager,
createDefaultModeManager,
ALL_MODES,
} from '../modes.js';
import type { PermissionConfig, GlobConfig, ModeConfig } from '../types.js';
describe('PermissionManager', () => {
let manager: PermissionManager;
beforeEach(() => {
manager = createPermissionManager();
});
describe('checkFileAccess', () => {
it('should return default permission for unmatched files', () => {
manager.setConfig({ default: 'ask' });
expect(manager.checkFileAccess('some/file.ts')).toBe('ask');
});
it('should match file patterns', () => {
manager.setConfig({
files: [
{ pattern: '*.ts', level: 'allow' },
{ pattern: 'secret/*', level: 'deny' },
],
default: 'ask',
});
expect(manager.checkFileAccess('app.ts')).toBe('allow');
expect(manager.checkFileAccess('secret/keys.json')).toBe('deny');
expect(manager.checkFileAccess('random.json')).toBe('ask');
});
it('should use first matching pattern', () => {
manager.setConfig({
files: [
{ pattern: '*.ts', level: 'deny' },
{ pattern: 'src/*.ts', level: 'allow' },
],
});
expect(manager.checkFileAccess('app.ts')).toBe('deny');
});
});
describe('checkCommandAccess', () => {
it('should check command patterns', () => {
manager.setConfig({
commands: [
{ pattern: 'npm *', level: 'allow' },
{ pattern: 'rm *', level: 'deny' },
],
default: 'ask',
});
expect(manager.checkCommandAccess('npm install')).toBe('allow');
expect(manager.checkCommandAccess('rm -rf /')).toBe('deny');
expect(manager.checkCommandAccess('git status')).toBe('ask');
});
});
describe('addFilePattern', () => {
it('should add file pattern', () => {
manager.addFilePattern({ pattern: '*.js', level: 'allow' });
expect(manager.checkFileAccess('app.js')).toBe('allow');
});
});
describe('generateOpenCodeConfig', () => {
it('should generate OpenCode-compatible config', () => {
manager.setConfig({
files: [{ pattern: 'src/*', level: 'allow' }],
commands: [{ pattern: 'npm *', level: 'allow' }],
default: 'ask',
});
const config = manager.generateOpenCodeConfig();
expect(config).toContain('File Access');
expect(config).toContain('allow: `src/*`');
expect(config).toContain('Command Execution');
expect(config).toContain('Default: ask');
});
});
describe('generateSkillMetadata', () => {
it('should generate skill metadata', () => {
manager.setConfig({
files: [{ pattern: '*.ts', level: 'allow' }],
default: 'deny',
});
const metadata = manager.generateSkillMetadata();
expect(metadata.filePermissions).toHaveLength(1);
expect(metadata.defaultPermission).toBe('deny');
});
});
describe('fromMetadata', () => {
it('should parse permissions from metadata', () => {
const metadata = {
filePermissions: [{ pattern: '*.ts', level: 'allow' }],
defaultPermission: 'ask',
};
const config = PermissionManager.fromMetadata(metadata);
expect(config.files).toHaveLength(1);
expect(config.default).toBe('ask');
});
});
});
describe('Permission helpers', () => {
it('isAllowed should work correctly', () => {
expect(isAllowed('allow')).toBe(true);
expect(isAllowed('deny')).toBe(false);
expect(isAllowed('ask')).toBe(false);
});
it('isDenied should work correctly', () => {
expect(isDenied('deny')).toBe(true);
expect(isDenied('allow')).toBe(false);
});
it('needsConfirmation should work correctly', () => {
expect(needsConfirmation('ask')).toBe(true);
expect(needsConfirmation('allow')).toBe(false);
});
});
describe('GlobMatcher', () => {
let matcher: GlobMatcher;
describe('matches', () => {
it('should match simple patterns', () => {
matcher = createGlobMatcher({ include: ['*.ts'] });
expect(matcher.matches('app.ts')).toBe(true);
expect(matcher.matches('app.js')).toBe(false);
});
it('should match wildcard patterns', () => {
matcher = createGlobMatcher({ include: ['src/**/*.ts'] });
expect(matcher.matches('src/app.ts')).toBe(true);
expect(matcher.matches('src/components/Button.ts')).toBe(true);
expect(matcher.matches('lib/app.ts')).toBe(false);
});
it('should respect exclude patterns', () => {
matcher = createGlobMatcher({
include: ['**/*.ts'],
exclude: ['**/*.test.ts'],
});
expect(matcher.matches('app.ts')).toBe(true);
expect(matcher.matches('app.test.ts')).toBe(false);
});
it('should skip hidden files by default', () => {
matcher = createGlobMatcher({ include: ['**/*'] });
expect(matcher.matches('.hidden/file.ts')).toBe(false);
});
it('should match hidden files when enabled', () => {
matcher = createGlobMatcher({
include: ['**/*'],
matchHidden: true,
});
expect(matcher.matches('.hidden/file.ts')).toBe(true);
});
});
describe('filter', () => {
it('should filter file list', () => {
matcher = createGlobMatcher({ include: ['*.ts'] });
const files = ['app.ts', 'app.js', 'index.ts'];
const result = matcher.filter(files);
expect(result).toEqual(['app.ts', 'index.ts']);
});
});
describe('addInclude', () => {
it('should add include pattern', () => {
matcher = createGlobMatcher({ include: ['*.ts'] });
matcher.addInclude('*.js');
expect(matcher.matches('app.js')).toBe(true);
});
});
describe('generateCursorGlobs', () => {
it('should generate Cursor-compatible globs', () => {
matcher = createGlobMatcher({
include: ['src/**/*.ts'],
exclude: ['**/*.test.ts'],
});
const globs = matcher.generateCursorGlobs();
expect(globs).toContain('src/**/*.ts');
expect(globs).toContain('!**/*.test.ts');
});
});
});
describe('matchPattern', () => {
it('should create matcher from single pattern', () => {
const matcher = matchPattern('*.ts');
expect(matcher.matches('app.ts')).toBe(true);
});
});
describe('parseGlobsFromMDC', () => {
it('should parse globs from MDC content', () => {
const content = `---
globs: ["**/*.ts", "!**/*.test.ts"]
---
Content here`;
const config = parseGlobsFromMDC(content);
expect(config?.include).toContain('**/*.ts');
expect(config?.exclude).toContain('**/*.test.ts');
});
it('should return null for invalid content', () => {
const result = parseGlobsFromMDC('no globs here');
expect(result).toBeNull();
});
});
describe('fromCommonPatterns', () => {
it('should create config from common patterns', () => {
const config = fromCommonPatterns(['typescript', 'source'], ['nodeModules']);
expect(config.include).toContain('**/*.ts');
expect(config.include).toContain('src/**/*');
expect(config.exclude).toContain('**/node_modules/**');
});
});
describe('COMMON_PATTERNS', () => {
it('should have expected patterns', () => {
expect(COMMON_PATTERNS.typescript).toContain('**/*.ts');
expect(COMMON_PATTERNS.tests).toContain('**/*.test.*');
expect(COMMON_PATTERNS.nodeModules).toContain('**/node_modules/**');
});
});
describe('BootstrapManager', () => {
let manager: BootstrapManager;
beforeEach(() => {
manager = createBootstrapManager();
});
describe('addFile/getFile', () => {
it('should add and get files', () => {
manager.addFile({
type: 'agents',
name: 'AGENTS.md',
content: '# Agents',
priority: 100,
});
const file = manager.getFile('agents');
expect(file).toBeDefined();
expect(file?.name).toBe('AGENTS.md');
});
});
describe('getFilesByPriority', () => {
it('should return files sorted by priority', () => {
manager.addFile({ type: 'tools', name: 'TOOLS.md', content: '', priority: 10 });
manager.addFile({ type: 'agents', name: 'AGENTS.md', content: '', priority: 100 });
manager.addFile({ type: 'soul', name: 'SOUL.md', content: '', priority: 50 });
const files = manager.getFilesByPriority();
expect(files[0].type).toBe('agents');
expect(files[1].type).toBe('soul');
expect(files[2].type).toBe('tools');
});
});
describe('createAgentsFile', () => {
it('should create AGENTS.md', () => {
manager.createAgentsFile([
{
name: 'Coder',
description: 'A coding agent',
capabilities: ['Write code', 'Debug'],
},
]);
const file = manager.getFile('agents');
expect(file).toBeDefined();
expect(file?.content).toContain('# Agents');
expect(file?.content).toContain('## Coder');
expect(file?.content).toContain('Write code');
});
});
describe('createSoulFile', () => {
it('should create SOUL.md', () => {
manager.createSoulFile({
personality: 'Helpful and precise',
values: ['Accuracy', 'Efficiency'],
});
const file = manager.getFile('soul');
expect(file).toBeDefined();
expect(file?.content).toContain('Helpful and precise');
expect(file?.content).toContain('Accuracy');
});
});
describe('createToolsFile', () => {
it('should create TOOLS.md', () => {
manager.createToolsFile([
{
name: 'read_file',
description: 'Read a file',
usage: 'read_file(path)',
},
]);
const file = manager.getFile('tools');
expect(file).toBeDefined();
expect(file?.content).toContain('## read_file');
expect(file?.content).toContain('read_file(path)');
});
});
describe('generateCombinedContent', () => {
it('should generate combined content', () => {
manager.addFile({ type: 'agents', name: 'AGENTS.md', content: '# Agents', priority: 100 });
manager.addFile({ type: 'soul', name: 'SOUL.md', content: '# Soul', priority: 50 });
const combined = manager.generateCombinedContent();
expect(combined).toContain('<!-- AGENTS.md -->');
expect(combined).toContain('# Agents');
expect(combined).toContain('<!-- SOUL.md -->');
});
});
});
describe('createBootstrapSet', () => {
it('should create complete bootstrap set', () => {
const manager = createBootstrapSet({
agents: [{ name: 'Test Agent' }],
soul: { personality: 'Friendly' },
tools: [{ name: 'tool1' }],
});
expect(manager.hasFile('agents')).toBe(true);
expect(manager.hasFile('soul')).toBe(true);
expect(manager.hasFile('tools')).toBe(true);
});
});
describe('ModeManager', () => {
let manager: ModeManager;
beforeEach(() => {
manager = createModeManager([
{ mode: 'code', description: 'Coding mode', skills: ['tdd', 'debugging'] },
{ mode: 'architect', description: 'Architecture mode', skills: ['planning'] },
]);
});
describe('addMode/getMode', () => {
it('should add and get modes', () => {
const mode = manager.getMode('code');
expect(mode).toBeDefined();
expect(mode?.description).toBe('Coding mode');
expect(mode?.skills).toContain('tdd');
});
});
describe('getAvailableModes', () => {
it('should return available modes', () => {
const modes = manager.getAvailableModes();
expect(modes).toContain('code');
expect(modes).toContain('architect');
});
});
describe('setMode/getCurrentMode', () => {
it('should set and get current mode', () => {
manager.setMode('architect');
expect(manager.getCurrentMode()).toBe('architect');
});
it('should throw for unconfigured mode', () => {
expect(() => manager.setMode('debug')).toThrow('Mode not configured');
});
});
describe('getCurrentSkills', () => {
it('should return skills for current mode', () => {
manager.setMode('code');
const skills = manager.getCurrentSkills();
expect(skills).toContain('tdd');
expect(skills).toContain('debugging');
});
});
describe('isSkillAvailable', () => {
it('should check if skill is available', () => {
manager.setMode('code');
expect(manager.isSkillAvailable('tdd')).toBe(true);
expect(manager.isSkillAvailable('planning')).toBe(false);
});
});
describe('isFileAllowed', () => {
it('should return true when no patterns defined', () => {
expect(manager.isFileAllowed('any/file.ts')).toBe(true);
});
it('should check file patterns when defined', () => {
manager.addMode({
mode: 'restricted',
description: 'Restricted mode',
skills: [],
allowedFiles: ['src/**/*'],
});
manager.setMode('restricted');
expect(manager.isFileAllowed('src/app.ts')).toBe(true);
expect(manager.isFileAllowed('lib/util.ts')).toBe(false);
});
});
describe('addModeListener', () => {
it('should notify listeners on mode change', () => {
let notified = false;
let newModeValue = '';
manager.addModeListener((newMode) => {
notified = true;
newModeValue = newMode;
});
manager.setMode('architect');
expect(notified).toBe(true);
expect(newModeValue).toBe('architect');
});
});
describe('generateRooConfig', () => {
it('should generate Roo-compatible config', () => {
const config = manager.generateRooConfig();
expect(config.defaultMode).toBe('code');
expect(config.modes).toBeDefined();
});
});
describe('generateModeDocumentation', () => {
it('should generate mode documentation', () => {
const docs = manager.generateModeDocumentation();
expect(docs).toContain('# Available Modes');
expect(docs).toContain('## code');
expect(docs).toContain('## architect');
});
});
});
describe('createDefaultModeManager', () => {
it('should create manager with default modes', () => {
const manager = createDefaultModeManager({
code: ['tdd'],
debug: ['debugging'],
});
const modes = manager.getAvailableModes();
expect(modes.length).toBe(7); // All default modes
expect(manager.getMode('code')?.skills).toContain('tdd');
});
});
describe('ALL_MODES', () => {
it('should contain all mode types', () => {
expect(ALL_MODES).toContain('code');
expect(ALL_MODES).toContain('architect');
expect(ALL_MODES).toContain('debug');
expect(ALL_MODES).toContain('test');
});
});
-434
View File
@@ -1,434 +0,0 @@
/**
* Bootstrap Files System
*
* Implements bootstrap file generation for agents that support them.
*/
import type {
BootstrapFile,
BootstrapFileType,
} from './types.js';
/**
* Default bootstrap file names for each type
*/
const DEFAULT_FILE_NAMES: Record<BootstrapFileType, string> = {
agents: 'AGENTS.md',
soul: 'SOUL.md',
tools: 'TOOLS.md',
identity: 'IDENTITY.md',
context: 'CONTEXT.md',
brief: 'BRIEF.md',
history: 'HISTORY.md',
};
/**
* BootstrapManager - Manage bootstrap files for agents
*/
export class BootstrapManager {
private files: Map<BootstrapFileType, BootstrapFile> = new Map();
/**
* Add a bootstrap file
*/
addFile(file: BootstrapFile): void {
this.files.set(file.type, file);
}
/**
* Get a bootstrap file by type
*/
getFile(type: BootstrapFileType): BootstrapFile | undefined {
return this.files.get(type);
}
/**
* Get all bootstrap files
*/
getAllFiles(): BootstrapFile[] {
return Array.from(this.files.values());
}
/**
* Get files sorted by priority
*/
getFilesByPriority(): BootstrapFile[] {
return this.getAllFiles().sort((a, b) => (b.priority || 0) - (a.priority || 0));
}
/**
* Remove a bootstrap file
*/
removeFile(type: BootstrapFileType): boolean {
return this.files.delete(type);
}
/**
* Check if a file type exists
*/
hasFile(type: BootstrapFileType): boolean {
return this.files.has(type);
}
/**
* Create AGENTS.md file
*/
createAgentsFile(agents: AgentDefinition[]): void {
const lines: string[] = [];
lines.push('# Agents');
lines.push('');
lines.push('This file defines the available agents and their capabilities.');
lines.push('');
for (const agent of agents) {
lines.push(`## ${agent.name}`);
lines.push('');
if (agent.description) {
lines.push(agent.description);
lines.push('');
}
if (agent.capabilities && agent.capabilities.length > 0) {
lines.push('### Capabilities');
lines.push('');
for (const cap of agent.capabilities) {
lines.push(`- ${cap}`);
}
lines.push('');
}
if (agent.constraints && agent.constraints.length > 0) {
lines.push('### Constraints');
lines.push('');
for (const constraint of agent.constraints) {
lines.push(`- ${constraint}`);
}
lines.push('');
}
}
this.addFile({
type: 'agents',
name: 'AGENTS.md',
content: lines.join('\n'),
priority: 100,
required: true,
});
}
/**
* Create SOUL.md file
*/
createSoulFile(soul: SoulDefinition): void {
const lines: string[] = [];
lines.push('# Soul');
lines.push('');
lines.push('This file defines the personality and behavior of the agent.');
lines.push('');
if (soul.personality) {
lines.push('## Personality');
lines.push('');
lines.push(soul.personality);
lines.push('');
}
if (soul.values && soul.values.length > 0) {
lines.push('## Values');
lines.push('');
for (const value of soul.values) {
lines.push(`- ${value}`);
}
lines.push('');
}
if (soul.communication) {
lines.push('## Communication Style');
lines.push('');
lines.push(soul.communication);
lines.push('');
}
if (soul.rules && soul.rules.length > 0) {
lines.push('## Rules');
lines.push('');
for (const rule of soul.rules) {
lines.push(`- ${rule}`);
}
lines.push('');
}
this.addFile({
type: 'soul',
name: 'SOUL.md',
content: lines.join('\n'),
priority: 90,
});
}
/**
* Create TOOLS.md file
*/
createToolsFile(tools: ToolDefinition[]): void {
const lines: string[] = [];
lines.push('# Tools');
lines.push('');
lines.push('This file defines the available tools and their usage.');
lines.push('');
for (const tool of tools) {
lines.push(`## ${tool.name}`);
lines.push('');
if (tool.description) {
lines.push(tool.description);
lines.push('');
}
if (tool.usage) {
lines.push('### Usage');
lines.push('');
lines.push('```');
lines.push(tool.usage);
lines.push('```');
lines.push('');
}
if (tool.examples && tool.examples.length > 0) {
lines.push('### Examples');
lines.push('');
for (const example of tool.examples) {
lines.push(`- ${example}`);
}
lines.push('');
}
}
this.addFile({
type: 'tools',
name: 'TOOLS.md',
content: lines.join('\n'),
priority: 80,
});
}
/**
* Create IDENTITY.md file
*/
createIdentityFile(identity: IdentityDefinition): void {
const lines: string[] = [];
lines.push('# Identity');
lines.push('');
if (identity.name) {
lines.push(`**Name:** ${identity.name}`);
lines.push('');
}
if (identity.role) {
lines.push(`**Role:** ${identity.role}`);
lines.push('');
}
if (identity.description) {
lines.push('## Description');
lines.push('');
lines.push(identity.description);
lines.push('');
}
if (identity.expertise && identity.expertise.length > 0) {
lines.push('## Expertise');
lines.push('');
for (const exp of identity.expertise) {
lines.push(`- ${exp}`);
}
lines.push('');
}
this.addFile({
type: 'identity',
name: 'IDENTITY.md',
content: lines.join('\n'),
priority: 95,
});
}
/**
* Create CONTEXT.md file
*/
createContextFile(context: ContextDefinition): void {
const lines: string[] = [];
lines.push('# Context');
lines.push('');
if (context.project) {
lines.push('## Project');
lines.push('');
lines.push(context.project);
lines.push('');
}
if (context.techStack && context.techStack.length > 0) {
lines.push('## Tech Stack');
lines.push('');
for (const tech of context.techStack) {
lines.push(`- ${tech}`);
}
lines.push('');
}
if (context.conventions && context.conventions.length > 0) {
lines.push('## Conventions');
lines.push('');
for (const conv of context.conventions) {
lines.push(`- ${conv}`);
}
lines.push('');
}
if (context.currentTask) {
lines.push('## Current Task');
lines.push('');
lines.push(context.currentTask);
lines.push('');
}
this.addFile({
type: 'context',
name: 'CONTEXT.md',
content: lines.join('\n'),
priority: 70,
});
}
/**
* Generate all files as a map
*/
generateFiles(): Map<string, string> {
const files = new Map<string, string>();
for (const file of this.getFilesByPriority()) {
files.set(file.name, file.content);
}
return files;
}
/**
* Generate combined content for agents without file support
*/
generateCombinedContent(): string {
const lines: string[] = [];
for (const file of this.getFilesByPriority()) {
lines.push(`<!-- ${file.name} -->`);
lines.push('');
lines.push(file.content);
lines.push('');
lines.push('---');
lines.push('');
}
return lines.join('\n');
}
/**
* Get default file name for a type
*/
static getDefaultFileName(type: BootstrapFileType): string {
return DEFAULT_FILE_NAMES[type];
}
}
/**
* Agent definition for AGENTS.md
*/
export interface AgentDefinition {
name: string;
description?: string;
capabilities?: string[];
constraints?: string[];
}
/**
* Soul definition for SOUL.md
*/
export interface SoulDefinition {
personality?: string;
values?: string[];
communication?: string;
rules?: string[];
}
/**
* Tool definition for TOOLS.md
*/
export interface ToolDefinition {
name: string;
description?: string;
usage?: string;
examples?: string[];
}
/**
* Identity definition for IDENTITY.md
*/
export interface IdentityDefinition {
name?: string;
role?: string;
description?: string;
expertise?: string[];
}
/**
* Context definition for CONTEXT.md
*/
export interface ContextDefinition {
project?: string;
techStack?: string[];
conventions?: string[];
currentTask?: string;
}
/**
* Create a BootstrapManager instance
*/
export function createBootstrapManager(): BootstrapManager {
return new BootstrapManager();
}
/**
* Create a complete bootstrap set from definitions
*/
export function createBootstrapSet(options: {
agents?: AgentDefinition[];
soul?: SoulDefinition;
tools?: ToolDefinition[];
identity?: IdentityDefinition;
context?: ContextDefinition;
}): BootstrapManager {
const manager = new BootstrapManager();
if (options.agents) {
manager.createAgentsFile(options.agents);
}
if (options.soul) {
manager.createSoulFile(options.soul);
}
if (options.tools) {
manager.createToolsFile(options.tools);
}
if (options.identity) {
manager.createIdentityFile(options.identity);
}
if (options.context) {
manager.createContextFile(options.context);
}
return manager;
}
-240
View File
@@ -1,240 +0,0 @@
/**
* Glob Pattern System
*
* Implements file pattern matching for file-scoped skills.
*/
import { minimatch } from 'minimatch';
import type { GlobConfig } from './types.js';
/**
* GlobMatcher - Match files against glob patterns
*/
export class GlobMatcher {
private config: GlobConfig;
private includePatterns: RegExp[];
private excludePatterns: RegExp[];
constructor(config: GlobConfig) {
this.config = config;
this.includePatterns = config.include.map((p) => this.patternToRegex(p));
this.excludePatterns = (config.exclude || []).map((p) => this.patternToRegex(p));
}
/**
* Check if a file matches the glob patterns
*/
matches(filePath: string): boolean {
// Normalize path separators
const normalizedPath = filePath.replace(/\\/g, '/');
// Check if hidden file and skip if not matching hidden
if (!this.config.matchHidden && this.isHiddenFile(normalizedPath)) {
return false;
}
// Check exclude patterns first
for (const pattern of this.excludePatterns) {
if (pattern.test(normalizedPath)) {
return false;
}
}
// Check include patterns
for (const pattern of this.includePatterns) {
if (pattern.test(normalizedPath)) {
return true;
}
}
return false;
}
/**
* Filter a list of files
*/
filter(filePaths: string[]): string[] {
return filePaths.filter((p) => this.matches(p));
}
/**
* Get all include patterns
*/
getIncludePatterns(): string[] {
return [...this.config.include];
}
/**
* Get all exclude patterns
*/
getExcludePatterns(): string[] {
return [...(this.config.exclude || [])];
}
/**
* Add an include pattern
*/
addInclude(pattern: string): void {
this.config.include.push(pattern);
this.includePatterns.push(this.patternToRegex(pattern));
}
/**
* Add an exclude pattern
*/
addExclude(pattern: string): void {
if (!this.config.exclude) {
this.config.exclude = [];
}
this.config.exclude.push(pattern);
this.excludePatterns.push(this.patternToRegex(pattern));
}
/**
* Convert glob pattern to regex using minimatch
*
* Uses the battle-tested minimatch library to avoid ReDoS vulnerabilities
* and ensure consistent glob matching behavior.
*/
private patternToRegex(pattern: string): RegExp {
// Handle negation
const isNegated = pattern.startsWith('!');
const cleanPattern = isNegated ? pattern.slice(1) : pattern;
// Adjust pattern for directory matching
let adjustedPattern = cleanPattern;
if (this.config.matchDirectories && !cleanPattern.endsWith('/**')) {
// Append /** to match directories and their contents
adjustedPattern = cleanPattern.endsWith('/')
? `${cleanPattern}**`
: `${cleanPattern}/**`;
}
// Use minimatch to create a safe regex
// minimatch returns null if pattern is invalid, fallback to match-nothing regex
const regex = minimatch.makeRe(adjustedPattern, { dot: this.config.matchHidden });
return regex || /(?!)/; // /(?!)/ is a regex that never matches anything
}
/**
* Check if file is hidden (starts with .)
*/
private isHiddenFile(path: string): boolean {
const parts = path.split('/');
return parts.some((part) => part.startsWith('.') && part !== '.' && part !== '..');
}
/**
* Generate Cursor-compatible globs field
*/
generateCursorGlobs(): string[] {
const globs: string[] = [...this.config.include];
// Add negated exclude patterns
if (this.config.exclude) {
for (const pattern of this.config.exclude) {
globs.push(`!${pattern}`);
}
}
return globs;
}
/**
* Generate MDC frontmatter
*/
generateMDCFrontmatter(): string {
const globs = this.generateCursorGlobs();
return `globs: ${JSON.stringify(globs)}`;
}
}
/**
* Create a GlobMatcher instance
*/
export function createGlobMatcher(config: GlobConfig): GlobMatcher {
return new GlobMatcher(config);
}
/**
* Create a GlobMatcher from a single pattern
*/
export function matchPattern(pattern: string): GlobMatcher {
return new GlobMatcher({ include: [pattern] });
}
/**
* Parse glob patterns from Cursor MDC format
*/
export function parseGlobsFromMDC(content: string): GlobConfig | null {
const match = content.match(/globs:\s*(\[.*?\])/s);
if (!match) {
return null;
}
try {
const patterns = JSON.parse(match[1]) as string[];
const include: string[] = [];
const exclude: string[] = [];
for (const pattern of patterns) {
if (pattern.startsWith('!')) {
exclude.push(pattern.slice(1));
} else {
include.push(pattern);
}
}
return { include, exclude };
} catch {
return null;
}
}
/**
* Common glob patterns for different file types
*/
export const COMMON_PATTERNS = {
/** All TypeScript files */
typescript: ['**/*.ts', '**/*.tsx'],
/** All JavaScript files */
javascript: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.cjs'],
/** All test files */
tests: ['**/*.test.*', '**/*.spec.*', '**/__tests__/**'],
/** All config files */
configs: ['*.config.*', '*rc', '*rc.*', '*.json', '*.yaml', '*.yml'],
/** All source files */
source: ['src/**/*'],
/** All documentation */
docs: ['**/*.md', 'docs/**/*', 'README*'],
/** Node modules (usually excluded) */
nodeModules: ['**/node_modules/**'],
/** Build outputs (usually excluded) */
buildOutputs: ['**/dist/**', '**/build/**', '**/.next/**'],
/** All files */
all: ['**/*'],
} as const;
/**
* Create glob config from common pattern names
*/
export function fromCommonPatterns(
includeNames: (keyof typeof COMMON_PATTERNS)[],
excludeNames?: (keyof typeof COMMON_PATTERNS)[]
): GlobConfig {
const include: string[] = [];
const exclude: string[] = [];
for (const name of includeNames) {
include.push(...COMMON_PATTERNS[name]);
}
if (excludeNames) {
for (const name of excludeNames) {
exclude.push(...COMMON_PATTERNS[name]);
}
}
return { include, exclude };
}
-15
View File
@@ -1,15 +0,0 @@
/**
* Agent Features Module
*
* Enhanced agent-specific features including:
* - Permissions system (OpenCode-style)
* - Glob pattern matching (Cursor-style)
* - Bootstrap files (Amp-style)
* - Multi-mode support (Roo/Kilo-style)
*/
export * from './types.js';
export * from './permissions.js';
export * from './globs.js';
export * from './bootstrap.js';
export * from './modes.js';
-301
View File
@@ -1,301 +0,0 @@
/**
* Multi-Mode System
*
* Implements multi-mode support for agents that support different operating modes.
*/
import type { AgentMode, ModeConfig } from './types.js';
import { GlobMatcher } from './globs.js';
/**
* Default mode configurations
*/
const DEFAULT_MODES: Record<AgentMode, Omit<ModeConfig, 'skills'>> = {
code: {
mode: 'code',
description: 'Code editing and implementation mode',
promptPrefix: 'You are in code mode. Focus on writing and editing code.',
},
architect: {
mode: 'architect',
description: 'Architecture and planning mode',
promptPrefix: 'You are in architect mode. Focus on system design and planning.',
},
ask: {
mode: 'ask',
description: 'Question and answer mode',
promptPrefix: 'You are in ask mode. Focus on answering questions clearly.',
},
debug: {
mode: 'debug',
description: 'Debugging and troubleshooting mode',
promptPrefix: 'You are in debug mode. Focus on finding and fixing issues.',
},
review: {
mode: 'review',
description: 'Code review mode',
promptPrefix: 'You are in review mode. Focus on reviewing code quality.',
},
test: {
mode: 'test',
description: 'Testing mode',
promptPrefix: 'You are in test mode. Focus on writing and running tests.',
},
docs: {
mode: 'docs',
description: 'Documentation mode',
promptPrefix: 'You are in docs mode. Focus on writing documentation.',
},
};
/**
* ModeManager - Manage agent operating modes
*/
export class ModeManager {
private modes: Map<AgentMode, ModeConfig> = new Map();
private currentMode: AgentMode = 'code';
private modeListeners: Set<ModeChangeListener> = new Set();
constructor(modes?: ModeConfig[]) {
if (modes) {
for (const mode of modes) {
this.addMode(mode);
}
}
}
/**
* Add a mode configuration
*/
addMode(config: ModeConfig): void {
this.modes.set(config.mode, config);
}
/**
* Get a mode configuration
*/
getMode(mode: AgentMode): ModeConfig | undefined {
return this.modes.get(mode);
}
/**
* Get all mode configurations
*/
getAllModes(): ModeConfig[] {
return Array.from(this.modes.values());
}
/**
* Get available mode names
*/
getAvailableModes(): AgentMode[] {
return Array.from(this.modes.keys());
}
/**
* Set the current mode
*/
setMode(mode: AgentMode): void {
const config = this.modes.get(mode);
if (!config) {
throw new Error(`Mode not configured: ${mode}`);
}
const previousMode = this.currentMode;
this.currentMode = mode;
// Notify listeners
for (const listener of this.modeListeners) {
listener(mode, previousMode, config);
}
}
/**
* Get the current mode
*/
getCurrentMode(): AgentMode {
return this.currentMode;
}
/**
* Get current mode configuration
*/
getCurrentModeConfig(): ModeConfig | undefined {
return this.modes.get(this.currentMode);
}
/**
* Get skills for current mode
*/
getCurrentSkills(): string[] {
const config = this.getCurrentModeConfig();
return config?.skills || [];
}
/**
* Get tools for current mode
*/
getCurrentTools(): string[] {
const config = this.getCurrentModeConfig();
return config?.tools || [];
}
/**
* Check if a skill is available in current mode
*/
isSkillAvailable(skillName: string): boolean {
const skills = this.getCurrentSkills();
return skills.length === 0 || skills.includes(skillName);
}
/**
* Check if a file is allowed in current mode
*/
isFileAllowed(filePath: string): boolean {
const config = this.getCurrentModeConfig();
if (!config?.allowedFiles || config.allowedFiles.length === 0) {
return true;
}
const matcher = new GlobMatcher({ include: config.allowedFiles });
return matcher.matches(filePath);
}
/**
* Add mode change listener
*/
addModeListener(listener: ModeChangeListener): void {
this.modeListeners.add(listener);
}
/**
* Remove mode change listener
*/
removeModeListener(listener: ModeChangeListener): void {
this.modeListeners.delete(listener);
}
/**
* Create a mode from default configuration
*/
addDefaultMode(mode: AgentMode, skills: string[]): void {
const defaultConfig = DEFAULT_MODES[mode];
this.addMode({
...defaultConfig,
skills,
});
}
/**
* Generate mode-specific prompt prefix
*/
getPromptPrefix(): string {
const config = this.getCurrentModeConfig();
return config?.promptPrefix || '';
}
/**
* Generate Roo-compatible mode configuration
*/
generateRooConfig(): Record<string, unknown> {
const modes: Record<string, unknown> = {};
for (const config of this.modes.values()) {
modes[config.mode] = {
description: config.description,
skills: config.skills,
tools: config.tools,
promptPrefix: config.promptPrefix,
};
}
return {
defaultMode: this.currentMode,
modes,
};
}
/**
* Generate mode documentation
*/
generateModeDocumentation(): string {
const lines: string[] = [];
lines.push('# Available Modes');
lines.push('');
for (const config of this.modes.values()) {
lines.push(`## ${config.mode}`);
lines.push('');
lines.push(config.description);
lines.push('');
if (config.skills.length > 0) {
lines.push('### Skills');
lines.push('');
for (const skill of config.skills) {
lines.push(`- ${skill}`);
}
lines.push('');
}
if (config.tools && config.tools.length > 0) {
lines.push('### Tools');
lines.push('');
for (const tool of config.tools) {
lines.push(`- ${tool}`);
}
lines.push('');
}
}
return lines.join('\n');
}
}
/**
* Mode change listener type
*/
export type ModeChangeListener = (
newMode: AgentMode,
previousMode: AgentMode,
config: ModeConfig
) => void;
/**
* Create a ModeManager instance
*/
export function createModeManager(modes?: ModeConfig[]): ModeManager {
return new ModeManager(modes);
}
/**
* Create a ModeManager with all default modes
*/
export function createDefaultModeManager(
skillsPerMode: Partial<Record<AgentMode, string[]>>
): ModeManager {
const manager = new ModeManager();
for (const [mode, config] of Object.entries(DEFAULT_MODES)) {
const skills = skillsPerMode[mode as AgentMode] || [];
manager.addMode({
...config,
skills,
});
}
return manager;
}
/**
* Get default configuration for a mode
*/
export function getDefaultModeConfig(mode: AgentMode): Omit<ModeConfig, 'skills'> {
return DEFAULT_MODES[mode];
}
/**
* All available agent modes
*/
export const ALL_MODES: AgentMode[] = ['code', 'architect', 'ask', 'debug', 'review', 'test', 'docs'];
-262
View File
@@ -1,262 +0,0 @@
/**
* Permissions System
*
* Implements permission patterns for agent skill access control.
*/
import { minimatch } from 'minimatch';
import type {
PermissionConfig,
PermissionPattern,
PermissionLevel,
} from './types.js';
/**
* PermissionManager - Manage skill permissions
*/
export class PermissionManager {
private config: PermissionConfig;
constructor(config?: PermissionConfig) {
this.config = config || { default: 'ask' };
}
/**
* Set permission configuration
*/
setConfig(config: PermissionConfig): void {
this.config = config;
}
/**
* Get permission configuration
*/
getConfig(): PermissionConfig {
return this.config;
}
/**
* Check file access permission
*/
checkFileAccess(path: string): PermissionLevel {
return this.checkPattern(path, this.config.files);
}
/**
* Check command execution permission
*/
checkCommandAccess(command: string): PermissionLevel {
return this.checkPattern(command, this.config.commands);
}
/**
* Check network access permission
*/
checkNetworkAccess(url: string): PermissionLevel {
return this.checkPattern(url, this.config.network);
}
/**
* Check environment variable access
*/
checkEnvAccess(varName: string): PermissionLevel {
return this.checkPattern(varName, this.config.env);
}
/**
* Add file permission pattern
*/
addFilePattern(pattern: PermissionPattern): void {
if (!this.config.files) {
this.config.files = [];
}
this.config.files.push(pattern);
}
/**
* Add command permission pattern
*/
addCommandPattern(pattern: PermissionPattern): void {
if (!this.config.commands) {
this.config.commands = [];
}
this.config.commands.push(pattern);
}
/**
* Check pattern against permission list
*/
private checkPattern(
value: string,
patterns?: PermissionPattern[]
): PermissionLevel {
if (!patterns || patterns.length === 0) {
return this.config.default || 'ask';
}
// Check patterns in order (first match wins)
for (const pattern of patterns) {
if (this.matchPattern(value, pattern.pattern)) {
return pattern.level;
}
}
return this.config.default || 'ask';
}
/**
* Match value against pattern (glob-style)
*
* Uses minimatch for safe glob matching, avoiding ReDoS vulnerabilities.
*/
private matchPattern(value: string, pattern: string): boolean {
// Use minimatch for safe, battle-tested glob matching
// nocase option ensures case-insensitive matching
return minimatch(value, pattern, { nocase: true });
}
/**
* Generate OpenCode-compatible permission config
*/
generateOpenCodeConfig(): string {
const lines: string[] = [];
lines.push('# Permission Configuration');
lines.push('');
if (this.config.files && this.config.files.length > 0) {
lines.push('## File Access');
lines.push('');
for (const pattern of this.config.files) {
lines.push(`- ${pattern.level}: \`${pattern.pattern}\``);
if (pattern.reason) {
lines.push(` - Reason: ${pattern.reason}`);
}
}
lines.push('');
}
if (this.config.commands && this.config.commands.length > 0) {
lines.push('## Command Execution');
lines.push('');
for (const pattern of this.config.commands) {
lines.push(`- ${pattern.level}: \`${pattern.pattern}\``);
if (pattern.reason) {
lines.push(` - Reason: ${pattern.reason}`);
}
}
lines.push('');
}
if (this.config.network && this.config.network.length > 0) {
lines.push('## Network Access');
lines.push('');
for (const pattern of this.config.network) {
lines.push(`- ${pattern.level}: \`${pattern.pattern}\``);
if (pattern.reason) {
lines.push(` - Reason: ${pattern.reason}`);
}
}
lines.push('');
}
lines.push(`Default: ${this.config.default || 'ask'}`);
lines.push('');
return lines.join('\n');
}
/**
* Generate SKILL.md metadata for permissions
*/
generateSkillMetadata(): Record<string, unknown> {
const metadata: Record<string, unknown> = {};
if (this.config.files) {
metadata.filePermissions = this.config.files.map((p) => ({
pattern: p.pattern,
level: p.level,
}));
}
if (this.config.commands) {
metadata.commandPermissions = this.config.commands.map((p) => ({
pattern: p.pattern,
level: p.level,
}));
}
if (this.config.network) {
metadata.networkPermissions = this.config.network.map((p) => ({
pattern: p.pattern,
level: p.level,
}));
}
if (this.config.default) {
metadata.defaultPermission = this.config.default;
}
return metadata;
}
/**
* Parse permissions from SKILL.md metadata
*/
static fromMetadata(metadata: Record<string, unknown>): PermissionConfig {
const config: PermissionConfig = {};
if (metadata.filePermissions && Array.isArray(metadata.filePermissions)) {
config.files = metadata.filePermissions as PermissionPattern[];
}
if (metadata.commandPermissions && Array.isArray(metadata.commandPermissions)) {
config.commands = metadata.commandPermissions as PermissionPattern[];
}
if (metadata.networkPermissions && Array.isArray(metadata.networkPermissions)) {
config.network = metadata.networkPermissions as PermissionPattern[];
}
if (metadata.defaultPermission) {
config.default = metadata.defaultPermission as PermissionLevel;
}
return config;
}
/**
* Merge two permission configs
*/
static merge(base: PermissionConfig, override: PermissionConfig): PermissionConfig {
return {
files: [...(base.files || []), ...(override.files || [])],
commands: [...(base.commands || []), ...(override.commands || [])],
network: [...(base.network || []), ...(override.network || [])],
env: [...(base.env || []), ...(override.env || [])],
default: override.default || base.default,
};
}
}
/**
* Create a PermissionManager instance
*/
export function createPermissionManager(config?: PermissionConfig): PermissionManager {
return new PermissionManager(config);
}
/**
* Quick permission check helpers
*/
export function isAllowed(level: PermissionLevel): boolean {
return level === 'allow';
}
export function isDenied(level: PermissionLevel): boolean {
return level === 'deny';
}
export function needsConfirmation(level: PermissionLevel): boolean {
return level === 'ask';
}
-214
View File
@@ -1,214 +0,0 @@
/**
* Agent Features Types
*
* Type definitions for enhanced agent-specific features.
*/
import type { AgentType } from '@skillkit/core';
/**
* Permission level for agent actions
*/
export type PermissionLevel = 'allow' | 'deny' | 'ask';
/**
* Permission pattern for file/resource access
*/
export interface PermissionPattern {
/** Pattern to match (glob or regex) */
pattern: string;
/** Permission level */
level: PermissionLevel;
/** Description of why this permission is needed */
reason?: string;
}
/**
* Permission configuration for skills
*/
export interface PermissionConfig {
/** File access permissions */
files?: PermissionPattern[];
/** Command execution permissions */
commands?: PermissionPattern[];
/** Network access permissions */
network?: PermissionPattern[];
/** Environment variable access */
env?: PermissionPattern[];
/** Default permission level */
default?: PermissionLevel;
}
/**
* Glob pattern configuration for file-scoped skills
*/
export interface GlobConfig {
/** Patterns to include */
include: string[];
/** Patterns to exclude */
exclude?: string[];
/** Whether to match directories */
matchDirectories?: boolean;
/** Whether to match hidden files */
matchHidden?: boolean;
}
/**
* Bootstrap file types
*/
export type BootstrapFileType =
| 'agents' // AGENTS.md - Agent definitions
| 'soul' // SOUL.md - Personality and behavior
| 'tools' // TOOLS.md - Available tools
| 'identity' // IDENTITY.md - Agent identity
| 'context' // CONTEXT.md - Context information
| 'brief' // BRIEF.md - Project brief
| 'history'; // HISTORY.md - Conversation history
/**
* Bootstrap file configuration
*/
export interface BootstrapFile {
/** File type */
type: BootstrapFileType;
/** File name */
name: string;
/** File content */
content: string;
/** Priority (higher = loaded first) */
priority?: number;
/** Whether file is required */
required?: boolean;
}
/**
* Agent mode types
*/
export type AgentMode =
| 'code' // Code editing mode
| 'architect' // Architecture/planning mode
| 'ask' // Question/answer mode
| 'debug' // Debugging mode
| 'review' // Code review mode
| 'test' // Testing mode
| 'docs'; // Documentation mode
/**
* Mode configuration
*/
export interface ModeConfig {
/** Mode name */
mode: AgentMode;
/** Mode description */
description: string;
/** Skills available in this mode */
skills: string[];
/** Tools available in this mode */
tools?: string[];
/** Default prompt prefix for this mode */
promptPrefix?: string;
/** Allowed file patterns in this mode */
allowedFiles?: string[];
}
/**
* Tool whitelist configuration
*/
export interface ToolWhitelistConfig {
/** Allowed tools */
allowed: string[];
/** Denied tools */
denied?: string[];
/** Mode for handling unlisted tools */
unlisted?: 'allow' | 'deny' | 'ask';
}
/**
* Skill package configuration (for .skill bundles)
*/
export interface SkillPackageConfig {
/** Package name */
name: string;
/** Package version */
version: string;
/** Package description */
description?: string;
/** Entry point skill */
entryPoint: string;
/** Included skill files */
files: string[];
/** Dependencies */
dependencies?: string[];
/** Metadata */
metadata?: Record<string, unknown>;
}
/**
* Agent feature capabilities
*/
export interface AgentCapabilities {
/** Supports permission system */
permissions: boolean;
/** Supports glob patterns */
globs: boolean;
/** Supports bootstrap files */
bootstrapFiles: boolean;
/** Supports multi-mode */
multiMode: boolean;
/** Supports tool whitelisting */
toolWhitelist: boolean;
/** Supports .skill packages */
skillPackages: boolean;
/** Supports hooks */
hooks: boolean;
/** Supports subagents */
subagents: boolean;
}
/**
* Agent feature set
*/
export interface AgentFeatures {
/** Agent type */
agent: AgentType;
/** Agent capabilities */
capabilities: AgentCapabilities;
/** Permission configuration */
permissions?: PermissionConfig;
/** Glob configuration */
globs?: GlobConfig;
/** Bootstrap files */
bootstrapFiles?: BootstrapFile[];
/** Mode configurations */
modes?: ModeConfig[];
/** Tool whitelist */
toolWhitelist?: ToolWhitelistConfig;
}
/**
* Feature generation options
*/
export interface FeatureGenerationOptions {
/** Target agent */
agent: AgentType;
/** Output directory */
outputDir?: string;
/** Include optional files */
includeOptional?: boolean;
/** Dry run (don't write files) */
dryRun?: boolean;
}
/**
* Feature validation result
*/
export interface FeatureValidationResult {
/** Whether features are valid */
valid: boolean;
/** Validation errors */
errors: string[];
/** Validation warnings */
warnings: string[];
/** Agent capabilities used */
usedCapabilities: (keyof AgentCapabilities)[];
}
+3 -6
View File
@@ -3,15 +3,12 @@ import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['gemini-cli'];
export class GeminiCliAdapter implements AgentAdapter {
readonly type: AgentType = 'gemini-cli';
readonly name = 'Gemini CLI';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.gemini/skills';
readonly configFile = 'GEMINI.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -67,7 +64,7 @@ ${JSON.stringify(skillsJson, null, 2)}
}
if (skillNames.length === 0) {
const headerRegex = /^###\s+(.+?)\s*$/gm;
const headerRegex = /^### ([a-z0-9-]+)$/gm;
let match;
while ((match = headerRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
+28 -27
View File
@@ -2,16 +2,14 @@ import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['github-copilot'];
export class GitHubCopilotAdapter implements AgentAdapter {
readonly type: AgentType = 'github-copilot';
readonly name = 'GitHub Copilot';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.github/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -20,38 +18,43 @@ export class GitHubCopilotAdapter implements AgentAdapter {
return '';
}
const skillsList = enabledSkills
.map(s => `### ${s.name}\n\n${s.description}\n\n**Invoke:** \`skillkit read ${s.name}\``)
.join('\n\n');
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
return `# Skills System
You have access to specialized skills that can help complete tasks.
Skills provide domain-specific knowledge and step-by-step instructions.
return `<skills_system priority="1">
## Available Skills
${skillsList}
<!-- SKILLS_TABLE_START -->
<usage>
When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
## How to Use Skills
How to use skills:
- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
- The skill content will load with detailed instructions on how to complete the task
- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
When a task matches a skill's description, load it using the terminal:
Usage notes:
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already loaded in your context
- Each skill invocation is stateless
</usage>
\`\`\`bash
skillkit read <skill-name>
\`\`\`
<available_skills>
The skill content will load with detailed instructions.
Each skill is self-contained with its own resources.
`;
${skillsXml}
</available_skills>
<!-- SKILLS_TABLE_END -->
</skills_system>`;
}
parseConfig(content: string): string[] {
const skillNames: string[] = [];
const headerRegex = /^###\s+(.+?)\s*$/gm;
const skillRegex = /<name>([^<]+)<\/name>/g;
let match;
while ((match = headerRegex.exec(content)) !== null) {
while ((match = skillRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
}
@@ -63,11 +66,9 @@ Each skill is self-contained with its own resources.
}
async isDetected(): Promise<boolean> {
const copilotInstructions = join(process.cwd(), '.github', 'copilot-instructions.md');
const githubInstructions = join(process.cwd(), '.github', 'instructions');
const projectGithub = join(process.cwd(), '.github', 'skills');
const globalCopilot = join(homedir(), '.copilot');
return existsSync(copilotInstructions) ||
existsSync(githubInstructions) || existsSync(globalCopilot);
return existsSync(projectGithub) || existsSync(globalCopilot);
}
}
+2 -5
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.goose;
export class GooseAdapter implements AgentAdapter {
readonly type: AgentType = 'goose';
readonly name = 'Goose';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.goose/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+7 -5
View File
@@ -37,9 +37,6 @@ export * from './trae.js';
export * from './windsurf.js';
export * from './universal.js';
// Agent features
export * from './features/index.js';
const adapters: Record<AgentType, AgentAdapter> = {
'claude-code': new ClaudeCodeAdapter(),
cursor: new CursorAdapter(),
@@ -99,5 +96,10 @@ export async function detectAgent(): Promise<AgentType> {
return 'universal';
}
// getSkillsDir and getConfigFile are now re-exported from @skillkit/core above
// This ensures a single source of truth for agent configurations
export function getSkillsDir(type: AgentType): string {
return adapters[type].skillsDir;
}
export function getConfigFile(type: AgentType): string {
return adapters[type].configFile;
}
+3 -7
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.kilo;
export class KiloAdapter implements AgentAdapter {
readonly type: AgentType = 'kilo';
readonly name = 'Kilo Code';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.kilocode/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -71,8 +68,7 @@ ${skillsXml}
async isDetected(): Promise<boolean> {
const projectKilo = join(process.cwd(), '.kilocode');
const globalKilo = join(homedir(), '.kilocode');
const kiloModes = join(process.cwd(), '.kilocode', 'modes');
return existsSync(projectKilo) || existsSync(globalKilo) || existsSync(kiloModes);
return existsSync(projectKilo) || existsSync(globalKilo);
}
}
+2 -5
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['kiro-cli'];
export class KiroCliAdapter implements AgentAdapter {
readonly type: AgentType = 'kiro-cli';
readonly name = 'Kiro CLI';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.kiro/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+4 -9
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.opencode;
export class OpenCodeAdapter implements AgentAdapter {
readonly type: AgentType = 'opencode';
readonly name = 'OpenCode';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.opencode/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -63,10 +60,8 @@ This loads the skill's instructions into context.
async isDetected(): Promise<boolean> {
const opencodeDir = join(process.cwd(), '.opencode');
const globalOpencode = join(homedir(), '.config', 'opencode');
const opencodeJson = join(process.cwd(), 'opencode.json');
const globalOpencode = join(homedir(), '.opencode');
return existsSync(opencodeDir) || existsSync(globalOpencode) ||
existsSync(opencodeJson);
return existsSync(opencodeDir) || existsSync(globalOpencode);
}
}
+3 -7
View File
@@ -4,15 +4,12 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.roo;
export class RooAdapter implements AgentAdapter {
readonly type: AgentType = 'roo';
readonly name = 'Roo Code';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.roo/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -71,8 +68,7 @@ ${skillsXml}
async isDetected(): Promise<boolean> {
const projectRoo = join(process.cwd(), '.roo');
const globalRoo = join(homedir(), '.roo');
const rooModes = join(process.cwd(), '.roo', 'modes');
return existsSync(projectRoo) || existsSync(globalRoo) || existsSync(rooModes);
return existsSync(projectRoo) || existsSync(globalRoo);
}
}
+27 -29
View File
@@ -2,16 +2,14 @@ import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.trae;
export class TraeAdapter implements AgentAdapter {
readonly type: AgentType = 'trae';
readonly name = 'Trae';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.trae/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -20,42 +18,43 @@ export class TraeAdapter implements AgentAdapter {
return '';
}
const skillsList = enabledSkills
.map(s => `### ${s.name}\n\n${s.description}\n\n**Invoke:** \`skillkit read ${s.name}\``)
.join('\n\n');
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
return `---
alwaysApply: true
description: SkillKit skills integration for Trae
globs: ["**/*"]
---
# Skills System
You have access to specialized skills that can help complete tasks.
When a task matches a skill's description, load it using the skillkit CLI.
return `<skills_system priority="1">
## Available Skills
${skillsList}
<!-- SKILLS_TABLE_START -->
<usage>
When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
## How to Use Skills
How to use skills:
- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
- The skill content will load with detailed instructions on how to complete the task
- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
When a task matches a skill's description, load it:
Usage notes:
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already loaded in your context
- Each skill invocation is stateless
</usage>
\`\`\`bash
skillkit read <skill-name>
\`\`\`
<available_skills>
Skills provide detailed instructions for completing complex tasks.
`;
${skillsXml}
</available_skills>
<!-- SKILLS_TABLE_END -->
</skills_system>`;
}
parseConfig(content: string): string[] {
const skillNames: string[] = [];
const headerRegex = /^###\s+(.+?)\s*$/gm;
const skillRegex = /<name>([^<]+)<\/name>/g;
let match;
while ((match = headerRegex.exec(content)) !== null) {
while ((match = skillRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
}
@@ -68,9 +67,8 @@ Skills provide detailed instructions for completing complex tasks.
async isDetected(): Promise<boolean> {
const projectTrae = join(process.cwd(), '.trae');
const traeRulesDir = join(process.cwd(), '.trae', 'rules');
const globalTrae = join(homedir(), '.trae');
return existsSync(projectTrae) || existsSync(traeRulesDir) || existsSync(globalTrae);
return existsSync(projectTrae) || existsSync(globalTrae);
}
}
+2 -5
View File
@@ -3,15 +3,12 @@ import { join } from 'node:path';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.universal;
export class UniversalAdapter implements AgentAdapter {
readonly type: AgentType = 'universal';
readonly name = 'Universal (Any Agent)';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.agent/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+27 -30
View File
@@ -2,16 +2,14 @@ import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.windsurf;
export class WindsurfAdapter implements AgentAdapter {
readonly type: AgentType = 'windsurf';
readonly name = 'Windsurf';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
readonly skillsDir = '.windsurf/skills';
readonly configFile = 'AGENTS.md';
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -20,42 +18,43 @@ export class WindsurfAdapter implements AgentAdapter {
return '';
}
const skillsList = enabledSkills
.map(s => `### ${s.name}\n\n${s.description}\n\n**Invoke:** \`skillkit read ${s.name}\``)
.join('\n\n');
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
return `---
name: "skillkit-skills"
mode: "model-decision"
---
# Skills System
You have access to specialized skills that can help complete tasks.
When a task matches a skill's description, load it using the skillkit CLI.
return `<skills_system priority="1">
## Available Skills
${skillsList}
<!-- SKILLS_TABLE_START -->
<usage>
When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
## How to Use Skills
How to use skills:
- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
- The skill content will load with detailed instructions on how to complete the task
- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
When a task matches a skill's description, load it:
Usage notes:
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already loaded in your context
- Each skill invocation is stateless
</usage>
\`\`\`bash
skillkit read <skill-name>
\`\`\`
<available_skills>
Skills provide detailed instructions for completing complex tasks.
Each skill is self-contained with its own resources.
`;
${skillsXml}
</available_skills>
<!-- SKILLS_TABLE_END -->
</skills_system>`;
}
parseConfig(content: string): string[] {
const skillNames: string[] = [];
const headerRegex = /^###\s+(.+?)\s*$/gm;
const skillRegex = /<name>([^<]+)<\/name>/g;
let match;
while ((match = headerRegex.exec(content)) !== null) {
while ((match = skillRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
}
@@ -68,10 +67,8 @@ Each skill is self-contained with its own resources.
async isDetected(): Promise<boolean> {
const projectWindsurf = join(process.cwd(), '.windsurf');
const projectRulesDir = join(process.cwd(), '.windsurf', 'rules');
const globalWindsurf = join(homedir(), '.codeium', 'windsurf');
return existsSync(projectWindsurf) || existsSync(projectRulesDir) ||
existsSync(globalWindsurf);
return existsSync(projectWindsurf) || existsSync(globalWindsurf);
}
}
-58
View File
@@ -101,62 +101,6 @@ skillkit workflow create # Create new workflow
skillkit cicd github-action # Generate GitHub Actions
skillkit cicd gitlab-ci # Generate GitLab CI
skillkit cicd pre-commit # Generate pre-commit hook
skillkit cicd init # Initialize CI/CD templates
```
### Team Collaboration
```bash
skillkit team init --name "Team" # Initialize team
skillkit team share <bundle> # Share skill bundle
skillkit team import <path> # Import bundle
skillkit team list # List team bundles
skillkit team sync # Sync with remote
skillkit team remove <bundle> # Remove bundle
skillkit team bundle-create # Create new bundle
skillkit team bundle-export <id> # Export bundle
skillkit team bundle-list # List all bundles
```
### Plugin System
```bash
skillkit plugin list # List installed plugins
skillkit plugin install <name> # Install plugin
skillkit plugin uninstall <name> # Uninstall plugin
skillkit plugin enable <name> # Enable plugin
skillkit plugin disable <name> # Disable plugin
skillkit plugin info <name> # Plugin details
```
### Methodologies & Plans
```bash
skillkit methodology list # List methodologies
skillkit methodology load <name> # Load methodology
skillkit methodology apply <name> # Apply to project
skillkit plan parse <file> # Parse plan file
skillkit plan validate <file> # Validate plan
skillkit plan execute <file> # Execute plan
skillkit plan status # Plan execution status
```
### Hooks & Automation
```bash
skillkit hook list # List registered hooks
skillkit hook register <event> # Register new hook
skillkit hook trigger <event> # Trigger hook manually
skillkit hook enable <id> # Enable hook
skillkit hook disable <id> # Disable hook
```
### Agent Commands
```bash
skillkit command generate <agent> # Generate agent-native commands
skillkit command list <agent> # List available commands
```
### Utilities
@@ -166,8 +110,6 @@ skillkit init # Initialize in project
skillkit init --agent cursor # Initialize for specific agent
skillkit validate ./skill # Validate skill format
skillkit create my-skill # Create new skill
skillkit settings # View all settings
skillkit settings --set key=value # Update setting
```
## Install Options
+2 -4
View File
@@ -1,6 +1,6 @@
{
"name": "@skillkit/cli",
"version": "1.6.4",
"version": "1.4.0",
"description": "CLI commands for SkillKit",
"type": "module",
"main": "./dist/index.js",
@@ -11,9 +11,7 @@
"types": "./dist/index.d.ts"
}
},
"files": [
"dist"
],
"files": ["dist"],
"scripts": {
"build": "tsup",
"dev": "tsup --watch",
-631
View File
@@ -1,631 +0,0 @@
/**
* Agent Command
*
* Manage custom AI sub-agents (e.g., .claude/agents/*.md)
*/
import chalk from 'chalk';
import { Command, Option } from 'clipanion';
import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import {
findAllAgents,
findAgent,
discoverAgents,
discoverAgentsFromPath,
validateAgent,
translateAgent,
getAgentTargetDirectory,
type CustomAgent,
type AgentType,
} from '@skillkit/core';
// Agent discovery uses root directories, not skill directories
export class AgentCommand extends Command {
static override paths = [['agent']];
static override usage = Command.Usage({
description: 'Manage custom AI sub-agents',
details: `
This command manages custom AI sub-agents that can be used with
Claude Code, Cursor, and other AI coding agents.
Agents are specialized personas (like architects, testers, reviewers)
that can be invoked with @mentions or the --agent flag.
Sub-commands:
agent list - List all installed agents
agent show - Show agent details
agent create - Create a new agent
agent translate - Translate agents between formats
agent sync - Sync agents to target AI agent
agent validate - Validate agent definitions
`,
examples: [
['List all agents', '$0 agent list'],
['Show agent details', '$0 agent show architect'],
['Create new agent', '$0 agent create security-reviewer'],
['Translate to Cursor format', '$0 agent translate --to cursor'],
['Sync agents', '$0 agent sync --agent claude-code'],
],
});
async execute(): Promise<number> {
console.log(chalk.cyan('Agent management commands:\n'));
console.log(' agent list List all installed agents');
console.log(' agent show <name> Show agent details');
console.log(' agent create <name> Create a new agent');
console.log(' agent translate Translate agents between formats');
console.log(' agent sync Sync agents to target AI agent');
console.log(' agent validate [path] Validate agent definitions');
console.log();
console.log(chalk.dim('Run `skillkit agent <subcommand> --help` for more info'));
return 0;
}
}
export class AgentListCommand extends Command {
static override paths = [['agent', 'list'], ['agent', 'ls']];
static override usage = Command.Usage({
description: 'List all installed agents',
examples: [
['List all agents', '$0 agent list'],
['Show JSON output', '$0 agent list --json'],
['Show only project agents', '$0 agent list --project'],
],
});
json = Option.Boolean('--json,-j', false, {
description: 'Output as JSON',
});
project = Option.Boolean('--project,-p', false, {
description: 'Show only project agents',
});
global = Option.Boolean('--global,-g', false, {
description: 'Show only global agents',
});
async execute(): Promise<number> {
const searchDirs = [process.cwd()];
let agents = findAllAgents(searchDirs);
if (this.project) {
agents = agents.filter((a: CustomAgent) => a.location === 'project');
} else if (this.global) {
agents = agents.filter((a: CustomAgent) => a.location === 'global');
}
agents.sort((a: CustomAgent, b: CustomAgent) => {
if (a.location !== b.location) {
return a.location === 'project' ? -1 : 1;
}
return a.name.localeCompare(b.name);
});
if (this.json) {
console.log(JSON.stringify(agents.map((a: CustomAgent) => ({
name: a.name,
description: a.description,
path: a.path,
location: a.location,
enabled: a.enabled,
model: a.frontmatter.model,
permissionMode: a.frontmatter.permissionMode,
})), null, 2));
return 0;
}
if (agents.length === 0) {
console.log(chalk.yellow('No agents found'));
console.log(chalk.dim('Create an agent with: skillkit agent create <name>'));
return 0;
}
console.log(chalk.cyan(`Installed agents (${agents.length}):\n`));
const projectAgents = agents.filter((a: CustomAgent) => a.location === 'project');
const globalAgents = agents.filter((a: CustomAgent) => a.location === 'global');
if (projectAgents.length > 0) {
console.log(chalk.blue('Project agents:'));
for (const agent of projectAgents) {
printAgent(agent);
}
console.log();
}
if (globalAgents.length > 0) {
console.log(chalk.dim('Global agents:'));
for (const agent of globalAgents) {
printAgent(agent);
}
console.log();
}
console.log(
chalk.dim(`${projectAgents.length} project, ${globalAgents.length} global`)
);
return 0;
}
}
export class AgentShowCommand extends Command {
static override paths = [['agent', 'show'], ['agent', 'info']];
static override usage = Command.Usage({
description: 'Show details for a specific agent',
examples: [
['Show agent details', '$0 agent show architect'],
],
});
name = Option.String({ required: true });
async execute(): Promise<number> {
const searchDirs = [process.cwd()];
const agent = findAgent(this.name, searchDirs);
if (!agent) {
console.log(chalk.red(`Agent not found: ${this.name}`));
return 1;
}
console.log(chalk.cyan(`Agent: ${agent.name}\n`));
console.log(`${chalk.dim('Description:')} ${agent.description}`);
console.log(`${chalk.dim('Location:')} ${agent.location} (${agent.path})`);
console.log(`${chalk.dim('Enabled:')} ${agent.enabled ? chalk.green('yes') : chalk.red('no')}`);
const fm = agent.frontmatter;
if (fm.model) {
console.log(`${chalk.dim('Model:')} ${fm.model}`);
}
if (fm.permissionMode) {
console.log(`${chalk.dim('Permission Mode:')} ${fm.permissionMode}`);
}
if (fm.context) {
console.log(`${chalk.dim('Context:')} ${fm.context}`);
}
if (fm.disallowedTools && fm.disallowedTools.length > 0) {
console.log(`${chalk.dim('Disallowed Tools:')} ${fm.disallowedTools.join(', ')}`);
}
if (fm.skills && fm.skills.length > 0) {
console.log(`${chalk.dim('Skills:')} ${fm.skills.join(', ')}`);
}
if (fm.hooks && fm.hooks.length > 0) {
console.log(`${chalk.dim('Hooks:')} ${fm.hooks.length} defined`);
}
if (fm.tags && fm.tags.length > 0) {
console.log(`${chalk.dim('Tags:')} ${fm.tags.join(', ')}`);
}
if (fm.author) {
console.log(`${chalk.dim('Author:')} ${fm.author}`);
}
if (fm.version) {
console.log(`${chalk.dim('Version:')} ${fm.version}`);
}
console.log();
console.log(chalk.dim('Content preview:'));
console.log(chalk.dim('─'.repeat(40)));
const preview = agent.content.slice(0, 500);
console.log(preview + (agent.content.length > 500 ? '\n...' : ''));
return 0;
}
}
export class AgentCreateCommand extends Command {
static override paths = [['agent', 'create'], ['agent', 'new']];
static override usage = Command.Usage({
description: 'Create a new agent',
examples: [
['Create an agent', '$0 agent create security-reviewer'],
['Create with model', '$0 agent create architect --model opus'],
['Create globally', '$0 agent create my-agent --global'],
],
});
name = Option.String({ required: true });
model = Option.String('--model,-m', {
description: 'Model to use (opus, sonnet, haiku)',
});
description = Option.String('--description,-d', {
description: 'Agent description',
});
global = Option.Boolean('--global,-g', false, {
description: 'Create in global agents directory',
});
async execute(): Promise<number> {
// Validate agent name format
const namePattern = /^[a-z0-9]+(-[a-z0-9]+)*$/;
if (!namePattern.test(this.name)) {
console.log(chalk.red('Invalid agent name: must be lowercase alphanumeric with hyphens'));
console.log(chalk.dim('Examples: my-agent, code-reviewer, security-expert'));
return 1;
}
// Determine target directory
let targetDir: string;
if (this.global) {
targetDir = join(homedir(), '.claude', 'agents');
} else {
targetDir = join(process.cwd(), '.claude', 'agents');
}
// Create directory if needed
if (!existsSync(targetDir)) {
mkdirSync(targetDir, { recursive: true });
}
// Check if agent already exists
const agentPath = join(targetDir, `${this.name}.md`);
if (existsSync(agentPath)) {
console.log(chalk.red(`Agent already exists: ${agentPath}`));
return 1;
}
// Generate content
const description = this.description || `${this.name} agent`;
const content = generateAgentTemplate(this.name, description, this.model);
// Write file
writeFileSync(agentPath, content);
console.log(chalk.green(`Created agent: ${agentPath}`));
console.log();
console.log(chalk.dim('Edit the file to customize the agent system prompt.'));
console.log(chalk.dim(`Invoke with: @${this.name}`));
return 0;
}
}
export class AgentTranslateCommand extends Command {
static override paths = [['agent', 'translate']];
static override usage = Command.Usage({
description: 'Translate agents between AI coding agent formats',
details: `
Translates agent definitions between different AI coding agent formats.
Supports recursive translation for directories with multiple agents.
Use --source to specify a custom source directory with agents.
Use --recursive to scan all subdirectories for agents.
`,
examples: [
['Translate all to Cursor', '$0 agent translate --to cursor'],
['Translate specific agent', '$0 agent translate architect --to cursor'],
['Translate from source directory', '$0 agent translate --source ./my-agents --to cursor'],
['Recursive translation', '$0 agent translate --source ./skills --to cursor --recursive'],
['Dry run', '$0 agent translate --to cursor --dry-run'],
],
});
name = Option.String({ required: false });
to = Option.String('--to,-t', {
description: 'Target AI agent (claude-code, cursor, codex, etc.)',
required: true,
});
source = Option.String('--source,-s', {
description: 'Source directory or file to translate from',
});
output = Option.String('--output,-o', {
description: 'Output directory',
});
dryRun = Option.Boolean('--dry-run,-n', false, {
description: 'Show what would be done without writing files',
});
all = Option.Boolean('--all,-a', false, {
description: 'Translate all agents',
});
recursive = Option.Boolean('--recursive,-r', false, {
description: 'Recursively scan directories for agents',
});
async execute(): Promise<number> {
const searchDirs = [process.cwd()];
const targetAgent = this.to as AgentType;
// Get agents to translate
let agents: CustomAgent[];
if (this.source) {
// Translate from custom source path
const sourcePath = this.source.startsWith('/')
? this.source
: join(process.cwd(), this.source);
if (!existsSync(sourcePath)) {
console.log(chalk.red(`Source path not found: ${sourcePath}`));
return 1;
}
agents = discoverAgentsFromPath(sourcePath, this.recursive);
if (agents.length === 0) {
console.log(chalk.yellow(`No agents found in: ${sourcePath}`));
if (!this.recursive) {
console.log(chalk.dim('Tip: Use --recursive to scan subdirectories'));
}
return 0;
}
} else if (this.name) {
const agent = findAgent(this.name, searchDirs);
if (!agent) {
console.log(chalk.red(`Agent not found: ${this.name}`));
return 1;
}
agents = [agent];
} else if (this.all) {
agents = findAllAgents(searchDirs);
} else {
agents = discoverAgents(process.cwd());
}
if (agents.length === 0) {
console.log(chalk.yellow('No agents found to translate'));
return 0;
}
// Determine output directory
const outputDir = this.output || getAgentTargetDirectory(process.cwd(), targetAgent);
console.log(chalk.cyan(`Translating ${agents.length} agent(s) to ${targetAgent} format...\n`));
let successCount = 0;
let errorCount = 0;
for (const agent of agents) {
try {
const result = translateAgent(agent, targetAgent, { addMetadata: true });
if (!result.success) {
console.log(chalk.red(`✗ ${agent.name}: Translation failed`));
errorCount++;
continue;
}
const outputPath = join(outputDir, result.filename);
if (this.dryRun) {
console.log(chalk.blue(`Would write: ${outputPath}`));
if (result.warnings.length > 0) {
for (const warning of result.warnings) {
console.log(chalk.yellow(` ⚠ ${warning}`));
}
}
if (result.incompatible.length > 0) {
for (const incompat of result.incompatible) {
console.log(chalk.dim(` ○ ${incompat}`));
}
}
} else {
// Create directory if needed
if (!existsSync(outputDir)) {
mkdirSync(outputDir, { recursive: true });
}
writeFileSync(outputPath, result.content);
console.log(chalk.green(`✓ ${agent.name} → ${outputPath}`));
}
successCount++;
} catch (error) {
console.log(chalk.red(`✗ ${agent.name}: ${error instanceof Error ? error.message : 'Unknown error'}`));
errorCount++;
}
}
console.log();
if (this.dryRun) {
console.log(chalk.dim(`Would translate ${successCount} agent(s)`));
} else {
console.log(chalk.dim(`Translated ${successCount} agent(s)${errorCount > 0 ? `, ${errorCount} failed` : ''}`));
}
return errorCount > 0 ? 1 : 0;
}
}
export class AgentSyncCommand extends Command {
static override paths = [['agent', 'sync']];
static override usage = Command.Usage({
description: 'Sync agents to target AI coding agent',
examples: [
['Sync to Claude Code', '$0 agent sync --agent claude-code'],
['Sync to multiple agents', '$0 agent sync --agent claude-code,cursor'],
],
});
agent = Option.String('--agent,-a', {
description: 'Target AI agent(s) (comma-separated)',
});
async execute(): Promise<number> {
const searchDirs = [process.cwd()];
const agents = findAllAgents(searchDirs);
if (agents.length === 0) {
console.log(chalk.yellow('No agents found to sync'));
return 0;
}
const targetAgents = this.agent
? this.agent.split(',').map(a => a.trim() as AgentType)
: ['claude-code' as AgentType];
console.log(chalk.cyan(`Syncing ${agents.length} agent(s)...\n`));
for (const targetAgent of targetAgents) {
const outputDir = getAgentTargetDirectory(process.cwd(), targetAgent);
console.log(chalk.blue(`→ ${targetAgent} (${outputDir})`));
if (!existsSync(outputDir)) {
mkdirSync(outputDir, { recursive: true });
}
for (const agent of agents) {
const result = translateAgent(agent, targetAgent);
if (result.success) {
const outputPath = join(outputDir, result.filename);
writeFileSync(outputPath, result.content);
console.log(chalk.green(` ✓ ${agent.name}`));
} else {
console.log(chalk.red(` ✗ ${agent.name}`));
}
}
}
console.log();
console.log(chalk.dim('Sync complete'));
return 0;
}
}
export class AgentValidateCommand extends Command {
static override paths = [['agent', 'validate']];
static override usage = Command.Usage({
description: 'Validate agent definitions',
examples: [
['Validate specific agent', '$0 agent validate ./my-agent.md'],
['Validate all agents', '$0 agent validate --all'],
],
});
agentPath = Option.String({ required: false });
all = Option.Boolean('--all,-a', false, {
description: 'Validate all discovered agents',
});
async execute(): Promise<number> {
let hasErrors = false;
if (this.agentPath) {
// Validate specific path
const result = validateAgent(this.agentPath);
printValidationResult(this.agentPath, result);
hasErrors = !result.valid;
} else if (this.all) {
// Validate all agents
const searchDirs = [process.cwd()];
const agents = findAllAgents(searchDirs);
if (agents.length === 0) {
console.log(chalk.yellow('No agents found'));
return 0;
}
console.log(chalk.cyan(`Validating ${agents.length} agent(s)...\n`));
for (const agent of agents) {
const result = validateAgent(agent.path);
printValidationResult(agent.name, result);
if (!result.valid) hasErrors = true;
}
} else {
console.log(chalk.yellow('Specify a path or use --all to validate all agents'));
return 1;
}
return hasErrors ? 1 : 0;
}
}
// Helper functions
function printAgent(agent: CustomAgent): void {
const status = agent.enabled ? chalk.green('✓') : chalk.red('○');
const name = agent.enabled ? agent.name : chalk.dim(agent.name);
const model = agent.frontmatter.model ? chalk.blue(`[${agent.frontmatter.model}]`) : '';
const desc = chalk.dim(truncate(agent.description, 40));
console.log(` ${status} ${name} ${model}`);
if (agent.description) {
console.log(` ${desc}`);
}
}
function printValidationResult(
name: string,
result: { valid: boolean; errors: string[]; warnings: string[] }
): void {
if (result.valid) {
console.log(chalk.green(`✓ ${name}`));
for (const warning of result.warnings) {
console.log(chalk.yellow(` ⚠ ${warning}`));
}
} else {
console.log(chalk.red(`✗ ${name}`));
for (const error of result.errors) {
console.log(chalk.red(` • ${error}`));
}
for (const warning of result.warnings) {
console.log(chalk.yellow(` ⚠ ${warning}`));
}
}
}
function truncate(str: string, maxLen: number): string {
if (str.length <= maxLen) return str;
return str.slice(0, maxLen - 3) + '...';
}
function generateAgentTemplate(name: string, description: string, model?: string): string {
const lines: string[] = [];
lines.push('---');
lines.push(`name: ${name}`);
lines.push(`description: ${description}`);
if (model) {
lines.push(`model: ${model}`);
}
lines.push('# permissionMode: default');
lines.push('# disallowedTools: []');
lines.push('# skills: []');
lines.push('# context: fork');
lines.push('---');
lines.push('');
lines.push(`# ${formatAgentName(name)}`);
lines.push('');
lines.push('You are a specialized AI assistant.');
lines.push('');
lines.push('## Responsibilities');
lines.push('');
lines.push('- TODO: Define what this agent is responsible for');
lines.push('- TODO: Add specific tasks and behaviors');
lines.push('');
lines.push('## Guidelines');
lines.push('');
lines.push('- TODO: Add guidelines for how this agent should behave');
lines.push('- TODO: Define any constraints or preferences');
lines.push('');
return lines.join('\n');
}
function formatAgentName(name: string): string {
return name
.split('-')
.map(word => word.charAt(0).toUpperCase() + word.slice(1))
.join(' ');
}
-390
View File
@@ -1,390 +0,0 @@
import { Command, Option } from 'clipanion';
import { resolve } from 'node:path';
import { promises as fs } from 'fs';
import chalk from 'chalk';
import ora from 'ora';
import {
type SearchableSkill,
type SkillExample,
AIManager,
loadIndex as loadIndexFromCache,
} from '@skillkit/core';
export class AICommand extends Command {
static override paths = [['ai']];
static override usage = Command.Usage({
description: 'AI-powered skill search and generation',
details: `
The ai command provides AI-powered features for skills:
- Natural language search: Find skills using conversational queries
- Skill generation: Automatically generate skills from examples
- Similar skills: Find skills similar to a given skill
Note: Without an API key, the command uses a basic mock AI provider.
Set ANTHROPIC_API_KEY or OPENAI_API_KEY to use real AI features.
`,
examples: [
['Search skills naturally', '$0 ai search "help me write better tests"'],
['Generate skill from description', '$0 ai generate --description "skill for code review"'],
['Generate from code example', '$0 ai generate --from-code example.ts --description "..."'],
['Find similar skills', '$0 ai similar my-skill-name'],
],
});
// Subcommand
subcommand = Option.String({ required: true });
// Search options
query = Option.String('--query,-q', {
description: 'Search query for natural language search',
});
// Generation options
description = Option.String('--description,-d', {
description: 'Description of the skill to generate',
});
fromCode = Option.String('--from-code', {
description: 'Generate skill from code example file',
});
additionalContext = Option.String('--context', {
description: 'Additional context for generation',
});
targetAgent = Option.String('--agent,-a', {
description: 'Target agent for generated skill',
});
// Similar skills option
skillName = Option.String({ required: false });
// Common options
limit = Option.String('--limit,-l', {
description: 'Maximum number of results',
});
minRelevance = Option.String('--min-relevance', {
description: 'Minimum relevance score (0-1)',
});
json = Option.Boolean('--json,-j', false, {
description: 'Output in JSON format',
});
output = Option.String('--output,-o', {
description: 'Output file for generated skill',
});
async execute(): Promise<number> {
const aiConfig = this.getAIConfig();
const manager = new AIManager(aiConfig);
if (!this.json) {
const providerName = manager.getProviderName();
if (providerName === 'mock') {
console.log(
chalk.yellow(
'⚠ Using mock AI provider (limited functionality)\n' +
' Set ANTHROPIC_API_KEY or OPENAI_API_KEY for real AI features\n'
)
);
}
}
switch (this.subcommand) {
case 'search':
return await this.handleSearch(manager);
case 'generate':
case 'gen':
return await this.handleGenerate(manager);
case 'similar':
return await this.handleSimilar(manager);
default:
console.error(
chalk.red(`Unknown subcommand: ${this.subcommand}\n`)
);
console.log('Valid subcommands: search, generate, similar');
return 1;
}
}
private async handleSearch(manager: AIManager): Promise<number> {
const query = this.query || this.skillName;
if (!query) {
console.error(chalk.red('Search query required (--query or positional argument)'));
return 1;
}
const skills = await this.loadSkills();
if (skills.length === 0) {
console.log(
chalk.yellow('No skills found. Run "skillkit recommend --update" first.')
);
return 0;
}
const spinner = ora('Searching with AI...').start();
try {
const results = await manager.searchSkills(query, skills, {
limit: this.limit ? parseInt(this.limit, 10) : 10,
minRelevance: this.minRelevance
? parseFloat(this.minRelevance)
: 0.5,
includeReasoning: !this.json,
});
spinner.stop();
if (this.json) {
console.log(JSON.stringify(results, null, 2));
return 0;
}
if (results.length === 0) {
console.log(chalk.yellow(`No skills found matching "${query}"`));
return 0;
}
console.log(chalk.cyan(`\nAI Search Results (${results.length} found):\n`));
for (const result of results) {
const score = Math.round(result.relevance * 100);
const scoreColor =
score >= 70 ? chalk.green : score >= 50 ? chalk.yellow : chalk.dim;
console.log(
` ${scoreColor(`${score}%`)} ${chalk.bold(result.skill.name)}`
);
if (result.skill.description) {
console.log(` ${chalk.dim(result.skill.description)}`);
}
if (result.reasoning) {
console.log(` ${chalk.dim('→ ' + result.reasoning)}`);
}
console.log();
}
return 0;
} catch (error) {
spinner.fail('Search failed');
console.error(
chalk.red(error instanceof Error ? error.message : String(error))
);
return 1;
}
}
private async handleGenerate(manager: AIManager): Promise<number> {
const description = this.description;
if (!description) {
console.error(chalk.red('Description required (--description)'));
return 1;
}
let codeExamples: string[] = [];
if (this.fromCode) {
const codePath = resolve(this.fromCode);
try {
const code = await fs.readFile(codePath, 'utf-8');
codeExamples = [code];
} catch {
console.error(chalk.red(`Failed to read code file: ${codePath}`));
return 1;
}
}
const example: SkillExample = {
description,
context: this.additionalContext,
codeExamples,
targetAgent: this.targetAgent,
};
const spinner = ora('Generating skill with AI...').start();
try {
const generated = await manager.generateSkill(example, {
targetAgent: this.targetAgent,
includeTests: true,
includeDocumentation: true,
});
spinner.stop();
const validation = manager.validateGenerated(generated);
if (!validation.valid) {
console.log(chalk.yellow('\n⚠ Generated skill has validation warnings:'));
for (const error of validation.errors) {
console.log(chalk.dim(` • ${error}`));
}
console.log();
}
if (this.json) {
console.log(JSON.stringify(generated, null, 2));
return 0;
}
console.log(chalk.green('\n✓ Generated skill successfully\n'));
console.log(chalk.cyan('Name:') + ` ${generated.name}`);
console.log(chalk.cyan('Description:') + ` ${generated.description}`);
console.log(
chalk.cyan('Tags:') + ` ${generated.tags.join(', ')}`
);
console.log(
chalk.cyan('Confidence:') +
` ${Math.round(generated.confidence * 100)}%`
);
if (generated.reasoning) {
console.log(chalk.cyan('Reasoning:') + ` ${generated.reasoning}`);
}
console.log('\n' + chalk.dim('Content:'));
console.log(chalk.dim('─'.repeat(60)));
console.log(generated.content);
console.log(chalk.dim('─'.repeat(60)));
if (this.output) {
const outputPath = resolve(this.output);
await fs.writeFile(outputPath, generated.content, 'utf-8');
console.log(chalk.green(`\n✓ Saved to: ${outputPath}`));
} else {
console.log(
chalk.dim('\nSave with: --output <filename>')
);
}
return 0;
} catch (error) {
spinner.fail('Generation failed');
console.error(
chalk.red(error instanceof Error ? error.message : String(error))
);
return 1;
}
}
private async handleSimilar(manager: AIManager): Promise<number> {
const skillName = this.skillName;
if (!skillName) {
console.error(chalk.red('Skill name required'));
return 1;
}
const skills = await this.loadSkills();
if (skills.length === 0) {
console.log(
chalk.yellow('No skills found. Run "skillkit recommend --update" first.')
);
return 0;
}
const targetSkill = skills.find(
(s) => s.name.toLowerCase() === skillName.toLowerCase()
);
if (!targetSkill) {
console.error(chalk.red(`Skill not found: ${skillName}`));
return 1;
}
const spinner = ora('Finding similar skills...').start();
try {
const results = await manager.findSimilar(targetSkill, skills, {
limit: this.limit ? parseInt(this.limit, 10) : 10,
minRelevance: this.minRelevance
? parseFloat(this.minRelevance)
: 0.5,
includeReasoning: !this.json,
});
spinner.stop();
if (this.json) {
console.log(JSON.stringify(results, null, 2));
return 0;
}
if (results.length === 0) {
console.log(
chalk.yellow(`No similar skills found for "${skillName}"`)
);
return 0;
}
console.log(
chalk.cyan(`\nSkills similar to "${skillName}" (${results.length} found):\n`)
);
for (const result of results) {
const score = Math.round(result.relevance * 100);
const scoreColor =
score >= 70 ? chalk.green : score >= 50 ? chalk.yellow : chalk.dim;
console.log(
` ${scoreColor(`${score}%`)} ${chalk.bold(result.skill.name)}`
);
if (result.skill.description) {
console.log(` ${chalk.dim(result.skill.description)}`);
}
if (result.reasoning) {
console.log(` ${chalk.dim('→ ' + result.reasoning)}`);
}
console.log();
}
return 0;
} catch (error) {
spinner.fail('Search failed');
console.error(
chalk.red(error instanceof Error ? error.message : String(error))
);
return 1;
}
}
private async loadSkills(): Promise<SearchableSkill[]> {
const index = loadIndexFromCache();
if (!index) {
return [];
}
return index.skills.map((s) => ({
name: s.name,
description: s.description,
content: '',
tags: s.tags,
source: s.source,
}));
}
private getAIConfig() {
const apiKey =
process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
return {
provider:
process.env.ANTHROPIC_API_KEY
? ('anthropic' as const)
: process.env.OPENAI_API_KEY
? ('openai' as const)
: ('none' as const),
apiKey,
model: process.env.ANTHROPIC_API_KEY ? 'claude-3-sonnet-20240229' : undefined,
maxTokens: 4096,
temperature: 0.7,
};
}
}
-288
View File
@@ -1,288 +0,0 @@
import { Command, Option } from 'clipanion';
import { resolve } from 'node:path';
import { promises as fs } from 'fs';
import path from 'path';
import chalk from 'chalk';
import { AuditLogger, type AuditQuery, type AuditEventType } from '@skillkit/core';
export class AuditCommand extends Command {
static override paths = [['audit']];
static override usage = Command.Usage({
description: 'View and manage audit logs',
details: `
The audit command provides access to the audit log system.
All skill operations, team activities, and plugin actions are logged.
Subcommands:
log View recent audit log entries
export Export audit logs to file
stats Show audit statistics
clear Clear old audit entries
`,
examples: [
['View recent logs', '$0 audit log'],
['View logs with filters', '$0 audit log --type skill.install --limit 20'],
['Export logs to JSON', '$0 audit export --format json --output audit.json'],
['Show statistics', '$0 audit stats'],
['Clear logs older than 30 days', '$0 audit clear --days 30'],
],
});
subcommand = Option.String({ required: true });
// Query options
type = Option.Array('--type,-t', {
description: 'Filter by event type',
});
user = Option.String('--user,-u', {
description: 'Filter by user',
});
resource = Option.String('--resource,-r', {
description: 'Filter by resource',
});
success = Option.Boolean('--success', {
description: 'Show only successful operations',
});
failed = Option.Boolean('--failed', {
description: 'Show only failed operations',
});
since = Option.String('--since', {
description: 'Show events since date (ISO 8601)',
});
until = Option.String('--until', {
description: 'Show events until date (ISO 8601)',
});
limit = Option.String('--limit,-l', {
description: 'Maximum number of entries',
});
// Export options
format = Option.String('--format,-f', {
description: 'Export format (json, csv, text)',
});
output = Option.String('--output,-o', {
description: 'Output file path',
});
// Clear options
days = Option.String('--days', {
description: 'Clear entries older than N days',
});
// Common options
json = Option.Boolean('--json,-j', false, {
description: 'Output in JSON format',
});
projectPath = Option.String('--path,-p', {
description: 'Project path (default: current directory)',
});
async execute(): Promise<number> {
const targetPath = resolve(this.projectPath || process.cwd());
const logDir = path.join(targetPath, '.skillkit');
const logger = new AuditLogger(logDir);
try {
switch (this.subcommand) {
case 'log':
case 'list':
return await this.handleLog(logger);
case 'export':
return await this.handleExport(logger);
case 'stats':
return await this.handleStats(logger);
case 'clear':
return await this.handleClear(logger);
default:
console.error(chalk.red(`Unknown subcommand: ${this.subcommand}\n`));
console.log('Valid subcommands: log, export, stats, clear');
return 1;
}
} finally {
await logger.destroy();
}
}
private async handleLog(logger: AuditLogger): Promise<number> {
const query = this.buildQuery();
const events = await logger.query(query);
if (this.json) {
console.log(JSON.stringify(events, null, 2));
return 0;
}
if (events.length === 0) {
console.log(chalk.yellow('No audit events found'));
return 0;
}
console.log(chalk.cyan(`\nAudit Log (${events.length} entries):\n`));
for (const event of events) {
const statusIcon = event.success ? chalk.green('✓') : chalk.red('✗');
const timestamp = event.timestamp.toLocaleString();
console.log(
`${statusIcon} ${chalk.dim(timestamp)} ${chalk.bold(event.type)}`
);
console.log(
` ${event.action} on ${chalk.cyan(event.resource)}`
);
if (event.user) {
console.log(` ${chalk.dim('User:')} ${event.user}`);
}
if (event.duration) {
console.log(` ${chalk.dim('Duration:')} ${event.duration}ms`);
}
if (event.error) {
console.log(` ${chalk.red('Error:')} ${event.error}`);
}
if (event.details && Object.keys(event.details).length > 0) {
console.log(` ${chalk.dim('Details:')} ${JSON.stringify(event.details)}`);
}
console.log();
}
return 0;
}
private async handleExport(logger: AuditLogger): Promise<number> {
const format = (this.format as 'json' | 'csv' | 'text') || 'json';
const query = this.buildQuery();
const content = await logger.export({ format, query });
if (this.output) {
const outputPath = resolve(this.output);
await fs.writeFile(outputPath, content, 'utf-8');
console.log(chalk.green(`✓ Exported audit log to: ${outputPath}`));
} else {
console.log(content);
}
return 0;
}
private async handleStats(logger: AuditLogger): Promise<number> {
const stats = await logger.stats();
if (this.json) {
console.log(JSON.stringify(stats, null, 2));
return 0;
}
console.log(chalk.cyan('\nAudit Statistics:\n'));
console.log(`Total Events: ${chalk.bold(stats.totalEvents.toString())}`);
console.log(
`Success Rate: ${chalk.bold(`${(stats.successRate * 100).toFixed(1)}%`)}`
);
if (Object.keys(stats.eventsByType).length > 0) {
console.log(chalk.cyan('\nEvents by Type:'));
const sorted = Object.entries(stats.eventsByType).sort(
([, a], [, b]) => b - a
);
for (const [type, count] of sorted) {
console.log(` ${type.padEnd(30)} ${count}`);
}
}
if (stats.topResources.length > 0) {
console.log(chalk.cyan('\nTop Resources:'));
for (const { resource, count } of stats.topResources) {
console.log(` ${resource.padEnd(40)} ${count}`);
}
}
if (stats.recentErrors.length > 0) {
console.log(chalk.cyan(`\nRecent Errors (${stats.recentErrors.length}):`));
for (const error of stats.recentErrors.slice(0, 5)) {
const timestamp = error.timestamp.toLocaleString();
console.log(
` ${chalk.red('✗')} ${chalk.dim(timestamp)} ${error.type}`
);
if (error.error) {
console.log(` ${chalk.dim(error.error)}`);
}
}
}
console.log();
return 0;
}
private async handleClear(logger: AuditLogger): Promise<number> {
if (!this.days) {
console.error(chalk.red('--days option required'));
return 1;
}
const daysAgo = parseInt(this.days, 10);
const cutoffDate = new Date();
cutoffDate.setDate(cutoffDate.getDate() - daysAgo);
const cleared = await logger.clear(cutoffDate);
console.log(
chalk.green(
`✓ Cleared ${cleared} audit entries older than ${daysAgo} days`
)
);
return 0;
}
private buildQuery(): AuditQuery {
const query: AuditQuery = {};
if (this.type && this.type.length > 0) {
query.types = this.type as AuditEventType[];
}
if (this.user) {
query.user = this.user;
}
if (this.resource) {
query.resource = this.resource;
}
if (this.success) {
query.success = true;
} else if (this.failed) {
query.success = false;
}
if (this.since) {
query.startDate = new Date(this.since);
}
if (this.until) {
query.endDate = new Date(this.until);
}
if (this.limit) {
query.limit = parseInt(this.limit, 10);
} else {
query.limit = 50;
}
return query;
}
}
-501
View File
@@ -1,501 +0,0 @@
/**
* Command CLI
*
* Manage slash commands and agent integration.
*/
import { Command, Option } from 'clipanion';
import { readFile, writeFile, mkdir } from 'node:fs/promises';
import { resolve, join, dirname, extname } from 'node:path';
import * as path from 'node:path';
import * as fs from 'node:fs/promises';
import { existsSync } from 'node:fs';
import {
createCommandRegistry,
createCommandGenerator,
getAgentFormat,
supportsSlashCommands,
} from '@skillkit/core';
import type { SlashCommand, AgentType } from '@skillkit/core';
export class CommandCmd extends Command {
static paths = [['command']];
static usage = Command.Usage({
category: 'Commands',
description: 'Manage slash commands and agent integration',
details: `
This command provides tools for working with slash commands.
Actions:
- list: List registered commands
- create: Create a new command from a skill
- generate: Generate agent-specific command files
- validate: Validate command definitions
- export: Export commands to a bundle
- import: Import commands from a bundle
Examples:
$ skillkit command list
$ skillkit command create my-skill --name my-command
$ skillkit command generate --agent claude-code
$ skillkit command validate ./commands.json
`,
examples: [
['List all commands', '$0 command list'],
['Create command from skill', '$0 command create tdd --name run-tdd'],
['Generate for Claude Code', '$0 command generate --agent claude-code'],
['Export commands', '$0 command export --output commands.json'],
],
});
action = Option.String({ required: true });
skill = Option.String('--skill,-s', {
description: 'Skill to create command from',
});
name = Option.String('--name,-n', {
description: 'Command name',
});
description = Option.String('--description,-d', {
description: 'Command description',
});
agent = Option.String('--agent,-a', {
description: 'Target agent for generation',
});
output = Option.String('--output,-o', {
description: 'Output file or directory',
});
input = Option.String('--input,-i', {
description: 'Input file',
});
category = Option.String('--category,-c', {
description: 'Command category',
});
all = Option.Boolean('--all', false, {
description: 'Include all commands (hidden and disabled)',
});
json = Option.Boolean('--json', false, {
description: 'Output as JSON',
});
dryRun = Option.Boolean('--dry-run', false, {
description: 'Show what would be generated without writing files',
});
async execute(): Promise<number> {
try {
switch (this.action) {
case 'list':
return await this.listCommands();
case 'create':
return await this.createCommand();
case 'generate':
return await this.generateCommands();
case 'validate':
return await this.validateCommands();
case 'export':
return await this.exportCommands();
case 'import':
return await this.importCommands();
case 'info':
return await this.showInfo();
default:
this.context.stderr.write(
`Unknown action: ${this.action}\n` +
`Available actions: list, create, generate, validate, export, import, info\n`
);
return 1;
}
} catch (error) {
this.context.stderr.write(`Error: ${(error as Error).message}\n`);
return 1;
}
}
private async listCommands(): Promise<number> {
const registry = createCommandRegistry();
// Load commands from local config
await this.loadCommandsFromConfig(registry);
const commands = registry.search({
category: this.category,
includeHidden: this.all,
includeDisabled: this.all,
});
if (this.json) {
this.context.stdout.write(JSON.stringify(commands, null, 2) + '\n');
} else {
if (commands.length === 0) {
this.context.stdout.write('No commands registered.\n');
this.context.stdout.write('Use "skillkit command create" to create commands from skills.\n');
return 0;
}
this.context.stdout.write(`Registered Commands (${commands.length}):\n\n`);
// Group by category
const categories = new Map<string, typeof commands>();
for (const cmd of commands) {
const cat = cmd.category || 'uncategorized';
if (!categories.has(cat)) {
categories.set(cat, []);
}
categories.get(cat)!.push(cmd);
}
for (const [category, cmds] of categories) {
this.context.stdout.write(` ${category.toUpperCase()}\n`);
for (const cmd of cmds) {
const status = cmd.enabled ? '' : ' (disabled)';
const hidden = cmd.hidden ? ' (hidden)' : '';
this.context.stdout.write(` /${cmd.name}${status}${hidden}\n`);
this.context.stdout.write(` ${cmd.description}\n`);
if (cmd.aliases && cmd.aliases.length > 0) {
this.context.stdout.write(` Aliases: ${cmd.aliases.join(', ')}\n`);
}
}
this.context.stdout.write('\n');
}
}
return 0;
}
private async createCommand(): Promise<number> {
if (!this.skill) {
this.context.stderr.write('Error: --skill is required for create action\n');
return 1;
}
const commandName = this.name || this.skill.toLowerCase().replace(/[^a-z0-9]+/g, '-');
const command: SlashCommand = {
name: commandName,
description: this.description || `Execute ${this.skill} skill`,
skill: this.skill,
category: this.category,
examples: [`/${commandName}`],
};
// Save to commands config
const configPath = resolve(process.cwd(), '.skillkit', 'commands.json');
let commands: SlashCommand[] = [];
if (existsSync(configPath)) {
const content = await readFile(configPath, 'utf-8');
const config = JSON.parse(content);
commands = config.commands || [];
}
// Check if command already exists
const existing = commands.findIndex((c) => c.name === commandName);
if (existing >= 0) {
// Merge new properties with existing command to preserve metadata
const previous = commands[existing];
commands[existing] = {
...previous,
name: commandName,
skill: this.skill,
description: this.description ?? previous.description ?? command.description,
category: this.category ?? previous.category,
examples: command.examples?.length ? command.examples : previous.examples,
// Preserve existing metadata if not provided
aliases: previous.aliases,
args: previous.args,
tags: previous.tags,
hidden: previous.hidden,
metadata: previous.metadata,
};
this.context.stdout.write(`Updated command: /${commandName}\n`);
} else {
commands.push(command);
this.context.stdout.write(`Created command: /${commandName}\n`);
}
// Ensure directory exists
await mkdir(dirname(configPath), { recursive: true });
// Save config
await writeFile(
configPath,
JSON.stringify({ version: '1.0.0', commands }, null, 2)
);
this.context.stdout.write(`Saved to: ${configPath}\n`);
return 0;
}
private async generateCommands(): Promise<number> {
const agent = (this.agent || 'claude-code') as AgentType;
if (!supportsSlashCommands(agent)) {
this.context.stdout.write(`Note: ${agent} has limited slash command support.\n`);
}
const registry = createCommandRegistry();
await this.loadCommandsFromConfig(registry);
const commands = registry.getAll(this.all);
if (commands.length === 0) {
this.context.stderr.write('No commands to generate. Create commands first.\n');
return 1;
}
const generator = createCommandGenerator({
includeHidden: this.all,
includeDisabled: this.all,
});
const format = getAgentFormat(agent);
const outputTarget = this.output
? resolve(this.output)
: resolve(process.cwd(), format.directory);
const outputDir = extname(outputTarget) ? dirname(outputTarget) : outputTarget;
const result = generator.generate(commands, agent);
if (typeof result === 'string') {
// Single file output (e.g., Cursor rules)
const extension = format.extension
? format.extension.startsWith('.') ? format.extension : `.${format.extension}`
: '.mdc';
const filePath = extname(outputTarget)
? outputTarget
: join(outputTarget, `commands${extension}`);
if (this.dryRun) {
this.context.stdout.write('Would write to: ' + filePath + '\n\n');
this.context.stdout.write(result);
} else {
await mkdir(dirname(filePath), { recursive: true });
await writeFile(filePath, result);
this.context.stdout.write(`Generated: ${filePath}\n`);
}
} else {
// Multiple file output
if (extname(outputTarget)) {
this.context.stderr.write(
'Error: --output must be a directory for multi-file formats\n'
);
return 1;
}
if (this.dryRun) {
this.context.stdout.write('Would write to: ' + outputDir + '\n\n');
for (const [filename, content] of result) {
this.context.stdout.write(`--- ${filename} ---\n`);
this.context.stdout.write(content.substring(0, 500));
if (content.length > 500) {
this.context.stdout.write('\n... (truncated)\n');
}
this.context.stdout.write('\n');
}
} else {
await mkdir(outputDir, { recursive: true });
for (const [filename, content] of result) {
const filePath = join(outputDir, filename);
await writeFile(filePath, content);
this.context.stdout.write(`Generated: ${filePath}\n`);
}
}
}
// Generate manifest
const manifestPath = join(outputDir, 'manifest.json');
const manifest = generator.generateManifest(commands);
if (!this.dryRun) {
await writeFile(manifestPath, manifest);
this.context.stdout.write(`Generated: ${manifestPath}\n`);
}
this.context.stdout.write(`\nGenerated ${commands.length} commands for ${agent}\n`);
return 0;
}
private async validateCommands(): Promise<number> {
const inputPath = this.input || resolve(process.cwd(), '.skillkit', 'commands.json');
if (!existsSync(inputPath)) {
this.context.stderr.write(`File not found: ${inputPath}\n`);
return 1;
}
const content = await readFile(inputPath, 'utf-8');
const config = JSON.parse(content);
const commands: SlashCommand[] = config.commands || [];
const registry = createCommandRegistry({ validateOnRegister: false });
let valid = 0;
let invalid = 0;
this.context.stdout.write(`Validating ${commands.length} commands...\n\n`);
for (const command of commands) {
const result = registry.validate(command);
if (result.valid) {
valid++;
if (!this.json) {
this.context.stdout.write(`\u2713 /${command.name}\n`);
}
} else {
invalid++;
if (!this.json) {
this.context.stdout.write(`\u2717 /${command.name}\n`);
for (const error of result.errors) {
this.context.stdout.write(` Error: ${error}\n`);
}
}
}
if (!this.json && result.warnings.length > 0) {
for (const warning of result.warnings) {
this.context.stdout.write(` Warning: ${warning}\n`);
}
}
}
if (this.json) {
this.context.stdout.write(
JSON.stringify({
total: commands.length,
valid,
invalid,
}) + '\n'
);
} else {
this.context.stdout.write(`\nValidation complete: ${valid} valid, ${invalid} invalid\n`);
}
return invalid > 0 ? 1 : 0;
}
private async exportCommands(): Promise<number> {
const registry = createCommandRegistry();
await this.loadCommandsFromConfig(registry);
const bundle = registry.export(this.all);
if (this.output) {
let outputPath = resolve(this.output);
// Check if output is a directory or ends with path separator
const stat = await fs.stat(outputPath).catch(() => null);
if ((stat && stat.isDirectory()) || this.output.endsWith(path.sep)) {
outputPath = path.join(outputPath, 'commands.json');
}
// Ensure parent directory exists
await fs.mkdir(path.dirname(outputPath), { recursive: true });
await writeFile(outputPath, JSON.stringify(bundle, null, 2));
this.context.stdout.write(`Exported ${bundle.commands.length} commands to: ${outputPath}\n`);
} else {
this.context.stdout.write(JSON.stringify(bundle, null, 2) + '\n');
}
return 0;
}
private async importCommands(): Promise<number> {
if (!this.input) {
this.context.stderr.write('Error: --input is required for import action\n');
return 1;
}
const inputPath = resolve(this.input);
if (!existsSync(inputPath)) {
this.context.stderr.write(`File not found: ${inputPath}\n`);
return 1;
}
const content = await readFile(inputPath, 'utf-8');
const bundle = JSON.parse(content);
// Load existing commands
const configPath = resolve(process.cwd(), '.skillkit', 'commands.json');
let existingCommands: SlashCommand[] = [];
if (existsSync(configPath)) {
const existingContent = await readFile(configPath, 'utf-8');
const config = JSON.parse(existingContent);
existingCommands = config.commands || [];
}
// Merge commands
const commandMap = new Map<string, SlashCommand>();
for (const cmd of existingCommands) {
commandMap.set(cmd.name, cmd);
}
for (const cmd of bundle.commands) {
commandMap.set(cmd.name, cmd);
}
const mergedCommands = Array.from(commandMap.values());
// Save
await mkdir(dirname(configPath), { recursive: true });
await writeFile(
configPath,
JSON.stringify({ version: '1.0.0', commands: mergedCommands }, null, 2)
);
const imported = bundle.commands.length;
this.context.stdout.write(`Imported ${imported} commands\n`);
this.context.stdout.write(`Total commands: ${mergedCommands.length}\n`);
this.context.stdout.write(`Saved to: ${configPath}\n`);
return 0;
}
private async showInfo(): Promise<number> {
const agent = (this.agent || 'claude-code') as AgentType;
const format = getAgentFormat(agent);
if (this.json) {
this.context.stdout.write(JSON.stringify(format, null, 2) + '\n');
} else {
this.context.stdout.write(`Agent: ${agent}\n`);
this.context.stdout.write(`Directory: ${format.directory}\n`);
this.context.stdout.write(`Extension: ${format.extension}\n`);
this.context.stdout.write(`Supports Slash Commands: ${format.supportsSlashCommands}\n`);
this.context.stdout.write(`Supports Command Files: ${format.supportsCommandFiles}\n`);
}
return 0;
}
private async loadCommandsFromConfig(
registry: ReturnType<typeof createCommandRegistry>
): Promise<void> {
const configPath = resolve(process.cwd(), '.skillkit', 'commands.json');
if (existsSync(configPath)) {
const content = await readFile(configPath, 'utf-8');
const config = JSON.parse(content);
const commands: SlashCommand[] = config.commands || [];
for (const command of commands) {
try {
registry.register(command);
} catch {
// Skip invalid commands
}
}
}
}
}
-282
View File
@@ -1,282 +0,0 @@
/**
* Hook Command
*
* Manage skill hooks for automatic triggering
*/
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
import { createHookManager, type HookEvent, type InjectionMode } from '@skillkit/core';
export class HookCommand extends Command {
static override paths = [['hook']];
static override usage = Command.Usage({
description: 'Manage skill hooks for automatic triggering',
examples: [
['List all hooks', '$0 hook list'],
['Add a session start hook', '$0 hook add session:start tdd-workflow'],
['Add a file save hook with pattern', '$0 hook add file:save code-review --pattern "*.ts"'],
['Remove a hook', '$0 hook remove <hook-id>'],
['Enable a hook', '$0 hook enable <hook-id>'],
['Disable a hook', '$0 hook disable <hook-id>'],
['Generate agent hooks', '$0 hook generate --agent claude-code'],
],
});
action = Option.String({ required: true });
target = Option.String({ required: false });
skill = Option.String({ required: false });
pattern = Option.String('--pattern,-p', { description: 'File pattern matcher' });
agent = Option.String('--agent,-a', { description: 'Target agent for generation' });
inject = Option.String('--inject,-i', { description: 'Injection mode: content, reference, prompt' });
priority = Option.String('--priority', { description: 'Hook priority (higher = earlier)' });
verbose = Option.Boolean('--verbose,-v', { description: 'Show detailed output' });
async execute(): Promise<number> {
const projectPath = process.cwd();
try {
switch (this.action) {
case 'list':
return await this.listHooks(projectPath);
case 'add':
return await this.addHook(projectPath);
case 'remove':
return await this.removeHook(projectPath);
case 'enable':
return await this.enableHook(projectPath);
case 'disable':
return await this.disableHook(projectPath);
case 'generate':
return await this.generateHooks(projectPath);
case 'info':
return await this.showHookInfo(projectPath);
default:
this.context.stderr.write(chalk.red(`Unknown action: ${this.action}\n`));
this.context.stderr.write('Available actions: list, add, remove, enable, disable, generate, info\n');
return 1;
}
} catch (err) {
this.context.stderr.write(chalk.red(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`));
return 1;
}
}
private async listHooks(projectPath: string): Promise<number> {
const manager = createHookManager({ projectPath });
const hooks = manager.getAllHooks();
if (hooks.length === 0) {
this.context.stdout.write('No hooks configured.\n');
this.context.stdout.write(chalk.gray('Run `skillkit hook add <event> <skill>` to add a hook.\n'));
return 0;
}
this.context.stdout.write(chalk.cyan('Configured Hooks:\n\n'));
// Group by event
const eventGroups = new Map<string, typeof hooks>();
for (const hook of hooks) {
const group = eventGroups.get(hook.event) || [];
group.push(hook);
eventGroups.set(hook.event, group);
}
for (const [event, eventHooks] of eventGroups) {
this.context.stdout.write(chalk.yellow(`${event}:\n`));
for (const hook of eventHooks) {
const status = hook.enabled ? chalk.green('●') : chalk.gray('○');
this.context.stdout.write(` ${status} ${chalk.white(hook.id.slice(0, 8))} → ${hook.skills.join(', ')}\n`);
if (hook.matcher) {
this.context.stdout.write(chalk.gray(` Pattern: ${hook.matcher}\n`));
}
if (this.verbose) {
this.context.stdout.write(chalk.gray(` Inject: ${hook.inject}, Priority: ${hook.priority || 0}\n`));
}
}
}
this.context.stdout.write(`\nTotal: ${hooks.length} hooks\n`);
return 0;
}
private async addHook(projectPath: string): Promise<number> {
if (!this.target) {
this.context.stderr.write(chalk.red('Event type required.\n'));
this.context.stderr.write('Usage: skillkit hook add <event> <skill>\n');
this.context.stderr.write('Events: session:start, session:end, file:save, file:open, task:start, commit:pre, commit:post, error:occur, test:fail, build:fail\n');
return 1;
}
if (!this.skill) {
this.context.stderr.write(chalk.red('Skill name required.\n'));
this.context.stderr.write('Usage: skillkit hook add <event> <skill>\n');
return 1;
}
const event = this.target as HookEvent;
const validEvents: HookEvent[] = [
'session:start', 'session:resume', 'session:end',
'file:open', 'file:save', 'file:create', 'file:delete',
'task:start', 'task:complete',
'commit:pre', 'commit:post',
'error:occur', 'test:fail', 'test:pass',
'build:start', 'build:fail', 'build:success',
];
if (!validEvents.includes(event)) {
this.context.stderr.write(chalk.red(`Invalid event: ${this.target}\n`));
this.context.stderr.write(`Valid events: ${validEvents.join(', ')}\n`);
return 1;
}
const manager = createHookManager({ projectPath });
const hook = manager.registerHook({
event,
skills: [this.skill],
inject: (this.inject as InjectionMode) || 'reference',
matcher: this.pattern,
priority: this.priority ? parseInt(this.priority, 10) : 0,
enabled: true,
});
manager.save();
this.context.stdout.write(chalk.green(`✓ Hook added: ${hook.id.slice(0, 8)}\n`));
this.context.stdout.write(` Event: ${event}\n`);
this.context.stdout.write(` Skill: ${this.skill}\n`);
if (this.pattern) {
this.context.stdout.write(` Pattern: ${this.pattern}\n`);
}
return 0;
}
private async removeHook(projectPath: string): Promise<number> {
if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n'));
this.context.stderr.write('Usage: skillkit hook remove <hook-id>\n');
return 1;
}
const manager = createHookManager({ projectPath });
const hooks = manager.getAllHooks();
// Find hook by ID prefix
const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`));
return 1;
}
manager.unregisterHook(hook.id);
manager.save();
this.context.stdout.write(chalk.green(`✓ Hook removed: ${hook.id.slice(0, 8)}\n`));
return 0;
}
private async enableHook(projectPath: string): Promise<number> {
if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n'));
return 1;
}
const manager = createHookManager({ projectPath });
const hooks = manager.getAllHooks();
const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`));
return 1;
}
manager.enableHook(hook.id);
manager.save();
this.context.stdout.write(chalk.green(`✓ Hook enabled: ${hook.id.slice(0, 8)}\n`));
return 0;
}
private async disableHook(projectPath: string): Promise<number> {
if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n'));
return 1;
}
const manager = createHookManager({ projectPath });
const hooks = manager.getAllHooks();
const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`));
return 1;
}
manager.disableHook(hook.id);
manager.save();
this.context.stdout.write(chalk.yellow(`○ Hook disabled: ${hook.id.slice(0, 8)}\n`));
return 0;
}
private async generateHooks(projectPath: string): Promise<number> {
const manager = createHookManager({ projectPath });
const hooks = manager.getAllHooks();
if (hooks.length === 0) {
this.context.stdout.write('No hooks configured to generate.\n');
return 0;
}
const agent = this.agent || 'claude-code';
const generated = manager.generateAgentHooks(agent as any);
this.context.stdout.write(chalk.cyan(`Generated hooks for ${agent}:\n\n`));
if (typeof generated === 'string') {
this.context.stdout.write(generated);
} else {
this.context.stdout.write(JSON.stringify(generated, null, 2));
}
this.context.stdout.write('\n');
return 0;
}
private async showHookInfo(projectPath: string): Promise<number> {
if (!this.target) {
this.context.stderr.write(chalk.red('Hook ID required.\n'));
return 1;
}
const manager = createHookManager({ projectPath });
const hooks = manager.getAllHooks();
const hook = hooks.find((h) => h.id.startsWith(this.target!));
if (!hook) {
this.context.stderr.write(chalk.red(`Hook not found: ${this.target}\n`));
return 1;
}
this.context.stdout.write(chalk.cyan(`\nHook: ${hook.id}\n`));
this.context.stdout.write(`Event: ${hook.event}\n`);
this.context.stdout.write(`Skills: ${hook.skills.join(', ')}\n`);
this.context.stdout.write(`Enabled: ${hook.enabled ? 'Yes' : 'No'}\n`);
this.context.stdout.write(`Inject: ${hook.inject}\n`);
this.context.stdout.write(`Priority: ${hook.priority || 0}\n`);
if (hook.matcher) {
this.context.stdout.write(`Pattern: ${hook.matcher}\n`);
}
if (hook.condition) {
this.context.stdout.write(`Condition: ${hook.condition}\n`);
}
if (hook.agentOverrides) {
this.context.stdout.write(`Agent Overrides: ${Object.keys(hook.agentOverrides).join(', ')}\n`);
}
return 0;
}
}
-15
View File
@@ -25,18 +25,3 @@ export { SettingsCommand } from './settings.js';
export { CICDCommand } from './cicd.js';
export { TeamCommand } from './team.js';
export { PluginCommand } from './plugin.js';
export { MethodologyCommand } from './methodology.js';
export { HookCommand } from './hook.js';
export { PlanCommand } from './plan.js';
export { CommandCmd } from './command.js';
export { AICommand } from './ai.js';
export { AuditCommand } from './audit.js';
export {
AgentCommand,
AgentListCommand,
AgentShowCommand,
AgentCreateCommand,
AgentTranslateCommand,
AgentSyncCommand,
AgentValidateCommand,
} from './agent.js';
-343
View File
@@ -1,343 +0,0 @@
/**
* Methodology Command
*
* Manage methodology packs for AI coding agents
*/
import { Command, Option } from 'clipanion';
import chalk from 'chalk';
import { createMethodologyManager, createMethodologyLoader } from '@skillkit/core';
export class MethodologyCommand extends Command {
static override paths = [['methodology']];
static override usage = Command.Usage({
description: 'Manage methodology packs for AI coding agents',
examples: [
['List available packs', '$0 methodology list'],
['Install all methodology packs', '$0 methodology install'],
['Install specific pack', '$0 methodology install testing'],
['Install specific skill', '$0 methodology install testing/red-green-refactor'],
['Sync methodology skills to agents', '$0 methodology sync'],
['Search methodology skills', '$0 methodology search tdd'],
['Show pack details', '$0 methodology info testing'],
],
});
action = Option.String({ required: true });
target = Option.String({ required: false });
agent = Option.String('--agent,-a', { description: 'Target agent for sync' });
dryRun = Option.Boolean('--dry-run', { description: 'Preview without making changes' });
verbose = Option.Boolean('--verbose,-v', { description: 'Show detailed output' });
async execute(): Promise<number> {
const projectPath = process.cwd();
try {
switch (this.action) {
case 'list':
return await this.listPacks();
case 'install':
return await this.installPacks(projectPath);
case 'uninstall':
return await this.uninstallPack(projectPath);
case 'sync':
return await this.syncSkills(projectPath);
case 'search':
return await this.searchSkills();
case 'info':
return await this.showPackInfo();
case 'installed':
return await this.listInstalled(projectPath);
default:
this.context.stderr.write(chalk.red(`Unknown action: ${this.action}\n`));
this.context.stderr.write('Available actions: list, install, uninstall, sync, search, info, installed\n');
return 1;
}
} catch (err) {
this.context.stderr.write(chalk.red(`✗ ${err instanceof Error ? err.message : 'Unknown error'}\n`));
return 1;
}
}
private async listPacks(): Promise<number> {
const loader = createMethodologyLoader();
const packs = await loader.loadAllPacks();
if (packs.length === 0) {
this.context.stdout.write('No methodology packs available.\n');
return 0;
}
this.context.stdout.write(chalk.cyan('Available Methodology Packs:\n\n'));
for (const pack of packs) {
this.context.stdout.write(chalk.green(` ${pack.name}`) + ` v${pack.version}\n`);
this.context.stdout.write(chalk.gray(` ${pack.description}\n`));
this.context.stdout.write(` Skills: ${pack.skills.join(', ')}\n`);
this.context.stdout.write(` Tags: ${pack.tags.join(', ')}\n`);
this.context.stdout.write('\n');
}
this.context.stdout.write(`Total: ${packs.length} packs\n`);
this.context.stdout.write(chalk.gray('\nRun `skillkit methodology install` to install all packs.\n'));
return 0;
}
private async installPacks(projectPath: string): Promise<number> {
const manager = createMethodologyManager({ projectPath });
const loader = manager.getLoader();
if (this.target) {
// Check if it's a skill ID (pack/skill) or pack name
if (this.target.includes('/')) {
// Install single skill
this.context.stdout.write(`Installing skill: ${chalk.cyan(this.target)}...\n`);
if (this.dryRun) {
this.context.stdout.write(chalk.yellow('[dry-run] Would install skill.\n'));
return 0;
}
const result = await manager.installSkill(this.target);
if (result.success) {
this.context.stdout.write(chalk.green(`✓ Skill installed: ${this.target}\n`));
} else {
for (const failed of result.failed) {
this.context.stderr.write(chalk.red(`✗ ${failed.name}: ${failed.error}\n`));
}
return 1;
}
} else {
// Install single pack
this.context.stdout.write(`Installing pack: ${chalk.cyan(this.target)}...\n`);
if (this.dryRun) {
const pack = await loader.loadPack(this.target);
if (pack) {
this.context.stdout.write(chalk.yellow(`[dry-run] Would install ${pack.skills.length} skills.\n`));
}
return 0;
}
const result = await manager.installPack(this.target);
if (result.success) {
this.context.stdout.write(chalk.green(`✓ Pack "${this.target}" installed!\n`));
this.context.stdout.write(` Installed: ${result.installed.length} skills\n`);
if (result.skipped.length > 0) {
this.context.stdout.write(` Skipped (already installed): ${result.skipped.length}\n`);
}
} else {
this.context.stderr.write(chalk.red(`✗ Failed to install pack\n`));
for (const failed of result.failed) {
this.context.stderr.write(chalk.red(` - ${failed.name}: ${failed.error}\n`));
}
return 1;
}
}
} else {
// Install all packs
this.context.stdout.write('Installing all methodology packs...\n\n');
if (this.dryRun) {
const packs = await loader.loadAllPacks();
let totalSkills = 0;
for (const pack of packs) {
this.context.stdout.write(chalk.yellow(`[dry-run] Would install ${pack.name} (${pack.skills.length} skills)\n`));
totalSkills += pack.skills.length;
}
this.context.stdout.write(chalk.yellow(`\n[dry-run] Would install ${totalSkills} skills total.\n`));
return 0;
}
const result = await manager.installAllPacks();
if (result.success) {
this.context.stdout.write(chalk.green('\n✓ All methodology packs installed!\n'));
this.context.stdout.write(` Installed: ${result.installed.length} skills\n`);
if (result.skipped.length > 0) {
this.context.stdout.write(` Skipped (already installed): ${result.skipped.length}\n`);
}
} else {
this.context.stdout.write(chalk.yellow('\n⚠ Some skills failed to install:\n'));
for (const failed of result.failed) {
this.context.stderr.write(chalk.red(` - ${failed.name}: ${failed.error}\n`));
}
this.context.stdout.write(`\n Installed: ${result.installed.length} skills\n`);
}
}
this.context.stdout.write(chalk.gray('\nRun `skillkit methodology sync` to sync to detected agents.\n'));
return 0;
}
private async uninstallPack(projectPath: string): Promise<number> {
const manager = createMethodologyManager({ projectPath });
if (!this.target) {
this.context.stderr.write(chalk.red('Pack name required for uninstall.\n'));
this.context.stderr.write('Usage: skillkit methodology uninstall <pack-name>\n');
return 1;
}
if (this.dryRun) {
this.context.stdout.write(chalk.yellow(`[dry-run] Would uninstall pack: ${this.target}\n`));
return 0;
}
await manager.uninstallPack(this.target);
this.context.stdout.write(chalk.green(`✓ Pack "${this.target}" uninstalled.\n`));
return 0;
}
private async syncSkills(projectPath: string): Promise<number> {
const manager = createMethodologyManager({ projectPath, autoSync: false });
this.context.stdout.write('Syncing methodology skills to detected agents...\n\n');
if (this.dryRun) {
const installed = manager.listInstalledSkills();
this.context.stdout.write(chalk.yellow(`[dry-run] Would sync ${installed.length} skills.\n`));
return 0;
}
const result = await manager.syncAll();
if (result.synced.length > 0) {
this.context.stdout.write(chalk.green('✓ Sync complete!\n'));
for (const sync of result.synced) {
this.context.stdout.write(` ${sync.skill} → ${sync.agents.join(', ')}\n`);
}
}
if (result.failed.length > 0) {
this.context.stdout.write(chalk.yellow('\n⚠ Some syncs failed:\n'));
for (const fail of result.failed) {
this.context.stderr.write(chalk.red(` ${fail.skill} (${fail.agent}): ${fail.error}\n`));
}
}
if (result.synced.length === 0 && result.failed.length === 0) {
this.context.stdout.write('No installed skills to sync. Run `skillkit methodology install` first.\n');
}
return result.success ? 0 : 1;
}
private async searchSkills(): Promise<number> {
const loader = createMethodologyLoader();
if (!this.target) {
this.context.stderr.write(chalk.red('Search query required.\n'));
this.context.stderr.write('Usage: skillkit methodology search <query>\n');
return 1;
}
const skills = await loader.searchSkills(this.target);
if (skills.length === 0) {
this.context.stdout.write(`No skills found matching "${this.target}".\n`);
return 0;
}
this.context.stdout.write(chalk.cyan(`Found ${skills.length} skills matching "${this.target}":\n\n`));
for (const skill of skills) {
this.context.stdout.write(chalk.green(` ${skill.id}`) + ` v${skill.version}\n`);
this.context.stdout.write(chalk.gray(` ${skill.description || 'No description'}\n`));
if (skill.tags.length > 0) {
this.context.stdout.write(` Tags: ${skill.tags.join(', ')}\n`);
}
if (this.verbose && skill.metadata.triggers) {
this.context.stdout.write(` Triggers: ${skill.metadata.triggers.join(', ')}\n`);
}
this.context.stdout.write('\n');
}
return 0;
}
private async showPackInfo(): Promise<number> {
const loader = createMethodologyLoader();
if (!this.target) {
this.context.stderr.write(chalk.red('Pack name required.\n'));
this.context.stderr.write('Usage: skillkit methodology info <pack-name>\n');
return 1;
}
const pack = await loader.loadPack(this.target);
if (!pack) {
this.context.stderr.write(chalk.red(`Pack not found: ${this.target}\n`));
return 1;
}
this.context.stdout.write(chalk.cyan(`\nPack: ${pack.name}\n`));
this.context.stdout.write(`Version: ${pack.version}\n`);
this.context.stdout.write(`Description: ${pack.description}\n`);
this.context.stdout.write(`Tags: ${pack.tags.join(', ')}\n`);
this.context.stdout.write(`Author: ${pack.author || 'Unknown'}\n`);
this.context.stdout.write(`License: ${pack.license || 'Unknown'}\n`);
this.context.stdout.write(`Compatibility: ${pack.compatibility.join(', ')}\n`);
this.context.stdout.write(chalk.cyan(`\nSkills (${pack.skills.length}):\n`));
const skills = await loader.loadPackSkills(this.target);
for (const skill of skills) {
this.context.stdout.write(chalk.green(` ${skill.id.split('/')[1]}\n`));
this.context.stdout.write(chalk.gray(` ${skill.description || 'No description'}\n`));
if (this.verbose) {
if (skill.metadata.triggers) {
this.context.stdout.write(` Triggers: ${skill.metadata.triggers.join(', ')}\n`);
}
if (skill.metadata.difficulty) {
this.context.stdout.write(` Difficulty: ${skill.metadata.difficulty}\n`);
}
if (skill.metadata.estimatedTime) {
this.context.stdout.write(` Est. Time: ${skill.metadata.estimatedTime} min\n`);
}
}
}
this.context.stdout.write(chalk.gray(`\nRun \`skillkit methodology install ${this.target}\` to install this pack.\n`));
return 0;
}
private async listInstalled(projectPath: string): Promise<number> {
const manager = createMethodologyManager({ projectPath });
const installedPacks = manager.listInstalledPacks();
const installedSkills = manager.listInstalledSkills();
if (installedPacks.length === 0 && installedSkills.length === 0) {
this.context.stdout.write('No methodology skills installed.\n');
this.context.stdout.write(chalk.gray('Run `skillkit methodology install` to install methodology packs.\n'));
return 0;
}
if (installedPacks.length > 0) {
this.context.stdout.write(chalk.cyan('Installed Packs:\n'));
for (const pack of installedPacks) {
this.context.stdout.write(chalk.green(` ${pack.name}`) + ` v${pack.version}\n`);
this.context.stdout.write(` Skills: ${pack.skills.length}\n`);
}
this.context.stdout.write('\n');
}
if (installedSkills.length > 0) {
this.context.stdout.write(chalk.cyan('Installed Skills:\n'));
for (const skill of installedSkills) {
const syncStatus = skill.syncedAgents.length > 0
? chalk.green(`synced to ${skill.syncedAgents.length} agents`)
: chalk.yellow('not synced');
this.context.stdout.write(` ${chalk.green(skill.id)} v${skill.version} [${syncStatus}]\n`);
}
}
this.context.stdout.write(chalk.gray(`\nTotal: ${installedSkills.length} skills installed.\n`));
return 0;
}
}
-388
View File
@@ -1,388 +0,0 @@
/**
* Plan Command
*
* Manage structured development plans.
* Parse, validate, execute, and generate plans.
*/
import { Command, Option } from 'clipanion';
import { readFile, writeFile } from 'node:fs/promises';
import { resolve } from 'node:path';
import {
createPlanParser,
createPlanValidator,
createPlanGenerator,
createPlanExecutor,
dryRunExecutor,
shellExecutor,
TASK_TEMPLATES,
} from '@skillkit/core';
export class PlanCommand extends Command {
static paths = [['plan']];
static usage = Command.Usage({
category: 'Development',
description: 'Manage structured development plans',
details: `
This command provides tools for working with structured development plans.
Actions:
- parse: Parse a markdown plan to structured format
- validate: Validate a plan for completeness
- execute: Execute a plan (with optional dry-run)
- generate: Generate a plan from task list
- templates: List available task templates
- create: Create a new empty plan
Examples:
$ skillkit plan parse ./plan.md
$ skillkit plan validate ./plan.md
$ skillkit plan execute ./plan.md --dry-run
$ skillkit plan generate "Add auth" --tasks "Setup,Login,Logout"
$ skillkit plan templates
`,
examples: [
['Parse a markdown plan', '$0 plan parse ./development-plan.md'],
['Validate a plan', '$0 plan validate ./plan.md --strict'],
['Dry-run execute a plan', '$0 plan execute ./plan.md --dry-run'],
['List task templates', '$0 plan templates'],
],
});
action = Option.String({ required: true });
file = Option.String('--file,-f', {
description: 'Plan file path',
});
output = Option.String('--output,-o', {
description: 'Output file path',
});
name = Option.String('--name,-n', {
description: 'Plan name',
});
goal = Option.String('--goal,-g', {
description: 'Plan goal',
});
tasks = Option.String('--tasks,-t', {
description: 'Comma-separated list of task names',
});
template = Option.String('--template', {
description: 'Task template to use',
});
techStack = Option.String('--tech-stack', {
description: 'Comma-separated tech stack',
});
dryRun = Option.Boolean('--dry-run', false, {
description: 'Dry run execution (no actual changes)',
});
strict = Option.Boolean('--strict', false, {
description: 'Strict validation (treat warnings as errors)',
});
stopOnError = Option.Boolean('--stop-on-error', true, {
description: 'Stop execution on first error',
});
verbose = Option.Boolean('--verbose,-v', false, {
description: 'Verbose output',
});
json = Option.Boolean('--json', false, {
description: 'Output as JSON',
});
async execute(): Promise<number> {
try {
switch (this.action) {
case 'parse':
return await this.parsePlan();
case 'validate':
return await this.validatePlan();
case 'execute':
return await this.executePlan();
case 'generate':
return await this.generatePlan();
case 'templates':
return await this.listTemplates();
case 'create':
return await this.createPlan();
default:
this.context.stderr.write(
`Unknown action: ${this.action}\n` +
`Available actions: parse, validate, execute, generate, templates, create\n`
);
return 1;
}
} catch (error) {
this.context.stderr.write(`Error: ${(error as Error).message}\n`);
return 1;
}
}
private async parsePlan(): Promise<number> {
if (!this.file) {
this.context.stderr.write('Error: --file is required for parse action\n');
return 1;
}
const filePath = resolve(this.file);
const content = await readFile(filePath, 'utf-8');
const parser = createPlanParser();
const plan = parser.parse(content);
if (this.json) {
this.context.stdout.write(JSON.stringify(plan, null, 2) + '\n');
} else {
this.context.stdout.write(`Plan: ${plan.name}\n`);
this.context.stdout.write(`Goal: ${plan.goal}\n`);
this.context.stdout.write(`Status: ${plan.status}\n`);
this.context.stdout.write(`Tasks: ${plan.tasks.length}\n\n`);
for (const task of plan.tasks) {
this.context.stdout.write(` Task ${task.id}: ${task.name}\n`);
this.context.stdout.write(` Steps: ${task.steps.length}\n`);
if (task.estimatedMinutes) {
this.context.stdout.write(` Estimated: ${task.estimatedMinutes} min\n`);
}
}
}
if (this.output) {
const outputPath = resolve(this.output);
await writeFile(outputPath, JSON.stringify(plan, null, 2));
this.context.stdout.write(`\nSaved to: ${outputPath}\n`);
}
return 0;
}
private async validatePlan(): Promise<number> {
if (!this.file) {
this.context.stderr.write('Error: --file is required for validate action\n');
return 1;
}
const filePath = resolve(this.file);
const content = await readFile(filePath, 'utf-8');
const parser = createPlanParser();
const plan = parser.parse(content);
const validator = createPlanValidator({ strict: this.strict });
const result = validator.validate(plan);
if (this.json) {
this.context.stdout.write(JSON.stringify(result, null, 2) + '\n');
} else {
this.context.stdout.write(`Validation: ${result.valid ? 'PASSED' : 'FAILED'}\n\n`);
this.context.stdout.write(`Statistics:\n`);
this.context.stdout.write(` Total tasks: ${result.stats.totalTasks}\n`);
this.context.stdout.write(` Total steps: ${result.stats.totalSteps}\n`);
this.context.stdout.write(` Estimated time: ${result.stats.estimatedMinutes} minutes\n`);
this.context.stdout.write(` Tasks with tests: ${result.stats.tasksWithTests}\n`);
this.context.stdout.write(` Avg steps/task: ${result.stats.avgStepsPerTask}\n\n`);
if (result.issues.length > 0) {
this.context.stdout.write(`Issues:\n`);
for (const issue of result.issues) {
const icon =
issue.type === 'error' ? '\u274C' : issue.type === 'warning' ? '\u26A0\uFE0F' : '\u2139\uFE0F';
const location = issue.taskId ? `Task ${issue.taskId}` : 'Plan';
this.context.stdout.write(` ${icon} [${location}] ${issue.message}\n`);
if (issue.suggestion && this.verbose) {
this.context.stdout.write(` Suggestion: ${issue.suggestion}\n`);
}
}
} else {
this.context.stdout.write('No issues found.\n');
}
}
return result.valid ? 0 : 1;
}
private async executePlan(): Promise<number> {
if (!this.file) {
this.context.stderr.write('Error: --file is required for execute action\n');
return 1;
}
const filePath = resolve(this.file);
const content = await readFile(filePath, 'utf-8');
const parser = createPlanParser();
const plan = parser.parse(content);
// Validate first
const validator = createPlanValidator({ strict: this.strict });
const validation = validator.validate(plan);
if (!validation.valid) {
this.context.stderr.write('Plan validation failed. Fix errors before executing.\n');
for (const issue of validation.issues.filter((i) => i.type === 'error')) {
this.context.stderr.write(` \u274C ${issue.message}\n`);
}
return 1;
}
// Create executor
const executor = createPlanExecutor({
stepExecutor: this.dryRun ? dryRunExecutor : shellExecutor,
});
// Add progress listener
executor.addListener((event, _plan, task) => {
if (this.verbose) {
if (event === 'plan:task_started' && task) {
this.context.stdout.write(`Starting task ${task.id}: ${task.name}\n`);
} else if (event === 'plan:task_completed' && task) {
this.context.stdout.write(`Completed task ${task.id}: ${task.name}\n`);
} else if (event === 'plan:task_failed' && task) {
this.context.stderr.write(`Failed task ${task.id}: ${task.name}\n`);
}
}
});
this.context.stdout.write(`Executing plan: ${plan.name}\n`);
if (this.dryRun) {
this.context.stdout.write('(Dry run mode - no actual changes)\n');
}
this.context.stdout.write('\n');
const result = await executor.execute(plan, {
dryRun: this.dryRun,
stopOnError: this.stopOnError,
onProgress: (taskId, step, status) => {
if (this.verbose) {
this.context.stdout.write(` Task ${taskId}, Step ${step}: ${status}\n`);
}
},
});
this.context.stdout.write('\n');
if (this.json) {
this.context.stdout.write(
JSON.stringify(
{
...result,
taskResults: Object.fromEntries(result.taskResults),
},
null,
2
) + '\n'
);
} else {
this.context.stdout.write(`Execution: ${result.success ? 'SUCCESS' : 'FAILED'}\n`);
this.context.stdout.write(`Duration: ${result.durationMs}ms\n`);
this.context.stdout.write(`Completed: ${result.completedTasks.length} tasks\n`);
this.context.stdout.write(`Failed: ${result.failedTasks.length} tasks\n`);
this.context.stdout.write(`Skipped: ${result.skippedTasks.length} tasks\n`);
if (result.errors && result.errors.length > 0) {
this.context.stdout.write('\nErrors:\n');
for (const error of result.errors) {
this.context.stderr.write(` - ${error}\n`);
}
}
}
return result.success ? 0 : 1;
}
private async generatePlan(): Promise<number> {
if (!this.name) {
this.context.stderr.write('Error: --name is required for generate action\n');
return 1;
}
const generator = createPlanGenerator({
includeTests: true,
includeCommits: true,
techStack: this.techStack?.split(',').map((s) => s.trim()).filter((s) => s !== ''),
});
let plan;
if (this.tasks) {
const taskNames = this.tasks.split(',').map((s) => s.trim()).filter((s) => s !== '');
plan = generator.fromTaskList(this.name, this.goal || 'Complete the tasks', taskNames, {
template: this.template as keyof typeof TASK_TEMPLATES,
techStack: this.techStack?.split(',').map((s) => s.trim()).filter((s) => s !== ''),
});
} else {
plan = generator.createPlan(this.name, this.goal || 'Complete the project');
if (this.techStack) {
plan.techStack = this.techStack.split(',').map((s) => s.trim()).filter((s) => s !== '');
}
}
const markdown = generator.toMarkdown(plan);
if (this.output) {
const outputPath = resolve(this.output);
await writeFile(outputPath, markdown);
this.context.stdout.write(`Plan saved to: ${outputPath}\n`);
} else if (this.json) {
this.context.stdout.write(JSON.stringify(plan, null, 2) + '\n');
} else {
this.context.stdout.write(markdown);
}
return 0;
}
private async listTemplates(): Promise<number> {
if (this.json) {
this.context.stdout.write(JSON.stringify(TASK_TEMPLATES, null, 2) + '\n');
} else {
this.context.stdout.write('Available Task Templates:\n\n');
for (const [name, template] of Object.entries(TASK_TEMPLATES)) {
this.context.stdout.write(` ${name}\n`);
this.context.stdout.write(` ${template.description}\n`);
this.context.stdout.write(` Steps: ${template.steps.length}\n`);
this.context.stdout.write(` Estimated: ${template.estimatedMinutes} min\n\n`);
}
}
return 0;
}
private async createPlan(): Promise<number> {
if (!this.name) {
this.context.stderr.write('Error: --name is required for create action\n');
return 1;
}
const generator = createPlanGenerator({
includeTests: true,
includeCommits: true,
});
const plan = generator.createPlan(this.name, this.goal || 'Complete the project');
if (this.techStack) {
plan.techStack = this.techStack.split(',').map((s) => s.trim()).filter((s) => s !== '');
}
const markdown = generator.toMarkdown(plan);
const outputPath = this.output || resolve(`${this.name.toLowerCase().replace(/\s+/g, '-')}-plan.md`);
await writeFile(outputPath, markdown);
this.context.stdout.write(`Plan created: ${outputPath}\n`);
return 0;
}
}
-121
View File
@@ -21,12 +21,6 @@ npm install @skillkit/core
- **Skill Testing**: Test framework with assertions for skill validation
- **Workflow Orchestration**: Compose skills into multi-step workflows
- **Marketplace Aggregation**: Browse and search curated skill repositories
- **Team Collaboration**: Share skill bundles with Git-based remote sync
- **Plugin System**: Extend with custom translators, providers, and commands
- **Methodologies**: 5 development frameworks (Agile, TDD, DevOps, Design Thinking, Feature Flags)
- **Multi-Agent Orchestration**: Coordinate teams of AI agents with task assignment
- **Plan System**: Parse, validate, and execute structured development plans
- **Hooks & Automation**: Auto-trigger skills on file changes, git events
## Usage
@@ -161,121 +155,6 @@ const filtered = await marketplace.search({
});
```
### Team Collaboration
```typescript
import { TeamManager, SkillBundle } from '@skillkit/core';
// Initialize team
const teamManager = new TeamManager('./my-project');
await teamManager.init('Engineering Team');
// Create skill bundle
const bundle = await teamManager.createBundle('onboarding', {
skills: ['git-workflow', 'code-review'],
description: 'New developer onboarding',
});
// Share bundle
await teamManager.shareBundle(bundle);
// Sync with remote registry
await teamManager.syncWithRemote('https://github.com/myorg/skills');
```
### Plugin System
```typescript
import { PluginManager, TranslatorPlugin } from '@skillkit/core';
// Load plugins
const pluginManager = new PluginManager('./my-project');
await pluginManager.loadAll();
// Install plugin
await pluginManager.install('custom-translator');
// Create custom plugin
const myPlugin: TranslatorPlugin = {
name: 'my-agent',
parse: async (content) => ({ /* canonical skill */ }),
generate: async (skill) => '/* custom format */',
};
```
### Methodologies
```typescript
import { MethodologyManager } from '@skillkit/core';
// List available methodologies
const methodologies = await MethodologyManager.list();
// Load methodology
const tdd = await MethodologyManager.load('tdd');
// Returns: { name: 'TDD', skills: ['red-green-refactor', 'test-first'], ... }
```
### Multi-Agent Orchestration
```typescript
import { TeamOrchestrator, TaskManager } from '@skillkit/core';
// Create agent team
const orchestrator = new TeamOrchestrator();
const team = await orchestrator.createTeam({
name: 'feature-dev',
leader: { id: 'architect', name: 'System Architect' },
teammates: [
{ id: 'frontend', name: 'Frontend Dev', capabilities: ['react'] },
{ id: 'backend', name: 'Backend Dev', capabilities: ['api'] },
],
});
// Manage tasks
const taskManager = new TaskManager();
const task = taskManager.createTask('Build login', 'Create login endpoint', spec);
await taskManager.assignTask(task.id, 'backend');
// Get stats
const stats = taskManager.getStats();
```
### Plan System
```typescript
import { PlanParser, PlanValidator, PlanExecutor } from '@skillkit/core';
// Parse plan from markdown
const parser = new PlanParser();
const plan = await parser.parseFile('./plan.md');
// Validate plan
const validator = new PlanValidator();
const validation = validator.validate(plan);
// Execute plan
const executor = new PlanExecutor();
const result = await executor.execute(plan, { dryRun: false });
```
### Hooks & Automation
```typescript
import { HookRegistry } from '@skillkit/core';
// Register hooks
const hooks = new HookRegistry('./my-project');
await hooks.register('pre-commit', {
event: 'pre-commit',
skill: 'code-review',
enabled: true,
});
// Trigger hook
await hooks.trigger('pre-commit', { files: ['src/index.ts'] });
```
## Supported Agents
The translator supports all 17 SkillKit-compatible agents:
+2 -6
View File
@@ -1,6 +1,6 @@
{
"name": "@skillkit/core",
"version": "1.6.4",
"version": "1.4.0",
"description": "Core functionality for SkillKit - skill discovery, parsing, and translation",
"type": "module",
"main": "./dist/index.js",
@@ -35,9 +35,7 @@
"types": "./dist/recommend/index.d.ts"
}
},
"files": [
"dist"
],
"files": ["dist"],
"scripts": {
"build": "tsup",
"dev": "tsup --watch",
@@ -45,8 +43,6 @@
"test": "vitest run"
},
"dependencies": {
"@types/minimatch": "^6.0.0",
"minimatch": "^10.1.1",
"yaml": "^2.6.1",
"zod": "^3.24.1"
},
@@ -1,432 +0,0 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import {
AGENT_SKILL_FORMATS,
parseSkillToCanonical,
parseSkillContentToCanonical,
translateSkillToAgent,
translateSkillToAll,
writeTranslatedSkill,
generateSkillsConfig,
getAgentSkillsDir,
getAgentConfigFile,
supportsAutoDiscovery,
getAllSkillsDirs,
getGlobalSkillsDir,
type CrossAgentSkill,
type SkillTranslationOptions,
} from '../skill-translator.js';
describe('Skill Translator', () => {
let tempDir: string;
beforeEach(() => {
tempDir = join(tmpdir(), `skillkit-test-${Date.now()}`);
mkdirSync(tempDir, { recursive: true });
});
afterEach(() => {
if (existsSync(tempDir)) {
rmSync(tempDir, { recursive: true, force: true });
}
});
describe('AGENT_SKILL_FORMATS', () => {
it('should have configurations for all supported agents', () => {
const expectedAgents = [
'claude-code', 'cursor', 'codex', 'gemini-cli', 'opencode',
'antigravity', 'amp', 'clawdbot', 'droid', 'github-copilot',
'goose', 'kilo', 'kiro-cli', 'roo', 'trae', 'windsurf', 'universal',
];
for (const agent of expectedAgents) {
expect(AGENT_SKILL_FORMATS[agent as keyof typeof AGENT_SKILL_FORMATS]).toBeDefined();
}
});
it('should have valid skillsDir for each agent', () => {
for (const [agent, format] of Object.entries(AGENT_SKILL_FORMATS)) {
expect(format.skillsDir).toBeTruthy();
expect(typeof format.skillsDir).toBe('string');
}
});
it('should have valid configFile for each agent', () => {
for (const [agent, format] of Object.entries(AGENT_SKILL_FORMATS)) {
expect(format.configFile).toBeTruthy();
expect(typeof format.configFile).toBe('string');
}
});
it('should have correct Cursor MDC format', () => {
const cursor = AGENT_SKILL_FORMATS.cursor;
expect(cursor.skillsDir).toBe('.cursor/skills');
expect(cursor.configFile).toBe('.cursor/rules/skills.mdc');
expect(cursor.configFormat).toBe('mdc');
});
it('should have correct Windsurf format', () => {
const windsurf = AGENT_SKILL_FORMATS.windsurf;
expect(windsurf.skillsDir).toBe('.windsurf/skills');
expect(windsurf.configFile).toBe('.windsurf/rules/skills.md');
expect(windsurf.configFormat).toBe('markdown');
expect(windsurf.globalSkillsDir).toBe('~/.codeium/windsurf/skills');
});
it('should have correct GitHub Copilot format', () => {
const copilot = AGENT_SKILL_FORMATS['github-copilot'];
expect(copilot.skillsDir).toBe('.github/skills');
expect(copilot.configFile).toBe('.github/copilot-instructions.md');
expect(copilot.configFormat).toBe('markdown');
});
});
describe('parseSkillToCanonical', () => {
it('should parse a valid SKILL.md file', () => {
const skillDir = join(tempDir, 'test-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: test-skill
description: A test skill for unit testing
version: "1.0.0"
author: Test Author
tags:
- testing
- unit-test
---
# Test Skill
This is a test skill for unit testing purposes.
## Usage
Use this skill when you need to test something.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.name).toBe('test-skill');
expect(result?.description).toBe('A test skill for unit testing');
expect(result?.version).toBe('1.0.0');
expect(result?.author).toBe('Test Author');
expect(result?.tags).toEqual(['testing', 'unit-test']);
expect(result?.content).toContain('# Test Skill');
});
it('should return null for non-existent skill', () => {
const result = parseSkillToCanonical(join(tempDir, 'non-existent'));
expect(result).toBeNull();
});
it('should handle SKILL.md without frontmatter', () => {
const skillDir = join(tempDir, 'no-frontmatter-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `# Simple Skill
Just some content without frontmatter.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
// Without frontmatter, name is derived from directory name
expect(result?.name).toBe('no-frontmatter-skill');
});
it('should extract allowed-tools from frontmatter', () => {
const skillDir = join(tempDir, 'tools-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: tools-skill
description: Skill with allowed tools
allowed-tools: Read, Write, Bash
---
Content here.
`);
const result = parseSkillToCanonical(skillDir);
expect(result?.allowedTools).toEqual(['Read', 'Write', 'Bash']);
});
});
describe('parseSkillContentToCanonical', () => {
it('should parse skill content with full frontmatter', () => {
const content = `---
name: content-skill
description: Parsed from content
model: opus
context: fork
disable-model-invocation: true
---
# Content Skill
Instructions here.
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill', 'claude-code');
expect(result?.name).toBe('content-skill');
expect(result?.description).toBe('Parsed from content');
expect(result?.agentFields?.['model']).toBe('opus');
expect(result?.agentFields?.['context']).toBe('fork');
expect(result?.agentFields?.['disable-model-invocation']).toBe(true);
expect(result?.sourceAgent).toBe('claude-code');
});
it('should extract description from content when not in frontmatter', () => {
const content = `---
name: no-desc
---
This is a longer paragraph that should be used as the description when none is provided in frontmatter.
## More Content
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill');
expect(result?.description).toContain('This is a longer paragraph');
});
});
describe('translateSkillToAgent', () => {
const testSkill: CrossAgentSkill = {
name: 'translate-test',
description: 'A skill to test translation',
content: '# Translate Test\n\nTest content for translation.',
frontmatter: { name: 'translate-test', description: 'A skill to test translation' },
sourcePath: '/test/path',
sourceAgent: 'claude-code',
version: '1.0.0',
author: 'Test',
tags: ['test'],
};
it('should translate to Claude Code format', () => {
const result = translateSkillToAgent(testSkill, 'claude-code');
expect(result.success).toBe(true);
expect(result.content).toContain('name: translate-test');
expect(result.content).toContain('description: A skill to test translation');
expect(result.targetAgent).toBe('claude-code');
});
it('should translate to Cursor format', () => {
const result = translateSkillToAgent(testSkill, 'cursor');
expect(result.success).toBe(true);
expect(result.content).toContain('name: translate-test');
expect(result.targetAgent).toBe('cursor');
});
it('should translate to Windsurf format', () => {
const result = translateSkillToAgent(testSkill, 'windsurf');
expect(result.success).toBe(true);
expect(result.targetAgent).toBe('windsurf');
});
it('should include translation metadata when requested', () => {
const options: SkillTranslationOptions = { addMetadata: true };
const result = translateSkillToAgent(testSkill, 'cursor', options);
expect(result.content).toContain('_translated-from: claude-code');
expect(result.content).toContain('_translated-at:');
});
it('should preserve agent-specific fields for Claude Code', () => {
const skillWithFields: CrossAgentSkill = {
...testSkill,
agentFields: {
model: 'opus',
context: 'fork',
'disable-model-invocation': true,
},
};
const result = translateSkillToAgent(skillWithFields, 'claude-code');
expect(result.content).toContain('model: opus');
expect(result.content).toContain('context: fork');
expect(result.content).toContain('disable-model-invocation: true');
});
it('should report incompatible features', () => {
const skillWithHooks: CrossAgentSkill = {
...testSkill,
agentFields: {
hooks: [{ type: 'PreToolUse', command: 'echo test' }],
},
};
const result = translateSkillToAgent(skillWithHooks, 'cursor');
expect(result.incompatible).toContain('hooks (only supported in Claude Code)');
});
});
describe('translateSkillToAll', () => {
it('should translate skill to all supported agents', () => {
const skillDir = join(tempDir, 'all-agents-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: all-agents
description: Skill for all agents
---
# All Agents Skill
`);
const results = translateSkillToAll(skillDir, 'claude-code');
expect(results.size).toBeGreaterThan(0);
// Should not include source agent
expect(results.has('claude-code')).toBe(false);
// Should include other agents
expect(results.has('cursor')).toBe(true);
expect(results.has('windsurf')).toBe(true);
});
it('should return empty map for non-existent skill', () => {
const results = translateSkillToAll(join(tempDir, 'non-existent'));
expect(results.size).toBe(0);
});
});
describe('writeTranslatedSkill', () => {
it('should write translated skill to disk', () => {
const result = {
success: true,
content: '---\nname: written-skill\n---\n# Content',
filename: 'SKILL.md',
targetDir: 'test-skill',
warnings: [],
incompatible: [],
targetAgent: 'claude-code' as const,
};
const writeResult = writeTranslatedSkill(result, tempDir);
expect(writeResult.success).toBe(true);
expect(existsSync(writeResult.path)).toBe(true);
});
it('should create nested directories', () => {
const result = {
success: true,
content: '---\nname: nested\n---\n# Content',
filename: 'SKILL.md',
targetDir: '.cursor/skills/nested-skill',
warnings: [],
incompatible: [],
targetAgent: 'cursor' as const,
};
const writeResult = writeTranslatedSkill(result, tempDir);
expect(writeResult.success).toBe(true);
expect(existsSync(join(tempDir, '.cursor/skills/nested-skill/SKILL.md'))).toBe(true);
});
});
describe('generateSkillsConfig', () => {
const testSkills = [
{ name: 'skill-one', description: 'First skill', path: '/path/one', location: 'project' as const, enabled: true },
{ name: 'skill-two', description: 'Second skill', path: '/path/two', location: 'project' as const, enabled: true },
{ name: 'disabled-skill', description: 'Disabled', path: '/path/disabled', location: 'project' as const, enabled: false },
];
it('should generate XML config for Claude Code', () => {
const config = generateSkillsConfig(testSkills, 'claude-code');
expect(config).toContain('<skills_system');
expect(config).toContain('<name>skill-one</name>');
expect(config).toContain('<name>skill-two</name>');
expect(config).not.toContain('disabled-skill');
});
it('should generate MDC config for Cursor', () => {
const config = generateSkillsConfig(testSkills, 'cursor');
expect(config).toContain('---');
expect(config).toContain('description:');
expect(config).toContain('globs:');
expect(config).toContain('alwaysApply: true');
expect(config).toContain('**skill-one**');
expect(config).toContain('**skill-two**');
});
it('should generate Markdown table config for Codex', () => {
const config = generateSkillsConfig(testSkills, 'codex');
expect(config).toContain('| Skill | Description | Command |');
expect(config).toContain('| skill-one |');
expect(config).toContain('| skill-two |');
});
it('should generate JSON config for Gemini CLI', () => {
const config = generateSkillsConfig(testSkills, 'gemini-cli');
expect(config).toContain('```json');
expect(config).toContain('"name": "skill-one"');
expect(config).toContain('"name": "skill-two"');
});
it('should generate Markdown config for Windsurf', () => {
const config = generateSkillsConfig(testSkills, 'windsurf');
expect(config).toContain('### skill-one');
expect(config).toContain('### skill-two');
expect(config).toContain('**Invoke:**');
});
it('should return empty string for no enabled skills', () => {
const disabledSkills = [
{ name: 'disabled', description: 'Disabled', path: '/path', location: 'project' as const, enabled: false },
];
const config = generateSkillsConfig(disabledSkills, 'claude-code');
expect(config).toBe('');
});
});
describe('utility functions', () => {
it('getAgentSkillsDir should return correct path', () => {
expect(getAgentSkillsDir('claude-code')).toBe('.claude/skills');
expect(getAgentSkillsDir('cursor')).toBe('.cursor/skills');
expect(getAgentSkillsDir('windsurf')).toBe('.windsurf/skills');
});
it('getAgentConfigFile should return correct path', () => {
expect(getAgentConfigFile('claude-code')).toBe('CLAUDE.md');
expect(getAgentConfigFile('cursor')).toBe('.cursor/rules/skills.mdc');
expect(getAgentConfigFile('github-copilot')).toBe('.github/copilot-instructions.md');
});
it('supportsAutoDiscovery should return true for all major agents', () => {
expect(supportsAutoDiscovery('claude-code')).toBe(true);
expect(supportsAutoDiscovery('cursor')).toBe(true);
expect(supportsAutoDiscovery('windsurf')).toBe(true);
});
it('getAllSkillsDirs should include alternative directories', () => {
const cursorDirs = getAllSkillsDirs('cursor');
expect(cursorDirs).toContain('.cursor/skills');
expect(cursorDirs).toContain('.cursor/commands');
const windsurfDirs = getAllSkillsDirs('windsurf');
expect(windsurfDirs).toContain('.windsurf/skills');
expect(windsurfDirs).toContain('.windsurf/workflows');
});
it('getGlobalSkillsDir should return correct global path', () => {
expect(getGlobalSkillsDir('claude-code')).toBe('~/.claude/skills');
expect(getGlobalSkillsDir('windsurf')).toBe('~/.codeium/windsurf/skills');
expect(getGlobalSkillsDir('opencode')).toBe('~/.config/opencode/skills');
expect(getGlobalSkillsDir('roo')).toBe('~/.roo/skills');
});
});
});
describe('Agent Adapter Integration', () => {
it('should have matching config formats between AGENT_SKILL_FORMATS and expected values', () => {
// Verify that the 2026 updates are consistent
expect(AGENT_SKILL_FORMATS.cursor.configFormat).toBe('mdc');
expect(AGENT_SKILL_FORMATS.windsurf.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS['github-copilot'].configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.trae.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS['claude-code'].configFormat).toBe('xml');
expect(AGENT_SKILL_FORMATS.codex.configFormat).toBe('markdown-table');
expect(AGENT_SKILL_FORMATS['gemini-cli'].configFormat).toBe('json');
});
it('should have valid invoke commands', () => {
for (const format of Object.values(AGENT_SKILL_FORMATS)) {
expect(format.invokeCommand).toBe('skillkit read');
}
});
});
-269
View File
@@ -1,269 +0,0 @@
/**
* Centralized Agent Configuration
*
* Single source of truth for all AI coding agent configurations.
* All modules should import from here instead of defining their own values.
*/
import type { AgentType } from './types.js';
/**
* Agent configuration for skills and config files
*/
export interface AgentDirectoryConfig {
/** Primary skills directory path */
skillsDir: string;
/** Config file that references skills */
configFile: string;
/** Alternative skills directories */
altSkillsDirs?: string[];
/** Global skills directory */
globalSkillsDir?: string;
/** Config format: xml, markdown, mdc, json, markdown-table */
configFormat: 'xml' | 'markdown' | 'mdc' | 'json' | 'markdown-table';
/** Whether agent uses YAML frontmatter in SKILL.md */
usesFrontmatter: boolean;
/** Agent-specific frontmatter fields */
frontmatterFields?: string[];
/** Whether agent supports skill auto-discovery */
supportsAutoDiscovery: boolean;
}
/**
* Centralized agent configurations
*
* This is the ONLY source of truth for agent paths and formats.
* Do not define these values elsewhere.
*/
export const AGENT_CONFIG: Record<AgentType, AgentDirectoryConfig> = {
// Claude Code - all Claude products use the same format
'claude-code': {
skillsDir: '.claude/skills',
configFile: 'CLAUDE.md',
globalSkillsDir: '~/.claude/skills',
configFormat: 'xml',
usesFrontmatter: true,
frontmatterFields: [
'name', 'description', 'allowed-tools', 'model', 'context',
'agent', 'disable-model-invocation', 'user-invocable', 'argument-hint',
],
supportsAutoDiscovery: true,
},
// Cursor - uses MDC format in .cursor/rules/
cursor: {
skillsDir: '.cursor/skills',
configFile: '.cursor/rules/skills.mdc',
altSkillsDirs: ['.cursor/commands'],
globalSkillsDir: '~/.cursor/skills',
configFormat: 'mdc',
usesFrontmatter: true,
frontmatterFields: ['description', 'globs', 'alwaysApply'],
supportsAutoDiscovery: true,
},
// Codex (OpenAI)
codex: {
skillsDir: '.codex/skills',
configFile: 'AGENTS.md',
globalSkillsDir: '~/.codex/skills',
configFormat: 'markdown-table',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Gemini CLI
'gemini-cli': {
skillsDir: '.gemini/skills',
configFile: 'GEMINI.md',
globalSkillsDir: '~/.gemini/skills',
configFormat: 'json',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// OpenCode
opencode: {
skillsDir: '.opencode/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.opencode/agent'],
globalSkillsDir: '~/.config/opencode/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Antigravity
antigravity: {
skillsDir: '.antigravity/skills',
configFile: 'AGENTS.md',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Amp - uses .amp/ directory
amp: {
skillsDir: '.amp/skills',
configFile: 'AGENTS.md',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Clawdbot
clawdbot: {
skillsDir: '.clawdbot/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['skills'],
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Droid (Factory)
droid: {
skillsDir: '.factory/skills',
configFile: 'AGENTS.md',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// GitHub Copilot
'github-copilot': {
skillsDir: '.github/skills',
configFile: '.github/copilot-instructions.md',
altSkillsDirs: ['.github/instructions'],
configFormat: 'markdown',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Goose
goose: {
skillsDir: '.goose/skills',
configFile: 'AGENTS.md',
globalSkillsDir: '~/.goose/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Kilo
kilo: {
skillsDir: '.kilocode/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.kilocode/modes'],
globalSkillsDir: '~/.kilocode/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Kiro CLI
'kiro-cli': {
skillsDir: '.kiro/skills',
configFile: 'AGENTS.md',
globalSkillsDir: '~/.kiro/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Roo Code
roo: {
skillsDir: '.roo/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.roo/modes'],
globalSkillsDir: '~/.roo/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Trae
trae: {
skillsDir: '.trae/skills',
configFile: '.trae/rules/project_rules.md',
altSkillsDirs: ['.trae/agent'],
configFormat: 'markdown',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Windsurf
windsurf: {
skillsDir: '.windsurf/skills',
configFile: '.windsurf/rules/skills.md',
altSkillsDirs: ['.windsurf/workflows'],
globalSkillsDir: '~/.codeium/windsurf/skills',
configFormat: 'markdown',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Universal - works with any agent
universal: {
skillsDir: 'skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.agent/skills', '.agents/skills'],
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
};
/**
* Get agent configuration
*/
export function getAgentDirectoryConfig(agent: AgentType): AgentDirectoryConfig {
return AGENT_CONFIG[agent];
}
/**
* Get skills directory for an agent
*/
export function getSkillsDir(agent: AgentType): string {
return AGENT_CONFIG[agent].skillsDir;
}
/**
* Get config file for an agent
*/
export function getConfigFile(agent: AgentType): string {
return AGENT_CONFIG[agent].configFile;
}
/**
* Get all skills directories for an agent (including alternatives)
*/
export function getAllSkillsDirs(agent: AgentType): string[] {
const config = AGENT_CONFIG[agent];
const dirs = [config.skillsDir];
if (config.altSkillsDirs) {
dirs.push(...config.altSkillsDirs);
}
return dirs;
}
/**
* Get global skills directory for an agent
*/
export function getGlobalSkillsDir(agent: AgentType): string | undefined {
return AGENT_CONFIG[agent].globalSkillsDir;
}
/**
* Check if agent supports auto-discovery
*/
export function supportsAutoDiscovery(agent: AgentType): boolean {
return AGENT_CONFIG[agent].supportsAutoDiscovery;
}
/**
* Get config format for an agent
*/
export function getConfigFormat(agent: AgentType): AgentDirectoryConfig['configFormat'] {
return AGENT_CONFIG[agent].configFormat;
}
@@ -1,556 +0,0 @@
/**
* Agent Discovery Tests
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import {
discoverAgents,
discoverAgentsForAgent,
discoverAgentsRecursive,
discoverAgentsFromPath,
findAllAgents,
findAgent,
getAgentsDirectory,
agentExists,
getAgentStats,
} from '../discovery.js';
describe('Agent Discovery', () => {
let testDir: string;
beforeEach(() => {
// Create a temporary test directory
testDir = join(tmpdir(), `agent-test-${Date.now()}`);
mkdirSync(testDir, { recursive: true });
});
afterEach(() => {
// Clean up
if (existsSync(testDir)) {
rmSync(testDir, { recursive: true, force: true });
}
});
describe('discoverAgents', () => {
it('should discover agents in .claude/agents directory', () => {
const agentsDir = join(testDir, '.claude', 'agents');
mkdirSync(agentsDir, { recursive: true });
writeFileSync(
join(agentsDir, 'test-agent.md'),
`---
name: test-agent
description: A test agent
---
Agent content here.`
);
const agents = discoverAgents(testDir);
expect(agents).toHaveLength(1);
expect(agents[0].name).toBe('test-agent');
expect(agents[0].description).toBe('A test agent');
expect(agents[0].location).toBe('project');
});
it('should discover multiple agents', () => {
const agentsDir = join(testDir, '.claude', 'agents');
mkdirSync(agentsDir, { recursive: true });
writeFileSync(
join(agentsDir, 'agent-one.md'),
`---
name: agent-one
description: First agent
---
Content.`
);
writeFileSync(
join(agentsDir, 'agent-two.md'),
`---
name: agent-two
description: Second agent
---
Content.`
);
const agents = discoverAgents(testDir);
expect(agents).toHaveLength(2);
const names = agents.map((a) => a.name);
expect(names).toContain('agent-one');
expect(names).toContain('agent-two');
});
it('should return empty array when no agents directory exists', () => {
const agents = discoverAgents(testDir);
expect(agents).toHaveLength(0);
});
it('should discover agents in alternative directories', () => {
const agentsDir = join(testDir, 'agents');
mkdirSync(agentsDir, { recursive: true });
writeFileSync(
join(agentsDir, 'my-agent.md'),
`---
name: my-agent
description: An agent in universal location
---
Content.`
);
const agents = discoverAgents(testDir);
expect(agents).toHaveLength(1);
expect(agents[0].name).toBe('my-agent');
});
});
describe('discoverAgentsForAgent', () => {
it('should discover agents for specific AI agent type', () => {
const claudeAgentsDir = join(testDir, '.claude', 'agents');
const cursorAgentsDir = join(testDir, '.cursor', 'agents');
mkdirSync(claudeAgentsDir, { recursive: true });
mkdirSync(cursorAgentsDir, { recursive: true });
writeFileSync(
join(claudeAgentsDir, 'claude-agent.md'),
`---
name: claude-agent
description: Claude specific
---
Content.`
);
writeFileSync(
join(cursorAgentsDir, 'cursor-agent.md'),
`---
name: cursor-agent
description: Cursor specific
---
Content.`
);
const claudeAgents = discoverAgentsForAgent(testDir, 'claude-code');
expect(claudeAgents).toHaveLength(1);
expect(claudeAgents[0].name).toBe('claude-agent');
const cursorAgents = discoverAgentsForAgent(testDir, 'cursor');
expect(cursorAgents).toHaveLength(1);
expect(cursorAgents[0].name).toBe('cursor-agent');
});
});
describe('findAllAgents', () => {
it('should find agents in multiple search directories', () => {
const dir1 = join(testDir, 'project1');
const dir2 = join(testDir, 'project2');
mkdirSync(join(dir1, '.claude', 'agents'), { recursive: true });
mkdirSync(join(dir2, '.claude', 'agents'), { recursive: true });
writeFileSync(
join(dir1, '.claude', 'agents', 'agent-a.md'),
`---
name: agent-a
description: Agent A
---
Content.`
);
writeFileSync(
join(dir2, '.claude', 'agents', 'agent-b.md'),
`---
name: agent-b
description: Agent B
---
Content.`
);
const agents = findAllAgents([dir1, dir2]);
expect(agents).toHaveLength(2);
const names = agents.map((a) => a.name);
expect(names).toContain('agent-a');
expect(names).toContain('agent-b');
});
it('should deduplicate agents by name', () => {
const dir1 = join(testDir, 'project1');
const dir2 = join(testDir, 'project2');
mkdirSync(join(dir1, '.claude', 'agents'), { recursive: true });
mkdirSync(join(dir2, '.claude', 'agents'), { recursive: true });
// Same agent name in both directories
writeFileSync(
join(dir1, '.claude', 'agents', 'shared-agent.md'),
`---
name: shared-agent
description: Shared agent (dir1)
---
Content.`
);
writeFileSync(
join(dir2, '.claude', 'agents', 'shared-agent.md'),
`---
name: shared-agent
description: Shared agent (dir2)
---
Content.`
);
const agents = findAllAgents([dir1, dir2]);
expect(agents).toHaveLength(1);
expect(agents[0].name).toBe('shared-agent');
});
});
describe('findAgent', () => {
it('should find a specific agent by name', () => {
const agentsDir = join(testDir, '.claude', 'agents');
mkdirSync(agentsDir, { recursive: true });
writeFileSync(
join(agentsDir, 'target-agent.md'),
`---
name: target-agent
description: The target agent
---
Content.`
);
writeFileSync(
join(agentsDir, 'other-agent.md'),
`---
name: other-agent
description: Another agent
---
Content.`
);
const agent = findAgent('target-agent', [testDir]);
expect(agent).not.toBeNull();
expect(agent?.name).toBe('target-agent');
expect(agent?.description).toBe('The target agent');
});
it('should return null when agent not found', () => {
const agentsDir = join(testDir, '.claude', 'agents');
mkdirSync(agentsDir, { recursive: true });
const agent = findAgent('non-existent', [testDir]);
expect(agent).toBeNull();
});
});
describe('getAgentsDirectory', () => {
it('should return correct directory for different agent types', () => {
expect(getAgentsDirectory(testDir, 'claude-code')).toBe(join(testDir, '.claude', 'agents'));
expect(getAgentsDirectory(testDir, 'cursor')).toBe(join(testDir, '.cursor', 'agents'));
expect(getAgentsDirectory(testDir, 'universal')).toBe(join(testDir, 'agents'));
});
});
describe('agentExists', () => {
it('should return true when agent exists', () => {
const agentsDir = join(testDir, '.claude', 'agents');
mkdirSync(agentsDir, { recursive: true });
writeFileSync(
join(agentsDir, 'existing-agent.md'),
`---
name: existing-agent
description: Exists
---
Content.`
);
expect(agentExists('existing-agent', [testDir])).toBe(true);
});
it('should return false when agent does not exist', () => {
expect(agentExists('non-existent', [testDir])).toBe(false);
});
});
describe('getAgentStats', () => {
it('should return correct stats', () => {
const agentsDir = join(testDir, '.claude', 'agents');
mkdirSync(agentsDir, { recursive: true });
writeFileSync(
join(agentsDir, 'agent-one.md'),
`---
name: agent-one
description: First
---
Content.`
);
writeFileSync(
join(agentsDir, 'agent-two.md'),
`---
name: agent-two
description: Second
---
Content.`
);
const stats = getAgentStats([testDir]);
expect(stats.total).toBe(2);
expect(stats.project).toBe(2);
expect(stats.global).toBe(0);
expect(stats.enabled).toBe(2);
expect(stats.disabled).toBe(0);
});
});
describe('discoverAgentsRecursive', () => {
it('should discover agents in nested directories', () => {
// Create nested structure like kubernetes-skills/claude-code/k8s-autoscaling
const rootDir = join(testDir, 'skills');
mkdirSync(join(rootDir, 'k8s-autoscaling'), { recursive: true });
mkdirSync(join(rootDir, 'k8s-security'), { recursive: true });
mkdirSync(join(rootDir, 'k8s-deploy'), { recursive: true });
writeFileSync(
join(rootDir, 'k8s-autoscaling', 'AGENT.md'),
`---
name: k8s-autoscaling
description: Kubernetes autoscaling agent
---
Autoscaling content.`
);
writeFileSync(
join(rootDir, 'k8s-security', 'AGENT.md'),
`---
name: k8s-security
description: Kubernetes security agent
---
Security content.`
);
writeFileSync(
join(rootDir, 'k8s-deploy', 'AGENT.md'),
`---
name: k8s-deploy
description: Kubernetes deployment agent
---
Deploy content.`
);
const agents = discoverAgentsRecursive(rootDir);
expect(agents).toHaveLength(3);
const names = agents.map((a) => a.name);
expect(names).toContain('k8s-autoscaling');
expect(names).toContain('k8s-security');
expect(names).toContain('k8s-deploy');
});
it('should discover deeply nested agents', () => {
const rootDir = join(testDir, 'deep-skills');
mkdirSync(join(rootDir, 'category1', 'subcategory', 'agent-deep'), { recursive: true });
writeFileSync(
join(rootDir, 'category1', 'subcategory', 'agent-deep', 'AGENT.md'),
`---
name: agent-deep
description: Deeply nested agent
---
Deep content.`
);
const agents = discoverAgentsRecursive(rootDir);
expect(agents).toHaveLength(1);
expect(agents[0].name).toBe('agent-deep');
});
it('should discover agents as markdown files', () => {
const rootDir = join(testDir, 'md-skills');
mkdirSync(join(rootDir, 'subdir'), { recursive: true });
writeFileSync(
join(rootDir, 'top-level-agent.md'),
`---
name: top-level-agent
description: Top level agent
---
Content.`
);
writeFileSync(
join(rootDir, 'subdir', 'nested-agent.md'),
`---
name: nested-agent
description: Nested agent
---
Content.`
);
const agents = discoverAgentsRecursive(rootDir);
expect(agents).toHaveLength(2);
const names = agents.map((a) => a.name);
expect(names).toContain('top-level-agent');
expect(names).toContain('nested-agent');
});
it('should skip hidden directories except standard agent paths', () => {
const rootDir = join(testDir, 'hidden-test');
mkdirSync(join(rootDir, '.hidden', 'agents'), { recursive: true });
mkdirSync(join(rootDir, '.claude', 'agents'), { recursive: true });
writeFileSync(
join(rootDir, '.hidden', 'agents', 'hidden-agent.md'),
`---
name: hidden-agent
description: Should be skipped
---
Content.`
);
writeFileSync(
join(rootDir, '.claude', 'agents', 'claude-agent.md'),
`---
name: claude-agent
description: Should be found
---
Content.`
);
const agents = discoverAgentsRecursive(rootDir);
expect(agents).toHaveLength(1);
expect(agents[0].name).toBe('claude-agent');
});
it('should return empty array for non-existent directory', () => {
const agents = discoverAgentsRecursive(join(testDir, 'non-existent'));
expect(agents).toHaveLength(0);
});
});
describe('discoverAgentsFromPath', () => {
it('should discover agent from single file', () => {
mkdirSync(testDir, { recursive: true });
writeFileSync(
join(testDir, 'single-agent.md'),
`---
name: single-agent
description: A single agent file
---
Content.`
);
const agents = discoverAgentsFromPath(join(testDir, 'single-agent.md'));
expect(agents).toHaveLength(1);
expect(agents[0].name).toBe('single-agent');
});
it('should discover agents from directory without recursive flag', () => {
const rootDir = join(testDir, 'flat-dir');
mkdirSync(rootDir, { recursive: true });
writeFileSync(
join(rootDir, 'agent-a.md'),
`---
name: agent-a
description: Agent A
---
Content.`
);
writeFileSync(
join(rootDir, 'agent-b.md'),
`---
name: agent-b
description: Agent B
---
Content.`
);
const agents = discoverAgentsFromPath(rootDir, false);
expect(agents).toHaveLength(2);
});
it('should discover agents from directory with recursive flag', () => {
const rootDir = join(testDir, 'nested-dir');
mkdirSync(join(rootDir, 'subdir'), { recursive: true });
writeFileSync(
join(rootDir, 'agent-top.md'),
`---
name: agent-top
description: Top agent
---
Content.`
);
writeFileSync(
join(rootDir, 'subdir', 'agent-nested.md'),
`---
name: agent-nested
description: Nested agent
---
Content.`
);
const agentsNonRecursive = discoverAgentsFromPath(rootDir, false);
expect(agentsNonRecursive).toHaveLength(1);
expect(agentsNonRecursive[0].name).toBe('agent-top');
const agentsRecursive = discoverAgentsFromPath(rootDir, true);
expect(agentsRecursive).toHaveLength(2);
const names = agentsRecursive.map((a) => a.name);
expect(names).toContain('agent-top');
expect(names).toContain('agent-nested');
});
it('should handle agent directory with AGENT.md', () => {
const agentDir = join(testDir, 'agent-dir');
mkdirSync(agentDir, { recursive: true });
writeFileSync(
join(agentDir, 'AGENT.md'),
`---
name: agent-dir
description: Directory-based agent
---
Content.`
);
const agents = discoverAgentsFromPath(agentDir);
expect(agents).toHaveLength(1);
expect(agents[0].name).toBe('agent-dir');
});
it('should return empty array for non-existent path', () => {
const agents = discoverAgentsFromPath(join(testDir, 'non-existent'));
expect(agents).toHaveLength(0);
});
it('should return empty array for non-markdown file', () => {
writeFileSync(join(testDir, 'not-agent.txt'), 'Not an agent');
const agents = discoverAgentsFromPath(join(testDir, 'not-agent.txt'));
expect(agents).toHaveLength(0);
});
});
});
@@ -1,201 +0,0 @@
/**
* Agent Parser Tests
*/
import { describe, it, expect } from 'vitest';
import {
extractAgentFrontmatter,
extractAgentContent,
toCanonicalAgent,
fromCanonicalAgent,
validateAgent,
} from '../parser.js';
import type { CustomAgent, CanonicalAgent, AgentFrontmatter } from '../types.js';
describe('Agent Parser', () => {
describe('extractAgentFrontmatter', () => {
it('should extract valid YAML frontmatter', () => {
const content = `---
name: test-agent
description: A test agent
model: opus
---
Agent content here.`;
const frontmatter = extractAgentFrontmatter(content);
expect(frontmatter).not.toBeNull();
expect(frontmatter?.name).toBe('test-agent');
expect(frontmatter?.description).toBe('A test agent');
expect(frontmatter?.model).toBe('opus');
});
it('should return null for content without frontmatter', () => {
const content = 'Just some content without frontmatter.';
const frontmatter = extractAgentFrontmatter(content);
expect(frontmatter).toBeNull();
});
it('should return null for invalid YAML', () => {
const content = `---
name: test-agent
invalid: yaml: structure: [broken
---
Content here.`;
const frontmatter = extractAgentFrontmatter(content);
expect(frontmatter).toBeNull();
});
it('should extract complex frontmatter with arrays', () => {
const content = `---
name: security-reviewer
description: Reviews code for security issues
disallowedTools:
- Bash
- Write
skills:
- code-review
- security
---
Content here.`;
const frontmatter = extractAgentFrontmatter(content);
expect(frontmatter?.name).toBe('security-reviewer');
expect(frontmatter?.disallowedTools).toEqual(['Bash', 'Write']);
expect(frontmatter?.skills).toEqual(['code-review', 'security']);
});
});
describe('extractAgentContent', () => {
it('should extract content after frontmatter', () => {
const content = `---
name: test-agent
description: A test agent
---
# Agent Instructions
This is the main content.`;
const extracted = extractAgentContent(content);
expect(extracted).toBe('# Agent Instructions\n\nThis is the main content.');
});
it('should return full content if no frontmatter', () => {
const content = 'Just content without frontmatter.';
const extracted = extractAgentContent(content);
expect(extracted).toBe('Just content without frontmatter.');
});
it('should handle empty content after frontmatter', () => {
const content = `---
name: test-agent
description: Empty agent
---`;
const extracted = extractAgentContent(content);
expect(extracted).toBe('');
});
});
describe('toCanonicalAgent', () => {
it('should convert CustomAgent to CanonicalAgent', () => {
const agent: CustomAgent = {
name: 'test-agent',
description: 'A test agent',
path: '/path/to/agent.md',
location: 'project',
frontmatter: {
name: 'test-agent',
description: 'A test agent',
model: 'opus',
permissionMode: 'default',
disallowedTools: ['Bash'],
skills: ['testing'],
} as AgentFrontmatter,
content: 'Agent instructions here.',
enabled: true,
};
const canonical = toCanonicalAgent(agent);
expect(canonical.name).toBe('test-agent');
expect(canonical.description).toBe('A test agent');
expect(canonical.model).toBe('opus');
expect(canonical.permissionMode).toBe('default');
expect(canonical.disallowedTools).toEqual(['Bash']);
expect(canonical.skills).toEqual(['testing']);
expect(canonical.content).toBe('Agent instructions here.');
expect(canonical.sourceFormat).toBe('claude-agent');
});
it('should handle string allowedTools', () => {
const agent: CustomAgent = {
name: 'test-agent',
description: 'Test',
path: '/path',
location: 'project',
frontmatter: {
name: 'test-agent',
description: 'Test',
allowedTools: 'Read, Glob, Grep',
} as unknown as AgentFrontmatter,
content: 'Content',
enabled: true,
};
const canonical = toCanonicalAgent(agent);
expect(canonical.allowedTools).toEqual(['Read', 'Glob', 'Grep']);
});
});
describe('fromCanonicalAgent', () => {
it('should generate markdown from CanonicalAgent', () => {
const canonical: CanonicalAgent = {
name: 'test-agent',
description: 'A test agent',
model: 'opus',
content: '# Test Agent\n\nInstructions here.',
sourceFormat: 'claude-agent',
};
const markdown = fromCanonicalAgent(canonical);
expect(markdown).toContain('---');
expect(markdown).toContain('name: test-agent');
expect(markdown).toContain('description: A test agent');
expect(markdown).toContain('model: opus');
expect(markdown).toContain('# Test Agent');
});
it('should include optional fields when present', () => {
const canonical: CanonicalAgent = {
name: 'security-agent',
description: 'Security reviewer',
permissionMode: 'plan',
disallowedTools: ['Bash', 'Write'],
allowedTools: ['Read', 'Glob'],
skills: ['security', 'review'],
tags: ['security', 'code-review'],
version: '1.0.0',
author: 'test',
content: 'Content here.',
sourceFormat: 'claude-agent',
};
const markdown = fromCanonicalAgent(canonical);
expect(markdown).toContain('permissionMode: plan');
expect(markdown).toContain('disallowedTools:');
expect(markdown).toContain(' - Bash');
expect(markdown).toContain('allowed-tools:');
expect(markdown).toContain('skills:');
expect(markdown).toContain('tags: [security, code-review]');
expect(markdown).toContain('version: "1.0.0"');
expect(markdown).toContain('author: test');
});
});
});
@@ -1,192 +0,0 @@
/**
* Agent Translator Tests
*/
import { describe, it, expect } from 'vitest';
import {
translateAgent,
translateCanonicalAgent,
getAgentFilename,
getAgentTargetDirectory,
isAgentCompatible,
} from '../translator.js';
import type { CustomAgent, CanonicalAgent, AgentFrontmatter } from '../types.js';
describe('Agent Translator', () => {
describe('translateAgent', () => {
it('should translate agent to claude-code format', () => {
const agent: CustomAgent = {
name: 'test-agent',
description: 'A test agent',
path: '/path/to/agent.md',
location: 'project',
frontmatter: {
name: 'test-agent',
description: 'A test agent',
model: 'opus',
} as AgentFrontmatter,
content: 'Agent instructions here.',
enabled: true,
};
const result = translateAgent(agent, 'claude-code');
expect(result.success).toBe(true);
expect(result.targetAgent).toBe('claude-code');
expect(result.targetFormat).toBe('claude-agent');
expect(result.content).toContain('name: test-agent');
expect(result.content).toContain('model: opus');
});
it('should translate agent to cursor format', () => {
const agent: CustomAgent = {
name: 'reviewer',
description: 'Code reviewer',
path: '/path/to/agent.md',
location: 'project',
frontmatter: {
name: 'reviewer',
description: 'Code reviewer',
} as AgentFrontmatter,
content: 'Review code carefully.',
enabled: true,
};
const result = translateAgent(agent, 'cursor');
expect(result.success).toBe(true);
expect(result.targetAgent).toBe('cursor');
expect(result.targetFormat).toBe('cursor-agent');
expect(result.filename).toBe('reviewer.md');
});
it('should add warnings for hooks in cursor format', () => {
const agent: CustomAgent = {
name: 'hooked-agent',
description: 'Agent with hooks',
path: '/path/to/agent.md',
location: 'project',
frontmatter: {
name: 'hooked-agent',
description: 'Agent with hooks',
hooks: [
{ type: 'PreToolUse', command: 'echo test' },
],
} as AgentFrontmatter,
content: 'Content here.',
enabled: true,
};
const result = translateAgent(agent, 'cursor');
expect(result.success).toBe(true);
expect(result.warnings).toContain('Hooks may require manual adjustment for Cursor');
});
it('should add incompatible features for universal format', () => {
const agent: CustomAgent = {
name: 'complex-agent',
description: 'Complex agent',
path: '/path/to/agent.md',
location: 'project',
frontmatter: {
name: 'complex-agent',
description: 'Complex agent',
permissionMode: 'plan',
hooks: [
{ type: 'SessionStart', command: 'echo start' },
],
} as AgentFrontmatter,
content: 'Content here.',
enabled: true,
};
const result = translateAgent(agent, 'universal');
expect(result.success).toBe(true);
expect(result.incompatible).toContain('hooks (not supported in universal format)');
expect(result.incompatible).toContain('permissionMode (not supported in universal format)');
});
});
describe('translateCanonicalAgent', () => {
it('should translate canonical agent to different formats', () => {
const canonical: CanonicalAgent = {
name: 'test-agent',
description: 'Test agent',
model: 'sonnet',
content: 'Agent content.',
sourceFormat: 'claude-agent',
};
const claudeResult = translateCanonicalAgent(canonical, 'claude-code');
expect(claudeResult.success).toBe(true);
expect(claudeResult.content).toContain('name: test-agent');
const cursorResult = translateCanonicalAgent(canonical, 'cursor');
expect(cursorResult.success).toBe(true);
expect(cursorResult.content).toContain('name: test-agent');
const universalResult = translateCanonicalAgent(canonical, 'universal');
expect(universalResult.success).toBe(true);
expect(universalResult.content).toContain('name: test-agent');
});
it('should include metadata when option is set', () => {
const canonical: CanonicalAgent = {
name: 'test-agent',
description: 'Test agent',
content: 'Content.',
sourceFormat: 'claude-agent',
sourceAgent: 'cursor',
};
const result = translateCanonicalAgent(canonical, 'claude-code', { addMetadata: true });
expect(result.content).toContain('# Translated by SkillKit from cursor');
});
});
describe('getAgentFilename', () => {
it('should return correct filename for different agents', () => {
expect(getAgentFilename('test-agent', 'claude-code')).toBe('test-agent.md');
expect(getAgentFilename('reviewer', 'cursor')).toBe('reviewer.md');
expect(getAgentFilename('my-agent', 'universal')).toBe('my-agent.md');
});
});
describe('getAgentTargetDirectory', () => {
it('should return correct target directory', () => {
const rootDir = '/home/user/project';
expect(getAgentTargetDirectory(rootDir, 'claude-code')).toBe('/home/user/project/.claude/agents');
expect(getAgentTargetDirectory(rootDir, 'cursor')).toBe('/home/user/project/.cursor/agents');
expect(getAgentTargetDirectory(rootDir, 'universal')).toBe('/home/user/project/agents');
});
});
describe('isAgentCompatible', () => {
it('should return compatible for same format', () => {
const result = isAgentCompatible('claude-agent', 'claude-agent');
expect(result.compatible).toBe(true);
expect(result.warnings).toHaveLength(0);
});
it('should return compatible for claude-agent target', () => {
const result = isAgentCompatible('cursor-agent', 'claude-agent');
expect(result.compatible).toBe(true);
});
it('should add warnings for universal target from claude-agent', () => {
const result = isAgentCompatible('claude-agent', 'universal');
expect(result.compatible).toBe(true);
expect(result.warnings.length).toBeGreaterThan(0);
});
it('should add warnings for cursor target from claude-agent', () => {
const result = isAgentCompatible('claude-agent', 'cursor-agent');
expect(result.compatible).toBe(true);
expect(result.warnings.length).toBeGreaterThan(0);
});
});
});
-383
View File
@@ -1,383 +0,0 @@
/**
* Agent Discovery
*
* Discovers custom agent definitions across all supported locations.
*/
import { existsSync, readdirSync, statSync } from 'node:fs';
import { join, extname } from 'node:path';
import { homedir } from 'node:os';
import {
ALL_AGENT_DISCOVERY_PATHS,
AGENT_DISCOVERY_PATHS,
type CustomAgent,
type AgentLocation,
} from './types.js';
import { parseAgentFile, parseAgentDir } from './parser.js';
import type { AgentType } from '../types.js';
/**
* Discover agents in a specific directory
*/
function discoverAgentsInDir(
dir: string,
location: AgentLocation
): CustomAgent[] {
const agents: CustomAgent[] = [];
if (!existsSync(dir)) {
return agents;
}
try {
const entries = readdirSync(dir, { withFileTypes: true });
for (const entry of entries) {
const entryPath = join(dir, entry.name);
if (entry.isFile() && extname(entry.name) === '.md') {
// Parse markdown file directly
const agent = parseAgentFile(entryPath, location);
if (agent) {
agents.push(agent);
}
} else if (entry.isDirectory()) {
// Parse directory with AGENT.md inside
const agent = parseAgentDir(entryPath, location);
if (agent) {
agents.push(agent);
}
}
}
} catch {
// Ignore errors (permission denied, etc.)
}
return agents;
}
/**
* Discover all agents in a project directory
*/
export function discoverAgents(rootDir: string): CustomAgent[] {
const agents: CustomAgent[] = [];
const seen = new Set<string>();
// Search all standard paths
for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
const fullPath = join(rootDir, searchPath);
if (existsSync(fullPath)) {
for (const agent of discoverAgentsInDir(fullPath, 'project')) {
if (!seen.has(agent.name)) {
seen.add(agent.name);
agents.push(agent);
}
}
}
}
return agents;
}
/**
* Discover agents for a specific AI coding agent
*/
export function discoverAgentsForAgent(
rootDir: string,
agentType: AgentType
): CustomAgent[] {
const agents: CustomAgent[] = [];
const seen = new Set<string>();
const paths = AGENT_DISCOVERY_PATHS[agentType] || [];
for (const searchPath of paths) {
const fullPath = join(rootDir, searchPath);
if (existsSync(fullPath)) {
for (const agent of discoverAgentsInDir(fullPath, 'project')) {
if (!seen.has(agent.name)) {
seen.add(agent.name);
agents.push(agent);
}
}
}
}
return agents;
}
/**
* Discover global agents (in ~/.claude/agents, etc.)
*/
export function discoverGlobalAgents(): CustomAgent[] {
const agents: CustomAgent[] = [];
const seen = new Set<string>();
const home = homedir();
// Global agent paths
const globalPaths = [
join(home, '.claude', 'agents'),
join(home, '.skillkit', 'agents'),
join(home, '.config', 'skillkit', 'agents'),
];
for (const searchPath of globalPaths) {
if (existsSync(searchPath)) {
for (const agent of discoverAgentsInDir(searchPath, 'global')) {
if (!seen.has(agent.name)) {
seen.add(agent.name);
agents.push(agent);
}
}
}
}
return agents;
}
/**
* Find all agents (project + global)
*/
export function findAllAgents(searchDirs: string[]): CustomAgent[] {
const agents: CustomAgent[] = [];
const seen = new Set<string>();
// Search provided directories
for (const dir of searchDirs) {
if (!existsSync(dir)) continue;
const discovered = discoverAgents(dir);
for (const agent of discovered) {
if (!seen.has(agent.name)) {
seen.add(agent.name);
agents.push(agent);
}
}
}
// Add global agents
for (const agent of discoverGlobalAgents()) {
if (!seen.has(agent.name)) {
seen.add(agent.name);
agents.push(agent);
}
}
return agents;
}
/**
* Find a specific agent by name
*/
export function findAgent(
name: string,
searchDirs: string[]
): CustomAgent | null {
// Search in provided directories first
for (const dir of searchDirs) {
if (!existsSync(dir)) continue;
// Check all discovery paths
for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
const agentsDir = join(dir, searchPath);
if (!existsSync(agentsDir)) continue;
// Try as file
const agentFile = join(agentsDir, `${name}.md`);
if (existsSync(agentFile)) {
return parseAgentFile(agentFile, 'project');
}
// Try as directory
const agentDir = join(agentsDir, name);
if (existsSync(agentDir) && statSync(agentDir).isDirectory()) {
return parseAgentDir(agentDir, 'project');
}
}
}
// Check global agents
const home = homedir();
const globalPaths = [
join(home, '.claude', 'agents'),
join(home, '.skillkit', 'agents'),
];
for (const agentsDir of globalPaths) {
if (!existsSync(agentsDir)) continue;
const agentFile = join(agentsDir, `${name}.md`);
if (existsSync(agentFile)) {
return parseAgentFile(agentFile, 'global');
}
const agentDir = join(agentsDir, name);
if (existsSync(agentDir) && statSync(agentDir).isDirectory()) {
return parseAgentDir(agentDir, 'global');
}
}
return null;
}
/**
* Get the agents directory for a specific AI coding agent
*/
export function getAgentsDirectory(
rootDir: string,
agentType: AgentType
): string {
const paths = AGENT_DISCOVERY_PATHS[agentType];
if (paths && paths.length > 0) {
return join(rootDir, paths[0]);
}
return join(rootDir, 'agents');
}
/**
* Check if an agent exists
*/
export function agentExists(
name: string,
searchDirs: string[]
): boolean {
return findAgent(name, searchDirs) !== null;
}
/**
* Get agent count statistics
*/
export function getAgentStats(searchDirs: string[]): {
total: number;
project: number;
global: number;
enabled: number;
disabled: number;
} {
const allAgents = findAllAgents(searchDirs);
return {
total: allAgents.length,
project: allAgents.filter(a => a.location === 'project').length,
global: allAgents.filter(a => a.location === 'global').length,
enabled: allAgents.filter(a => a.enabled).length,
disabled: allAgents.filter(a => !a.enabled).length,
};
}
/**
* Recursively discover all agents in a directory tree
* This finds agents at any depth, useful for batch translation
*/
export function discoverAgentsRecursive(
rootDir: string,
location: AgentLocation = 'project'
): CustomAgent[] {
const agents: CustomAgent[] = [];
const seen = new Set<string>();
if (!existsSync(rootDir)) {
return agents;
}
function scanDirectory(dir: string): void {
try {
const entries = readdirSync(dir, { withFileTypes: true });
for (const entry of entries) {
const entryPath = join(dir, entry.name);
if (entry.isFile() && extname(entry.name) === '.md') {
// Parse markdown file directly
const agent = parseAgentFile(entryPath, location);
if (agent && !seen.has(agent.name)) {
seen.add(agent.name);
agents.push(agent);
}
} else if (entry.isDirectory()) {
// Skip hidden directories except standard agent paths
if (entry.name.startsWith('.') && !entry.name.startsWith('.claude') &&
!entry.name.startsWith('.cursor') && !entry.name.startsWith('.codex')) {
continue;
}
// Try to parse as agent directory first
const agent = parseAgentDir(entryPath, location);
if (agent && !seen.has(agent.name)) {
seen.add(agent.name);
agents.push(agent);
} else {
// If not an agent directory, recurse into it
scanDirectory(entryPath);
}
}
}
} catch {
// Ignore errors (permission denied, etc.)
}
}
scanDirectory(rootDir);
return agents;
}
/**
* Discover agents from a custom source path
* Handles both file paths and directories
*/
export function discoverAgentsFromPath(
sourcePath: string,
recursive: boolean = false,
location: AgentLocation = 'project'
): CustomAgent[] {
if (!existsSync(sourcePath)) {
return [];
}
const stats = statSync(sourcePath);
// Single file
if (stats.isFile()) {
if (extname(sourcePath) === '.md') {
const agent = parseAgentFile(sourcePath, location);
return agent ? [agent] : [];
}
return [];
}
// Directory
if (stats.isDirectory()) {
if (recursive) {
return discoverAgentsRecursive(sourcePath, location);
}
// Non-recursive: only check immediate directory
// First try as agent directory
const agent = parseAgentDir(sourcePath, location);
if (agent) {
return [agent];
}
// Otherwise scan directory contents (one level)
const agents: CustomAgent[] = [];
try {
const entries = readdirSync(sourcePath, { withFileTypes: true });
for (const entry of entries) {
const entryPath = join(sourcePath, entry.name);
if (entry.isFile() && extname(entry.name) === '.md') {
const a = parseAgentFile(entryPath, location);
if (a) agents.push(a);
} else if (entry.isDirectory()) {
const a = parseAgentDir(entryPath, location);
if (a) agents.push(a);
}
}
} catch {
// Ignore errors
}
return agents;
}
return [];
}
-62
View File
@@ -1,62 +0,0 @@
/**
* Agent Module
*
* Custom AI sub-agent management for SkillKit.
* Supports discovery, parsing, and translation of agents
* between different AI coding agent formats.
*/
// Types
export {
AgentPermissionMode,
AgentHook,
AgentFrontmatter,
AgentLocation,
AgentMetadata,
AGENT_DISCOVERY_PATHS,
ALL_AGENT_DISCOVERY_PATHS,
CUSTOM_AGENT_FORMAT_MAP,
type CustomAgent,
type CanonicalAgent,
type AgentFormatCategory,
type AgentTranslationResult,
type AgentTranslationOptions,
} from './types.js';
// Parser
export {
extractAgentFrontmatter,
extractAgentContent,
parseAgentFile,
parseAgentDir,
loadAgentMetadata,
toCanonicalAgent,
fromCanonicalAgent,
readAgentContent,
validateAgent,
} from './parser.js';
// Discovery
export {
discoverAgents,
discoverAgentsForAgent,
discoverGlobalAgents,
discoverAgentsRecursive,
discoverAgentsFromPath,
findAllAgents,
findAgent,
getAgentsDirectory,
agentExists,
getAgentStats,
} from './discovery.js';
// Translator
export {
translateAgent,
translateCanonicalAgent,
translateAgentContent,
translateAgents,
getAgentFilename,
getAgentTargetDirectory,
isAgentCompatible,
} from './translator.js';
-418
View File
@@ -1,418 +0,0 @@
/**
* Agent Parser
*
* Parses agent definition files (e.g., .claude/agents/*.md)
*/
import { existsSync, readFileSync, statSync } from 'node:fs';
import { join, basename, extname } from 'node:path';
import { parse as parseYaml } from 'yaml';
import {
AgentFrontmatter,
AgentMetadata,
type CustomAgent,
type AgentLocation,
type CanonicalAgent,
type AgentFormatCategory,
} from './types.js';
import type { AgentType } from '../types.js';
/**
* Extract YAML frontmatter from markdown content
*/
export function extractAgentFrontmatter(content: string): Record<string, unknown> | null {
const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
if (!match) {
return null;
}
try {
return parseYaml(match[1]) as Record<string, unknown>;
} catch {
return null;
}
}
/**
* Extract content after frontmatter
*/
export function extractAgentContent(content: string): string {
const withoutFrontmatter = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, '');
return withoutFrontmatter.trim();
}
/**
* Parse an agent file (.md)
*/
export function parseAgentFile(
filePath: string,
location: AgentLocation = 'project'
): CustomAgent | null {
if (!existsSync(filePath)) {
return null;
}
// Only parse .md files
if (extname(filePath) !== '.md') {
return null;
}
try {
const content = readFileSync(filePath, 'utf-8');
const rawFrontmatter = extractAgentFrontmatter(content);
const agentContent = extractAgentContent(content);
// If no frontmatter, use filename as name
if (!rawFrontmatter) {
const name = basename(filePath, '.md');
return {
name,
description: 'No description available',
path: filePath,
location,
frontmatter: {
name,
description: 'No description available',
},
content: agentContent,
enabled: true,
};
}
// Parse frontmatter with validation
const parsed = AgentFrontmatter.safeParse(rawFrontmatter);
if (!parsed.success) {
// Fallback to basic parsing
const name = (rawFrontmatter.name as string) || basename(filePath, '.md');
return {
name,
description: (rawFrontmatter.description as string) || 'No description available',
path: filePath,
location,
frontmatter: {
name,
description: (rawFrontmatter.description as string) || 'No description available',
...rawFrontmatter,
} as AgentFrontmatter,
content: agentContent,
enabled: true,
};
}
// Load metadata if exists
const metadataPath = filePath.replace(/\.md$/, '.skillkit-agent.json');
const metadata = loadAgentMetadata(metadataPath);
return {
name: parsed.data.name,
description: parsed.data.description,
path: filePath,
location,
frontmatter: parsed.data,
content: agentContent,
metadata: metadata ?? undefined,
enabled: metadata?.enabled ?? true,
};
} catch {
return null;
}
}
/**
* Parse an agent from a directory (containing AGENT.md)
*/
export function parseAgentDir(
dirPath: string,
location: AgentLocation = 'project'
): CustomAgent | null {
const agentMdPath = join(dirPath, 'AGENT.md');
if (existsSync(agentMdPath)) {
const agent = parseAgentFile(agentMdPath, location);
if (agent) {
// Update path to directory
agent.path = dirPath;
}
return agent;
}
// Try index.md
const indexMdPath = join(dirPath, 'index.md');
if (existsSync(indexMdPath)) {
const agent = parseAgentFile(indexMdPath, location);
if (agent) {
agent.path = dirPath;
}
return agent;
}
return null;
}
/**
* Load agent metadata from JSON file
*/
export function loadAgentMetadata(metadataPath: string): AgentMetadata | null {
if (!existsSync(metadataPath)) {
return null;
}
try {
const content = readFileSync(metadataPath, 'utf-8');
const data = JSON.parse(content);
const parsed = AgentMetadata.safeParse(data);
return parsed.success ? parsed.data : null;
} catch {
return null;
}
}
/**
* Convert parsed agent to canonical format for translation
*/
export function toCanonicalAgent(
agent: CustomAgent,
sourceAgent?: AgentType
): CanonicalAgent {
const fm = agent.frontmatter;
// Handle allowed-tools (can be string or array)
let allowedTools: string[] | undefined;
if (fm.allowedTools) {
if (typeof fm.allowedTools === 'string') {
// Parse YAML-style list
allowedTools = fm.allowedTools.split(/[,\n]/).map(t => t.trim()).filter(Boolean);
} else {
allowedTools = fm.allowedTools;
}
}
return {
name: agent.name,
description: agent.description,
model: fm.model,
permissionMode: fm.permissionMode,
disallowedTools: fm.disallowedTools,
allowedTools,
hooks: fm.hooks,
skills: fm.skills,
context: fm.context,
version: fm.version,
author: fm.author,
tags: fm.tags,
userInvocable: fm['user-invocable'],
argumentHint: fm['argument-hint'],
content: agent.content,
sourceFormat: 'claude-agent',
sourceAgent,
};
}
/**
* Generate agent markdown from canonical format
*/
export function fromCanonicalAgent(
canonical: CanonicalAgent,
_targetFormat: AgentFormatCategory = 'claude-agent'
): string {
// Note: _targetFormat reserved for format-specific output in future
const lines: string[] = [];
// Generate frontmatter
lines.push('---');
lines.push(`name: ${canonical.name}`);
lines.push(`description: ${canonical.description}`);
if (canonical.model) {
lines.push(`model: ${canonical.model}`);
}
if (canonical.permissionMode) {
lines.push(`permissionMode: ${canonical.permissionMode}`);
}
if (canonical.disallowedTools && canonical.disallowedTools.length > 0) {
lines.push('disallowedTools:');
for (const tool of canonical.disallowedTools) {
lines.push(` - ${tool}`);
}
}
if (canonical.allowedTools && canonical.allowedTools.length > 0) {
lines.push('allowed-tools:');
for (const tool of canonical.allowedTools) {
lines.push(` - ${tool}`);
}
}
if (canonical.hooks && canonical.hooks.length > 0) {
lines.push('hooks:');
for (const hook of canonical.hooks) {
lines.push(` - type: ${hook.type}`);
lines.push(` command: ${hook.command}`);
if (hook.timeout) lines.push(` timeout: ${hook.timeout}`);
if (hook.once) lines.push(` once: ${hook.once}`);
if (hook.matcher) lines.push(` matcher: ${hook.matcher}`);
}
}
if (canonical.skills && canonical.skills.length > 0) {
lines.push('skills:');
for (const skill of canonical.skills) {
lines.push(` - ${skill}`);
}
}
if (canonical.context) {
lines.push(`context: ${canonical.context}`);
}
if (canonical.version) {
lines.push(`version: "${canonical.version}"`);
}
if (canonical.author) {
lines.push(`author: ${canonical.author}`);
}
if (canonical.tags && canonical.tags.length > 0) {
lines.push(`tags: [${canonical.tags.join(', ')}]`);
}
if (canonical.userInvocable !== undefined) {
lines.push(`user-invocable: ${canonical.userInvocable}`);
}
if (canonical.argumentHint) {
lines.push(`argument-hint: "${canonical.argumentHint}"`);
}
lines.push('---');
lines.push('');
// Add content
lines.push(canonical.content);
return lines.join('\n');
}
/**
* Read raw agent content
*/
export function readAgentContent(agentPath: string): string | null {
// If it's a file
if (existsSync(agentPath) && extname(agentPath) === '.md') {
try {
return readFileSync(agentPath, 'utf-8');
} catch {
return null;
}
}
// If it's a directory
const agentMdPath = join(agentPath, 'AGENT.md');
if (existsSync(agentMdPath)) {
try {
return readFileSync(agentMdPath, 'utf-8');
} catch {
return null;
}
}
// Try index.md
const indexMdPath = join(agentPath, 'index.md');
if (existsSync(indexMdPath)) {
try {
return readFileSync(indexMdPath, 'utf-8');
} catch {
return null;
}
}
return null;
}
/**
* Validate an agent file
*/
export function validateAgent(
agentPath: string
): { valid: boolean; errors: string[]; warnings: string[] } {
const errors: string[] = [];
const warnings: string[] = [];
// Check file exists
let filePath = agentPath;
if (!existsSync(agentPath)) {
errors.push(`Agent file not found: ${agentPath}`);
return { valid: false, errors, warnings };
}
// If directory, look for AGENT.md
const stats = statSync(agentPath);
if (stats.isDirectory()) {
const agentMd = join(agentPath, 'AGENT.md');
const indexMd = join(agentPath, 'index.md');
if (existsSync(agentMd)) {
filePath = agentMd;
} else if (existsSync(indexMd)) {
filePath = indexMd;
} else {
errors.push('Directory must contain AGENT.md or index.md');
return { valid: false, errors, warnings };
}
}
// Read content
let content: string;
try {
content = readFileSync(filePath, 'utf-8');
} catch {
errors.push(`Cannot read file: ${filePath}`);
return { valid: false, errors, warnings };
}
// Check frontmatter
const frontmatter = extractAgentFrontmatter(content);
if (!frontmatter) {
errors.push('Missing YAML frontmatter');
return { valid: false, errors, warnings };
}
// Validate frontmatter
const parsed = AgentFrontmatter.safeParse(frontmatter);
if (!parsed.success) {
for (const issue of parsed.error.issues) {
errors.push(`${issue.path.join('.') || 'frontmatter'}: ${issue.message}`);
}
}
// Warnings
if (parsed.success) {
const data = parsed.data;
const fileName = basename(filePath, '.md');
if (data.name !== fileName && fileName !== 'AGENT' && fileName !== 'index') {
warnings.push(`name "${data.name}" does not match filename "${fileName}"`);
}
if (data.description && data.description.length < 20) {
warnings.push('description is short; consider adding more detail');
}
if (data.permissionMode === 'full-auto' || data.permissionMode === 'bypassPermissions') {
warnings.push(`permissionMode "${data.permissionMode}" is potentially dangerous`);
}
}
// Check content
const agentContent = extractAgentContent(content);
if (agentContent.length < 50) {
warnings.push('Agent system prompt is very short');
}
return { valid: errors.length === 0, errors, warnings };
}
-431
View File
@@ -1,431 +0,0 @@
/**
* Agent Translator
*
* Translates agent definitions between different AI coding agent formats.
*/
import {
type CanonicalAgent,
type AgentFormatCategory,
type AgentTranslationResult,
type AgentTranslationOptions,
type CustomAgent,
CUSTOM_AGENT_FORMAT_MAP,
AGENT_DISCOVERY_PATHS,
AgentFrontmatter,
} from './types.js';
import {
toCanonicalAgent,
fromCanonicalAgent,
extractAgentFrontmatter,
extractAgentContent,
} from './parser.js';
import type { AgentType } from '../types.js';
import { join } from 'node:path';
/**
* Translate an agent to a target AI coding agent format
*/
export function translateAgent(
agent: CustomAgent,
targetAgent: AgentType,
options?: AgentTranslationOptions
): AgentTranslationResult {
const canonical = toCanonicalAgent(agent);
return translateCanonicalAgent(canonical, targetAgent, options);
}
/**
* Translate a canonical agent to a target format
*/
export function translateCanonicalAgent(
canonical: CanonicalAgent,
targetAgent: AgentType,
options?: AgentTranslationOptions
): AgentTranslationResult {
const targetFormat = CUSTOM_AGENT_FORMAT_MAP[targetAgent];
const warnings: string[] = [];
const incompatible: string[] = [];
// Track incompatible features
if (targetFormat === 'universal') {
// Universal format has limited support
if (canonical.hooks && canonical.hooks.length > 0) {
incompatible.push('hooks (not supported in universal format)');
}
if (canonical.permissionMode) {
incompatible.push('permissionMode (not supported in universal format)');
}
}
if (targetFormat === 'cursor-agent') {
// Cursor may have different hook syntax
if (canonical.hooks && canonical.hooks.length > 0) {
warnings.push('Hooks may require manual adjustment for Cursor');
}
}
// Generate content based on target format
let content: string;
switch (targetFormat) {
case 'claude-agent':
content = generateClaudeAgent(canonical, options);
break;
case 'cursor-agent':
content = generateCursorAgent(canonical, options);
break;
case 'universal':
content = generateUniversalAgent(canonical, options);
break;
default:
content = fromCanonicalAgent(canonical, targetFormat);
}
// Determine filename
const filename = options?.outputFilename || getAgentFilename(canonical.name, targetAgent);
return {
success: true,
content,
filename,
warnings,
incompatible,
targetFormat,
targetAgent,
};
}
/**
* Translate agent content directly
*/
export function translateAgentContent(
content: string,
_sourceAgent: AgentType,
targetAgent: AgentType,
options?: AgentTranslationOptions
): AgentTranslationResult {
// Note: _sourceAgent reserved for future format-specific parsing
const agent = parseAgentFromContent(content);
if (!agent) {
return {
success: false,
content: '',
filename: '',
warnings: ['Failed to parse agent content'],
incompatible: [],
targetFormat: CUSTOM_AGENT_FORMAT_MAP[targetAgent],
targetAgent,
};
}
return translateAgent(agent, targetAgent, options);
}
/**
* Parse agent from raw content
*/
function parseAgentFromContent(content: string): CustomAgent | null {
const rawFrontmatter = extractAgentFrontmatter(content);
const agentContent = extractAgentContent(content);
if (!rawFrontmatter) {
return null;
}
const parsed = AgentFrontmatter.safeParse(rawFrontmatter);
const frontmatter = parsed.success ? parsed.data : {
name: (rawFrontmatter.name as string) || 'unnamed-agent',
description: (rawFrontmatter.description as string) || 'No description',
...rawFrontmatter,
};
return {
name: frontmatter.name,
description: frontmatter.description,
path: '',
location: 'project',
frontmatter,
content: agentContent,
enabled: true,
};
}
/**
* Generate Claude Code agent format
*/
function generateClaudeAgent(
canonical: CanonicalAgent,
options?: AgentTranslationOptions
): string {
const lines: string[] = [];
// Frontmatter
lines.push('---');
lines.push(`name: ${canonical.name}`);
lines.push(`description: ${escapeYamlString(canonical.description)}`);
if (canonical.model) {
lines.push(`model: ${canonical.model}`);
}
if (canonical.permissionMode) {
lines.push(`permissionMode: ${canonical.permissionMode}`);
}
if (canonical.disallowedTools && canonical.disallowedTools.length > 0) {
lines.push('disallowedTools:');
for (const tool of canonical.disallowedTools) {
lines.push(` - ${tool}`);
}
}
if (canonical.allowedTools && canonical.allowedTools.length > 0) {
lines.push('allowed-tools:');
for (const tool of canonical.allowedTools) {
lines.push(` - ${tool}`);
}
}
if (canonical.hooks && canonical.hooks.length > 0) {
lines.push('hooks:');
for (const hook of canonical.hooks) {
lines.push(` - type: ${hook.type}`);
lines.push(` command: "${escapeYamlString(hook.command)}"`);
if (hook.timeout) lines.push(` timeout: ${hook.timeout}`);
if (hook.once) lines.push(` once: true`);
if (hook.matcher) lines.push(` matcher: "${hook.matcher}"`);
}
}
if (canonical.skills && canonical.skills.length > 0) {
lines.push('skills:');
for (const skill of canonical.skills) {
lines.push(` - ${skill}`);
}
}
if (canonical.context) {
lines.push(`context: ${canonical.context}`);
}
if (canonical.version) {
lines.push(`version: "${canonical.version}"`);
}
if (canonical.author) {
lines.push(`author: ${canonical.author}`);
}
if (canonical.tags && canonical.tags.length > 0) {
lines.push(`tags: [${canonical.tags.join(', ')}]`);
}
if (canonical.userInvocable !== undefined) {
lines.push(`user-invocable: ${canonical.userInvocable}`);
}
if (canonical.argumentHint) {
lines.push(`argument-hint: "${escapeYamlString(canonical.argumentHint)}"`);
}
if (options?.addMetadata) {
lines.push(`# Translated by SkillKit from ${canonical.sourceAgent || 'unknown'}`);
}
lines.push('---');
lines.push('');
// Content
lines.push(canonical.content);
return lines.join('\n');
}
/**
* Generate Cursor agent format
*/
function generateCursorAgent(
canonical: CanonicalAgent,
options?: AgentTranslationOptions
): string {
const lines: string[] = [];
// Cursor uses .mdc format for rules, but agents might be markdown
lines.push('---');
lines.push(`name: ${canonical.name}`);
lines.push(`description: ${escapeYamlString(canonical.description)}`);
if (canonical.model) {
lines.push(`model: ${canonical.model}`);
}
// Cursor-specific: may use different permission syntax
if (canonical.allowedTools && canonical.allowedTools.length > 0) {
lines.push(`tools: [${canonical.allowedTools.join(', ')}]`);
}
if (canonical.version) {
lines.push(`version: "${canonical.version}"`);
}
if (canonical.tags && canonical.tags.length > 0) {
lines.push(`tags: [${canonical.tags.join(', ')}]`);
}
if (options?.addMetadata) {
lines.push(`# Translated by SkillKit from ${canonical.sourceAgent || 'unknown'}`);
}
lines.push('---');
lines.push('');
// Content
lines.push(canonical.content);
// Add note about incompatible features
if (canonical.hooks && canonical.hooks.length > 0) {
lines.push('');
lines.push('<!-- Note: Hooks from original agent may need manual configuration -->');
}
return lines.join('\n');
}
/**
* Generate universal agent format
*/
function generateUniversalAgent(
canonical: CanonicalAgent,
options?: AgentTranslationOptions
): string {
const lines: string[] = [];
// Universal format: simplified, portable
lines.push('---');
lines.push(`name: ${canonical.name}`);
lines.push(`description: ${escapeYamlString(canonical.description)}`);
if (canonical.model) {
lines.push(`model: ${canonical.model}`);
}
if (canonical.version) {
lines.push(`version: "${canonical.version}"`);
}
if (canonical.author) {
lines.push(`author: ${canonical.author}`);
}
if (canonical.tags && canonical.tags.length > 0) {
lines.push(`tags: [${canonical.tags.join(', ')}]`);
}
if (options?.addMetadata) {
lines.push(`# Translated by SkillKit`);
if (canonical.sourceAgent) {
lines.push(`# Original format: ${canonical.sourceAgent}`);
}
}
lines.push('---');
lines.push('');
// Content
lines.push(`# ${canonical.name}`);
lines.push('');
lines.push(canonical.content);
return lines.join('\n');
}
/**
* Get the expected filename for an agent
*/
export function getAgentFilename(
agentName: string,
targetAgent: AgentType
): string {
const format = CUSTOM_AGENT_FORMAT_MAP[targetAgent];
switch (format) {
case 'cursor-agent':
return `${agentName}.md`; // Or .mdc if Cursor uses that for agents
default:
return `${agentName}.md`;
}
}
/**
* Get the target directory for an agent
*/
export function getAgentTargetDirectory(
rootDir: string,
targetAgent: AgentType
): string {
const paths = AGENT_DISCOVERY_PATHS[targetAgent];
if (paths && paths.length > 0) {
return join(rootDir, paths[0]);
}
return join(rootDir, 'agents');
}
/**
* Escape special characters in YAML strings
*/
function escapeYamlString(str: string): string {
if (/[:\{\}\[\],&*#?|\-<>=!%@`]/.test(str) || str.includes('\n')) {
return `"${str.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
}
return str;
}
/**
* Translate multiple agents
*/
export function translateAgents(
agents: CustomAgent[],
targetAgent: AgentType,
options?: AgentTranslationOptions
): AgentTranslationResult[] {
return agents.map(agent => translateAgent(agent, targetAgent, options));
}
/**
* Check if agent format is compatible with target
*/
export function isAgentCompatible(
sourceFormat: AgentFormatCategory,
targetFormat: AgentFormatCategory
): { compatible: boolean; warnings: string[] } {
const warnings: string[] = [];
if (sourceFormat === targetFormat) {
return { compatible: true, warnings };
}
// All formats can translate to claude-agent (most feature-rich)
if (targetFormat === 'claude-agent') {
return { compatible: true, warnings };
}
// Universal format loses some features
if (targetFormat === 'universal') {
if (sourceFormat === 'claude-agent') {
warnings.push('Hooks, permissionMode, and disallowedTools will be lost');
}
return { compatible: true, warnings };
}
// Cursor format has partial support
if (targetFormat === 'cursor-agent') {
if (sourceFormat === 'claude-agent') {
warnings.push('Some Claude-specific features may not translate perfectly');
}
return { compatible: true, warnings };
}
return { compatible: true, warnings };
}
-289
View File
@@ -1,289 +0,0 @@
/**
* Agent Types
*
* Types for custom AI sub-agents (e.g., .claude/agents/*.md)
* Based on Claude Code's agent specification.
*/
import { z } from 'zod';
import type { AgentType } from '../types.js';
/**
* Agent permission modes
*/
export const AgentPermissionMode = z.enum([
'default', // Normal permission prompts
'plan', // Plan mode - ask before executing
'auto-edit', // Auto-accept edits
'full-auto', // Auto-accept everything (dangerous)
'bypassPermissions', // Skip all permission checks
]);
export type AgentPermissionMode = z.infer<typeof AgentPermissionMode>;
/**
* Agent hook definition
*/
export const AgentHook = z.object({
/** Hook event type */
type: z.enum([
'PreToolUse',
'PostToolUse',
'Stop',
'SubagentStop',
'SessionStart',
'SessionEnd',
]),
/** Command to run */
command: z.string(),
/** Timeout in milliseconds */
timeout: z.number().optional(),
/** Run only once */
once: z.boolean().optional(),
/** Tool matcher (for PreToolUse/PostToolUse) */
matcher: z.string().optional(),
});
export type AgentHook = z.infer<typeof AgentHook>;
/**
* Agent frontmatter schema
*/
export const AgentFrontmatter = z.object({
/** Agent name (kebab-case) */
name: z.string()
.min(1)
.max(64)
.regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, 'Agent name must be lowercase alphanumeric with hyphens'),
/** Description of what this agent does */
description: z.string().min(1).max(1024),
/** Model to use (e.g., 'opus', 'sonnet', 'haiku') */
model: z.string().optional(),
/** Permission mode for this agent */
permissionMode: AgentPermissionMode.optional(),
/** Tools this agent cannot use */
disallowedTools: z.array(z.string()).optional(),
/** Allowed tools for this agent */
allowedTools: z.union([
z.array(z.string()),
z.string(), // YAML-style list in frontmatter
]).optional(),
/** Agent-scoped hooks */
hooks: z.array(AgentHook).optional(),
/** Skills to auto-load for this agent */
skills: z.array(z.string()).optional(),
/** Run in forked sub-agent context */
context: z.enum(['fork', 'inline']).optional(),
/** Version */
version: z.string().optional(),
/** Author */
author: z.string().optional(),
/** Tags for categorization */
tags: z.array(z.string()).optional(),
/** Whether agent is user-invocable via @mention */
'user-invocable': z.boolean().optional(),
/** Argument hint for agent invocation */
'argument-hint': z.string().optional(),
});
export type AgentFrontmatter = z.infer<typeof AgentFrontmatter>;
/**
* Agent location (project or global)
*/
export const AgentLocation = z.enum(['project', 'global']);
export type AgentLocation = z.infer<typeof AgentLocation>;
/**
* Agent metadata (stored in .skillkit-agent.json)
*/
export const AgentMetadata = z.object({
name: z.string(),
description: z.string(),
source: z.string(),
sourceType: z.enum(['github', 'gitlab', 'bitbucket', 'local']),
subpath: z.string().optional(),
installedAt: z.string().datetime(),
updatedAt: z.string().datetime().optional(),
enabled: z.boolean().default(true),
version: z.string().optional(),
checksum: z.string().optional(),
});
export type AgentMetadata = z.infer<typeof AgentMetadata>;
/**
* Parsed agent definition
*/
export interface CustomAgent {
/** Agent name */
name: string;
/** Description */
description: string;
/** Path to agent directory or file */
path: string;
/** Project or global location */
location: AgentLocation;
/** Full frontmatter */
frontmatter: AgentFrontmatter;
/** Agent content (system prompt) */
content: string;
/** Metadata if installed via skillkit */
metadata?: AgentMetadata;
/** Whether agent is enabled */
enabled: boolean;
}
/**
* Canonical agent for translation
*/
export interface CanonicalAgent {
/** Agent name */
name: string;
/** Description */
description: string;
/** Model to use */
model?: string;
/** Permission mode */
permissionMode?: AgentPermissionMode;
/** Disallowed tools */
disallowedTools?: string[];
/** Allowed tools */
allowedTools?: string[];
/** Agent-scoped hooks */
hooks?: AgentHook[];
/** Skills to load */
skills?: string[];
/** Execution context */
context?: 'fork' | 'inline';
/** Version */
version?: string;
/** Author */
author?: string;
/** Tags */
tags?: string[];
/** User invocable */
userInvocable?: boolean;
/** Argument hint */
argumentHint?: string;
/** Main content (system prompt) */
content: string;
/** Source format */
sourceFormat: AgentFormatCategory;
/** Source agent type */
sourceAgent?: AgentType;
}
/**
* Agent format categories
*/
export type AgentFormatCategory =
| 'claude-agent' // Claude Code .claude/agents/*.md
| 'cursor-agent' // Cursor agent format (if different)
| 'universal'; // Universal agent format
/**
* Agent translation result
*/
export interface AgentTranslationResult {
/** Whether translation succeeded */
success: boolean;
/** Translated content */
content: string;
/** Output filename */
filename: string;
/** Warnings during translation */
warnings: string[];
/** Features that couldn't be translated */
incompatible: string[];
/** Target format */
targetFormat: AgentFormatCategory;
/** Target agent type */
targetAgent: AgentType;
}
/**
* Agent translation options
*/
export interface AgentTranslationOptions {
/** Preserve original comments */
preserveComments?: boolean;
/** Add translation metadata */
addMetadata?: boolean;
/** Custom output filename */
outputFilename?: string;
}
/**
* Agent discovery paths per AI coding agent (2026 updated)
*/
export const AGENT_DISCOVERY_PATHS: Record<AgentType, string[]> = {
'claude-code': ['.claude/agents'],
'cursor': ['.cursor/agents', '.cursor/commands'],
'codex': ['.codex/agents'],
'gemini-cli': ['.gemini/agents'],
'opencode': ['.opencode/agents', '.opencode/agent'],
'antigravity': ['.antigravity/agents'],
'amp': ['.amp/agents'],
'clawdbot': ['.clawdbot/agents', 'agents'],
'droid': ['.factory/agents'],
'github-copilot': ['.github/agents', '.github/instructions', '.github/custom-agents'],
'goose': ['.goose/agents'],
'kilo': ['.kilocode/agents', '.kilocode/modes'],
'kiro-cli': ['.kiro/agents'],
'roo': ['.roo/agents', '.roo/modes'],
'trae': ['.trae/agents', '.trae/agent'],
'windsurf': ['.windsurf/agents', '.windsurf/workflows'],
'universal': ['agents', '.agents'],
};
/**
* All agent discovery paths (union of all agent paths) - 2026 updated
*/
export const ALL_AGENT_DISCOVERY_PATHS = [
'agents',
'.agents',
'.claude/agents',
'.cursor/agents',
'.cursor/commands',
'.codex/agents',
'.gemini/agents',
'.opencode/agents',
'.opencode/agent',
'.antigravity/agents',
'.amp/agents',
'.clawdbot/agents',
'.factory/agents',
'.github/agents',
'.github/instructions',
'.github/custom-agents',
'.goose/agents',
'.kilocode/agents',
'.kilocode/modes',
'.kiro/agents',
'.roo/agents',
'.roo/modes',
'.trae/agents',
'.trae/agent',
'.windsurf/agents',
'.windsurf/workflows',
];
/**
* Agent format mapping (which agents use which format)
*/
export const CUSTOM_AGENT_FORMAT_MAP: Record<AgentType, AgentFormatCategory> = {
'claude-code': 'claude-agent',
'cursor': 'cursor-agent',
'codex': 'claude-agent',
'gemini-cli': 'claude-agent',
'opencode': 'claude-agent',
'antigravity': 'claude-agent',
'amp': 'claude-agent',
'clawdbot': 'claude-agent',
'droid': 'claude-agent',
'github-copilot': 'universal',
'goose': 'claude-agent',
'kilo': 'claude-agent',
'kiro-cli': 'claude-agent',
'roo': 'claude-agent',
'trae': 'claude-agent',
'windsurf': 'universal',
'universal': 'universal',
};
@@ -1,238 +0,0 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { AIManager } from '../manager.js';
import type { SearchableSkill, SkillExample } from '../types.js';
describe('AIManager', () => {
let manager: AIManager;
let testSkills: SearchableSkill[];
beforeEach(() => {
manager = new AIManager({
provider: 'mock',
});
testSkills = [
{
name: 'test-driven-development',
description: 'Write tests before code using TDD methodology',
content: 'TDD skill content',
tags: ['testing', 'tdd', 'quality'],
source: 'test-repo',
},
{
name: 'code-review',
description: 'Perform thorough code reviews',
content: 'Code review skill content',
tags: ['review', 'quality', 'collaboration'],
source: 'test-repo',
},
{
name: 'debugging-guide',
description: 'Systematic approach to debugging issues',
content: 'Debugging skill content',
tags: ['debugging', 'troubleshooting'],
source: 'test-repo',
},
];
});
describe('searchSkills', () => {
it('should search skills by query', async () => {
const results = await manager.searchSkills('testing', testSkills, {
minRelevance: 0,
});
expect(results.length).toBeGreaterThan(0);
expect(results[0].skill.name).toBe('test-driven-development');
expect(results[0].relevance).toBeGreaterThan(0);
});
it('should respect limit option', async () => {
const results = await manager.searchSkills('code', testSkills, {
limit: 1,
});
expect(results.length).toBeLessThanOrEqual(1);
});
it('should filter by min relevance', async () => {
const results = await manager.searchSkills('testing', testSkills, {
minRelevance: 0.8,
});
for (const result of results) {
expect(result.relevance).toBeGreaterThanOrEqual(0.8);
}
});
it('should include reasoning when requested', async () => {
const results = await manager.searchSkills('testing', testSkills, {
includeReasoning: true,
});
if (results.length > 0) {
expect(results[0].reasoning).toBeDefined();
expect(results[0].reasoning.length).toBeGreaterThan(0);
}
});
});
describe('searchByIntent', () => {
it('should search by user intent', async () => {
const results = await manager.searchByIntent(
'I want to improve my testing workflow',
testSkills,
{ minRelevance: 0 }
);
expect(results.length).toBeGreaterThan(0);
const names = results.map((r) => r.skill.name);
expect(names).toContain('test-driven-development');
});
});
describe('findSimilar', () => {
it('should find similar skills', async () => {
const targetSkill = testSkills[0];
const results = await manager.findSimilar(targetSkill, testSkills, {
minRelevance: 0,
});
expect(results.length).toBeGreaterThan(0);
results.forEach((r) => {
expect(r.skill.name).not.toBe(targetSkill.name);
});
});
});
describe('generateSkill', () => {
it('should generate skill from example', async () => {
const example: SkillExample = {
description: 'Help with API testing',
context: 'REST APIs using Jest',
};
const generated = await manager.generateSkill(example);
expect(generated.name).toBeDefined();
expect(generated.name.length).toBeGreaterThan(0);
expect(generated.description).toBe(example.description);
expect(generated.content).toBeDefined();
expect(generated.tags).toBeDefined();
expect(generated.confidence).toBeGreaterThan(0);
});
it('should include target agent metadata', async () => {
const example: SkillExample = {
description: 'Test skill',
};
const generated = await manager.generateSkill(example, {
targetAgent: 'claude-code',
});
expect(generated.content).toContain('agent: claude-code');
});
});
describe('generateFromCode', () => {
it('should generate skill from code example', async () => {
const code = `
function add(a: number, b: number): number {
return a + b;
}
`;
const description = 'Simple addition function';
const generated = await manager.generateFromCode(code, description);
expect(generated.name).toBeDefined();
expect(generated.description).toBe(description);
expect(generated.content).toContain('Example');
});
});
describe('generateFromTemplate', () => {
it('should generate skill from template', async () => {
const generated = await manager.generateFromTemplate(
'api-testing',
{ framework: 'Jest', type: 'REST' }
);
expect(generated.name).toBeDefined();
expect(generated.content).toBeDefined();
});
});
describe('validateGenerated', () => {
it('should validate valid generated skill', () => {
const skill = {
name: 'valid-skill-name',
description: 'This is a valid description with enough length',
content: 'This is valid content with enough length to pass validation checks',
tags: ['test', 'valid'],
confidence: 0.8,
reasoning: 'Valid reasoning',
};
const result = manager.validateGenerated(skill);
expect(result.valid).toBe(true);
expect(result.errors).toHaveLength(0);
});
it('should reject skill with short name', () => {
const skill = {
name: 'ab',
description: 'Valid description',
content: 'Valid content with enough length',
tags: [],
confidence: 0.8,
reasoning: '',
};
const result = manager.validateGenerated(skill);
expect(result.valid).toBe(false);
expect(result.errors).toContain(
'Skill name must be at least 3 characters'
);
});
it('should reject skill with low confidence', () => {
const skill = {
name: 'valid-name',
description: 'Valid description',
content: 'Valid content with enough length',
tags: [],
confidence: 0.4,
reasoning: '',
};
const result = manager.validateGenerated(skill);
expect(result.valid).toBe(false);
expect(result.errors).toContain(
'Skill confidence is too low (< 0.6)'
);
});
});
describe('getProviderName', () => {
it('should return provider name', () => {
const name = manager.getProviderName();
expect(name).toBe('mock');
});
});
describe('updateConfig', () => {
it('should update configuration', () => {
manager.updateConfig({
temperature: 0.5,
});
// Provider should be recreated
expect(manager.getProviderName()).toBe('mock');
});
});
});
-89
View File
@@ -1,89 +0,0 @@
import type {
AIProvider,
AIGenerateOptions,
GeneratedSkill,
SkillExample,
} from './types.js';
export class AISkillGenerator {
constructor(private provider: AIProvider) {}
async generate(
example: SkillExample,
options: AIGenerateOptions = {}
): Promise<GeneratedSkill> {
const skill = await this.provider.generateSkill(example);
if (options.targetAgent && skill.content) {
skill.content = this.addAgentMetadata(skill.content, options.targetAgent);
}
return skill;
}
async generateFromCode(
code: string,
description: string,
options: AIGenerateOptions = {}
): Promise<GeneratedSkill> {
return this.generate(
{
description,
codeExamples: [code],
},
options
);
}
async generateFromTemplate(
templateName: string,
variables: Record<string, string>,
options: AIGenerateOptions = {}
): Promise<GeneratedSkill> {
return this.generate(
{
description: `Create a skill based on the ${templateName} template with the following customization: ${JSON.stringify(variables)}`,
context: `Template: ${templateName}`,
},
options
);
}
private addAgentMetadata(content: string, agent: string): string {
const metadata = `---
agent: ${agent}
generated: ${new Date().toISOString()}
---
${content}`;
return metadata;
}
validateGenerated(skill: GeneratedSkill): {
valid: boolean;
errors: string[];
} {
const errors: string[] = [];
if (!skill.name || skill.name.length < 3) {
errors.push('Skill name must be at least 3 characters');
}
if (!skill.description || skill.description.length < 10) {
errors.push('Skill description must be at least 10 characters');
}
if (!skill.content || skill.content.length < 50) {
errors.push('Skill content must be at least 50 characters');
}
if (skill.confidence < 0.6) {
errors.push('Skill confidence is too low (< 0.6)');
}
return {
valid: errors.length === 0,
errors,
};
}
}
-5
View File
@@ -1,5 +0,0 @@
export * from './types.js';
export * from './search.js';
export * from './generator.js';
export * from './manager.js';
export * from './providers/index.js';
-104
View File
@@ -1,104 +0,0 @@
import type {
AIConfig,
AIProvider,
AISearchOptions,
AISearchResult,
AIGenerateOptions,
GeneratedSkill,
SearchableSkill,
SkillExample,
} from './types.js';
import { AISearch } from './search.js';
import { AISkillGenerator } from './generator.js';
import { MockAIProvider } from './providers/mock.js';
export class AIManager {
private provider: AIProvider;
private search: AISearch;
private generator: AISkillGenerator;
constructor(private config: AIConfig) {
this.provider = this.createProvider();
this.search = new AISearch(this.provider);
this.generator = new AISkillGenerator(this.provider);
}
async searchSkills(
query: string,
skills: SearchableSkill[],
options?: AISearchOptions
): Promise<AISearchResult[]> {
return this.search.search(query, skills, options);
}
async searchByIntent(
intent: string,
skills: SearchableSkill[],
options?: AISearchOptions
): Promise<AISearchResult[]> {
return this.search.searchByIntent(intent, skills, options);
}
async findSimilar(
skill: SearchableSkill,
allSkills: SearchableSkill[],
options?: AISearchOptions
): Promise<AISearchResult[]> {
return this.search.findSimilar(skill, allSkills, options);
}
async generateSkill(
example: SkillExample,
options?: AIGenerateOptions
): Promise<GeneratedSkill> {
return this.generator.generate(example, options);
}
async generateFromCode(
code: string,
description: string,
options?: AIGenerateOptions
): Promise<GeneratedSkill> {
return this.generator.generateFromCode(code, description, options);
}
async generateFromTemplate(
templateName: string,
variables: Record<string, string>,
options?: AIGenerateOptions
): Promise<GeneratedSkill> {
return this.generator.generateFromTemplate(templateName, variables, options);
}
validateGenerated(skill: GeneratedSkill): {
valid: boolean;
errors: string[];
} {
return this.generator.validateGenerated(skill);
}
private createProvider(): AIProvider {
if (this.config.provider === 'none' || !this.config.apiKey) {
return new MockAIProvider();
}
switch (this.config.provider) {
case 'anthropic':
case 'openai':
return new MockAIProvider();
default:
return new MockAIProvider();
}
}
getProviderName(): string {
return this.provider.name;
}
updateConfig(config: Partial<AIConfig>): void {
this.config = { ...this.config, ...config };
this.provider = this.createProvider();
this.search = new AISearch(this.provider);
this.generator = new AISkillGenerator(this.provider);
}
}
-119
View File
@@ -1,119 +0,0 @@
import type {
AIProvider,
AISearchResult,
GeneratedSkill,
SearchableSkill,
SkillExample,
} from '../types.js';
export abstract class BaseAIProvider implements AIProvider {
abstract name: string;
abstract search(
query: string,
skills: SearchableSkill[]
): Promise<AISearchResult[]>;
abstract generateSkill(example: SkillExample): Promise<GeneratedSkill>;
protected buildSearchPrompt(query: string, skills: SearchableSkill[]): string {
const skillsList = skills
.map(
(s, i) =>
`${i + 1}. ${s.name}${s.description ? ` - ${s.description}` : ''}${s.tags ? ` [${s.tags.join(', ')}]` : ''}`
)
.join('\n');
return `You are a skill search assistant. Given a user query and a list of available skills, identify the most relevant skills.
User Query: "${query}"
Available Skills:
${skillsList}
For each relevant skill (up to 10), provide:
1. Skill index number
2. Relevance score (0-1)
3. Brief reasoning
Format your response as JSON:
[
{
"index": <number>,
"relevance": <0-1>,
"reasoning": "<explanation>"
}
]`;
}
protected buildGeneratePrompt(example: SkillExample): string {
let prompt = `You are a skill generation assistant. Generate a complete skill based on the following specification:
Description: ${example.description}`;
if (example.context) {
prompt += `\n\nContext: ${example.context}`;
}
if (example.codeExamples && example.codeExamples.length > 0) {
prompt += `\n\nCode Examples:\n${example.codeExamples.map((code, i) => `Example ${i + 1}:\n\`\`\`\n${code}\n\`\`\``).join('\n\n')}`;
}
if (example.expectedBehavior) {
prompt += `\n\nExpected Behavior: ${example.expectedBehavior}`;
}
prompt += `
Generate a skill in SKILL.md format with:
1. Clear name (kebab-case)
2. Comprehensive description
3. Detailed instructions
4. Relevant tags
5. Usage examples if applicable
Format your response as JSON:
{
"name": "<skill-name>",
"description": "<description>",
"content": "<full SKILL.md content>",
"tags": ["<tag1>", "<tag2>"],
"confidence": <0-1>,
"reasoning": "<why this skill design>"
}`;
return prompt;
}
protected parseSearchResponse(
response: string,
skills: SearchableSkill[]
): AISearchResult[] {
try {
const parsed = JSON.parse(response);
return parsed.map((item: any) => ({
skill: skills[item.index - 1],
relevance: item.relevance,
reasoning: item.reasoning,
}));
} catch {
return [];
}
}
protected parseGenerateResponse(response: string): GeneratedSkill {
try {
const parsed = JSON.parse(response);
return {
name: parsed.name,
description: parsed.description,
content: parsed.content,
tags: parsed.tags || [],
confidence: parsed.confidence || 0.7,
reasoning: parsed.reasoning || '',
};
} catch {
throw new Error('Failed to parse skill generation response');
}
}
}
-2
View File
@@ -1,2 +0,0 @@
export { BaseAIProvider } from './base.js';
export { MockAIProvider } from './mock.js';
-144
View File
@@ -1,144 +0,0 @@
import { BaseAIProvider } from './base.js';
import type {
AISearchResult,
GeneratedSkill,
SearchableSkill,
SkillExample,
} from '../types.js';
export class MockAIProvider extends BaseAIProvider {
name = 'mock';
async search(
query: string,
skills: SearchableSkill[]
): Promise<AISearchResult[]> {
const lowerQuery = query.toLowerCase();
const queryTerms = lowerQuery.split(/\s+/).filter((t) => t.length > 2);
return skills
.map((skill) => {
let relevance = 0;
const nameMatch = skill.name.toLowerCase().includes(lowerQuery);
const descMatch = skill.description?.toLowerCase().includes(lowerQuery);
const tagMatch = skill.tags?.some((t) =>
t.toLowerCase().includes(lowerQuery)
);
const contentMatch = skill.content.toLowerCase().includes(lowerQuery);
// Also check individual terms
const nameTermMatch = queryTerms.some((term) =>
skill.name.toLowerCase().includes(term)
);
const descTermMatch = queryTerms.some(
(term) => skill.description?.toLowerCase().includes(term)
);
const tagTermMatch = queryTerms.some((term) =>
skill.tags?.some((t) => t.toLowerCase().includes(term))
);
if (nameMatch) relevance += 0.5;
if (descMatch) relevance += 0.3;
if (tagMatch) relevance += 0.2;
if (contentMatch) relevance += 0.1;
// Partial term matches
if (!nameMatch && nameTermMatch) relevance += 0.3;
if (!descMatch && descTermMatch) relevance += 0.2;
if (!tagMatch && tagTermMatch) relevance += 0.15;
relevance = Math.min(1, relevance);
return {
skill,
relevance,
reasoning: this.buildReasoning(
nameMatch || nameTermMatch,
descMatch || descTermMatch,
tagMatch || tagTermMatch,
contentMatch
),
};
})
.filter((r) => r.relevance > 0)
.sort((a, b) => b.relevance - a.relevance)
.slice(0, 10);
}
async generateSkill(example: SkillExample): Promise<GeneratedSkill> {
const name = this.generateName(example.description);
const tags = this.generateTags(example.description);
return {
name,
description: example.description,
content: this.generateContent(name, example),
tags,
confidence: 0.75,
reasoning: 'Mock generated skill based on description and examples',
};
}
private buildReasoning(
nameMatch: boolean,
descMatch: boolean | undefined,
tagMatch: boolean | undefined,
contentMatch: boolean
): string {
const matches: string[] = [];
if (nameMatch) matches.push('name');
if (descMatch === true) matches.push('description');
if (tagMatch === true) matches.push('tags');
if (contentMatch) matches.push('content');
return matches.length > 0
? `Matched in: ${matches.join(', ')}`
: 'No significant matches';
}
private generateName(description: string): string {
return description
.toLowerCase()
.replace(/[^a-z0-9\s]/g, '')
.split(/\s+/)
.slice(0, 3)
.join('-');
}
private generateTags(description: string): string[] {
const commonTags = ['productivity', 'automation', 'development'];
if (description.toLowerCase().includes('test')) commonTags.push('testing');
if (description.toLowerCase().includes('debug'))
commonTags.push('debugging');
if (description.toLowerCase().includes('code')) commonTags.push('coding');
return commonTags.slice(0, 5);
}
private generateContent(name: string, example: SkillExample): string {
let content = `# ${name}\n\n${example.description}\n\n`;
if (example.context) {
content += `## Context\n\n${example.context}\n\n`;
}
content += `## Instructions\n\n`;
content += `1. Review the task requirements\n`;
content += `2. Implement the solution\n`;
content += `3. Test the implementation\n`;
content += `4. Document the changes\n\n`;
if (example.codeExamples && example.codeExamples.length > 0) {
content += `## Examples\n\n`;
example.codeExamples.forEach((code, i) => {
content += `### Example ${i + 1}\n\n\`\`\`\n${code}\n\`\`\`\n\n`;
});
}
if (example.expectedBehavior) {
content += `## Expected Behavior\n\n${example.expectedBehavior}\n`;
}
return content;
}
}
-55
View File
@@ -1,55 +0,0 @@
import type {
AIProvider,
AISearchOptions,
AISearchResult,
SearchableSkill,
} from './types.js';
export class AISearch {
constructor(private provider: AIProvider) {}
async search(
query: string,
skills: SearchableSkill[],
options: AISearchOptions = {}
): Promise<AISearchResult[]> {
const {
limit = 10,
minRelevance = 0.5,
includeReasoning = true,
} = options;
const results = await this.provider.search(query, skills);
const filtered = results
.filter((r) => r.relevance >= minRelevance)
.slice(0, limit);
if (!includeReasoning) {
filtered.forEach((r) => {
r.reasoning = '';
});
}
return filtered;
}
async searchByIntent(
intent: string,
skills: SearchableSkill[],
options: AISearchOptions = {}
): Promise<AISearchResult[]> {
const enhancedQuery = `Find skills that help with: ${intent}. Consider the skill's purpose, capabilities, and use cases.`;
return this.search(enhancedQuery, skills, options);
}
async findSimilar(
skill: SearchableSkill,
allSkills: SearchableSkill[],
options: AISearchOptions = {}
): Promise<AISearchResult[]> {
const query = `Find skills similar to "${skill.name}". ${skill.description ? `This skill: ${skill.description}` : ''}`;
const filtered = allSkills.filter((s) => s.name !== skill.name);
return this.search(query, filtered, options);
}
}
-56
View File
@@ -1,56 +0,0 @@
export interface AIProvider {
name: string;
search(query: string, skills: SearchableSkill[]): Promise<AISearchResult[]>;
generateSkill(example: SkillExample): Promise<GeneratedSkill>;
}
export interface SearchableSkill {
name: string;
description?: string;
content: string;
tags?: string[];
source?: string;
}
export interface AISearchResult {
skill: SearchableSkill;
relevance: number;
reasoning: string;
}
export interface SkillExample {
description: string;
context?: string;
codeExamples?: string[];
expectedBehavior?: string;
targetAgent?: string;
}
export interface GeneratedSkill {
name: string;
description: string;
content: string;
tags: string[];
confidence: number;
reasoning: string;
}
export interface AIConfig {
provider: 'anthropic' | 'openai' | 'none';
apiKey?: string;
model?: string;
maxTokens?: number;
temperature?: number;
}
export interface AISearchOptions {
limit?: number;
minRelevance?: number;
includeReasoning?: boolean;
}
export interface AIGenerateOptions {
targetAgent?: string;
includeTests?: boolean;
includeDocumentation?: boolean;
}
@@ -1,309 +0,0 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { promises as fs } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
import { AuditLogger } from '../logger.js';
describe('AuditLogger', () => {
let logger: AuditLogger;
let tempDir: string;
beforeEach(async () => {
tempDir = join(tmpdir(), `skillkit-audit-test-${Date.now()}`);
await fs.mkdir(tempDir, { recursive: true });
logger = new AuditLogger(tempDir);
});
afterEach(async () => {
await logger.destroy();
try {
await fs.rm(tempDir, { recursive: true, force: true });
} catch {
// Ignore cleanup errors
}
});
describe('log', () => {
it('should log an event', async () => {
await logger.log(
'skill.install',
'install',
'test-skill',
{ source: 'github' },
true
);
await logger.flush();
const events = await logger.query();
expect(events.length).toBe(1);
expect(events[0].type).toBe('skill.install');
expect(events[0].action).toBe('install');
expect(events[0].resource).toBe('test-skill');
expect(events[0].success).toBe(true);
});
it('should log failure event', async () => {
await logger.log(
'skill.install',
'install',
'test-skill',
{},
false,
'Network error'
);
await logger.flush();
const events = await logger.query();
expect(events[0].success).toBe(false);
expect(events[0].error).toBe('Network error');
});
it('should log event with duration', async () => {
await logger.log(
'skill.execute',
'execute',
'test-skill',
{},
true,
undefined,
1234
);
await logger.flush();
const events = await logger.query();
expect(events[0].duration).toBe(1234);
});
it('should auto-flush when buffer reaches limit', async () => {
for (let i = 0; i < 15; i++) {
await logger.log(
'skill.sync',
'sync',
`skill-${i}`,
{},
true
);
}
const events = await logger.query();
expect(events.length).toBeGreaterThan(0);
});
});
describe('query', () => {
beforeEach(async () => {
await logger.log('skill.install', 'install', 'skill-1', {}, true);
await logger.log('skill.uninstall', 'uninstall', 'skill-2', {}, true);
await logger.log('team.create', 'create', 'team-1', {}, true);
await logger.log('skill.install', 'install', 'skill-3', {}, false, 'Error');
await logger.flush();
});
it('should query all events', async () => {
const events = await logger.query();
expect(events.length).toBe(4);
});
it('should filter by type', async () => {
const events = await logger.query({
types: ['skill.install'],
});
expect(events.length).toBe(2);
events.forEach((e) => {
expect(e.type).toBe('skill.install');
});
});
it('should filter by success', async () => {
const events = await logger.query({
success: true,
});
expect(events.length).toBe(3);
events.forEach((e) => {
expect(e.success).toBe(true);
});
});
it('should filter by resource', async () => {
const events = await logger.query({
resource: 'skill-1',
});
expect(events.length).toBe(1);
expect(events[0].resource).toBe('skill-1');
});
it('should filter by date range', async () => {
const startDate = new Date(Date.now() - 1000);
const endDate = new Date(Date.now() + 1000);
const events = await logger.query({
startDate,
endDate,
});
expect(events.length).toBe(4);
});
it('should respect limit', async () => {
const events = await logger.query({
limit: 2,
});
expect(events.length).toBe(2);
});
it('should respect offset', async () => {
const events = await logger.query({
offset: 2,
});
expect(events.length).toBe(2);
});
});
describe('stats', () => {
beforeEach(async () => {
await logger.log('skill.install', 'install', 'skill-1', {}, true);
await logger.log('skill.install', 'install', 'skill-2', {}, true);
await logger.log('skill.install', 'install', 'skill-3', {}, false, 'Error');
await logger.log('team.create', 'create', 'team-1', {}, true);
await logger.flush();
});
it('should calculate stats', async () => {
const stats = await logger.stats();
expect(stats.totalEvents).toBe(4);
expect(stats.successRate).toBe(0.75); // 3 out of 4
expect(stats.eventsByType['skill.install']).toBe(3);
expect(stats.eventsByType['team.create']).toBe(1);
});
it('should include recent errors', async () => {
const stats = await logger.stats();
expect(stats.recentErrors.length).toBe(1);
expect(stats.recentErrors[0].error).toBe('Error');
});
it('should include top resources', async () => {
const stats = await logger.stats();
expect(stats.topResources.length).toBeGreaterThan(0);
expect(stats.topResources[0].count).toBeGreaterThan(0);
});
});
describe('export', () => {
beforeEach(async () => {
await logger.log('skill.install', 'install', 'skill-1', {}, true);
await logger.log('team.create', 'create', 'team-1', {}, true);
await logger.flush();
});
it('should export to JSON', async () => {
const content = await logger.export({ format: 'json' });
const parsed = JSON.parse(content);
expect(Array.isArray(parsed)).toBe(true);
expect(parsed.length).toBe(2);
});
it('should export to CSV', async () => {
const content = await logger.export({ format: 'csv' });
expect(content).toContain('ID,Timestamp,Type');
expect(content).toContain('skill.install');
expect(content).toContain('team.create');
});
it('should export to text', async () => {
const content = await logger.export({ format: 'text' });
expect(content).toContain('skill.install');
expect(content).toContain('SUCCESS');
});
it('should export with query filter', async () => {
const content = await logger.export({
format: 'json',
query: { types: ['skill.install'] },
});
const parsed = JSON.parse(content);
expect(parsed.length).toBe(1);
expect(parsed[0].type).toBe('skill.install');
});
});
describe('clear', () => {
beforeEach(async () => {
const oldDate = new Date(Date.now() - 1000 * 60 * 60 * 24 * 40);
const recentDate = new Date();
await logger.log('skill.install', 'install', 'old-skill', {}, true);
await logger.flush();
const events = await logger.query();
events[0].timestamp = oldDate;
const logFile = join(tempDir, 'audit.log');
const content = events.map((e) => JSON.stringify(e)).join('\n');
await fs.writeFile(logFile, content, 'utf-8');
await logger.log('skill.install', 'install', 'new-skill', {}, true);
await logger.flush();
});
it('should clear old entries', async () => {
const cutoffDate = new Date(Date.now() - 1000 * 60 * 60 * 24 * 30);
const cleared = await logger.clear(cutoffDate);
expect(cleared).toBeGreaterThan(0);
const events = await logger.query();
events.forEach((e) => {
expect(e.timestamp.getTime()).toBeGreaterThanOrEqual(
cutoffDate.getTime()
);
});
});
it('should clear all entries when no date provided', async () => {
const cleared = await logger.clear();
expect(cleared).toBeGreaterThan(0);
const events = await logger.query();
expect(events.length).toBe(0);
});
});
describe('flush', () => {
it('should persist buffered events', async () => {
await logger.log('skill.install', 'install', 'skill-1', {}, true);
// Don't auto-flush
let events = await logger.query();
expect(events.length).toBe(0);
await logger.flush();
events = await logger.query();
expect(events.length).toBe(1);
});
it('should handle empty buffer', async () => {
await logger.flush();
const events = await logger.query();
expect(events.length).toBe(0);
});
});
});
-2
View File
@@ -1,2 +0,0 @@
export * from './types.js';
export * from './logger.js';
-293
View File
@@ -1,293 +0,0 @@
import { promises as fs } from 'fs';
import path from 'path';
import type {
AuditEvent,
AuditEventType,
AuditQuery,
AuditStats,
AuditExportOptions,
} from './types.js';
export class AuditLogger {
private logFile: string;
private buffer: AuditEvent[] = [];
private flushInterval: NodeJS.Timeout | null = null;
private flushing: Promise<void> | null = null;
constructor(logDir: string) {
this.logFile = path.join(logDir, 'audit.log');
this.startAutoFlush();
}
async log(
type: AuditEventType,
action: string,
resource: string,
details?: Record<string, unknown>,
success: boolean = true,
error?: string,
duration?: number
): Promise<void> {
const event: AuditEvent = {
id: this.generateId(),
timestamp: new Date(),
type,
user: process.env.USER || 'unknown',
action,
resource,
details,
success,
error,
duration,
};
this.buffer.push(event);
if (this.buffer.length >= 10) {
await this.flush();
}
}
async query(query: AuditQuery = {}): Promise<AuditEvent[]> {
const events = await this.loadEvents();
return this.filterEvents(events, query);
}
async stats(): Promise<AuditStats> {
const events = await this.loadEvents();
const totalEvents = events.length;
const successEvents = events.filter((e) => e.success).length;
const successRate = totalEvents > 0 ? successEvents / totalEvents : 0;
const eventsByType: Record<AuditEventType, number> = {} as any;
events.forEach((e) => {
eventsByType[e.type] = (eventsByType[e.type] || 0) + 1;
});
const recentErrors = events
.filter((e) => !e.success)
.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
.slice(0, 10);
const resourceCounts = new Map<string, number>();
events.forEach((e) => {
resourceCounts.set(e.resource, (resourceCounts.get(e.resource) || 0) + 1);
});
const topResources = Array.from(resourceCounts.entries())
.map(([resource, count]) => ({ resource, count }))
.sort((a, b) => b.count - a.count)
.slice(0, 10);
return {
totalEvents,
successRate,
eventsByType,
recentErrors,
topResources,
};
}
async export(options: AuditExportOptions): Promise<string> {
const events = await this.query(options.query);
switch (options.format) {
case 'json':
return JSON.stringify(events, null, 2);
case 'csv':
return this.toCsv(events);
case 'text':
return this.toText(events);
default:
return JSON.stringify(events, null, 2);
}
}
async clear(olderThan?: Date): Promise<number> {
const events = await this.loadEvents();
const filtered = olderThan
? events.filter((e) => e.timestamp >= olderThan)
: [];
await this.saveEvents(filtered);
return events.length - filtered.length;
}
async flush(): Promise<void> {
// If already flushing, wait for it to complete
if (this.flushing) {
return this.flushing;
}
if (this.buffer.length === 0) {
return;
}
// Start flush with mutex
this.flushing = this.doFlush();
try {
await this.flushing;
} finally {
this.flushing = null;
}
}
private async doFlush(): Promise<void> {
// Snapshot buffer and clear it before async operations
const toFlush = this.buffer;
this.buffer = [];
try {
const events = await this.loadEvents();
events.push(...toFlush);
await this.saveEvents(events);
} catch (error) {
// Restore events on failure
this.buffer = [...toFlush, ...this.buffer];
console.error('Failed to flush audit log:', error);
}
}
async destroy(): Promise<void> {
if (this.flushInterval) {
clearInterval(this.flushInterval);
this.flushInterval = null;
}
await this.flush();
}
private startAutoFlush(): void {
this.flushInterval = setInterval(
() => {
this.flush().catch(console.error);
},
30000
);
}
private async loadEvents(): Promise<AuditEvent[]> {
try {
const content = await fs.readFile(this.logFile, 'utf-8');
const events: AuditEvent[] = [];
for (const line of content.split('\n')) {
if (!line.trim()) continue;
try {
const event = JSON.parse(line);
event.timestamp = new Date(event.timestamp);
events.push(event);
} catch (error) {
// Skip malformed lines silently to prevent data loss
// Malformed lines are ignored, valid events are preserved
continue;
}
}
return events;
} catch (error) {
// Only propagate genuine filesystem errors
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
throw error;
}
return [];
}
}
private async saveEvents(events: AuditEvent[]): Promise<void> {
const dir = path.dirname(this.logFile);
await fs.mkdir(dir, { recursive: true });
const content = events.map((e) => JSON.stringify(e)).join('\n');
await fs.writeFile(this.logFile, content, 'utf-8');
}
private filterEvents(events: AuditEvent[], query: AuditQuery): AuditEvent[] {
let filtered = events;
if (query.types && query.types.length > 0) {
filtered = filtered.filter((e) => query.types!.includes(e.type));
}
if (query.user) {
filtered = filtered.filter((e) => e.user === query.user);
}
if (query.resource) {
filtered = filtered.filter((e) =>
e.resource.toLowerCase().includes(query.resource!.toLowerCase())
);
}
if (query.startDate) {
filtered = filtered.filter((e) => e.timestamp >= query.startDate!);
}
if (query.endDate) {
filtered = filtered.filter((e) => e.timestamp <= query.endDate!);
}
if (query.success !== undefined) {
filtered = filtered.filter((e) => e.success === query.success);
}
filtered.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
if (query.offset !== undefined && query.offset !== null) {
filtered = filtered.slice(query.offset);
}
if (query.limit !== undefined && query.limit !== null) {
filtered = filtered.slice(0, query.limit);
}
return filtered;
}
private generateId(): string {
return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
}
private toCsv(events: AuditEvent[]): string {
const headers = [
'ID',
'Timestamp',
'Type',
'User',
'Action',
'Resource',
'Success',
'Error',
'Duration',
];
const rows = events.map((e) => [
e.id,
e.timestamp.toISOString(),
e.type,
e.user || '',
e.action,
e.resource,
e.success ? 'true' : 'false',
e.error || '',
e.duration?.toString() || '',
]);
return [headers.join(','), ...rows.map((r) => r.join(','))].join('\n');
}
private toText(events: AuditEvent[]): string {
return events
.map((e) => {
let text = `[${e.timestamp.toISOString()}] ${e.type} - ${e.action} on ${e.resource}`;
if (e.user) text += ` by ${e.user}`;
text += ` (${e.success ? 'SUCCESS' : 'FAILED'})`;
if (e.error) text += `\n Error: ${e.error}`;
if (e.duration) text += `\n Duration: ${e.duration}ms`;
return text;
})
.join('\n\n');
}
}
-57
View File
@@ -1,57 +0,0 @@
export type AuditEventType =
| 'skill.install'
| 'skill.uninstall'
| 'skill.sync'
| 'skill.translate'
| 'skill.execute'
| 'team.create'
| 'team.share'
| 'team.import'
| 'team.sync'
| 'bundle.create'
| 'bundle.export'
| 'bundle.import'
| 'plugin.install'
| 'plugin.uninstall'
| 'plugin.enable'
| 'plugin.disable'
| 'workflow.execute'
| 'ai.search'
| 'ai.generate';
export interface AuditEvent {
id: string;
timestamp: Date;
type: AuditEventType;
user?: string;
action: string;
resource: string;
details?: Record<string, unknown>;
success: boolean;
error?: string;
duration?: number;
}
export interface AuditQuery {
types?: AuditEventType[];
user?: string;
resource?: string;
startDate?: Date;
endDate?: Date;
success?: boolean;
limit?: number;
offset?: number;
}
export interface AuditStats {
totalEvents: number;
successRate: number;
eventsByType: Record<AuditEventType, number>;
recentErrors: AuditEvent[];
topResources: Array<{ resource: string; count: number }>;
}
export interface AuditExportOptions {
format: 'json' | 'csv' | 'text';
query?: AuditQuery;
}
@@ -1,589 +0,0 @@
/**
* Commands Module Tests
*/
import { describe, it, expect, beforeEach } from 'vitest';
import {
CommandRegistry,
createCommandRegistry,
CommandGenerator,
createCommandGenerator,
getAgentFormat,
supportsSlashCommands,
} from '../index.js';
import type { SlashCommand, CommandContext, AgentType } from '../types.js';
describe('CommandRegistry', () => {
let registry: CommandRegistry;
beforeEach(() => {
registry = createCommandRegistry({ allowOverrides: true });
});
describe('register', () => {
it('should register a valid command', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
};
registry.register(command);
expect(registry.has('test-cmd')).toBe(true);
expect(registry.size).toBe(1);
});
it('should register command with aliases', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
aliases: ['tc', 'test'],
};
registry.register(command);
expect(registry.has('test-cmd')).toBe(true);
expect(registry.has('tc')).toBe(true);
expect(registry.has('test')).toBe(true);
});
it('should throw on duplicate command without override', () => {
const strictRegistry = createCommandRegistry({ allowOverrides: false });
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
};
strictRegistry.register(command);
expect(() => strictRegistry.register(command)).toThrow('Command already registered');
});
it('should allow override when enabled', () => {
const command1: SlashCommand = {
name: 'test-cmd',
description: 'First version',
skill: 'test-skill',
};
const command2: SlashCommand = {
name: 'test-cmd',
description: 'Second version',
skill: 'test-skill-2',
};
registry.register(command1);
registry.register(command2);
expect(registry.get('test-cmd')?.description).toBe('Second version');
});
it('should validate command on register', () => {
const invalidCommand: SlashCommand = {
name: '', // Invalid: empty name
description: 'Test',
skill: 'test',
};
expect(() => registry.register(invalidCommand)).toThrow('Invalid command');
});
});
describe('unregister', () => {
it('should unregister a command', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
aliases: ['tc'],
};
registry.register(command);
expect(registry.has('test-cmd')).toBe(true);
const result = registry.unregister('test-cmd');
expect(result).toBe(true);
expect(registry.has('test-cmd')).toBe(false);
expect(registry.has('tc')).toBe(false);
});
it('should return false for non-existent command', () => {
const result = registry.unregister('non-existent');
expect(result).toBe(false);
});
});
describe('get', () => {
it('should get command by name', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
};
registry.register(command);
const result = registry.get('test-cmd');
expect(result?.name).toBe('test-cmd');
});
it('should get command by alias', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
aliases: ['tc'],
};
registry.register(command);
const result = registry.get('tc');
expect(result?.name).toBe('test-cmd');
});
it('should return undefined for non-existent command', () => {
const result = registry.get('non-existent');
expect(result).toBeUndefined();
});
});
describe('search', () => {
beforeEach(() => {
registry.register({
name: 'test-one',
description: 'First test command',
skill: 'skill-one',
category: 'testing',
tags: ['test', 'one'],
});
registry.register({
name: 'test-two',
description: 'Second test command',
skill: 'skill-two',
category: 'testing',
tags: ['test', 'two'],
});
registry.register({
name: 'deploy',
description: 'Deploy command',
skill: 'deploy-skill',
category: 'deployment',
tags: ['deploy'],
});
});
it('should search by query', () => {
const results = registry.search({ query: 'test' });
expect(results).toHaveLength(2);
});
it('should search by category', () => {
const results = registry.search({ category: 'testing' });
expect(results).toHaveLength(2);
});
it('should search by tags', () => {
const results = registry.search({ tags: ['deploy'] });
expect(results).toHaveLength(1);
expect(results[0].name).toBe('deploy');
});
it('should limit results', () => {
const results = registry.search({ limit: 1 });
expect(results).toHaveLength(1);
});
});
describe('enable/disable', () => {
it('should disable a command', () => {
registry.register({
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
});
registry.disable('test-cmd');
const cmd = registry.get('test-cmd');
expect(cmd?.enabled).toBe(false);
});
it('should enable a command', () => {
registry.register({
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
});
registry.disable('test-cmd');
registry.enable('test-cmd');
const cmd = registry.get('test-cmd');
expect(cmd?.enabled).toBe(true);
});
});
describe('execute', () => {
it('should execute command with handler', async () => {
registry.register(
{
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
},
async () => ({
success: true,
output: 'Executed',
})
);
const context: Omit<CommandContext, 'command'> = {
args: {},
agent: 'claude-code' as AgentType,
cwd: '/test',
};
const result = await registry.execute('test-cmd', context);
expect(result.success).toBe(true);
expect(result.output).toBe('Executed');
});
it('should return error for non-existent command', async () => {
const result = await registry.execute('non-existent', {
args: {},
agent: 'claude-code' as AgentType,
cwd: '/test',
});
expect(result.success).toBe(false);
expect(result.error).toContain('not found');
});
it('should return error for disabled command', async () => {
registry.register({
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
});
registry.disable('test-cmd');
const result = await registry.execute('test-cmd', {
args: {},
agent: 'claude-code' as AgentType,
cwd: '/test',
});
expect(result.success).toBe(false);
expect(result.error).toContain('disabled');
});
});
describe('validate', () => {
it('should validate valid command', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
examples: ['/test-cmd'],
};
const result = registry.validate(command);
expect(result.valid).toBe(true);
expect(result.errors).toHaveLength(0);
});
it('should reject command without name', () => {
const command: SlashCommand = {
name: '',
description: 'Test command',
skill: 'test-skill',
};
const result = registry.validate(command);
expect(result.valid).toBe(false);
expect(result.errors).toContain('Command must have a name');
});
it('should reject command with invalid name format', () => {
const command: SlashCommand = {
name: 'INVALID_NAME',
description: 'Test command',
skill: 'test-skill',
};
const result = registry.validate(command);
expect(result.valid).toBe(false);
});
it('should warn about missing examples', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
};
const result = registry.validate(command);
expect(result.warnings).toContain('Command has no usage examples');
});
});
describe('export/import', () => {
it('should export commands to bundle', () => {
registry.register({
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
});
const bundle = registry.export();
expect(bundle.version).toBe('1.0.0');
expect(bundle.commands).toHaveLength(1);
expect(bundle.commands[0].name).toBe('test-cmd');
});
it('should import commands from bundle', () => {
const bundle = {
version: '1.0.0',
commands: [
{
name: 'imported-cmd',
description: 'Imported command',
skill: 'imported-skill',
},
],
};
const imported = registry.import(bundle);
expect(imported).toBe(1);
expect(registry.has('imported-cmd')).toBe(true);
});
});
describe('getCategories', () => {
it('should return unique categories', () => {
registry.register({
name: 'cmd-one',
description: 'Command one',
skill: 'skill',
category: 'testing',
});
registry.register({
name: 'cmd-two',
description: 'Command two',
skill: 'skill',
category: 'debugging',
});
registry.register({
name: 'cmd-three',
description: 'Command three',
skill: 'skill',
category: 'testing',
});
const categories = registry.getCategories();
expect(categories).toHaveLength(2);
expect(categories).toContain('testing');
expect(categories).toContain('debugging');
});
});
});
describe('CommandGenerator', () => {
let generator: CommandGenerator;
beforeEach(() => {
generator = createCommandGenerator();
});
describe('fromSkill', () => {
it('should generate command from skill', () => {
const skill = {
name: 'Test Skill',
description: 'A test skill',
content: 'Test content',
tags: ['test'],
};
const command = generator.fromSkill(skill);
expect(command.name).toBe('test-skill');
expect(command.description).toBe('A test skill');
expect(command.skill).toBe('Test Skill');
});
it('should use custom command name', () => {
const skill = {
name: 'Test Skill',
description: 'A test skill',
content: 'Test content',
};
const command = generator.fromSkill(skill, 'custom-name');
expect(command.name).toBe('custom-name');
});
});
describe('generateClaudeCommand', () => {
it('should generate Claude Code command file', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
aliases: ['tc'],
examples: ['/test-cmd'],
};
const content = generator.generateClaudeCommand(command);
expect(content).toContain('name: test-cmd');
expect(content).toContain('description: Test command');
expect(content).toContain('aliases: [tc]');
expect(content).toContain('# /test-cmd');
});
it('should include args in frontmatter', () => {
const command: SlashCommand = {
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
args: [
{
name: 'file',
description: 'File path',
required: true,
},
],
};
const content = generator.generateClaudeCommand(command);
expect(content).toContain('args:');
expect(content).toContain('name: file');
expect(content).toContain('required: true');
});
});
describe('generateCursorRules', () => {
it('should generate Cursor rules with @-mentions', () => {
const commands: SlashCommand[] = [
{
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
},
];
const content = generator.generateCursorRules(commands);
expect(content).toContain('## @test-cmd');
expect(content).toContain('Test command');
});
});
describe('generate', () => {
const commands: SlashCommand[] = [
{
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
},
];
it('should generate for claude-code', () => {
const result = generator.generate(commands, 'claude-code');
expect(result instanceof Map).toBe(true);
expect((result as Map<string, string>).has('test-cmd.md')).toBe(true);
});
it('should generate for cursor', () => {
const result = generator.generate(commands, 'cursor');
expect(typeof result).toBe('string');
expect((result as string)).toContain('@test-cmd');
});
it('should generate for opencode', () => {
const result = generator.generate(commands, 'opencode');
expect(result instanceof Map).toBe(true);
});
it('should generate for github-copilot', () => {
const result = generator.generate(commands, 'github-copilot');
expect(result instanceof Map).toBe(true);
});
});
describe('generateManifest', () => {
it('should generate JSON manifest', () => {
const commands: SlashCommand[] = [
{
name: 'test-cmd',
description: 'Test command',
skill: 'test-skill',
},
];
const manifest = generator.generateManifest(commands);
const parsed = JSON.parse(manifest);
expect(parsed.version).toBe('1.0.0');
expect(parsed.commands).toHaveLength(1);
expect(parsed.generatedAt).toBeDefined();
});
});
});
describe('getAgentFormat', () => {
it('should return format for claude-code', () => {
const format = getAgentFormat('claude-code');
expect(format.agent).toBe('claude-code');
expect(format.directory).toBe('.claude/commands');
expect(format.extension).toBe('.md');
expect(format.supportsSlashCommands).toBe(true);
});
it('should return format for cursor', () => {
const format = getAgentFormat('cursor');
expect(format.agent).toBe('cursor');
expect(format.supportsSlashCommands).toBe(false);
});
it('should return universal format for unknown agent', () => {
const format = getAgentFormat('unknown' as AgentType);
expect(format.agent).toBe('universal');
});
});
describe('supportsSlashCommands', () => {
it('should return true for claude-code', () => {
expect(supportsSlashCommands('claude-code')).toBe(true);
});
it('should return false for cursor', () => {
expect(supportsSlashCommands('cursor')).toBe(false);
});
it('should return false for windsurf', () => {
expect(supportsSlashCommands('windsurf')).toBe(false);
});
});
-532
View File
@@ -1,532 +0,0 @@
/**
* Command Generator
*
* Generates agent-specific slash commands from skills.
*/
import type { AgentType } from '../types.js';
import type { CanonicalSkill } from '../translator/types.js';
import type {
SlashCommand,
CommandGeneratorOptions,
AgentCommandFormat,
RegisteredCommand,
} from './types.js';
/**
* Agent command formats
*/
const AGENT_FORMATS: Record<AgentType, AgentCommandFormat> = {
'claude-code': {
agent: 'claude-code',
extension: '.md',
directory: '.claude/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
cursor: {
agent: 'cursor',
extension: '.mdc',
directory: '.cursor/rules',
supportsSlashCommands: false,
supportsCommandFiles: true,
},
codex: {
agent: 'codex',
extension: '.md',
directory: '.codex/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
'gemini-cli': {
agent: 'gemini-cli',
extension: '.md',
directory: '.gemini/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
opencode: {
agent: 'opencode',
extension: '.md',
directory: '.opencode/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
antigravity: {
agent: 'antigravity',
extension: '.md',
directory: '.antigravity/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
amp: {
agent: 'amp',
extension: '.md',
directory: '.amp/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
clawdbot: {
agent: 'clawdbot',
extension: '.md',
directory: '.clawdbot/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
droid: {
agent: 'droid',
extension: '.md',
directory: '.factory/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
'github-copilot': {
agent: 'github-copilot',
extension: '.md',
directory: '.github/copilot/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
goose: {
agent: 'goose',
extension: '.md',
directory: '.goose/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
kilo: {
agent: 'kilo',
extension: '.md',
directory: '.kilocode/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
'kiro-cli': {
agent: 'kiro-cli',
extension: '.md',
directory: '.kiro/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
roo: {
agent: 'roo',
extension: '.md',
directory: '.roo/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
trae: {
agent: 'trae',
extension: '.md',
directory: '.trae/commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
windsurf: {
agent: 'windsurf',
extension: '.md',
directory: '.windsurf/commands',
supportsSlashCommands: false,
supportsCommandFiles: true,
},
universal: {
agent: 'universal',
extension: '.md',
directory: 'commands',
supportsSlashCommands: true,
supportsCommandFiles: true,
},
};
/**
* CommandGenerator - Generate agent-specific commands
*/
export class CommandGenerator {
private options: Partial<CommandGeneratorOptions>;
constructor(options?: Partial<CommandGeneratorOptions>) {
this.options = options || {};
}
/**
* Get agent command format
*/
getAgentFormat(agent: AgentType): AgentCommandFormat {
return AGENT_FORMATS[agent] || AGENT_FORMATS.universal;
}
/**
* Generate command from skill
*/
fromSkill(skill: CanonicalSkill, commandName?: string): SlashCommand {
return {
name: commandName || this.slugify(skill.name),
description: skill.description || `Execute ${skill.name} skill`,
skill: skill.name,
tags: skill.tags,
category: this.inferCategory(skill),
examples: this.generateExamples(skill, commandName || this.slugify(skill.name)),
};
}
/**
* Generate commands from multiple skills
*/
fromSkills(skills: CanonicalSkill[]): SlashCommand[] {
return skills.map((skill) => this.fromSkill(skill));
}
/**
* Generate Claude Code command file
*/
generateClaudeCommand(command: SlashCommand | RegisteredCommand): string {
const lines: string[] = [];
// Frontmatter
lines.push('---');
lines.push(`name: ${command.name}`);
lines.push(`description: ${command.description}`);
if (command.aliases && command.aliases.length > 0) {
lines.push(`aliases: [${command.aliases.join(', ')}]`);
}
if (command.disableModelInvocation) {
lines.push('disableModelInvocation: true');
}
if (command.args && command.args.length > 0) {
lines.push('args:');
for (const arg of command.args) {
lines.push(` - name: ${arg.name}`);
lines.push(` description: ${arg.description}`);
if (arg.required) lines.push(` required: true`);
if (arg.default) lines.push(` default: "${arg.default}"`);
}
}
lines.push('---');
lines.push('');
// Command content
lines.push(`# /${command.name}`);
lines.push('');
lines.push(command.description);
lines.push('');
// Usage examples
if (command.examples && command.examples.length > 0) {
lines.push('## Usage');
lines.push('');
for (const example of command.examples) {
lines.push(`- ${example}`);
}
lines.push('');
}
// Skill reference
lines.push('## Skill');
lines.push('');
lines.push(`This command invokes the \`${command.skill}\` skill.`);
lines.push('');
return lines.join('\n');
}
/**
* Generate Claude Code commands
*/
generateClaudeCommands(commands: (SlashCommand | RegisteredCommand)[]): Map<string, string> {
const files = new Map<string, string>();
for (const command of commands) {
if (this.shouldInclude(command)) {
const filename = `${command.name}.md`;
files.set(filename, this.generateClaudeCommand(command));
}
}
return files;
}
/**
* Generate Cursor rules with @-mention syntax
*/
generateCursorRules(commands: (SlashCommand | RegisteredCommand)[]): string {
const lines: string[] = [];
lines.push('---');
lines.push('description: Available commands');
lines.push('globs: ["**/*"]');
lines.push('---');
lines.push('');
lines.push('# Available Commands');
lines.push('');
lines.push('You can invoke the following commands using @-mentions:');
lines.push('');
for (const command of commands) {
if (this.shouldInclude(command)) {
lines.push(`## @${command.name}`);
lines.push('');
lines.push(command.description);
lines.push('');
if (command.examples && command.examples.length > 0) {
lines.push('**Usage:**');
for (const example of command.examples) {
lines.push(`- ${example}`);
}
lines.push('');
}
}
}
return lines.join('\n');
}
/**
* Generate OpenCode commands
*/
generateOpenCodeCommands(commands: (SlashCommand | RegisteredCommand)[]): Map<string, string> {
const files = new Map<string, string>();
for (const command of commands) {
if (this.shouldInclude(command)) {
const lines: string[] = [];
// SKILL.md format with command metadata
lines.push('---');
lines.push(`name: ${command.name}`);
lines.push(`description: ${command.description}`);
lines.push('type: command');
if (command.aliases && command.aliases.length > 0) {
lines.push(`aliases: [${command.aliases.join(', ')}]`);
}
lines.push('---');
lines.push('');
lines.push(`# ${command.name}`);
lines.push('');
lines.push(command.description);
lines.push('');
if (command.args && command.args.length > 0) {
lines.push('## Arguments');
lines.push('');
for (const arg of command.args) {
const required = arg.required ? '(required)' : '(optional)';
lines.push(`- \`${arg.name}\` ${required}: ${arg.description}`);
}
lines.push('');
}
if (command.examples && command.examples.length > 0) {
lines.push('## Examples');
lines.push('');
for (const example of command.examples) {
lines.push(`- ${example}`);
}
lines.push('');
}
lines.push('## Skill Reference');
lines.push('');
lines.push(`Invokes: \`${command.skill}\``);
lines.push('');
const filename = `${command.name}.md`;
files.set(filename, lines.join('\n'));
}
}
return files;
}
/**
* Generate Copilot commands (agent skills format)
*/
generateCopilotCommands(commands: (SlashCommand | RegisteredCommand)[]): Map<string, string> {
const files = new Map<string, string>();
for (const command of commands) {
if (this.shouldInclude(command)) {
const lines: string[] = [];
lines.push(`# ${command.name}`);
lines.push('');
lines.push(`> ${command.description}`);
lines.push('');
if (command.args && command.args.length > 0) {
lines.push('## Parameters');
lines.push('');
lines.push('| Name | Required | Description |');
lines.push('|------|----------|-------------|');
for (const arg of command.args) {
lines.push(`| ${arg.name} | ${arg.required ? 'Yes' : 'No'} | ${arg.description} |`);
}
lines.push('');
}
if (command.examples && command.examples.length > 0) {
lines.push('## Examples');
lines.push('');
for (const example of command.examples) {
lines.push(`\`\`\`\n${example}\n\`\`\``);
}
lines.push('');
}
lines.push('## Implementation');
lines.push('');
lines.push(`This command is powered by the \`${command.skill}\` skill.`);
lines.push('');
const filename = `${command.name}.md`;
files.set(filename, lines.join('\n'));
}
}
return files;
}
/**
* Generate commands for any agent
*/
generate(
commands: (SlashCommand | RegisteredCommand)[],
agent: AgentType
): Map<string, string> | string {
switch (agent) {
case 'claude-code':
case 'codex':
case 'gemini-cli':
case 'amp':
case 'roo':
case 'kiro-cli':
return this.generateClaudeCommands(commands);
case 'cursor':
return this.generateCursorRules(commands);
case 'opencode':
return this.generateOpenCodeCommands(commands);
case 'github-copilot':
return this.generateCopilotCommands(commands);
default:
// Use Claude Code format as default
return this.generateClaudeCommands(commands);
}
}
/**
* Generate JSON manifest of commands
*/
generateManifest(commands: (SlashCommand | RegisteredCommand)[]): string {
const manifest = {
version: '1.0.0',
commands: commands.filter((c) => this.shouldInclude(c)).map((c) => ({
name: c.name,
description: c.description,
skill: c.skill,
aliases: c.aliases,
args: c.args,
category: c.category,
tags: c.tags,
})),
generatedAt: new Date().toISOString(),
};
return JSON.stringify(manifest, null, 2);
}
/**
* Check if command should be included
*/
private shouldInclude(command: SlashCommand | RegisteredCommand): boolean {
// Check hidden
if (command.hidden && !this.options.includeHidden) {
return false;
}
// Check enabled (for RegisteredCommand)
if ('enabled' in command && !command.enabled && !this.options.includeDisabled) {
return false;
}
return true;
}
/**
* Slugify a string for command name
*/
private slugify(str: string): string {
return str
.toLowerCase()
.replace(/[^a-z0-9]+/g, '-')
.replace(/^-|-$/g, '');
}
/**
* Infer category from skill
*/
private inferCategory(skill: CanonicalSkill): string | undefined {
const tags = skill.tags || [];
const name = skill.name.toLowerCase();
if (tags.includes('testing') || name.includes('test')) {
return 'testing';
}
if (tags.includes('debugging') || name.includes('debug')) {
return 'debugging';
}
if (tags.includes('planning') || name.includes('plan')) {
return 'planning';
}
if (tags.includes('collaboration') || name.includes('review')) {
return 'collaboration';
}
if (tags.includes('git') || name.includes('commit') || name.includes('branch')) {
return 'git';
}
return undefined;
}
/**
* Generate usage examples
*/
private generateExamples(skill: CanonicalSkill, commandName: string): string[] {
const examples: string[] = [];
examples.push(`/${commandName}`);
// Add examples based on skill content
if (skill.content.toLowerCase().includes('file')) {
examples.push(`/${commandName} path/to/file.ts`);
}
if (skill.content.toLowerCase().includes('test')) {
examples.push(`/${commandName} --run-tests`);
}
return examples;
}
}
/**
* Create a CommandGenerator instance
*/
export function createCommandGenerator(options?: Partial<CommandGeneratorOptions>): CommandGenerator {
return new CommandGenerator(options);
}
/**
* Get agent format info
*/
export function getAgentFormat(agent: AgentType): AgentCommandFormat {
return AGENT_FORMATS[agent] || AGENT_FORMATS.universal;
}
/**
* Check if agent supports slash commands
*/
export function supportsSlashCommands(agent: AgentType): boolean {
const format = AGENT_FORMATS[agent];
return format?.supportsSlashCommands ?? true;
}
-9
View File
@@ -1,9 +0,0 @@
/**
* Commands Module
*
* Slash commands and agent integration.
*/
export * from './types.js';
export * from './registry.js';
export * from './generator.js';
-428
View File
@@ -1,428 +0,0 @@
/**
* Command Registry
*
* Central registry for managing slash commands.
*/
import type {
SlashCommand,
RegisteredCommand,
CommandRegistryOptions,
CommandSearchOptions,
CommandValidationResult,
CommandHandler,
CommandEvent,
CommandEventListener,
CommandContext,
SlashCommandResult,
CommandBundle,
} from './types.js';
/**
* CommandRegistry - Central registry for slash commands
*/
export class CommandRegistry {
private commands: Map<string, RegisteredCommand> = new Map();
private aliases: Map<string, string> = new Map();
private listeners: Set<CommandEventListener> = new Set();
private options: CommandRegistryOptions;
constructor(options?: CommandRegistryOptions) {
this.options = {
allowOverrides: false,
validateOnRegister: true,
...options,
};
}
/**
* Register a command
*/
register(command: SlashCommand, handler?: CommandHandler, source?: string): void {
// Validate if enabled
if (this.options.validateOnRegister) {
const validation = this.validate(command);
if (!validation.valid) {
throw new Error(`Invalid command: ${validation.errors.join(', ')}`);
}
}
// Check for existing command
if (this.commands.has(command.name) && !this.options.allowOverrides) {
throw new Error(`Command already registered: ${command.name}`);
}
// Create registered command
const registered: RegisteredCommand = {
...command,
handler: handler || this.options.defaultHandler,
enabled: true,
source,
};
// Register command
this.commands.set(command.name, registered);
// Register aliases
if (command.aliases) {
for (const alias of command.aliases) {
this.aliases.set(alias, command.name);
}
}
this.emit('command:registered', registered);
}
/**
* Register multiple commands
*/
registerAll(commands: SlashCommand[], handler?: CommandHandler, source?: string): void {
for (const command of commands) {
this.register(command, handler, source);
}
}
/**
* Unregister a command
*/
unregister(name: string): boolean {
const command = this.commands.get(name);
if (!command) {
return false;
}
// Remove aliases
if (command.aliases) {
for (const alias of command.aliases) {
this.aliases.delete(alias);
}
}
this.commands.delete(name);
this.emit('command:unregistered', command);
return true;
}
/**
* Get a command by name or alias
*/
get(name: string): RegisteredCommand | undefined {
// Check direct name
const command = this.commands.get(name);
if (command) {
return command;
}
// Check aliases
const aliasTarget = this.aliases.get(name);
if (aliasTarget) {
return this.commands.get(aliasTarget);
}
return undefined;
}
/**
* Check if a command exists
*/
has(name: string): boolean {
return this.commands.has(name) || this.aliases.has(name);
}
/**
* Get all registered commands
*/
getAll(includeDisabled = false): RegisteredCommand[] {
const commands = Array.from(this.commands.values());
return includeDisabled ? commands : commands.filter((c) => c.enabled);
}
/**
* Search commands
*/
search(options?: CommandSearchOptions): RegisteredCommand[] {
let commands = this.getAll(options?.includeDisabled);
// Filter hidden
if (!options?.includeHidden) {
commands = commands.filter((c) => !c.hidden);
}
// Filter by category
if (options?.category) {
commands = commands.filter((c) => c.category === options.category);
}
// Filter by tags
if (options?.tags && options.tags.length > 0) {
commands = commands.filter((c) => c.tags && options.tags!.some((t) => c.tags!.includes(t)));
}
// Search by query
if (options?.query) {
const query = options.query.toLowerCase();
commands = commands.filter(
(c) =>
c.name.toLowerCase().includes(query) ||
c.description.toLowerCase().includes(query) ||
c.aliases?.some((a) => a.toLowerCase().includes(query))
);
}
// Sort by priority
commands.sort((a, b) => (b.priority || 0) - (a.priority || 0));
// Limit results
if (options?.limit) {
commands = commands.slice(0, options.limit);
}
return commands;
}
/**
* Enable a command
*/
enable(name: string): boolean {
const command = this.commands.get(name);
if (!command) {
return false;
}
command.enabled = true;
this.emit('command:enabled', command);
return true;
}
/**
* Disable a command
*/
disable(name: string): boolean {
const command = this.commands.get(name);
if (!command) {
return false;
}
command.enabled = false;
this.emit('command:disabled', command);
return true;
}
/**
* Execute a command
*/
async execute(name: string, context: Omit<CommandContext, 'command'>): Promise<SlashCommandResult> {
const command = this.get(name);
if (!command) {
return {
success: false,
error: `Command not found: ${name}`,
};
}
if (!command.enabled) {
return {
success: false,
error: `Command is disabled: ${name}`,
};
}
if (!command.handler) {
return {
success: false,
error: `Command has no handler: ${name}`,
};
}
const startTime = Date.now();
try {
const result = await command.handler({
...context,
command,
});
result.durationMs = Date.now() - startTime;
this.emit('command:executed', command, result);
return result;
} catch (error) {
const result: SlashCommandResult = {
success: false,
error: (error as Error).message,
durationMs: Date.now() - startTime,
};
this.emit('command:failed', command, result);
return result;
}
}
/**
* Validate a command
*/
validate(command: SlashCommand): CommandValidationResult {
const errors: string[] = [];
const warnings: string[] = [];
// Name is required
if (!command.name || !command.name.trim()) {
errors.push('Command must have a name');
} else {
// Name format validation
if (!/^[a-z][a-z0-9-]*$/.test(command.name)) {
errors.push('Command name must start with a letter and contain only lowercase letters, numbers, and hyphens');
}
}
// Description is required
if (!command.description || !command.description.trim()) {
errors.push('Command must have a description');
}
// Skill is required
if (!command.skill || !command.skill.trim()) {
errors.push('Command must reference a skill');
}
// Validate aliases
if (command.aliases) {
for (const alias of command.aliases) {
if (!/^[a-z][a-z0-9-]*$/.test(alias)) {
errors.push(`Invalid alias format: ${alias}`);
}
}
}
// Validate args
if (command.args) {
const argNames = new Set<string>();
for (const arg of command.args) {
if (!arg.name || !arg.name.trim()) {
errors.push('Argument must have a name');
} else if (argNames.has(arg.name)) {
errors.push(`Duplicate argument name: ${arg.name}`);
} else {
argNames.add(arg.name);
}
if (!arg.description || !arg.description.trim()) {
warnings.push(`Argument ${arg.name} has no description`);
}
}
}
// Validate examples
if (!command.examples || command.examples.length === 0) {
warnings.push('Command has no usage examples');
}
return {
valid: errors.length === 0,
errors,
warnings,
};
}
/**
* Get categories
*/
getCategories(): string[] {
const categories = new Set<string>();
for (const command of this.commands.values()) {
if (command.category) {
categories.add(command.category);
}
}
return Array.from(categories).sort();
}
/**
* Get commands by category
*/
getByCategory(category: string): RegisteredCommand[] {
return this.getAll().filter((c) => c.category === category);
}
/**
* Export commands to bundle
*/
export(includeDisabled = false): CommandBundle {
const commands = this.getAll(includeDisabled).map((c) => {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const { handler, enabled, source, ...command } = c;
return command;
});
return {
version: '1.0.0',
commands,
metadata: {
createdAt: new Date(),
},
};
}
/**
* Import commands from bundle
*/
import(bundle: CommandBundle, handler?: CommandHandler, source?: string): number {
let imported = 0;
for (const command of bundle.commands) {
try {
this.register(command, handler, source);
imported++;
} catch {
// Skip commands that fail to register
}
}
return imported;
}
/**
* Clear all commands
*/
clear(): void {
this.commands.clear();
this.aliases.clear();
}
/**
* Get command count
*/
get size(): number {
return this.commands.size;
}
/**
* Add event listener
*/
addListener(listener: CommandEventListener): void {
this.listeners.add(listener);
}
/**
* Remove event listener
*/
removeListener(listener: CommandEventListener): void {
this.listeners.delete(listener);
}
/**
* Emit event
*/
private emit(event: CommandEvent, command: RegisteredCommand, result?: SlashCommandResult): void {
for (const listener of this.listeners) {
try {
listener(event, command, result);
} catch {
// Ignore listener errors
}
}
}
}
/**
* Create a CommandRegistry instance
*/
export function createCommandRegistry(options?: CommandRegistryOptions): CommandRegistry {
return new CommandRegistry(options);
}
-221
View File
@@ -1,221 +0,0 @@
/**
* Command Types
*
* Type definitions for slash commands and agent integration.
*/
import type { AgentType } from '../types.js';
/**
* Command argument definition
*/
export interface CommandArg {
/** Argument name */
name: string;
/** Argument description */
description: string;
/** Whether the argument is required */
required?: boolean;
/** Default value */
default?: string;
/** Argument type */
type?: 'string' | 'number' | 'boolean' | 'file' | 'choice';
/** Valid choices (for type: 'choice') */
choices?: string[];
/** Validation pattern (regex) */
pattern?: string;
}
/**
* Slash command definition
*/
export interface SlashCommand {
/** Command name (without slash) */
name: string;
/** Command description */
description: string;
/** Skill to invoke when command is executed */
skill: string;
/** Alternative names for the command */
aliases?: string[];
/** Whether to disable model invocation (user-only) */
disableModelInvocation?: boolean;
/** Command arguments */
args?: CommandArg[];
/** Category for grouping */
category?: string;
/** Usage examples */
examples?: string[];
/** Tags for filtering */
tags?: string[];
/** Priority for ordering */
priority?: number;
/** Whether the command is hidden from help */
hidden?: boolean;
/** Metadata */
metadata?: Record<string, unknown>;
}
/**
* Command execution context
*/
export interface CommandContext {
/** The command being executed */
command: SlashCommand;
/** Parsed arguments */
args: Record<string, unknown>;
/** Agent executing the command */
agent: AgentType;
/** Working directory */
cwd: string;
/** Environment variables */
env?: Record<string, string>;
/** Additional context */
metadata?: Record<string, unknown>;
}
/**
* Command execution result
*/
export interface SlashCommandResult {
/** Whether execution succeeded */
success: boolean;
/** Output message */
output?: string;
/** Error message if failed */
error?: string;
/** Data returned by the command */
data?: unknown;
/** Duration in milliseconds */
durationMs?: number;
}
/**
* Command handler function
*/
export type CommandHandler = (context: CommandContext) => Promise<SlashCommandResult>;
/**
* Registered command with handler
*/
export interface RegisteredCommand extends SlashCommand {
/** Command handler function */
handler?: CommandHandler;
/** Whether the command is enabled */
enabled: boolean;
/** Source of the command (plugin, skill, etc.) */
source?: string;
}
/**
* Command registry options
*/
export interface CommandRegistryOptions {
/** Allow command overrides */
allowOverrides?: boolean;
/** Validate commands on registration */
validateOnRegister?: boolean;
/** Default handler for commands without one */
defaultHandler?: CommandHandler;
}
/**
* Command generator options
*/
export interface CommandGeneratorOptions {
/** Target agent */
agent: AgentType;
/** Include hidden commands */
includeHidden?: boolean;
/** Include disabled commands */
includeDisabled?: boolean;
/** Output format */
format?: 'markdown' | 'json' | 'native';
/** Custom template */
template?: string;
}
/**
* Command search options
*/
export interface CommandSearchOptions {
/** Search query */
query?: string;
/** Filter by category */
category?: string;
/** Filter by tags */
tags?: string[];
/** Include hidden commands */
includeHidden?: boolean;
/** Include disabled commands */
includeDisabled?: boolean;
/** Maximum results */
limit?: number;
}
/**
* Command validation result
*/
export interface CommandValidationResult {
/** Whether the command is valid */
valid: boolean;
/** Validation errors */
errors: string[];
/** Validation warnings */
warnings: string[];
}
/**
* Agent command format
*/
export interface AgentCommandFormat {
/** Agent type */
agent: AgentType;
/** File extension */
extension: string;
/** Directory for commands */
directory: string;
/** Whether agent supports slash commands */
supportsSlashCommands: boolean;
/** Whether agent supports command files */
supportsCommandFiles: boolean;
/** Template for generating commands */
template?: string;
}
/**
* Command event types
*/
export type CommandEvent =
| 'command:registered'
| 'command:unregistered'
| 'command:enabled'
| 'command:disabled'
| 'command:executed'
| 'command:failed';
/**
* Command event listener
*/
export type CommandEventListener = (
event: CommandEvent,
command: RegisteredCommand,
result?: SlashCommandResult
) => void;
/**
* Command import/export format
*/
export interface CommandBundle {
/** Bundle version */
version: string;
/** Commands in the bundle */
commands: SlashCommand[];
/** Bundle metadata */
metadata?: {
name?: string;
description?: string;
author?: string;
createdAt?: Date;
};
}
+28 -6
View File
@@ -5,7 +5,6 @@ import type { ContextSyncOptions } from './types.js';
import { ContextManager } from './manager.js';
import { translateSkillFile } from '../translator/index.js';
import { findAllSkills } from '../skills.js';
import { AGENT_CONFIG } from '../agent-config.js';
/**
* Result of a sync operation
@@ -30,6 +29,29 @@ export interface SyncReport {
results: SyncResult[];
}
/**
* Agent directory configuration
*/
const AGENT_DIRS: Record<AgentType, { skillsDir: string; configFile: string }> = {
'claude-code': { skillsDir: '.claude/skills', configFile: 'AGENTS.md' },
'cursor': { skillsDir: '.cursor/skills', configFile: '.cursorrules' },
'codex': { skillsDir: '.codex/skills', configFile: 'AGENTS.md' },
'gemini-cli': { skillsDir: '.gemini/skills', configFile: 'GEMINI.md' },
'opencode': { skillsDir: '.opencode/skills', configFile: 'AGENTS.md' },
'antigravity': { skillsDir: '.antigravity/skills', configFile: 'AGENTS.md' },
'amp': { skillsDir: '.agents/skills', configFile: 'AGENTS.md' },
'clawdbot': { skillsDir: 'skills', configFile: 'AGENTS.md' },
'droid': { skillsDir: '.factory/skills', configFile: 'AGENTS.md' },
'github-copilot': { skillsDir: '.github/skills', configFile: 'AGENTS.md' },
'goose': { skillsDir: '.goose/skills', configFile: 'AGENTS.md' },
'kilo': { skillsDir: '.kilocode/skills', configFile: 'AGENTS.md' },
'kiro-cli': { skillsDir: '.kiro/skills', configFile: 'AGENTS.md' },
'roo': { skillsDir: '.roo/skills', configFile: 'AGENTS.md' },
'trae': { skillsDir: '.trae/skills', configFile: 'AGENTS.md' },
'windsurf': { skillsDir: '.windsurf/skills', configFile: 'AGENTS.md' },
'universal': { skillsDir: '.agent/skills', configFile: 'AGENTS.md' },
};
/**
* Context Sync
*
@@ -51,7 +73,7 @@ export class ContextSync {
detectAgents(): AgentType[] {
const detected: AgentType[] = [];
for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
for (const [agent, config] of Object.entries(AGENT_DIRS)) {
const skillsPath = join(this.projectPath, config.skillsDir);
const configPath = join(this.projectPath, config.configFile);
@@ -149,7 +171,7 @@ export class ContextSync {
const sourceSkills = skills || this.getSourceSkills();
// Get target directory
const agentConfig = AGENT_CONFIG[agent];
const agentConfig = AGENT_DIRS[agent];
if (!agentConfig) {
result.success = false;
result.errors.push(`Unknown agent: ${agent}`);
@@ -275,8 +297,8 @@ export class ContextSync {
// Search directories based on primary agent or common locations
const searchDirs: string[] = [];
if (primaryAgent && AGENT_CONFIG[primaryAgent]) {
searchDirs.push(join(this.projectPath, AGENT_CONFIG[primaryAgent].skillsDir));
if (primaryAgent && AGENT_DIRS[primaryAgent]) {
searchDirs.push(join(this.projectPath, AGENT_DIRS[primaryAgent].skillsDir));
}
// Add common skill locations
@@ -305,7 +327,7 @@ export class ContextSync {
checkStatus(): Record<AgentType, { hasSkills: boolean; skillCount: number; skills: string[] }> {
const status: Record<string, { hasSkills: boolean; skillCount: number; skills: string[] }> = {};
for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
for (const [agent, config] of Object.entries(AGENT_DIRS)) {
const skillsPath = join(this.projectPath, config.skillsDir);
const skills: string[] = [];
@@ -1,610 +0,0 @@
/**
* Hooks System Tests
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { HookManager, createHookManager } from '../manager.js';
import { SkillTriggerEngine, createTriggerEngine } from '../triggers.js';
import type { SkillHook, HookEvent, HookContext } from '../types.js';
describe('HookManager', () => {
let tempDir: string;
let manager: HookManager;
beforeEach(() => {
tempDir = mkdtempSync(join(tmpdir(), 'skillkit-hooks-test-'));
manager = createHookManager({ projectPath: tempDir, autoLoad: false });
});
afterEach(() => {
rmSync(tempDir, { recursive: true, force: true });
});
describe('registerHook', () => {
it('should register a hook with generated ID', () => {
const hook = manager.registerHook({
event: 'session:start',
skills: ['tdd-workflow'],
inject: 'reference',
enabled: true,
});
expect(hook.id).toBeDefined();
expect(hook.event).toBe('session:start');
expect(hook.skills).toEqual(['tdd-workflow']);
expect(hook.inject).toBe('reference');
expect(hook.enabled).toBe(true);
});
it('should register a hook with custom ID', () => {
const hook = manager.registerHook({
id: 'my-hook',
event: 'file:save',
skills: ['code-review'],
inject: 'content',
enabled: true,
});
expect(hook.id).toBe('my-hook');
});
it('should set default values', () => {
const hook = manager.registerHook({
event: 'session:start',
skills: ['test'],
inject: 'reference',
enabled: true,
});
expect(hook.priority).toBe(0);
});
});
describe('unregisterHook', () => {
it('should remove a registered hook', () => {
const hook = manager.registerHook({
event: 'session:start',
skills: ['test'],
inject: 'reference',
enabled: true,
});
expect(manager.getHook(hook.id)).toBeDefined();
expect(manager.unregisterHook(hook.id)).toBe(true);
expect(manager.getHook(hook.id)).toBeUndefined();
});
it('should return false for non-existent hook', () => {
expect(manager.unregisterHook('non-existent')).toBe(false);
});
});
describe('getHooksForEvent', () => {
it('should return hooks for a specific event', () => {
manager.registerHook({
event: 'session:start',
skills: ['skill1'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'session:start',
skills: ['skill2'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'file:save',
skills: ['skill3'],
inject: 'reference',
enabled: true,
});
const sessionHooks = manager.getHooksForEvent('session:start');
expect(sessionHooks).toHaveLength(2);
expect(sessionHooks.every((h) => h.event === 'session:start')).toBe(true);
});
it('should only return enabled hooks', () => {
manager.registerHook({
event: 'session:start',
skills: ['skill1'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'session:start',
skills: ['skill2'],
inject: 'reference',
enabled: false,
});
const hooks = manager.getHooksForEvent('session:start');
expect(hooks).toHaveLength(1);
});
it('should sort by priority (higher first)', () => {
manager.registerHook({
event: 'session:start',
skills: ['low'],
inject: 'reference',
enabled: true,
priority: 1,
});
manager.registerHook({
event: 'session:start',
skills: ['high'],
inject: 'reference',
enabled: true,
priority: 10,
});
manager.registerHook({
event: 'session:start',
skills: ['medium'],
inject: 'reference',
enabled: true,
priority: 5,
});
const hooks = manager.getHooksForEvent('session:start');
expect(hooks[0].skills).toEqual(['high']);
expect(hooks[1].skills).toEqual(['medium']);
expect(hooks[2].skills).toEqual(['low']);
});
});
describe('enableHook/disableHook', () => {
it('should enable a disabled hook', () => {
const hook = manager.registerHook({
event: 'session:start',
skills: ['test'],
inject: 'reference',
enabled: false,
});
expect(manager.enableHook(hook.id)).toBe(true);
expect(manager.getHook(hook.id)?.enabled).toBe(true);
});
it('should disable an enabled hook', () => {
const hook = manager.registerHook({
event: 'session:start',
skills: ['test'],
inject: 'reference',
enabled: true,
});
expect(manager.disableHook(hook.id)).toBe(true);
expect(manager.getHook(hook.id)?.enabled).toBe(false);
});
});
describe('trigger', () => {
it('should trigger hooks for an event', async () => {
manager.registerHook({
event: 'session:start',
skills: ['skill1', 'skill2'],
inject: 'reference',
enabled: true,
});
const context: HookContext = {
event: 'session:start',
trigger: 'test',
projectPath: tempDir,
agent: 'claude-code',
timestamp: new Date(),
};
const result = await manager.trigger('session:start', context);
expect(result.event).toBe('session:start');
expect(result.matchedHooks).toHaveLength(1);
expect(result.activatedSkills).toHaveLength(2);
expect(result.errors).toHaveLength(0);
});
it('should filter by matcher pattern', async () => {
manager.registerHook({
event: 'file:save',
skills: ['test-skill'],
inject: 'reference',
matcher: '*.test.ts',
enabled: true,
});
const matchContext: HookContext = {
event: 'file:save',
trigger: 'foo.test.ts',
projectPath: tempDir,
agent: 'claude-code',
timestamp: new Date(),
};
const noMatchContext: HookContext = {
event: 'file:save',
trigger: 'foo.ts',
projectPath: tempDir,
agent: 'claude-code',
timestamp: new Date(),
};
const matchResult = await manager.trigger('file:save', matchContext);
expect(matchResult.matchedHooks).toHaveLength(1);
const noMatchResult = await manager.trigger('file:save', noMatchContext);
expect(noMatchResult.matchedHooks).toHaveLength(0);
});
it('should handle injection modes', async () => {
manager.registerHook({
event: 'session:start',
skills: ['ref-skill'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'session:start',
skills: ['content-skill'],
inject: 'content',
enabled: true,
});
manager.registerHook({
event: 'session:start',
skills: ['prompt-skill'],
inject: 'prompt',
enabled: true,
});
const context: HookContext = {
event: 'session:start',
trigger: 'test',
projectPath: tempDir,
agent: 'claude-code',
timestamp: new Date(),
};
const result = await manager.trigger('session:start', context);
const refSkill = result.activatedSkills.find((s) => s.skillId === 'ref-skill');
expect(refSkill?.reference).toBe('@ref-skill');
const contentSkill = result.activatedSkills.find((s) => s.skillId === 'content-skill');
expect(contentSkill?.content).toBeDefined();
const promptSkill = result.activatedSkills.find((s) => s.skillId === 'prompt-skill');
expect(promptSkill?.content).toContain('prompt-skill');
});
});
describe('save/load', () => {
it('should save and load hooks', () => {
manager.registerHook({
event: 'session:start',
skills: ['skill1'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'file:save',
skills: ['skill2'],
inject: 'content',
enabled: false,
matcher: '*.ts',
});
manager.save();
// Create new manager to load
const newManager = createHookManager({ projectPath: tempDir, autoLoad: true });
const hooks = newManager.getAllHooks();
expect(hooks).toHaveLength(2);
expect(hooks.find((h) => h.skills[0] === 'skill1')).toBeDefined();
expect(hooks.find((h) => h.skills[0] === 'skill2')).toBeDefined();
});
});
describe('generateAgentHooks', () => {
it('should generate Claude Code hooks format', () => {
manager.registerHook({
event: 'session:start',
skills: ['tdd'],
inject: 'reference',
enabled: true,
});
const hooks = manager.generateAgentHooks('claude-code');
expect(hooks).toHaveProperty('hooks');
expect((hooks as any).hooks).toBeInstanceOf(Array);
});
it('should generate Cursor rules format', () => {
manager.registerHook({
event: 'session:start',
skills: ['tdd'],
inject: 'reference',
enabled: true,
});
const rules = manager.generateAgentHooks('cursor');
expect(typeof rules).toBe('string');
expect(rules).toContain('session start');
});
it('should generate generic format for other agents', () => {
manager.registerHook({
event: 'session:start',
skills: ['tdd'],
inject: 'reference',
enabled: true,
});
const content = manager.generateAgentHooks('gemini-cli');
expect(typeof content).toBe('string');
expect(content).toContain('Skill Activation Triggers');
});
});
describe('listeners', () => {
it('should notify listeners on trigger', async () => {
let notified = false;
manager.addListener((event, context, result) => {
notified = true;
expect(event).toBe('session:start');
});
manager.registerHook({
event: 'session:start',
skills: ['test'],
inject: 'reference',
enabled: true,
});
await manager.trigger('session:start', {
event: 'session:start',
trigger: 'test',
projectPath: tempDir,
agent: 'claude-code',
timestamp: new Date(),
});
expect(notified).toBe(true);
});
it('should remove listeners', async () => {
let callCount = 0;
const listener = () => {
callCount++;
};
manager.addListener(listener);
manager.registerHook({
event: 'session:start',
skills: ['test'],
inject: 'reference',
enabled: true,
});
const context: HookContext = {
event: 'session:start',
trigger: 'test',
projectPath: tempDir,
agent: 'claude-code',
timestamp: new Date(),
};
await manager.trigger('session:start', context);
expect(callCount).toBe(1);
manager.removeListener(listener);
await manager.trigger('session:start', context);
expect(callCount).toBe(1); // Should not increase
});
});
});
describe('SkillTriggerEngine', () => {
let tempDir: string;
let manager: HookManager;
let engine: SkillTriggerEngine;
beforeEach(() => {
tempDir = mkdtempSync(join(tmpdir(), 'skillkit-trigger-test-'));
manager = createHookManager({ projectPath: tempDir, autoLoad: false });
engine = createTriggerEngine(manager, { projectPath: tempDir, watchFiles: false });
});
afterEach(() => {
engine.stop();
rmSync(tempDir, { recursive: true, force: true });
});
describe('lifecycle', () => {
it('should start and stop', async () => {
let sessionStartTriggered = false;
let sessionEndTriggered = false;
manager.registerHook({
event: 'session:start',
skills: ['start-skill'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'session:end',
skills: ['end-skill'],
inject: 'reference',
enabled: true,
});
manager.addListener((event) => {
if (event === 'session:start') sessionStartTriggered = true;
if (event === 'session:end') sessionEndTriggered = true;
});
engine.start('claude-code');
// Give it a moment to process
await new Promise((r) => setTimeout(r, 10));
expect(sessionStartTriggered).toBe(true);
expect(engine.isActive()).toBe(true);
engine.stop();
await new Promise((r) => setTimeout(r, 10));
expect(sessionEndTriggered).toBe(true);
expect(engine.isActive()).toBe(false);
});
});
describe('event triggering', () => {
beforeEach(() => {
manager.registerHook({
event: 'file:save',
skills: ['save-skill'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'task:start',
skills: ['task-skill'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'commit:pre',
skills: ['commit-skill'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'error:occur',
skills: ['error-skill'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'test:fail',
skills: ['test-skill'],
inject: 'reference',
enabled: true,
});
manager.registerHook({
event: 'build:fail',
skills: ['build-skill'],
inject: 'reference',
enabled: true,
});
});
it('should trigger file save event', async () => {
const result = await engine.triggerFileSave('src/index.ts');
expect(result.matchedHooks).toHaveLength(1);
expect(result.activatedSkills[0].skillId).toBe('save-skill');
});
it('should trigger task start event', async () => {
const result = await engine.triggerTaskStart('implement-feature', 'task-123');
expect(result.matchedHooks).toHaveLength(1);
expect(result.activatedSkills[0].skillId).toBe('task-skill');
});
it('should trigger pre-commit event', async () => {
const result = await engine.triggerPreCommit('feat: add new feature');
expect(result.matchedHooks).toHaveLength(1);
expect(result.activatedSkills[0].skillId).toBe('commit-skill');
});
it('should trigger error event', async () => {
const result = await engine.triggerError(new Error('Something went wrong'), 'test-context');
expect(result.matchedHooks).toHaveLength(1);
expect(result.activatedSkills[0].skillId).toBe('error-skill');
});
it('should trigger test fail event', async () => {
const result = await engine.triggerTestFail('should add numbers', 'Expected 4 but got 5');
expect(result.matchedHooks).toHaveLength(1);
expect(result.activatedSkills[0].skillId).toBe('test-skill');
});
it('should trigger build fail event', async () => {
const result = await engine.triggerBuildFail('TypeScript error');
expect(result.matchedHooks).toHaveLength(1);
expect(result.activatedSkills[0].skillId).toBe('build-skill');
});
});
describe('agent setting', () => {
it('should use the set agent in context', async () => {
manager.registerHook({
event: 'session:start',
skills: ['test'],
inject: 'reference',
enabled: true,
});
let capturedAgent: string | null = null;
manager.addListener((event, context) => {
capturedAgent = context.agent;
});
engine.setAgent('cursor');
await engine.triggerEvent('session:start', 'test');
expect(capturedAgent).toBe('cursor');
});
});
describe('listeners', () => {
it('should notify engine listeners', async () => {
let notified = false;
engine.addListener((event) => {
notified = true;
expect(event).toBe('task:start');
});
manager.registerHook({
event: 'task:start',
skills: ['test'],
inject: 'reference',
enabled: true,
});
await engine.triggerTaskStart('test-task');
expect(notified).toBe(true);
});
});
});
describe('Hook Event Types', () => {
it('should support all documented events', () => {
const events: HookEvent[] = [
'session:start',
'session:resume',
'session:end',
'file:open',
'file:save',
'file:create',
'file:delete',
'task:start',
'task:complete',
'commit:pre',
'commit:post',
'error:occur',
'test:fail',
'test:pass',
'build:start',
'build:fail',
'build:success',
];
// Just verify all events are valid strings
expect(events).toHaveLength(17);
events.forEach((event) => {
expect(typeof event).toBe('string');
expect(event).toContain(':');
});
});
});
-35
View File
@@ -1,35 +0,0 @@
/**
* Hooks & Automatic Triggering System
*
* Provides event-driven skill activation across all supported agents.
*
* Key features:
* - 17+ hook events (session, file, task, commit, error, test, build)
* - Pattern matching with glob support
* - Agent-specific hook generation
* - File watching for automatic triggers
* - Condition expressions for complex logic
*/
// Manager
export { HookManager, createHookManager } from './manager.js';
// Trigger Engine
export { SkillTriggerEngine, createTriggerEngine } from './triggers.js';
// Types
export type {
HookEvent,
InjectionMode,
SkillHook,
HookContext,
ActivatedSkill,
HookTriggerResult,
HookError,
HookConfig,
AgentHookFormat,
HookManagerOptions,
TriggerEngineOptions,
HookEventListener,
MatcherFunction,
} from './types.js';
-539
View File
@@ -1,539 +0,0 @@
/**
* Hook Manager
*
* Manages skill hooks for automatic triggering across all supported agents.
*/
import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { randomUUID } from 'node:crypto';
import { minimatch } from 'minimatch';
import type { AgentType } from '../types.js';
import type {
SkillHook,
HookEvent,
HookContext,
HookConfig,
HookManagerOptions,
ActivatedSkill,
HookTriggerResult,
HookError,
HookEventListener,
} from './types.js';
const DEFAULT_CONFIG_PATH = '.skillkit/hooks.json';
/**
* HookManager - Manages skill hooks for automatic triggering
*/
export class HookManager {
private hooks: Map<string, SkillHook> = new Map();
private listeners: Set<HookEventListener> = new Set();
private options: Required<HookManagerOptions>;
constructor(options: HookManagerOptions) {
this.options = {
projectPath: options.projectPath,
configPath: options.configPath || join(options.projectPath, DEFAULT_CONFIG_PATH),
autoLoad: options.autoLoad ?? true,
defaultInjectionMode: options.defaultInjectionMode || 'reference',
};
if (this.options.autoLoad) {
this.load();
}
}
/**
* Register a new hook
*/
registerHook(hook: Omit<SkillHook, 'id'> & { id?: string }): SkillHook {
const fullHook: SkillHook = {
...hook,
id: hook.id || randomUUID(),
inject: hook.inject || this.options.defaultInjectionMode,
enabled: hook.enabled ?? true,
priority: hook.priority ?? 0,
};
this.hooks.set(fullHook.id, fullHook);
return fullHook;
}
/**
* Unregister a hook by ID
*/
unregisterHook(id: string): boolean {
return this.hooks.delete(id);
}
/**
* Get a hook by ID
*/
getHook(id: string): SkillHook | undefined {
return this.hooks.get(id);
}
/**
* Get all hooks
*/
getAllHooks(): SkillHook[] {
return Array.from(this.hooks.values());
}
/**
* Get hooks for a specific event
*/
getHooksForEvent(event: HookEvent): SkillHook[] {
return this.getAllHooks()
.filter((hook) => hook.event === event && hook.enabled)
.sort((a, b) => (b.priority || 0) - (a.priority || 0));
}
/**
* Update a hook
*/
updateHook(id: string, updates: Partial<SkillHook>): SkillHook | undefined {
const existing = this.hooks.get(id);
if (!existing) return undefined;
const updated = { ...existing, ...updates, id };
this.hooks.set(id, updated);
return updated;
}
/**
* Enable a hook
*/
enableHook(id: string): boolean {
const hook = this.hooks.get(id);
if (!hook) return false;
hook.enabled = true;
return true;
}
/**
* Disable a hook
*/
disableHook(id: string): boolean {
const hook = this.hooks.get(id);
if (!hook) return false;
hook.enabled = false;
return true;
}
/**
* Trigger hooks for an event
*/
async trigger(event: HookEvent, context: HookContext): Promise<HookTriggerResult> {
const startTime = Date.now();
const matchedHooks: SkillHook[] = [];
const activatedSkills: ActivatedSkill[] = [];
const errors: HookError[] = [];
const hooks = this.getHooksForEvent(event);
for (const hook of hooks) {
try {
// Check if matcher matches
if (hook.matcher && !this.matchesTrigger(hook.matcher, context.trigger)) {
continue;
}
// Check condition if present
if (hook.condition && !this.evaluateCondition(hook.condition, context)) {
continue;
}
matchedHooks.push(hook);
// Apply agent-specific overrides
const effectiveHook = this.applyAgentOverrides(hook, context.agent);
// Activate each skill
for (const skillId of effectiveHook.skills) {
try {
const activated = await this.activateSkill(skillId, effectiveHook, context);
activatedSkills.push(activated);
} catch (err) {
errors.push({
hookId: hook.id,
skillId,
message: err instanceof Error ? err.message : 'Unknown error',
stack: err instanceof Error ? err.stack : undefined,
});
}
}
} catch (err) {
errors.push({
hookId: hook.id,
message: err instanceof Error ? err.message : 'Unknown error',
stack: err instanceof Error ? err.stack : undefined,
});
}
}
const result: HookTriggerResult = {
event,
matchedHooks,
activatedSkills,
errors,
executionTimeMs: Date.now() - startTime,
};
// Notify listeners
await this.notifyListeners(event, context, result);
return result;
}
/**
* Add event listener
*/
addListener(listener: HookEventListener): void {
this.listeners.add(listener);
}
/**
* Remove event listener
*/
removeListener(listener: HookEventListener): void {
this.listeners.delete(listener);
}
/**
* Load hooks from config file
*/
load(): void {
if (!existsSync(this.options.configPath)) {
return;
}
try {
const content = readFileSync(this.options.configPath, 'utf-8');
const config: HookConfig = JSON.parse(content);
this.hooks.clear();
for (const hook of config.hooks) {
this.hooks.set(hook.id, {
...hook,
inject: hook.inject || config.defaults?.inject || this.options.defaultInjectionMode,
priority: hook.priority ?? config.defaults?.priority ?? 0,
enabled: hook.enabled ?? config.defaults?.enabled ?? true,
});
}
} catch {
// Ignore parse errors, start with empty hooks
}
}
/**
* Save hooks to config file
*/
save(): void {
const config: HookConfig = {
version: 1,
hooks: this.getAllHooks(),
defaults: {
inject: this.options.defaultInjectionMode,
priority: 0,
enabled: true,
},
};
const dir = dirname(this.options.configPath);
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
writeFileSync(this.options.configPath, JSON.stringify(config, null, 2));
}
/**
* Generate agent-specific hook configuration
*/
generateAgentHooks(agent: AgentType): string | Record<string, unknown> {
const hooks = this.getAllHooks().filter((h) => h.enabled);
switch (agent) {
case 'claude-code':
return this.generateClaudeCodeHooks(hooks);
case 'cursor':
return this.generateCursorHooks(hooks);
case 'opencode':
return this.generateOpenCodeHooks(hooks);
default:
return this.generateGenericHooks(hooks);
}
}
/**
* Generate Claude Code hooks.json format
*/
private generateClaudeCodeHooks(hooks: SkillHook[]): Record<string, unknown> {
const hookEntries: Record<string, unknown>[] = [];
for (const hook of hooks) {
// Map our events to Claude Code hook events
const claudeEvent = this.mapToClaudeCodeEvent(hook.event);
if (!claudeEvent) continue;
hookEntries.push({
event: claudeEvent,
command: this.generateClaudeCommand(hook),
matcher: hook.matcher ? String(hook.matcher) : undefined,
});
}
return { hooks: hookEntries };
}
/**
* Map SkillKit events to Claude Code events
*/
private mapToClaudeCodeEvent(event: HookEvent): string | null {
const mapping: Record<HookEvent, string | null> = {
'session:start': 'SessionStart',
'session:resume': 'SessionResume',
'session:end': 'SessionEnd',
'file:open': null,
'file:save': 'PreToolUse',
'file:create': 'PostToolUse',
'file:delete': 'PostToolUse',
'task:start': null,
'task:complete': null,
'commit:pre': 'PreToolUse',
'commit:post': 'PostToolUse',
'error:occur': null,
'test:fail': 'PostToolUse',
'test:pass': 'PostToolUse',
'build:start': 'PreToolUse',
'build:fail': 'PostToolUse',
'build:success': 'PostToolUse',
};
return mapping[event];
}
/**
* Generate Claude Code command for a hook
*/
private generateClaudeCommand(hook: SkillHook): string {
const skillRefs = hook.skills.map((s) => `@${s}`).join(' ');
return `echo "Activating skills: ${skillRefs}"`;
}
/**
* Generate Cursor rules with hooks
*/
private generateCursorHooks(hooks: SkillHook[]): string {
const lines: string[] = ['# Auto-generated skill activation rules', ''];
for (const hook of hooks) {
lines.push(`## ${hook.event} Hook`);
lines.push(`When ${hook.event.replace(':', ' ')} occurs:`);
for (const skill of hook.skills) {
lines.push(`- Apply skill: ${skill}`);
}
if (hook.matcher) {
lines.push(`- Pattern: ${hook.matcher}`);
}
lines.push('');
}
return lines.join('\n');
}
/**
* Generate OpenCode hooks
*/
private generateOpenCodeHooks(hooks: SkillHook[]): Record<string, unknown> {
return {
triggers: hooks.map((hook) => ({
event: hook.event,
skills: hook.skills,
matcher: hook.matcher ? String(hook.matcher) : undefined,
enabled: hook.enabled,
})),
};
}
/**
* Generate generic AGENTS.md injection for unsupported agents
*/
private generateGenericHooks(hooks: SkillHook[]): string {
const lines: string[] = [
'# Skill Activation Triggers',
'',
'The following skills should be activated based on events:',
'',
];
const eventGroups = new Map<HookEvent, SkillHook[]>();
for (const hook of hooks) {
const group = eventGroups.get(hook.event) || [];
group.push(hook);
eventGroups.set(hook.event, group);
}
for (const [event, eventHooks] of eventGroups) {
lines.push(`## On ${event.replace(':', ' ').replace(/\b\w/g, (c) => c.toUpperCase())}`);
for (const hook of eventHooks) {
lines.push(`- Activate: ${hook.skills.join(', ')}`);
if (hook.matcher) {
lines.push(` - When matching: ${hook.matcher}`);
}
}
lines.push('');
}
return lines.join('\n');
}
/**
* Check if trigger matches the pattern
*/
private matchesTrigger(matcher: string | RegExp, trigger: string): boolean {
if (matcher instanceof RegExp) {
return matcher.test(trigger);
}
// Use minimatch for glob patterns
return minimatch(trigger, matcher);
}
/**
* Evaluate condition expression
*/
private evaluateCondition(condition: string, context: HookContext): boolean {
// Simple condition evaluation
// Supports: event == 'x', trigger.includes('y'), metadata.key == 'value'
try {
const safeContext = {
event: context.event,
trigger: context.trigger,
agent: context.agent,
metadata: context.metadata || {},
};
// Very basic expression evaluation
if (condition.includes('==')) {
const [left, right] = condition.split('==').map((s) => s.trim());
const leftVal = this.resolveValue(left, safeContext);
const rightVal = right.replace(/['"]/g, '');
return leftVal === rightVal;
}
if (condition.includes('.includes(')) {
const match = condition.match(/(\w+)\.includes\(['"](.+)['"]\)/);
if (match) {
const [, prop, search] = match;
const val = this.resolveValue(prop, safeContext);
return typeof val === 'string' && val.includes(search);
}
}
return true;
} catch {
return true;
}
}
/**
* Resolve a value from context
*/
private resolveValue(path: string, context: Record<string, unknown>): unknown {
const parts = path.split('.');
let current: unknown = context;
for (const part of parts) {
if (current && typeof current === 'object' && part in current) {
current = (current as Record<string, unknown>)[part];
} else {
return undefined;
}
}
return current;
}
/**
* Apply agent-specific overrides to a hook
*/
private applyAgentOverrides(hook: SkillHook, agent: AgentType): SkillHook {
if (!hook.agentOverrides || !hook.agentOverrides[agent]) {
return hook;
}
return {
...hook,
...hook.agentOverrides[agent],
id: hook.id,
event: hook.event,
};
}
/**
* Activate a skill from a hook
*/
private async activateSkill(
skillId: string,
hook: SkillHook,
context: HookContext
): Promise<ActivatedSkill> {
const activated: ActivatedSkill = {
skillId,
hookId: hook.id,
injectionMode: hook.inject,
activatedAt: new Date(),
};
switch (hook.inject) {
case 'content':
// Load skill content
activated.content = await this.loadSkillContent(skillId, context);
break;
case 'reference':
// Create reference
activated.reference = `@${skillId}`;
break;
case 'prompt':
// Create prompt injection
activated.content = `Please apply the "${skillId}" skill to this task.`;
break;
}
return activated;
}
/**
* Load skill content (placeholder - integrates with skill loader)
*/
private async loadSkillContent(skillId: string, _context: HookContext): Promise<string> {
// This would integrate with the methodology loader or skill manager
// For now, return a placeholder
return `# Skill: ${skillId}\n\nThis skill was auto-activated by a hook.`;
}
/**
* Notify all listeners of a trigger event
*/
private async notifyListeners(
event: HookEvent,
context: HookContext,
result: HookTriggerResult
): Promise<void> {
for (const listener of this.listeners) {
try {
await listener(event, context, result);
} catch {
// Ignore listener errors
}
}
}
}
/**
* Create a HookManager instance
*/
export function createHookManager(options: HookManagerOptions): HookManager {
return new HookManager(options);
}
-314
View File
@@ -1,314 +0,0 @@
/**
* Skill Trigger Engine
*
* Monitors events and triggers skill activation based on configured hooks.
*/
import { watch, type FSWatcher } from 'node:fs';
import { join, relative } from 'node:path';
import type { AgentType } from '../types.js';
import type {
HookEvent,
HookContext,
HookTriggerResult,
TriggerEngineOptions,
HookEventListener,
} from './types.js';
import { HookManager } from './manager.js';
/**
* Debounce helper
*/
function debounce<T extends (...args: string[]) => void>(
fn: T,
delay: number
): (...args: Parameters<T>) => void {
let timeoutId: ReturnType<typeof setTimeout> | null = null;
return (...args: Parameters<T>) => {
if (timeoutId) clearTimeout(timeoutId);
timeoutId = setTimeout(() => fn(...args), delay);
};
}
/**
* SkillTriggerEngine - Monitors events and triggers skill activation
*/
export class SkillTriggerEngine {
private hookManager: HookManager;
private options: Required<TriggerEngineOptions>;
private watchers: Map<string, FSWatcher> = new Map();
private listeners: Set<HookEventListener> = new Set();
private isRunning = false;
private currentAgent: AgentType = 'universal';
constructor(hookManager: HookManager, options: TriggerEngineOptions) {
this.hookManager = hookManager;
this.options = {
projectPath: options.projectPath,
watchFiles: options.watchFiles ?? false,
debounceMs: options.debounceMs ?? 100,
};
}
/**
* Start the trigger engine
*/
start(agent?: AgentType): void {
if (this.isRunning) return;
this.isRunning = true;
this.currentAgent = agent || 'universal';
if (this.options.watchFiles) {
this.startFileWatcher();
}
// Trigger session:start
this.triggerEvent('session:start', 'engine_start');
}
/**
* Stop the trigger engine
*/
stop(): void {
if (!this.isRunning) return;
// Trigger session:end
this.triggerEvent('session:end', 'engine_stop');
this.stopFileWatcher();
this.isRunning = false;
}
/**
* Set the current agent
*/
setAgent(agent: AgentType): void {
this.currentAgent = agent;
}
/**
* Manually trigger an event
*/
async triggerEvent(
event: HookEvent,
trigger: string,
metadata?: Record<string, unknown>
): Promise<HookTriggerResult> {
const context: HookContext = {
event,
trigger,
projectPath: this.options.projectPath,
agent: this.currentAgent,
metadata,
timestamp: new Date(),
};
const result = await this.hookManager.trigger(event, context);
// Notify local listeners
for (const listener of this.listeners) {
try {
await listener(event, context, result);
} catch {
// Ignore listener errors
}
}
return result;
}
/**
* Trigger file:open event
*/
async triggerFileOpen(filePath: string): Promise<HookTriggerResult> {
return this.triggerEvent('file:open', filePath, { filePath });
}
/**
* Trigger file:save event
*/
async triggerFileSave(filePath: string): Promise<HookTriggerResult> {
return this.triggerEvent('file:save', filePath, { filePath });
}
/**
* Trigger file:create event
*/
async triggerFileCreate(filePath: string): Promise<HookTriggerResult> {
return this.triggerEvent('file:create', filePath, { filePath });
}
/**
* Trigger file:delete event
*/
async triggerFileDelete(filePath: string): Promise<HookTriggerResult> {
return this.triggerEvent('file:delete', filePath, { filePath });
}
/**
* Trigger task:start event
*/
async triggerTaskStart(taskName: string, taskId?: string): Promise<HookTriggerResult> {
return this.triggerEvent('task:start', taskName, { taskName, taskId });
}
/**
* Trigger task:complete event
*/
async triggerTaskComplete(
taskName: string,
taskId?: string,
success?: boolean
): Promise<HookTriggerResult> {
return this.triggerEvent('task:complete', taskName, { taskName, taskId, success });
}
/**
* Trigger commit:pre event
*/
async triggerPreCommit(message?: string): Promise<HookTriggerResult> {
return this.triggerEvent('commit:pre', 'git_commit', { message });
}
/**
* Trigger commit:post event
*/
async triggerPostCommit(commitHash?: string, message?: string): Promise<HookTriggerResult> {
return this.triggerEvent('commit:post', 'git_commit', { commitHash, message });
}
/**
* Trigger error:occur event
*/
async triggerError(error: Error | string, context?: string): Promise<HookTriggerResult> {
const errorMessage = error instanceof Error ? error.message : error;
const errorStack = error instanceof Error ? error.stack : undefined;
return this.triggerEvent('error:occur', errorMessage, { error: errorMessage, stack: errorStack, context });
}
/**
* Trigger test:fail event
*/
async triggerTestFail(testName: string, error?: string): Promise<HookTriggerResult> {
return this.triggerEvent('test:fail', testName, { testName, error });
}
/**
* Trigger test:pass event
*/
async triggerTestPass(testName: string): Promise<HookTriggerResult> {
return this.triggerEvent('test:pass', testName, { testName });
}
/**
* Trigger build:start event
*/
async triggerBuildStart(command?: string): Promise<HookTriggerResult> {
return this.triggerEvent('build:start', 'build', { command });
}
/**
* Trigger build:fail event
*/
async triggerBuildFail(error?: string): Promise<HookTriggerResult> {
return this.triggerEvent('build:fail', 'build', { error });
}
/**
* Trigger build:success event
*/
async triggerBuildSuccess(): Promise<HookTriggerResult> {
return this.triggerEvent('build:success', 'build', {});
}
/**
* Add event listener
*/
addListener(listener: HookEventListener): void {
this.listeners.add(listener);
}
/**
* Remove event listener
*/
removeListener(listener: HookEventListener): void {
this.listeners.delete(listener);
}
/**
* Check if engine is running
*/
isActive(): boolean {
return this.isRunning;
}
/**
* Start file watcher
*/
private startFileWatcher(): void {
try {
const watcher = watch(
this.options.projectPath,
{ recursive: true },
debounce((eventType: string, filename: string | null) => {
if (!filename) return;
const relativePath = relative(this.options.projectPath, join(this.options.projectPath, filename));
// Skip node_modules, .git, etc.
if (this.shouldIgnore(relativePath)) return;
if (eventType === 'rename') {
// Could be create or delete
this.triggerFileCreate(relativePath);
} else if (eventType === 'change') {
this.triggerFileSave(relativePath);
}
}, this.options.debounceMs)
);
this.watchers.set('main', watcher);
} catch {
// File watching not available
}
}
/**
* Stop file watcher
*/
private stopFileWatcher(): void {
for (const watcher of this.watchers.values()) {
watcher.close();
}
this.watchers.clear();
}
/**
* Check if a path should be ignored
*/
private shouldIgnore(filePath: string): boolean {
const ignorePaths = [
'node_modules',
'.git',
'.skillkit',
'dist',
'build',
'coverage',
'.next',
'.nuxt',
];
return ignorePaths.some((ignore) => filePath.includes(ignore));
}
}
/**
* Create a SkillTriggerEngine instance
*/
export function createTriggerEngine(
hookManager: HookManager,
options: TriggerEngineOptions
): SkillTriggerEngine {
return new SkillTriggerEngine(hookManager, options);
}
-189
View File
@@ -1,189 +0,0 @@
/**
* Hooks & Automatic Triggering System Types
*
* Provides event-driven skill activation across all supported agents.
*/
import type { AgentType } from '../types.js';
/**
* Hook events that can trigger skill activation
*/
export type HookEvent =
| 'session:start'
| 'session:resume'
| 'session:end'
| 'file:open'
| 'file:save'
| 'file:create'
| 'file:delete'
| 'task:start'
| 'task:complete'
| 'commit:pre'
| 'commit:post'
| 'error:occur'
| 'test:fail'
| 'test:pass'
| 'build:start'
| 'build:fail'
| 'build:success';
/**
* How to inject the skill when triggered
*/
export type InjectionMode = 'content' | 'reference' | 'prompt';
/**
* Skill hook configuration
*/
export interface SkillHook {
/** Unique identifier for this hook */
id: string;
/** Event that triggers this hook */
event: HookEvent;
/** Pattern to match (e.g., "*.test.ts", "src/**\/*.tsx") */
matcher?: string | RegExp;
/** Skills to activate when triggered */
skills: string[];
/** How to inject the skill */
inject: InjectionMode;
/** Priority (higher = earlier execution) */
priority?: number;
/** Condition expression (optional) */
condition?: string;
/** Whether hook is enabled */
enabled: boolean;
/** Agent-specific overrides */
agentOverrides?: Partial<Record<AgentType, Partial<SkillHook>>>;
/** Metadata */
metadata?: Record<string, unknown>;
}
/**
* Context provided when a hook is triggered
*/
export interface HookContext {
/** The event that was triggered */
event: HookEvent;
/** What triggered the event (filename, command, etc.) */
trigger: string;
/** Project path */
projectPath: string;
/** Target agent */
agent: AgentType;
/** Additional metadata */
metadata?: Record<string, unknown>;
/** Timestamp */
timestamp: Date;
}
/**
* Result of activating a skill via hook
*/
export interface ActivatedSkill {
/** Skill ID */
skillId: string;
/** Hook that activated it */
hookId: string;
/** Injection mode used */
injectionMode: InjectionMode;
/** The skill content (if injection mode is 'content') */
content?: string;
/** The skill reference (if injection mode is 'reference') */
reference?: string;
/** Activation timestamp */
activatedAt: Date;
}
/**
* Hook trigger result
*/
export interface HookTriggerResult {
/** Event that was triggered */
event: HookEvent;
/** Hooks that matched */
matchedHooks: SkillHook[];
/** Skills that were activated */
activatedSkills: ActivatedSkill[];
/** Any errors that occurred */
errors: HookError[];
/** Total execution time in ms */
executionTimeMs: number;
}
/**
* Hook error
*/
export interface HookError {
hookId: string;
skillId?: string;
message: string;
stack?: string;
}
/**
* Hook configuration file format
*/
export interface HookConfig {
version: number;
hooks: SkillHook[];
defaults?: {
inject?: InjectionMode;
priority?: number;
enabled?: boolean;
};
}
/**
* Agent-specific hook format generator
*/
export interface AgentHookFormat {
/** Agent type */
agent: AgentType;
/** Generate hook configuration for this agent */
generate(hooks: SkillHook[]): string | Record<string, unknown>;
/** Parse agent-specific hook format */
parse(content: string | Record<string, unknown>): SkillHook[];
/** File path for hook configuration */
configPath: string;
}
/**
* Hook manager options
*/
export interface HookManagerOptions {
/** Project path */
projectPath: string;
/** Path to hooks configuration file */
configPath?: string;
/** Whether to auto-load hooks on init */
autoLoad?: boolean;
/** Default injection mode */
defaultInjectionMode?: InjectionMode;
}
/**
* Trigger engine options
*/
export interface TriggerEngineOptions {
/** Project path */
projectPath: string;
/** Whether to enable file watching */
watchFiles?: boolean;
/** Debounce time for file events (ms) */
debounceMs?: number;
}
/**
* Hook event listener
*/
export type HookEventListener = (
event: HookEvent,
context: HookContext,
result: HookTriggerResult
) => void | Promise<void>;
/**
* Matcher function type
*/
export type MatcherFunction = (trigger: string, context: HookContext) => boolean;
-30
View File
@@ -1,9 +1,6 @@
// Types
export * from './types.js';
// Centralized Agent Configuration (single source of truth)
export * from './agent-config.js';
// Skills discovery and parsing
export * from './skills.js';
@@ -48,30 +45,3 @@ export * from './team/index.js';
// Plugin System (Extensibility)
export * from './plugins/index.js';
// Methodology Framework (Phase 12)
export * from './methodology/index.js';
// Hooks & Automatic Triggering System (Phase 13)
export * from './hooks/index.js';
// Team Orchestration System (Phase 14)
export * from './orchestrator/index.js';
// Structured Plan System (Phase 15)
export * from './plan/index.js';
// Slash Commands & Agent Integration (Phase 16)
export * from './commands/index.js';
// AI-Powered Features (Phase 18)
export * from './ai/index.js';
// Audit Logging (Phase 18)
export * from './audit/index.js';
// Custom Agents Support (Phase 19)
export * from './agents/index.js';
// Skill Translator (Phase 20 - Cross-Agent Skill Translation)
export * from './skill-translator.js';
@@ -1,275 +0,0 @@
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { MethodologyLoader, createMethodologyLoader } from '../loader.js';
describe('MethodologyLoader', () => {
let testDir: string;
let packsDir: string;
beforeEach(() => {
// Create temporary directory for tests
testDir = join(tmpdir(), `skillkit-test-${Date.now()}`);
packsDir = join(testDir, 'packs');
mkdirSync(packsDir, { recursive: true });
});
afterEach(() => {
// Clean up
if (existsSync(testDir)) {
rmSync(testDir, { recursive: true, force: true });
}
});
function createTestPack(name: string, skills: string[]): void {
const packDir = join(packsDir, name);
mkdirSync(packDir, { recursive: true });
// Create pack.json
const manifest = {
name,
version: '1.0.0',
description: `Test ${name} pack`,
skills,
tags: [name],
compatibility: ['all'],
};
writeFileSync(join(packDir, 'pack.json'), JSON.stringify(manifest, null, 2));
// Create skill directories and SKILL.md files
for (const skill of skills) {
const skillDir = join(packDir, skill);
mkdirSync(skillDir, { recursive: true });
const skillContent = `---
name: ${skill}
description: Test skill ${skill}
version: 1.0.0
triggers:
- ${skill}
tags:
- test
---
# ${skill}
This is a test skill. You must follow these instructions.
## Instructions
Do the thing.
`;
writeFileSync(join(skillDir, 'SKILL.md'), skillContent);
}
}
describe('loadAllPacks', () => {
it('should load all available packs', async () => {
createTestPack('testing', ['skill1', 'skill2']);
createTestPack('debugging', ['skill3']);
const loader = new MethodologyLoader(packsDir);
const packs = await loader.loadAllPacks();
expect(packs).toHaveLength(2);
expect(packs.map(p => p.name).sort()).toEqual(['debugging', 'testing']);
});
it('should return empty array when no packs exist', async () => {
const loader = new MethodologyLoader(packsDir);
const packs = await loader.loadAllPacks();
expect(packs).toHaveLength(0);
});
});
describe('loadPack', () => {
it('should load a specific pack by name', async () => {
createTestPack('testing', ['skill1', 'skill2']);
const loader = new MethodologyLoader(packsDir);
const pack = await loader.loadPack('testing');
expect(pack).not.toBeNull();
expect(pack?.name).toBe('testing');
expect(pack?.skills).toEqual(['skill1', 'skill2']);
});
it('should return null for non-existent pack', async () => {
const loader = new MethodologyLoader(packsDir);
const pack = await loader.loadPack('nonexistent');
expect(pack).toBeNull();
});
it('should cache loaded packs', async () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
const pack1 = await loader.loadPack('testing');
const pack2 = await loader.loadPack('testing');
expect(pack1).toBe(pack2);
});
});
describe('loadPackSkills', () => {
it('should load all skills from a pack', async () => {
createTestPack('testing', ['skill1', 'skill2']);
const loader = new MethodologyLoader(packsDir);
const skills = await loader.loadPackSkills('testing');
expect(skills).toHaveLength(2);
expect(skills.map(s => s.id).sort()).toEqual(['testing/skill1', 'testing/skill2']);
});
it('should throw error for non-existent pack', async () => {
const loader = new MethodologyLoader(packsDir);
await expect(loader.loadPackSkills('nonexistent')).rejects.toThrow();
});
});
describe('loadSkill', () => {
it('should load a specific skill', async () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
const skill = await loader.loadSkill('testing', 'skill1');
expect(skill).not.toBeNull();
expect(skill?.id).toBe('testing/skill1');
expect(skill?.name).toBe('skill1');
expect(skill?.pack).toBe('testing');
});
it('should return null for non-existent skill', async () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
const skill = await loader.loadSkill('testing', 'nonexistent');
expect(skill).toBeNull();
});
it('should extract metadata from skill content', async () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
const skill = await loader.loadSkill('testing', 'skill1');
expect(skill?.metadata.triggers).toEqual(['skill1']);
expect(skill?.tags).toEqual(['test']);
});
});
describe('getSkillById', () => {
it('should get skill by full ID', async () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
const skill = await loader.getSkillById('testing/skill1');
expect(skill).not.toBeNull();
expect(skill?.id).toBe('testing/skill1');
});
it('should return null for invalid ID format', async () => {
const loader = new MethodologyLoader(packsDir);
const skill = await loader.getSkillById('invalid');
expect(skill).toBeNull();
});
});
describe('searchSkills', () => {
it('should search skills by name', async () => {
createTestPack('testing', ['tdd-skill', 'debug-skill']);
const loader = new MethodologyLoader(packsDir);
const skills = await loader.searchSkills('tdd');
expect(skills).toHaveLength(1);
expect(skills[0].id).toBe('testing/tdd-skill');
});
it('should search skills by tag', async () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
const skills = await loader.searchSkills('test');
expect(skills).toHaveLength(1);
});
it('should return all skills when query is empty', async () => {
createTestPack('testing', ['skill1', 'skill2']);
const loader = new MethodologyLoader(packsDir);
const skills = await loader.searchSkills('');
expect(skills).toHaveLength(2);
});
});
describe('packExists', () => {
it('should return true for existing pack', () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
expect(loader.packExists('testing')).toBe(true);
});
it('should return false for non-existent pack', () => {
const loader = new MethodologyLoader(packsDir);
expect(loader.packExists('nonexistent')).toBe(false);
});
});
describe('clearCache', () => {
it('should clear cached packs and skills', async () => {
createTestPack('testing', ['skill1']);
const loader = new MethodologyLoader(packsDir);
// Load to populate cache
await loader.loadPack('testing');
await loader.loadSkill('testing', 'skill1');
// Clear cache
loader.clearCache();
// Modify pack on disk
const packDir = join(packsDir, 'testing');
const manifest = {
name: 'testing',
version: '2.0.0',
description: 'Updated pack',
skills: ['skill1'],
tags: ['testing'],
compatibility: ['all'],
};
writeFileSync(join(packDir, 'pack.json'), JSON.stringify(manifest, null, 2));
// Reload should get new version
const pack = await loader.loadPack('testing');
expect(pack?.version).toBe('2.0.0');
});
});
});
describe('createMethodologyLoader', () => {
it('should create a loader instance', () => {
const loader = createMethodologyLoader();
expect(loader).toBeInstanceOf(MethodologyLoader);
});
it('should accept custom packs directory', () => {
const customDir = '/custom/packs';
const loader = createMethodologyLoader(customDir);
expect(loader.getPacksDir()).toBe(customDir);
});
});
@@ -1,353 +0,0 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { MethodologyManager, createMethodologyManager } from '../manager.js';
describe('MethodologyManager', () => {
let testDir: string;
let packsDir: string;
let projectPath: string;
beforeEach(() => {
// Create temporary directories for tests
testDir = join(tmpdir(), `skillkit-manager-test-${Date.now()}`);
packsDir = join(testDir, 'packs');
projectPath = join(testDir, 'project');
mkdirSync(packsDir, { recursive: true });
mkdirSync(projectPath, { recursive: true });
});
afterEach(() => {
// Clean up
if (existsSync(testDir)) {
rmSync(testDir, { recursive: true, force: true });
}
});
function createTestPack(name: string, skills: string[]): void {
const packDir = join(packsDir, name);
mkdirSync(packDir, { recursive: true });
// Create pack.json
const manifest = {
name,
version: '1.0.0',
description: `Test ${name} pack`,
skills,
tags: [name],
compatibility: ['all'],
};
writeFileSync(join(packDir, 'pack.json'), JSON.stringify(manifest, null, 2));
// Create skill directories and SKILL.md files
for (const skill of skills) {
const skillDir = join(packDir, skill);
mkdirSync(skillDir, { recursive: true });
const skillContent = `---
name: ${skill}
description: Test skill ${skill}
version: 1.0.0
triggers:
- ${skill}
tags:
- test
---
# ${skill}
This is a test skill. You must follow these instructions.
## Instructions
Do the thing.
`;
writeFileSync(join(skillDir, 'SKILL.md'), skillContent);
}
}
describe('installPack', () => {
it('should install a pack and its skills', async () => {
createTestPack('testing', ['skill1', 'skill2']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.installPack('testing');
expect(result.success).toBe(true);
expect(result.installed).toHaveLength(2);
expect(result.installed).toContain('testing/skill1');
expect(result.installed).toContain('testing/skill2');
});
it('should skip already installed packs', async () => {
createTestPack('testing', ['skill1']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
// Install first time
await manager.installPack('testing');
// Install again
const result = await manager.installPack('testing');
expect(result.success).toBe(true);
expect(result.skipped).toContain('testing');
});
it('should fail for non-existent pack', async () => {
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.installPack('nonexistent');
expect(result.success).toBe(false);
expect(result.failed).toHaveLength(1);
});
});
describe('installAllPacks', () => {
it('should install all available packs', async () => {
createTestPack('testing', ['skill1']);
createTestPack('debugging', ['skill2']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.installAllPacks();
expect(result.success).toBe(true);
expect(result.installed).toHaveLength(2);
});
});
describe('installSkill', () => {
it('should install a single skill', async () => {
createTestPack('testing', ['skill1', 'skill2']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.installSkill('testing/skill1');
expect(result.success).toBe(true);
expect(result.installed).toContain('testing/skill1');
});
it('should fail for non-existent skill', async () => {
createTestPack('testing', ['skill1']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.installSkill('testing/nonexistent');
expect(result.success).toBe(false);
});
});
describe('uninstallPack', () => {
it('should uninstall a pack', async () => {
createTestPack('testing', ['skill1']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
await manager.installPack('testing');
await manager.uninstallPack('testing');
const installed = manager.listInstalledPacks();
expect(installed).toHaveLength(0);
});
it('should throw for non-installed pack', async () => {
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
await expect(manager.uninstallPack('testing')).rejects.toThrow();
});
});
describe('listInstalledPacks', () => {
it('should list installed packs', async () => {
createTestPack('testing', ['skill1', 'skill2']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
await manager.installPack('testing');
const installed = manager.listInstalledPacks();
expect(installed).toHaveLength(1);
expect(installed[0].name).toBe('testing');
expect(installed[0].skills).toHaveLength(2);
});
it('should return empty array when nothing installed', () => {
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const installed = manager.listInstalledPacks();
expect(installed).toHaveLength(0);
});
});
describe('listInstalledSkills', () => {
it('should list installed skills', async () => {
createTestPack('testing', ['skill1', 'skill2']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
await manager.installPack('testing');
const installed = manager.listInstalledSkills();
expect(installed).toHaveLength(2);
});
});
describe('listAvailablePacks', () => {
it('should list packs not yet installed', async () => {
createTestPack('testing', ['skill1']);
createTestPack('debugging', ['skill2']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
await manager.installPack('testing');
const available = await manager.listAvailablePacks();
expect(available).toHaveLength(1);
expect(available[0].name).toBe('debugging');
});
});
describe('search', () => {
it('should search by query string', async () => {
createTestPack('testing', ['tdd-skill']);
createTestPack('debugging', ['debug-skill']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.search({ query: 'tdd' });
expect(result.skills).toHaveLength(1);
expect(result.skills[0].id).toBe('testing/tdd-skill');
});
it('should search by tags', async () => {
createTestPack('testing', ['skill1']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.search({ tags: ['test'] });
expect(result.skills).toHaveLength(1);
});
it('should search by pack', async () => {
createTestPack('testing', ['skill1', 'skill2']);
createTestPack('debugging', ['skill3']);
const manager = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const result = await manager.search({ pack: 'testing' });
expect(result.skills).toHaveLength(2);
expect(result.packs).toHaveLength(1);
});
});
describe('state persistence', () => {
it('should persist installed packs across instances', async () => {
createTestPack('testing', ['skill1']);
// Install with first instance
const manager1 = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
await manager1.installPack('testing');
// Check with second instance
const manager2 = createMethodologyManager({
projectPath,
packsDir,
autoSync: false,
});
const installed = manager2.listInstalledPacks();
expect(installed).toHaveLength(1);
expect(installed[0].name).toBe('testing');
});
});
});
describe('createMethodologyManager', () => {
it('should create a manager instance', () => {
const testDir = join(tmpdir(), `skillkit-test-create-${Date.now()}`);
mkdirSync(testDir, { recursive: true });
try {
const manager = createMethodologyManager({ projectPath: testDir });
expect(manager).toBeInstanceOf(MethodologyManager);
} finally {
rmSync(testDir, { recursive: true, force: true });
}
});
});
@@ -1,270 +0,0 @@
import { describe, it, expect } from 'vitest';
import {
validatePackManifest,
validateSkillContent,
extractSkillMetadata,
} from '../validator.js';
describe('validatePackManifest', () => {
it('should validate a valid pack manifest', () => {
const manifest = {
name: 'testing',
version: '1.0.0',
description: 'Test-driven development methodology pack',
skills: ['red-green-refactor', 'test-patterns'],
tags: ['tdd', 'testing'],
compatibility: ['all'],
};
const result = validatePackManifest(manifest);
expect(result.valid).toBe(true);
expect(result.errors).toHaveLength(0);
});
it('should reject manifest with missing name', () => {
const manifest = {
version: '1.0.0',
description: 'Test pack',
skills: ['skill1'],
};
const result = validatePackManifest(manifest);
expect(result.valid).toBe(false);
expect(result.errors.some(e => e.code === 'MISSING_NAME')).toBe(true);
});
it('should reject manifest with invalid name format', () => {
const manifest = {
name: 'Invalid Name',
version: '1.0.0',
description: 'Test pack',
skills: ['skill1'],
};
const result = validatePackManifest(manifest);
expect(result.valid).toBe(false);
expect(result.errors.some(e => e.code === 'INVALID_NAME')).toBe(true);
});
it('should reject manifest with missing version', () => {
const manifest = {
name: 'testing',
description: 'Test pack',
skills: ['skill1'],
};
const result = validatePackManifest(manifest);
expect(result.valid).toBe(false);
expect(result.errors.some(e => e.code === 'MISSING_VERSION')).toBe(true);
});
it('should reject manifest with invalid version format', () => {
const manifest = {
name: 'testing',
version: 'v1',
description: 'Test pack',
skills: ['skill1'],
};
const result = validatePackManifest(manifest);
expect(result.valid).toBe(false);
expect(result.errors.some(e => e.code === 'INVALID_VERSION')).toBe(true);
});
it('should reject manifest with empty skills array', () => {
const manifest = {
name: 'testing',
version: '1.0.0',
description: 'Test pack',
skills: [],
};
const result = validatePackManifest(manifest);
expect(result.valid).toBe(false);
expect(result.errors.some(e => e.code === 'EMPTY_SKILLS')).toBe(true);
});
it('should warn about short description', () => {
const manifest = {
name: 'testing',
version: '1.0.0',
description: 'Short',
skills: ['skill1'],
};
const result = validatePackManifest(manifest);
expect(result.warnings.some(w => w.code === 'SHORT_DESCRIPTION')).toBe(true);
});
it('should warn about missing tags', () => {
const manifest = {
name: 'testing',
version: '1.0.0',
description: 'A longer description for the pack',
skills: ['skill1'],
};
const result = validatePackManifest(manifest);
expect(result.warnings.some(w => w.code === 'MISSING_TAGS')).toBe(true);
});
});
describe('validateSkillContent', () => {
it('should validate valid skill content', () => {
const content = `---
name: Test Skill
description: A test skill
version: 1.0.0
triggers:
- test
---
# Test Skill
## Description
This skill helps with testing. You should always write tests first.
## Instructions
1. Write a failing test
2. Make it pass
3. Refactor
`;
const result = validateSkillContent(content);
expect(result.valid).toBe(true);
expect(result.errors).toHaveLength(0);
});
it('should reject empty content', () => {
const result = validateSkillContent('');
expect(result.valid).toBe(false);
expect(result.errors.some(e => e.code === 'EMPTY_CONTENT')).toBe(true);
});
it('should reject unclosed frontmatter', () => {
const content = `---
name: Test Skill
description: A test skill
# Missing closing frontmatter
`;
const result = validateSkillContent(content);
expect(result.valid).toBe(false);
expect(result.errors.some(e => e.code === 'UNCLOSED_FRONTMATTER')).toBe(true);
});
it('should warn about missing frontmatter', () => {
const content = `# Test Skill
This is a skill without frontmatter. You should always follow these instructions.
`;
const result = validateSkillContent(content);
expect(result.valid).toBe(true); // Still valid, just a warning
expect(result.warnings.some(w => w.code === 'NO_FRONTMATTER')).toBe(true);
});
it('should warn about missing structure', () => {
const content = `---
name: Test
---
Just some random text without proper sections. You must follow this.
`;
const result = validateSkillContent(content);
expect(result.warnings.some(w => w.code === 'MISSING_STRUCTURE')).toBe(true);
});
});
describe('extractSkillMetadata', () => {
it('should extract simple key-value pairs', () => {
const content = `---
name: Test Skill
version: 1.0.0
difficulty: intermediate
---
# Content
`;
const metadata = extractSkillMetadata(content);
expect(metadata.name).toBe('Test Skill');
expect(metadata.version).toBe('1.0.0');
expect(metadata.difficulty).toBe('intermediate');
});
it('should extract array values', () => {
const content = `---
name: Test Skill
triggers:
- tdd
- test driven
- write tests
tags:
- testing
- quality
---
# Content
`;
const metadata = extractSkillMetadata(content);
expect(metadata.triggers).toEqual(['tdd', 'test driven', 'write tests']);
expect(metadata.tags).toEqual(['testing', 'quality']);
});
it('should extract inline arrays', () => {
const content = `---
name: Test Skill
tags: [testing, quality]
---
# Content
`;
const metadata = extractSkillMetadata(content);
expect(metadata.tags).toEqual(['testing', 'quality']);
});
it('should extract numeric values', () => {
const content = `---
name: Test Skill
estimatedTime: 15
---
# Content
`;
const metadata = extractSkillMetadata(content);
expect(metadata.estimatedTime).toBe(15);
});
it('should extract boolean values', () => {
const content = `---
name: Test Skill
deprecated: true
active: false
---
# Content
`;
const metadata = extractSkillMetadata(content);
expect(metadata.deprecated).toBe(true);
expect(metadata.active).toBe(false);
});
it('should return empty object for content without frontmatter', () => {
const content = `# Test Skill
No frontmatter here.
`;
const metadata = extractSkillMetadata(content);
expect(metadata).toEqual({});
});
});
-50
View File
@@ -1,50 +0,0 @@
/**
* Methodology Framework
*
* Provides a composable, community-driven methodology system for AI coding agents.
* Supports multiple approaches (TDD, BDD, DDD, or custom methodologies) through
* installable "packs" of related skills.
*
* Key features:
* - Methodology packs: Collections of related skills (testing, debugging, planning)
* - Universal translation: Skills work across all 17 supported agents
* - Pack management: Install, uninstall, and sync methodology skills
* - Community-driven: Open for custom methodology contributions
*/
// Manager
export { MethodologyManager, createMethodologyManager } from './manager.js';
// Loader
export {
MethodologyLoader,
createMethodologyLoader,
getBuiltinPacksDir,
} from './loader.js';
// Validator
export {
validatePackManifest,
validateSkillContent,
validatePackDirectory,
validateBuiltinPacks,
extractSkillMetadata,
} from './validator.js';
// Types
export type {
MethodologyPack,
MethodologySkill,
MethodologySkillMetadata,
MethodologyState,
MethodologyManagerOptions,
InstallResult,
MethodologySyncResult,
ValidationResult,
ValidationError,
ValidationWarning,
MethodologySearchQuery,
MethodologySearchResult,
InstalledPackInfo,
InstalledSkillInfo,
} from './types.js';
-278
View File
@@ -1,278 +0,0 @@
/**
* Methodology Loader
*
* Loads methodology packs and skills from the built-in packs directory
* and custom locations.
*/
import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
import type {
MethodologyPack,
MethodologySkill,
MethodologySkillMetadata,
} from './types.js';
import { validatePackDirectory, extractSkillMetadata } from './validator.js';
// Get the directory of this module
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
// Built-in packs directory (relative to this file in dist)
const BUILTIN_PACKS_DIR = join(__dirname, 'packs');
/**
* Methodology Loader class
*/
export class MethodologyLoader {
private packsDir: string;
private loadedPacks: Map<string, MethodologyPack> = new Map();
private loadedSkills: Map<string, MethodologySkill> = new Map();
constructor(customPacksDir?: string) {
this.packsDir = customPacksDir || BUILTIN_PACKS_DIR;
}
/**
* Load all available packs
*/
async loadAllPacks(): Promise<MethodologyPack[]> {
const packs: MethodologyPack[] = [];
if (!existsSync(this.packsDir)) {
return packs;
}
const packDirs = readdirSync(this.packsDir).filter((name) => {
const packPath = join(this.packsDir, name);
return statSync(packPath).isDirectory();
});
for (const packName of packDirs) {
try {
const pack = await this.loadPack(packName);
if (pack) {
packs.push(pack);
}
} catch {
// Skip invalid packs
}
}
return packs;
}
/**
* Load a specific pack by name
*/
async loadPack(packName: string): Promise<MethodologyPack | null> {
// Check cache
if (this.loadedPacks.has(packName)) {
return this.loadedPacks.get(packName)!;
}
const packPath = join(this.packsDir, packName);
const manifestPath = join(packPath, 'pack.json');
if (!existsSync(manifestPath)) {
return null;
}
// Validate pack
const validation = validatePackDirectory(packPath);
if (!validation.valid) {
throw new Error(
`Invalid pack "${packName}": ${validation.errors.map((e) => e.message).join(', ')}`
);
}
// Load manifest
const manifest = JSON.parse(
readFileSync(manifestPath, 'utf-8')
) as MethodologyPack;
// Cache and return
this.loadedPacks.set(packName, manifest);
return manifest;
}
/**
* Load all skills from a pack
*/
async loadPackSkills(packName: string): Promise<MethodologySkill[]> {
const pack = await this.loadPack(packName);
if (!pack) {
throw new Error(`Pack not found: ${packName}`);
}
const skills: MethodologySkill[] = [];
for (const skillName of pack.skills) {
const skill = await this.loadSkill(packName, skillName);
if (skill) {
skills.push(skill);
}
}
return skills;
}
/**
* Load a specific skill
*/
async loadSkill(
packName: string,
skillName: string
): Promise<MethodologySkill | null> {
const skillId = `${packName}/${skillName}`;
// Check cache
if (this.loadedSkills.has(skillId)) {
return this.loadedSkills.get(skillId)!;
}
const skillPath = join(this.packsDir, packName, skillName, 'SKILL.md');
if (!existsSync(skillPath)) {
return null;
}
const content = readFileSync(skillPath, 'utf-8');
const rawMetadata = extractSkillMetadata(content);
// Parse metadata with defaults
const metadata: MethodologySkillMetadata = {
triggers: rawMetadata.triggers as string[] | undefined,
relatedSkills: rawMetadata.relatedSkills as string[] | undefined,
difficulty: rawMetadata.difficulty as MethodologySkillMetadata['difficulty'],
estimatedTime: rawMetadata.estimatedTime as number | undefined,
prerequisites: rawMetadata.prerequisites as string[] | undefined,
...rawMetadata,
};
const skill: MethodologySkill = {
id: skillId,
name: (rawMetadata.name as string) || formatSkillName(skillName),
description: (rawMetadata.description as string) || '',
version: (rawMetadata.version as string) || '1.0.0',
pack: packName,
tags: (rawMetadata.tags as string[]) || [],
path: skillPath,
content,
metadata,
};
// Cache and return
this.loadedSkills.set(skillId, skill);
return skill;
}
/**
* Get skill by full ID (pack/skill)
*/
async getSkillById(skillId: string): Promise<MethodologySkill | null> {
const [packName, skillName] = skillId.split('/');
if (!packName || !skillName) {
return null;
}
return this.loadSkill(packName, skillName);
}
/**
* Search skills by query
*/
async searchSkills(query: string): Promise<MethodologySkill[]> {
const allSkills: MethodologySkill[] = [];
const packs = await this.loadAllPacks();
for (const pack of packs) {
const skills = await this.loadPackSkills(pack.name);
allSkills.push(...skills);
}
if (!query) {
return allSkills;
}
const lowerQuery = query.toLowerCase();
return allSkills.filter((skill) => {
return (
skill.name.toLowerCase().includes(lowerQuery) ||
skill.description.toLowerCase().includes(lowerQuery) ||
skill.tags.some((tag) => tag.toLowerCase().includes(lowerQuery)) ||
skill.metadata.triggers?.some((t) =>
t.toLowerCase().includes(lowerQuery)
)
);
});
}
/**
* Get skills by tag
*/
async getSkillsByTag(tag: string): Promise<MethodologySkill[]> {
const allSkills: MethodologySkill[] = [];
const packs = await this.loadAllPacks();
for (const pack of packs) {
const skills = await this.loadPackSkills(pack.name);
allSkills.push(...skills);
}
const lowerTag = tag.toLowerCase();
return allSkills.filter((skill) =>
skill.tags.some((t) => t.toLowerCase() === lowerTag)
);
}
/**
* Get built-in packs directory path
*/
getPacksDir(): string {
return this.packsDir;
}
/**
* Check if a pack exists
*/
packExists(packName: string): boolean {
const packPath = join(this.packsDir, packName);
const manifestPath = join(packPath, 'pack.json');
return existsSync(manifestPath);
}
/**
* Clear cache
*/
clearCache(): void {
this.loadedPacks.clear();
this.loadedSkills.clear();
}
}
/**
* Format skill directory name to display name
*/
function formatSkillName(dirName: string): string {
return dirName
.split('-')
.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
.join(' ');
}
/**
* Create a methodology loader instance
*/
export function createMethodologyLoader(
customPacksDir?: string
): MethodologyLoader {
return new MethodologyLoader(customPacksDir);
}
/**
* Get the built-in packs directory
*/
export function getBuiltinPacksDir(): string {
return BUILTIN_PACKS_DIR;
}

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