@codemcp/skills 1.8.1 → 2.1.0

package/dist/cli.js

@@ -0,0 +1,1883 @@
+#!/usr/bin/env node
+import {
+  M,
+  Se,
+  Y,
+  agents,
+  detectInstalledAgents,
+  discoverSkills,
+  fe,
+  fetchSkillFolderHash,
+  getAllLockedSkills,
+  getCanonicalPath,
+  getCanonicalSkillsDir,
+  getGitHubToken,
+  getInstallPath,
+  getMCPCanonicalSkillsDir,
+  getSkillFromLock,
+  he,
+  initTelemetry,
+  isRepoPrivate,
+  listInstalledSkills,
+  pD,
+  parseAddOptions,
+  parseSyncOptions,
+  removeSkillFromLock,
+  require_picocolors,
+  runAdd,
+  runInstallFromLock,
+  runSync,
+  sanitizeName,
+  track,
+  ve,
+  xe,
+  ye
+} from "./chunk-US7NTYE7.js";
+import {
+  ConfigGeneratorRegistry,
+  GitHubCopilotGenerator,
+  KiroGenerator,
+  McpConfigAdapterRegistry,
+  OpenCodeAgentGenerator,
+  OpenCodeMcpGenerator,
+  VsCodeGenerator
+} from "./chunk-OAWSLH2D.js";
+import {
+  __toESM
+} from "./chunk-JSBRDJBE.js";
+
+// src/cli.ts
+import { spawnSync } from "child_process";
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { basename, join as join3, dirname as dirname2 } from "path";
+import { homedir as homedir4 } from "os";
+import { fileURLToPath } from "url";
+
+// src/find.ts
+import * as readline from "readline";
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[38;5;102m";
+var TEXT = "\x1B[38;5;145m";
+var CYAN = "\x1B[36m";
+var SEARCH_API_BASE = process.env.SKILLS_API_URL || "https://skills.sh";
+function formatInstalls(count) {
+  if (!count || count <= 0) return "";
+  if (count >= 1e6) return `${(count / 1e6).toFixed(1).replace(/\.0$/, "")}M installs`;
+  if (count >= 1e3) return `${(count / 1e3).toFixed(1).replace(/\.0$/, "")}K installs`;
+  return `${count} install${count === 1 ? "" : "s"}`;
+}
+async function searchSkillsAPI(query) {
+  try {
+    const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=10`;
+    const res = await fetch(url);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.skills.map((skill) => ({
+      name: skill.name,
+      slug: skill.id,
+      source: skill.source || "",
+      installs: skill.installs
+    }));
+  } catch {
+    return [];
+  }
+}
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var CLEAR_DOWN = "\x1B[J";
+var MOVE_UP = (n) => `\x1B[${n}A`;
+var MOVE_TO_COL = (n) => `\x1B[${n}G`;
+async function runSearchPrompt(initialQuery = "") {
+  let results = [];
+  let selectedIndex = 0;
+  let query = initialQuery;
+  let loading = false;
+  let debounceTimer = null;
+  let lastRenderedLines = 0;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.resume();
+  process.stdout.write(HIDE_CURSOR);
+  function render() {
+    if (lastRenderedLines > 0) {
+      process.stdout.write(MOVE_UP(lastRenderedLines) + MOVE_TO_COL(1));
+    }
+    process.stdout.write(CLEAR_DOWN);
+    const lines = [];
+    const cursor = `${BOLD}_${RESET}`;
+    lines.push(`${TEXT}Search skills:${RESET} ${query}${cursor}`);
+    lines.push("");
+    if (!query || query.length < 2) {
+      lines.push(`${DIM}Start typing to search (min 2 chars)${RESET}`);
+    } else if (results.length === 0 && loading) {
+      lines.push(`${DIM}Searching...${RESET}`);
+    } else if (results.length === 0) {
+      lines.push(`${DIM}No skills found${RESET}`);
+    } else {
+      const maxVisible = 8;
+      const visible = results.slice(0, maxVisible);
+      for (let i = 0; i < visible.length; i++) {
+        const skill = visible[i];
+        const isSelected = i === selectedIndex;
+        const arrow = isSelected ? `${BOLD}>${RESET}` : " ";
+        const name = isSelected ? `${BOLD}${skill.name}${RESET}` : `${TEXT}${skill.name}${RESET}`;
+        const source = skill.source ? ` ${DIM}${skill.source}${RESET}` : "";
+        const installs = formatInstalls(skill.installs);
+        const installsBadge = installs ? ` ${CYAN}${installs}${RESET}` : "";
+        const loadingIndicator = loading && i === 0 ? ` ${DIM}...${RESET}` : "";
+        lines.push(`  ${arrow} ${name}${source}${installsBadge}${loadingIndicator}`);
+      }
+    }
+    lines.push("");
+    lines.push(`${DIM}up/down navigate | enter select | esc cancel${RESET}`);
+    for (const line of lines) {
+      process.stdout.write(line + "\n");
+    }
+    lastRenderedLines = lines.length;
+  }
+  function triggerSearch(q) {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+    loading = false;
+    if (!q || q.length < 2) {
+      results = [];
+      selectedIndex = 0;
+      render();
+      return;
+    }
+    loading = true;
+    render();
+    const debounceMs = Math.max(150, 350 - q.length * 50);
+    debounceTimer = setTimeout(async () => {
+      try {
+        results = await searchSkillsAPI(q);
+        selectedIndex = 0;
+      } catch {
+        results = [];
+      } finally {
+        loading = false;
+        debounceTimer = null;
+        render();
+      }
+    }, debounceMs);
+  }
+  if (initialQuery) {
+    triggerSearch(initialQuery);
+  }
+  render();
+  return new Promise((resolve) => {
+    function cleanup() {
+      process.stdin.removeListener("keypress", handleKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdout.write(SHOW_CURSOR);
+      process.stdin.pause();
+    }
+    function handleKeypress(_ch, key) {
+      if (!key) return;
+      if (key.name === "escape" || key.ctrl && key.name === "c") {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (key.name === "return") {
+        cleanup();
+        resolve(results[selectedIndex] || null);
+        return;
+      }
+      if (key.name === "up") {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        render();
+        return;
+      }
+      if (key.name === "down") {
+        selectedIndex = Math.min(Math.max(0, results.length - 1), selectedIndex + 1);
+        render();
+        return;
+      }
+      if (key.name === "backspace") {
+        if (query.length > 0) {
+          query = query.slice(0, -1);
+          triggerSearch(query);
+        }
+        return;
+      }
+      if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+        const char = key.sequence;
+        if (char >= " " && char <= "~") {
+          query += char;
+          triggerSearch(query);
+        }
+      }
+    }
+    process.stdin.on("keypress", handleKeypress);
+  });
+}
+function getOwnerRepoFromString(pkg) {
+  const atIndex = pkg.lastIndexOf("@");
+  const repoPath = atIndex > 0 ? pkg.slice(0, atIndex) : pkg;
+  const match = repoPath.match(/^([^/]+)\/([^/]+)$/);
+  if (match) {
+    return { owner: match[1], repo: match[2] };
+  }
+  return null;
+}
+async function isRepoPublic(owner, repo) {
+  const isPrivate = await isRepoPrivate(owner, repo);
+  return isPrivate === false;
+}
+async function runFind(args) {
+  const query = args.join(" ");
+  const isNonInteractive = !process.stdin.isTTY;
+  const agentTip = `${DIM}Tip: if running in a coding agent, follow these steps:${RESET}
+${DIM}  1) npx @codemcp/skills find [query]${RESET}
+${DIM}  2) npx @codemcp/skills add <owner/repo@skill>${RESET}`;
+  if (query) {
+    const results = await searchSkillsAPI(query);
+    track({
+      event: "find",
+      query,
+      resultCount: String(results.length)
+    });
+    if (results.length === 0) {
+      console.log(`${DIM}No skills found for "${query}"${RESET}`);
+      return;
+    }
+    console.log(`${DIM}Install with${RESET} npx @codemcp/skills add <owner/repo@skill>`);
+    console.log();
+    for (const skill of results.slice(0, 6)) {
+      const pkg2 = skill.source || skill.slug;
+      const installs = formatInstalls(skill.installs);
+      console.log(
+        `${TEXT}${pkg2}@${skill.name}${RESET}${installs ? ` ${CYAN}${installs}${RESET}` : ""}`
+      );
+      console.log(`${DIM}\u2514 https://skills.sh/${skill.slug}${RESET}`);
+      console.log();
+    }
+    return;
+  }
+  if (isNonInteractive) {
+    console.log(agentTip);
+    console.log();
+  }
+  const selected = await runSearchPrompt();
+  track({
+    event: "find",
+    query: "",
+    resultCount: selected ? "1" : "0",
+    interactive: "1"
+  });
+  if (!selected) {
+    console.log(`${DIM}Search cancelled${RESET}`);
+    console.log();
+    return;
+  }
+  const pkg = selected.source || selected.slug;
+  const skillName = selected.name;
+  console.log();
+  console.log(`${TEXT}Installing ${BOLD}${skillName}${RESET} from ${DIM}${pkg}${RESET}...`);
+  console.log();
+  const { source, options } = parseAddOptions([pkg, "--skill", skillName]);
+  await runAdd(source, options);
+  console.log();
+  const info = getOwnerRepoFromString(pkg);
+  if (info && await isRepoPublic(info.owner, info.repo)) {
+    console.log(
+      `${DIM}View the skill at${RESET} ${TEXT}https://skills.sh/${selected.slug}${RESET}`
+    );
+  } else {
+    console.log(`${DIM}Discover more skills at${RESET} ${TEXT}https://skills.sh${RESET}`);
+  }
+  console.log();
+}
+
+// src/list.ts
+import { homedir } from "os";
+var RESET2 = "\x1B[0m";
+var BOLD2 = "\x1B[1m";
+var DIM2 = "\x1B[38;5;102m";
+var CYAN2 = "\x1B[36m";
+var YELLOW = "\x1B[33m";
+function shortenPath(fullPath, cwd) {
+  const home = homedir();
+  if (fullPath.startsWith(home)) {
+    return fullPath.replace(home, "~");
+  }
+  if (fullPath.startsWith(cwd)) {
+    return "." + fullPath.slice(cwd.length);
+  }
+  return fullPath;
+}
+function formatList(items, maxShow = 5) {
+  if (items.length <= maxShow) {
+    return items.join(", ");
+  }
+  const shown = items.slice(0, maxShow);
+  const remaining = items.length - maxShow;
+  return `${shown.join(", ")} +${remaining} more`;
+}
+function parseListOptions(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-g" || arg === "--global") {
+      options.global = true;
+    } else if (arg === "-a" || arg === "--agent") {
+      options.agent = options.agent || [];
+      while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        options.agent.push(args[++i]);
+      }
+    }
+  }
+  return options;
+}
+async function runList(args) {
+  const options = parseListOptions(args);
+  const scope = options.global === true ? true : false;
+  let agentFilter;
+  if (options.agent && options.agent.length > 0) {
+    const validAgents = Object.keys(agents);
+    const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+    if (invalidAgents.length > 0) {
+      console.log(`${YELLOW}Invalid agents: ${invalidAgents.join(", ")}${RESET2}`);
+      console.log(`${DIM2}Valid agents: ${validAgents.join(", ")}${RESET2}`);
+      process.exit(1);
+    }
+    agentFilter = options.agent;
+  }
+  const installedSkills = await listInstalledSkills({
+    global: scope,
+    agentFilter
+  });
+  const lockedSkills = await getAllLockedSkills();
+  const cwd = process.cwd();
+  const scopeLabel = scope ? "Global" : "Project";
+  if (installedSkills.length === 0) {
+    console.log(`${DIM2}No ${scopeLabel.toLowerCase()} skills found.${RESET2}`);
+    if (scope) {
+      console.log(`${DIM2}Try listing project skills without -g${RESET2}`);
+    } else {
+      console.log(`${DIM2}Try listing global skills with -g${RESET2}`);
+    }
+    return;
+  }
+  function printSkill(skill, indent = false) {
+    const prefix = indent ? "  " : "";
+    const shortPath = shortenPath(skill.canonicalPath, cwd);
+    const agentNames = skill.agents.map((a) => agents[a].displayName);
+    const agentInfo = skill.agents.length > 0 ? formatList(agentNames) : `${YELLOW}not linked${RESET2}`;
+    console.log(`${prefix}${CYAN2}${skill.name}${RESET2} ${DIM2}${shortPath}${RESET2}`);
+    console.log(`${prefix}  ${DIM2}Agents:${RESET2} ${agentInfo}`);
+  }
+  console.log(`${BOLD2}${scopeLabel} Skills${RESET2}`);
+  console.log();
+  const groupedSkills = {};
+  const ungroupedSkills = [];
+  for (const skill of installedSkills) {
+    const lockEntry = lockedSkills[skill.name];
+    if (lockEntry?.pluginName) {
+      const group = lockEntry.pluginName;
+      if (!groupedSkills[group]) {
+        groupedSkills[group] = [];
+      }
+      groupedSkills[group].push(skill);
+    } else {
+      ungroupedSkills.push(skill);
+    }
+  }
+  const hasGroups = Object.keys(groupedSkills).length > 0;
+  if (hasGroups) {
+    const sortedGroups = Object.keys(groupedSkills).sort();
+    for (const group of sortedGroups) {
+      const title = group.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      console.log(`${BOLD2}${title}${RESET2}`);
+      const skills = groupedSkills[group];
+      if (skills) {
+        for (const skill of skills) {
+          printSkill(skill, true);
+        }
+      }
+      console.log();
+    }
+    if (ungroupedSkills.length > 0) {
+      console.log(`${BOLD2}General${RESET2}`);
+      for (const skill of ungroupedSkills) {
+        printSkill(skill, true);
+      }
+      console.log();
+    }
+  } else {
+    for (const skill of installedSkills) {
+      printSkill(skill);
+    }
+    console.log();
+  }
+}
+
+// src/remove.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { readdir, rm, lstat } from "fs/promises";
+import { join } from "path";
+async function removeCommand(skillNames, options) {
+  const isGlobal = options.global ?? false;
+  const cwd = process.cwd();
+  const spinner = Y();
+  spinner.start("Scanning for installed skills...");
+  const skillNamesSet = /* @__PURE__ */ new Set();
+  const scanDir = async (dir) => {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          skillNamesSet.add(entry.name);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.code !== "ENOENT") {
+        M.warn(`Could not scan directory ${dir}: ${err.message}`);
+      }
+    }
+  };
+  if (isGlobal) {
+    await scanDir(getCanonicalSkillsDir(true, cwd));
+    for (const agent of Object.values(agents)) {
+      if (agent.globalSkillsDir !== void 0) {
+        await scanDir(agent.globalSkillsDir);
+      }
+    }
+  } else {
+    await scanDir(getCanonicalSkillsDir(false, cwd));
+    for (const agent of Object.values(agents)) {
+      await scanDir(join(cwd, agent.skillsDir));
+    }
+  }
+  const installedSkills = Array.from(skillNamesSet).sort();
+  spinner.stop(`Found ${installedSkills.length} unique installed skill(s)`);
+  if (installedSkills.length === 0) {
+    Se(import_picocolors.default.yellow("No skills found to remove."));
+    return;
+  }
+  if (options.agent && options.agent.length > 0) {
+    const validAgents = Object.keys(agents);
+    const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+    if (invalidAgents.length > 0) {
+      M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+      M.info(`Valid agents: ${validAgents.join(", ")}`);
+      process.exit(1);
+    }
+  }
+  let selectedSkills = [];
+  if (options.all) {
+    selectedSkills = installedSkills;
+  } else if (skillNames.length > 0) {
+    selectedSkills = installedSkills.filter(
+      (s) => skillNames.some((name) => name.toLowerCase() === s.toLowerCase())
+    );
+    if (selectedSkills.length === 0) {
+      M.error(`No matching skills found for: ${skillNames.join(", ")}`);
+      return;
+    }
+  } else {
+    const choices = installedSkills.map((s) => ({
+      value: s,
+      label: s
+    }));
+    const selected = await fe({
+      message: `Select skills to remove ${import_picocolors.default.dim("(space to toggle)")}`,
+      options: choices,
+      required: true
+    });
+    if (pD(selected)) {
+      xe("Removal cancelled");
+      process.exit(0);
+    }
+    selectedSkills = selected;
+  }
+  let targetAgents;
+  if (options.agent && options.agent.length > 0) {
+    targetAgents = options.agent;
+  } else {
+    targetAgents = Object.keys(agents);
+    spinner.stop(`Targeting ${targetAgents.length} potential agent(s)`);
+  }
+  if (!options.yes) {
+    console.log();
+    M.info("Skills to remove:");
+    for (const skill of selectedSkills) {
+      M.message(`  ${import_picocolors.default.red("\u2022")} ${skill}`);
+    }
+    console.log();
+    const confirmed = await ye({
+      message: `Are you sure you want to uninstall ${selectedSkills.length} skill(s)?`
+    });
+    if (pD(confirmed) || !confirmed) {
+      xe("Removal cancelled");
+      process.exit(0);
+    }
+  }
+  spinner.start("Removing skills...");
+  const results = [];
+  for (const skillName of selectedSkills) {
+    try {
+      const canonicalPath = getCanonicalPath(skillName, { global: isGlobal, cwd });
+      for (const agentKey of targetAgents) {
+        const agent = agents[agentKey];
+        const skillPath = getInstallPath(skillName, agentKey, { global: isGlobal, cwd });
+        const pathsToCleanup = /* @__PURE__ */ new Set([skillPath]);
+        const sanitizedName = sanitizeName(skillName);
+        if (isGlobal && agent.globalSkillsDir) {
+          pathsToCleanup.add(join(agent.globalSkillsDir, sanitizedName));
+        } else {
+          pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
+        }
+        for (const pathToCleanup of pathsToCleanup) {
+          if (pathToCleanup === canonicalPath) {
+            continue;
+          }
+          try {
+            const stats = await lstat(pathToCleanup).catch(() => null);
+            if (stats) {
+              await rm(pathToCleanup, { recursive: true, force: true });
+            }
+          } catch (err) {
+            M.warn(
+              `Could not remove skill from ${agent.displayName}: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
+      const installedAgents = await detectInstalledAgents();
+      const remainingAgents = installedAgents.filter((a) => !targetAgents.includes(a));
+      let isStillUsed = false;
+      for (const agentKey of remainingAgents) {
+        const path = getInstallPath(skillName, agentKey, { global: isGlobal, cwd });
+        const exists = await lstat(path).catch(() => null);
+        if (exists) {
+          isStillUsed = true;
+          break;
+        }
+      }
+      if (!isStillUsed) {
+        await rm(canonicalPath, { recursive: true, force: true });
+      }
+      const lockEntry = isGlobal ? await getSkillFromLock(skillName) : null;
+      const effectiveSource = lockEntry?.source || "local";
+      const effectiveSourceType = lockEntry?.sourceType || "local";
+      if (isGlobal) {
+        await removeSkillFromLock(skillName);
+      }
+      results.push({
+        skill: skillName,
+        success: true,
+        source: effectiveSource,
+        sourceType: effectiveSourceType
+      });
+    } catch (err) {
+      results.push({
+        skill: skillName,
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  spinner.stop("Removal process complete");
+  const successful = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+  if (successful.length > 0) {
+    const bySource = /* @__PURE__ */ new Map();
+    for (const r of successful) {
+      const source = r.source || "local";
+      const existing = bySource.get(source) || { skills: [] };
+      existing.skills.push(r.skill);
+      existing.sourceType = r.sourceType;
+      bySource.set(source, existing);
+    }
+    for (const [source, data] of bySource) {
+      track({
+        event: "remove",
+        source,
+        skills: data.skills.join(","),
+        agents: targetAgents.join(","),
+        ...isGlobal && { global: "1" },
+        sourceType: data.sourceType
+      });
+    }
+  }
+  if (successful.length > 0) {
+    M.success(import_picocolors.default.green(`Successfully removed ${successful.length} skill(s)`));
+  }
+  if (failed.length > 0) {
+    M.error(import_picocolors.default.red(`Failed to remove ${failed.length} skill(s)`));
+    for (const r of failed) {
+      M.message(`  ${import_picocolors.default.red("\u2717")} ${r.skill}: ${r.error}`);
+    }
+  }
+  console.log();
+  Se(import_picocolors.default.green("Done!"));
+}
+function parseRemoveOptions(args) {
+  const options = {};
+  const skills = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-g" || arg === "--global") {
+      options.global = true;
+    } else if (arg === "-y" || arg === "--yes") {
+      options.yes = true;
+    } else if (arg === "--all") {
+      options.all = true;
+    } else if (arg === "-a" || arg === "--agent") {
+      options.agent = options.agent || [];
+      i++;
+      let nextArg = args[i];
+      while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+        options.agent.push(nextArg);
+        i++;
+        nextArg = args[i];
+      }
+      i--;
+    } else if (arg && !arg.startsWith("-")) {
+      skills.push(arg);
+    }
+  }
+  return { skills, options };
+}
+
+// src/mcp.ts
+import { homedir as homedir3 } from "os";
+
+// src/mcp-configurator.ts
+import { promises as fs } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+var AGENT_TO_MCP_CLIENT = {
+  "claude-code": "claude-desktop",
+  claude: "claude-desktop",
+  cline: "cline",
+  cursor: "cursor",
+  "kiro-cli": "kiro",
+  kiro: "kiro",
+  junie: "junie",
+  opencode: "opencode",
+  zed: "zed",
+  continue: "continue",
+  "github-copilot": "github-copilot",
+  "mistral-vibe": "mistral-vibe",
+  windsurf: "windsurf",
+  codex: "codex",
+  "command-code": "command-code",
+  cortex: "cortex",
+  crush: "crush",
+  droid: "droid",
+  "gemini-cli": "gemini-cli",
+  goose: "goose",
+  "iflow-cli": "iflow-cli",
+  kilo: "kilo",
+  "kimi-cli": "kimi-cli",
+  kode: "kode",
+  mcpjam: "mcpjam",
+  mux: "mux",
+  neovate: "neovate",
+  openhands: "openhands",
+  pi: "pi",
+  qoder: "qoder",
+  "qwen-code": "qwen-code",
+  replit: "replit",
+  roo: "roo",
+  trae: "trae",
+  "trae-cn": "trae-cn",
+  zencoder: "zencoder",
+  pochi: "pochi",
+  adal: "adal",
+  universal: "universal",
+  amp: "amp",
+  antigravity: "antigravity",
+  augment: "augment",
+  openclaw: "openclaw",
+  codebuddy: "codebuddy"
+};
+function getAgentConfigPath(agentType, cwd, scope = "local") {
+  const mappedType = AGENT_TO_MCP_CLIENT[agentType] || agentType;
+  switch (mappedType) {
+    case "claude-desktop":
+      return join2(cwd, ".claude", "mcp.json");
+    case "cline":
+      return join2(cwd, ".cline", "mcp.json");
+    case "cursor":
+      return join2(cwd, ".cursor", "mcp.json");
+    case "kiro":
+      if (scope === "global") {
+        return join2(cwd, ".kiro", "agents", "default.json");
+      }
+      return join2(cwd, ".kiro", "mcp.json");
+    case "github-copilot":
+      return join2(cwd, ".vscode", "mcp.json");
+    case "junie":
+      return join2(cwd, ".junie", "mcp.json");
+    case "opencode":
+      if (scope === "global") {
+        return join2(cwd, ".config", "opencode", "opencode.json");
+      }
+      return join2(cwd, "opencode.json");
+    case "zed":
+      return join2(cwd, ".config", "zed", "settings.json");
+    case "continue":
+      return join2(cwd, ".continue", "config.json");
+    // For other agents, try to infer config path
+    default:
+      const sanitized = mappedType.replace(/[^a-z0-9-]/gi, "_").toLowerCase();
+      return join2(cwd, `.${sanitized}`, "mcp.json");
+  }
+}
+async function readAgentConfig(configPath, agentType) {
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const raw = JSON.parse(content);
+    if (agentType) {
+      const mappedType = AGENT_TO_MCP_CLIENT[agentType] || agentType;
+      const adapter = McpConfigAdapterRegistry.getAdapter(mappedType);
+      return adapter.toStandard(raw);
+    }
+    return raw;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { mcpServers: {} };
+    }
+    throw error;
+  }
+}
+async function writeAgentConfig(configPath, config) {
+  const dir = dirname(configPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+async function configureAgentMcp(agentType, cwd, scope = "local") {
+  if (!agentType || typeof agentType !== "string") {
+    throw new Error(`Invalid agent type: ${agentType}`);
+  }
+  if (!AGENT_TO_MCP_CLIENT[agentType] && !isValidMcpClientType(agentType)) {
+    throw new Error(`Unknown agent type: ${agentType}`);
+  }
+  const configPath = getAgentConfigPath(agentType, cwd, scope);
+  let config = await readAgentConfig(configPath, agentType);
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  const mcpServerConfig = {
+    command: "npx",
+    args: ["-y", "@codemcp/skills-server"]
+  };
+  config.mcpServers.agentskills = mcpServerConfig;
+  const mappedType = AGENT_TO_MCP_CLIENT[agentType] || agentType;
+  const adapter = McpConfigAdapterRegistry.getAdapter(mappedType);
+  let existingAgentConfig;
+  try {
+    const existingContent = await fs.readFile(configPath, "utf-8");
+    existingAgentConfig = JSON.parse(existingContent);
+  } catch {
+    existingAgentConfig = void 0;
+  }
+  const agentSpecificConfig = adapter.toClient(config, existingAgentConfig);
+  await writeAgentConfig(configPath, agentSpecificConfig);
+}
+function isValidMcpClientType(type) {
+  const validTypes = [
+    "claude-desktop",
+    "cline",
+    "cursor",
+    "kiro",
+    "junie",
+    "opencode",
+    "zed",
+    "continue",
+    "codium"
+  ];
+  return validTypes.includes(type);
+}
+function buildConfigGeneratorRegistry() {
+  const registry = new ConfigGeneratorRegistry();
+  registry.register(new VsCodeGenerator());
+  registry.register(new KiroGenerator());
+  registry.register(new OpenCodeMcpGenerator());
+  return registry;
+}
+async function safeWrite(filePath, content) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.isDirectory()) {
+      throw new Error(
+        `Generator returned a directory path instead of a file path: ${filePath}. Generators must write to a specific named file and must never clear or overwrite directories.`
+      );
+    }
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  const dir = dirname(filePath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function writeGeneratedConfig(generatedConfig) {
+  if (generatedConfig.files) {
+    for (const file of generatedConfig.files) {
+      const content = typeof file.content === "string" ? file.content : JSON.stringify(file.content, null, 2);
+      await safeWrite(file.path, content);
+    }
+  } else {
+    const content = typeof generatedConfig.content === "string" ? generatedConfig.content : JSON.stringify(generatedConfig.content, null, 2);
+    await safeWrite(generatedConfig.filePath, content);
+  }
+}
+async function generateSkillsMcpAgent(agentType, cwd, scope = "local", extraServers, includeAgentConfig = true) {
+  const registry = buildConfigGeneratorRegistry();
+  const skillsDir = scope === "global" ? homedir2() : cwd;
+  const baseConfig = {
+    id: "skills-mcp",
+    description: "Agent-skills MCP server with use_skill tool access",
+    mcp_servers: {
+      "agent-skills": {
+        type: "stdio",
+        command: "npx",
+        args: ["-y", "@codemcp/skills-server"],
+        tools: ["*"]
+      },
+      ...extraServers
+    },
+    tools: { use_skill: true },
+    permissions: { use_skill: "allow" }
+  };
+  const generatorOptions = {
+    skillsDir,
+    agentId: "skills-mcp",
+    scope,
+    isGlobal: scope === "global",
+    includeAgentConfig
+  };
+  const generator = registry.getGenerator(agentType);
+  if (!generator) {
+    throw new Error(
+      `No config generator found for agent type: ${agentType}. Supported types: ${registry.getSupportedAgentTypes().join(", ")}`
+    );
+  }
+  await writeGeneratedConfig(await generator.generate(baseConfig, generatorOptions));
+  if (includeAgentConfig && generator instanceof VsCodeGenerator) {
+    const agentFileGenerator = new GitHubCopilotGenerator();
+    await writeGeneratedConfig(await agentFileGenerator.generate(baseConfig, generatorOptions));
+  }
+  if (includeAgentConfig && generator instanceof OpenCodeMcpGenerator) {
+    const agentFileGenerator = new OpenCodeAgentGenerator();
+    await writeGeneratedConfig(await agentFileGenerator.generate(baseConfig, generatorOptions));
+  }
+}
+
+// src/mcp-skill-deps.ts
+import { promises as fs2 } from "fs";
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+async function loadInstalledSkillMcpDeps(cwd, scope) {
+  const isGlobal = scope === "global";
+  const searchDirs = [
+    getCanonicalSkillsDir(isGlobal, cwd),
+    getMCPCanonicalSkillsDir(isGlobal, cwd)
+  ];
+  const seen = /* @__PURE__ */ new Map();
+  const serverToolSets = /* @__PURE__ */ new Map();
+  for (const dir of searchDirs) {
+    try {
+      const skills = await discoverSkills(dir, void 0, { fullDepth: true });
+      for (const skill of skills) {
+        for (const dep of skill.requiresMcpServers ?? []) {
+          if (!seen.has(dep.name)) {
+            seen.set(dep.name, dep);
+          }
+          const skillAllowedTools = skill.allowedTools;
+          const serverName = dep.name;
+          if (!skillAllowedTools || skillAllowedTools.length === 0) {
+            serverToolSets.set(serverName, "wildcard");
+          } else if (serverToolSets.get(serverName) !== "wildcard") {
+            const prefix = `@${serverName}/`;
+            const serverTools = skillAllowedTools.filter((t) => t.startsWith(prefix)).map((t) => t.slice(prefix.length));
+            if (serverTools.length === 0) {
+              serverToolSets.set(serverName, "wildcard");
+            } else {
+              const existing = serverToolSets.get(serverName);
+              if (existing instanceof Set) {
+                for (const t of serverTools) existing.add(t);
+              } else {
+                serverToolSets.set(serverName, new Set(serverTools));
+              }
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const allowedToolsByServer = {};
+  for (const [serverName, toolsOrWildcard] of serverToolSets.entries()) {
+    if (toolsOrWildcard instanceof Set) {
+      allowedToolsByServer[serverName] = [...toolsOrWildcard];
+    }
+  }
+  return { deps: [...seen.values()], allowedToolsByServer };
+}
+function substituteParam(value, params) {
+  return value.replace(
+    /\{\{([A-Za-z0-9_-]+)\}\}/g,
+    (_, key) => params[key] ?? `{{${key}}}`
+  );
+}
+function applyParams(dep, params) {
+  const result = {
+    command: dep.command
+  };
+  if (dep.args?.length) result.args = dep.args.map((a) => substituteParam(a, params));
+  if (dep.env && Object.keys(dep.env).length) {
+    result.env = Object.fromEntries(
+      Object.entries(dep.env).map(([k, v]) => [k, substituteParam(v, params)])
+    );
+  }
+  if (dep.cwd) result.cwd = dep.cwd;
+  return result;
+}
+async function resolveParameters(dep) {
+  const result = {};
+  if (!dep.parameters) return result;
+  for (const [paramName, spec] of Object.entries(dep.parameters)) {
+    let resolved = spec.default;
+    if (resolved?.startsWith("{{ENV:")) {
+      const m = resolved.match(/\{\{ENV:([A-Za-z0-9_]+)\}\}/);
+      if (m) resolved = process.env[m[1]] ?? void 0;
+    }
+    if (resolved !== void 0) {
+      result[paramName] = resolved;
+      continue;
+    }
+    if (!spec.required) continue;
+    const answer = await he({
+      message: `${import_picocolors2.default.cyan(dep.name)} needs ${import_picocolors2.default.bold(paramName)}: ${spec.description}`
+    });
+    if (pD(answer)) {
+      xe("MCP server configuration cancelled");
+      process.exit(0);
+    }
+    result[paramName] = answer;
+  }
+  return result;
+}
+async function configureSkillMcpDepsForAgents(deps, agentTypes, configCwd, scope, configMode = "agent-config", allowedToolsByServer = {}) {
+  if (deps.length === 0 || agentTypes.length === 0) return;
+  const resolvedConfigs = /* @__PURE__ */ new Map();
+  for (const dep of deps) {
+    const params = await resolveParameters(dep);
+    resolvedConfigs.set(dep.name, applyParams(dep, params));
+  }
+  const registry = buildConfigGeneratorRegistry();
+  let anyConfigured = false;
+  for (const agentType of agentTypes) {
+    const useAgentConfig = configMode === "agent-config" && registry.supports(agentType);
+    if (useAgentConfig) {
+      const missingServers = {};
+      for (const dep of deps) {
+        const resolved = resolvedConfigs.get(dep.name);
+        const restrictedTools = allowedToolsByServer[dep.name];
+        missingServers[dep.name] = {
+          command: resolved.command,
+          args: resolved.args,
+          env: resolved.env,
+          ...resolved.cwd ? { cwd: resolved.cwd } : {},
+          // Only whitelist specific tools when the skill declares allowedTools
+          // for this server; otherwise leave undefined so generators use wildcard.
+          ...restrictedTools ? { tools: restrictedTools } : {}
+        };
+      }
+      try {
+        await generateSkillsMcpAgent(agentType, configCwd, scope, missingServers);
+        for (const dep of deps) {
+          M.success(
+            `${import_picocolors2.default.green("\u2713")} Added ${import_picocolors2.default.cyan(dep.name)} to ${import_picocolors2.default.dim(agents[agentType]?.displayName || agentType)}`
+          );
+        }
+        anyConfigured = true;
+      } catch {
+        M.warn(
+          import_picocolors2.default.yellow(
+            `Could not update agent config for ${agents[agentType]?.displayName || agentType} \u2014 add skill MCP servers manually`
+          )
+        );
+      }
+    } else {
+      const { McpConfigAdapterRegistry: McpConfigAdapterRegistry2 } = await import("./dist-TGUYKB34.js");
+      const configPath = getAgentConfigPath(agentType, configCwd, scope);
+      const config = await readAgentConfig(configPath, agentType);
+      if (!config.mcpServers) config.mcpServers = {};
+      let anyServerAdded = false;
+      for (const dep of deps) {
+        if (config.mcpServers[dep.name]) continue;
+        config.mcpServers[dep.name] = resolvedConfigs.get(dep.name);
+        anyServerAdded = true;
+        M.success(
+          `${import_picocolors2.default.green("\u2713")} Added ${import_picocolors2.default.cyan(dep.name)} to ${import_picocolors2.default.dim(agents[agentType]?.displayName || agentType)}`
+        );
+      }
+      if (anyServerAdded) {
+        try {
+          const { McpConfigAdapterRegistry: McpConfigAdapterRegistry3 } = await import("./dist-TGUYKB34.js");
+          const adapter = McpConfigAdapterRegistry3.getAdapter(agentType);
+          let existingAgentConfig;
+          try {
+            const existingContent = await fs2.readFile(configPath, "utf-8");
+            existingAgentConfig = JSON.parse(existingContent);
+          } catch {
+            existingAgentConfig = void 0;
+          }
+          const agentSpecificConfig = adapter.toClient(config, existingAgentConfig);
+          await writeAgentConfig(configPath, agentSpecificConfig);
+          anyConfigured = true;
+        } catch (error) {
+          M.warn(
+            import_picocolors2.default.yellow(
+              `Could not update MCP config for ${agents[agentType]?.displayName || agentType} \u2014 add skills manually`
+            )
+          );
+        }
+      }
+    }
+  }
+  if (anyConfigured) {
+    console.log();
+  }
+}
+
+// src/mcp.ts
+function parseMcpOptions(args) {
+  const agentList = [];
+  let scope = "local";
+  let configMode;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-a" || arg === "--agent") {
+      i++;
+      let nextArg = args[i];
+      while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+        agentList.push(nextArg);
+        i++;
+        nextArg = args[i];
+      }
+      i--;
+    } else if (arg === "-g" || arg === "--global") {
+      scope = "global";
+    } else if (arg === "--agent-config") {
+      configMode = "agent-config";
+    } else if (arg === "--mcp-json") {
+      configMode = "mcp-json";
+    }
+  }
+  const mode = agentList.length > 0 ? "cli" : "tui";
+  return {
+    mode,
+    agents: agentList,
+    scope,
+    configMode
+  };
+}
+async function runMcpSetup(options, cwd = process.cwd()) {
+  const scope = options.scope || "local";
+  const configCwd = scope === "global" ? homedir3() : cwd;
+  if (options.mode === "tui") {
+    await setupTuiMode(configCwd, scope, options.configMode);
+  } else {
+    await setupCliMode(options.agents, configCwd, scope, options.configMode);
+  }
+}
+function isGeneratorBacked(agentType) {
+  return buildConfigGeneratorRegistry().supports(agentType);
+}
+async function configureOneAgent(agentType, configCwd, scope, configMode) {
+  try {
+    if (configMode === "agent-config" && isGeneratorBacked(agentType)) {
+      await generateSkillsMcpAgent(agentType, configCwd, scope);
+    } else {
+      await configureAgentMcp(agentType, configCwd, scope);
+    }
+    return agentType;
+  } catch (error) {
+    console.error(
+      `\u2717 Failed to configure ${agents[agentType]?.displayName || agentType}:`,
+      error.message
+    );
+    return null;
+  }
+}
+function printAgentSummary(agentType, configMode, _scope) {
+  const agent = agents[agentType];
+  const displayName = agent?.displayName || agentType;
+  const isVerified = agent?.agentConfigSupport?.verified ?? false;
+  if (configMode === "agent-config" && isGeneratorBacked(agentType)) {
+    const hint = agent?.agentConfigSupport?.activationHint;
+    console.log(`  \u2713 ${displayName} \u2014 agent config written`);
+    if (hint) {
+      const looksLikeCli = !hint.includes(" ") || hint.startsWith("kiro") || hint.startsWith("opencode");
+      if (looksLikeCli) {
+        console.log(`    \u2192 To activate:  ${hint}`);
+      } else {
+        console.log(`    \u2192 ${hint}`);
+      }
+    }
+    if (!isVerified) {
+      console.log(
+        `    \u26A0\uFE0F  MCP integration not yet verified. Please ensure ${displayName} picks up the MCP server.`
+      );
+    }
+  } else {
+    console.log(`  \u2713 ${displayName} \u2014 MCP server registered in mcp.json`);
+    if (!isVerified) {
+      console.log(
+        `    \u26A0\uFE0F  MCP integration not yet verified. Please check that ${displayName} has loaded the MCP server.`
+      );
+    }
+  }
+}
+async function setupTuiMode(cwd, scope = "local", forcedConfigMode) {
+  const installedAgents = await detectInstalledAgents();
+  if (installedAgents.length === 0) {
+    console.log("No supported agents detected. Please install an agent first.");
+    return;
+  }
+  const selectedScope = await ve({
+    message: "Where should MCP configs be stored?",
+    options: [
+      { value: "local", label: "Local (Project directory) \u2014 shared via Git" },
+      { value: "global", label: "Global (Home directory) \u2014 personal settings only" }
+    ]
+  });
+  if (typeof selectedScope === "symbol") {
+    xe("Operation cancelled");
+    return;
+  }
+  scope = selectedScope;
+  const configCwd = scope === "global" ? homedir3() : cwd;
+  const selectedAgents = await fe({
+    message: "Select agents to configure for MCP:",
+    options: installedAgents.map((agentType) => {
+      const agent = agents[agentType];
+      const supportsAgentConfig = !!agent?.agentConfigSupport;
+      return {
+        value: agentType,
+        label: `${agent?.displayName || agentType}${supportsAgentConfig ? " \u2726" : ""}`,
+        hint: supportsAgentConfig ? "supports agent config" : void 0
+      };
+    })
+  });
+  if (typeof selectedAgents === "symbol") {
+    xe("Operation cancelled");
+    return;
+  }
+  if (!selectedAgents || selectedAgents.length === 0) {
+    console.log("No agents selected.");
+    return;
+  }
+  const agentConfigCapable = selectedAgents.filter(
+    (a) => isGeneratorBacked(a)
+  );
+  let configMode = "mcp-json";
+  if (forcedConfigMode) {
+    configMode = forcedConfigMode;
+  } else if (agentConfigCapable.length > 0) {
+    const capableNames = agentConfigCapable.map((a) => agents[a]?.displayName || a).join(", ");
+    const modeChoice = await ve({
+      message: `How should skills-mcp be configured for ${capableNames}?`,
+      options: [
+        {
+          value: "agent-config",
+          label: 'Agent config \u2014 creates a named "skills-mcp" agent with usage instructions',
+          hint: "Recommended: selectable by name; bundled prompt guides the agent"
+        },
+        {
+          value: "mcp-json",
+          label: "MCP server only \u2014 registers servers in mcp.json, no dedicated agent",
+          hint: "Simpler; MCP server is available in all conversations without a named agent"
+        }
+      ]
+    });
+    if (typeof modeChoice === "symbol") {
+      xe("Operation cancelled");
+      return;
+    }
+    configMode = modeChoice;
+  }
+  console.log("");
+  const configuredAgents = [];
+  for (const agentType of selectedAgents) {
+    const result = await configureOneAgent(agentType, configCwd, scope, configMode);
+    if (result !== null) configuredAgents.push(agentType);
+  }
+  if (configuredAgents.length > 0) {
+    const { deps: skillDeps, allowedToolsByServer } = await loadInstalledSkillMcpDeps(cwd, scope);
+    await configureSkillMcpDepsForAgents(
+      skillDeps,
+      configuredAgents,
+      configCwd,
+      scope,
+      configMode,
+      allowedToolsByServer
+    );
+  }
+  const scopeLabel = scope === "global" ? "global (home directory)" : "local (project directory)";
+  const failCount = selectedAgents.length - configuredAgents.length;
+  console.log("");
+  if (configuredAgents.length > 0) {
+    console.log(`Configured ${configuredAgents.length} agent(s) in ${scopeLabel}:`);
+    for (const agentType of configuredAgents) {
+      printAgentSummary(agentType, configMode, scope);
+    }
+  }
+  if (failCount > 0) {
+    console.error(`
+\u2717 Failed to configure ${failCount} agent(s) in ${scopeLabel}`);
+  }
+}
+async function setupCliMode(agentTypes, cwd, scope = "local", forcedConfigMode) {
+  if (agentTypes.includes("*")) {
+    const installedAgents = await detectInstalledAgents();
+    agentTypes = installedAgents;
+  }
+  const configuredAgents = [];
+  for (const agentType of agentTypes) {
+    const configMode = forcedConfigMode ?? (isGeneratorBacked(agentType) ? "agent-config" : "mcp-json");
+    const result = await configureOneAgent(agentType, cwd, scope, configMode);
+    if (result !== null) configuredAgents.push(agentType);
+  }
+  if (configuredAgents.length > 0) {
+    const { deps: skillDeps, allowedToolsByServer } = await loadInstalledSkillMcpDeps(cwd, scope);
+    if (forcedConfigMode) {
+      const generatorBacked = configuredAgents.filter((a) => isGeneratorBacked(a));
+      const rawMcp = configuredAgents.filter((a) => !isGeneratorBacked(a));
+      if (generatorBacked.length > 0) {
+        await configureSkillMcpDepsForAgents(
+          skillDeps,
+          generatorBacked,
+          cwd,
+          scope,
+          forcedConfigMode,
+          allowedToolsByServer
+        );
+      }
+      if (rawMcp.length > 0) {
+        await configureSkillMcpDepsForAgents(
+          skillDeps,
+          rawMcp,
+          cwd,
+          scope,
+          "mcp-json",
+          allowedToolsByServer
+        );
+      }
+    } else {
+      const generatorBacked = configuredAgents.filter((a) => isGeneratorBacked(a));
+      const rawMcp = configuredAgents.filter((a) => !isGeneratorBacked(a));
+      if (generatorBacked.length > 0) {
+        await configureSkillMcpDepsForAgents(
+          skillDeps,
+          generatorBacked,
+          cwd,
+          scope,
+          "agent-config",
+          allowedToolsByServer
+        );
+      }
+      if (rawMcp.length > 0) {
+        await configureSkillMcpDepsForAgents(
+          skillDeps,
+          rawMcp,
+          cwd,
+          scope,
+          "mcp-json",
+          allowedToolsByServer
+        );
+      }
+    }
+  }
+  const failCount = agentTypes.length - configuredAgents.length;
+  if (configuredAgents.length > 0) {
+    console.log(`
+Configured ${configuredAgents.length} agent(s):`);
+    for (const agentType of configuredAgents) {
+      const configMode = forcedConfigMode ?? (isGeneratorBacked(agentType) ? "agent-config" : "mcp-json");
+      printAgentSummary(agentType, configMode, scope);
+    }
+  }
+  if (failCount > 0) {
+    console.error(`
+\u2717 Failed to configure ${failCount} agent(s)`);
+  }
+}
+
+// src/cli.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+function getVersion() {
+  try {
+    const pkgPath = join3(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = getVersion();
+initTelemetry(VERSION);
+var RESET3 = "\x1B[0m";
+var BOLD3 = "\x1B[1m";
+var DIM3 = "\x1B[38;5;102m";
+var TEXT2 = "\x1B[38;5;145m";
+var LOGO_LINES = [
+  "\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\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\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\u2554\u2550\u2550\u2550\u2550\u255D      \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\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\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  "\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2550\u255D ",
+  "\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\u2588\u2588\u2588\u2588\u2588\u2551      \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\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\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     "
+];
+var GRAYS = [
+  "\x1B[38;5;250m",
+  // lighter gray
+  "\x1B[38;5;248m",
+  "\x1B[38;5;245m",
+  // mid gray
+  "\x1B[38;5;243m",
+  "\x1B[38;5;240m",
+  "\x1B[38;5;238m"
+  // darker gray
+];
+function showLogo() {
+  console.log();
+  LOGO_LINES.forEach((line, i) => {
+    console.log(`${GRAYS[i]}${line}${RESET3}`);
+  });
+}
+function showBanner() {
+  showLogo();
+  console.log();
+  console.log(`${DIM3}The open agent skills ecosystem${RESET3}`);
+  console.log();
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills add ${DIM3}<package>${RESET3}        ${DIM3}Add a new skill${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills remove${RESET3}               ${DIM3}Remove installed skills${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills list${RESET3}                 ${DIM3}List installed skills${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills find ${DIM3}[query]${RESET3}         ${DIM3}Search for skills${RESET3}`
+  );
+  console.log();
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills check${RESET3}                ${DIM3}Check for updates${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills update${RESET3}               ${DIM3}Update all skills${RESET3}`
+  );
+  console.log();
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills experimental_install${RESET3} ${DIM3}Restore from skills-lock.json${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills init ${DIM3}[name]${RESET3}          ${DIM3}Create a new skill${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}$${RESET3} ${TEXT2}npx @codemcp/skills experimental_sync${RESET3}    ${DIM3}Sync skills from node_modules${RESET3}`
+  );
+  console.log();
+  console.log(`${DIM3}try:${RESET3} npx @codemcp/skills add vercel-labs/agent-skills`);
+  console.log();
+  console.log(`Discover more skills at ${TEXT2}https://skills.sh/${RESET3}`);
+  console.log();
+}
+function showHelp() {
+  console.log(`
+${BOLD3}Usage:${RESET3} npx @codemcp/skills <command> [options]
+
+${BOLD3}Manage Skills:${RESET3}
+  add <package>        Add a skill package (alias: a)
+                       e.g. vercel-labs/agent-skills
+                            https://github.com/vercel-labs/agent-skills
+  remove [skills]      Remove installed skills
+  list, ls             List installed skills
+  find [query]         Search for skills interactively
+
+${BOLD3}Updates:${RESET3}
+  check                Check for available skill updates
+  update               Update all skills to latest versions
+
+${BOLD3}Project:${RESET3}
+  experimental_install Restore skills from skills-lock.json
+  init [name]          Initialize a skill (creates <name>/SKILL.md or ./SKILL.md)
+  experimental_sync    Sync skills from node_modules into agent directories
+
+${BOLD3}Add Options:${RESET3}
+  -g, --global           Install skill globally (user-level) instead of project-level
+  -a, --agent <agents>   Specify agents to install to (use '*' for all agents)
+  -s, --skill <skills>   Specify skill names to install (use '*' for all skills)
+  -l, --list             List available skills in the repository without installing
+  -y, --yes              Skip confirmation prompts
+  --copy                 Copy files instead of symlinking to agent directories
+  --all                  Shorthand for --skill '*' --agent '*' -y
+  --full-depth           Search all subdirectories even when a root SKILL.md exists
+
+${BOLD3}Remove Options:${RESET3}
+  -g, --global           Remove from global scope
+  -a, --agent <agents>   Remove from specific agents (use '*' for all agents)
+  -s, --skill <skills>   Specify skills to remove (use '*' for all skills)
+  -y, --yes              Skip confirmation prompts
+  --all                  Shorthand for --skill '*' --agent '*' -y
+  
+${BOLD3}Experimental Sync Options:${RESET3}
+  -a, --agent <agents>   Specify agents to install to (use '*' for all agents)
+  -y, --yes              Skip confirmation prompts
+
+${BOLD3}List Options:${RESET3}
+  -g, --global           List global skills (default: project)
+  -a, --agent <agents>   Filter by specific agents
+
+${BOLD3}Options:${RESET3}
+  --help, -h        Show this help message
+  --version, -v     Show version number
+
+${BOLD3}Examples:${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills add vercel-labs/agent-skills
+  ${DIM3}$${RESET3} npx @codemcp/skills add vercel-labs/agent-skills -g
+  ${DIM3}$${RESET3} npx @codemcp/skills add vercel-labs/agent-skills --agent claude-code cursor
+  ${DIM3}$${RESET3} npx @codemcp/skills add vercel-labs/agent-skills --skill pr-review commit
+  ${DIM3}$${RESET3} npx @codemcp/skills remove                        ${DIM3}# interactive remove${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills remove web-design             ${DIM3}# remove by name${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills rm --global frontend-design
+  ${DIM3}$${RESET3} npx @codemcp/skills list                          ${DIM3}# list project skills${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills ls -g                         ${DIM3}# list global skills${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills ls -a claude-code             ${DIM3}# filter by agent${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills find                          ${DIM3}# interactive search${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills find typescript               ${DIM3}# search by keyword${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills check
+  ${DIM3}$${RESET3} npx @codemcp/skills update
+  ${DIM3}$${RESET3} npx @codemcp/skills experimental_install            ${DIM3}# restore from skills-lock.json${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills init my-skill
+  ${DIM3}$${RESET3} npx @codemcp/skills experimental_sync              ${DIM3}# sync from node_modules${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills experimental_sync -y           ${DIM3}# sync without prompts${RESET3}
+
+Discover more skills at ${TEXT2}https://skills.sh/${RESET3}
+`);
+}
+function showRemoveHelp() {
+  console.log(`
+${BOLD3}Usage:${RESET3} npx @codemcp/skills remove [skills...] [options]
+
+${BOLD3}Description:${RESET3}
+  Remove installed skills from agents. If no skill names are provided,
+  an interactive selection menu will be shown.
+
+${BOLD3}Arguments:${RESET3}
+  skills            Optional skill names to remove (space-separated)
+
+${BOLD3}Options:${RESET3}
+  -g, --global       Remove from global scope (~/) instead of project scope
+  -a, --agent        Remove from specific agents (use '*' for all agents)
+  -s, --skill        Specify skills to remove (use '*' for all skills)
+  -y, --yes          Skip confirmation prompts
+  --all              Shorthand for --skill '*' --agent '*' -y
+
+${BOLD3}Examples:${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills remove                           ${DIM3}# interactive selection${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills remove my-skill                   ${DIM3}# remove specific skill${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills remove skill1 skill2 -y           ${DIM3}# remove multiple skills${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills remove --global my-skill          ${DIM3}# remove from global scope${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills rm --agent claude-code my-skill   ${DIM3}# remove from specific agent${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills remove --all                      ${DIM3}# remove all skills${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills remove --skill '*' -a cursor      ${DIM3}# remove all skills from cursor${RESET3}
+
+Discover more skills at ${TEXT2}https://skills.sh/${RESET3}
+`);
+}
+function showMcpHelp() {
+  console.log(`
+${BOLD3}Usage:${RESET3} npx @codemcp/skills mcp setup [options]
+
+${BOLD3}Description:${RESET3}
+  Configure MCP (Model Context Protocol) server for agent environments.
+  Supports both interactive (TUI) and command-line (CLI) modes.
+
+${BOLD3}Subcommands:${RESET3}
+  setup               Configure MCP server for agents (default if no subcommand)
+
+${BOLD3}Options:${RESET3}
+  -a, --agent         Specify agents to configure (space-separated)
+                      Use '*' to configure all detected agents
+  -g, --global        Write configs to home directory instead of project
+  --agent-config      Create a named agent file with usage instructions
+                      (Kiro, GitHub Copilot, OpenCode only; default for those agents)
+  --mcp-json          Register MCP servers in mcp.json only, no agent file
+                      (works for all agents; skips the TUI mode-selection prompt)
+
+${BOLD3}Modes:${RESET3}
+  ${DIM3}Interactive (TUI):${RESET3} npx @codemcp/skills mcp setup
+    Guides through scope \u2192 agent selection \u2192 config type \u2192 summary
+
+  ${DIM3}Command-line (CLI):${RESET3} npx @codemcp/skills mcp setup --agent <agents>
+    Configures specified agents without interaction
+
+${BOLD3}Examples:${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills mcp setup                                        ${DIM3}# interactive${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills mcp setup --agent claude-code                    ${DIM3}# mcp.json for Claude${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills mcp setup --agent kiro-cli --agent-config        ${DIM3}# Kiro agent file${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills mcp setup --agent kiro-cli --mcp-json            ${DIM3}# Kiro mcp.json only${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills mcp setup --agent claude-code cline --mcp-json   ${DIM3}# multiple, mcp.json${RESET3}
+  ${DIM3}$${RESET3} npx @codemcp/skills mcp setup --agent '*'                            ${DIM3}# all agents${RESET3}
+
+${BOLD3}Supported Agents:${RESET3}
+  claude-code, cline, cursor, kiro-cli, junie, opencode, and more
+  Agents marked \u2726 in the TUI support a rich agent config file.
+
+Discover more at ${TEXT2}https://skills.sh/${RESET3}
+`);
+}
+function runInit(args) {
+  const cwd = process.cwd();
+  const skillName = args[0] || basename(cwd);
+  const hasName = args[0] !== void 0;
+  const skillDir = hasName ? join3(cwd, skillName) : cwd;
+  const skillFile = join3(skillDir, "SKILL.md");
+  const displayPath = hasName ? `${skillName}/SKILL.md` : "SKILL.md";
+  if (existsSync(skillFile)) {
+    console.log(`${TEXT2}Skill already exists at ${DIM3}${displayPath}${RESET3}`);
+    return;
+  }
+  if (hasName) {
+    mkdirSync(skillDir, { recursive: true });
+  }
+  const skillContent = `---
+name: ${skillName}
+description: A brief description of what this skill does
+---
+
+# ${skillName}
+
+Instructions for the agent to follow when this skill is activated.
+
+## When to use
+
+Describe when this skill should be used.
+
+## Instructions
+
+1. First step
+2. Second step
+3. Additional steps as needed
+`;
+  writeFileSync(skillFile, skillContent);
+  console.log(`${TEXT2}Initialized skill: ${DIM3}${skillName}${RESET3}`);
+  console.log();
+  console.log(`${DIM3}Created:${RESET3}`);
+  console.log(`  ${displayPath}`);
+  console.log();
+  console.log(`${DIM3}Next steps:${RESET3}`);
+  console.log(`  1. Edit ${TEXT2}${displayPath}${RESET3} to define your skill instructions`);
+  console.log(
+    `  2. Update the ${TEXT2}name${RESET3} and ${TEXT2}description${RESET3} in the frontmatter`
+  );
+  console.log();
+  console.log(`${DIM3}Publishing:${RESET3}`);
+  console.log(
+    `  ${DIM3}GitHub:${RESET3}  Push to a repo, then ${TEXT2}npx @codemcp/skills add <owner>/<repo>${RESET3}`
+  );
+  console.log(
+    `  ${DIM3}URL:${RESET3}     Host the file, then ${TEXT2}npx @codemcp/skills add https://example.com/${displayPath}${RESET3}`
+  );
+  console.log();
+  console.log(`Browse existing skills for inspiration at ${TEXT2}https://skills.sh/${RESET3}`);
+  console.log();
+}
+var AGENTS_DIR = ".agents";
+var LOCK_FILE = ".skill-lock.json";
+var CURRENT_LOCK_VERSION = 3;
+function getSkillLockPath() {
+  return join3(homedir4(), AGENTS_DIR, LOCK_FILE);
+}
+function readSkillLock() {
+  const lockPath = getSkillLockPath();
+  try {
+    const content = readFileSync(lockPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.version !== "number" || !parsed.skills) {
+      return { version: CURRENT_LOCK_VERSION, skills: {} };
+    }
+    if (parsed.version < CURRENT_LOCK_VERSION) {
+      return { version: CURRENT_LOCK_VERSION, skills: {} };
+    }
+    return parsed;
+  } catch {
+    return { version: CURRENT_LOCK_VERSION, skills: {} };
+  }
+}
+async function runCheck(args = []) {
+  console.log(`${TEXT2}Checking for skill updates...${RESET3}`);
+  console.log();
+  const lock = readSkillLock();
+  const skillNames = Object.keys(lock.skills);
+  if (skillNames.length === 0) {
+    console.log(`${DIM3}No skills tracked in lock file.${RESET3}`);
+    console.log(
+      `${DIM3}Install skills with${RESET3} ${TEXT2}npx @codemcp/skills add <package>${RESET3}`
+    );
+    return;
+  }
+  const token = getGitHubToken();
+  const skillsBySource = /* @__PURE__ */ new Map();
+  let skippedCount = 0;
+  for (const skillName of skillNames) {
+    const entry = lock.skills[skillName];
+    if (!entry) continue;
+    if (entry.sourceType !== "github" || !entry.skillFolderHash || !entry.skillPath) {
+      skippedCount++;
+      continue;
+    }
+    const existing = skillsBySource.get(entry.source) || [];
+    existing.push({ name: skillName, entry });
+    skillsBySource.set(entry.source, existing);
+  }
+  const totalSkills = skillNames.length - skippedCount;
+  if (totalSkills === 0) {
+    console.log(`${DIM3}No GitHub skills to check.${RESET3}`);
+    return;
+  }
+  console.log(`${DIM3}Checking ${totalSkills} skill(s) for updates...${RESET3}`);
+  const updates = [];
+  const errors = [];
+  for (const [source, skills] of skillsBySource) {
+    for (const { name, entry } of skills) {
+      try {
+        const latestHash = await fetchSkillFolderHash(source, entry.skillPath, token);
+        if (!latestHash) {
+          errors.push({ name, source, error: "Could not fetch from GitHub" });
+          continue;
+        }
+        if (latestHash !== entry.skillFolderHash) {
+          updates.push({ name, source });
+        }
+      } catch (err) {
+        errors.push({
+          name,
+          source,
+          error: err instanceof Error ? err.message : "Unknown error"
+        });
+      }
+    }
+  }
+  console.log();
+  if (updates.length === 0) {
+    console.log(`${TEXT2}\u2713 All skills are up to date${RESET3}`);
+  } else {
+    console.log(`${TEXT2}${updates.length} update(s) available:${RESET3}`);
+    console.log();
+    for (const update of updates) {
+      console.log(`  ${TEXT2}\u2191${RESET3} ${update.name}`);
+      console.log(`    ${DIM3}source: ${update.source}${RESET3}`);
+    }
+    console.log();
+    console.log(
+      `${DIM3}Run${RESET3} ${TEXT2}npx @codemcp/skills update${RESET3} ${DIM3}to update all skills${RESET3}`
+    );
+  }
+  if (errors.length > 0) {
+    console.log();
+    console.log(`${DIM3}Could not check ${errors.length} skill(s) (may need reinstall)${RESET3}`);
+  }
+  track({
+    event: "check",
+    skillCount: String(totalSkills),
+    updatesAvailable: String(updates.length)
+  });
+  console.log();
+}
+async function runUpdate() {
+  console.log(`${TEXT2}Checking for skill updates...${RESET3}`);
+  console.log();
+  const lock = readSkillLock();
+  const skillNames = Object.keys(lock.skills);
+  if (skillNames.length === 0) {
+    console.log(`${DIM3}No skills tracked in lock file.${RESET3}`);
+    console.log(
+      `${DIM3}Install skills with${RESET3} ${TEXT2}npx @codemcp/skills add <package>${RESET3}`
+    );
+    return;
+  }
+  const token = getGitHubToken();
+  const updates = [];
+  let checkedCount = 0;
+  for (const skillName of skillNames) {
+    const entry = lock.skills[skillName];
+    if (!entry) continue;
+    if (entry.sourceType !== "github" || !entry.skillFolderHash || !entry.skillPath) {
+      continue;
+    }
+    checkedCount++;
+    try {
+      const latestHash = await fetchSkillFolderHash(entry.source, entry.skillPath, token);
+      if (latestHash && latestHash !== entry.skillFolderHash) {
+        updates.push({ name: skillName, source: entry.source, entry });
+      }
+    } catch {
+    }
+  }
+  if (checkedCount === 0) {
+    console.log(`${DIM3}No skills to check.${RESET3}`);
+    return;
+  }
+  if (updates.length === 0) {
+    console.log(`${TEXT2}\u2713 All skills are up to date${RESET3}`);
+    console.log();
+    return;
+  }
+  console.log(`${TEXT2}Found ${updates.length} update(s)${RESET3}`);
+  console.log();
+  let successCount = 0;
+  let failCount = 0;
+  for (const update of updates) {
+    console.log(`${TEXT2}Updating ${update.name}...${RESET3}`);
+    let installUrl = update.entry.sourceUrl;
+    if (update.entry.skillPath) {
+      let skillFolder = update.entry.skillPath;
+      if (skillFolder.endsWith("/SKILL.md")) {
+        skillFolder = skillFolder.slice(0, -9);
+      } else if (skillFolder.endsWith("SKILL.md")) {
+        skillFolder = skillFolder.slice(0, -8);
+      }
+      if (skillFolder.endsWith("/")) {
+        skillFolder = skillFolder.slice(0, -1);
+      }
+      installUrl = update.entry.sourceUrl.replace(/\.git$/, "").replace(/\/$/, "");
+      installUrl = `${installUrl}/tree/main/${skillFolder}`;
+    }
+    const result = spawnSync("npx", ["-y", "@codemcp/skills", "add", installUrl, "-g", "-y"], {
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    if (result.status === 0) {
+      successCount++;
+      console.log(`  ${TEXT2}\u2713${RESET3} Updated ${update.name}`);
+    } else {
+      failCount++;
+      console.log(`  ${DIM3}\u2717 Failed to update ${update.name}${RESET3}`);
+    }
+  }
+  console.log();
+  if (successCount > 0) {
+    console.log(`${TEXT2}\u2713 Updated ${successCount} skill(s)${RESET3}`);
+  }
+  if (failCount > 0) {
+    console.log(`${DIM3}Failed to update ${failCount} skill(s)${RESET3}`);
+  }
+  track({
+    event: "update",
+    skillCount: String(updates.length),
+    successCount: String(successCount),
+    failCount: String(failCount)
+  });
+  console.log();
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    showBanner();
+    return;
+  }
+  const command = args[0];
+  const restArgs = args.slice(1);
+  switch (command) {
+    case "find":
+    case "search":
+    case "f":
+    case "s":
+      showLogo();
+      console.log();
+      await runFind(restArgs);
+      break;
+    case "init":
+      showLogo();
+      console.log();
+      runInit(restArgs);
+      break;
+    case "experimental_install": {
+      showLogo();
+      await runInstallFromLock(restArgs);
+      break;
+    }
+    case "i":
+    case "install":
+    case "a":
+    case "add": {
+      showLogo();
+      const { source: addSource, options: addOpts } = parseAddOptions(restArgs);
+      await runAdd(addSource, addOpts);
+      break;
+    }
+    case "remove":
+    case "rm":
+    case "r":
+      if (restArgs.includes("--help") || restArgs.includes("-h")) {
+        showRemoveHelp();
+        break;
+      }
+      const { skills, options: removeOptions } = parseRemoveOptions(restArgs);
+      await removeCommand(skills, removeOptions);
+      break;
+    case "experimental_sync": {
+      showLogo();
+      const { options: syncOptions } = parseSyncOptions(restArgs);
+      await runSync(restArgs, syncOptions);
+      break;
+    }
+    case "list":
+    case "ls":
+      await runList(restArgs);
+      break;
+    case "check":
+      runCheck(restArgs);
+      break;
+    case "update":
+    case "upgrade":
+      runUpdate();
+      break;
+    case "mcp": {
+      if (!restArgs[0] || restArgs[0] === "--help" || restArgs[0] === "-h") {
+        showMcpHelp();
+        break;
+      }
+      const subcommand = restArgs[0];
+      const mcpArgs = restArgs.slice(1);
+      if (subcommand === "setup") {
+        showLogo();
+        const options = parseMcpOptions(mcpArgs);
+        await runMcpSetup(options);
+      } else {
+        console.error(`Unknown mcp subcommand: ${subcommand}`);
+        showMcpHelp();
+      }
+      break;
+    }
+    case "--help":
+    case "-h":
+      showHelp();
+      break;
+    case "--version":
+    case "-v":
+      console.log(VERSION);
+      break;
+    default:
+      console.log(`Unknown command: ${command}`);
+      console.log(`Run ${BOLD3}npx @codemcp/skills --help${RESET3} for usage.`);
+  }
+}
+main();