@skillkit/agents 1.3.0

package/dist/index.js

@@ -0,0 +1,1190 @@
+// src/claude-code.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/base.ts
+function createSkillXml(skill) {
+  return `<skill>
+<name>${skill.name}</name>
+<description>${escapeXml(skill.description)}</description>
+<location>${skill.location}</location>
+</skill>`;
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/claude-code.ts
+var ClaudeCodeAdapter = class {
+  type = "claude-code";
+  name = "Claude Code";
+  skillsDir = ".claude/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectClaude = join(process.cwd(), ".claude");
+    const globalClaude = join(homedir(), ".claude");
+    const claudeMd = join(process.cwd(), "CLAUDE.md");
+    return existsSync(projectClaude) || existsSync(globalClaude) || existsSync(claudeMd);
+  }
+};
+
+// src/cursor.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var CursorAdapter = class {
+  type = "cursor";
+  name = "Cursor";
+  skillsDir = ".cursor/skills";
+  configFile = ".cursorrules";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsList = enabledSkills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `# 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
+skillkit read <skill-name>
+\`\`\`
+
+The skill will provide detailed instructions for completing the task.
+
+<!-- SKILLS_DATA_START -->
+${skillsXml}
+<!-- SKILLS_DATA_END -->
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const cursorRules = join2(process.cwd(), ".cursorrules");
+    const cursorDir = join2(process.cwd(), ".cursor");
+    return existsSync2(cursorRules) || existsSync2(cursorDir);
+  }
+};
+
+// src/codex.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+var CodexAdapter = class {
+  type = "codex";
+  name = "OpenAI Codex CLI";
+  skillsDir = ".codex/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsList = enabledSkills.map((s) => `| ${s.name} | ${s.description} | \`skillkit read ${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
+skillkit read <skill-name>
+\`\`\`
+
+Skills are loaded on-demand to keep context clean. Only load skills when relevant to the current task.
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const tableRegex = /^\|\s*([a-z0-9-]+)\s*\|/gm;
+    let match;
+    while ((match = tableRegex.exec(content)) !== null) {
+      const name = match[1].trim();
+      if (name && name !== "Skill" && name !== "-------") {
+        skillNames.push(name);
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const codexDir = join3(process.cwd(), ".codex");
+    const globalCodex = join3(homedir2(), ".codex");
+    return existsSync3(codexDir) || existsSync3(globalCodex);
+  }
+};
+
+// src/gemini-cli.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var GeminiCliAdapter = class {
+  type = "gemini-cli";
+  name = "Gemini CLI";
+  skillsDir = ".gemini/skills";
+  configFile = "GEMINI.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsJson = enabledSkills.map((s) => ({
+      name: s.name,
+      description: s.description,
+      invoke: `skillkit read ${s.name}`,
+      location: s.location
+    }));
+    return `# Skills Configuration
+
+You have access to specialized skills that extend your capabilities.
+
+## Available Skills
+
+${enabledSkills.map((s) => `### ${s.name}
+${s.description}
+
+Invoke: \`skillkit read ${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
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const jsonMatch = content.match(/```json\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+      try {
+        const skills = JSON.parse(jsonMatch[1]);
+        if (Array.isArray(skills)) {
+          skills.forEach((s) => {
+            if (s.name) skillNames.push(s.name);
+          });
+        }
+      } catch {
+      }
+    }
+    if (skillNames.length === 0) {
+      const headerRegex = /^### ([a-z0-9-]+)$/gm;
+      let match;
+      while ((match = headerRegex.exec(content)) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const geminiMd = join4(process.cwd(), "GEMINI.md");
+    const geminiDir = join4(process.cwd(), ".gemini");
+    const globalGemini = join4(homedir3(), ".gemini");
+    return existsSync4(geminiMd) || existsSync4(geminiDir) || existsSync4(globalGemini);
+  }
+};
+
+// src/opencode.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+var OpenCodeAdapter = class {
+  type = "opencode";
+  name = "OpenCode";
+  skillsDir = ".opencode/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<!-- SKILLKIT_START -->
+# Skills
+
+The following skills are available to help complete tasks:
+
+<skills>
+${skillsXml}
+</skills>
+
+## How to Use
+
+When a task matches a skill's description:
+
+\`\`\`bash
+skillkit read <skill-name>
+\`\`\`
+
+This loads the skill's instructions into context.
+
+<!-- SKILLKIT_END -->`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const opencodeDir = join5(process.cwd(), ".opencode");
+    const globalOpencode = join5(homedir4(), ".opencode");
+    return existsSync5(opencodeDir) || existsSync5(globalOpencode);
+  }
+};
+
+// src/antigravity.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+var AntigravityAdapter = class {
+  type = "antigravity";
+  name = "Antigravity";
+  skillsDir = ".antigravity/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsYaml = enabledSkills.map((s) => `  - name: ${s.name}
+    description: "${s.description}"
+    invoke: skillkit read ${s.name}`).join("\n");
+    return `# Antigravity Skills Configuration
+
+<!-- skills:
+${skillsYaml}
+-->
+
+## Available Skills
+
+${enabledSkills.map((s) => `### ${s.name}
+
+${s.description}
+
+**Usage:** \`skillkit read ${s.name}\`
+`).join("\n")}
+
+## How Skills Work
+
+1. Skills provide specialized knowledge for specific tasks
+2. Load a skill when the current task matches its description
+3. Skills are loaded on-demand to preserve context window
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const yamlMatch = content.match(/<!-- skills:\s*([\s\S]*?)-->/);
+    if (yamlMatch) {
+      const nameRegex = /name:\s*([a-z0-9-]+)/g;
+      let match;
+      while ((match = nameRegex.exec(yamlMatch[1])) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    if (skillNames.length === 0) {
+      const headerRegex = /^### ([a-z0-9-]+)$/gm;
+      let match;
+      while ((match = headerRegex.exec(content)) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const agDir = join6(process.cwd(), ".antigravity");
+    const globalAg = join6(homedir5(), ".antigravity");
+    return existsSync6(agDir) || existsSync6(globalAg);
+  }
+};
+
+// src/amp.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+var AmpAdapter = class {
+  type = "amp";
+  name = "Amp";
+  skillsDir = ".agents/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectAgents = join7(process.cwd(), ".agents");
+    const globalAgents = join7(homedir6(), ".config", "agents");
+    return existsSync7(projectAgents) || existsSync7(globalAgents);
+  }
+};
+
+// src/clawdbot.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
+var ClawdbotAdapter = class {
+  type = "clawdbot";
+  name = "Clawdbot";
+  skillsDir = "skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectSkills = join8(process.cwd(), "skills");
+    const globalClawdbot = join8(homedir7(), ".clawdbot");
+    return existsSync8(globalClawdbot) || existsSync8(projectSkills) && existsSync8(join8(process.cwd(), ".clawdbot"));
+  }
+};
+
+// src/droid.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir8 } from "os";
+var DroidAdapter = class {
+  type = "droid";
+  name = "Droid (Factory)";
+  skillsDir = ".factory/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectFactory = join9(process.cwd(), ".factory");
+    const globalFactory = join9(homedir8(), ".factory");
+    return existsSync9(projectFactory) || existsSync9(globalFactory);
+  }
+};
+
+// src/github-copilot.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir9 } from "os";
+var GitHubCopilotAdapter = class {
+  type = "github-copilot";
+  name = "GitHub Copilot";
+  skillsDir = ".github/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectGithub = join10(process.cwd(), ".github", "skills");
+    const globalCopilot = join10(homedir9(), ".copilot");
+    return existsSync10(projectGithub) || existsSync10(globalCopilot);
+  }
+};
+
+// src/goose.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir10 } from "os";
+var GooseAdapter = class {
+  type = "goose";
+  name = "Goose";
+  skillsDir = ".goose/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectGoose = join11(process.cwd(), ".goose");
+    const globalGoose = join11(homedir10(), ".config", "goose");
+    return existsSync11(projectGoose) || existsSync11(globalGoose);
+  }
+};
+
+// src/kilo.ts
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir11 } from "os";
+var KiloAdapter = class {
+  type = "kilo";
+  name = "Kilo Code";
+  skillsDir = ".kilocode/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectKilo = join12(process.cwd(), ".kilocode");
+    const globalKilo = join12(homedir11(), ".kilocode");
+    return existsSync12(projectKilo) || existsSync12(globalKilo);
+  }
+};
+
+// src/kiro-cli.ts
+import { existsSync as existsSync13 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir12 } from "os";
+var KiroCliAdapter = class {
+  type = "kiro-cli";
+  name = "Kiro CLI";
+  skillsDir = ".kiro/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>
+
+**Note for Kiro CLI users:** After installing skills, you need to manually add them to your custom agent's \`resources\` in \`.kiro/agents/<agent>.json\`:
+
+\`\`\`json
+{
+  "resources": [
+    "skill://.kiro/skills/**/SKILL.md"
+  ]
+}
+\`\`\``;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectKiro = join13(process.cwd(), ".kiro");
+    const globalKiro = join13(homedir12(), ".kiro");
+    return existsSync13(projectKiro) || existsSync13(globalKiro);
+  }
+};
+
+// src/roo.ts
+import { existsSync as existsSync14 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir13 } from "os";
+var RooAdapter = class {
+  type = "roo";
+  name = "Roo Code";
+  skillsDir = ".roo/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectRoo = join14(process.cwd(), ".roo");
+    const globalRoo = join14(homedir13(), ".roo");
+    return existsSync14(projectRoo) || existsSync14(globalRoo);
+  }
+};
+
+// src/trae.ts
+import { existsSync as existsSync15 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir14 } from "os";
+var TraeAdapter = class {
+  type = "trae";
+  name = "Trae";
+  skillsDir = ".trae/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectTrae = join15(process.cwd(), ".trae");
+    const globalTrae = join15(homedir14(), ".trae");
+    return existsSync15(projectTrae) || existsSync15(globalTrae);
+  }
+};
+
+// src/windsurf.ts
+import { existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir15 } from "os";
+var WindsurfAdapter = class {
+  type = "windsurf";
+  name = "Windsurf";
+  skillsDir = ".windsurf/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectWindsurf = join16(process.cwd(), ".windsurf");
+    const globalWindsurf = join16(homedir15(), ".codeium", "windsurf");
+    return existsSync16(projectWindsurf) || existsSync16(globalWindsurf);
+  }
+};
+
+// src/universal.ts
+import { existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
+var UniversalAdapter = class {
+  type = "universal";
+  name = "Universal (Any Agent)";
+  skillsDir = ".agent/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    const skillsList = enabledSkills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+    return `# Skills System
+
+<!-- SKILLKIT_SKILLS_START -->
+
+## Available Skills
+
+${skillsList}
+
+## How to Use Skills
+
+When a task matches one of the available skills, load it to get detailed instructions:
+
+\`\`\`bash
+skillkit read <skill-name>
+\`\`\`
+
+Or with npx:
+
+\`\`\`bash
+npx skillkit read <skill-name>
+\`\`\`
+
+## Skills Data
+
+<skills_system>
+<usage>
+Skills provide specialized capabilities and domain knowledge.
+- Invoke: \`skillkit read <skill-name>\`
+- Base directory provided in output for resolving resources
+- Only use skills listed below
+- Each invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+</skills_system>
+
+<!-- SKILLKIT_SKILLS_END -->
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    if (skillNames.length === 0) {
+      const listRegex = /^- \*\*([a-z0-9-]+)\*\*:/gm;
+      while ((match = listRegex.exec(content)) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const agentDir = join17(process.cwd(), ".agent");
+    const agentsMd = join17(process.cwd(), "AGENTS.md");
+    return existsSync17(agentDir) || existsSync17(agentsMd);
+  }
+};
+
+// src/index.ts
+var adapters = {
+  "claude-code": new ClaudeCodeAdapter(),
+  cursor: new CursorAdapter(),
+  codex: new CodexAdapter(),
+  "gemini-cli": new GeminiCliAdapter(),
+  opencode: new OpenCodeAdapter(),
+  antigravity: new AntigravityAdapter(),
+  amp: new AmpAdapter(),
+  clawdbot: new ClawdbotAdapter(),
+  droid: new DroidAdapter(),
+  "github-copilot": new GitHubCopilotAdapter(),
+  goose: new GooseAdapter(),
+  kilo: new KiloAdapter(),
+  "kiro-cli": new KiroCliAdapter(),
+  roo: new RooAdapter(),
+  trae: new TraeAdapter(),
+  windsurf: new WindsurfAdapter(),
+  universal: new UniversalAdapter()
+};
+function getAdapter(type) {
+  return adapters[type];
+}
+function getAllAdapters() {
+  return Object.values(adapters);
+}
+async function detectAgent() {
+  const checkOrder = [
+    "claude-code",
+    "cursor",
+    "codex",
+    "gemini-cli",
+    "opencode",
+    "antigravity",
+    "amp",
+    "clawdbot",
+    "droid",
+    "github-copilot",
+    "goose",
+    "kilo",
+    "kiro-cli",
+    "roo",
+    "trae",
+    "windsurf",
+    "universal"
+  ];
+  for (const type of checkOrder) {
+    const adapter = adapters[type];
+    if (await adapter.isDetected()) {
+      return type;
+    }
+  }
+  return "universal";
+}
+function getSkillsDir(type) {
+  return adapters[type].skillsDir;
+}
+function getConfigFile(type) {
+  return adapters[type].configFile;
+}
+export {
+  AmpAdapter,
+  AntigravityAdapter,
+  ClaudeCodeAdapter,
+  ClawdbotAdapter,
+  CodexAdapter,
+  CursorAdapter,
+  DroidAdapter,
+  GeminiCliAdapter,
+  GitHubCopilotAdapter,
+  GooseAdapter,
+  KiloAdapter,
+  KiroCliAdapter,
+  OpenCodeAdapter,
+  RooAdapter,
+  TraeAdapter,
+  UniversalAdapter,
+  WindsurfAdapter,
+  createSkillXml,
+  detectAgent,
+  escapeXml,
+  getAdapter,
+  getAllAdapters,
+  getConfigFile,
+  getSkillsDir
+};
+//# sourceMappingURL=index.js.map