mirror of
https://github.com/rohitg00/skillkit.git
synced 2026-11-20 12:23:29 +00:00
Compare commits
10
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
131bc122be | ||
|
|
e35cd0d0df | ||
|
|
287dfeac58 | ||
|
|
32914cb8dc | ||
|
|
04c4faff6a | ||
|
|
d8a6b4a700 | ||
|
|
0518ed40a3 | ||
|
|
91e7ab3450 | ||
|
|
d62fe0b761 | ||
|
|
1344d65b3d |
@@ -7,6 +7,7 @@ on:
|
||||
branches: [main]
|
||||
|
||||
jobs:
|
||||
# Unit tests run on all Node versions
|
||||
test:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
@@ -35,5 +36,55 @@ jobs:
|
||||
- name: Build
|
||||
run: pnpm build
|
||||
|
||||
- name: Test
|
||||
- name: Unit Tests
|
||||
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!"
|
||||
|
||||
+5
-1
@@ -59,4 +59,8 @@ skillkit.yaml
|
||||
.skillkit/
|
||||
|
||||
# Turbo cache
|
||||
.turbo/
|
||||
.turbo/
|
||||
|
||||
# Project documentation (not for version control)
|
||||
CLAUDE.md
|
||||
prd.md
|
||||
@@ -13,13 +13,14 @@
|
||||
npm install -g skillkit
|
||||
```
|
||||
|
||||
## What's New in v1.5.0
|
||||
## What's New in v1.6.0
|
||||
|
||||
- **Team Collaboration**: Share skill bundles with your team via Git
|
||||
- **Plugin System**: Extend SkillKit with custom translators, providers, and commands
|
||||
- **Methodologies**: 5 ready-to-use development frameworks (Agile, TDD, DevOps, etc.)
|
||||
- **Agent Orchestration**: Coordinate multiple AI agents working together
|
||||
- **Hooks & Automation**: Auto-trigger skills on git commits, file changes
|
||||
- **Methodology Framework**: 5 ready-to-use development frameworks (Agile, TDD, DevOps, Security-First, Documentation-First) with 13 specialized skills
|
||||
- **Hooks System**: Event-driven skill triggers - auto-activate on git commits, file changes, builds, tests, deployments
|
||||
- **Agent Orchestration**: Multi-agent team coordination with leader/teammate roles and task assignment
|
||||
- **Plan System**: Structured plan creation with validation and execution - parse, validate, and execute development plans
|
||||
- **Slash Commands**: Generate agent-native commands from natural language for all 17 AI agents
|
||||
- **Enhanced TUI**: New Methodology (o) and Plan (n) screens with improved navigation
|
||||
|
||||
## The Problem
|
||||
|
||||
@@ -230,7 +231,7 @@ skillkit cicd pre-commit
|
||||
| OpenCode | SKILL.md | `.opencode/skills/` |
|
||||
| Antigravity | SKILL.md | `.antigravity/skills/` |
|
||||
| Amp | SKILL.md | `.amp/skills/` |
|
||||
| Clawdbot | SKILL.md | `skills/` |
|
||||
| Clawdbot | SKILL.md | `skills/` or `~/.clawdbot/skills/` |
|
||||
| Droid (Factory) | SKILL.md | `.factory/skills/` |
|
||||
| GitHub Copilot | Markdown | `.github/skills/` |
|
||||
| Goose | SKILL.md | `.goose/skills/` |
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "skillkit",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"description": "Universal skills loader for AI coding agents - supports Claude Code, Codex, Cursor, Antigravity, OpenCode, Gemini CLI and more",
|
||||
"type": "module",
|
||||
"bin": {
|
||||
@@ -53,10 +53,10 @@
|
||||
"node": ">=18.0.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@skillkit/core": "workspace:*",
|
||||
"@skillkit/agents": "workspace:*",
|
||||
"@skillkit/cli": "workspace:*",
|
||||
"@skillkit/tui": "workspace:*",
|
||||
"@skillkit/core": "^1.6.0",
|
||||
"@skillkit/agents": "^1.6.0",
|
||||
"@skillkit/cli": "^1.6.0",
|
||||
"@skillkit/tui": "^1.6.0",
|
||||
"clipanion": "^4.0.0-rc.4"
|
||||
},
|
||||
"devDependencies": {
|
||||
|
||||
@@ -0,0 +1,458 @@
|
||||
/**
|
||||
* 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();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,292 @@
|
||||
/**
|
||||
* 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();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,285 @@
|
||||
/**
|
||||
* 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}`
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
/**
|
||||
* E2E Test Helpers - Barrel Export
|
||||
*/
|
||||
|
||||
export * from './cli-runner.js';
|
||||
@@ -0,0 +1,400 @@
|
||||
/**
|
||||
* 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);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,424 @@
|
||||
/**
|
||||
* 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);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,397 @@
|
||||
/**
|
||||
* 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();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,333 @@
|
||||
/**
|
||||
* 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);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,345 @@
|
||||
/**
|
||||
* 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);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"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"]
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
import { defineConfig } from 'vitest/config';
|
||||
|
||||
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,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "skillkit",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "skillkit",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"chalk": "^5.3.0",
|
||||
|
||||
+4
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "skillkit-monorepo",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"private": true,
|
||||
"description": "Universal skills loader for AI coding agents - Monorepo",
|
||||
"type": "module",
|
||||
@@ -10,6 +10,9 @@
|
||||
"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"
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@skillkit/agents",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"description": "Agent adapters for SkillKit - supports 17+ AI coding agents",
|
||||
"type": "module",
|
||||
"main": "./dist/index.js",
|
||||
@@ -21,7 +21,7 @@
|
||||
"test": "vitest run"
|
||||
},
|
||||
"dependencies": {
|
||||
"@skillkit/core": "workspace:*",
|
||||
"@skillkit/core": "^1.6.0",
|
||||
"minimatch": "^9.0.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
|
||||
@@ -0,0 +1,412 @@
|
||||
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('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>');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -20,7 +20,8 @@ export function createSkillXml(skill: Skill): string {
|
||||
</skill>`;
|
||||
}
|
||||
|
||||
export function escapeXml(text: string): string {
|
||||
export function escapeXml(text: string | undefined): string {
|
||||
if (!text) return '';
|
||||
return text
|
||||
.replace(/&/g, '&')
|
||||
.replace(/</g, '<')
|
||||
|
||||
@@ -68,7 +68,8 @@ ${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(globalClawdbot) || (existsSync(projectSkills) && existsSync(join(process.cwd(), '.clawdbot')));
|
||||
return existsSync(projectSkills) || existsSync(globalClawdbot) || existsSync(clawdbotConfig);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@skillkit/cli",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"description": "CLI commands for SkillKit",
|
||||
"type": "module",
|
||||
"main": "./dist/index.js",
|
||||
@@ -21,9 +21,9 @@
|
||||
"test": "vitest run"
|
||||
},
|
||||
"dependencies": {
|
||||
"@skillkit/core": "workspace:*",
|
||||
"@skillkit/agents": "workspace:*",
|
||||
"@skillkit/tui": "workspace:*",
|
||||
"@skillkit/core": "^1.6.0",
|
||||
"@skillkit/agents": "^1.6.0",
|
||||
"@skillkit/tui": "^1.6.0",
|
||||
"chalk": "^5.3.0",
|
||||
"clipanion": "^4.0.0-rc.4",
|
||||
"got": "^14.4.1",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@skillkit/core",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"description": "Core functionality for SkillKit - skill discovery, parsing, and translation",
|
||||
"type": "module",
|
||||
"main": "./dist/index.js",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@skillkit/tui",
|
||||
"version": "1.5.0",
|
||||
"version": "1.6.1",
|
||||
"description": "Terminal UI for SkillKit",
|
||||
"type": "module",
|
||||
"main": "./dist/index.js",
|
||||
@@ -21,8 +21,8 @@
|
||||
"test": "vitest run"
|
||||
},
|
||||
"dependencies": {
|
||||
"@skillkit/core": "workspace:*",
|
||||
"@skillkit/agents": "workspace:*",
|
||||
"@skillkit/core": "^1.6.0",
|
||||
"@skillkit/agents": "^1.6.0",
|
||||
"chalk": "^5.3.0",
|
||||
"ink": "^5.0.1",
|
||||
"ink-select-input": "^6.0.0",
|
||||
|
||||
Generated
+82
-20
@@ -30,17 +30,17 @@ importers:
|
||||
apps/skillkit:
|
||||
dependencies:
|
||||
'@skillkit/agents':
|
||||
specifier: workspace:*
|
||||
version: link:../../packages/agents
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0
|
||||
'@skillkit/cli':
|
||||
specifier: workspace:*
|
||||
version: link:../../packages/cli
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0(@types/react@18.3.27)(typanion@3.14.0)
|
||||
'@skillkit/core':
|
||||
specifier: workspace:*
|
||||
version: link:../../packages/core
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0
|
||||
'@skillkit/tui':
|
||||
specifier: workspace:*
|
||||
version: link:../../packages/tui
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0(@types/react@18.3.27)
|
||||
clipanion:
|
||||
specifier: ^4.0.0-rc.4
|
||||
version: 4.0.0-rc.4(typanion@3.14.0)
|
||||
@@ -61,8 +61,8 @@ importers:
|
||||
packages/agents:
|
||||
dependencies:
|
||||
'@skillkit/core':
|
||||
specifier: workspace:*
|
||||
version: link:../core
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0
|
||||
minimatch:
|
||||
specifier: ^9.0.0
|
||||
version: 9.0.5
|
||||
@@ -83,14 +83,14 @@ importers:
|
||||
packages/cli:
|
||||
dependencies:
|
||||
'@skillkit/agents':
|
||||
specifier: workspace:*
|
||||
version: link:../agents
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0
|
||||
'@skillkit/core':
|
||||
specifier: workspace:*
|
||||
version: link:../core
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0
|
||||
'@skillkit/tui':
|
||||
specifier: workspace:*
|
||||
version: link:../tui
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0(@types/react@18.3.27)
|
||||
chalk:
|
||||
specifier: ^5.3.0
|
||||
version: 5.6.2
|
||||
@@ -154,11 +154,11 @@ importers:
|
||||
packages/tui:
|
||||
dependencies:
|
||||
'@skillkit/agents':
|
||||
specifier: workspace:*
|
||||
version: link:../agents
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0
|
||||
'@skillkit/core':
|
||||
specifier: workspace:*
|
||||
version: link:../core
|
||||
specifier: ^1.6.0
|
||||
version: 1.6.0
|
||||
chalk:
|
||||
specifier: ^5.3.0
|
||||
version: 5.6.2
|
||||
@@ -650,6 +650,22 @@ packages:
|
||||
resolution: {integrity: sha512-P1Cz1dWaFfR4IR+U13mqqiGsLFf1KbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzf13K8DCCXQw==}
|
||||
engines: {node: '>=18'}
|
||||
|
||||
'@skillkit/agents@1.6.0':
|
||||
resolution: {integrity: sha512-rYq9wMqI55ucVOMxR6fyal7Pj87funV884bb8NNop7MUOAEoETtHbMPMRL6MYv9bGvBRzwaNkWRo8cszCj+zjQ==}
|
||||
engines: {node: '>=18.0.0'}
|
||||
|
||||
'@skillkit/cli@1.6.0':
|
||||
resolution: {integrity: sha512-ghmeF3kj0TIB5hfct5aoQJO8KnxVBm2+m7wFwXg9aPtewSwws1C7nEYVFMRFWnL0kHPe6+tEo4qddm+GxJ8NFQ==}
|
||||
engines: {node: '>=18.0.0'}
|
||||
|
||||
'@skillkit/core@1.6.0':
|
||||
resolution: {integrity: sha512-987hhnYir4a3qnIkB/iIxeVeJ8mNF6R8IidtnFo9Q4GamcyvJ0W692V5wVOoR2MiS1F/NSstjfrV/h2ujMydyw==}
|
||||
engines: {node: '>=18.0.0'}
|
||||
|
||||
'@skillkit/tui@1.6.0':
|
||||
resolution: {integrity: sha512-5ifBzM0G0QhiX3cJDiUNd65SSQEmoFWKJEFtYLNDe/wcP7k3WPZemliyIpSknZh2564wqnwf3w4Ua2TtO9M/WQ==}
|
||||
engines: {node: '>=18.0.0'}
|
||||
|
||||
'@types/estree@1.0.8':
|
||||
resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
|
||||
|
||||
@@ -1891,6 +1907,52 @@ snapshots:
|
||||
|
||||
'@sindresorhus/is@7.2.0': {}
|
||||
|
||||
'@skillkit/agents@1.6.0':
|
||||
dependencies:
|
||||
'@skillkit/core': 1.6.0
|
||||
minimatch: 9.0.5
|
||||
|
||||
'@skillkit/cli@1.6.0(@types/react@18.3.27)(typanion@3.14.0)':
|
||||
dependencies:
|
||||
'@skillkit/agents': 1.6.0
|
||||
'@skillkit/core': 1.6.0
|
||||
'@skillkit/tui': 1.6.0(@types/react@18.3.27)
|
||||
chalk: 5.6.2
|
||||
clipanion: 4.0.0-rc.4(typanion@3.14.0)
|
||||
got: 14.6.6
|
||||
isomorphic-git: 1.36.1
|
||||
ora: 8.2.0
|
||||
yaml: 2.8.2
|
||||
transitivePeerDependencies:
|
||||
- '@types/react'
|
||||
- bufferutil
|
||||
- react-devtools-core
|
||||
- typanion
|
||||
- utf-8-validate
|
||||
|
||||
'@skillkit/core@1.6.0':
|
||||
dependencies:
|
||||
'@types/minimatch': 6.0.0
|
||||
minimatch: 10.1.1
|
||||
yaml: 2.8.2
|
||||
zod: 3.25.76
|
||||
|
||||
'@skillkit/tui@1.6.0(@types/react@18.3.27)':
|
||||
dependencies:
|
||||
'@skillkit/agents': 1.6.0
|
||||
'@skillkit/core': 1.6.0
|
||||
chalk: 5.6.2
|
||||
ink: 5.2.1(@types/react@18.3.27)(react@18.3.1)
|
||||
ink-select-input: 6.2.0(ink@5.2.1(@types/react@18.3.27)(react@18.3.1))(react@18.3.1)
|
||||
ink-spinner: 5.0.0(ink@5.2.1(@types/react@18.3.27)(react@18.3.1))(react@18.3.1)
|
||||
ink-text-input: 6.0.0(ink@5.2.1(@types/react@18.3.27)(react@18.3.1))(react@18.3.1)
|
||||
react: 18.3.1
|
||||
transitivePeerDependencies:
|
||||
- '@types/react'
|
||||
- bufferutil
|
||||
- react-devtools-core
|
||||
- utf-8-validate
|
||||
|
||||
'@types/estree@1.0.8': {}
|
||||
|
||||
'@types/http-cache-semantics@4.0.4': {}
|
||||
|
||||
Reference in New Issue
Block a user