skillkit 1.0.1 → 1.1.0

package/dist/cli.js

@@ -46,6 +46,16 @@ var init_types = __esm({
       "antigravity",
       "opencode",
       "gemini-cli",
+      "amp",
+      "clawdbot",
+      "droid",
+      "github-copilot",
+      "goose",
+      "kilo",
+      "kiro-cli",
+      "roo",
+      "trae",
+      "windsurf",
       "universal"
     ]);
     GitProvider = z.enum(["github", "gitlab", "bitbucket", "local"]);
@@ -97,7 +107,7 @@ var init_types = __esm({
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { join, basename } from "path";
 import { parse as parseYaml } from "yaml";
-function discoverSkills(dir) {
+function discoverSkillsInDir(dir) {
   const skills = [];
   if (!existsSync(dir)) {
     return skills;
@@ -116,6 +126,68 @@ function discoverSkills(dir) {
   }
   return skills;
 }
+function discoverSkillsRecursive(dir, seen, maxDepth = 5, currentDepth = 0) {
+  const skills = [];
+  if (currentDepth >= maxDepth || !existsSync(dir)) {
+    return skills;
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git") {
+        continue;
+      }
+      if (!entry.isDirectory()) continue;
+      const entryPath = join(dir, entry.name);
+      const skillMdPath = join(entryPath, "SKILL.md");
+      if (existsSync(skillMdPath)) {
+        const skill = parseSkill(entryPath);
+        if (skill && !seen.has(skill.name)) {
+          seen.add(skill.name);
+          skills.push(skill);
+        }
+      } else {
+        const subSkills = discoverSkillsRecursive(entryPath, seen, maxDepth, currentDepth + 1);
+        skills.push(...subSkills);
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+function discoverSkills(rootDir) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rootSkillMd = join(rootDir, "SKILL.md");
+  if (existsSync(rootSkillMd)) {
+    const skill = parseSkill(rootDir);
+    if (skill && !seen.has(skill.name)) {
+      seen.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  for (const searchPath of SKILL_DISCOVERY_PATHS) {
+    const fullPath = join(rootDir, searchPath);
+    if (existsSync(fullPath)) {
+      for (const skill of discoverSkillsInDir(fullPath)) {
+        if (!seen.has(skill.name)) {
+          seen.add(skill.name);
+          skills.push(skill);
+        }
+      }
+    }
+  }
+  for (const skill of discoverSkillsInDir(rootDir)) {
+    if (!seen.has(skill.name)) {
+      seen.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  if (skills.length === 0) {
+    skills.push(...discoverSkillsRecursive(rootDir, seen));
+  }
+  return skills;
+}
 function parseSkill(skillPath, location = "project") {
   const skillMdPath = join(skillPath, "SKILL.md");
   if (!existsSync(skillMdPath)) {
@@ -261,10 +333,35 @@ function isPathInside(child, parent) {
   const relative = child.replace(parent, "");
   return !relative.startsWith("..") && !relative.includes("/..");
 }
+var SKILL_DISCOVERY_PATHS;
 var init_skills = __esm({
   "src/core/skills.ts"() {
     "use strict";
     init_types();
+    SKILL_DISCOVERY_PATHS = [
+      "skills",
+      "skills/.curated",
+      "skills/.experimental",
+      "skills/.system",
+      ".agents/skills",
+      ".agent/skills",
+      ".claude/skills",
+      ".codex/skills",
+      ".cursor/skills",
+      ".factory/skills",
+      ".gemini/skills",
+      ".github/skills",
+      ".goose/skills",
+      ".kilocode/skills",
+      ".kiro/skills",
+      ".opencode/skills",
+      ".roo/skills",
+      ".trae/skills",
+      ".windsurf/skills",
+      ".clawdbot/skills",
+      ".antigravity/skills",
+      ".copilot/skills"
+    ];
   }
 });
 
@@ -591,7 +688,12 @@ var init_local = __esm({
           return {
             success: true,
             path: actualPath,
-            skills: skills.map((s) => s.name)
+            skills: skills.map((s) => s.name),
+            discoveredSkills: skills.map((s) => ({
+              name: s.name,
+              dirName: basename5(s.path),
+              path: s.path
+            }))
           };
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
@@ -664,17 +766,17 @@ import { Cli, Builtins } from "clipanion";
 
 // src/commands/install.ts
 init_providers();
-import { existsSync as existsSync14, mkdirSync as mkdirSync2, cpSync, rmSync as rmSync4 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync2, cpSync, rmSync as rmSync4 } from "fs";
+import { join as join24 } from "path";
 import chalk from "chalk";
 import ora from "ora";
 import { Command, Option } from "clipanion";
 
 // src/core/config.ts
 init_types();
-import { existsSync as existsSync13, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-import { join as join13, dirname } from "path";
-import { homedir as homedir7 } from "os";
+import { existsSync as existsSync23, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { join as join23, dirname } from "path";
+import { homedir as homedir17 } from "os";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 
 // src/agents/claude-code.ts
@@ -846,13 +948,665 @@ Skills are loaded on-demand to keep context clean. Only load skills when relevan
   }
   parseConfig(content) {
     const skillNames = [];
-    const tableRegex = /^\|\s*([a-z0-9-]+)\s*\|/gm;
+    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 = join8(process.cwd(), ".codex");
+    const globalCodex = join8(homedir3(), ".codex");
+    return existsSync8(codexDir) || existsSync8(globalCodex);
+  }
+};
+
+// src/agents/gemini-cli.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir4 } 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 = join9(process.cwd(), "GEMINI.md");
+    const geminiDir = join9(process.cwd(), ".gemini");
+    const globalGemini = join9(homedir4(), ".gemini");
+    return existsSync9(geminiMd) || existsSync9(geminiDir) || existsSync9(globalGemini);
+  }
+};
+
+// src/agents/opencode.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir5 } 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 = join10(process.cwd(), ".opencode");
+    const globalOpencode = join10(homedir5(), ".opencode");
+    return existsSync10(opencodeDir) || existsSync10(globalOpencode);
+  }
+};
+
+// src/agents/antigravity.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir6 } 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 = join11(process.cwd(), ".antigravity");
+    const globalAg = join11(homedir6(), ".antigravity");
+    return existsSync11(agDir) || existsSync11(globalAg);
+  }
+};
+
+// src/agents/amp.ts
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir7 } from "os";
+var AmpAdapter = class {
+  type = "amp";
+  name = "Amp";
+  skillsDir = ".agents/skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join12(homedir7(), ".config", "agents", "skills");
+  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 = join12(process.cwd(), ".agents");
+    const globalAgents = join12(homedir7(), ".config", "agents");
+    return existsSync12(projectAgents) || existsSync12(globalAgents);
+  }
+};
+
+// src/agents/clawdbot.ts
+import { existsSync as existsSync13 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir8 } from "os";
+var ClawdbotAdapter = class {
+  type = "clawdbot";
+  name = "Clawdbot";
+  skillsDir = "skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join13(homedir8(), ".clawdbot", "skills");
+  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 = join13(process.cwd(), "skills");
+    const globalClawdbot = join13(homedir8(), ".clawdbot");
+    return existsSync13(globalClawdbot) || existsSync13(projectSkills) && existsSync13(join13(process.cwd(), ".clawdbot"));
+  }
+};
+
+// src/agents/droid.ts
+import { existsSync as existsSync14 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir9 } from "os";
+var DroidAdapter = class {
+  type = "droid";
+  name = "Droid (Factory)";
+  skillsDir = ".factory/skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join14(homedir9(), ".factory", "skills");
+  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 = join14(process.cwd(), ".factory");
+    const globalFactory = join14(homedir9(), ".factory");
+    return existsSync14(projectFactory) || existsSync14(globalFactory);
+  }
+};
+
+// src/agents/github-copilot.ts
+import { existsSync as existsSync15 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir10 } from "os";
+var GitHubCopilotAdapter = class {
+  type = "github-copilot";
+  name = "GitHub Copilot";
+  skillsDir = ".github/skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join15(homedir10(), ".copilot", "skills");
+  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 = join15(process.cwd(), ".github", "skills");
+    const globalCopilot = join15(homedir10(), ".copilot");
+    return existsSync15(projectGithub) || existsSync15(globalCopilot);
+  }
+};
+
+// src/agents/goose.ts
+import { existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir11 } from "os";
+var GooseAdapter = class {
+  type = "goose";
+  name = "Goose";
+  skillsDir = ".goose/skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join16(homedir11(), ".config", "goose", "skills");
+  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 = join16(process.cwd(), ".goose");
+    const globalGoose = join16(homedir11(), ".config", "goose");
+    return existsSync16(projectGoose) || existsSync16(globalGoose);
+  }
+};
+
+// src/agents/kilo.ts
+import { existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir12 } from "os";
+var KiloAdapter = class {
+  type = "kilo";
+  name = "Kilo Code";
+  skillsDir = ".kilocode/skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join17(homedir12(), ".kilocode", "skills");
+  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 = join17(process.cwd(), ".kilocode");
+    const globalKilo = join17(homedir12(), ".kilocode");
+    return existsSync17(projectKilo) || existsSync17(globalKilo);
+  }
+};
+
+// src/agents/kiro-cli.ts
+import { existsSync as existsSync18 } from "fs";
+import { join as join18 } from "path";
+import { homedir as homedir13 } from "os";
+var KiroCliAdapter = class {
+  type = "kiro-cli";
+  name = "Kiro CLI";
+  skillsDir = ".kiro/skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join18(homedir13(), ".kiro", "skills");
+  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 = tableRegex.exec(content)) !== null) {
-      const name = match[1].trim();
-      if (name && name !== "Skill" && name !== "-------") {
-        skillNames.push(name);
-      }
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
     }
     return skillNames;
   }
@@ -860,76 +1614,62 @@ Skills are loaded on-demand to keep context clean. Only load skills when relevan
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const codexDir = join8(process.cwd(), ".codex");
-    const globalCodex = join8(homedir3(), ".codex");
-    return existsSync8(codexDir) || existsSync8(globalCodex);
+    const projectKiro = join18(process.cwd(), ".kiro");
+    const globalKiro = join18(homedir13(), ".kiro");
+    return existsSync18(projectKiro) || existsSync18(globalKiro);
   }
 };
 
-// src/agents/gemini-cli.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir4 } from "os";
-var GeminiCliAdapter = class {
-  type = "gemini-cli";
-  name = "Gemini CLI";
-  skillsDir = ".gemini/skills";
-  configFile = "GEMINI.md";
+// src/agents/roo.ts
+import { existsSync as existsSync19 } from "fs";
+import { join as join19 } from "path";
+import { homedir as homedir14 } from "os";
+var RooAdapter = class {
+  type = "roo";
+  name = "Roo Code";
+  skillsDir = ".roo/skills";
+  configFile = "AGENTS.md";
+  globalSkillsDir = join19(homedir14(), ".roo", "skills");
   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.
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
 
 ## Available Skills
 
-${enabledSkills.map((s) => `### ${s.name}
-${s.description}
+<!-- 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.
 
-Invoke: \`skillkit read ${s.name}\``).join("\n\n")}
+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/)
 
-## Skills Data
+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>
 
-\`\`\`json
-${JSON.stringify(skillsJson, null, 2)}
-\`\`\`
+<available_skills>
 
-## Usage Instructions
+${skillsXml}
 
-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
-`;
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
   }
   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());
-      }
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
     }
     return skillNames;
   }
@@ -937,48 +1677,55 @@ ${JSON.stringify(skillsJson, null, 2)}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const geminiMd = join9(process.cwd(), "GEMINI.md");
-    const geminiDir = join9(process.cwd(), ".gemini");
-    const globalGemini = join9(homedir4(), ".gemini");
-    return existsSync9(geminiMd) || existsSync9(geminiDir) || existsSync9(globalGemini);
+    const projectRoo = join19(process.cwd(), ".roo");
+    const globalRoo = join19(homedir14(), ".roo");
+    return existsSync19(projectRoo) || existsSync19(globalRoo);
   }
 };
 
-// src/agents/opencode.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir5 } from "os";
-var OpenCodeAdapter = class {
-  type = "opencode";
-  name = "OpenCode";
-  skillsDir = ".opencode/skills";
+// src/agents/trae.ts
+import { existsSync as existsSync20 } from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir15 } from "os";
+var TraeAdapter = class {
+  type = "trae";
+  name = "Trae";
+  skillsDir = ".trae/skills";
   configFile = "AGENTS.md";
+  globalSkillsDir = join20(homedir15(), ".trae", "skills");
   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
+    return `<skills_system priority="1">
 
-The following skills are available to help complete tasks:
+## Available Skills
 
-<skills>
-${skillsXml}
-</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
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
 
-When a task matches a skill's description:
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
 
-\`\`\`bash
-skillkit read <skill-name>
-\`\`\`
+<available_skills>
 
-This loads the skill's instructions into context.
+${skillsXml}
 
-<!-- SKILLKIT_END -->`;
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
   }
   parseConfig(content) {
     const skillNames = [];
@@ -993,67 +1740,62 @@ This loads the skill's instructions into context.
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const opencodeDir = join10(process.cwd(), ".opencode");
-    const globalOpencode = join10(homedir5(), ".opencode");
-    return existsSync10(opencodeDir) || existsSync10(globalOpencode);
+    const projectTrae = join20(process.cwd(), ".trae");
+    const globalTrae = join20(homedir15(), ".trae");
+    return existsSync20(projectTrae) || existsSync20(globalTrae);
   }
 };
 
-// src/agents/antigravity.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir6 } from "os";
-var AntigravityAdapter = class {
-  type = "antigravity";
-  name = "Antigravity";
-  skillsDir = ".antigravity/skills";
+// src/agents/windsurf.ts
+import { existsSync as existsSync21 } from "fs";
+import { join as join21 } from "path";
+import { homedir as homedir16 } from "os";
+var WindsurfAdapter = class {
+  type = "windsurf";
+  name = "Windsurf";
+  skillsDir = ".windsurf/skills";
   configFile = "AGENTS.md";
+  globalSkillsDir = join21(homedir16(), ".codeium", "windsurf", "skills");
   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}
--->
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
 
 ## Available Skills
 
-${enabledSkills.map((s) => `### ${s.name}
+<!-- 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.
 
-${s.description}
+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:** \`skillkit read ${s.name}\`
-`).join("\n")}
+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>
 
-## How Skills Work
+<available_skills>
 
-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
-`;
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
   }
   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());
-      }
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
     }
     return skillNames;
   }
@@ -1061,15 +1803,15 @@ ${s.description}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const agDir = join11(process.cwd(), ".antigravity");
-    const globalAg = join11(homedir6(), ".antigravity");
-    return existsSync11(agDir) || existsSync11(globalAg);
+    const projectWindsurf = join21(process.cwd(), ".windsurf");
+    const globalWindsurf = join21(homedir16(), ".codeium", "windsurf");
+    return existsSync21(projectWindsurf) || existsSync21(globalWindsurf);
   }
 };
 
 // src/agents/universal.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { join as join22 } from "path";
 var UniversalAdapter = class {
   type = "universal";
   name = "Universal (Any Agent)";
@@ -1144,9 +1886,9 @@ ${skillsXml}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const agentDir = join12(process.cwd(), ".agent");
-    const agentsMd = join12(process.cwd(), "AGENTS.md");
-    return existsSync12(agentDir) || existsSync12(agentsMd);
+    const agentDir = join22(process.cwd(), ".agent");
+    const agentsMd = join22(process.cwd(), "AGENTS.md");
+    return existsSync22(agentDir) || existsSync22(agentsMd);
   }
 };
 
@@ -1158,6 +1900,16 @@ var adapters = {
   "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) {
@@ -1174,6 +1926,16 @@ async function detectAgent() {
     "gemini-cli",
     "opencode",
     "antigravity",
+    "amp",
+    "clawdbot",
+    "droid",
+    "github-copilot",
+    "goose",
+    "kilo",
+    "kiro-cli",
+    "roo",
+    "trae",
+    "windsurf",
     "universal"
   ];
   for (const type of checkOrder) {
@@ -1189,15 +1951,15 @@ async function detectAgent() {
 var CONFIG_FILE = "skillkit.yaml";
 var METADATA_FILE = ".skillkit.json";
 function getProjectConfigPath() {
-  return join13(process.cwd(), CONFIG_FILE);
+  return join23(process.cwd(), CONFIG_FILE);
 }
 function getGlobalConfigPath() {
-  return join13(homedir7(), ".config", "skillkit", CONFIG_FILE);
+  return join23(homedir17(), ".config", "skillkit", CONFIG_FILE);
 }
 function loadConfig() {
   const projectPath = getProjectConfigPath();
   const globalPath = getGlobalConfigPath();
-  if (existsSync13(projectPath)) {
+  if (existsSync23(projectPath)) {
     try {
       const content = readFileSync2(projectPath, "utf-8");
       const data = parseYaml2(content);
@@ -1208,7 +1970,7 @@ function loadConfig() {
     } catch {
     }
   }
-  if (existsSync13(globalPath)) {
+  if (existsSync23(globalPath)) {
     try {
       const content = readFileSync2(globalPath, "utf-8");
       const data = parseYaml2(content);
@@ -1228,7 +1990,7 @@ function loadConfig() {
 function saveConfig(config, global = false) {
   const configPath = global ? getGlobalConfigPath() : getProjectConfigPath();
   const dir = dirname(configPath);
-  if (!existsSync13(dir)) {
+  if (!existsSync23(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   const content = stringifyYaml(config);
@@ -1238,32 +2000,32 @@ function getSearchDirs(agentType) {
   const type = agentType || loadConfig().agent;
   const adapter = getAdapter(type);
   const dirs = [];
-  dirs.push(join13(process.cwd(), adapter.skillsDir));
-  dirs.push(join13(process.cwd(), ".agent", "skills"));
-  dirs.push(join13(homedir7(), adapter.skillsDir));
-  dirs.push(join13(homedir7(), ".agent", "skills"));
+  dirs.push(join23(process.cwd(), adapter.skillsDir));
+  dirs.push(join23(process.cwd(), ".agent", "skills"));
+  dirs.push(join23(homedir17(), adapter.skillsDir));
+  dirs.push(join23(homedir17(), ".agent", "skills"));
   return dirs;
 }
 function getInstallDir(global = false, agentType) {
   const type = agentType || loadConfig().agent;
   const adapter = getAdapter(type);
   if (global) {
-    return join13(homedir7(), adapter.skillsDir);
+    return join23(homedir17(), adapter.skillsDir);
   }
-  return join13(process.cwd(), adapter.skillsDir);
+  return join23(process.cwd(), adapter.skillsDir);
 }
 function getAgentConfigPath(agentType) {
   const type = agentType || loadConfig().agent;
   const adapter = getAdapter(type);
-  return join13(process.cwd(), adapter.configFile);
+  return join23(process.cwd(), adapter.configFile);
 }
 function saveSkillMetadata(skillPath, metadata) {
-  const metadataPath = join13(skillPath, METADATA_FILE);
+  const metadataPath = join23(skillPath, METADATA_FILE);
   writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 function loadSkillMetadata(skillPath) {
-  const metadataPath = join13(skillPath, METADATA_FILE);
-  if (!existsSync13(metadataPath)) {
+  const metadataPath = join23(skillPath, METADATA_FILE);
+  if (!existsSync23(metadataPath)) {
     return null;
   }
   try {
@@ -1286,8 +2048,8 @@ function setSkillEnabled(skillPath, enabled) {
 async function initProject(agentType) {
   const type = agentType || await detectAgent();
   const adapter = getAdapter(type);
-  const skillsDir = join13(process.cwd(), adapter.skillsDir);
-  if (!existsSync13(skillsDir)) {
+  const skillsDir = join23(process.cwd(), adapter.skillsDir);
+  if (!existsSync23(skillsDir)) {
     mkdirSync(skillsDir, { recursive: true });
   }
   const config = {
@@ -1296,8 +2058,8 @@ async function initProject(agentType) {
     autoSync: true
   };
   saveConfig(config);
-  const agentConfigPath = join13(process.cwd(), adapter.configFile);
-  if (!existsSync13(agentConfigPath)) {
+  const agentConfigPath = join23(process.cwd(), adapter.configFile);
+  if (!existsSync23(agentConfigPath)) {
     writeFileSync(agentConfigPath, `# ${adapter.name} Configuration
 
 `, "utf-8");
@@ -1317,7 +2079,9 @@ var InstallCommand = class extends Command {
       ["Install specific skills (CI/CD)", "$0 install owner/repo --skills=pdf,xlsx"],
       ["Install all skills non-interactively", "$0 install owner/repo --all"],
       ["Install from local path", "$0 install ./my-skills"],
-      ["Install globally", "$0 install owner/repo --global"]
+      ["Install globally", "$0 install owner/repo --global"],
+      ["List available skills", "$0 install owner/repo --list"],
+      ["Install to specific agents", "$0 install owner/repo --agent claude-code --agent cursor"]
     ]
   });
   source = Option.String({ required: true });
@@ -1339,6 +2103,12 @@ var InstallCommand = class extends Command {
   provider = Option.String("--provider,-p", {
     description: "Force specific provider (github, gitlab, bitbucket)"
   });
+  list = Option.Boolean("--list,-l", false, {
+    description: "List available skills without installing"
+  });
+  agent = Option.Array("--agent", {
+    description: "Target specific agents (can specify multiple)"
+  });
   async execute() {
     const spinner = ora();
     try {
@@ -1364,6 +2134,25 @@ var InstallCommand = class extends Command {
       }
       spinner.succeed(`Found ${result.skills?.length || 0} skill(s)`);
       const discoveredSkills = result.discoveredSkills || [];
+      if (this.list) {
+        if (discoveredSkills.length === 0) {
+          console.log(chalk.yellow("\nNo skills found in this repository"));
+        } else {
+          console.log(chalk.cyan("\nAvailable skills:\n"));
+          for (const skill of discoveredSkills) {
+            console.log(`  ${chalk.green(skill.name)}`);
+          }
+          console.log();
+          console.log(chalk.dim(`Total: ${discoveredSkills.length} skill(s)`));
+          console.log(chalk.dim("\nTo install specific skills: skillkit install <source> --skills=skill1,skill2"));
+          console.log(chalk.dim("To install all skills: skillkit install <source> --all"));
+        }
+        const cleanupPath2 = result.tempRoot || result.path;
+        if (!isLocalPath(this.source) && cleanupPath2 && existsSync24(cleanupPath2)) {
+          rmSync4(cleanupPath2, { recursive: true, force: true });
+        }
+        return 0;
+      }
       let skillsToInstall = discoveredSkills;
       if (this.skills) {
         const requestedSkills = this.skills.split(",").map((s) => s.trim());
@@ -1389,53 +2178,78 @@ var InstallCommand = class extends Command {
         console.log(chalk.yellow("No skills to install"));
         return 0;
       }
-      const installDir = getInstallDir(this.global);
-      if (!existsSync14(installDir)) {
-        mkdirSync2(installDir, { recursive: true });
-      }
-      let installed = 0;
-      for (const skill of skillsToInstall) {
-        const skillName = skill.name;
-        const sourcePath = skill.path;
-        const targetPath = join14(installDir, skillName);
-        if (existsSync14(targetPath) && !this.force) {
-          console.log(chalk.yellow(`  Skipping ${skillName} (already exists, use --force to overwrite)`));
-          continue;
+      let targetAgents;
+      if (this.agent && this.agent.length > 0) {
+        targetAgents = this.agent;
+      } else {
+        const detectedAgent = await detectAgent();
+        targetAgents = [detectedAgent];
+      }
+      let totalInstalled = 0;
+      const installResults = [];
+      for (const agentType of targetAgents) {
+        const adapter = getAdapter(agentType);
+        const installDir = getInstallDir(this.global, agentType);
+        if (!existsSync24(installDir)) {
+          mkdirSync2(installDir, { recursive: true });
         }
-        const securityRoot = result.tempRoot || result.path;
-        if (!isPathInside(sourcePath, securityRoot)) {
-          console.log(chalk.red(`  Skipping ${skillName} (path traversal detected)`));
-          continue;
+        if (targetAgents.length > 1) {
+          console.log(chalk.cyan(`
+Installing to ${adapter.name}...`));
         }
-        spinner.start(`Installing ${skillName}...`);
-        try {
-          if (existsSync14(targetPath)) {
-            rmSync4(targetPath, { recursive: true, force: true });
+        let installed = 0;
+        for (const skill of skillsToInstall) {
+          const skillName = skill.name;
+          const sourcePath = skill.path;
+          const targetPath = join24(installDir, skillName);
+          if (existsSync24(targetPath) && !this.force) {
+            console.log(chalk.yellow(`  Skipping ${skillName} (already exists, use --force to overwrite)`));
+            continue;
+          }
+          const securityRoot = result.tempRoot || result.path;
+          if (!isPathInside(sourcePath, securityRoot)) {
+            console.log(chalk.red(`  Skipping ${skillName} (path traversal detected)`));
+            continue;
+          }
+          spinner.start(`Installing ${skillName}...`);
+          try {
+            if (existsSync24(targetPath)) {
+              rmSync4(targetPath, { recursive: true, force: true });
+            }
+            cpSync(sourcePath, targetPath, { recursive: true, dereference: true });
+            const metadata = {
+              name: skillName,
+              description: "",
+              source: this.source,
+              sourceType: providerAdapter.type,
+              subpath: skillName,
+              installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              enabled: true
+            };
+            saveSkillMetadata(targetPath, metadata);
+            spinner.succeed(chalk.green(`Installed ${skillName}`));
+            installed++;
+          } catch (error) {
+            spinner.fail(chalk.red(`Failed to install ${skillName}`));
+            console.error(chalk.dim(error instanceof Error ? error.message : String(error)));
           }
-          cpSync(sourcePath, targetPath, { recursive: true, dereference: true });
-          const metadata = {
-            name: skillName,
-            description: "",
-            source: this.source,
-            sourceType: providerAdapter.type,
-            subpath: skillName,
-            installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            enabled: true
-          };
-          saveSkillMetadata(targetPath, metadata);
-          spinner.succeed(chalk.green(`Installed ${skillName}`));
-          installed++;
-        } catch (error) {
-          spinner.fail(chalk.red(`Failed to install ${skillName}`));
-          console.error(chalk.dim(error instanceof Error ? error.message : String(error)));
         }
+        totalInstalled += installed;
+        installResults.push({ agent: adapter.name, dir: installDir, count: installed });
       }
       const cleanupPath = result.tempRoot || result.path;
-      if (!isLocalPath(this.source) && cleanupPath && existsSync14(cleanupPath)) {
+      if (!isLocalPath(this.source) && cleanupPath && existsSync24(cleanupPath)) {
         rmSync4(cleanupPath, { recursive: true, force: true });
       }
       console.log();
-      console.log(chalk.green(`Installed ${installed} skill(s) to ${installDir}`));
+      if (targetAgents.length > 1) {
+        console.log(chalk.green(`Installed ${totalInstalled} skill(s) across ${targetAgents.length} agents:`));
+        for (const r of installResults) {
+          console.log(chalk.dim(`  - ${r.agent}: ${r.count} skill(s) to ${r.dir}`));
+        }
+      } else {
+        console.log(chalk.green(`Installed ${totalInstalled} skill(s) to ${installResults[0]?.dir}`));
+      }
       if (!this.yes) {
         console.log(chalk.dim("\nRun `skillkit sync` to update your agent config"));
       }
@@ -1449,7 +2263,7 @@ var InstallCommand = class extends Command {
 };
 
 // src/commands/sync.ts
-import { existsSync as existsSync15, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 import chalk2 from "chalk";
 import { Command as Command2, Option as Option2 } from "clipanion";
@@ -1511,12 +2325,12 @@ var SyncCommand = class extends Command2 {
         return 0;
       }
       let existingContent = "";
-      if (existsSync15(outputPath)) {
+      if (existsSync25(outputPath)) {
         existingContent = readFileSync3(outputPath, "utf-8");
       }
       const newContent = updateConfigContent(existingContent, config, agentType);
       const dir = dirname2(outputPath);
-      if (!existsSync15(dir)) {
+      if (!existsSync25(dir)) {
         mkdirSync3(dir, { recursive: true });
       }
       writeFileSync2(outputPath, newContent, "utf-8");
@@ -1799,8 +2613,8 @@ var DisableCommand = class extends Command5 {
 };
 
 // src/commands/update.ts
-import { existsSync as existsSync16, rmSync as rmSync5, cpSync as cpSync2 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync26, rmSync as rmSync5, cpSync as cpSync2 } from "fs";
+import { join as join25 } from "path";
 import chalk6 from "chalk";
 import ora2 from "ora";
 import { Command as Command6, Option as Option6 } from "clipanion";
@@ -1852,14 +2666,14 @@ var UpdateCommand = class extends Command6 {
       spinner.start(`Updating ${skill.name}...`);
       try {
         if (isLocalPath(metadata.source)) {
-          const localPath = metadata.subpath ? join15(metadata.source, metadata.subpath) : metadata.source;
-          if (!existsSync16(localPath)) {
+          const localPath = metadata.subpath ? join25(metadata.source, metadata.subpath) : metadata.source;
+          if (!existsSync26(localPath)) {
             spinner.warn(chalk6.yellow(`${skill.name}: local source missing`));
             skipped++;
             continue;
           }
-          const skillMdPath = join15(localPath, "SKILL.md");
-          if (!existsSync16(skillMdPath)) {
+          const skillMdPath = join25(localPath, "SKILL.md");
+          if (!existsSync26(skillMdPath)) {
             spinner.warn(chalk6.yellow(`${skill.name}: no SKILL.md at source`));
             skipped++;
             continue;
@@ -1883,9 +2697,9 @@ var UpdateCommand = class extends Command6 {
             failed++;
             continue;
           }
-          const sourcePath = metadata.subpath ? join15(result.path, metadata.subpath) : result.path;
-          const skillMdPath = join15(sourcePath, "SKILL.md");
-          if (!existsSync16(skillMdPath)) {
+          const sourcePath = metadata.subpath ? join25(result.path, metadata.subpath) : result.path;
+          const skillMdPath = join25(sourcePath, "SKILL.md");
+          if (!existsSync26(skillMdPath)) {
             spinner.warn(chalk6.yellow(`${skill.name}: no SKILL.md in source`));
             rmSync5(result.path, { recursive: true, force: true });
             skipped++;
@@ -1916,7 +2730,7 @@ var UpdateCommand = class extends Command6 {
 };
 
 // src/commands/remove.ts
-import { existsSync as existsSync17, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync27, rmSync as rmSync6 } from "fs";
 import chalk7 from "chalk";
 import { Command as Command7, Option as Option7 } from "clipanion";
 init_skills();
@@ -1944,7 +2758,7 @@ var RemoveCommand = class extends Command7 {
         console.log(chalk7.yellow(`Skill not found: ${skillName}`));
         continue;
       }
-      if (!existsSync17(skill.path)) {
+      if (!existsSync27(skill.path)) {
         console.log(chalk7.yellow(`Path not found: ${skill.path}`));
         continue;
       }
@@ -2031,8 +2845,8 @@ var InitCommand = class extends Command8 {
 
 // src/commands/validate.ts
 init_skills();
-import { existsSync as existsSync18, readdirSync as readdirSync2 } from "fs";
-import { join as join16, basename as basename6 } from "path";
+import { existsSync as existsSync28, readdirSync as readdirSync2 } from "fs";
+import { join as join26, basename as basename6 } from "path";
 import chalk9 from "chalk";
 import { Command as Command9, Option as Option9 } from "clipanion";
 var ValidateCommand = class extends Command9 {
@@ -2050,7 +2864,7 @@ var ValidateCommand = class extends Command9 {
   });
   async execute() {
     const targetPath = this.skillPath;
-    if (!existsSync18(targetPath)) {
+    if (!existsSync28(targetPath)) {
       console.error(chalk9.red(`Path does not exist: ${targetPath}`));
       return 1;
     }
@@ -2059,8 +2873,8 @@ var ValidateCommand = class extends Command9 {
       const entries = readdirSync2(targetPath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const skillPath = join16(targetPath, entry.name);
-          if (existsSync18(join16(skillPath, "SKILL.md"))) {
+          const skillPath = join26(targetPath, entry.name);
+          if (existsSync28(join26(skillPath, "SKILL.md"))) {
             skillPaths.push(skillPath);
           }
         }
@@ -2102,6 +2916,114 @@ var ValidateCommand = class extends Command9 {
   }
 };
 
+// src/commands/create.ts
+import { existsSync as existsSync29, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join27 } from "path";
+import chalk10 from "chalk";
+import { Command as Command10, Option as Option10 } from "clipanion";
+var CreateCommand = class extends Command10 {
+  static paths = [["create"], ["new"]];
+  static usage = Command10.Usage({
+    description: "Create a new skill with proper structure",
+    examples: [
+      ["Create a new skill", "$0 create my-skill"],
+      ["Create with all optional directories", "$0 create my-skill --full"],
+      ["Create with scripts directory", "$0 create my-skill --scripts"]
+    ]
+  });
+  name = Option10.String({ required: true, name: "skill-name" });
+  full = Option10.Boolean("--full,-f", false, {
+    description: "Include all optional directories (references, scripts, assets)"
+  });
+  scripts = Option10.Boolean("--scripts", false, {
+    description: "Include scripts directory"
+  });
+  references = Option10.Boolean("--references", false, {
+    description: "Include references directory"
+  });
+  assets = Option10.Boolean("--assets", false, {
+    description: "Include assets directory"
+  });
+  directory = Option10.String("--dir,-d", {
+    description: "Parent directory to create skill in (default: current directory)"
+  });
+  async execute() {
+    const skillName = this.name.toLowerCase();
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(skillName)) {
+      console.error(chalk10.red("Invalid skill name"));
+      console.error(chalk10.dim("Must be lowercase alphanumeric with hyphens (e.g., my-skill)"));
+      return 1;
+    }
+    const parentDir = this.directory || process.cwd();
+    const skillDir = join27(parentDir, skillName);
+    if (existsSync29(skillDir)) {
+      console.error(chalk10.red(`Directory already exists: ${skillDir}`));
+      return 1;
+    }
+    try {
+      mkdirSync4(skillDir, { recursive: true });
+      const skillMd = generateSkillMd(skillName);
+      writeFileSync3(join27(skillDir, "SKILL.md"), skillMd);
+      if (this.full || this.references) {
+        const refsDir = join27(skillDir, "references");
+        mkdirSync4(refsDir);
+        writeFileSync3(join27(refsDir, ".gitkeep"), "");
+      }
+      if (this.full || this.scripts) {
+        const scriptsDir = join27(skillDir, "scripts");
+        mkdirSync4(scriptsDir);
+        writeFileSync3(join27(scriptsDir, ".gitkeep"), "");
+      }
+      if (this.full || this.assets) {
+        const assetsDir = join27(skillDir, "assets");
+        mkdirSync4(assetsDir);
+        writeFileSync3(join27(assetsDir, ".gitkeep"), "");
+      }
+      console.log(chalk10.green(`Created skill: ${skillName}`));
+      console.log();
+      console.log(chalk10.dim("Structure:"));
+      console.log(chalk10.dim(`  ${skillDir}/`));
+      console.log(chalk10.dim("  \u251C\u2500\u2500 SKILL.md"));
+      if (this.full || this.references) console.log(chalk10.dim("  \u251C\u2500\u2500 references/"));
+      if (this.full || this.scripts) console.log(chalk10.dim("  \u251C\u2500\u2500 scripts/"));
+      if (this.full || this.assets) console.log(chalk10.dim("  \u2514\u2500\u2500 assets/"));
+      console.log();
+      console.log(chalk10.cyan("Next steps:"));
+      console.log(chalk10.dim("  1. Edit SKILL.md with your instructions"));
+      console.log(chalk10.dim("  2. Validate: skillkit validate " + skillDir));
+      console.log(chalk10.dim("  3. Test: skillkit read " + skillName));
+      return 0;
+    } catch (error) {
+      console.error(chalk10.red("Failed to create skill"));
+      console.error(chalk10.dim(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+};
+function generateSkillMd(name) {
+  const title = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return `---
+name: ${name}
+description: Describe what this skill does and when to use it. Include trigger keywords.
+---
+
+# ${title}
+
+Instructions for the AI agent on how to use this skill.
+
+## When to Use
+
+- Scenario 1
+- Scenario 2
+
+## Steps
+
+1. First step
+2. Second step
+3. Third step
+`;
+}
+
 // src/cli.ts
 var cli = new Cli({
   binaryLabel: "skillkit",
@@ -2120,5 +3042,6 @@ cli.register(UpdateCommand);
 cli.register(RemoveCommand);
 cli.register(InitCommand);
 cli.register(ValidateCommand);
+cli.register(CreateCommand);
 cli.runExit(process.argv.slice(2));
 //# sourceMappingURL=cli.js.map