feat: update agent adapters for 2026 compatibility (#10)

* feat: update agent adapters for 2026 compatibility

- Add new skill-translator module for cross-agent skill translation
- Update Cursor adapter to use .cursor/rules/*.mdc format with YAML frontmatter
- Update Windsurf adapter to use .windsurf/rules/*.md with mode field
- Update GitHub Copilot to use .github/copilot-instructions.md
- Update Trae to use .trae/rules/project_rules.md with YAML frontmatter
- Update OpenCode global path to ~/.config/opencode/
- Add new discovery paths for Cursor, Kilo, Roo, Windsurf, GitHub Copilot
- Improve agent detection with additional config file checks

BREAKING CHANGE: Config file paths have changed for Cursor, Windsurf, Trae, and GitHub Copilot adapters to match their 2026 specifications.

* feat: add e2e tests for skill-translator and fix translation issues

- Add comprehensive e2e tests for skill translator (86 tests)
- Fix translateSkillToAll to include all 17 agents
- Fix writeTranslatedSkill to check for failed translations
- Update vitest config to resolve workspace packages
- Remove unnecessary 2026 comments from agent adapters and skill-translator

* fix: improve agent detection and add overwrite option to translator

Agent detection fixes:
- github-copilot: Remove overly broad .github dir check, only detect
  Copilot-specific artifacts (copilot-instructions.md, instructions, ~/.copilot)
- kilo: Fix modes path from .kilocodemodes to .kilocode/modes
- roo: Fix modes path from .roomodes to .roo/modes

Translator improvements:
- Add overwrite option to writeTranslatedSkill() to prevent accidental overwrites
- Return skipped flag when file exists and overwrite=false

Refactoring:
- Centralize agent config in packages/core/src/agent-config.ts
- Update all agent adapters to use shared AGENT_CONFIG
- Re-export utility functions for backwards compatibility

* fix: update clawdbot test and use workspace dependency

- Update clawdbot test to expect new standardized skillsDir (.clawdbot/skills)
- Change @skillkit/core dependency to workspace:* for proper monorepo linking

* fix: address CodeRabbit and Devin review suggestions

- Remove AGENTS.md from detection in Kilo, Roo, Trae adapters (prevents false positives)
- Fix AmpAdapter detection path (check .amp instead of .agents)
- Fix regex pattern in parseConfig for markdown adapters to match any skill name format
- Add hooks and permissionMode to specialFields for proper extraction
- Add path traversal protection in writeTranslatedSkill
- Fix boolean field preservation using 'in' check instead of truthy checks
- Add mode field preservation for Windsurf
- Add permissionMode support for Roo adapter
This commit is contained in:
Rohit Ghumare
2026-01-25 14:09:47 +00:00
committed by GitHub
parent eadbaff07e
commit 413519d486
29 changed files with 2378 additions and 181 deletions
+761
View File
@@ -0,0 +1,761 @@
/**
* E2E Tests: Skill Translator
*
* End-to-end tests for cross-agent skill translation.
* Tests the complete workflow of parsing, translating, and writing skills.
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { join } from 'node:path';
import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
import {
createTestDir,
cleanupTestDir,
createTestSkill,
testFileExists,
readTestFile,
} from './helpers/cli-runner.js';
import {
parseSkillToCanonical,
parseSkillContentToCanonical,
translateSkillToAgent,
translateSkillToAll,
writeTranslatedSkill,
generateSkillsConfig,
getAgentSkillsDir,
getAgentConfigFile,
AGENT_SKILL_FORMATS,
type CrossAgentSkill,
} from '@skillkit/core';
// All 17 supported agents
const SUPPORTED_AGENTS = [
'claude-code',
'cursor',
'codex',
'gemini-cli',
'opencode',
'antigravity',
'amp',
'clawdbot',
'droid',
'github-copilot',
'goose',
'kilo',
'kiro-cli',
'roo',
'trae',
'windsurf',
'universal',
] as const;
describe('E2E: Skill Translator - Parsing', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir('skillkit-translator-');
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('parseSkillToCanonical', () => {
it('should parse a complete SKILL.md with all frontmatter fields', () => {
const skillDir = join(testDir, 'complete-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: complete-skill
description: A comprehensive skill for E2E testing
version: "2.0.0"
author: SkillKit Team
tags:
- testing
- e2e
- comprehensive
allowed-tools: Read, Write, Bash(npm:*)
---
# Complete Skill
This skill tests all parsing capabilities.
## Features
- Full frontmatter parsing
- Content extraction
- Agent-specific field handling
## Usage
\`\`\`bash
skillkit read complete-skill
\`\`\`
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.name).toBe('complete-skill');
expect(result?.description).toBe('A comprehensive skill for E2E testing');
expect(result?.version).toBe('2.0.0');
expect(result?.author).toBe('SkillKit Team');
expect(result?.tags).toEqual(['testing', 'e2e', 'comprehensive']);
expect(result?.allowedTools).toEqual(['Read', 'Write', 'Bash(npm:*)']);
expect(result?.content).toContain('# Complete Skill');
expect(result?.content).toContain('## Features');
});
it('should handle SKILL.md with minimal frontmatter', () => {
const skillDir = join(testDir, 'minimal-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: minimal-skill
description: Just the basics
---
# Minimal Skill
Simple content.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.name).toBe('minimal-skill');
expect(result?.description).toBe('Just the basics');
expect(result?.version).toBeUndefined();
expect(result?.author).toBeUndefined();
});
it('should extract description from content when not in frontmatter', () => {
const skillDir = join(testDir, 'no-desc-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: no-desc-skill
---
This is the first paragraph which should become the description automatically.
## More Content
Additional content here.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.description).toContain('This is the first paragraph');
});
it('should handle SKILL.md without any frontmatter', () => {
const skillDir = join(testDir, 'no-frontmatter');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `# No Frontmatter Skill
This skill has no YAML frontmatter at all.
## Usage
Just use it directly.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
// Name should be derived from directory
expect(result?.name).toBe('no-frontmatter');
expect(result?.content).toContain('# No Frontmatter Skill');
});
it('should return null for non-existent skill directory', () => {
const result = parseSkillToCanonical(join(testDir, 'does-not-exist'));
expect(result).toBeNull();
});
it('should return null for directory without SKILL.md', () => {
const emptyDir = join(testDir, 'empty-dir');
mkdirSync(emptyDir, { recursive: true });
writeFileSync(join(emptyDir, 'README.md'), '# Not a skill');
const result = parseSkillToCanonical(emptyDir);
expect(result).toBeNull();
});
});
describe('parseSkillContentToCanonical', () => {
it('should parse content with Claude Code specific fields', () => {
const content = `---
name: claude-specific
description: Skill with Claude Code specific fields
model: opus
context: fork
disable-model-invocation: true
---
# Claude Specific Skill
Use with Claude Code for best results.
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill', 'claude-code');
expect(result?.name).toBe('claude-specific');
expect(result?.agentFields?.model).toBe('opus');
expect(result?.agentFields?.context).toBe('fork');
expect(result?.agentFields?.['disable-model-invocation']).toBe(true);
expect(result?.sourceAgent).toBe('claude-code');
});
it('should parse content with Cursor specific fields', () => {
const content = `---
name: cursor-specific
description: Skill with Cursor specific fields
globs: "**/*.ts"
alwaysApply: true
---
# Cursor Specific Skill
Optimized for Cursor.
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill', 'cursor');
expect(result?.name).toBe('cursor-specific');
expect(result?.agentFields?.globs).toBe('**/*.ts');
expect(result?.agentFields?.alwaysApply).toBe(true);
expect(result?.sourceAgent).toBe('cursor');
});
});
});
describe('E2E: Skill Translator - Translation', () => {
let testDir: string;
let testSkill: CrossAgentSkill;
beforeEach(() => {
testDir = createTestDir('skillkit-translate-');
testSkill = {
name: 'translation-test',
description: 'A skill designed for testing cross-agent translation',
content: `# Translation Test Skill
This skill is used to verify that translation works correctly across all supported agents.
## Features
- Cross-agent compatibility
- Frontmatter preservation
- Content integrity
## Usage
\`\`\`bash
skillkit read translation-test
\`\`\`
`,
frontmatter: {
name: 'translation-test',
description: 'A skill designed for testing cross-agent translation',
version: '1.0.0',
author: 'SkillKit E2E Tests',
tags: ['testing', 'translation'],
},
sourcePath: join(testDir, 'translation-test'),
sourceAgent: 'claude-code',
version: '1.0.0',
author: 'SkillKit E2E Tests',
tags: ['testing', 'translation'],
allowedTools: ['Read', 'Write', 'Bash'],
};
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('translateSkillToAgent', () => {
it.each(SUPPORTED_AGENTS)('should translate skill to %s format', (agent) => {
const result = translateSkillToAgent(testSkill, agent);
expect(result.success).toBe(true);
expect(result.targetAgent).toBe(agent);
expect(result.content).toBeTruthy();
expect(result.content).toContain('translation-test');
expect(typeof result.filename).toBe('string');
});
it('should preserve skill name and description across translations', () => {
for (const agent of SUPPORTED_AGENTS) {
const result = translateSkillToAgent(testSkill, agent);
expect(result.content).toContain('translation-test');
}
});
it('should add translation metadata when requested', () => {
const result = translateSkillToAgent(testSkill, 'cursor', { addMetadata: true });
expect(result.success).toBe(true);
expect(result.content).toContain('_translated-from: claude-code');
expect(result.content).toContain('_translated-at:');
});
it('should not add metadata by default', () => {
const result = translateSkillToAgent(testSkill, 'cursor');
expect(result.success).toBe(true);
expect(result.content).not.toContain('_translated-from');
});
it('should preserve Claude Code specific fields when translating back to Claude Code', () => {
const claudeSkill: CrossAgentSkill = {
...testSkill,
agentFields: {
model: 'opus',
context: 'fork',
'disable-model-invocation': true,
},
};
const result = translateSkillToAgent(claudeSkill, 'claude-code');
expect(result.success).toBe(true);
expect(result.content).toContain('model: opus');
expect(result.content).toContain('context: fork');
expect(result.content).toContain('disable-model-invocation: true');
});
it('should report incompatible features when translating hooks to non-Claude agents', () => {
const skillWithHooks: CrossAgentSkill = {
...testSkill,
agentFields: {
hooks: [{ type: 'PreToolUse', command: 'echo test' }],
},
};
const result = translateSkillToAgent(skillWithHooks, 'cursor');
expect(result.incompatible).toContain('hooks (only supported in Claude Code)');
});
});
describe('translateSkillToAll', () => {
it('should translate skill to all agents except source', () => {
const skillDir = join(testDir, 'all-agents-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: all-agents
description: Skill for all agents testing
version: "1.0.0"
---
# All Agents Skill
Universal skill content.
`);
const results = translateSkillToAll(skillDir, 'claude-code');
// Should have translations for all agents except source
expect(results.size).toBe(SUPPORTED_AGENTS.length - 1);
expect(results.has('claude-code')).toBe(false);
for (const agent of SUPPORTED_AGENTS) {
if (agent !== 'claude-code') {
expect(results.has(agent)).toBe(true);
const result = results.get(agent);
expect(result?.success).toBe(true);
}
}
});
it('should return empty map for non-existent skill', () => {
const results = translateSkillToAll(join(testDir, 'non-existent'));
expect(results.size).toBe(0);
});
});
});
describe('E2E: Skill Translator - Writing', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir('skillkit-write-');
});
afterEach(() => {
cleanupTestDir(testDir);
});
describe('writeTranslatedSkill', () => {
it('should write translated skill to correct location', () => {
const translationResult = {
success: true,
content: `---
name: written-skill
description: A skill that was written to disk
---
# Written Skill
Content here.
`,
filename: 'SKILL.md',
targetDir: 'written-skill',
warnings: [],
incompatible: [],
targetAgent: 'claude-code' as const,
};
const writeResult = writeTranslatedSkill(translationResult, testDir);
expect(writeResult.success).toBe(true);
expect(existsSync(writeResult.path)).toBe(true);
const writtenContent = readFileSync(writeResult.path, 'utf-8');
expect(writtenContent).toContain('name: written-skill');
expect(writtenContent).toContain('# Written Skill');
});
it('should create nested directories as needed', () => {
const translationResult = {
success: true,
content: '---\nname: nested\n---\n# Content',
filename: 'SKILL.md',
targetDir: '.cursor/skills/deeply/nested/skill',
warnings: [],
incompatible: [],
targetAgent: 'cursor' as const,
};
const writeResult = writeTranslatedSkill(translationResult, testDir);
expect(writeResult.success).toBe(true);
expect(existsSync(join(testDir, '.cursor/skills/deeply/nested/skill/SKILL.md'))).toBe(true);
});
it('should handle failed translation results gracefully', () => {
const failedResult = {
success: false,
content: '',
filename: 'SKILL.md',
targetDir: 'failed-skill',
warnings: ['Translation failed'],
incompatible: [],
targetAgent: 'cursor' as const,
};
const writeResult = writeTranslatedSkill(failedResult, testDir);
expect(writeResult.success).toBe(false);
});
});
});
describe('E2E: Skill Translator - Config Generation', () => {
const testSkills = [
{ name: 'skill-alpha', description: 'First test skill', path: '/skills/alpha', location: 'project' as const, enabled: true },
{ name: 'skill-beta', description: 'Second test skill', path: '/skills/beta', location: 'project' as const, enabled: true },
{ name: 'skill-gamma', description: 'Third test skill', path: '/skills/gamma', location: 'global' as const, enabled: true },
{ name: 'skill-disabled', description: 'Disabled skill', path: '/skills/disabled', location: 'project' as const, enabled: false },
];
describe('generateSkillsConfig', () => {
it('should generate XML config for Claude Code', () => {
const config = generateSkillsConfig(testSkills, 'claude-code');
expect(config).toContain('<skills_system');
expect(config).toContain('<name>skill-alpha</name>');
expect(config).toContain('<name>skill-beta</name>');
expect(config).toContain('<name>skill-gamma</name>');
expect(config).not.toContain('skill-disabled');
expect(config).toContain('<description>First test skill</description>');
expect(config).toContain('skillkit read');
});
it('should generate MDC config for Cursor', () => {
const config = generateSkillsConfig(testSkills, 'cursor');
expect(config).toContain('---');
expect(config).toContain('description:');
expect(config).toContain('globs:');
expect(config).toContain('alwaysApply: true');
expect(config).toContain('**skill-alpha**');
expect(config).toContain('**skill-beta**');
expect(config).not.toContain('skill-disabled');
});
it('should generate Markdown table config for Codex', () => {
const config = generateSkillsConfig(testSkills, 'codex');
expect(config).toContain('| Skill | Description | Command |');
expect(config).toContain('| skill-alpha |');
expect(config).toContain('| skill-beta |');
expect(config).toContain('First test skill');
expect(config).not.toContain('skill-disabled');
});
it('should generate JSON config for Gemini CLI', () => {
const config = generateSkillsConfig(testSkills, 'gemini-cli');
expect(config).toContain('```json');
expect(config).toContain('"name": "skill-alpha"');
expect(config).toContain('"name": "skill-beta"');
expect(config).toContain('"description": "First test skill"');
expect(config).not.toContain('skill-disabled');
});
it('should generate Markdown config for Windsurf', () => {
const config = generateSkillsConfig(testSkills, 'windsurf');
expect(config).toContain('### skill-alpha');
expect(config).toContain('### skill-beta');
expect(config).toContain('**Invoke:**');
expect(config).toContain('`skillkit read skill-alpha`');
expect(config).not.toContain('skill-disabled');
});
it('should generate XML config for Roo', () => {
const config = generateSkillsConfig(testSkills, 'roo');
expect(config).toContain('<skills_system');
expect(config).toContain('<name>skill-alpha</name>');
});
it('should generate Markdown config for Trae', () => {
const config = generateSkillsConfig(testSkills, 'trae');
expect(config).toContain('### skill-alpha');
expect(config).toContain('### skill-beta');
});
it('should generate Markdown config for GitHub Copilot', () => {
const config = generateSkillsConfig(testSkills, 'github-copilot');
expect(config).toContain('### skill-alpha');
expect(config).toContain('### skill-beta');
});
it('should return empty string when no skills are enabled', () => {
const disabledOnlySkills = [
{ name: 'disabled-1', description: 'Disabled', path: '/d1', location: 'project' as const, enabled: false },
{ name: 'disabled-2', description: 'Also disabled', path: '/d2', location: 'project' as const, enabled: false },
];
const config = generateSkillsConfig(disabledOnlySkills, 'claude-code');
expect(config).toBe('');
});
it('should exclude disabled skills from all agent configs', () => {
for (const agent of SUPPORTED_AGENTS) {
const config = generateSkillsConfig(testSkills, agent);
expect(config).not.toContain('skill-disabled');
}
});
});
});
describe('E2E: Skill Translator - Utility Functions', () => {
describe('getAgentSkillsDir', () => {
it.each(SUPPORTED_AGENTS)('should return valid skills directory for %s', (agent) => {
const dir = getAgentSkillsDir(agent);
expect(typeof dir).toBe('string');
expect(dir.length).toBeGreaterThan(0);
});
it('should return correct paths for major agents', () => {
expect(getAgentSkillsDir('claude-code')).toBe('.claude/skills');
expect(getAgentSkillsDir('cursor')).toBe('.cursor/skills');
expect(getAgentSkillsDir('windsurf')).toBe('.windsurf/skills');
expect(getAgentSkillsDir('github-copilot')).toBe('.github/skills');
expect(getAgentSkillsDir('codex')).toBe('.codex/skills');
});
});
describe('getAgentConfigFile', () => {
it.each(SUPPORTED_AGENTS)('should return valid config file for %s', (agent) => {
const file = getAgentConfigFile(agent);
expect(typeof file).toBe('string');
expect(file.length).toBeGreaterThan(0);
});
it('should return correct config files for major agents', () => {
expect(getAgentConfigFile('claude-code')).toBe('CLAUDE.md');
expect(getAgentConfigFile('cursor')).toBe('.cursor/rules/skills.mdc');
expect(getAgentConfigFile('windsurf')).toBe('.windsurf/rules/skills.md');
expect(getAgentConfigFile('github-copilot')).toBe('.github/copilot-instructions.md');
});
});
describe('AGENT_SKILL_FORMATS', () => {
it('should have configuration for all supported agents', () => {
for (const agent of SUPPORTED_AGENTS) {
expect(AGENT_SKILL_FORMATS[agent]).toBeDefined();
expect(AGENT_SKILL_FORMATS[agent].skillsDir).toBeTruthy();
expect(AGENT_SKILL_FORMATS[agent].configFile).toBeTruthy();
expect(AGENT_SKILL_FORMATS[agent].invokeCommand).toBe('skillkit read');
}
});
it('should have correct config formats for each agent', () => {
expect(AGENT_SKILL_FORMATS['claude-code'].configFormat).toBe('xml');
expect(AGENT_SKILL_FORMATS.cursor.configFormat).toBe('mdc');
expect(AGENT_SKILL_FORMATS.windsurf.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.codex.configFormat).toBe('markdown-table');
expect(AGENT_SKILL_FORMATS['gemini-cli'].configFormat).toBe('json');
expect(AGENT_SKILL_FORMATS['github-copilot'].configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.trae.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.roo.configFormat).toBe('xml');
});
});
});
describe('E2E: Skill Translator - Complete Workflow', () => {
let testDir: string;
beforeEach(() => {
testDir = createTestDir('skillkit-workflow-');
});
afterEach(() => {
cleanupTestDir(testDir);
});
it('should complete full translation workflow from Claude Code to all agents', () => {
// Create a Claude Code skill
const skillDir = join(testDir, 'workflow-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: workflow-skill
description: Complete workflow test skill
version: "1.0.0"
author: E2E Test Suite
tags:
- workflow
- testing
allowed-tools: Read, Write
---
# Workflow Test Skill
This skill tests the complete translation workflow.
## Instructions
1. Parse the SKILL.md file
2. Translate to target agent format
3. Write the translated skill
4. Generate config
## Usage
Use \`skillkit read workflow-skill\` to load this skill.
`);
// Step 1: Parse to canonical format
const canonicalSkill = parseSkillToCanonical(skillDir);
expect(canonicalSkill).not.toBeNull();
expect(canonicalSkill?.name).toBe('workflow-skill');
// Step 2: Translate to all agents
const translations = translateSkillToAll(skillDir, 'claude-code');
expect(translations.size).toBeGreaterThan(0);
// Step 3: Verify translations for key agents
const cursorTranslation = translations.get('cursor');
expect(cursorTranslation?.success).toBe(true);
expect(cursorTranslation?.content).toContain('workflow-skill');
const windsurfTranslation = translations.get('windsurf');
expect(windsurfTranslation?.success).toBe(true);
expect(windsurfTranslation?.content).toContain('workflow-skill');
const copilotTranslation = translations.get('github-copilot');
expect(copilotTranslation?.success).toBe(true);
expect(copilotTranslation?.content).toContain('workflow-skill');
// Step 4: Write a translation to disk
const outputDir = join(testDir, 'output');
mkdirSync(outputDir, { recursive: true });
if (cursorTranslation) {
const writeResult = writeTranslatedSkill(cursorTranslation, outputDir);
expect(writeResult.success).toBe(true);
expect(existsSync(writeResult.path)).toBe(true);
}
// Step 5: Generate config for installed skills
const installedSkills = [
{ name: 'workflow-skill', description: 'Complete workflow test skill', path: skillDir, location: 'project' as const, enabled: true },
];
const claudeConfig = generateSkillsConfig(installedSkills, 'claude-code');
expect(claudeConfig).toContain('<name>workflow-skill</name>');
const cursorConfig = generateSkillsConfig(installedSkills, 'cursor');
expect(cursorConfig).toContain('**workflow-skill**');
});
it('should handle skill with agent-specific features during translation', () => {
// Create a CrossAgentSkill directly with hooks in agentFields
// This is more reliable than parsing from YAML
const skillWithHooks: CrossAgentSkill = {
name: 'agent-specific',
description: 'Skill with agent-specific features',
content: '# Agent Specific Skill\n\nThis skill has Claude Code specific features.',
frontmatter: { name: 'agent-specific', description: 'Skill with agent-specific features' },
sourcePath: join(testDir, 'agent-specific'),
sourceAgent: 'claude-code',
agentFields: {
model: 'opus',
context: 'fork',
hooks: [
{ type: 'PreToolUse', command: 'echo "Before tool use"' },
{ type: 'PostToolUse', command: 'echo "After tool use"' },
],
},
};
// Translate to Claude Code (should preserve features)
const claudeResult = translateSkillToAgent(skillWithHooks, 'claude-code');
expect(claudeResult.success).toBe(true);
expect(claudeResult.incompatible).toHaveLength(0);
// Translate to Cursor (should report incompatible features)
const cursorResult = translateSkillToAgent(skillWithHooks, 'cursor');
expect(cursorResult.success).toBe(true);
// Hooks are not supported in Cursor
expect(cursorResult.incompatible.some(i => i.includes('hooks'))).toBe(true);
});
it('should maintain content integrity across multiple translations', () => {
const originalContent = `## Important Section
This content must be preserved exactly.
\`\`\`typescript
const important = "code";
console.log(important);
\`\`\`
### Subsection
- Bullet point 1
- Bullet point 2
- Bullet point 3
`;
const skillDir = join(testDir, 'content-integrity');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: content-integrity
description: Tests content preservation
---
${originalContent}`);
const canonicalSkill = parseSkillToCanonical(skillDir);
expect(canonicalSkill).not.toBeNull();
// Verify content is preserved in translations
for (const agent of ['cursor', 'windsurf', 'github-copilot', 'codex'] as const) {
const result = translateSkillToAgent(canonicalSkill!, agent);
expect(result.success).toBe(true);
expect(result.content).toContain('## Important Section');
expect(result.content).toContain('const important = "code"');
expect(result.content).toContain('- Bullet point 1');
}
});
});
+7
View File
@@ -1,4 +1,5 @@
import { defineConfig } from 'vitest/config';
import { resolve } from 'node:path';
export default defineConfig({
test: {
@@ -19,4 +20,10 @@ export default defineConfig({
},
},
},
resolve: {
alias: {
'@skillkit/core': resolve(__dirname, '../packages/core/src/index.ts'),
'@skillkit/agents': resolve(__dirname, '../packages/agents/src/index.ts'),
},
},
});
+1 -1
View File
@@ -21,7 +21,7 @@
"test": "vitest run"
},
"dependencies": {
"@skillkit/core": "^1.6.0",
"@skillkit/core": "workspace:*",
"minimatch": "^9.0.0"
},
"devDependencies": {
@@ -33,7 +33,7 @@ describe('ClawdbotAdapter', () => {
});
it('should have correct skillsDir', () => {
expect(adapter.skillsDir).toBe('skills');
expect(adapter.skillsDir).toBe('.clawdbot/skills');
});
it('should have correct configFile', () => {
+8 -5
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.amp;
export class AmpAdapter implements AgentAdapter {
readonly type: AgentType = 'amp';
readonly name = 'Amp';
readonly skillsDir = '.agents/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -66,9 +69,9 @@ ${skillsXml}
}
async isDetected(): Promise<boolean> {
const projectAgents = join(process.cwd(), '.agents');
const globalAgents = join(homedir(), '.config', 'agents');
const projectAmp = join(process.cwd(), '.amp');
const globalAmp = join(homedir(), '.amp');
return existsSync(projectAgents) || existsSync(globalAgents);
return existsSync(projectAmp) || existsSync(globalAmp);
}
}
+5 -2
View File
@@ -3,12 +3,15 @@ import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.antigravity;
export class AntigravityAdapter implements AgentAdapter {
readonly type: AgentType = 'antigravity';
readonly name = 'Antigravity';
readonly skillsDir = '.antigravity/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+5 -2
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['claude-code'];
export class ClaudeCodeAdapter implements AgentAdapter {
readonly type: AgentType = 'claude-code';
readonly name = 'Claude Code';
readonly skillsDir = '.claude/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+5 -2
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.clawdbot;
export class ClawdbotAdapter implements AgentAdapter {
readonly type: AgentType = 'clawdbot';
readonly name = 'Clawdbot';
readonly skillsDir = 'skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+5 -2
View File
@@ -3,12 +3,15 @@ import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.codex;
export class CodexAdapter implements AgentAdapter {
readonly type: AgentType = 'codex';
readonly name = 'OpenAI Codex CLI';
readonly skillsDir = '.codex/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+19 -5
View File
@@ -1,14 +1,18 @@
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.cursor;
export class CursorAdapter implements AgentAdapter {
readonly type: AgentType = 'cursor';
readonly name = 'Cursor';
readonly skillsDir = '.cursor/skills';
readonly configFile = '.cursorrules';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -23,7 +27,12 @@ export class CursorAdapter implements AgentAdapter {
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
return `# Skills System
return `---
description: SkillKit skills integration - provides specialized capabilities and domain knowledge
globs: "**/*"
alwaysApply: true
---
# Skills System
You have access to specialized skills that can help complete tasks. Use the skillkit CLI to load skill instructions when needed.
@@ -63,9 +72,14 @@ ${skillsXml}
}
async isDetected(): Promise<boolean> {
const cursorRules = join(process.cwd(), '.cursorrules');
const cursorDir = join(process.cwd(), '.cursor');
const cursorRulesDir = join(process.cwd(), '.cursor', 'rules');
// Legacy .cursorrules file (deprecated but still supported)
const cursorRulesFile = join(process.cwd(), '.cursorrules');
// Global Cursor config
const globalCursor = join(homedir(), '.cursor');
return existsSync(cursorRules) || existsSync(cursorDir);
return existsSync(cursorDir) || existsSync(cursorRulesDir) ||
existsSync(cursorRulesFile) || existsSync(globalCursor);
}
}
+5 -2
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.droid;
export class DroidAdapter implements AgentAdapter {
readonly type: AgentType = 'droid';
readonly name = 'Droid (Factory)';
readonly skillsDir = '.factory/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+6 -3
View File
@@ -3,12 +3,15 @@ import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['gemini-cli'];
export class GeminiCliAdapter implements AgentAdapter {
readonly type: AgentType = 'gemini-cli';
readonly name = 'Gemini CLI';
readonly skillsDir = '.gemini/skills';
readonly configFile = 'GEMINI.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -64,7 +67,7 @@ ${JSON.stringify(skillsJson, null, 2)}
}
if (skillNames.length === 0) {
const headerRegex = /^### ([a-z0-9-]+)$/gm;
const headerRegex = /^###\s+(.+?)\s*$/gm;
let match;
while ((match = headerRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
+27 -28
View File
@@ -2,14 +2,16 @@ import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['github-copilot'];
export class GitHubCopilotAdapter implements AgentAdapter {
readonly type: AgentType = 'github-copilot';
readonly name = 'GitHub Copilot';
readonly skillsDir = '.github/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -18,43 +20,38 @@ export class GitHubCopilotAdapter implements AgentAdapter {
return '';
}
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
const skillsList = enabledSkills
.map(s => `### ${s.name}\n\n${s.description}\n\n**Invoke:** \`skillkit read ${s.name}\``)
.join('\n\n');
return `<skills_system priority="1">
return `# Skills System
You have access to specialized skills that can help complete tasks.
Skills provide domain-specific knowledge and step-by-step instructions.
## Available Skills
<!-- SKILLS_TABLE_START -->
<usage>
When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
${skillsList}
How to use skills:
- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
- The skill content will load with detailed instructions on how to complete the task
- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
## How to Use Skills
Usage notes:
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already loaded in your context
- Each skill invocation is stateless
</usage>
When a task matches a skill's description, load it using the terminal:
<available_skills>
\`\`\`bash
skillkit read <skill-name>
\`\`\`
${skillsXml}
</available_skills>
<!-- SKILLS_TABLE_END -->
</skills_system>`;
The skill content will load with detailed instructions.
Each skill is self-contained with its own resources.
`;
}
parseConfig(content: string): string[] {
const skillNames: string[] = [];
const skillRegex = /<name>([^<]+)<\/name>/g;
const headerRegex = /^###\s+(.+?)\s*$/gm;
let match;
while ((match = skillRegex.exec(content)) !== null) {
while ((match = headerRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
}
@@ -66,9 +63,11 @@ ${skillsXml}
}
async isDetected(): Promise<boolean> {
const projectGithub = join(process.cwd(), '.github', 'skills');
const copilotInstructions = join(process.cwd(), '.github', 'copilot-instructions.md');
const githubInstructions = join(process.cwd(), '.github', 'instructions');
const globalCopilot = join(homedir(), '.copilot');
return existsSync(projectGithub) || existsSync(globalCopilot);
return existsSync(copilotInstructions) ||
existsSync(githubInstructions) || existsSync(globalCopilot);
}
}
+5 -2
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.goose;
export class GooseAdapter implements AgentAdapter {
readonly type: AgentType = 'goose';
readonly name = 'Goose';
readonly skillsDir = '.goose/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+2 -7
View File
@@ -99,10 +99,5 @@ export async function detectAgent(): Promise<AgentType> {
return 'universal';
}
export function getSkillsDir(type: AgentType): string {
return adapters[type].skillsDir;
}
export function getConfigFile(type: AgentType): string {
return adapters[type].configFile;
}
// getSkillsDir and getConfigFile are now re-exported from @skillkit/core above
// This ensures a single source of truth for agent configurations
+7 -3
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.kilo;
export class KiloAdapter implements AgentAdapter {
readonly type: AgentType = 'kilo';
readonly name = 'Kilo Code';
readonly skillsDir = '.kilocode/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -68,7 +71,8 @@ ${skillsXml}
async isDetected(): Promise<boolean> {
const projectKilo = join(process.cwd(), '.kilocode');
const globalKilo = join(homedir(), '.kilocode');
const kiloModes = join(process.cwd(), '.kilocode', 'modes');
return existsSync(projectKilo) || existsSync(globalKilo);
return existsSync(projectKilo) || existsSync(globalKilo) || existsSync(kiloModes);
}
}
+5 -2
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG['kiro-cli'];
export class KiroCliAdapter implements AgentAdapter {
readonly type: AgentType = 'kiro-cli';
readonly name = 'Kiro CLI';
readonly skillsDir = '.kiro/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+9 -4
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.opencode;
export class OpenCodeAdapter implements AgentAdapter {
readonly type: AgentType = 'opencode';
readonly name = 'OpenCode';
readonly skillsDir = '.opencode/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -60,8 +63,10 @@ This loads the skill's instructions into context.
async isDetected(): Promise<boolean> {
const opencodeDir = join(process.cwd(), '.opencode');
const globalOpencode = join(homedir(), '.opencode');
const globalOpencode = join(homedir(), '.config', 'opencode');
const opencodeJson = join(process.cwd(), 'opencode.json');
return existsSync(opencodeDir) || existsSync(globalOpencode);
return existsSync(opencodeDir) || existsSync(globalOpencode) ||
existsSync(opencodeJson);
}
}
+7 -3
View File
@@ -4,12 +4,15 @@ import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.roo;
export class RooAdapter implements AgentAdapter {
readonly type: AgentType = 'roo';
readonly name = 'Roo Code';
readonly skillsDir = '.roo/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -68,7 +71,8 @@ ${skillsXml}
async isDetected(): Promise<boolean> {
const projectRoo = join(process.cwd(), '.roo');
const globalRoo = join(homedir(), '.roo');
const rooModes = join(process.cwd(), '.roo', 'modes');
return existsSync(projectRoo) || existsSync(globalRoo);
return existsSync(projectRoo) || existsSync(globalRoo) || existsSync(rooModes);
}
}
+29 -27
View File
@@ -2,14 +2,16 @@ import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.trae;
export class TraeAdapter implements AgentAdapter {
readonly type: AgentType = 'trae';
readonly name = 'Trae';
readonly skillsDir = '.trae/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -18,43 +20,42 @@ export class TraeAdapter implements AgentAdapter {
return '';
}
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
const skillsList = enabledSkills
.map(s => `### ${s.name}\n\n${s.description}\n\n**Invoke:** \`skillkit read ${s.name}\``)
.join('\n\n');
return `<skills_system priority="1">
return `---
alwaysApply: true
description: SkillKit skills integration for Trae
globs: ["**/*"]
---
# Skills System
You have access to specialized skills that can help complete tasks.
When a task matches a skill's description, load it using the skillkit CLI.
## Available Skills
<!-- SKILLS_TABLE_START -->
<usage>
When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
${skillsList}
How to use skills:
- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
- The skill content will load with detailed instructions on how to complete the task
- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
## How to Use Skills
Usage notes:
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already loaded in your context
- Each skill invocation is stateless
</usage>
When a task matches a skill's description, load it:
<available_skills>
\`\`\`bash
skillkit read <skill-name>
\`\`\`
${skillsXml}
</available_skills>
<!-- SKILLS_TABLE_END -->
</skills_system>`;
Skills provide detailed instructions for completing complex tasks.
`;
}
parseConfig(content: string): string[] {
const skillNames: string[] = [];
const skillRegex = /<name>([^<]+)<\/name>/g;
const headerRegex = /^###\s+(.+?)\s*$/gm;
let match;
while ((match = skillRegex.exec(content)) !== null) {
while ((match = headerRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
}
@@ -67,8 +68,9 @@ ${skillsXml}
async isDetected(): Promise<boolean> {
const projectTrae = join(process.cwd(), '.trae');
const traeRulesDir = join(process.cwd(), '.trae', 'rules');
const globalTrae = join(homedir(), '.trae');
return existsSync(projectTrae) || existsSync(globalTrae);
return existsSync(projectTrae) || existsSync(traeRulesDir) || existsSync(globalTrae);
}
}
+5 -2
View File
@@ -3,12 +3,15 @@ import { join } from 'node:path';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.universal;
export class UniversalAdapter implements AgentAdapter {
readonly type: AgentType = 'universal';
readonly name = 'Universal (Any Agent)';
readonly skillsDir = '.agent/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
+30 -27
View File
@@ -2,14 +2,16 @@ import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import type { AgentAdapter } from './base.js';
import { createSkillXml } from './base.js';
import type { Skill, AgentType } from '@skillkit/core';
import { AGENT_CONFIG } from '@skillkit/core';
const config = AGENT_CONFIG.windsurf;
export class WindsurfAdapter implements AgentAdapter {
readonly type: AgentType = 'windsurf';
readonly name = 'Windsurf';
readonly skillsDir = '.windsurf/skills';
readonly configFile = 'AGENTS.md';
readonly skillsDir = config.skillsDir;
readonly configFile = config.configFile;
generateConfig(skills: Skill[]): string {
const enabledSkills = skills.filter(s => s.enabled);
@@ -18,43 +20,42 @@ export class WindsurfAdapter implements AgentAdapter {
return '';
}
const skillsXml = enabledSkills.map(createSkillXml).join('\n\n');
const skillsList = enabledSkills
.map(s => `### ${s.name}\n\n${s.description}\n\n**Invoke:** \`skillkit read ${s.name}\``)
.join('\n\n');
return `<skills_system priority="1">
return `---
name: "skillkit-skills"
mode: "model-decision"
---
# Skills System
You have access to specialized skills that can help complete tasks.
When a task matches a skill's description, load it using the skillkit CLI.
## Available Skills
<!-- SKILLS_TABLE_START -->
<usage>
When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
${skillsList}
How to use skills:
- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
- The skill content will load with detailed instructions on how to complete the task
- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
## How to Use Skills
Usage notes:
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already loaded in your context
- Each skill invocation is stateless
</usage>
When a task matches a skill's description, load it:
<available_skills>
\`\`\`bash
skillkit read <skill-name>
\`\`\`
${skillsXml}
</available_skills>
<!-- SKILLS_TABLE_END -->
</skills_system>`;
Skills provide detailed instructions for completing complex tasks.
Each skill is self-contained with its own resources.
`;
}
parseConfig(content: string): string[] {
const skillNames: string[] = [];
const skillRegex = /<name>([^<]+)<\/name>/g;
const headerRegex = /^###\s+(.+?)\s*$/gm;
let match;
while ((match = skillRegex.exec(content)) !== null) {
while ((match = headerRegex.exec(content)) !== null) {
skillNames.push(match[1].trim());
}
@@ -67,8 +68,10 @@ ${skillsXml}
async isDetected(): Promise<boolean> {
const projectWindsurf = join(process.cwd(), '.windsurf');
const projectRulesDir = join(process.cwd(), '.windsurf', 'rules');
const globalWindsurf = join(homedir(), '.codeium', 'windsurf');
return existsSync(projectWindsurf) || existsSync(globalWindsurf);
return existsSync(projectWindsurf) || existsSync(projectRulesDir) ||
existsSync(globalWindsurf);
}
}
@@ -0,0 +1,432 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import {
AGENT_SKILL_FORMATS,
parseSkillToCanonical,
parseSkillContentToCanonical,
translateSkillToAgent,
translateSkillToAll,
writeTranslatedSkill,
generateSkillsConfig,
getAgentSkillsDir,
getAgentConfigFile,
supportsAutoDiscovery,
getAllSkillsDirs,
getGlobalSkillsDir,
type CrossAgentSkill,
type SkillTranslationOptions,
} from '../skill-translator.js';
describe('Skill Translator', () => {
let tempDir: string;
beforeEach(() => {
tempDir = join(tmpdir(), `skillkit-test-${Date.now()}`);
mkdirSync(tempDir, { recursive: true });
});
afterEach(() => {
if (existsSync(tempDir)) {
rmSync(tempDir, { recursive: true, force: true });
}
});
describe('AGENT_SKILL_FORMATS', () => {
it('should have configurations for all supported agents', () => {
const expectedAgents = [
'claude-code', 'cursor', 'codex', 'gemini-cli', 'opencode',
'antigravity', 'amp', 'clawdbot', 'droid', 'github-copilot',
'goose', 'kilo', 'kiro-cli', 'roo', 'trae', 'windsurf', 'universal',
];
for (const agent of expectedAgents) {
expect(AGENT_SKILL_FORMATS[agent as keyof typeof AGENT_SKILL_FORMATS]).toBeDefined();
}
});
it('should have valid skillsDir for each agent', () => {
for (const [agent, format] of Object.entries(AGENT_SKILL_FORMATS)) {
expect(format.skillsDir).toBeTruthy();
expect(typeof format.skillsDir).toBe('string');
}
});
it('should have valid configFile for each agent', () => {
for (const [agent, format] of Object.entries(AGENT_SKILL_FORMATS)) {
expect(format.configFile).toBeTruthy();
expect(typeof format.configFile).toBe('string');
}
});
it('should have correct Cursor MDC format', () => {
const cursor = AGENT_SKILL_FORMATS.cursor;
expect(cursor.skillsDir).toBe('.cursor/skills');
expect(cursor.configFile).toBe('.cursor/rules/skills.mdc');
expect(cursor.configFormat).toBe('mdc');
});
it('should have correct Windsurf format', () => {
const windsurf = AGENT_SKILL_FORMATS.windsurf;
expect(windsurf.skillsDir).toBe('.windsurf/skills');
expect(windsurf.configFile).toBe('.windsurf/rules/skills.md');
expect(windsurf.configFormat).toBe('markdown');
expect(windsurf.globalSkillsDir).toBe('~/.codeium/windsurf/skills');
});
it('should have correct GitHub Copilot format', () => {
const copilot = AGENT_SKILL_FORMATS['github-copilot'];
expect(copilot.skillsDir).toBe('.github/skills');
expect(copilot.configFile).toBe('.github/copilot-instructions.md');
expect(copilot.configFormat).toBe('markdown');
});
});
describe('parseSkillToCanonical', () => {
it('should parse a valid SKILL.md file', () => {
const skillDir = join(tempDir, 'test-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: test-skill
description: A test skill for unit testing
version: "1.0.0"
author: Test Author
tags:
- testing
- unit-test
---
# Test Skill
This is a test skill for unit testing purposes.
## Usage
Use this skill when you need to test something.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
expect(result?.name).toBe('test-skill');
expect(result?.description).toBe('A test skill for unit testing');
expect(result?.version).toBe('1.0.0');
expect(result?.author).toBe('Test Author');
expect(result?.tags).toEqual(['testing', 'unit-test']);
expect(result?.content).toContain('# Test Skill');
});
it('should return null for non-existent skill', () => {
const result = parseSkillToCanonical(join(tempDir, 'non-existent'));
expect(result).toBeNull();
});
it('should handle SKILL.md without frontmatter', () => {
const skillDir = join(tempDir, 'no-frontmatter-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `# Simple Skill
Just some content without frontmatter.
`);
const result = parseSkillToCanonical(skillDir);
expect(result).not.toBeNull();
// Without frontmatter, name is derived from directory name
expect(result?.name).toBe('no-frontmatter-skill');
});
it('should extract allowed-tools from frontmatter', () => {
const skillDir = join(tempDir, 'tools-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: tools-skill
description: Skill with allowed tools
allowed-tools: Read, Write, Bash
---
Content here.
`);
const result = parseSkillToCanonical(skillDir);
expect(result?.allowedTools).toEqual(['Read', 'Write', 'Bash']);
});
});
describe('parseSkillContentToCanonical', () => {
it('should parse skill content with full frontmatter', () => {
const content = `---
name: content-skill
description: Parsed from content
model: opus
context: fork
disable-model-invocation: true
---
# Content Skill
Instructions here.
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill', 'claude-code');
expect(result?.name).toBe('content-skill');
expect(result?.description).toBe('Parsed from content');
expect(result?.agentFields?.['model']).toBe('opus');
expect(result?.agentFields?.['context']).toBe('fork');
expect(result?.agentFields?.['disable-model-invocation']).toBe(true);
expect(result?.sourceAgent).toBe('claude-code');
});
it('should extract description from content when not in frontmatter', () => {
const content = `---
name: no-desc
---
This is a longer paragraph that should be used as the description when none is provided in frontmatter.
## More Content
`;
const result = parseSkillContentToCanonical(content, '/path/to/skill');
expect(result?.description).toContain('This is a longer paragraph');
});
});
describe('translateSkillToAgent', () => {
const testSkill: CrossAgentSkill = {
name: 'translate-test',
description: 'A skill to test translation',
content: '# Translate Test\n\nTest content for translation.',
frontmatter: { name: 'translate-test', description: 'A skill to test translation' },
sourcePath: '/test/path',
sourceAgent: 'claude-code',
version: '1.0.0',
author: 'Test',
tags: ['test'],
};
it('should translate to Claude Code format', () => {
const result = translateSkillToAgent(testSkill, 'claude-code');
expect(result.success).toBe(true);
expect(result.content).toContain('name: translate-test');
expect(result.content).toContain('description: A skill to test translation');
expect(result.targetAgent).toBe('claude-code');
});
it('should translate to Cursor format', () => {
const result = translateSkillToAgent(testSkill, 'cursor');
expect(result.success).toBe(true);
expect(result.content).toContain('name: translate-test');
expect(result.targetAgent).toBe('cursor');
});
it('should translate to Windsurf format', () => {
const result = translateSkillToAgent(testSkill, 'windsurf');
expect(result.success).toBe(true);
expect(result.targetAgent).toBe('windsurf');
});
it('should include translation metadata when requested', () => {
const options: SkillTranslationOptions = { addMetadata: true };
const result = translateSkillToAgent(testSkill, 'cursor', options);
expect(result.content).toContain('_translated-from: claude-code');
expect(result.content).toContain('_translated-at:');
});
it('should preserve agent-specific fields for Claude Code', () => {
const skillWithFields: CrossAgentSkill = {
...testSkill,
agentFields: {
model: 'opus',
context: 'fork',
'disable-model-invocation': true,
},
};
const result = translateSkillToAgent(skillWithFields, 'claude-code');
expect(result.content).toContain('model: opus');
expect(result.content).toContain('context: fork');
expect(result.content).toContain('disable-model-invocation: true');
});
it('should report incompatible features', () => {
const skillWithHooks: CrossAgentSkill = {
...testSkill,
agentFields: {
hooks: [{ type: 'PreToolUse', command: 'echo test' }],
},
};
const result = translateSkillToAgent(skillWithHooks, 'cursor');
expect(result.incompatible).toContain('hooks (only supported in Claude Code)');
});
});
describe('translateSkillToAll', () => {
it('should translate skill to all supported agents', () => {
const skillDir = join(tempDir, 'all-agents-skill');
mkdirSync(skillDir, { recursive: true });
writeFileSync(join(skillDir, 'SKILL.md'), `---
name: all-agents
description: Skill for all agents
---
# All Agents Skill
`);
const results = translateSkillToAll(skillDir, 'claude-code');
expect(results.size).toBeGreaterThan(0);
// Should not include source agent
expect(results.has('claude-code')).toBe(false);
// Should include other agents
expect(results.has('cursor')).toBe(true);
expect(results.has('windsurf')).toBe(true);
});
it('should return empty map for non-existent skill', () => {
const results = translateSkillToAll(join(tempDir, 'non-existent'));
expect(results.size).toBe(0);
});
});
describe('writeTranslatedSkill', () => {
it('should write translated skill to disk', () => {
const result = {
success: true,
content: '---\nname: written-skill\n---\n# Content',
filename: 'SKILL.md',
targetDir: 'test-skill',
warnings: [],
incompatible: [],
targetAgent: 'claude-code' as const,
};
const writeResult = writeTranslatedSkill(result, tempDir);
expect(writeResult.success).toBe(true);
expect(existsSync(writeResult.path)).toBe(true);
});
it('should create nested directories', () => {
const result = {
success: true,
content: '---\nname: nested\n---\n# Content',
filename: 'SKILL.md',
targetDir: '.cursor/skills/nested-skill',
warnings: [],
incompatible: [],
targetAgent: 'cursor' as const,
};
const writeResult = writeTranslatedSkill(result, tempDir);
expect(writeResult.success).toBe(true);
expect(existsSync(join(tempDir, '.cursor/skills/nested-skill/SKILL.md'))).toBe(true);
});
});
describe('generateSkillsConfig', () => {
const testSkills = [
{ name: 'skill-one', description: 'First skill', path: '/path/one', location: 'project' as const, enabled: true },
{ name: 'skill-two', description: 'Second skill', path: '/path/two', location: 'project' as const, enabled: true },
{ name: 'disabled-skill', description: 'Disabled', path: '/path/disabled', location: 'project' as const, enabled: false },
];
it('should generate XML config for Claude Code', () => {
const config = generateSkillsConfig(testSkills, 'claude-code');
expect(config).toContain('<skills_system');
expect(config).toContain('<name>skill-one</name>');
expect(config).toContain('<name>skill-two</name>');
expect(config).not.toContain('disabled-skill');
});
it('should generate MDC config for Cursor', () => {
const config = generateSkillsConfig(testSkills, 'cursor');
expect(config).toContain('---');
expect(config).toContain('description:');
expect(config).toContain('globs:');
expect(config).toContain('alwaysApply: true');
expect(config).toContain('**skill-one**');
expect(config).toContain('**skill-two**');
});
it('should generate Markdown table config for Codex', () => {
const config = generateSkillsConfig(testSkills, 'codex');
expect(config).toContain('| Skill | Description | Command |');
expect(config).toContain('| skill-one |');
expect(config).toContain('| skill-two |');
});
it('should generate JSON config for Gemini CLI', () => {
const config = generateSkillsConfig(testSkills, 'gemini-cli');
expect(config).toContain('```json');
expect(config).toContain('"name": "skill-one"');
expect(config).toContain('"name": "skill-two"');
});
it('should generate Markdown config for Windsurf', () => {
const config = generateSkillsConfig(testSkills, 'windsurf');
expect(config).toContain('### skill-one');
expect(config).toContain('### skill-two');
expect(config).toContain('**Invoke:**');
});
it('should return empty string for no enabled skills', () => {
const disabledSkills = [
{ name: 'disabled', description: 'Disabled', path: '/path', location: 'project' as const, enabled: false },
];
const config = generateSkillsConfig(disabledSkills, 'claude-code');
expect(config).toBe('');
});
});
describe('utility functions', () => {
it('getAgentSkillsDir should return correct path', () => {
expect(getAgentSkillsDir('claude-code')).toBe('.claude/skills');
expect(getAgentSkillsDir('cursor')).toBe('.cursor/skills');
expect(getAgentSkillsDir('windsurf')).toBe('.windsurf/skills');
});
it('getAgentConfigFile should return correct path', () => {
expect(getAgentConfigFile('claude-code')).toBe('CLAUDE.md');
expect(getAgentConfigFile('cursor')).toBe('.cursor/rules/skills.mdc');
expect(getAgentConfigFile('github-copilot')).toBe('.github/copilot-instructions.md');
});
it('supportsAutoDiscovery should return true for all major agents', () => {
expect(supportsAutoDiscovery('claude-code')).toBe(true);
expect(supportsAutoDiscovery('cursor')).toBe(true);
expect(supportsAutoDiscovery('windsurf')).toBe(true);
});
it('getAllSkillsDirs should include alternative directories', () => {
const cursorDirs = getAllSkillsDirs('cursor');
expect(cursorDirs).toContain('.cursor/skills');
expect(cursorDirs).toContain('.cursor/commands');
const windsurfDirs = getAllSkillsDirs('windsurf');
expect(windsurfDirs).toContain('.windsurf/skills');
expect(windsurfDirs).toContain('.windsurf/workflows');
});
it('getGlobalSkillsDir should return correct global path', () => {
expect(getGlobalSkillsDir('claude-code')).toBe('~/.claude/skills');
expect(getGlobalSkillsDir('windsurf')).toBe('~/.codeium/windsurf/skills');
expect(getGlobalSkillsDir('opencode')).toBe('~/.config/opencode/skills');
expect(getGlobalSkillsDir('roo')).toBe('~/.roo/skills');
});
});
});
describe('Agent Adapter Integration', () => {
it('should have matching config formats between AGENT_SKILL_FORMATS and expected values', () => {
// Verify that the 2026 updates are consistent
expect(AGENT_SKILL_FORMATS.cursor.configFormat).toBe('mdc');
expect(AGENT_SKILL_FORMATS.windsurf.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS['github-copilot'].configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS.trae.configFormat).toBe('markdown');
expect(AGENT_SKILL_FORMATS['claude-code'].configFormat).toBe('xml');
expect(AGENT_SKILL_FORMATS.codex.configFormat).toBe('markdown-table');
expect(AGENT_SKILL_FORMATS['gemini-cli'].configFormat).toBe('json');
});
it('should have valid invoke commands', () => {
for (const format of Object.values(AGENT_SKILL_FORMATS)) {
expect(format.invokeCommand).toBe('skillkit read');
}
});
});
+269
View File
@@ -0,0 +1,269 @@
/**
* Centralized Agent Configuration
*
* Single source of truth for all AI coding agent configurations.
* All modules should import from here instead of defining their own values.
*/
import type { AgentType } from './types.js';
/**
* Agent configuration for skills and config files
*/
export interface AgentDirectoryConfig {
/** Primary skills directory path */
skillsDir: string;
/** Config file that references skills */
configFile: string;
/** Alternative skills directories */
altSkillsDirs?: string[];
/** Global skills directory */
globalSkillsDir?: string;
/** Config format: xml, markdown, mdc, json, markdown-table */
configFormat: 'xml' | 'markdown' | 'mdc' | 'json' | 'markdown-table';
/** Whether agent uses YAML frontmatter in SKILL.md */
usesFrontmatter: boolean;
/** Agent-specific frontmatter fields */
frontmatterFields?: string[];
/** Whether agent supports skill auto-discovery */
supportsAutoDiscovery: boolean;
}
/**
* Centralized agent configurations
*
* This is the ONLY source of truth for agent paths and formats.
* Do not define these values elsewhere.
*/
export const AGENT_CONFIG: Record<AgentType, AgentDirectoryConfig> = {
// Claude Code - all Claude products use the same format
'claude-code': {
skillsDir: '.claude/skills',
configFile: 'CLAUDE.md',
globalSkillsDir: '~/.claude/skills',
configFormat: 'xml',
usesFrontmatter: true,
frontmatterFields: [
'name', 'description', 'allowed-tools', 'model', 'context',
'agent', 'disable-model-invocation', 'user-invocable', 'argument-hint',
],
supportsAutoDiscovery: true,
},
// Cursor - uses MDC format in .cursor/rules/
cursor: {
skillsDir: '.cursor/skills',
configFile: '.cursor/rules/skills.mdc',
altSkillsDirs: ['.cursor/commands'],
globalSkillsDir: '~/.cursor/skills',
configFormat: 'mdc',
usesFrontmatter: true,
frontmatterFields: ['description', 'globs', 'alwaysApply'],
supportsAutoDiscovery: true,
},
// Codex (OpenAI)
codex: {
skillsDir: '.codex/skills',
configFile: 'AGENTS.md',
globalSkillsDir: '~/.codex/skills',
configFormat: 'markdown-table',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Gemini CLI
'gemini-cli': {
skillsDir: '.gemini/skills',
configFile: 'GEMINI.md',
globalSkillsDir: '~/.gemini/skills',
configFormat: 'json',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// OpenCode
opencode: {
skillsDir: '.opencode/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.opencode/agent'],
globalSkillsDir: '~/.config/opencode/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Antigravity
antigravity: {
skillsDir: '.antigravity/skills',
configFile: 'AGENTS.md',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Amp - uses .amp/ directory
amp: {
skillsDir: '.amp/skills',
configFile: 'AGENTS.md',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Clawdbot
clawdbot: {
skillsDir: '.clawdbot/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['skills'],
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Droid (Factory)
droid: {
skillsDir: '.factory/skills',
configFile: 'AGENTS.md',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// GitHub Copilot
'github-copilot': {
skillsDir: '.github/skills',
configFile: '.github/copilot-instructions.md',
altSkillsDirs: ['.github/instructions'],
configFormat: 'markdown',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Goose
goose: {
skillsDir: '.goose/skills',
configFile: 'AGENTS.md',
globalSkillsDir: '~/.goose/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Kilo
kilo: {
skillsDir: '.kilocode/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.kilocode/modes'],
globalSkillsDir: '~/.kilocode/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Kiro CLI
'kiro-cli': {
skillsDir: '.kiro/skills',
configFile: 'AGENTS.md',
globalSkillsDir: '~/.kiro/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Roo Code
roo: {
skillsDir: '.roo/skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.roo/modes'],
globalSkillsDir: '~/.roo/skills',
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Trae
trae: {
skillsDir: '.trae/skills',
configFile: '.trae/rules/project_rules.md',
altSkillsDirs: ['.trae/agent'],
configFormat: 'markdown',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Windsurf
windsurf: {
skillsDir: '.windsurf/skills',
configFile: '.windsurf/rules/skills.md',
altSkillsDirs: ['.windsurf/workflows'],
globalSkillsDir: '~/.codeium/windsurf/skills',
configFormat: 'markdown',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
// Universal - works with any agent
universal: {
skillsDir: 'skills',
configFile: 'AGENTS.md',
altSkillsDirs: ['.agent/skills', '.agents/skills'],
configFormat: 'xml',
usesFrontmatter: true,
supportsAutoDiscovery: true,
},
};
/**
* Get agent configuration
*/
export function getAgentDirectoryConfig(agent: AgentType): AgentDirectoryConfig {
return AGENT_CONFIG[agent];
}
/**
* Get skills directory for an agent
*/
export function getSkillsDir(agent: AgentType): string {
return AGENT_CONFIG[agent].skillsDir;
}
/**
* Get config file for an agent
*/
export function getConfigFile(agent: AgentType): string {
return AGENT_CONFIG[agent].configFile;
}
/**
* Get all skills directories for an agent (including alternatives)
*/
export function getAllSkillsDirs(agent: AgentType): string[] {
const config = AGENT_CONFIG[agent];
const dirs = [config.skillsDir];
if (config.altSkillsDirs) {
dirs.push(...config.altSkillsDirs);
}
return dirs;
}
/**
* Get global skills directory for an agent
*/
export function getGlobalSkillsDir(agent: AgentType): string | undefined {
return AGENT_CONFIG[agent].globalSkillsDir;
}
/**
* Check if agent supports auto-discovery
*/
export function supportsAutoDiscovery(agent: AgentType): boolean {
return AGENT_CONFIG[agent].supportsAutoDiscovery;
}
/**
* Get config format for an agent
*/
export function getConfigFormat(agent: AgentType): AgentDirectoryConfig['configFormat'] {
return AGENT_CONFIG[agent].configFormat;
}
+17 -10
View File
@@ -211,51 +211,58 @@ export interface AgentTranslationOptions {
}
/**
* Agent discovery paths per AI coding agent
* Agent discovery paths per AI coding agent (2026 updated)
*/
export const AGENT_DISCOVERY_PATHS: Record<AgentType, string[]> = {
'claude-code': ['.claude/agents'],
'cursor': ['.cursor/agents'],
'cursor': ['.cursor/agents', '.cursor/commands'],
'codex': ['.codex/agents'],
'gemini-cli': ['.gemini/agents'],
'opencode': ['.opencode/agents'],
'opencode': ['.opencode/agents', '.opencode/agent'],
'antigravity': ['.antigravity/agents'],
'amp': ['.amp/agents'],
'clawdbot': ['.clawdbot/agents', 'agents'],
'droid': ['.factory/agents'],
'github-copilot': ['.github/agents', '.github/copilot/agents'],
'github-copilot': ['.github/agents', '.github/instructions', '.github/custom-agents'],
'goose': ['.goose/agents'],
'kilo': ['.kilocode/agents'],
'kilo': ['.kilocode/agents', '.kilocode/modes'],
'kiro-cli': ['.kiro/agents'],
'roo': ['.roo/agents'],
'trae': ['.trae/agents'],
'windsurf': ['.windsurf/agents'],
'roo': ['.roo/agents', '.roo/modes'],
'trae': ['.trae/agents', '.trae/agent'],
'windsurf': ['.windsurf/agents', '.windsurf/workflows'],
'universal': ['agents', '.agents'],
};
/**
* All agent discovery paths (union of all agent paths)
* All agent discovery paths (union of all agent paths) - 2026 updated
*/
export const ALL_AGENT_DISCOVERY_PATHS = [
'agents',
'.agents',
'.claude/agents',
'.cursor/agents',
'.cursor/commands',
'.codex/agents',
'.gemini/agents',
'.opencode/agents',
'.opencode/agent',
'.antigravity/agents',
'.amp/agents',
'.clawdbot/agents',
'.factory/agents',
'.github/agents',
'.github/copilot/agents',
'.github/instructions',
'.github/custom-agents',
'.goose/agents',
'.kilocode/agents',
'.kilocode/modes',
'.kiro/agents',
'.roo/agents',
'.roo/modes',
'.trae/agents',
'.trae/agent',
'.windsurf/agents',
'.windsurf/workflows',
];
/**
+6 -28
View File
@@ -5,6 +5,7 @@ import type { ContextSyncOptions } from './types.js';
import { ContextManager } from './manager.js';
import { translateSkillFile } from '../translator/index.js';
import { findAllSkills } from '../skills.js';
import { AGENT_CONFIG } from '../agent-config.js';
/**
* Result of a sync operation
@@ -29,29 +30,6 @@ export interface SyncReport {
results: SyncResult[];
}
/**
* Agent directory configuration
*/
const AGENT_DIRS: Record<AgentType, { skillsDir: string; configFile: string }> = {
'claude-code': { skillsDir: '.claude/skills', configFile: 'AGENTS.md' },
'cursor': { skillsDir: '.cursor/skills', configFile: '.cursorrules' },
'codex': { skillsDir: '.codex/skills', configFile: 'AGENTS.md' },
'gemini-cli': { skillsDir: '.gemini/skills', configFile: 'GEMINI.md' },
'opencode': { skillsDir: '.opencode/skills', configFile: 'AGENTS.md' },
'antigravity': { skillsDir: '.antigravity/skills', configFile: 'AGENTS.md' },
'amp': { skillsDir: '.agents/skills', configFile: 'AGENTS.md' },
'clawdbot': { skillsDir: 'skills', configFile: 'AGENTS.md' },
'droid': { skillsDir: '.factory/skills', configFile: 'AGENTS.md' },
'github-copilot': { skillsDir: '.github/skills', configFile: 'AGENTS.md' },
'goose': { skillsDir: '.goose/skills', configFile: 'AGENTS.md' },
'kilo': { skillsDir: '.kilocode/skills', configFile: 'AGENTS.md' },
'kiro-cli': { skillsDir: '.kiro/skills', configFile: 'AGENTS.md' },
'roo': { skillsDir: '.roo/skills', configFile: 'AGENTS.md' },
'trae': { skillsDir: '.trae/skills', configFile: 'AGENTS.md' },
'windsurf': { skillsDir: '.windsurf/skills', configFile: 'AGENTS.md' },
'universal': { skillsDir: '.agent/skills', configFile: 'AGENTS.md' },
};
/**
* Context Sync
*
@@ -73,7 +51,7 @@ export class ContextSync {
detectAgents(): AgentType[] {
const detected: AgentType[] = [];
for (const [agent, config] of Object.entries(AGENT_DIRS)) {
for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
const skillsPath = join(this.projectPath, config.skillsDir);
const configPath = join(this.projectPath, config.configFile);
@@ -171,7 +149,7 @@ export class ContextSync {
const sourceSkills = skills || this.getSourceSkills();
// Get target directory
const agentConfig = AGENT_DIRS[agent];
const agentConfig = AGENT_CONFIG[agent];
if (!agentConfig) {
result.success = false;
result.errors.push(`Unknown agent: ${agent}`);
@@ -297,8 +275,8 @@ export class ContextSync {
// Search directories based on primary agent or common locations
const searchDirs: string[] = [];
if (primaryAgent && AGENT_DIRS[primaryAgent]) {
searchDirs.push(join(this.projectPath, AGENT_DIRS[primaryAgent].skillsDir));
if (primaryAgent && AGENT_CONFIG[primaryAgent]) {
searchDirs.push(join(this.projectPath, AGENT_CONFIG[primaryAgent].skillsDir));
}
// Add common skill locations
@@ -327,7 +305,7 @@ export class ContextSync {
checkStatus(): Record<AgentType, { hasSkills: boolean; skillCount: number; skills: string[] }> {
const status: Record<string, { hasSkills: boolean; skillCount: number; skills: string[] }> = {};
for (const [agent, config] of Object.entries(AGENT_DIRS)) {
for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
const skillsPath = join(this.projectPath, config.skillsDir);
const skills: string[] = [];
+6
View File
@@ -1,6 +1,9 @@
// Types
export * from './types.js';
// Centralized Agent Configuration (single source of truth)
export * from './agent-config.js';
// Skills discovery and parsing
export * from './skills.js';
@@ -69,3 +72,6 @@ export * from './audit/index.js';
// Custom Agents Support (Phase 19)
export * from './agents/index.js';
// Skill Translator (Phase 20 - Cross-Agent Skill Translation)
export * from './skill-translator.js';
+692
View File
@@ -0,0 +1,692 @@
/**
* Skill Translator
*
* Translates SKILL.md files between different AI coding agent formats.
* This is the core functionality for SkillKit's cross-agent skill ecosystem.
*/
import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
import { join, basename, dirname, resolve, relative, isAbsolute } from 'node:path';
import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
import type { AgentType, Skill } from './types.js';
import {
AGENT_CONFIG,
type AgentDirectoryConfig,
getSkillsDir,
getConfigFile,
getAllSkillsDirs as getAgentAllSkillsDirs,
getGlobalSkillsDir as getAgentGlobalSkillsDir,
supportsAutoDiscovery as agentSupportsAutoDiscovery,
} from './agent-config.js';
/**
* Extended skill format for translation (includes invokeCommand)
*/
export interface AgentSkillFormat extends AgentDirectoryConfig {
invokeCommand: string;
}
/**
* Agent-specific skill format configurations
* Extends AGENT_CONFIG with invokeCommand for all agents
*/
export const AGENT_SKILL_FORMATS: Record<AgentType, AgentSkillFormat> = Object.fromEntries(
Object.entries(AGENT_CONFIG).map(([agent, config]) => [
agent,
{ ...config, invokeCommand: 'skillkit read' },
])
) as Record<AgentType, AgentSkillFormat>;
/**
* Canonical skill representation for cross-agent translation
*/
export interface CrossAgentSkill {
name: string;
description: string;
content: string;
frontmatter: Record<string, unknown>;
sourcePath: string;
sourceAgent?: AgentType;
version?: string;
author?: string;
tags?: string[];
allowedTools?: string[];
/** Agent-specific fields preserved during translation */
agentFields?: Record<string, unknown>;
}
/**
* Skill translation result
*/
export interface SkillTranslationResult {
success: boolean;
content: string;
filename: string;
targetDir: string;
warnings: string[];
incompatible: string[];
targetAgent: AgentType;
}
/**
* Skill translation options
*/
export interface SkillTranslationOptions {
/** Preserve original comments and formatting */
preserveComments?: boolean;
/** Add translation metadata comment */
addMetadata?: boolean;
/** Custom output filename */
outputFilename?: string;
/** Overwrite existing files */
overwrite?: boolean;
/** Write to disk */
write?: boolean;
/** Output directory override */
outputDir?: string;
}
/**
* Parse a SKILL.md file into canonical format
*/
export function parseSkillToCanonical(
skillPath: string,
sourceAgent?: AgentType
): CrossAgentSkill | null {
const skillMdPath = skillPath.endsWith('SKILL.md')
? skillPath
: join(skillPath, 'SKILL.md');
if (!existsSync(skillMdPath)) {
return null;
}
try {
const content = readFileSync(skillMdPath, 'utf-8');
return parseSkillContentToCanonical(content, skillPath, sourceAgent);
} catch {
return null;
}
}
/**
* Parse skill content string into canonical format
*/
export function parseSkillContentToCanonical(
content: string,
sourcePath: string,
sourceAgent?: AgentType
): CrossAgentSkill | null {
const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
let frontmatter: Record<string, unknown> = {};
let bodyContent = content;
if (frontmatterMatch) {
try {
frontmatter = parseYaml(frontmatterMatch[1]) as Record<string, unknown>;
bodyContent = content.slice(frontmatterMatch[0].length).trim();
} catch {
// Continue without frontmatter
}
}
// If sourcePath is a directory (skill folder), use its basename
// If sourcePath is a file (SKILL.md), use the parent directory's basename
const name = (frontmatter.name as string) || basename(sourcePath.endsWith('.md') ? dirname(sourcePath) : sourcePath);
const description = (frontmatter.description as string) || extractDescriptionFromContent(bodyContent);
return {
name,
description,
content: bodyContent,
frontmatter,
sourcePath,
sourceAgent,
version: frontmatter.version as string | undefined,
author: frontmatter.author as string | undefined,
tags: frontmatter.tags as string[] | undefined,
allowedTools: parseAllowedTools(frontmatter['allowed-tools']),
agentFields: extractAgentSpecificFields(frontmatter, sourceAgent),
};
}
/**
* Extract description from markdown content if not in frontmatter
*/
function extractDescriptionFromContent(content: string): string {
// Try to find first paragraph or first heading
const lines = content.split('\n').filter(line => line.trim());
for (const line of lines) {
const trimmed = line.trim();
// Skip headings
if (trimmed.startsWith('#')) continue;
// Skip code blocks
if (trimmed.startsWith('```')) continue;
// Return first substantive line
if (trimmed.length > 10) {
return trimmed.slice(0, 200) + (trimmed.length > 200 ? '...' : '');
}
}
return 'No description available';
}
/**
* Parse allowed-tools field (can be string or array)
*/
function parseAllowedTools(value: unknown): string[] | undefined {
if (!value) return undefined;
if (Array.isArray(value)) return value;
if (typeof value === 'string') {
return value.split(',').map(t => t.trim()).filter(Boolean);
}
return undefined;
}
/**
* Extract agent-specific fields from frontmatter
*/
function extractAgentSpecificFields(
frontmatter: Record<string, unknown>,
_sourceAgent?: AgentType
): Record<string, unknown> {
const agentFields: Record<string, unknown> = {};
// Preserve special fields that might be agent-specific
const specialFields = [
'disable-model-invocation',
'user-invocable',
'argument-hint',
'model',
'context',
'agent',
'globs',
'alwaysApply',
'applyTo',
'mode',
'hooks',
'permissionMode',
];
for (const field of specialFields) {
if (field in frontmatter) {
agentFields[field] = frontmatter[field];
}
}
return agentFields;
}
/**
* Translate a cross-agent skill to target agent format
*/
export function translateSkillToAgent(
canonical: CrossAgentSkill,
targetAgent: AgentType,
options?: SkillTranslationOptions
): SkillTranslationResult {
const format = AGENT_SKILL_FORMATS[targetAgent];
const warnings: string[] = [];
const incompatible: string[] = [];
// Check for incompatible features
if (canonical.agentFields?.['hooks'] && targetAgent !== 'claude-code') {
incompatible.push('hooks (only supported in Claude Code)');
}
if (canonical.agentFields?.['permissionMode'] && !['claude-code', 'roo'].includes(targetAgent)) {
warnings.push('permissionMode may not be fully supported');
}
// Generate SKILL.md content for target agent
const content = generateSkillContent(canonical, targetAgent, format, options);
// Determine output filename and directory
const filename = options?.outputFilename || 'SKILL.md';
const targetDir = options?.outputDir || join(format.skillsDir, canonical.name);
return {
success: true,
content,
filename,
targetDir,
warnings,
incompatible,
targetAgent,
};
}
/**
* Generate SKILL.md content for target agent
*/
function generateSkillContent(
canonical: CrossAgentSkill,
targetAgent: AgentType,
format: AgentSkillFormat,
options?: SkillTranslationOptions
): string {
const lines: string[] = [];
// Build frontmatter
const frontmatter: Record<string, unknown> = {
name: canonical.name,
description: canonical.description,
};
// Add version and author if present
if (canonical.version) {
frontmatter.version = canonical.version;
}
if (canonical.author) {
frontmatter.author = canonical.author;
}
if (canonical.tags && canonical.tags.length > 0) {
frontmatter.tags = canonical.tags;
}
// Add allowed-tools if present
if (canonical.allowedTools && canonical.allowedTools.length > 0) {
frontmatter['allowed-tools'] = canonical.allowedTools.join(', ');
}
// Add agent-specific fields based on target
addAgentSpecificFields(frontmatter, canonical, targetAgent, format);
// Add translation metadata if requested
if (options?.addMetadata && canonical.sourceAgent) {
frontmatter['_translated-from'] = canonical.sourceAgent;
frontmatter['_translated-at'] = new Date().toISOString();
}
// Generate YAML frontmatter
lines.push('---');
lines.push(stringifyYaml(frontmatter).trim());
lines.push('---');
lines.push('');
// Add content
lines.push(canonical.content);
return lines.join('\n');
}
/**
* Add agent-specific fields to frontmatter
*/
function addAgentSpecificFields(
frontmatter: Record<string, unknown>,
canonical: CrossAgentSkill,
targetAgent: AgentType,
_format: AgentSkillFormat
): void {
// Claude Code specific
if (targetAgent === 'claude-code') {
if ('model' in (canonical.agentFields ?? {})) {
frontmatter.model = canonical.agentFields!['model'];
}
if ('context' in (canonical.agentFields ?? {})) {
frontmatter.context = canonical.agentFields!['context'];
}
if ('agent' in (canonical.agentFields ?? {})) {
frontmatter.agent = canonical.agentFields!['agent'];
}
if ('disable-model-invocation' in (canonical.agentFields ?? {})) {
frontmatter['disable-model-invocation'] = canonical.agentFields!['disable-model-invocation'];
}
if ('user-invocable' in (canonical.agentFields ?? {})) {
frontmatter['user-invocable'] = canonical.agentFields!['user-invocable'];
}
if ('argument-hint' in (canonical.agentFields ?? {})) {
frontmatter['argument-hint'] = canonical.agentFields!['argument-hint'];
}
if ('hooks' in (canonical.agentFields ?? {})) {
frontmatter.hooks = canonical.agentFields!['hooks'];
}
if ('permissionMode' in (canonical.agentFields ?? {})) {
frontmatter.permissionMode = canonical.agentFields!['permissionMode'];
}
}
// Cursor/Trae/Windsurf specific (MDC-style)
if (['cursor', 'trae', 'windsurf'].includes(targetAgent)) {
if ('globs' in (canonical.agentFields ?? {})) {
frontmatter.globs = canonical.agentFields!['globs'];
}
if ('alwaysApply' in (canonical.agentFields ?? {})) {
frontmatter.alwaysApply = canonical.agentFields!['alwaysApply'];
}
if (targetAgent === 'windsurf' && 'mode' in (canonical.agentFields ?? {})) {
frontmatter.mode = canonical.agentFields!['mode'];
}
}
// GitHub Copilot specific
if (targetAgent === 'github-copilot') {
if ('applyTo' in (canonical.agentFields ?? {})) {
frontmatter.applyTo = canonical.agentFields!['applyTo'];
}
}
// Roo specific
if (targetAgent === 'roo') {
if ('disable-model-invocation' in (canonical.agentFields ?? {})) {
frontmatter['disable-model-invocation'] = canonical.agentFields!['disable-model-invocation'];
}
if ('user-invocable' in (canonical.agentFields ?? {})) {
frontmatter['user-invocable'] = canonical.agentFields!['user-invocable'];
}
if ('permissionMode' in (canonical.agentFields ?? {})) {
frontmatter.permissionMode = canonical.agentFields!['permissionMode'];
}
}
}
/**
* Translate a skill file to multiple target agents
*/
export function translateSkillToAll(
skillPath: string,
sourceAgent?: AgentType,
options?: SkillTranslationOptions
): Map<AgentType, SkillTranslationResult> {
const canonical = parseSkillToCanonical(skillPath, sourceAgent);
if (!canonical) {
return new Map();
}
const results = new Map<AgentType, SkillTranslationResult>();
const agents: AgentType[] = [
'claude-code', 'cursor', 'codex', 'gemini-cli', 'opencode',
'antigravity', 'amp', 'clawdbot', 'droid', 'github-copilot',
'goose', 'kilo', 'kiro-cli', 'roo', 'trae', 'windsurf', 'universal',
];
for (const agent of agents) {
if (agent !== sourceAgent) {
results.set(agent, translateSkillToAgent(canonical, agent, options));
}
}
return results;
}
/**
* Write translated skill to disk
*/
export function writeTranslatedSkill(
result: SkillTranslationResult,
rootDir: string,
options?: { overwrite?: boolean }
): { success: boolean; path: string; error?: string; skipped?: boolean } {
// Don't write if translation failed
if (!result.success) {
return {
success: false,
path: '',
error: 'Translation failed',
};
}
try {
const rootPath = resolve(rootDir);
const filePath = resolve(rootDir, result.targetDir, result.filename);
const targetPath = dirname(filePath);
// Guard against path traversal
const relPath = relative(rootPath, filePath);
if (relPath.startsWith('..') || isAbsolute(relPath)) {
return {
success: false,
path: filePath,
error: 'Resolved output path escapes rootDir',
};
}
// Check if file exists and overwrite is disabled
if (existsSync(filePath) && options?.overwrite === false) {
return {
success: false,
path: filePath,
error: 'File exists and overwrite=false',
skipped: true,
};
}
// Create directory if needed
if (!existsSync(targetPath)) {
mkdirSync(targetPath, { recursive: true });
}
writeFileSync(filePath, result.content, 'utf-8');
return { success: true, path: filePath };
} catch (error) {
return {
success: false,
path: '',
error: error instanceof Error ? error.message : String(error),
};
}
}
/**
* Generate config file content that references skills
* This generates the agent-specific config format (AGENTS.md, .cursorrules, etc.)
*/
export function generateSkillsConfig(
skills: Skill[],
targetAgent: AgentType
): string {
const format = AGENT_SKILL_FORMATS[targetAgent];
const enabledSkills = skills.filter(s => s.enabled);
if (enabledSkills.length === 0) {
return '';
}
switch (format.configFormat) {
case 'xml':
return generateXmlConfig(enabledSkills, format);
case 'mdc':
return generateMdcConfig(enabledSkills, format);
case 'markdown-table':
return generateMarkdownTableConfig(enabledSkills, format);
case 'json':
return generateJsonConfig(enabledSkills, format);
case 'markdown':
return generateMarkdownConfig(enabledSkills, format);
default:
return generateMarkdownConfig(enabledSkills, format);
}
}
/**
* Generate XML-style config (Claude Code, OpenCode, etc.)
*/
function generateXmlConfig(skills: Skill[], format: AgentSkillFormat): string {
const skillsXml = skills.map(s => `<skill>
<name>${escapeXml(s.name)}</name>
<description>${escapeXml(s.description)}</description>
<location>${escapeXml(s.path)}</location>
</skill>`).join('\n\n');
return `<skills_system priority="1">
## Available Skills
<!-- SKILLS_TABLE_START -->
<usage>
When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
How to use skills:
- Invoke: \`${format.invokeCommand} <skill-name>\` or \`npx ${format.invokeCommand} <skill-name>\`
- The skill content will load with detailed instructions on how to complete the task
- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
Usage notes:
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already loaded in your context
- Each skill invocation is stateless
</usage>
<available_skills>
${skillsXml}
</available_skills>
<!-- SKILLS_TABLE_END -->
</skills_system>`;
}
/**
* Generate MDC-style config (Cursor)
*/
function generateMdcConfig(skills: Skill[], format: AgentSkillFormat): string {
const skillsList = skills
.map(s => `- **${s.name}**: ${s.description}`)
.join('\n');
const skillsXml = skills.map(s => `<skill>
<name>${escapeXml(s.name)}</name>
<description>${escapeXml(s.description)}</description>
<location>${escapeXml(s.path)}</location>
</skill>`).join('\n\n');
return `---
description: SkillKit skills integration - provides specialized capabilities and domain knowledge
globs: "**/*"
alwaysApply: true
---
# Skills System
You have access to specialized skills that can help complete tasks. Use the skillkit CLI to load skill instructions when needed.
## Available Skills
${skillsList}
## How to Use Skills
When a task matches a skill's description, load it with:
\`\`\`bash
${format.invokeCommand} <skill-name>
\`\`\`
The skill will provide detailed instructions for completing the task.
<!-- SKILLS_DATA_START -->
${skillsXml}
<!-- SKILLS_DATA_END -->
`;
}
/**
* Generate Markdown table config (Codex)
*/
function generateMarkdownTableConfig(skills: Skill[], format: AgentSkillFormat): string {
const skillsList = skills
.map(s => `| ${s.name} | ${s.description} | \`${format.invokeCommand} ${s.name}\` |`)
.join('\n');
return `# Skills
You have access to specialized skills for completing complex tasks.
| Skill | Description | Command |
|-------|-------------|---------|
${skillsList}
## Usage
When a task matches a skill's capability, run the command to load detailed instructions:
\`\`\`bash
${format.invokeCommand} <skill-name>
\`\`\`
Skills are loaded on-demand to keep context clean. Only load skills when relevant to the current task.
`;
}
/**
* Generate JSON config (Gemini CLI)
*/
function generateJsonConfig(skills: Skill[], format: AgentSkillFormat): string {
const skillsJson = skills.map(s => ({
name: s.name,
description: s.description,
invoke: `${format.invokeCommand} ${s.name}`,
location: s.path,
}));
return `# Skills Configuration
You have access to specialized skills that extend your capabilities.
## Available Skills
${skills.map(s => `### ${s.name}\n${s.description}\n\nInvoke: \`${format.invokeCommand} ${s.name}\``).join('\n\n')}
## Skills Data
\`\`\`json
${JSON.stringify(skillsJson, null, 2)}
\`\`\`
## Usage Instructions
1. When a task matches a skill's description, load it using the invoke command
2. Skills provide step-by-step instructions for complex tasks
3. Each skill is self-contained with its own resources
`;
}
/**
* Generate Markdown config (Windsurf, Trae, GitHub Copilot)
*/
function generateMarkdownConfig(skills: Skill[], format: AgentSkillFormat): string {
const skillsList = skills
.map(s => `### ${s.name}\n\n${s.description}\n\n**Invoke:** \`${format.invokeCommand} ${s.name}\``)
.join('\n\n');
return `# Skills System
You have access to specialized skills that can help complete tasks.
## Available Skills
${skillsList}
## How to Use Skills
When a task matches a skill's description, load it:
\`\`\`bash
${format.invokeCommand} <skill-name>
\`\`\`
Skills provide detailed instructions for completing complex tasks.
`;
}
/**
* Escape XML special characters
*/
function escapeXml(text: string): string {
return text
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;')
.replace(/"/g, '&quot;')
.replace(/'/g, '&apos;');
}
// Re-export utility functions from centralized config with legacy names for backwards compatibility
export const getAgentSkillsDir = getSkillsDir;
export const getAgentConfigFile = getConfigFile;
export { agentSupportsAutoDiscovery as supportsAutoDiscovery };
export { getAgentAllSkillsDirs as getAllSkillsDirs };
export { getAgentGlobalSkillsDir as getGlobalSkillsDir };
+2 -13
View File
@@ -61,8 +61,8 @@ importers:
packages/agents:
dependencies:
'@skillkit/core':
specifier: ^1.6.0
version: 1.6.0
specifier: workspace:*
version: link:../core
minimatch:
specifier: ^9.0.0
version: 9.0.5
@@ -650,10 +650,6 @@ packages:
resolution: {integrity: sha512-P1Cz1dWaFfR4IR+U13mqqiGsLFf1KbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzf13K8DCCXQw==}
engines: {node: '>=18'}
'@skillkit/core@1.6.0':
resolution: {integrity: sha512-987hhnYir4a3qnIkB/iIxeVeJ8mNF6R8IidtnFo9Q4GamcyvJ0W692V5wVOoR2MiS1F/NSstjfrV/h2ujMydyw==}
engines: {node: '>=18.0.0'}
'@types/estree@1.0.8':
resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
@@ -1895,13 +1891,6 @@ snapshots:
'@sindresorhus/is@7.2.0': {}
'@skillkit/core@1.6.0':
dependencies:
'@types/minimatch': 6.0.0
minimatch: 10.1.1
yaml: 2.8.2
zod: 3.25.76
'@types/estree@1.0.8': {}
'@types/http-cache-semantics@4.0.4': {}