skillkit 1.0.3 → 1.2.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);
@@ -659,29 +761,6 @@ var init_providers = __esm({
   }
 });
 
-// src/cli.ts
-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 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 { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
-
-// src/agents/claude-code.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir2 } from "os";
-
 // src/agents/base.ts
 function createSkillXml(skill) {
   return `<skill>
@@ -693,20 +772,33 @@ function createSkillXml(skill) {
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
+var init_base2 = __esm({
+  "src/agents/base.ts"() {
+    "use strict";
+  }
+});
 
 // src/agents/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">
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir2 } from "os";
+var ClaudeCodeAdapter;
+var init_claude_code = __esm({
+  "src/agents/claude-code.ts"() {
+    "use strict";
+    init_base2();
+    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
 
@@ -733,43 +825,50 @@ ${skillsXml}
 <!-- 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 = join6(process.cwd(), ".claude");
+        const globalClaude = join6(homedir2(), ".claude");
+        const claudeMd = join6(process.cwd(), "CLAUDE.md");
+        return existsSync6(projectClaude) || existsSync6(globalClaude) || existsSync6(claudeMd);
+      }
+    };
   }
-  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 = join6(process.cwd(), ".claude");
-    const globalClaude = join6(homedir2(), ".claude");
-    const claudeMd = join6(process.cwd(), "CLAUDE.md");
-    return existsSync6(projectClaude) || existsSync6(globalClaude) || existsSync6(claudeMd);
-  }
-};
+});
 
 // src/agents/cursor.ts
 import { existsSync as existsSync7 } from "fs";
 import { join as join7 } 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
+var CursorAdapter;
+var init_cursor = __esm({
+  "src/agents/cursor.ts"() {
+    "use strict";
+    init_base2();
+    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.
 
@@ -790,42 +889,48 @@ The skill will provide detailed instructions for completing the task.
 ${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 = join7(process.cwd(), ".cursorrules");
+        const cursorDir = join7(process.cwd(), ".cursor");
+        return existsSync7(cursorRules) || existsSync7(cursorDir);
+      }
+    };
   }
-  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 = join7(process.cwd(), ".cursorrules");
-    const cursorDir = join7(process.cwd(), ".cursor");
-    return existsSync7(cursorRules) || existsSync7(cursorDir);
-  }
-};
+});
 
 // src/agents/codex.ts
 import { existsSync as existsSync8 } from "fs";
 import { join as join8 } from "path";
 import { homedir as homedir3 } 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
+var CodexAdapter;
+var init_codex = __esm({
+  "src/agents/codex.ts"() {
+    "use strict";
+    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.
 
@@ -843,50 +948,56 @@ 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 = join8(process.cwd(), ".codex");
-    const globalCodex = join8(homedir3(), ".codex");
-    return existsSync8(codexDir) || existsSync8(globalCodex);
+      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 = 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
+var GeminiCliAdapter;
+var init_gemini_cli = __esm({
+  "src/agents/gemini-cli.ts"() {
+    "use strict";
+    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.
 
@@ -909,57 +1020,64 @@ ${JSON.stringify(skillsJson, null, 2)}
 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);
-          });
+      }
+      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());
+          }
         }
-      } catch {
+        return skillNames;
       }
-    }
-    if (skillNames.length === 0) {
-      const headerRegex = /^### ([a-z0-9-]+)$/gm;
-      let match;
-      while ((match = headerRegex.exec(content)) !== null) {
-        skillNames.push(match[1].trim());
+      getInvokeCommand(skillName) {
+        return `skillkit read ${skillName}`;
       }
-    }
-    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);
+      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 -->
+var OpenCodeAdapter;
+var init_opencode = __esm({
+  "src/agents/opencode.ts"() {
+    "use strict";
+    init_base2();
+    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:
@@ -979,44 +1097,50 @@ 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);
+      }
+    };
   }
-  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}
+var AntigravityAdapter;
+var init_antigravity = __esm({
+  "src/agents/antigravity.ts"() {
+    "use strict";
+    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
+        return `# Antigravity Skills Configuration
 
 <!-- skills:
 ${skillsYaml}
@@ -1024,65 +1148,782 @@ ${skillsYaml}
 
 ## Available Skills
 
-${enabledSkills.map((s) => `### ${s.name}
+${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;
+var init_amp = __esm({
+  "src/agents/amp.ts"() {
+    "use strict";
+    init_base2();
+    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;
+var init_clawdbot = __esm({
+  "src/agents/clawdbot.ts"() {
+    "use strict";
+    init_base2();
+    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;
+var init_droid = __esm({
+  "src/agents/droid.ts"() {
+    "use strict";
+    init_base2();
+    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;
+var init_github_copilot = __esm({
+  "src/agents/github-copilot.ts"() {
+    "use strict";
+    init_base2();
+    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;
+var init_goose = __esm({
+  "src/agents/goose.ts"() {
+    "use strict";
+    init_base2();
+    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;
+var init_kilo = __esm({
+  "src/agents/kilo.ts"() {
+    "use strict";
+    init_base2();
+    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;
+var init_kiro_cli = __esm({
+  "src/agents/kiro-cli.ts"() {
+    "use strict";
+    init_base2();
+    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 = skillRegex.exec(content)) !== null) {
+          skillNames.push(match[1].trim());
+        }
+        return skillNames;
+      }
+      getInvokeCommand(skillName) {
+        return `skillkit read ${skillName}`;
+      }
+      async isDetected() {
+        const projectKiro = join18(process.cwd(), ".kiro");
+        const globalKiro = join18(homedir13(), ".kiro");
+        return existsSync18(projectKiro) || existsSync18(globalKiro);
+      }
+    };
+  }
+});
+
+// src/agents/roo.ts
+import { existsSync as existsSync19 } from "fs";
+import { join as join19 } from "path";
+import { homedir as homedir14 } from "os";
+var RooAdapter;
+var init_roo = __esm({
+  "src/agents/roo.ts"() {
+    "use strict";
+    init_base2();
+    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 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 = join19(process.cwd(), ".roo");
+        const globalRoo = join19(homedir14(), ".roo");
+        return existsSync19(projectRoo) || existsSync19(globalRoo);
+      }
+    };
+  }
+});
+
+// src/agents/trae.ts
+import { existsSync as existsSync20 } from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir15 } from "os";
+var TraeAdapter;
+var init_trae = __esm({
+  "src/agents/trae.ts"() {
+    "use strict";
+    init_base2();
+    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 `<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 = join20(process.cwd(), ".trae");
+        const globalTrae = join20(homedir15(), ".trae");
+        return existsSync20(projectTrae) || existsSync20(globalTrae);
+      }
+    };
+  }
+});
+
+// src/agents/windsurf.ts
+import { existsSync as existsSync21 } from "fs";
+import { join as join21 } from "path";
+import { homedir as homedir16 } from "os";
+var WindsurfAdapter;
+var init_windsurf = __esm({
+  "src/agents/windsurf.ts"() {
+    "use strict";
+    init_base2();
+    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 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>
 
-${s.description}
+<available_skills>
 
-**Usage:** \`skillkit read ${s.name}\`
-`).join("\n")}
+${skillsXml}
 
-## How Skills Work
+</available_skills>
+<!-- SKILLS_TABLE_END -->
 
-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());
+</skills_system>`;
       }
-    }
-    if (skillNames.length === 0) {
-      const headerRegex = /^### ([a-z0-9-]+)$/gm;
-      let match;
-      while ((match = headerRegex.exec(content)) !== null) {
-        skillNames.push(match[1].trim());
+      parseConfig(content) {
+        const skillNames = [];
+        const skillRegex = /<name>([^<]+)<\/name>/g;
+        let match;
+        while ((match = skillRegex.exec(content)) !== null) {
+          skillNames.push(match[1].trim());
+        }
+        return skillNames;
       }
-    }
-    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);
+      getInvokeCommand(skillName) {
+        return `skillkit read ${skillName}`;
+      }
+      async isDetected() {
+        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";
-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
+import { existsSync as existsSync22 } from "fs";
+import { join as join22 } from "path";
+var UniversalAdapter;
+var init_universal = __esm({
+  "src/agents/universal.ts"() {
+    "use strict";
+    init_base2();
+    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 -->
 
@@ -1124,42 +1965,35 @@ ${skillsXml}
 
 <!-- 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 = join12(process.cwd(), ".agent");
-    const agentsMd = join12(process.cwd(), "AGENTS.md");
-    return existsSync12(agentDir) || existsSync12(agentsMd);
+      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 = join22(process.cwd(), ".agent");
+        const agentsMd = join22(process.cwd(), "AGENTS.md");
+        return existsSync22(agentDir) || existsSync22(agentsMd);
+      }
+    };
   }
-};
+});
 
 // src/agents/index.ts
-var adapters = {
-  "claude-code": new ClaudeCodeAdapter(),
-  cursor: new CursorAdapter(),
-  codex: new CodexAdapter(),
-  "gemini-cli": new GeminiCliAdapter(),
-  opencode: new OpenCodeAdapter(),
-  antigravity: new AntigravityAdapter(),
-  universal: new UniversalAdapter()
-};
 function getAdapter(type) {
   return adapters[type];
 }
@@ -1174,6 +2008,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) {
@@ -1184,20 +2028,82 @@ async function detectAgent() {
   }
   return "universal";
 }
+var adapters;
+var init_agents = __esm({
+  "src/agents/index.ts"() {
+    "use strict";
+    init_claude_code();
+    init_cursor();
+    init_codex();
+    init_gemini_cli();
+    init_opencode();
+    init_antigravity();
+    init_amp();
+    init_clawdbot();
+    init_droid();
+    init_github_copilot();
+    init_goose();
+    init_kilo();
+    init_kiro_cli();
+    init_roo();
+    init_trae();
+    init_windsurf();
+    init_universal();
+    init_base2();
+    init_claude_code();
+    init_cursor();
+    init_codex();
+    init_gemini_cli();
+    init_opencode();
+    init_antigravity();
+    init_amp();
+    init_clawdbot();
+    init_droid();
+    init_github_copilot();
+    init_goose();
+    init_kilo();
+    init_kiro_cli();
+    init_roo();
+    init_trae();
+    init_windsurf();
+    init_universal();
+    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()
+    };
+  }
+});
 
 // src/core/config.ts
-var CONFIG_FILE = "skillkit.yaml";
-var METADATA_FILE = ".skillkit.json";
+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";
 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 +2114,7 @@ function loadConfig() {
     } catch {
     }
   }
-  if (existsSync13(globalPath)) {
+  if (existsSync23(globalPath)) {
     try {
       const content = readFileSync2(globalPath, "utf-8");
       const data = parseYaml2(content);
@@ -1228,7 +2134,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 +2144,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 +2192,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,16 +2202,825 @@ 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");
   }
 }
+var CONFIG_FILE, METADATA_FILE;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    init_types();
+    init_agents();
+    CONFIG_FILE = "skillkit.yaml";
+    METADATA_FILE = ".skillkit.json";
+  }
+});
+
+// src/tui/theme.ts
+import chalk11 from "chalk";
+var colors, symbols, logo;
+var init_theme = __esm({
+  "src/tui/theme.ts"() {
+    "use strict";
+    colors = {
+      primary: "white",
+      secondary: "white",
+      secondaryDim: "gray",
+      success: "white",
+      danger: "white",
+      warning: "white",
+      background: "bgBlack",
+      borderDim: "gray"
+    };
+    symbols = {
+      pointer: chalk11.white("\u276F"),
+      bullet: "\u25CF",
+      checkboxOn: chalk11.white("\u2714"),
+      checkboxOff: chalk11.dim("\u2716"),
+      check: chalk11.white("\u2713"),
+      star: "\u2605",
+      spinner: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+    };
+    logo = `
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2557     \u2588\u2588\u2557     \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551   \u2588\u2588\u2551   
+\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551   
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551   
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D   \u255A\u2550\u255D   
+`;
+  }
+});
+
+// src/tui/components/Sidebar.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Sidebar({ screen }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: 14, borderStyle: "single", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: colors.primary, children: "SkillKit" }),
+    NAV.slice(0, 2).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
+      screen === item.id ? symbols.bullet : " ",
+      item.label
+    ] }, item.id)),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    NAV.slice(2).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
+      screen === item.id ? symbols.bullet : " ",
+      item.label
+    ] }, item.id)),
+    /* @__PURE__ */ jsx(Box, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "? Help" }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "q Quit" })
+  ] });
+}
+var NAV;
+var init_Sidebar = __esm({
+  "src/tui/components/Sidebar.tsx"() {
+    "use strict";
+    init_theme();
+    NAV = [
+      { id: "home", label: "Home" },
+      { id: "browse", label: "Browse" },
+      { id: "installed", label: "List" },
+      { id: "sync", label: "Sync" },
+      { id: "settings", label: "Config" }
+    ];
+  }
+});
+
+// src/tui/screens/Home.tsx
+import { useState, useEffect } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function scramble(target, progress) {
+  return target.split("\n").map((line) => {
+    return line.split("").map((char, i) => {
+      if (char === " ") return char;
+      if (progress > i / line.length * 100) return char;
+      return CHARS[Math.floor(Math.random() * CHARS.length)];
+    }).join("");
+  }).join("\n");
+}
+function Home({ cols = 80, rows = 24 }) {
+  const [progress, setProgress] = useState(0);
+  const [display, setDisplay] = useState("");
+  const useLogo = cols < 80 ? logoSmall : logo;
+  useEffect(() => {
+    if (progress >= 100) {
+      setDisplay(useLogo);
+      return;
+    }
+    const t = setInterval(() => {
+      setProgress((p) => {
+        const next = p + 12;
+        setDisplay(scramble(useLogo, next));
+        return next;
+      });
+    }, 35);
+    return () => clearInterval(t);
+  }, [progress, useLogo]);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { color: colors.primary, children: display || useLogo }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { children: "Manage AI agent skills from your terminal." }) }),
+    /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Quick Actions:" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  [b] Browse skills marketplace" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  [l] View installed skills" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  [s] Sync skills across agents" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  [,] Settings" })
+    ] }),
+    rows >= 18 && /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Navigation:" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  \u2191\u2193    Navigate lists" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  Enter Select / Confirm" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  Esc   Go back / Home" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  q     Quit" })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "v1.1.0 - Works with 17 AI agents" }) })
+  ] });
+}
+var CHARS, logoSmall;
+var init_Home = __esm({
+  "src/tui/screens/Home.tsx"() {
+    "use strict";
+    init_theme();
+    CHARS = "01\u2588\u2593\u2592\u2591\u2554\u2557\u255A\u255D\u2551\u2550";
+    logoSmall = `
+\u2554\u2550\u2557\u2566\u2554\u2550\u2566\u2566  \u2566  \u2566\u2554\u2550\u2566\u2554\u2566\u2557
+\u255A\u2550\u2557\u2560\u2569\u2557\u2551\u2551  \u2551  \u2560\u2569\u2557\u2551 \u2551 
+\u255A\u2550\u255D\u2569 \u2569\u2569\u2569\u2550\u255D\u2569\u2550\u255D\u2569 \u2569\u2569 \u2569 
+`.trim();
+  }
+});
+
+// src/tui/hooks/useMarketplace.ts
+import { useState as useState2, useCallback, useEffect as useEffect2 } from "react";
+function useMarketplace() {
+  const [allSkills, setAllSkills] = useState2([]);
+  const [filteredSkills, setFilteredSkills] = useState2([]);
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [currentRepo, setCurrentRepo] = useState2(null);
+  const [fetchedRepos, setFetchedRepos] = useState2(/* @__PURE__ */ new Set());
+  const fetchRepo = useCallback(async (source) => {
+    if (fetchedRepos.has(source)) return;
+    setLoading(true);
+    setError(null);
+    setCurrentRepo(source);
+    try {
+      const provider = detectProvider(source);
+      if (!provider) {
+        throw new Error(`Could not detect provider for: ${source}`);
+      }
+      const result = await provider.clone(source, "", { depth: 1 });
+      if (!result.success || !result.discoveredSkills) {
+        throw new Error(result.error || "Failed to fetch skills");
+      }
+      const repoName = POPULAR_REPOS.find((r) => r.source === source)?.name || source;
+      const newSkills = result.discoveredSkills.map((skill) => ({
+        name: skill.name,
+        source,
+        repoName,
+        description: void 0
+      }));
+      setAllSkills((prev) => {
+        const updated = [...prev, ...newSkills];
+        return updated.sort((a, b) => a.name.localeCompare(b.name));
+      });
+      setFetchedRepos((prev) => /* @__PURE__ */ new Set([...prev, source]));
+      if (result.tempRoot) {
+        const { rmSync: rmSync8 } = await import("fs");
+        rmSync8(result.tempRoot, { recursive: true, force: true });
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch repository");
+    } finally {
+      setLoading(false);
+      setCurrentRepo(null);
+    }
+  }, [fetchedRepos]);
+  const fetchAllRepos = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    for (const repo of POPULAR_REPOS) {
+      if (!fetchedRepos.has(repo.source)) {
+        setCurrentRepo(repo.source);
+        try {
+          await fetchRepo(repo.source);
+        } catch {
+        }
+      }
+    }
+    setLoading(false);
+    setCurrentRepo(null);
+  }, [fetchRepo, fetchedRepos]);
+  const search = useCallback((query) => {
+    if (!query.trim()) {
+      setFilteredSkills(allSkills);
+    } else {
+      const lowerQuery = query.toLowerCase();
+      setFilteredSkills(
+        allSkills.filter(
+          (s) => s.name.toLowerCase().includes(lowerQuery) || s.source.toLowerCase().includes(lowerQuery) || s.repoName.toLowerCase().includes(lowerQuery) || s.description?.toLowerCase().includes(lowerQuery)
+        )
+      );
+    }
+  }, [allSkills]);
+  const refresh = useCallback(() => {
+    setFetchedRepos(/* @__PURE__ */ new Set());
+    setAllSkills([]);
+    setFilteredSkills([]);
+  }, []);
+  useEffect2(() => {
+    setFilteredSkills(allSkills);
+  }, [allSkills]);
+  const skills = filteredSkills.map((s) => ({
+    name: s.name,
+    description: s.description || s.repoName,
+    source: s.source
+  }));
+  return {
+    skills,
+    loading,
+    error,
+    totalCount: allSkills.length,
+    repos: POPULAR_REPOS,
+    currentRepo,
+    refresh,
+    search,
+    fetchRepo,
+    fetchAllRepos
+  };
+}
+var POPULAR_REPOS;
+var init_useMarketplace = __esm({
+  "src/tui/hooks/useMarketplace.ts"() {
+    "use strict";
+    init_providers();
+    POPULAR_REPOS = [
+      { source: "anthropics/skills", name: "Anthropic Official" },
+      { source: "vercel-labs/agent-skills", name: "Vercel Labs" },
+      { source: "expo/skills", name: "Expo / React Native" },
+      { source: "remotion-dev/skills", name: "Remotion Video" },
+      { source: "ComposioHQ/awesome-claude-skills", name: "Composio Awesome" },
+      { source: "travisvn/awesome-claude-skills", name: "Travis Awesome" },
+      { source: "mhattingpete/claude-skills-marketplace", name: "Skills Marketplace" },
+      { source: "coreyhaines31/marketingskills", name: "Marketing Skills" },
+      { source: "obra/superpowers", name: "Superpowers TDD" },
+      { source: "softaworks/agent-toolkit", name: "Softaworks Toolkit" },
+      { source: "wshobson/agents", name: "Dev Patterns" },
+      { source: "langgenius/dify", name: "Dify Frontend" },
+      { source: "trailofbits/skills", name: "Trail of Bits Security" },
+      { source: "better-auth/skills", name: "Better Auth" },
+      { source: "onmax/nuxt-skills", name: "Nuxt / Vue" },
+      { source: "hyf0/vue-skills", name: "Vue Best Practices" },
+      { source: "jezweb/claude-skills", name: "Cloudflare / TanStack" },
+      { source: "elysiajs/skills", name: "ElysiaJS / Bun" },
+      { source: "kadajett/agent-nestjs-skills", name: "NestJS" },
+      { source: "callstackincubator/agent-skills", name: "React Native" },
+      { source: "cloudai-x/threejs-skills", name: "Three.js" },
+      { source: "emalorenzo/three-agent-skills", name: "Three.js Advanced" },
+      { source: "dimillian/skills", name: "SwiftUI iOS" },
+      { source: "stripe/ai", name: "Stripe Payments" },
+      { source: "waynesutton/convexskills", name: "Convex Backend" },
+      { source: "kepano/obsidian-skills", name: "Obsidian Notes" },
+      { source: "jimliu/baoyu-skills", name: "Baoyu Tools" },
+      { source: "giuseppe-trisciuoglio/developer-kit", name: "Shadcn / Radix" },
+      { source: "openrouterteam/agent-skills", name: "OpenRouter SDK" },
+      { source: "intellectronica/agent-skills", name: "Context7" },
+      { source: "boristane/agent-skills", name: "Logging Patterns" },
+      { source: "f/awesome-chatgpt-prompts", name: "ChatGPT Prompts" },
+      { source: "rohitg00/openskills", name: "OpenSkills" }
+    ];
+  }
+});
+
+// src/tui/screens/Browse.tsx
+import { useState as useState3 } from "react";
+import { existsSync as existsSync30, mkdirSync as mkdirSync5, cpSync as cpSync3, rmSync as rmSync7 } from "fs";
+import { join as join28 } from "path";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Browse({ rows = 24 }) {
+  const { repos, skills, loading, currentRepo, fetchRepo, fetchAllRepos } = useMarketplace();
+  const [view, setView] = useState3("repos");
+  const [sel, setSel] = useState3(0);
+  const [installing, setInstalling] = useState3(null);
+  const [message, setMessage] = useState3(null);
+  const [selectedSkill, setSelectedSkill] = useState3(null);
+  const [agents, setAgents] = useState3([]);
+  const items = view === "repos" ? repos : view === "skills" ? skills : agents;
+  const maxVisible = Math.max(5, rows - 8);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), items.length - maxVisible));
+  const visible = items.slice(start, start + maxVisible);
+  const showAgentSelection = async (skillName, source) => {
+    setSelectedSkill({ name: skillName, source });
+    const adapters2 = getAllAdapters();
+    const agentList = [];
+    for (const a of adapters2) {
+      agentList.push({
+        type: a.type,
+        name: a.name,
+        detected: await a.isDetected()
+      });
+    }
+    setAgents(agentList);
+    setView("agents");
+    setSel(0);
+  };
+  const installSkill = async (skillName, source, agentType) => {
+    setInstalling(skillName);
+    setMessage(null);
+    try {
+      const provider = detectProvider(source);
+      if (!provider) {
+        setMessage(`Error: Unknown provider for ${source}`);
+        setInstalling(null);
+        return;
+      }
+      const result = await provider.clone(source, "", { depth: 1 });
+      if (!result.success || !result.discoveredSkills) {
+        setMessage(`Error: ${result.error || "Failed to fetch"}`);
+        setInstalling(null);
+        return;
+      }
+      const skill = result.discoveredSkills.find((s) => s.name === skillName);
+      if (!skill) {
+        setMessage(`Error: Skill ${skillName} not found`);
+        setInstalling(null);
+        return;
+      }
+      const targetAgentType = agentType || await detectAgent();
+      const adapter = getAdapter(targetAgentType);
+      const installDir = getInstallDir(false, targetAgentType);
+      if (!existsSync30(installDir)) {
+        mkdirSync5(installDir, { recursive: true });
+      }
+      const targetPath = join28(installDir, skillName);
+      if (existsSync30(targetPath)) {
+        rmSync7(targetPath, { recursive: true, force: true });
+      }
+      cpSync3(skill.path, targetPath, { recursive: true, dereference: true });
+      const metadata = {
+        name: skillName,
+        description: "",
+        source,
+        sourceType: provider.type,
+        subpath: skillName,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        enabled: true
+      };
+      saveSkillMetadata(targetPath, metadata);
+      if (result.tempRoot) {
+        rmSync7(result.tempRoot, { recursive: true, force: true });
+      }
+      setMessage(`\u2713 Installed ${skillName} to ${adapter.name}`);
+      if (!agentType) {
+        setView("skills");
+      }
+    } catch (err) {
+      setMessage(`Error: ${err instanceof Error ? err.message : "Unknown error"}`);
+    } finally {
+      setInstalling(null);
+      if (agentType) {
+        setSelectedSkill(null);
+      }
+    }
+  };
+  useInput((input, key) => {
+    if (loading || installing) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(items.length - 1, i + 1));
+    else if (key.return) {
+      if (view === "repos" && repos[sel]) {
+        fetchRepo(repos[sel].source);
+        setView("skills");
+        setSel(0);
+        setMessage(null);
+      } else if (view === "skills" && skills[sel]?.source) {
+        installSkill(skills[sel].name, skills[sel].source);
+      } else if (view === "agents" && agents[sel]) {
+        installSkill(selectedSkill.name, selectedSkill.source, agents[sel].type);
+      }
+    } else if (input === "m" && view === "skills" && skills[sel]?.source) {
+      showAgentSelection(skills[sel].name, skills[sel].source);
+    } else if (input === "r") {
+      if (view === "skills") {
+        setView("repos");
+        setSel(0);
+        setMessage(null);
+      } else if (view === "agents") {
+        setView("skills");
+        setSel(0);
+      }
+    } else if (input === "a" && view === "repos") {
+      fetchAllRepos();
+      setView("skills");
+      setSel(0);
+    }
+  });
+  if (view === "agents") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: colors.primary, children: "SELECT AGENT" }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        'Install "',
+        selectedSkill?.name,
+        '" to which agent?'
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "(All agents supported - directory created if needed)" }),
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, flexDirection: "column", children: visible.map((agent, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        const a = agent;
+        const status = a.detected ? "(ready)" : "(will create)";
+        return /* @__PURE__ */ jsxs3(Text3, { inverse: isSel, children: [
+          isSel ? symbols.pointer : " ",
+          " ",
+          a.name.padEnd(20),
+          " ",
+          /* @__PURE__ */ jsx3(Text3, { color: colors.secondaryDim, children: status })
+        ] }, a.type);
+      }) }),
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Enter=install to selected agent  r=back  q=quit" }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, color: colors.primary, children: view === "repos" ? "REPOSITORIES" : "SKILLS" }),
+    loading && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "Loading ",
+      currentRepo,
+      "..."
+    ] }),
+    installing && /* @__PURE__ */ jsxs3(Text3, { children: [
+      "Installing ",
+      installing,
+      "..."
+    ] }),
+    message && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: message }),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      items.length,
+      " items"
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "  \u2191 ",
+        start,
+        " more"
+      ] }),
+      visible.map((item, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        const name = view === "repos" ? item.name : item.name;
+        const src = view === "repos" ? item.source : item.source || "";
+        return /* @__PURE__ */ jsxs3(Text3, { inverse: isSel, children: [
+          isSel ? symbols.pointer : " ",
+          name.padEnd(25),
+          " ",
+          /* @__PURE__ */ jsx3(Text3, { color: colors.secondaryDim, children: src })
+        ] }, src + name);
+      }),
+      start + maxVisible < items.length && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "  \u2193 ",
+        items.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: view === "repos" ? "Enter=fetch  a=all  q=quit" : "Enter=quick install  m=choose agent  r=back  q=quit" }) })
+  ] });
+}
+var init_Browse = __esm({
+  "src/tui/screens/Browse.tsx"() {
+    "use strict";
+    init_theme();
+    init_useMarketplace();
+    init_providers();
+    init_agents();
+    init_config();
+  }
+});
+
+// src/tui/hooks/useSkills.ts
+import { useState as useState4, useEffect as useEffect3 } from "react";
+function useSkills() {
+  const [skills, setSkills] = useState4([]);
+  const [loading, setLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const refresh = () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const searchDirs = getSearchDirs();
+      const foundSkills = findAllSkills(searchDirs);
+      const skillItems = foundSkills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        source: s.metadata?.source,
+        enabled: s.enabled
+      }));
+      setSkills(skillItems);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load skills");
+    } finally {
+      setLoading(false);
+    }
+  };
+  const remove = async (name) => {
+    const { rmSync: rmSync8 } = await import("fs");
+    const foundSkill = skills.find((s) => s.name === name);
+    if (foundSkill) {
+      const searchDirs = getSearchDirs();
+      const allSkills = findAllSkills(searchDirs);
+      const skill = allSkills.find((s) => s.name === name);
+      if (skill) {
+        rmSync8(skill.path, { recursive: true, force: true });
+        refresh();
+      }
+    }
+  };
+  useEffect3(() => {
+    refresh();
+  }, []);
+  return { skills, loading, error, refresh, remove };
+}
+var init_useSkills = __esm({
+  "src/tui/hooks/useSkills.ts"() {
+    "use strict";
+    init_config();
+    init_skills();
+  }
+});
+
+// src/tui/screens/Installed.tsx
+import { useState as useState5 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function Installed({ rows = 24 }) {
+  const { skills, loading, refresh, remove } = useSkills();
+  const [sel, setSel] = useState5(0);
+  const maxVisible = Math.max(5, rows - 6);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), skills.length - maxVisible));
+  const visible = skills.slice(start, start + maxVisible);
+  useInput2((input, key) => {
+    if (loading) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(skills.length - 1, i + 1));
+    else if (input === "r") refresh();
+    else if (input === "d" && skills[sel]) remove(skills[sel].name);
+  });
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: colors.primary, children: "INSTALLED SKILLS" }),
+    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      skills.length,
+      " skills"
+    ] }),
+    loading && /* @__PURE__ */ jsx4(Text4, { children: "Loading..." }),
+    !loading && skills.length === 0 && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "No skills installed. Press b to browse." }),
+    !loading && skills.length > 0 && /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "  \u2191 ",
+        start,
+        " more"
+      ] }),
+      visible.map((skill, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        return /* @__PURE__ */ jsxs4(Text4, { inverse: isSel, children: [
+          isSel ? symbols.pointer : " ",
+          skill.name.padEnd(30),
+          " ",
+          skill.source && /* @__PURE__ */ jsx4(Text4, { color: colors.secondaryDim, children: skill.source })
+        ] }, skill.name);
+      }),
+      start + maxVisible < skills.length && /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "  \u2193 ",
+        skills.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "r=refresh  d=delete  q=quit" }) })
+  ] });
+}
+var init_Installed = __esm({
+  "src/tui/screens/Installed.tsx"() {
+    "use strict";
+    init_theme();
+    init_useSkills();
+  }
+});
+
+// src/tui/screens/Sync.tsx
+import { useState as useState6, useEffect as useEffect4 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function Sync({ rows = 24 }) {
+  const [agents, setAgents] = useState6([]);
+  const [loading, setLoading] = useState6(true);
+  const [sel, setSel] = useState6(0);
+  const [syncing, setSyncing] = useState6(false);
+  const maxVisible = Math.max(5, rows - 6);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), agents.length - maxVisible));
+  const visible = agents.slice(start, start + maxVisible);
+  useEffect4(() => {
+    (async () => {
+      const adapters2 = getAllAdapters();
+      const s = [];
+      for (const a of adapters2) {
+        s.push({ name: a.name, type: a.type, detected: await a.isDetected() });
+      }
+      setAgents(s);
+      setLoading(false);
+    })();
+  }, []);
+  useInput3((input, key) => {
+    if (loading || syncing) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(agents.length - 1, i + 1));
+    else if (input === "a") {
+      setSyncing(true);
+      setTimeout(() => setSyncing(false), 500);
+    } else if (key.return && agents[sel]?.detected) {
+      setSyncing(true);
+      setTimeout(() => setSyncing(false), 300);
+    }
+  });
+  const detected = agents.filter((a) => a.detected).length;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, color: colors.primary, children: "SYNC SKILLS" }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      detected,
+      "/",
+      agents.length,
+      " agents detected"
+    ] }),
+    loading && /* @__PURE__ */ jsx5(Text5, { children: "Detecting agents..." }),
+    syncing && /* @__PURE__ */ jsx5(Text5, { children: "Syncing..." }),
+    !loading && !syncing && /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "  \u2191 ",
+        start,
+        " more"
+      ] }),
+      visible.map((agent, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        return /* @__PURE__ */ jsxs5(Text5, { inverse: isSel, dimColor: !agent.detected, children: [
+          isSel ? symbols.pointer : " ",
+          agent.detected ? symbols.checkboxOn : symbols.checkboxOff,
+          " ",
+          agent.name.padEnd(20),
+          " ",
+          agent.detected ? "Ready" : "N/A"
+        ] }, agent.type);
+      }),
+      start + maxVisible < agents.length && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "  \u2193 ",
+        agents.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Enter=sync  a=all  q=quit" }) })
+  ] });
+}
+var init_Sync = __esm({
+  "src/tui/screens/Sync.tsx"() {
+    "use strict";
+    init_theme();
+    init_agents();
+  }
+});
+
+// src/tui/screens/Settings.tsx
+import { useState as useState7 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput4 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function Settings({}) {
+  const [sel, setSel] = useState7(0);
+  useInput4((_, key) => {
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(SETTINGS.length - 1, i + 1));
+  });
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, color: colors.primary, children: "SETTINGS" }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Configure SkillKit" }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, flexDirection: "column", children: SETTINGS.map((s, i) => {
+      const isSel = i === sel;
+      return /* @__PURE__ */ jsxs6(Text6, { inverse: isSel, children: [
+        isSel ? symbols.pointer : " ",
+        s.label.padEnd(16),
+        " ",
+        /* @__PURE__ */ jsx6(Text6, { color: colors.secondaryDim, children: s.value })
+      ] }, s.id);
+    }) }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Enter=edit  q=quit" }) })
+  ] });
+}
+var SETTINGS;
+var init_Settings = __esm({
+  "src/tui/screens/Settings.tsx"() {
+    "use strict";
+    init_theme();
+    SETTINGS = [
+      { id: "agent", label: "Default Agent", value: "auto-detect" },
+      { id: "sync", label: "Auto Sync", value: "disabled" },
+      { id: "cache", label: "Cache Dir", value: "~/.skillkit/cache" }
+    ];
+  }
+});
+
+// src/tui/App.tsx
+import { useState as useState8 } from "react";
+import { Box as Box7, Text as Text7, useInput as useInput5, useApp, useStdout } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function App() {
+  const [screen, setScreen] = useState8("home");
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const cols = stdout?.columns || 80;
+  const rows = stdout?.rows || 24;
+  const showSidebar = cols >= 70;
+  useInput5((input, key) => {
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (key.escape) {
+      setScreen("home");
+      return;
+    }
+    if (input === "h") setScreen("home");
+    if (input === "b") setScreen("browse");
+    if (input === "l") setScreen("installed");
+    if (input === "s") setScreen("sync");
+    if (input === ",") setScreen("settings");
+  });
+  const renderScreen = () => {
+    switch (screen) {
+      case "home":
+        return /* @__PURE__ */ jsx7(Home, { onNavigate: setScreen, cols, rows });
+      case "browse":
+        return /* @__PURE__ */ jsx7(Browse, { cols, rows });
+      case "installed":
+        return /* @__PURE__ */ jsx7(Installed, { cols, rows });
+      case "sync":
+        return /* @__PURE__ */ jsx7(Sync, { cols, rows });
+      case "settings":
+        return /* @__PURE__ */ jsx7(Settings, { cols, rows });
+    }
+  };
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Box7, { flexDirection: "row", flexGrow: 1, children: [
+      showSidebar && /* @__PURE__ */ jsx7(Sidebar, { screen, onNavigate: setScreen }),
+      /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", flexGrow: 1, marginLeft: 1, children: renderScreen() })
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "h Home  b Browse  l List  s Sync  , Config  Esc Back  q Quit" })
+  ] });
+}
+var init_App = __esm({
+  "src/tui/App.tsx"() {
+    "use strict";
+    init_Sidebar();
+    init_Home();
+    init_Browse();
+    init_Installed();
+    init_Sync();
+    init_Settings();
+  }
+});
+
+// src/tui/index.tsx
+var tui_exports = {};
+__export(tui_exports, {
+  startTUI: () => startTUI
+});
+import { render } from "ink";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function startTUI() {
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx8(App, {}));
+  return waitUntilExit();
+}
+var init_tui = __esm({
+  "src/tui/index.tsx"() {
+    "use strict";
+    init_App();
+  }
+});
+
+// src/cli.ts
+import { Cli, Builtins } from "clipanion";
 
 // src/commands/install.ts
+init_providers();
+init_config();
 init_skills();
+init_agents();
+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";
 var InstallCommand = class extends Command {
   static paths = [["install"], ["i"]];
   static usage = Command.Usage({
@@ -1317,7 +3032,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 +3056,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 +3087,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 +3131,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;
-        }
-        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 (existsSync14(targetPath)) {
-            rmSync4(targetPath, { recursive: true, force: true });
+      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 });
+        }
+        if (targetAgents.length > 1) {
+          console.log(chalk.cyan(`
+Installing to ${adapter.name}...`));
+        }
+        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,11 +3216,13 @@ var InstallCommand = class extends Command {
 };
 
 // src/commands/sync.ts
-import { existsSync as existsSync15, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+init_config();
+init_skills();
+init_agents();
+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";
-init_skills();
 var SyncCommand = class extends Command2 {
   static paths = [["sync"], ["s"]];
   static usage = Command2.Usage({
@@ -1511,12 +3280,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");
@@ -1565,9 +3334,10 @@ function updateConfigContent(existing, newConfig, agentType) {
 }
 
 // src/commands/read.ts
+init_config();
+init_skills();
 import chalk3 from "chalk";
 import { Command as Command3, Option as Option3 } from "clipanion";
-init_skills();
 var ReadCommand = class extends Command3 {
   static paths = [["read"], ["r"]];
   static usage = Command3.Usage({
@@ -1626,9 +3396,10 @@ var ReadCommand = class extends Command3 {
 };
 
 // src/commands/list.ts
+init_config();
+init_skills();
 import chalk4 from "chalk";
 import { Command as Command4, Option as Option4 } from "clipanion";
-init_skills();
 var ListCommand = class extends Command4 {
   static paths = [["list"], ["ls"], ["l"]];
   static usage = Command4.Usage({
@@ -1714,9 +3485,10 @@ function truncate(str, maxLen) {
 }
 
 // src/commands/enable.ts
+init_config();
+init_skills();
 import chalk5 from "chalk";
 import { Command as Command5, Option as Option5 } from "clipanion";
-init_skills();
 var EnableCommand = class extends Command5 {
   static paths = [["enable"]];
   static usage = Command5.Usage({
@@ -1799,13 +3571,14 @@ 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";
+init_config();
+init_skills();
+init_providers();
+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";
-init_skills();
-init_providers();
 var UpdateCommand = class extends Command6 {
   static paths = [["update"], ["u"]];
   static usage = Command6.Usage({
@@ -1852,14 +3625,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 +3656,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,10 +3689,11 @@ var UpdateCommand = class extends Command6 {
 };
 
 // src/commands/remove.ts
-import { existsSync as existsSync17, rmSync as rmSync6 } from "fs";
+init_config();
+init_skills();
+import { existsSync as existsSync27, rmSync as rmSync6 } from "fs";
 import chalk7 from "chalk";
 import { Command as Command7, Option as Option7 } from "clipanion";
-init_skills();
 var RemoveCommand = class extends Command7 {
   static paths = [["remove"], ["rm"], ["uninstall"]];
   static usage = Command7.Usage({
@@ -1944,7 +3718,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;
       }
@@ -1966,6 +3740,8 @@ var RemoveCommand = class extends Command7 {
 };
 
 // src/commands/init.ts
+init_config();
+init_agents();
 import chalk8 from "chalk";
 import { Command as Command8, Option as Option8 } from "clipanion";
 var InitCommand = class extends Command8 {
@@ -2031,8 +3807,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 +3826,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 +3835,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,11 +3878,137 @@ 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/commands/ui.ts
+import { Command as Command11 } from "clipanion";
+var UICommand = class extends Command11 {
+  static paths = [["ui"], ["tui"]];
+  static usage = Command11.Usage({
+    description: "Launch the interactive TUI (Terminal User Interface)",
+    examples: [
+      ["Open interactive TUI", "$0 ui"],
+      ["Alias for TUI", "$0 tui"]
+    ]
+  });
+  async execute() {
+    const { startTUI: startTUI2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
+    await startTUI2();
+    return 0;
+  }
+};
+
 // src/cli.ts
 var cli = new Cli({
   binaryLabel: "skillkit",
   binaryName: "skillkit",
-  binaryVersion: "1.0.0"
+  binaryVersion: "1.1.0"
 });
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);
@@ -2120,5 +4022,7 @@ cli.register(UpdateCommand);
 cli.register(RemoveCommand);
 cli.register(InitCommand);
 cli.register(ValidateCommand);
+cli.register(CreateCommand);
+cli.register(UICommand);
 cli.runExit(process.argv.slice(2));
 //# sourceMappingURL=cli.js.map