From 413519d4867a1b47a88f1dcbe91b7454975db3b5 Mon Sep 17 00:00:00 2001 From: Rohit Ghumare <48523873+rohitg00@users.noreply.github.com> Date: Sun, 25 Jan 2026 14:09:47 +0000 Subject: [PATCH] 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 --- e2e/skill-translator.e2e.test.ts | 761 ++++++++++++++++++ e2e/vitest.config.ts | 7 + packages/agents/package.json | 2 +- .../agents/src/__tests__/clawdbot.test.ts | 2 +- packages/agents/src/amp.ts | 13 +- packages/agents/src/antigravity.ts | 7 +- packages/agents/src/claude-code.ts | 7 +- packages/agents/src/clawdbot.ts | 7 +- packages/agents/src/codex.ts | 7 +- packages/agents/src/cursor.ts | 24 +- packages/agents/src/droid.ts | 7 +- packages/agents/src/gemini-cli.ts | 9 +- packages/agents/src/github-copilot.ts | 55 +- packages/agents/src/goose.ts | 7 +- packages/agents/src/index.ts | 9 +- packages/agents/src/kilo.ts | 10 +- packages/agents/src/kiro-cli.ts | 7 +- packages/agents/src/opencode.ts | 13 +- packages/agents/src/roo.ts | 10 +- packages/agents/src/trae.ts | 56 +- packages/agents/src/universal.ts | 7 +- packages/agents/src/windsurf.ts | 57 +- .../src/__tests__/skill-translator.test.ts | 432 ++++++++++ packages/core/src/agent-config.ts | 269 +++++++ packages/core/src/agents/types.ts | 27 +- packages/core/src/context/sync.ts | 34 +- packages/core/src/index.ts | 6 + packages/core/src/skill-translator.ts | 692 ++++++++++++++++ pnpm-lock.yaml | 15 +- 29 files changed, 2378 insertions(+), 181 deletions(-) create mode 100644 e2e/skill-translator.e2e.test.ts create mode 100644 packages/core/src/__tests__/skill-translator.test.ts create mode 100644 packages/core/src/agent-config.ts create mode 100644 packages/core/src/skill-translator.ts diff --git a/e2e/skill-translator.e2e.test.ts b/e2e/skill-translator.e2e.test.ts new file mode 100644 index 00000000..eb5c3801 --- /dev/null +++ b/e2e/skill-translator.e2e.test.ts @@ -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('skill-alpha'); + expect(config).toContain('skill-beta'); + expect(config).toContain('skill-gamma'); + expect(config).not.toContain('skill-disabled'); + expect(config).toContain('First test skill'); + 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('skill-alpha'); + }); + + 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('workflow-skill'); + + 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'); + } + }); +}); diff --git a/e2e/vitest.config.ts b/e2e/vitest.config.ts index cc4997a7..d6514e5c 100644 --- a/e2e/vitest.config.ts +++ b/e2e/vitest.config.ts @@ -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'), + }, + }, }); diff --git a/packages/agents/package.json b/packages/agents/package.json index 05a16b0b..c030baf1 100644 --- a/packages/agents/package.json +++ b/packages/agents/package.json @@ -21,7 +21,7 @@ "test": "vitest run" }, "dependencies": { - "@skillkit/core": "^1.6.0", + "@skillkit/core": "workspace:*", "minimatch": "^9.0.0" }, "devDependencies": { diff --git a/packages/agents/src/__tests__/clawdbot.test.ts b/packages/agents/src/__tests__/clawdbot.test.ts index 3030ab6c..28017bf5 100644 --- a/packages/agents/src/__tests__/clawdbot.test.ts +++ b/packages/agents/src/__tests__/clawdbot.test.ts @@ -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', () => { diff --git a/packages/agents/src/amp.ts b/packages/agents/src/amp.ts index 034acf79..e2463329 100644 --- a/packages/agents/src/amp.ts +++ b/packages/agents/src/amp.ts @@ -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 { - 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); } } diff --git a/packages/agents/src/antigravity.ts b/packages/agents/src/antigravity.ts index 7f7e3f1a..fd1dfa6c 100644 --- a/packages/agents/src/antigravity.ts +++ b/packages/agents/src/antigravity.ts @@ -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); diff --git a/packages/agents/src/claude-code.ts b/packages/agents/src/claude-code.ts index d800ad60..bdc1d27e 100644 --- a/packages/agents/src/claude-code.ts +++ b/packages/agents/src/claude-code.ts @@ -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); diff --git a/packages/agents/src/clawdbot.ts b/packages/agents/src/clawdbot.ts index cc24b160..2f56a339 100644 --- a/packages/agents/src/clawdbot.ts +++ b/packages/agents/src/clawdbot.ts @@ -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); diff --git a/packages/agents/src/codex.ts b/packages/agents/src/codex.ts index cf229078..d36d725a 100644 --- a/packages/agents/src/codex.ts +++ b/packages/agents/src/codex.ts @@ -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); diff --git a/packages/agents/src/cursor.ts b/packages/agents/src/cursor.ts index 1db1d7fc..17c80e4a 100644 --- a/packages/agents/src/cursor.ts +++ b/packages/agents/src/cursor.ts @@ -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 { - 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); } } diff --git a/packages/agents/src/droid.ts b/packages/agents/src/droid.ts index 373605ab..1446e409 100644 --- a/packages/agents/src/droid.ts +++ b/packages/agents/src/droid.ts @@ -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); diff --git a/packages/agents/src/gemini-cli.ts b/packages/agents/src/gemini-cli.ts index 15bc3a8b..3751b1e9 100644 --- a/packages/agents/src/gemini-cli.ts +++ b/packages/agents/src/gemini-cli.ts @@ -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()); diff --git a/packages/agents/src/github-copilot.ts b/packages/agents/src/github-copilot.ts index 5a1c20ff..689e24f9 100644 --- a/packages/agents/src/github-copilot.ts +++ b/packages/agents/src/github-copilot.ts @@ -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 ` + 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 - - -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 \` or \`npx skillkit read \` -- 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 below -- Do not invoke a skill that is already loaded in your context -- Each skill invocation is stateless - +When a task matches a skill's description, load it using the terminal: - +\`\`\`bash +skillkit read +\`\`\` -${skillsXml} - - - - -`; +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>/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 { - 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); } } diff --git a/packages/agents/src/goose.ts b/packages/agents/src/goose.ts index 870961c5..a31818b1 100644 --- a/packages/agents/src/goose.ts +++ b/packages/agents/src/goose.ts @@ -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); diff --git a/packages/agents/src/index.ts b/packages/agents/src/index.ts index 9cdef5fc..49155305 100644 --- a/packages/agents/src/index.ts +++ b/packages/agents/src/index.ts @@ -99,10 +99,5 @@ export async function detectAgent(): Promise { 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 diff --git a/packages/agents/src/kilo.ts b/packages/agents/src/kilo.ts index dec3e644..f8f989fa 100644 --- a/packages/agents/src/kilo.ts +++ b/packages/agents/src/kilo.ts @@ -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 { 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); } } diff --git a/packages/agents/src/kiro-cli.ts b/packages/agents/src/kiro-cli.ts index 299837a4..6a904cce 100644 --- a/packages/agents/src/kiro-cli.ts +++ b/packages/agents/src/kiro-cli.ts @@ -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); diff --git a/packages/agents/src/opencode.ts b/packages/agents/src/opencode.ts index 7b99f542..b04e9d5b 100644 --- a/packages/agents/src/opencode.ts +++ b/packages/agents/src/opencode.ts @@ -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 { 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); } } diff --git a/packages/agents/src/roo.ts b/packages/agents/src/roo.ts index dbd82e0d..7d489b91 100644 --- a/packages/agents/src/roo.ts +++ b/packages/agents/src/roo.ts @@ -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 { 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); } } diff --git a/packages/agents/src/trae.ts b/packages/agents/src/trae.ts index 35ecca1c..bd03b338 100644 --- a/packages/agents/src/trae.ts +++ b/packages/agents/src/trae.ts @@ -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 ` + 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 - - -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 \` or \`npx skillkit read \` -- 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 below -- Do not invoke a skill that is already loaded in your context -- Each skill invocation is stateless - +When a task matches a skill's description, load it: - +\`\`\`bash +skillkit read +\`\`\` -${skillsXml} - - - - -`; +Skills provide detailed instructions for completing complex tasks. +`; } parseConfig(content: string): string[] { const skillNames: string[] = []; - const skillRegex = /([^<]+)<\/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 { 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); } } diff --git a/packages/agents/src/universal.ts b/packages/agents/src/universal.ts index 781b3474..00eade7d 100644 --- a/packages/agents/src/universal.ts +++ b/packages/agents/src/universal.ts @@ -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); diff --git a/packages/agents/src/windsurf.ts b/packages/agents/src/windsurf.ts index e3cc6fe8..850531ca 100644 --- a/packages/agents/src/windsurf.ts +++ b/packages/agents/src/windsurf.ts @@ -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 ` + 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 - - -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 \` or \`npx skillkit read \` -- 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 below -- Do not invoke a skill that is already loaded in your context -- Each skill invocation is stateless - +When a task matches a skill's description, load it: - +\`\`\`bash +skillkit read +\`\`\` -${skillsXml} - - - - -`; +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>/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 { 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); } } diff --git a/packages/core/src/__tests__/skill-translator.test.ts b/packages/core/src/__tests__/skill-translator.test.ts new file mode 100644 index 00000000..4a0a5dac --- /dev/null +++ b/packages/core/src/__tests__/skill-translator.test.ts @@ -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('skill-one'); + expect(config).toContain('skill-two'); + 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'); + } + }); +}); diff --git a/packages/core/src/agent-config.ts b/packages/core/src/agent-config.ts new file mode 100644 index 00000000..c83d2816 --- /dev/null +++ b/packages/core/src/agent-config.ts @@ -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 = { + // 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; +} diff --git a/packages/core/src/agents/types.ts b/packages/core/src/agents/types.ts index 643fbd8a..9dce8fae 100644 --- a/packages/core/src/agents/types.ts +++ b/packages/core/src/agents/types.ts @@ -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 = { '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', ]; /** diff --git a/packages/core/src/context/sync.ts b/packages/core/src/context/sync.ts index 56690861..8e76c195 100644 --- a/packages/core/src/context/sync.ts +++ b/packages/core/src/context/sync.ts @@ -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 = { - '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 { const status: Record = {}; - 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[] = []; diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index b1f61551..ba18da6e 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -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'; diff --git a/packages/core/src/skill-translator.ts b/packages/core/src/skill-translator.ts new file mode 100644 index 00000000..6feb0b08 --- /dev/null +++ b/packages/core/src/skill-translator.ts @@ -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 = Object.fromEntries( + Object.entries(AGENT_CONFIG).map(([agent, config]) => [ + agent, + { ...config, invokeCommand: 'skillkit read' }, + ]) +) as Record; + +/** + * Canonical skill representation for cross-agent translation + */ +export interface CrossAgentSkill { + name: string; + description: string; + content: string; + frontmatter: Record; + sourcePath: string; + sourceAgent?: AgentType; + version?: string; + author?: string; + tags?: string[]; + allowedTools?: string[]; + /** Agent-specific fields preserved during translation */ + agentFields?: Record; +} + +/** + * 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 = {}; + let bodyContent = content; + + if (frontmatterMatch) { + try { + frontmatter = parseYaml(frontmatterMatch[1]) as Record; + 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, + _sourceAgent?: AgentType +): Record { + const agentFields: Record = {}; + + // 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 = { + 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, + 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 { + const canonical = parseSkillToCanonical(skillPath, sourceAgent); + if (!canonical) { + return new Map(); + } + + const results = new Map(); + 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 => ` +${escapeXml(s.name)} +${escapeXml(s.description)} +${escapeXml(s.path)} +`).join('\n\n'); + + return ` + +## Available Skills + + + +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} \` or \`npx ${format.invokeCommand} \` +- 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 below +- Do not invoke a skill that is already loaded in your context +- Each skill invocation is stateless + + + + +${skillsXml} + + + + +`; +} + +/** + * 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 => ` +${escapeXml(s.name)} +${escapeXml(s.description)} +${escapeXml(s.path)} +`).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} +\`\`\` + +The skill will provide detailed instructions for completing the task. + + +${skillsXml} + +`; +} + +/** + * 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} +\`\`\` + +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} +\`\`\` + +Skills provide detailed instructions for completing complex tasks. +`; +} + +/** + * Escape XML special characters + */ +function escapeXml(text: string): string { + return text + .replace(/&/g, '&') + .replace(//g, '>') + .replace(/"/g, '"') + .replace(/'/g, '''); +} + +// 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 }; diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 87b092ad..3b6c92e7 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -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': {}