@skillkit/cli 1.3.0

package/dist/index.js

@@ -0,0 +1,2247 @@
+// src/commands/list.ts
+import chalk from "chalk";
+import { Command, Option } from "clipanion";
+import { findAllSkills } from "@skillkit/core";
+
+// src/helpers.ts
+import {
+  loadConfig,
+  getSearchDirs as coreGetSearchDirs,
+  getInstallDir as coreGetInstallDir,
+  getAgentConfigPath as coreGetAgentConfigPath,
+  initProject as coreInitProject,
+  loadSkillMetadata as coreLoadSkillMetadata,
+  saveSkillMetadata as coreSaveSkillMetadata
+} from "@skillkit/core";
+import { getAdapter, detectAgent } from "@skillkit/agents";
+var loadSkillMetadata = coreLoadSkillMetadata;
+var saveSkillMetadata = coreSaveSkillMetadata;
+function getSearchDirs(agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  const adapterInfo = {
+    type: adapter.type,
+    name: adapter.name,
+    skillsDir: adapter.skillsDir,
+    configFile: adapter.configFile
+  };
+  return coreGetSearchDirs(adapterInfo);
+}
+function getInstallDir(global = false, agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  const adapterInfo = {
+    type: adapter.type,
+    name: adapter.name,
+    skillsDir: adapter.skillsDir,
+    configFile: adapter.configFile
+  };
+  return coreGetInstallDir(adapterInfo, global);
+}
+function getAgentConfigPath(agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  const adapterInfo = {
+    type: adapter.type,
+    name: adapter.name,
+    skillsDir: adapter.skillsDir,
+    configFile: adapter.configFile
+  };
+  return coreGetAgentConfigPath(adapterInfo);
+}
+async function initProject(agentType) {
+  const type = agentType || await detectAgent();
+  const adapter = getAdapter(type);
+  const adapterInfo = {
+    type: adapter.type,
+    name: adapter.name,
+    skillsDir: adapter.skillsDir,
+    configFile: adapter.configFile
+  };
+  return coreInitProject(type, adapterInfo);
+}
+
+// src/commands/list.ts
+var ListCommand = class extends Command {
+  static paths = [["list"], ["ls"], ["l"]];
+  static usage = Command.Usage({
+    description: "List all installed skills",
+    examples: [
+      ["List all skills", "$0 list"],
+      ["Show only enabled skills", "$0 list --enabled"],
+      ["Show JSON output", "$0 list --json"]
+    ]
+  });
+  enabled = Option.Boolean("--enabled,-e", false, {
+    description: "Show only enabled skills"
+  });
+  disabled = Option.Boolean("--disabled,-d", false, {
+    description: "Show only disabled skills"
+  });
+  json = Option.Boolean("--json,-j", false, {
+    description: "Output as JSON"
+  });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let skills = findAllSkills(searchDirs);
+    if (this.enabled) {
+      skills = skills.filter((s) => s.enabled);
+    } else if (this.disabled) {
+      skills = skills.filter((s) => !s.enabled);
+    }
+    skills.sort((a, b) => {
+      if (a.location !== b.location) {
+        return a.location === "project" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    if (this.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return 0;
+    }
+    if (skills.length === 0) {
+      console.log(chalk.yellow("No skills installed"));
+      console.log(chalk.dim("Install skills with: skillkit install <source>"));
+      return 0;
+    }
+    console.log(chalk.cyan(`Installed skills (${skills.length}):
+`));
+    const projectSkills = skills.filter((s) => s.location === "project");
+    const globalSkills = skills.filter((s) => s.location === "global");
+    if (projectSkills.length > 0) {
+      console.log(chalk.blue("Project skills:"));
+      for (const skill of projectSkills) {
+        printSkill(skill);
+      }
+      console.log();
+    }
+    if (globalSkills.length > 0) {
+      console.log(chalk.dim("Global skills:"));
+      for (const skill of globalSkills) {
+        printSkill(skill);
+      }
+      console.log();
+    }
+    const enabledCount = skills.filter((s) => s.enabled).length;
+    const disabledCount = skills.length - enabledCount;
+    console.log(
+      chalk.dim(
+        `${projectSkills.length} project, ${globalSkills.length} global` + (disabledCount > 0 ? `, ${disabledCount} disabled` : "")
+      )
+    );
+    return 0;
+  }
+};
+function printSkill(skill) {
+  const status = skill.enabled ? chalk.green("\u2713") : chalk.red("\u25CB");
+  const name = skill.enabled ? skill.name : chalk.dim(skill.name);
+  const desc = chalk.dim(truncate(skill.description, 50));
+  console.log(`  ${status} ${name}`);
+  if (skill.description) {
+    console.log(`    ${desc}`);
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// src/commands/read.ts
+import chalk2 from "chalk";
+import { Command as Command2, Option as Option2 } from "clipanion";
+import { findSkill, readSkillContent } from "@skillkit/core";
+var ReadCommand = class extends Command2 {
+  static paths = [["read"], ["r"]];
+  static usage = Command2.Usage({
+    description: "Read skill content for AI agent consumption",
+    examples: [
+      ["Read a single skill", "$0 read pdf"],
+      ["Read multiple skills", "$0 read pdf,xlsx,docx"],
+      ["Read with verbose output", "$0 read pdf --verbose"]
+    ]
+  });
+  skills = Option2.String({ required: true });
+  verbose = Option2.Boolean("--verbose,-v", false, {
+    description: "Show additional information"
+  });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    const skillNames = this.skills.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (skillNames.length === 0) {
+      console.error(chalk2.red("No skill names provided"));
+      return 1;
+    }
+    let exitCode = 0;
+    for (const skillName of skillNames) {
+      const skill = findSkill(skillName, searchDirs);
+      if (!skill) {
+        console.error(chalk2.red(`Skill not found: ${skillName}`));
+        console.error(chalk2.dim("Available directories:"));
+        searchDirs.forEach((d) => console.error(chalk2.dim(`  - ${d}`)));
+        exitCode = 1;
+        continue;
+      }
+      if (!skill.enabled) {
+        console.error(chalk2.yellow(`Skill disabled: ${skillName}`));
+        console.error(chalk2.dim("Enable with: skillkit enable " + skillName));
+        exitCode = 1;
+        continue;
+      }
+      const content = readSkillContent(skill.path);
+      if (!content) {
+        console.error(chalk2.red(`Could not read SKILL.md for: ${skillName}`));
+        exitCode = 1;
+        continue;
+      }
+      console.log(`Reading: ${skillName}`);
+      console.log(`Base directory: ${skill.path}`);
+      console.log();
+      console.log(content);
+      console.log();
+      console.log(`Skill read: ${skillName}`);
+      if (skillNames.length > 1 && skillName !== skillNames[skillNames.length - 1]) {
+        console.log("\n---\n");
+      }
+    }
+    return exitCode;
+  }
+};
+
+// src/commands/sync.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import chalk3 from "chalk";
+import { Command as Command3, Option as Option3 } from "clipanion";
+import { loadConfig as loadConfig2, findAllSkills as findAllSkills2 } from "@skillkit/core";
+import { getAdapter as getAdapter2, detectAgent as detectAgent2 } from "@skillkit/agents";
+var SyncCommand = class extends Command3 {
+  static paths = [["sync"], ["s"]];
+  static usage = Command3.Usage({
+    description: "Sync skills to agent configuration file",
+    examples: [
+      ["Sync all enabled skills", "$0 sync"],
+      ["Sync to specific file", "$0 sync --output AGENTS.md"],
+      ["Sync for specific agent", "$0 sync --agent cursor"],
+      ["Only sync enabled skills", "$0 sync --enabled-only"]
+    ]
+  });
+  output = Option3.String("--output,-o", {
+    description: "Output file path (default: agent-specific config file)"
+  });
+  agent = Option3.String("--agent,-a", {
+    description: "Target agent type (claude-code, cursor, codex, etc.)"
+  });
+  enabledOnly = Option3.Boolean("--enabled-only,-e", true, {
+    description: "Only include enabled skills (default: true)"
+  });
+  yes = Option3.Boolean("--yes,-y", false, {
+    description: "Skip confirmation prompts"
+  });
+  async execute() {
+    try {
+      let agentType;
+      if (this.agent) {
+        agentType = this.agent;
+      } else {
+        const config2 = loadConfig2();
+        agentType = config2.agent || await detectAgent2();
+      }
+      const adapter = getAdapter2(agentType);
+      const outputPath = this.output || getAgentConfigPath(agentType);
+      const searchDirs = getSearchDirs(agentType);
+      let skills = findAllSkills2(searchDirs);
+      if (this.enabledOnly) {
+        skills = skills.filter((s) => s.enabled);
+      }
+      if (skills.length === 0) {
+        console.log(chalk3.yellow("No skills found to sync"));
+        console.log(chalk3.dim("Install skills with: skillkit install <source>"));
+        return 0;
+      }
+      console.log(chalk3.cyan(`Syncing ${skills.length} skill(s) for ${adapter.name}:`));
+      skills.forEach((s) => {
+        const status = s.enabled ? chalk3.green("\u2713") : chalk3.dim("\u25CB");
+        const location = s.location === "project" ? chalk3.blue("[project]") : chalk3.dim("[global]");
+        console.log(`  ${status} ${s.name} ${location}`);
+      });
+      console.log();
+      const config = adapter.generateConfig(skills);
+      if (!config) {
+        console.log(chalk3.yellow("No configuration generated"));
+        return 0;
+      }
+      let existingContent = "";
+      if (existsSync(outputPath)) {
+        existingContent = readFileSync(outputPath, "utf-8");
+      }
+      const newContent = updateConfigContent(existingContent, config, agentType);
+      const dir = dirname(outputPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(outputPath, newContent, "utf-8");
+      console.log(chalk3.green(`Synced to ${outputPath}`));
+      console.log(chalk3.dim(`Agent: ${adapter.name}`));
+      return 0;
+    } catch (error) {
+      console.error(chalk3.red("Sync failed"));
+      console.error(chalk3.dim(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+};
+function updateConfigContent(existing, newConfig, agentType) {
+  const markers = {
+    "claude-code": {
+      start: "<!-- SKILLS_TABLE_START -->",
+      end: "<!-- SKILLS_TABLE_END -->"
+    },
+    cursor: {
+      start: "<!-- SKILLS_DATA_START -->",
+      end: "<!-- SKILLS_DATA_END -->"
+    },
+    universal: {
+      start: "<!-- SKILLKIT_SKILLS_START -->",
+      end: "<!-- SKILLKIT_SKILLS_END -->"
+    }
+  };
+  const agentMarkers = markers[agentType] || markers.universal;
+  const startIdx = existing.indexOf(agentMarkers.start);
+  const endIdx = existing.indexOf(agentMarkers.end);
+  if (startIdx !== -1 && endIdx !== -1) {
+    return existing.slice(0, startIdx) + newConfig.slice(newConfig.indexOf(agentMarkers.start)) + existing.slice(endIdx + agentMarkers.end.length);
+  }
+  const genericStart = "<!-- SKILLKIT_SKILLS_START -->";
+  const genericEnd = "<!-- SKILLKIT_SKILLS_END -->";
+  const gStartIdx = existing.indexOf(genericStart);
+  const gEndIdx = existing.indexOf(genericEnd);
+  if (gStartIdx !== -1 && gEndIdx !== -1) {
+    return existing.slice(0, gStartIdx) + newConfig + existing.slice(gEndIdx + genericEnd.length);
+  }
+  if (existing.trim()) {
+    return existing + "\n\n" + newConfig;
+  }
+  return newConfig;
+}
+
+// src/commands/init.ts
+import chalk4 from "chalk";
+import { Command as Command4, Option as Option4 } from "clipanion";
+import { detectAgent as detectAgent3, getAdapter as getAdapter3, getAllAdapters } from "@skillkit/agents";
+var InitCommand = class extends Command4 {
+  static paths = [["init"]];
+  static usage = Command4.Usage({
+    description: "Initialize skillkit in a project",
+    examples: [
+      ["Auto-detect agent and initialize", "$0 init"],
+      ["Initialize for specific agent", "$0 init --agent cursor"],
+      ["List supported agents", "$0 init --list"]
+    ]
+  });
+  agent = Option4.String("--agent,-a", {
+    description: "Target agent type"
+  });
+  list = Option4.Boolean("--list,-l", false, {
+    description: "List supported agents"
+  });
+  async execute() {
+    if (this.list) {
+      console.log(chalk4.cyan("Supported agents:\n"));
+      const adapters = getAllAdapters();
+      for (const adapter of adapters) {
+        console.log(`  ${chalk4.green(adapter.type)}`);
+        console.log(`    Name: ${adapter.name}`);
+        console.log(`    Skills dir: ${adapter.skillsDir}`);
+        console.log(`    Config file: ${adapter.configFile}`);
+        console.log();
+      }
+      return 0;
+    }
+    try {
+      let agentType;
+      if (this.agent) {
+        agentType = this.agent;
+      } else {
+        console.log(chalk4.dim("Auto-detecting agent..."));
+        agentType = await detectAgent3();
+      }
+      const adapter = getAdapter3(agentType);
+      console.log(chalk4.cyan(`Initializing for ${adapter.name}...`));
+      await initProject(agentType);
+      console.log();
+      console.log(chalk4.green("Initialized successfully!"));
+      console.log();
+      console.log(chalk4.dim("Created:"));
+      console.log(chalk4.dim(`  - ${adapter.skillsDir}/ (skills directory)`));
+      console.log(chalk4.dim(`  - skillkit.yaml (config file)`));
+      console.log(chalk4.dim(`  - ${adapter.configFile} (agent config)`));
+      console.log();
+      console.log(chalk4.cyan("Next steps:"));
+      console.log(chalk4.dim("  1. Install skills: skillkit install owner/repo"));
+      console.log(chalk4.dim("  2. Sync config: skillkit sync"));
+      console.log(chalk4.dim("  3. Use skills: skillkit read <skill-name>"));
+      return 0;
+    } catch (error) {
+      console.error(chalk4.red("Initialization failed"));
+      console.error(chalk4.dim(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+};
+
+// src/commands/enable.ts
+import chalk5 from "chalk";
+import { Command as Command5, Option as Option5 } from "clipanion";
+import { setSkillEnabled, findSkill as findSkill2 } from "@skillkit/core";
+var EnableCommand = class extends Command5 {
+  static paths = [["enable"]];
+  static usage = Command5.Usage({
+    description: "Enable one or more skills",
+    examples: [
+      ["Enable a skill", "$0 enable pdf"],
+      ["Enable multiple skills", "$0 enable pdf xlsx docx"]
+    ]
+  });
+  skills = Option5.Rest({ required: 1 });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let success = 0;
+    let failed = 0;
+    for (const skillName of this.skills) {
+      const skill = findSkill2(skillName, searchDirs);
+      if (!skill) {
+        console.log(chalk5.red(`Skill not found: ${skillName}`));
+        failed++;
+        continue;
+      }
+      if (skill.enabled) {
+        console.log(chalk5.dim(`Already enabled: ${skillName}`));
+        continue;
+      }
+      const result = setSkillEnabled(skill.path, true);
+      if (result) {
+        console.log(chalk5.green(`Enabled: ${skillName}`));
+        success++;
+      } else {
+        console.log(chalk5.red(`Failed to enable: ${skillName}`));
+        failed++;
+      }
+    }
+    if (success > 0) {
+      console.log(chalk5.dim("\nRun `skillkit sync` to update your agent config"));
+    }
+    return failed > 0 ? 1 : 0;
+  }
+};
+var DisableCommand = class extends Command5 {
+  static paths = [["disable"]];
+  static usage = Command5.Usage({
+    description: "Disable one or more skills",
+    examples: [
+      ["Disable a skill", "$0 disable pdf"],
+      ["Disable multiple skills", "$0 disable pdf xlsx docx"]
+    ]
+  });
+  skills = Option5.Rest({ required: 1 });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let success = 0;
+    let failed = 0;
+    for (const skillName of this.skills) {
+      const skill = findSkill2(skillName, searchDirs);
+      if (!skill) {
+        console.log(chalk5.red(`Skill not found: ${skillName}`));
+        failed++;
+        continue;
+      }
+      if (!skill.enabled) {
+        console.log(chalk5.dim(`Already disabled: ${skillName}`));
+        continue;
+      }
+      const result = setSkillEnabled(skill.path, false);
+      if (result) {
+        console.log(chalk5.yellow(`Disabled: ${skillName}`));
+        success++;
+      } else {
+        console.log(chalk5.red(`Failed to disable: ${skillName}`));
+        failed++;
+      }
+    }
+    if (success > 0) {
+      console.log(chalk5.dim("\nRun `skillkit sync` to update your agent config"));
+    }
+    return failed > 0 ? 1 : 0;
+  }
+};
+
+// src/commands/remove.ts
+import { existsSync as existsSync2, rmSync } from "fs";
+import chalk6 from "chalk";
+import { Command as Command6, Option as Option6 } from "clipanion";
+import { findSkill as findSkill3 } from "@skillkit/core";
+var RemoveCommand = class extends Command6 {
+  static paths = [["remove"], ["rm"], ["uninstall"]];
+  static usage = Command6.Usage({
+    description: "Remove installed skills",
+    examples: [
+      ["Remove a skill", "$0 remove pdf"],
+      ["Remove multiple skills", "$0 remove pdf xlsx docx"],
+      ["Force removal without confirmation", "$0 remove pdf --force"]
+    ]
+  });
+  skills = Option6.Rest({ required: 1 });
+  force = Option6.Boolean("--force,-f", false, {
+    description: "Skip confirmation"
+  });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let removed = 0;
+    let failed = 0;
+    for (const skillName of this.skills) {
+      const skill = findSkill3(skillName, searchDirs);
+      if (!skill) {
+        console.log(chalk6.yellow(`Skill not found: ${skillName}`));
+        continue;
+      }
+      if (!existsSync2(skill.path)) {
+        console.log(chalk6.yellow(`Path not found: ${skill.path}`));
+        continue;
+      }
+      try {
+        rmSync(skill.path, { recursive: true, force: true });
+        console.log(chalk6.green(`Removed: ${skillName}`));
+        removed++;
+      } catch (error) {
+        console.log(chalk6.red(`Failed to remove: ${skillName}`));
+        console.error(chalk6.dim(error instanceof Error ? error.message : String(error)));
+        failed++;
+      }
+    }
+    if (removed > 0) {
+      console.log(chalk6.dim("\nRun `skillkit sync` to update your agent config"));
+    }
+    return failed > 0 ? 1 : 0;
+  }
+};
+
+// src/commands/install.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, cpSync, rmSync as rmSync2 } from "fs";
+import { join } from "path";
+import chalk7 from "chalk";
+import ora from "ora";
+import { Command as Command7, Option as Option7 } from "clipanion";
+import { detectProvider, isLocalPath, getProvider } from "@skillkit/core";
+import { isPathInside } from "@skillkit/core";
+import { getAdapter as getAdapter4, detectAgent as detectAgent4 } from "@skillkit/agents";
+var InstallCommand = class extends Command7 {
+  static paths = [["install"], ["i"]];
+  static usage = Command7.Usage({
+    description: "Install skills from GitHub, GitLab, Bitbucket, or local path",
+    examples: [
+      ["Install from GitHub", "$0 install owner/repo"],
+      ["Install from GitLab", "$0 install gitlab:owner/repo"],
+      ["Install from Bitbucket", "$0 install bitbucket:owner/repo"],
+      ["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"],
+      ["List available skills", "$0 install owner/repo --list"],
+      ["Install to specific agents", "$0 install owner/repo --agent claude-code --agent cursor"]
+    ]
+  });
+  source = Option7.String({ required: true });
+  skills = Option7.String("--skills,-s", {
+    description: "Comma-separated list of skills to install (non-interactive)"
+  });
+  all = Option7.Boolean("--all,-a", false, {
+    description: "Install all discovered skills (non-interactive)"
+  });
+  yes = Option7.Boolean("--yes,-y", false, {
+    description: "Skip confirmation prompts"
+  });
+  global = Option7.Boolean("--global,-g", false, {
+    description: "Install to global skills directory"
+  });
+  force = Option7.Boolean("--force,-f", false, {
+    description: "Overwrite existing skills"
+  });
+  provider = Option7.String("--provider,-p", {
+    description: "Force specific provider (github, gitlab, bitbucket)"
+  });
+  list = Option7.Boolean("--list,-l", false, {
+    description: "List available skills without installing"
+  });
+  agent = Option7.Array("--agent", {
+    description: "Target specific agents (can specify multiple)"
+  });
+  async execute() {
+    const spinner = ora();
+    try {
+      let providerAdapter = detectProvider(this.source);
+      if (this.provider) {
+        providerAdapter = getProvider(this.provider);
+      }
+      if (!providerAdapter) {
+        console.error(chalk7.red(`Could not detect provider for: ${this.source}`));
+        console.error(chalk7.dim("Use --provider flag or specify source as:"));
+        console.error(chalk7.dim("  GitHub: owner/repo or https://github.com/owner/repo"));
+        console.error(chalk7.dim("  GitLab: gitlab:owner/repo or https://gitlab.com/owner/repo"));
+        console.error(chalk7.dim("  Bitbucket: bitbucket:owner/repo"));
+        console.error(chalk7.dim("  Local: ./path or ~/path"));
+        return 1;
+      }
+      spinner.start(`Fetching from ${providerAdapter.name}...`);
+      const result = await providerAdapter.clone(this.source, "", { depth: 1 });
+      if (!result.success || !result.path) {
+        spinner.fail(chalk7.red(result.error || "Failed to fetch source"));
+        return 1;
+      }
+      spinner.succeed(`Found ${result.skills?.length || 0} skill(s)`);
+      const discoveredSkills = result.discoveredSkills || [];
+      if (this.list) {
+        if (discoveredSkills.length === 0) {
+          console.log(chalk7.yellow("\nNo skills found in this repository"));
+        } else {
+          console.log(chalk7.cyan("\nAvailable skills:\n"));
+          for (const skill of discoveredSkills) {
+            console.log(`  ${chalk7.green(skill.name)}`);
+          }
+          console.log();
+          console.log(chalk7.dim(`Total: ${discoveredSkills.length} skill(s)`));
+          console.log(chalk7.dim("\nTo install specific skills: skillkit install <source> --skills=skill1,skill2"));
+          console.log(chalk7.dim("To install all skills: skillkit install <source> --all"));
+        }
+        const cleanupPath2 = result.tempRoot || result.path;
+        if (!isLocalPath(this.source) && cleanupPath2 && existsSync3(cleanupPath2)) {
+          rmSync2(cleanupPath2, { recursive: true, force: true });
+        }
+        return 0;
+      }
+      let skillsToInstall = discoveredSkills;
+      if (this.skills) {
+        const requestedSkills = this.skills.split(",").map((s) => s.trim());
+        const available = discoveredSkills.map((s) => s.name);
+        const notFound = requestedSkills.filter((s) => !available.includes(s));
+        if (notFound.length > 0) {
+          console.error(chalk7.red(`Skills not found: ${notFound.join(", ")}`));
+          console.error(chalk7.dim(`Available: ${available.join(", ")}`));
+          return 1;
+        }
+        skillsToInstall = discoveredSkills.filter((s) => requestedSkills.includes(s.name));
+      } else if (this.all || this.yes) {
+        skillsToInstall = discoveredSkills;
+      } else {
+        skillsToInstall = discoveredSkills;
+        if (skillsToInstall.length > 0) {
+          console.log(chalk7.cyan("\nSkills to install:"));
+          skillsToInstall.forEach((s) => console.log(chalk7.dim(`  - ${s.name}`)));
+          console.log();
+        }
+      }
+      if (skillsToInstall.length === 0) {
+        console.log(chalk7.yellow("No skills to install"));
+        return 0;
+      }
+      let targetAgents;
+      if (this.agent && this.agent.length > 0) {
+        targetAgents = this.agent;
+      } else {
+        const detectedAgent = await detectAgent4();
+        targetAgents = [detectedAgent];
+      }
+      let totalInstalled = 0;
+      const installResults = [];
+      for (const agentType of targetAgents) {
+        const adapter = getAdapter4(agentType);
+        const installDir = getInstallDir(this.global, agentType);
+        if (!existsSync3(installDir)) {
+          mkdirSync2(installDir, { recursive: true });
+        }
+        if (targetAgents.length > 1) {
+          console.log(chalk7.cyan(`
+Installing to ${adapter.name}...`));
+        }
+        let installed = 0;
+        for (const skill of skillsToInstall) {
+          const skillName = skill.name;
+          const sourcePath = skill.path;
+          const targetPath = join(installDir, skillName);
+          if (existsSync3(targetPath) && !this.force) {
+            console.log(chalk7.yellow(`  Skipping ${skillName} (already exists, use --force to overwrite)`));
+            continue;
+          }
+          const securityRoot = result.tempRoot || result.path;
+          if (!isPathInside(sourcePath, securityRoot)) {
+            console.log(chalk7.red(`  Skipping ${skillName} (path traversal detected)`));
+            continue;
+          }
+          spinner.start(`Installing ${skillName}...`);
+          try {
+            if (existsSync3(targetPath)) {
+              rmSync2(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(chalk7.green(`Installed ${skillName}`));
+            installed++;
+          } catch (error) {
+            spinner.fail(chalk7.red(`Failed to install ${skillName}`));
+            console.error(chalk7.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 && existsSync3(cleanupPath)) {
+        rmSync2(cleanupPath, { recursive: true, force: true });
+      }
+      console.log();
+      if (targetAgents.length > 1) {
+        console.log(chalk7.green(`Installed ${totalInstalled} skill(s) across ${targetAgents.length} agents:`));
+        for (const r of installResults) {
+          console.log(chalk7.dim(`  - ${r.agent}: ${r.count} skill(s) to ${r.dir}`));
+        }
+      } else {
+        console.log(chalk7.green(`Installed ${totalInstalled} skill(s) to ${installResults[0]?.dir}`));
+      }
+      if (!this.yes) {
+        console.log(chalk7.dim("\nRun `skillkit sync` to update your agent config"));
+      }
+      return 0;
+    } catch (error) {
+      spinner.fail(chalk7.red("Installation failed"));
+      console.error(chalk7.dim(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+};
+
+// src/commands/update.ts
+import { existsSync as existsSync4, rmSync as rmSync3, cpSync as cpSync2 } from "fs";
+import { join as join2 } from "path";
+import chalk8 from "chalk";
+import ora2 from "ora";
+import { Command as Command8, Option as Option8 } from "clipanion";
+import { findAllSkills as findAllSkills3, findSkill as findSkill4, detectProvider as detectProvider2, isLocalPath as isLocalPath2 } from "@skillkit/core";
+var UpdateCommand = class extends Command8 {
+  static paths = [["update"], ["u"]];
+  static usage = Command8.Usage({
+    description: "Update skills from their original sources",
+    examples: [
+      ["Update all skills", "$0 update"],
+      ["Update specific skills", "$0 update pdf xlsx"],
+      ["Force update (overwrite local changes)", "$0 update --force"]
+    ]
+  });
+  skills = Option8.Rest();
+  force = Option8.Boolean("--force,-f", false, {
+    description: "Force update even if local changes exist"
+  });
+  async execute() {
+    const spinner = ora2();
+    const searchDirs = getSearchDirs();
+    let skillsToUpdate;
+    if (this.skills.length > 0) {
+      skillsToUpdate = this.skills.map((name) => findSkill4(name, searchDirs)).filter((s) => s !== null);
+      const notFound = this.skills.filter((name) => !findSkill4(name, searchDirs));
+      if (notFound.length > 0) {
+        console.log(chalk8.yellow(`Skills not found: ${notFound.join(", ")}`));
+      }
+    } else {
+      skillsToUpdate = findAllSkills3(searchDirs);
+    }
+    if (skillsToUpdate.length === 0) {
+      console.log(chalk8.yellow("No skills to update"));
+      return 0;
+    }
+    console.log(chalk8.cyan(`Updating ${skillsToUpdate.length} skill(s)...
+`));
+    let updated = 0;
+    let skipped = 0;
+    let failed = 0;
+    for (const skill of skillsToUpdate) {
+      const metadata = loadSkillMetadata(skill.path);
+      if (!metadata) {
+        console.log(chalk8.dim(`Skipping ${skill.name} (no metadata, reinstall needed)`));
+        skipped++;
+        continue;
+      }
+      spinner.start(`Updating ${skill.name}...`);
+      try {
+        if (isLocalPath2(metadata.source)) {
+          const localPath = metadata.subpath ? join2(metadata.source, metadata.subpath) : metadata.source;
+          if (!existsSync4(localPath)) {
+            spinner.warn(chalk8.yellow(`${skill.name}: local source missing`));
+            skipped++;
+            continue;
+          }
+          const skillMdPath = join2(localPath, "SKILL.md");
+          if (!existsSync4(skillMdPath)) {
+            spinner.warn(chalk8.yellow(`${skill.name}: no SKILL.md at source`));
+            skipped++;
+            continue;
+          }
+          rmSync3(skill.path, { recursive: true, force: true });
+          cpSync2(localPath, skill.path, { recursive: true, dereference: true });
+          metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          saveSkillMetadata(skill.path, metadata);
+          spinner.succeed(chalk8.green(`Updated ${skill.name}`));
+          updated++;
+        } else {
+          const provider = detectProvider2(metadata.source);
+          if (!provider) {
+            spinner.warn(chalk8.yellow(`${skill.name}: unknown provider`));
+            skipped++;
+            continue;
+          }
+          const result = await provider.clone(metadata.source, "", { depth: 1 });
+          if (!result.success || !result.path) {
+            spinner.fail(chalk8.red(`${skill.name}: ${result.error || "clone failed"}`));
+            failed++;
+            continue;
+          }
+          const sourcePath = metadata.subpath ? join2(result.path, metadata.subpath) : result.path;
+          const skillMdPath = join2(sourcePath, "SKILL.md");
+          if (!existsSync4(skillMdPath)) {
+            spinner.warn(chalk8.yellow(`${skill.name}: no SKILL.md in source`));
+            rmSync3(result.path, { recursive: true, force: true });
+            skipped++;
+            continue;
+          }
+          rmSync3(skill.path, { recursive: true, force: true });
+          cpSync2(sourcePath, skill.path, { recursive: true, dereference: true });
+          rmSync3(result.path, { recursive: true, force: true });
+          metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          saveSkillMetadata(skill.path, metadata);
+          spinner.succeed(chalk8.green(`Updated ${skill.name}`));
+          updated++;
+        }
+      } catch (error) {
+        spinner.fail(chalk8.red(`Failed to update ${skill.name}`));
+        console.error(chalk8.dim(error instanceof Error ? error.message : String(error)));
+        failed++;
+      }
+    }
+    console.log();
+    console.log(
+      chalk8.cyan(
+        `Updated: ${updated}, Skipped: ${skipped}, Failed: ${failed}`
+      )
+    );
+    return failed > 0 ? 1 : 0;
+  }
+};
+
+// src/commands/validate.ts
+import { existsSync as existsSync5, readdirSync } from "fs";
+import { join as join3, basename } from "path";
+import chalk9 from "chalk";
+import { Command as Command9, Option as Option9 } from "clipanion";
+import { validateSkill } from "@skillkit/core";
+var ValidateCommand = class extends Command9 {
+  static paths = [["validate"], ["v"]];
+  static usage = Command9.Usage({
+    description: "Validate skill(s) against the Agent Skills specification (agentskills.io)",
+    examples: [
+      ["Validate a skill directory", "$0 validate ./my-skill"],
+      ["Validate all skills in a directory", "$0 validate ./skills --all"]
+    ]
+  });
+  skillPath = Option9.String({ required: true });
+  all = Option9.Boolean("--all,-a", false, {
+    description: "Validate all skills in the directory"
+  });
+  async execute() {
+    const targetPath = this.skillPath;
+    if (!existsSync5(targetPath)) {
+      console.error(chalk9.red(`Path does not exist: ${targetPath}`));
+      return 1;
+    }
+    const skillPaths = [];
+    if (this.all) {
+      const entries = readdirSync(targetPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillPath = join3(targetPath, entry.name);
+          if (existsSync5(join3(skillPath, "SKILL.md"))) {
+            skillPaths.push(skillPath);
+          }
+        }
+      }
+      if (skillPaths.length === 0) {
+        console.error(chalk9.yellow("No skills found in directory"));
+        return 1;
+      }
+    } else {
+      skillPaths.push(targetPath);
+    }
+    let hasErrors = false;
+    for (const skillPath of skillPaths) {
+      const skillName = basename(skillPath);
+      const result = validateSkill(skillPath);
+      if (result.valid) {
+        console.log(chalk9.green(`\u2713 ${skillName}`));
+        if (result.warnings && result.warnings.length > 0) {
+          result.warnings.forEach((w) => {
+            console.log(chalk9.yellow(`  \u26A0 ${w}`));
+          });
+        }
+      } else {
+        console.log(chalk9.red(`\u2717 ${skillName}`));
+        result.errors.forEach((e) => {
+          console.log(chalk9.red(`  \u2022 ${e}`));
+        });
+        hasErrors = true;
+      }
+    }
+    console.log();
+    if (hasErrors) {
+      console.log(chalk9.red("Validation failed"));
+      console.log(chalk9.dim("See https://agentskills.io/specification for the complete format"));
+      return 1;
+    }
+    console.log(chalk9.green(`Validated ${skillPaths.length} skill(s) successfully`));
+    return 0;
+  }
+};
+
+// src/commands/create.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } 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 = join4(parentDir, skillName);
+    if (existsSync6(skillDir)) {
+      console.error(chalk10.red(`Directory already exists: ${skillDir}`));
+      return 1;
+    }
+    try {
+      mkdirSync3(skillDir, { recursive: true });
+      const skillMd = generateSkillMd(skillName);
+      writeFileSync2(join4(skillDir, "SKILL.md"), skillMd);
+      if (this.full || this.references) {
+        const refsDir = join4(skillDir, "references");
+        mkdirSync3(refsDir);
+        writeFileSync2(join4(refsDir, ".gitkeep"), "");
+      }
+      if (this.full || this.scripts) {
+        const scriptsDir = join4(skillDir, "scripts");
+        mkdirSync3(scriptsDir);
+        writeFileSync2(join4(scriptsDir, ".gitkeep"), "");
+      }
+      if (this.full || this.assets) {
+        const assetsDir = join4(skillDir, "assets");
+        mkdirSync3(assetsDir);
+        writeFileSync2(join4(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 } = await import("@skillkit/tui");
+    await startTUI();
+    return 0;
+  }
+};
+
+// src/commands/translate.ts
+import { Command as Command12, Option as Option11 } from "clipanion";
+import { existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { join as join5, basename as basename2, dirname as dirname2 } from "path";
+import chalk11 from "chalk";
+import {
+  translateSkill,
+  translateSkillFile,
+  getSupportedTranslationAgents,
+  translatorRegistry,
+  findAllSkills as findAllSkills4
+} from "@skillkit/core";
+import { getAdapter as getAdapter5, getAllAdapters as getAllAdapters2 } from "@skillkit/agents";
+var TranslateCommand = class extends Command12 {
+  static paths = [["translate"]];
+  static usage = Command12.Usage({
+    description: "Translate skills between different AI agent formats",
+    details: `
+      This command translates skills from one AI agent format to another.
+
+      Supported formats:
+      - SKILL.md (Claude Code, Codex, Gemini CLI, and 10+ more)
+      - Cursor MDC (.mdc files with globs)
+      - Windsurf rules (.windsurfrules)
+      - GitHub Copilot instructions (copilot-instructions.md)
+
+      Translation is bidirectional - you can translate from any format to any other.
+    `,
+    examples: [
+      ["Translate a skill to Cursor format", "$0 translate my-skill --to cursor"],
+      ["Translate all skills to Windsurf", "$0 translate --all --to windsurf"],
+      ["Translate a file directly", "$0 translate ./SKILL.md --to cursor --output ./my-skill.mdc"],
+      ["List all supported agents", "$0 translate --list"],
+      ["Preview translation without writing", "$0 translate my-skill --to cursor --dry-run"]
+    ]
+  });
+  // Skill name or path
+  source = Option11.String({ required: false });
+  // Target agent
+  to = Option11.String("--to,-t", {
+    description: "Target agent to translate to"
+  });
+  // Source agent (auto-detected if not specified)
+  from = Option11.String("--from,-f", {
+    description: "Source agent format (auto-detected if not specified)"
+  });
+  // Output path
+  output = Option11.String("--output,-o", {
+    description: "Output file path (default: agent skills directory)"
+  });
+  // Translate all installed skills
+  all = Option11.Boolean("--all,-a", false, {
+    description: "Translate all installed skills"
+  });
+  // Dry run (preview without writing)
+  dryRun = Option11.Boolean("--dry-run,-n", false, {
+    description: "Preview translation without writing files"
+  });
+  // Add metadata comments
+  metadata = Option11.Boolean("--metadata,-m", false, {
+    description: "Add translation metadata to output"
+  });
+  // Force overwrite
+  force = Option11.Boolean("--force", false, {
+    description: "Overwrite existing files"
+  });
+  // List supported agents
+  list = Option11.Boolean("--list,-l", false, {
+    description: "List all supported agents and formats"
+  });
+  // Show compatibility info
+  compat = Option11.Boolean("--compat,-c", false, {
+    description: "Show compatibility info between agents"
+  });
+  async execute() {
+    if (this.list) {
+      return this.listAgents();
+    }
+    if (this.compat) {
+      return this.showCompatibility();
+    }
+    if (!this.to) {
+      console.error(chalk11.red("Error: --to/-t target agent is required"));
+      console.log(chalk11.gray("Use --list to see all supported agents"));
+      return 1;
+    }
+    const targetAgent = this.to;
+    if (!getSupportedTranslationAgents().includes(targetAgent)) {
+      console.error(chalk11.red(`Error: Unknown target agent "${this.to}"`));
+      console.log(chalk11.gray("Use --list to see all supported agents"));
+      return 1;
+    }
+    if (this.all) {
+      return this.translateAll(targetAgent);
+    }
+    if (!this.source) {
+      console.error(chalk11.red("Error: Please specify a skill name or path, or use --all"));
+      return 1;
+    }
+    return this.translateSingle(this.source, targetAgent);
+  }
+  /**
+   * List all supported agents and their formats
+   */
+  listAgents() {
+    console.log(chalk11.bold("\nSupported Agents for Translation:\n"));
+    const agents = getSupportedTranslationAgents();
+    const adapters = getAllAdapters2();
+    const byFormat = {};
+    for (const agent of agents) {
+      const format = translatorRegistry.getFormatForAgent(agent);
+      if (!byFormat[format]) byFormat[format] = [];
+      byFormat[format].push(agent);
+    }
+    const formatNames = {
+      "skill-md": "SKILL.md Format (Standard)",
+      "cursor-mdc": "Cursor MDC Format",
+      "markdown-rules": "Markdown Rules Format",
+      "external": "External Systems"
+    };
+    for (const [format, formatAgents] of Object.entries(byFormat)) {
+      console.log(chalk11.cyan(`  ${formatNames[format] || format}:`));
+      for (const agent of formatAgents) {
+        const adapter = adapters.find((a) => a.type === agent);
+        const name = adapter?.name || agent;
+        console.log(`    ${chalk11.green(agent.padEnd(16))} ${chalk11.gray(name)}`);
+      }
+      console.log();
+    }
+    console.log(chalk11.gray("All formats can translate to any other format."));
+    console.log(chalk11.gray("Use --compat to see compatibility details.\n"));
+    return 0;
+  }
+  /**
+   * Show compatibility between agents
+   */
+  showCompatibility() {
+    if (!this.from || !this.to) {
+      console.error(chalk11.red("Error: Both --from and --to are required for compatibility check"));
+      return 1;
+    }
+    const fromAgent = this.from;
+    const toAgent = this.to;
+    const info = translatorRegistry.getCompatibilityInfo(fromAgent, toAgent);
+    console.log(chalk11.bold(`
+Translation: ${fromAgent} \u2192 ${toAgent}
+`));
+    if (info.supported) {
+      console.log(chalk11.green("  \u2713 Translation supported"));
+    } else {
+      console.log(chalk11.red("  \u2717 Translation not supported"));
+      return 1;
+    }
+    if (info.warnings.length > 0) {
+      console.log(chalk11.yellow("\n  Warnings:"));
+      for (const warning of info.warnings) {
+        console.log(chalk11.yellow(`    \u2022 ${warning}`));
+      }
+    }
+    if (info.lossyFields.length > 0) {
+      console.log(chalk11.gray("\n  Fields with reduced functionality:"));
+      for (const field of info.lossyFields) {
+        console.log(chalk11.gray(`    \u2022 ${field}`));
+      }
+    }
+    console.log();
+    return 0;
+  }
+  /**
+   * Translate all installed skills
+   */
+  async translateAll(targetAgent) {
+    const searchDirs = getSearchDirs();
+    const skills = findAllSkills4(searchDirs);
+    if (skills.length === 0) {
+      console.log(chalk11.yellow("No skills found to translate"));
+      return 0;
+    }
+    console.log(chalk11.bold(`
+Translating ${skills.length} skill(s) to ${targetAgent}...
+`));
+    let success = 0;
+    let failed = 0;
+    for (const skill of skills) {
+      const skillMdPath = join5(skill.path, "SKILL.md");
+      if (!existsSync7(skillMdPath)) {
+        console.log(chalk11.yellow(`  \u26A0 ${skill.name}: No SKILL.md found`));
+        failed++;
+        continue;
+      }
+      const result = translateSkillFile(skillMdPath, targetAgent, {
+        addMetadata: this.metadata
+      });
+      if (result.success) {
+        if (this.dryRun) {
+          console.log(chalk11.green(`  \u2713 ${skill.name} \u2192 ${result.filename} (dry run)`));
+          if (result.warnings.length > 0) {
+            for (const warning of result.warnings) {
+              console.log(chalk11.gray(`      ${warning}`));
+            }
+          }
+        } else {
+          const targetAdapter = getAdapter5(targetAgent);
+          const outputDir = this.output || join5(process.cwd(), targetAdapter.skillsDir, skill.name);
+          if (!existsSync7(outputDir)) {
+            mkdirSync4(outputDir, { recursive: true });
+          }
+          const outputPath = join5(outputDir, result.filename);
+          if (existsSync7(outputPath) && !this.force) {
+            console.log(chalk11.yellow(`  \u26A0 ${skill.name}: ${outputPath} exists (use --force)`));
+            failed++;
+            continue;
+          }
+          writeFileSync3(outputPath, result.content, "utf-8");
+          console.log(chalk11.green(`  \u2713 ${skill.name} \u2192 ${outputPath}`));
+        }
+        if (result.incompatible.length > 0) {
+          for (const item of result.incompatible) {
+            console.log(chalk11.gray(`      \u26A0 ${item}`));
+          }
+        }
+        success++;
+      } else {
+        console.log(chalk11.red(`  \u2717 ${skill.name}: Translation failed`));
+        for (const item of result.incompatible) {
+          console.log(chalk11.red(`      ${item}`));
+        }
+        failed++;
+      }
+    }
+    console.log();
+    console.log(chalk11.bold(`Translated: ${success}, Failed: ${failed}`));
+    return failed > 0 ? 1 : 0;
+  }
+  /**
+   * Translate a single skill
+   */
+  async translateSingle(source, targetAgent) {
+    let sourcePath;
+    let skillName;
+    if (existsSync7(source)) {
+      sourcePath = source;
+      skillName = basename2(dirname2(source));
+      if (skillName === ".") {
+        skillName = basename2(source).replace(/\.(md|mdc)$/i, "");
+      }
+    } else {
+      const searchDirs = getSearchDirs();
+      let found = false;
+      for (const dir of searchDirs) {
+        const skillPath = join5(dir, source);
+        const skillMdPath = join5(skillPath, "SKILL.md");
+        if (existsSync7(skillMdPath)) {
+          sourcePath = skillMdPath;
+          skillName = source;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        console.error(chalk11.red(`Error: Skill "${source}" not found`));
+        console.log(chalk11.gray("Searched in:"));
+        for (const dir of searchDirs) {
+          console.log(chalk11.gray(`  ${dir}`));
+        }
+        return 1;
+      }
+    }
+    const content = readFileSync2(sourcePath, "utf-8");
+    const result = translateSkill(content, targetAgent, {
+      addMetadata: this.metadata,
+      sourceFilename: basename2(sourcePath)
+    });
+    if (!result.success) {
+      console.error(chalk11.red("Translation failed:"));
+      for (const item of result.incompatible) {
+        console.error(chalk11.red(`  ${item}`));
+      }
+      return 1;
+    }
+    if (result.warnings.length > 0) {
+      console.log(chalk11.yellow("\nWarnings:"));
+      for (const warning of result.warnings) {
+        console.log(chalk11.yellow(`  \u2022 ${warning}`));
+      }
+    }
+    if (result.incompatible.length > 0) {
+      console.log(chalk11.gray("\nIncompatible features:"));
+      for (const item of result.incompatible) {
+        console.log(chalk11.gray(`  \u2022 ${item}`));
+      }
+    }
+    if (this.dryRun) {
+      console.log(chalk11.bold(`
+Translated content (${result.filename}):
+`));
+      console.log(chalk11.gray("\u2500".repeat(60)));
+      console.log(result.content);
+      console.log(chalk11.gray("\u2500".repeat(60)));
+      return 0;
+    }
+    let outputPath;
+    if (this.output) {
+      outputPath = this.output;
+    } else {
+      const targetAdapter = getAdapter5(targetAgent);
+      const outputDir2 = join5(process.cwd(), targetAdapter.skillsDir, skillName);
+      if (!existsSync7(outputDir2)) {
+        mkdirSync4(outputDir2, { recursive: true });
+      }
+      outputPath = join5(outputDir2, result.filename);
+    }
+    if (existsSync7(outputPath) && !this.force) {
+      console.error(chalk11.red(`Error: ${outputPath} already exists`));
+      console.log(chalk11.gray("Use --force to overwrite"));
+      return 1;
+    }
+    const outputDir = dirname2(outputPath);
+    if (!existsSync7(outputDir)) {
+      mkdirSync4(outputDir, { recursive: true });
+    }
+    writeFileSync3(outputPath, result.content, "utf-8");
+    console.log(chalk11.green(`
+\u2713 Translated to ${outputPath}`));
+    console.log(chalk11.gray(`  Format: ${result.targetFormat}`));
+    console.log(chalk11.gray(`  Agent: ${result.targetAgent}`));
+    return 0;
+  }
+};
+
+// src/commands/context.ts
+import { Command as Command13, Option as Option12 } from "clipanion";
+import { existsSync as existsSync8, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { resolve } from "path";
+import chalk12 from "chalk";
+import {
+  ContextManager,
+  createContextSync,
+  analyzeProject,
+  getStackTags
+} from "@skillkit/core";
+import { getAllAdapters as getAllAdapters3 } from "@skillkit/agents";
+var ContextCommand = class extends Command13 {
+  static paths = [["context"]];
+  static usage = Command13.Usage({
+    description: "Manage project context for multi-agent skill synchronization",
+    details: `
+      The context command helps you configure your project once and sync skills
+      across all AI coding agents.
+
+      Subcommands:
+      - init:   Initialize project context with auto-detection
+      - show:   Display current project context
+      - export: Export context to a file
+      - import: Import context from a file
+      - sync:   Sync skills to all configured agents
+      - detect: Run project detection
+    `,
+    examples: [
+      ["Initialize project context", "$0 context init"],
+      ["Show current context", "$0 context show"],
+      ["Sync skills to all agents", "$0 context sync"],
+      ["Sync to specific agent", "$0 context sync --agent cursor"],
+      ["Export context", "$0 context export --output context.yaml"]
+    ]
+  });
+  // Subcommand (init, show, export, import, sync, detect)
+  action = Option12.String({ required: false });
+  // Agent filter
+  agent = Option12.String("--agent,-a", {
+    description: "Target agent for sync"
+  });
+  // Output file for export
+  output = Option12.String("--output,-o", {
+    description: "Output file path"
+  });
+  // Input file for import
+  input = Option12.String("--input,-i", {
+    description: "Input file path"
+  });
+  // Force overwrite
+  force = Option12.Boolean("--force,-f", false, {
+    description: "Force overwrite existing files"
+  });
+  // Dry run
+  dryRun = Option12.Boolean("--dry-run,-n", false, {
+    description: "Preview without making changes"
+  });
+  // Merge on import
+  merge = Option12.Boolean("--merge,-m", false, {
+    description: "Merge with existing context on import"
+  });
+  // JSON output
+  json = Option12.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  // Verbose output
+  verbose = Option12.Boolean("--verbose,-v", false, {
+    description: "Show detailed output"
+  });
+  async execute() {
+    const action = this.action || "show";
+    switch (action) {
+      case "init":
+        return this.initContext();
+      case "show":
+        return this.showContext();
+      case "export":
+        return this.exportContext();
+      case "import":
+        return this.importContext();
+      case "sync":
+        return this.syncContext();
+      case "detect":
+        return this.detectProject();
+      case "agents":
+        return this.listAgents();
+      default:
+        console.error(chalk12.red(`Unknown action: ${action}`));
+        console.log(chalk12.gray("Available actions: init, show, export, import, sync, detect, agents"));
+        return 1;
+    }
+  }
+  /**
+   * Initialize project context
+   */
+  async initContext() {
+    const manager = new ContextManager(process.cwd());
+    if (manager.exists() && !this.force) {
+      console.log(chalk12.yellow("Context already exists. Use --force to reinitialize."));
+      return this.showContext();
+    }
+    console.log(chalk12.cyan("Initializing project context...\n"));
+    const context = manager.init({ force: this.force });
+    console.log(chalk12.green("\u2713 Context initialized\n"));
+    console.log(chalk12.gray(`  Location: .skillkit/context.yaml
+`));
+    this.printContextSummary(context);
+    const sync = createContextSync(process.cwd());
+    const detected = sync.detectAgents();
+    if (detected.length > 0) {
+      console.log(chalk12.cyan("\nDetected agents:"));
+      for (const agent of detected) {
+        console.log(`  ${chalk12.green("\u2022")} ${agent}`);
+      }
+      manager.updateAgents({
+        detected,
+        synced: detected
+      });
+    }
+    console.log(chalk12.gray("\nRun `skillkit context sync` to sync skills to all agents."));
+    return 0;
+  }
+  /**
+   * Show current context
+   */
+  async showContext() {
+    const manager = new ContextManager(process.cwd());
+    const context = manager.load();
+    if (!context) {
+      console.log(chalk12.yellow("No context found. Run `skillkit context init` first."));
+      return 1;
+    }
+    if (this.json) {
+      console.log(JSON.stringify(context, null, 2));
+      return 0;
+    }
+    this.printContextSummary(context);
+    if (this.verbose) {
+      console.log(chalk12.gray("\nFull context:"));
+      console.log(chalk12.gray(JSON.stringify(context, null, 2)));
+    }
+    return 0;
+  }
+  /**
+   * Export context to file
+   */
+  async exportContext() {
+    const manager = new ContextManager(process.cwd());
+    const context = manager.get();
+    if (!context) {
+      console.error(chalk12.red("No context found. Run `skillkit context init` first."));
+      return 1;
+    }
+    const format = this.json ? "json" : "yaml";
+    const content = manager.export({
+      format,
+      includeSkills: true,
+      includeAgents: true
+    });
+    if (this.output) {
+      const outputPath = resolve(this.output);
+      if (existsSync8(outputPath) && !this.force) {
+        console.error(chalk12.red(`File exists: ${outputPath}. Use --force to overwrite.`));
+        return 1;
+      }
+      writeFileSync4(outputPath, content, "utf-8");
+      console.log(chalk12.green(`\u2713 Context exported to ${outputPath}`));
+    } else {
+      console.log(content);
+    }
+    return 0;
+  }
+  /**
+   * Import context from file
+   */
+  async importContext() {
+    if (!this.input) {
+      console.error(chalk12.red("Error: --input/-i file path is required"));
+      return 1;
+    }
+    const inputPath = resolve(this.input);
+    if (!existsSync8(inputPath)) {
+      console.error(chalk12.red(`File not found: ${inputPath}`));
+      return 1;
+    }
+    const manager = new ContextManager(process.cwd());
+    const content = readFileSync3(inputPath, "utf-8");
+    try {
+      const context = manager.import(content, {
+        merge: this.merge,
+        overwrite: this.force
+      });
+      console.log(chalk12.green("\u2713 Context imported successfully"));
+      this.printContextSummary(context);
+      return 0;
+    } catch (error) {
+      console.error(chalk12.red(`Import failed: ${error}`));
+      return 1;
+    }
+  }
+  /**
+   * Sync skills to all configured agents
+   */
+  async syncContext() {
+    const manager = new ContextManager(process.cwd());
+    const context = manager.get();
+    if (!context) {
+      console.log(chalk12.yellow("No context found. Initializing..."));
+      manager.init();
+    }
+    const sync = createContextSync(process.cwd());
+    console.log(chalk12.cyan("Syncing skills across agents...\n"));
+    const agents = this.agent ? [this.agent] : void 0;
+    const report = await sync.syncAll({
+      agents,
+      force: this.force,
+      dryRun: this.dryRun
+    });
+    for (const result of report.results) {
+      const status = result.success ? chalk12.green("\u2713") : chalk12.red("\u2717");
+      console.log(`${status} ${result.agent}: ${result.skillsSynced} synced, ${result.skillsSkipped} skipped`);
+      if (this.verbose && result.files.length > 0) {
+        for (const file of result.files) {
+          console.log(chalk12.gray(`    \u2192 ${file}`));
+        }
+      }
+      if (result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+          console.log(chalk12.yellow(`    \u26A0 ${warning}`));
+        }
+      }
+      if (result.errors.length > 0) {
+        for (const error of result.errors) {
+          console.log(chalk12.red(`    \u2717 ${error}`));
+        }
+      }
+    }
+    console.log();
+    console.log(chalk12.bold(`Summary: ${report.successfulAgents}/${report.totalAgents} agents, ${report.totalSkills} skills`));
+    if (this.dryRun) {
+      console.log(chalk12.gray("\n(Dry run - no files were written)"));
+    }
+    return report.successfulAgents === report.totalAgents ? 0 : 1;
+  }
+  /**
+   * Detect project stack
+   */
+  async detectProject() {
+    console.log(chalk12.cyan("Analyzing project...\n"));
+    const stack = analyzeProject(process.cwd());
+    const tags = getStackTags(stack);
+    if (stack.languages.length > 0) {
+      console.log(chalk12.bold("Languages:"));
+      for (const lang of stack.languages) {
+        const version = lang.version ? ` (${lang.version})` : "";
+        console.log(`  ${chalk12.green("\u2022")} ${lang.name}${version}`);
+      }
+      console.log();
+    }
+    if (stack.frameworks.length > 0) {
+      console.log(chalk12.bold("Frameworks:"));
+      for (const fw of stack.frameworks) {
+        const version = fw.version ? ` (${fw.version})` : "";
+        console.log(`  ${chalk12.green("\u2022")} ${fw.name}${version}`);
+      }
+      console.log();
+    }
+    if (stack.libraries.length > 0) {
+      console.log(chalk12.bold("Libraries:"));
+      for (const lib of stack.libraries) {
+        const version = lib.version ? ` (${lib.version})` : "";
+        console.log(`  ${chalk12.green("\u2022")} ${lib.name}${version}`);
+      }
+      console.log();
+    }
+    if (stack.styling.length > 0) {
+      console.log(chalk12.bold("Styling:"));
+      for (const style of stack.styling) {
+        console.log(`  ${chalk12.green("\u2022")} ${style.name}`);
+      }
+      console.log();
+    }
+    if (stack.testing.length > 0) {
+      console.log(chalk12.bold("Testing:"));
+      for (const test of stack.testing) {
+        console.log(`  ${chalk12.green("\u2022")} ${test.name}`);
+      }
+      console.log();
+    }
+    if (stack.databases.length > 0) {
+      console.log(chalk12.bold("Databases:"));
+      for (const db of stack.databases) {
+        console.log(`  ${chalk12.green("\u2022")} ${db.name}`);
+      }
+      console.log();
+    }
+    if (stack.tools.length > 0) {
+      console.log(chalk12.bold("Tools:"));
+      for (const tool of stack.tools) {
+        console.log(`  ${chalk12.green("\u2022")} ${tool.name}`);
+      }
+      console.log();
+    }
+    if (tags.length > 0) {
+      console.log(chalk12.bold("Recommended skill tags:"));
+      console.log(`  ${chalk12.cyan(tags.join(", "))}`);
+      console.log();
+    }
+    if (this.json) {
+      console.log(chalk12.gray("\nJSON:"));
+      console.log(JSON.stringify(stack, null, 2));
+    }
+    return 0;
+  }
+  /**
+   * List detected agents
+   */
+  async listAgents() {
+    const sync = createContextSync(process.cwd());
+    const detected = sync.detectAgents();
+    const status = sync.checkStatus();
+    const adapters = getAllAdapters3();
+    console.log(chalk12.bold("\nAgent Status:\n"));
+    for (const [agent, info] of Object.entries(status)) {
+      const adapter = adapters.find((a) => a.type === agent);
+      const name = adapter?.name || agent;
+      const isDetected = detected.includes(agent);
+      const statusIcon = info.hasSkills ? chalk12.green("\u25CF") : isDetected ? chalk12.yellow("\u25CB") : chalk12.gray("\u25CB");
+      const skillInfo = info.skillCount > 0 ? chalk12.gray(` (${info.skillCount} skills)`) : "";
+      console.log(`  ${statusIcon} ${name.padEnd(20)} ${chalk12.gray(agent)}${skillInfo}`);
+      if (this.verbose && info.skills.length > 0) {
+        for (const skill of info.skills) {
+          console.log(chalk12.gray(`      \u2514\u2500 ${skill}`));
+        }
+      }
+    }
+    console.log();
+    console.log(chalk12.gray("Legend: \u25CF has skills, \u25CB detected/configured, \u25CB not detected"));
+    console.log();
+    return 0;
+  }
+  /**
+   * Print context summary
+   */
+  printContextSummary(context) {
+    console.log(chalk12.bold("Project:"));
+    console.log(`  Name: ${chalk12.cyan(context.project.name)}`);
+    if (context.project.type) {
+      console.log(`  Type: ${context.project.type}`);
+    }
+    if (context.project.description) {
+      console.log(`  Description: ${context.project.description}`);
+    }
+    const stackItems = [];
+    if (context.stack.languages.length > 0) {
+      stackItems.push(`${context.stack.languages.length} languages`);
+    }
+    if (context.stack.frameworks.length > 0) {
+      stackItems.push(`${context.stack.frameworks.length} frameworks`);
+    }
+    if (context.stack.libraries.length > 0) {
+      stackItems.push(`${context.stack.libraries.length} libraries`);
+    }
+    if (context.stack.databases.length > 0) {
+      stackItems.push(`${context.stack.databases.length} databases`);
+    }
+    if (stackItems.length > 0) {
+      console.log(`
+${chalk12.bold("Stack:")} ${stackItems.join(", ")}`);
+      const topFrameworks = context.stack.frameworks.slice(0, 3).map((f) => f.name);
+      if (topFrameworks.length > 0) {
+        console.log(`  Frameworks: ${chalk12.cyan(topFrameworks.join(", "))}`);
+      }
+      const topLibs = context.stack.libraries.slice(0, 3).map((l) => l.name);
+      if (topLibs.length > 0) {
+        console.log(`  Libraries: ${chalk12.cyan(topLibs.join(", "))}`);
+      }
+    }
+    if (context.skills) {
+      console.log(`
+${chalk12.bold("Skills:")}`);
+      console.log(`  Installed: ${context.skills.installed?.length || 0}`);
+      console.log(`  Auto-sync: ${context.skills.autoSync ? "enabled" : "disabled"}`);
+    }
+    if (context.agents) {
+      console.log(`
+${chalk12.bold("Agents:")}`);
+      if (context.agents.primary) {
+        console.log(`  Primary: ${chalk12.cyan(context.agents.primary)}`);
+      }
+      if (context.agents.synced?.length) {
+        console.log(`  Synced: ${context.agents.synced.join(", ")}`);
+      }
+    }
+  }
+};
+
+// src/commands/recommend.ts
+import { Command as Command14, Option as Option13 } from "clipanion";
+import { existsSync as existsSync9, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve2, join as join6 } from "path";
+import chalk13 from "chalk";
+import {
+  ContextManager as ContextManager2,
+  RecommendationEngine
+} from "@skillkit/core";
+var INDEX_PATH = join6(process.env.HOME || "~", ".skillkit", "index.json");
+var INDEX_CACHE_HOURS = 24;
+var RecommendCommand = class extends Command14 {
+  static paths = [["recommend"], ["rec"]];
+  static usage = Command14.Usage({
+    description: "Get skill recommendations based on your project",
+    details: `
+      The recommend command analyzes your project and suggests skills that match
+      your technology stack, frameworks, and patterns.
+
+      It scores skills based on:
+      - Framework compatibility (React, Vue, Next.js, etc.)
+      - Language match (TypeScript, Python, etc.)
+      - Library alignment (Tailwind, Prisma, etc.)
+      - Tag relevance
+      - Popularity and quality metrics
+
+      Run "skillkit recommend --update" to refresh the skill index from known sources.
+    `,
+    examples: [
+      ["Get recommendations", "$0 recommend"],
+      ["Show top 5 recommendations", "$0 recommend --limit 5"],
+      ["Filter by category", "$0 recommend --category security"],
+      ["Show detailed reasons", "$0 recommend --verbose"],
+      ["Update skill index", "$0 recommend --update"],
+      ["Search for skills by task", '$0 recommend --search "authentication"']
+    ]
+  });
+  // Limit number of results
+  limit = Option13.String("--limit,-l", {
+    description: "Maximum number of recommendations"
+  });
+  // Minimum score threshold
+  minScore = Option13.String("--min-score", {
+    description: "Minimum match score (0-100)"
+  });
+  // Filter by category/tag
+  category = Option13.Array("--category,-c", {
+    description: "Filter by category (can be used multiple times)"
+  });
+  // Verbose output with reasons
+  verbose = Option13.Boolean("--verbose,-v", false, {
+    description: "Show detailed match reasons"
+  });
+  // Update index
+  update = Option13.Boolean("--update,-u", false, {
+    description: "Update skill index from sources"
+  });
+  // Search mode
+  search = Option13.String("--search,-s", {
+    description: "Search skills by task/query"
+  });
+  // Include installed skills
+  includeInstalled = Option13.Boolean("--include-installed", false, {
+    description: "Include already installed skills"
+  });
+  // JSON output
+  json = Option13.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  // Project path
+  projectPath = Option13.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve2(this.projectPath || process.cwd());
+    if (this.update) {
+      return this.updateIndex();
+    }
+    const profile = await this.getProjectProfile(targetPath);
+    if (!profile) {
+      console.error(chalk13.red("Failed to analyze project"));
+      return 1;
+    }
+    const index = this.loadIndex();
+    if (!index || index.skills.length === 0) {
+      console.log(chalk13.yellow("No skill index found."));
+      console.log(chalk13.dim('Run "skillkit recommend --update" to fetch skills from known sources.'));
+      console.log(chalk13.dim('Or install skills manually with "skillkit install <source>"\n'));
+      this.showProjectProfile(profile);
+      return 0;
+    }
+    const engine = new RecommendationEngine();
+    engine.loadIndex(index);
+    if (this.search) {
+      return this.handleSearch(engine, this.search);
+    }
+    const result = engine.recommend(profile, {
+      limit: this.limit ? parseInt(this.limit, 10) : 10,
+      minScore: this.minScore ? parseInt(this.minScore, 10) : 30,
+      categories: this.category,
+      excludeInstalled: !this.includeInstalled,
+      includeReasons: this.verbose
+    });
+    if (this.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return 0;
+    }
+    this.displayRecommendations(result.recommendations, profile, result.totalSkillsScanned);
+    return 0;
+  }
+  /**
+   * Get project profile from context or by analyzing project
+   */
+  async getProjectProfile(projectPath) {
+    const manager = new ContextManager2(projectPath);
+    let context = manager.get();
+    if (!context) {
+      if (!this.json) {
+        console.log(chalk13.dim("Analyzing project...\n"));
+      }
+      context = manager.init();
+    }
+    if (!context) {
+      return null;
+    }
+    return {
+      name: context.project.name,
+      type: context.project.type,
+      stack: context.stack,
+      patterns: context.patterns,
+      installedSkills: context.skills?.installed || [],
+      excludedSkills: context.skills?.excluded || []
+    };
+  }
+  /**
+   * Show project profile summary
+   */
+  showProjectProfile(profile) {
+    console.log(chalk13.cyan("Project Profile:"));
+    console.log(`  Name: ${chalk13.bold(profile.name)}`);
+    if (profile.type) {
+      console.log(`  Type: ${profile.type}`);
+    }
+    const stackItems = [];
+    for (const lang of profile.stack.languages) {
+      stackItems.push(`${lang.name}${lang.version ? ` ${lang.version}` : ""}`);
+    }
+    for (const fw of profile.stack.frameworks) {
+      stackItems.push(`${fw.name}${fw.version ? ` ${fw.version}` : ""}`);
+    }
+    if (stackItems.length > 0) {
+      console.log(`  Stack: ${chalk13.dim(stackItems.join(", "))}`);
+    }
+    console.log();
+  }
+  /**
+   * Display recommendations
+   */
+  displayRecommendations(recommendations, profile, totalScanned) {
+    this.showProjectProfile(profile);
+    if (recommendations.length === 0) {
+      console.log(chalk13.yellow("No matching skills found."));
+      console.log(chalk13.dim("Try lowering the minimum score with --min-score"));
+      return;
+    }
+    console.log(chalk13.cyan(`Recommended Skills (${recommendations.length} of ${totalScanned} scanned):
+`));
+    for (const rec of recommendations) {
+      const scoreColor = rec.score >= 70 ? chalk13.green : rec.score >= 50 ? chalk13.yellow : chalk13.dim;
+      const scoreBar = this.getScoreBar(rec.score);
+      console.log(`  ${scoreColor(`${rec.score}%`)} ${scoreBar} ${chalk13.bold(rec.skill.name)}`);
+      if (rec.skill.description) {
+        console.log(`      ${chalk13.dim(truncate2(rec.skill.description, 70))}`);
+      }
+      if (rec.skill.source) {
+        console.log(`      ${chalk13.dim("Source:")} ${rec.skill.source}`);
+      }
+      if (this.verbose && rec.reasons.length > 0) {
+        console.log(chalk13.dim("      Reasons:"));
+        for (const reason of rec.reasons.filter((r) => r.weight > 0)) {
+          console.log(`        ${chalk13.dim("\u2022")} ${reason.description} (+${reason.weight})`);
+        }
+      }
+      if (rec.warnings.length > 0) {
+        for (const warning of rec.warnings) {
+          console.log(`      ${chalk13.yellow("\u26A0")} ${warning}`);
+        }
+      }
+      console.log();
+    }
+    console.log(chalk13.dim("Install with: skillkit install <source>"));
+  }
+  /**
+   * Generate a visual score bar
+   */
+  getScoreBar(score) {
+    const filled = Math.round(score / 10);
+    const empty = 10 - filled;
+    return chalk13.green("\u2588".repeat(filled)) + chalk13.dim("\u2591".repeat(empty));
+  }
+  /**
+   * Handle search mode
+   */
+  handleSearch(engine, query) {
+    const results = engine.search({
+      query,
+      limit: this.limit ? parseInt(this.limit, 10) : 10,
+      semantic: true,
+      filters: {
+        minScore: this.minScore ? parseInt(this.minScore, 10) : void 0
+      }
+    });
+    if (this.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return 0;
+    }
+    if (results.length === 0) {
+      console.log(chalk13.yellow(`No skills found matching "${query}"`));
+      return 0;
+    }
+    console.log(chalk13.cyan(`Search results for "${query}" (${results.length} found):
+`));
+    for (const result of results) {
+      const relevanceColor = result.relevance >= 70 ? chalk13.green : result.relevance >= 50 ? chalk13.yellow : chalk13.dim;
+      console.log(`  ${relevanceColor(`${result.relevance}%`)} ${chalk13.bold(result.skill.name)}`);
+      if (result.snippet) {
+        console.log(`      ${chalk13.dim(result.snippet)}`);
+      }
+      if (result.matchedTerms.length > 0) {
+        console.log(`      ${chalk13.dim("Matched:")} ${result.matchedTerms.join(", ")}`);
+      }
+      console.log();
+    }
+    return 0;
+  }
+  /**
+   * Load skill index from cache
+   */
+  loadIndex() {
+    if (!existsSync9(INDEX_PATH)) {
+      return null;
+    }
+    try {
+      const content = readFileSync4(INDEX_PATH, "utf-8");
+      const index = JSON.parse(content);
+      const lastUpdated = new Date(index.lastUpdated);
+      const hoursSinceUpdate = (Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60);
+      if (hoursSinceUpdate > INDEX_CACHE_HOURS && !this.json) {
+        console.log(
+          chalk13.dim(`Index is ${Math.round(hoursSinceUpdate)} hours old. Run --update to refresh.
+`)
+        );
+      }
+      return index;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Update skill index from sources
+   */
+  updateIndex() {
+    console.log(chalk13.cyan("Updating skill index...\n"));
+    const sampleIndex = {
+      version: 1,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      skills: getSampleSkills(),
+      sources: [
+        {
+          name: "vercel-labs",
+          url: "https://github.com/vercel-labs/agent-skills",
+          lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
+          skillCount: 5
+        },
+        {
+          name: "anthropics",
+          url: "https://github.com/anthropics/skills",
+          lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
+          skillCount: 3
+        }
+      ]
+    };
+    const indexDir = join6(process.env.HOME || "~", ".skillkit");
+    if (!existsSync9(indexDir)) {
+      mkdirSync5(indexDir, { recursive: true });
+    }
+    writeFileSync5(INDEX_PATH, JSON.stringify(sampleIndex, null, 2));
+    console.log(chalk13.green(`\u2713 Updated index with ${sampleIndex.skills.length} skills`));
+    console.log(chalk13.dim(`  Sources: ${sampleIndex.sources.map((s) => s.name).join(", ")}`));
+    console.log(chalk13.dim(`  Saved to: ${INDEX_PATH}
+`));
+    return 0;
+  }
+};
+function truncate2(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function getSampleSkills() {
+  return [
+    {
+      name: "vercel-react-best-practices",
+      description: "Modern React patterns including Server Components, hooks best practices, and performance optimization",
+      source: "vercel-labs/agent-skills",
+      tags: ["react", "frontend", "typescript", "nextjs", "performance"],
+      compatibility: {
+        frameworks: ["react", "nextjs"],
+        languages: ["typescript", "javascript"],
+        libraries: []
+      },
+      popularity: 1500,
+      quality: 95,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    },
+    {
+      name: "tailwind-v4-patterns",
+      description: "Tailwind CSS v4 utility patterns, responsive design, and component styling best practices",
+      source: "vercel-labs/agent-skills",
+      tags: ["tailwind", "css", "styling", "frontend", "responsive"],
+      compatibility: {
+        frameworks: [],
+        languages: ["typescript", "javascript"],
+        libraries: ["tailwindcss"]
+      },
+      popularity: 1200,
+      quality: 92,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    },
+    {
+      name: "nextjs-app-router",
+      description: "Next.js App Router patterns including layouts, server actions, and data fetching",
+      source: "vercel-labs/agent-skills",
+      tags: ["nextjs", "react", "routing", "server-actions", "frontend"],
+      compatibility: {
+        frameworks: ["nextjs"],
+        languages: ["typescript", "javascript"],
+        libraries: []
+      },
+      popularity: 1100,
+      quality: 94,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    },
+    {
+      name: "typescript-strict-patterns",
+      description: "TypeScript strict mode patterns, type safety, and advanced type utilities",
+      source: "anthropics/skills",
+      tags: ["typescript", "types", "safety", "patterns"],
+      compatibility: {
+        frameworks: [],
+        languages: ["typescript"],
+        libraries: []
+      },
+      popularity: 900,
+      quality: 90,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    },
+    {
+      name: "supabase-best-practices",
+      description: "Supabase integration patterns including auth, database queries, and real-time subscriptions",
+      source: "anthropics/skills",
+      tags: ["supabase", "database", "auth", "backend", "postgresql"],
+      compatibility: {
+        frameworks: [],
+        languages: ["typescript", "javascript"],
+        libraries: ["@supabase/supabase-js"]
+      },
+      popularity: 800,
+      quality: 88,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    },
+    {
+      name: "vitest-testing-patterns",
+      description: "Testing patterns with Vitest including mocking, assertions, and test organization",
+      source: "anthropics/skills",
+      tags: ["vitest", "testing", "typescript", "mocking", "tdd"],
+      compatibility: {
+        frameworks: [],
+        languages: ["typescript", "javascript"],
+        libraries: ["vitest"]
+      },
+      popularity: 700,
+      quality: 86,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: false
+    },
+    {
+      name: "prisma-database-patterns",
+      description: "Prisma ORM patterns for schema design, migrations, and efficient queries",
+      source: "vercel-labs/agent-skills",
+      tags: ["prisma", "database", "orm", "postgresql", "backend"],
+      compatibility: {
+        frameworks: [],
+        languages: ["typescript"],
+        libraries: ["@prisma/client"]
+      },
+      popularity: 850,
+      quality: 89,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    },
+    {
+      name: "security-best-practices",
+      description: "Security patterns for web applications including XSS prevention, CSRF, and secure headers",
+      source: "trailofbits/skills",
+      tags: ["security", "xss", "csrf", "headers", "owasp"],
+      compatibility: {
+        frameworks: [],
+        languages: ["typescript", "javascript", "python"],
+        libraries: []
+      },
+      popularity: 600,
+      quality: 95,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    },
+    {
+      name: "python-fastapi-patterns",
+      description: "FastAPI best practices for building high-performance Python APIs",
+      source: "python-skills/fastapi",
+      tags: ["python", "fastapi", "backend", "api", "async"],
+      compatibility: {
+        frameworks: ["fastapi"],
+        languages: ["python"],
+        libraries: []
+      },
+      popularity: 550,
+      quality: 85,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: false
+    },
+    {
+      name: "zustand-state-management",
+      description: "Zustand state management patterns for React applications",
+      source: "react-skills/state",
+      tags: ["zustand", "react", "state-management", "frontend"],
+      compatibility: {
+        frameworks: ["react"],
+        languages: ["typescript", "javascript"],
+        libraries: ["zustand"]
+      },
+      popularity: 650,
+      quality: 84,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: false
+    }
+  ];
+}
+export {
+  ContextCommand,
+  CreateCommand,
+  DisableCommand,
+  EnableCommand,
+  InitCommand,
+  InstallCommand,
+  ListCommand,
+  ReadCommand,
+  RecommendCommand,
+  RemoveCommand,
+  SyncCommand,
+  TranslateCommand,
+  UICommand,
+  UpdateCommand,
+  ValidateCommand,
+  getAgentConfigPath,
+  getInstallDir,
+  getSearchDirs,
+  initProject,
+  loadSkillMetadata,
+  saveSkillMetadata
+};
+//# sourceMappingURL=index.js.map