skillsmgr 0.1.0

package/dist/index.js

@@ -0,0 +1,1638 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command8 } from "commander";
+
+// src/commands/setup.ts
+import { Command } from "commander";
+import { join as join3 } from "path";
+import { fileURLToPath } from "url";
+import { dirname as dirname2 } from "path";
+
+// src/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var SKILLS_MANAGER_DIR = join(homedir(), ".skills-manager");
+var METADATA_FILENAME = ".skillsmgr.json";
+var SKILL_SOURCES = ["official", "community", "custom"];
+var SUPPORTED_TOOLS = [
+  "claude-code",
+  "cursor",
+  "windsurf",
+  "cline",
+  "roo-code",
+  "kilo-code",
+  "antigravity"
+];
+var ANTHROPIC_SKILLS_REPO = "https://github.com/anthropics/skills";
+
+// src/utils/fs.ts
+import {
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+  symlinkSync,
+  lstatSync,
+  readFileSync,
+  readdirSync,
+  unlinkSync,
+  writeFileSync,
+  rmSync
+} from "fs";
+import { dirname, join as join2 } from "path";
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function copyFile(src, dest) {
+  ensureDir(dirname(dest));
+  copyFileSync(src, dest);
+}
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function readFileContent(path) {
+  return readFileSync(path, "utf-8");
+}
+function writeFile(path, content) {
+  ensureDir(dirname(path));
+  writeFileSync(path, content, "utf-8");
+}
+function fileExists(path) {
+  return existsSync(path);
+}
+function removeDir(dir) {
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+function getDirectoriesInDir(dir) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const entries = readdirSync(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => ({
+    name: e.name,
+    path: join2(dir, e.name)
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function copyDir(src, dest) {
+  ensureDir(dest);
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join2(src, entry.name);
+    const destPath = join2(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFile(srcPath, destPath);
+    }
+  }
+}
+function linkDir(src, dest) {
+  ensureDir(dirname(dest));
+  if (existsSync(dest)) {
+    unlinkSync(dest);
+  }
+  symlinkSync(src, dest);
+}
+
+// src/commands/setup.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+async function executeSetup() {
+  console.log(`Creating ${SKILLS_MANAGER_DIR}...`);
+  for (const source of SKILL_SOURCES) {
+    const dir = join3(SKILLS_MANAGER_DIR, source);
+    ensureDir(dir);
+    console.log(`\u2713 Created ${source}/`);
+  }
+  const templateDir = join3(__dirname2, "templates", "example-skill");
+  const targetDir = join3(SKILLS_MANAGER_DIR, "custom", "example-skill");
+  if (!fileExists(targetDir)) {
+    copyDir(templateDir, targetDir);
+    console.log("\u2713 Created custom/example-skill/SKILL.md");
+  } else {
+    console.log("\xB7 custom/example-skill already exists, skipping");
+  }
+  console.log("\nSetup complete!\n");
+  console.log("Next steps:");
+  console.log("  skillsmgr install anthropic    # Download official Anthropic skills");
+  console.log("  skillsmgr list                 # View available skills");
+  console.log("  skillsmgr init                 # Deploy skills to your project");
+}
+var setupCommand = new Command("setup").description("Initialize ~/.skills-manager/ directory structure").action(async () => {
+  await executeSetup();
+});
+
+// src/commands/install.ts
+import { Command as Command2 } from "commander";
+import { join as join6 } from "path";
+
+// src/services/git.ts
+import { execSync } from "child_process";
+import { join as join4, basename } from "path";
+import { existsSync as existsSync2 } from "fs";
+var GitService = class {
+  /**
+   * Clone a git repository to the skills manager directory
+   * @param url Git URL or 'anthropic' shorthand
+   * @param isCustom Whether to install to custom/ instead of community/
+   * @returns Path where repo was cloned
+   */
+  clone(url, isCustom = false) {
+    const actualUrl = url === "anthropic" ? ANTHROPIC_SKILLS_REPO : url;
+    const repoName = this.extractRepoName(actualUrl);
+    let targetDir;
+    if (url === "anthropic") {
+      targetDir = join4(SKILLS_MANAGER_DIR, "official", "anthropic");
+    } else if (isCustom) {
+      targetDir = join4(SKILLS_MANAGER_DIR, "custom", repoName);
+    } else {
+      targetDir = join4(SKILLS_MANAGER_DIR, "community", repoName);
+    }
+    if (existsSync2(targetDir)) {
+      console.log(`Updating existing ${repoName}...`);
+      execSync("git pull", { cwd: targetDir, stdio: "inherit" });
+      return targetDir;
+    }
+    ensureDir(join4(targetDir, ".."));
+    console.log(`Cloning ${repoName}...`);
+    execSync(`git clone --depth 1 "${actualUrl}" "${targetDir}"`, {
+      stdio: "inherit"
+    });
+    return targetDir;
+  }
+  /**
+   * Clone a specific skill from a repository
+   * @param url Git URL with path to specific skill (e.g., https://github.com/org/repo/tree/main/skill-name)
+   * @param isCustom Whether to install to custom/
+   * @returns Path where skill was cloned
+   */
+  cloneSpecificSkill(url, isCustom = false) {
+    const match = url.match(
+      /github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/
+    );
+    if (!match) {
+      return null;
+    }
+    const [, owner, repo, branch, skillPath] = match;
+    const skillName = basename(skillPath);
+    const repoUrl = `https://github.com/${owner}/${repo}`;
+    const isAnthropic = owner === "anthropics" && repo === "skills";
+    let targetDir;
+    if (isAnthropic) {
+      targetDir = join4(SKILLS_MANAGER_DIR, "official", "anthropic");
+    } else if (isCustom) {
+      targetDir = join4(SKILLS_MANAGER_DIR, "custom", repo);
+    } else {
+      targetDir = join4(SKILLS_MANAGER_DIR, "community", repo);
+    }
+    const skillTargetDir = join4(targetDir, skillName);
+    ensureDir(targetDir);
+    if (!existsSync2(join4(targetDir, ".git"))) {
+      execSync(`git init`, { cwd: targetDir, stdio: "pipe" });
+      execSync(`git remote add origin "${repoUrl}"`, {
+        cwd: targetDir,
+        stdio: "pipe"
+      });
+    }
+    execSync(`git config core.sparseCheckout true`, {
+      cwd: targetDir,
+      stdio: "pipe"
+    });
+    execSync(`echo "${skillPath}" >> .git/info/sparse-checkout`, {
+      cwd: targetDir,
+      stdio: "pipe"
+    });
+    execSync(`git pull --depth 1 origin ${branch}`, {
+      cwd: targetDir,
+      stdio: "inherit"
+    });
+    return skillTargetDir;
+  }
+  extractRepoName(url) {
+    const match = url.match(/\/([^/]+?)(\.git)?$/);
+    return match ? match[1] : "unknown";
+  }
+  /**
+   * Check if a URL points to a specific skill (vs a repository)
+   */
+  isSpecificSkillUrl(url) {
+    return url.includes("/tree/");
+  }
+};
+
+// src/services/github.ts
+import { join as join5 } from "path";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+var GitHubService = class {
+  baseApiUrl = "https://api.github.com";
+  defaultBranchCache = /* @__PURE__ */ new Map();
+  /**
+   * Get the default branch for a repository
+   */
+  async getDefaultBranch(owner, repo) {
+    const cacheKey = `${owner}/${repo}`;
+    if (this.defaultBranchCache.has(cacheKey)) {
+      return this.defaultBranchCache.get(cacheKey);
+    }
+    const url = `${this.baseApiUrl}/repos/${owner}/${repo}`;
+    const response = await fetch(url, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      return "main";
+    }
+    const data = await response.json();
+    const branch = data.default_branch || "main";
+    this.defaultBranchCache.set(cacheKey, branch);
+    return branch;
+  }
+  /**
+   * List skills in a GitHub repository's skills directory
+   */
+  async listSkills(owner, repo, skillsPath = "skills") {
+    const url = `${this.baseApiUrl}/repos/${owner}/${repo}/contents/${skillsPath}`;
+    const response = await fetch(url, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to list skills: ${response.statusText}`);
+    }
+    const contents = await response.json();
+    return contents.filter((item) => item.type === "dir").map((item) => ({ name: item.name, path: item.path }));
+  }
+  /**
+   * Download a specific skill directory from GitHub
+   */
+  async downloadSkill(owner, repo, skillPath, targetDir) {
+    ensureDir(targetDir);
+    await this.downloadDirectory(owner, repo, skillPath, targetDir);
+  }
+  /**
+   * Download all files in a directory recursively
+   */
+  async downloadDirectory(owner, repo, path, targetDir) {
+    const url = `${this.baseApiUrl}/repos/${owner}/${repo}/contents/${path}`;
+    const response = await fetch(url, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to download directory: ${response.statusText}`);
+    }
+    const contents = await response.json();
+    for (const item of contents) {
+      const localPath = join5(targetDir, item.name);
+      if (item.type === "file" && item.download_url) {
+        await this.downloadFile(item.download_url, localPath);
+      } else if (item.type === "dir") {
+        mkdirSync2(localPath, { recursive: true });
+        await this.downloadDirectory(owner, repo, item.path, localPath);
+      }
+    }
+  }
+  /**
+   * Download a single file
+   */
+  async downloadFile(url, localPath) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download file: ${response.statusText}`);
+    }
+    const content = await response.text();
+    writeFileSync2(localPath, content, "utf-8");
+  }
+  /**
+   * Get the target directory for a skill based on source
+   */
+  getTargetDir(owner, repo, skillName, isCustom = false) {
+    const isAnthropic = owner === "anthropics" && repo === "skills";
+    let baseDir;
+    if (isAnthropic) {
+      baseDir = join5(SKILLS_MANAGER_DIR, "official", "anthropic");
+    } else if (isCustom) {
+      baseDir = join5(SKILLS_MANAGER_DIR, "custom", repo);
+    } else {
+      baseDir = join5(SKILLS_MANAGER_DIR, "community", repo);
+    }
+    return join5(baseDir, skillName);
+  }
+  /**
+   * Parse a GitHub URL to extract owner, repo, and optional path
+   */
+  parseGitHubUrl(url) {
+    const treeMatch = url.match(
+      /github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)(?:\/(.+))?/
+    );
+    if (treeMatch) {
+      return {
+        owner: treeMatch[1],
+        repo: treeMatch[2],
+        branch: treeMatch[3],
+        path: treeMatch[4]
+      };
+    }
+    const basicMatch = url.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (basicMatch) {
+      return {
+        owner: basicMatch[1],
+        repo: basicMatch[2]
+      };
+    }
+    return null;
+  }
+  getHeaders() {
+    const headers = {
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "skillsmgr"
+    };
+    const token = process.env.GITHUB_TOKEN;
+    if (token) {
+      headers["Authorization"] = `token ${token}`;
+    }
+    return headers;
+  }
+};
+
+// src/utils/prompts.ts
+import inquirer from "inquirer";
+
+// src/tools/configs.ts
+var TOOL_CONFIGS = {
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    skillsDir: ".claude/skills",
+    supportsLink: true,
+    supportsModeSpecific: false
+  },
+  "cursor": {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: ".cursor/skills",
+    supportsLink: true,
+    supportsModeSpecific: false
+  },
+  "windsurf": {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDir: ".windsurf/skills",
+    supportsLink: true,
+    supportsModeSpecific: false
+  },
+  "cline": {
+    name: "cline",
+    displayName: "Cline",
+    skillsDir: ".cline/skills",
+    supportsLink: true,
+    supportsModeSpecific: false
+  },
+  "roo-code": {
+    name: "roo-code",
+    displayName: "Roo Code",
+    skillsDir: ".roo/skills",
+    supportsLink: true,
+    supportsModeSpecific: true,
+    modePattern: "skills-{mode}",
+    availableModes: ["code", "architect"]
+  },
+  "kilo-code": {
+    name: "kilo-code",
+    displayName: "Kilo Code",
+    skillsDir: ".kilocode/skills",
+    supportsLink: true,
+    supportsModeSpecific: true,
+    modePattern: "skills-{mode}",
+    availableModes: ["code", "architect"]
+  },
+  "antigravity": {
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDir: ".agent/skills",
+    supportsLink: true,
+    supportsModeSpecific: false
+  }
+};
+function getTargetDir(config, mode) {
+  if (config.supportsModeSpecific && mode && mode !== "all" && config.modePattern) {
+    const baseDir = config.skillsDir.split("/").slice(0, -1).join("/");
+    return `${baseDir}/${config.modePattern.replace("{mode}", mode)}`;
+  }
+  return config.skillsDir;
+}
+
+// src/utils/interactive-select.ts
+import * as readline from "readline";
+function wrapText(text, maxWidth) {
+  const words = text.split(" ");
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    if (currentLine.length === 0) {
+      currentLine = word;
+    } else if (currentLine.length + 1 + word.length <= maxWidth) {
+      currentLine += " " + word;
+    } else {
+      lines.push(currentLine);
+      currentLine = word;
+    }
+  }
+  if (currentLine.length > 0) {
+    lines.push(currentLine);
+  }
+  return lines;
+}
+function buildDisplayItems(choices, searchQuery) {
+  const displayItems = [];
+  const filteredIndices = [];
+  let currentGroup;
+  choices.forEach((choice, index) => {
+    if (searchQuery && !choice.name.toLowerCase().includes(searchQuery.toLowerCase())) {
+      return;
+    }
+    filteredIndices.push(index);
+    if (choice.group && choice.group !== currentGroup) {
+      currentGroup = choice.group;
+      displayItems.push({ type: "separator", text: `\u2500\u2500 ${choice.group} \u2500\u2500` });
+    }
+    displayItems.push({ type: "choice", choiceIndex: index });
+  });
+  return { displayItems, filteredIndices };
+}
+async function interactiveCheckbox(options) {
+  const { message, choices, pageSize = 15, searchThreshold = 20 } = options;
+  const enableSearch = choices.length > searchThreshold;
+  const selected = new Set(
+    choices.map((c, i) => c.checked ? i : -1).filter((i) => i >= 0)
+  );
+  let searchQuery = "";
+  let { displayItems, filteredIndices } = buildDisplayItems(choices, searchQuery);
+  let cursor = displayItems.findIndex((item) => item.type === "choice");
+  if (cursor === -1) cursor = 0;
+  let scrollOffset = 0;
+  let lastRenderedLines = 0;
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    readline.emitKeypressEvents(process.stdin, rl);
+    const render = (isInitial = false) => {
+      if (!isInitial && lastRenderedLines > 0) {
+        process.stdout.write(`\x1B[${lastRenderedLines}A\x1B[J`);
+      }
+      const lines = [];
+      lines.push(`? ${message}`);
+      if (enableSearch) {
+        const searchDisplay = searchQuery || "";
+        lines.push(`  \x1B[33m\u{1F50D} Search:\x1B[0m ${searchDisplay}\x1B[2m\u2502\x1B[0m \x1B[2m(${filteredIndices.length}/${choices.length} skills)\x1B[0m`);
+      }
+      const visibleStart = scrollOffset;
+      const visibleEnd = Math.min(scrollOffset + pageSize, displayItems.length);
+      if (scrollOffset > 0) {
+        lines.push("  \x1B[2m\u2191 more above\x1B[0m");
+      }
+      if (displayItems.length === 0) {
+        lines.push("  \x1B[2mNo matching skills found\x1B[0m");
+      }
+      for (let i = visibleStart; i < visibleEnd; i++) {
+        const item = displayItems[i];
+        if (item.type === "separator") {
+          lines.push(`  \x1B[33m${item.text}\x1B[0m`);
+        } else {
+          const choice = choices[item.choiceIndex];
+          const isSelected = selected.has(item.choiceIndex);
+          const isCursor = i === cursor;
+          const checkbox = isSelected ? "\x1B[32m\u25C9\x1B[0m" : "\u25EF";
+          const prefix = isCursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+          const highlight = isCursor ? "\x1B[36m" : "";
+          const reset = "\x1B[0m";
+          const suffix = choice.suffix ? ` \x1B[33m${choice.suffix}\x1B[0m` : "";
+          lines.push(
+            `${prefix} ${checkbox} ${highlight}${choice.name}${reset}${suffix}`
+          );
+          if (isCursor && choice.description) {
+            const maxWidth = process.stdout.columns ? process.stdout.columns - 6 : 74;
+            const descLines = wrapText(choice.description, maxWidth);
+            for (const descLine of descLines) {
+              lines.push(`    \x1B[2m${descLine}\x1B[0m`);
+            }
+          }
+        }
+      }
+      if (visibleEnd < displayItems.length) {
+        lines.push("  \x1B[2m\u2193 more below\x1B[0m");
+      }
+      if (enableSearch) {
+        lines.push(
+          "\x1B[2m(Type to search, \u2191\u2193 move, space select, ctrl+a toggle filtered, enter confirm)\x1B[0m"
+        );
+      } else {
+        lines.push(
+          "\x1B[2m(\u2191\u2193 move, space select, ctrl+a toggle all, enter confirm)\x1B[0m"
+        );
+      }
+      console.log(lines.join("\n"));
+      lastRenderedLines = lines.length;
+    };
+    render(true);
+    const cleanup = () => {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.removeListener("keypress", handleKeypress);
+      rl.close();
+    };
+    const findPrevChoice = (from) => {
+      for (let i = from - 1; i >= 0; i--) {
+        if (displayItems[i].type === "choice") return i;
+      }
+      return from;
+    };
+    const findNextChoice = (from) => {
+      for (let i = from + 1; i < displayItems.length; i++) {
+        if (displayItems[i].type === "choice") return i;
+      }
+      return from;
+    };
+    const updateSearch = (newQuery) => {
+      searchQuery = newQuery;
+      const result = buildDisplayItems(choices, searchQuery);
+      displayItems = result.displayItems;
+      filteredIndices = result.filteredIndices;
+      cursor = displayItems.findIndex((item) => item.type === "choice");
+      if (cursor === -1) cursor = 0;
+      scrollOffset = 0;
+    };
+    const handleKeypress = (str, key) => {
+      if (!key) return;
+      if (enableSearch && str && str.length === 1 && !key.ctrl && !key.meta && key.name !== "space") {
+        if (/^[a-zA-Z0-9\-_.]$/.test(str)) {
+          updateSearch(searchQuery + str);
+          render();
+          return;
+        }
+      }
+      if (key.name === "up") {
+        cursor = findPrevChoice(cursor);
+        if (cursor < scrollOffset) {
+          scrollOffset = cursor;
+        }
+        render();
+      } else if (key.name === "down") {
+        cursor = findNextChoice(cursor);
+        if (cursor >= scrollOffset + pageSize) {
+          scrollOffset = cursor - pageSize + 1;
+        }
+        render();
+      } else if (key.name === "space") {
+        const item = displayItems[cursor];
+        if (item && item.type === "choice") {
+          const choiceIndex = item.choiceIndex;
+          if (selected.has(choiceIndex)) {
+            selected.delete(choiceIndex);
+          } else {
+            selected.add(choiceIndex);
+          }
+          render();
+        }
+      } else if (key.name === "a" && key.ctrl) {
+        const indicesToToggle = enableSearch && searchQuery ? filteredIndices : choices.map((_, i) => i);
+        const allSelected = indicesToToggle.every((i) => selected.has(i));
+        if (allSelected) {
+          indicesToToggle.forEach((i) => selected.delete(i));
+        } else {
+          indicesToToggle.forEach((i) => selected.add(i));
+        }
+        render();
+      } else if (key.name === "return") {
+        cleanup();
+        process.stdout.write(`\x1B[${lastRenderedLines}A\x1B[J`);
+        const selectedNames = Array.from(selected).sort((a, b) => a - b).map((i) => choices[i].name);
+        if (selectedNames.length === 0) {
+          console.log(`? ${message} \x1B[2mNone selected\x1B[0m`);
+        } else if (selectedNames.length <= 3) {
+          console.log(
+            `? ${message} \x1B[36m${selectedNames.join(", ")}\x1B[0m`
+          );
+        } else {
+          console.log(
+            `? ${message} \x1B[36m${selectedNames.length} skills selected\x1B[0m`
+          );
+        }
+        resolve(
+          Array.from(selected).sort((a, b) => a - b).map((i) => choices[i].value)
+        );
+      } else if (key.name === "c" && key.ctrl) {
+        cleanup();
+        console.log("\nCancelled.");
+        process.exit(0);
+      } else if (key.name === "backspace") {
+        if (enableSearch && searchQuery.length > 0) {
+          updateSearch(searchQuery.slice(0, -1));
+          render();
+        }
+      }
+    };
+    process.stdin.on("keypress", handleKeypress);
+  });
+}
+
+// src/utils/prompts.ts
+function handlePromptError(error) {
+  if (error && typeof error === "object" && "name" in error) {
+    if (error.name === "ExitPromptError") {
+      console.log("\nCancelled.");
+      process.exit(0);
+    }
+  }
+  throw error;
+}
+async function promptTools(configuredTools) {
+  const choices = SUPPORTED_TOOLS.map((tool) => {
+    const config = TOOL_CONFIGS[tool];
+    const isConfigured = configuredTools?.includes(tool);
+    return {
+      name: isConfigured ? `${config.displayName} [configured]` : config.displayName,
+      value: tool,
+      checked: isConfigured
+    };
+  });
+  try {
+    const { tools } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "tools",
+        message: "Select target tools:",
+        choices,
+        validate: (answer) => {
+          if (answer.length === 0) {
+            return "You must select at least one tool.";
+          }
+          return true;
+        }
+      }
+    ]);
+    return tools;
+  } catch (error) {
+    handlePromptError(error);
+  }
+}
+async function promptMode(toolName, modes) {
+  const config = TOOL_CONFIGS[toolName];
+  const choices = [
+    { name: `All modes (${config.skillsDir}/)`, value: "all" },
+    ...modes.map((mode) => ({
+      name: `${mode.charAt(0).toUpperCase() + mode.slice(1)} mode only (${config.skillsDir.replace("skills", `skills-${mode}`)}/)`,
+      value: mode
+    }))
+  ];
+  try {
+    const { mode } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "mode",
+        message: `Select target mode for ${config.displayName}:`,
+        choices
+      }
+    ]);
+    return mode;
+  } catch (error) {
+    handlePromptError(error);
+  }
+}
+async function promptSkills(skills, deployedSkillNames = []) {
+  const grouped = {};
+  for (const skill of skills) {
+    if (!grouped[skill.source]) {
+      grouped[skill.source] = [];
+    }
+    grouped[skill.source].push(skill);
+  }
+  const choices = [];
+  for (const [source, sourceSkills] of Object.entries(grouped)) {
+    for (const skill of sourceSkills) {
+      const isDeployed = deployedSkillNames.includes(skill.name);
+      choices.push({
+        name: skill.name,
+        description: skill.description,
+        value: skill.name,
+        checked: isDeployed,
+        group: source,
+        suffix: isDeployed ? "[deployed]" : void 0
+      });
+    }
+  }
+  return interactiveCheckbox({
+    message: "Select skills to deploy:",
+    choices,
+    pageSize: 15
+  });
+}
+async function promptSkillsToInstall(skills) {
+  const choices = skills.map((skill) => ({
+    name: skill.name,
+    description: skill.description,
+    value: skill.name
+  }));
+  return interactiveCheckbox({
+    message: "Select skills to install:",
+    choices,
+    pageSize: 15
+  });
+}
+async function promptSelect(message, choices) {
+  try {
+    const { selected } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selected",
+        message,
+        choices
+      }
+    ]);
+    return selected;
+  } catch (error) {
+    handlePromptError(error);
+  }
+}
+async function promptSyncAction(filename) {
+  try {
+    const { action } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: `${filename}: source changed`,
+        choices: [
+          { name: "Overwrite", value: "overwrite" },
+          { name: "Skip", value: "skip" },
+          { name: "Show diff", value: "diff" }
+        ]
+      }
+    ]);
+    return action;
+  } catch (error) {
+    handlePromptError(error);
+  }
+}
+async function promptOrphanAction(skillName) {
+  try {
+    const { action } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: `${skillName}: source no longer exists`,
+        choices: [
+          { name: "Remove", value: "remove" },
+          { name: "Keep", value: "keep" }
+        ]
+      }
+    ]);
+    return action;
+  } catch (error) {
+    handlePromptError(error);
+  }
+}
+
+// src/utils/progress.ts
+var ProgressBar = class {
+  current = 0;
+  total;
+  label;
+  barWidth = 30;
+  constructor(total, label = "Progress") {
+    this.total = total;
+    this.label = label;
+  }
+  /**
+   * Start the progress bar
+   */
+  start() {
+    this.current = 0;
+    this.render();
+  }
+  /**
+   * Increment progress by 1
+   */
+  tick() {
+    this.current++;
+    this.render();
+  }
+  /**
+   * Update to specific value
+   */
+  update(value) {
+    this.current = value;
+    this.render();
+  }
+  /**
+   * Complete the progress bar
+   */
+  complete() {
+    this.current = this.total;
+    this.render();
+    console.log("");
+  }
+  /**
+   * Render the progress bar
+   */
+  render() {
+    const percent = Math.min(100, Math.round(this.current / this.total * 100));
+    const filled = Math.round(this.current / this.total * this.barWidth);
+    const empty = this.barWidth - filled;
+    const bar = "\x1B[32m" + "\u2588".repeat(filled) + "\x1B[0m" + "\u2591".repeat(empty);
+    const status = `${this.current}/${this.total}`;
+    process.stdout.write(`\r\x1B[K${this.label} ${bar} ${percent}% (${status})`);
+  }
+};
+
+// src/commands/install.ts
+function parseSkillDescription(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return "";
+  }
+  const descMatch = frontmatterMatch[1].match(/^description:\s*(.+)$/m);
+  return descMatch ? descMatch[1].trim() : "";
+}
+async function installFromAnthropic(options) {
+  const githubService = new GitHubService();
+  const owner = "anthropics";
+  const repo = "skills";
+  console.log("Fetching available skills from anthropic/skills...");
+  const skillsList = await githubService.listSkills(owner, repo, "skills");
+  if (skillsList.length === 0) {
+    console.log("No skills found in repository");
+    return;
+  }
+  const defaultBranch = await githubService.getDefaultBranch(owner, repo);
+  const skills = [];
+  const progress = new ProgressBar(skillsList.length, "Fetching skill info");
+  progress.start();
+  for (const skill of skillsList) {
+    try {
+      const response = await fetch(
+        `https://raw.githubusercontent.com/${owner}/${repo}/${defaultBranch}/${skill.path}/SKILL.md`
+      );
+      if (response.ok) {
+        const content = await response.text();
+        const description = parseSkillDescription(content);
+        skills.push({
+          name: skill.name,
+          description,
+          path: skill.path
+        });
+      } else {
+        skills.push({ name: skill.name, description: "", path: skill.path });
+      }
+    } catch {
+      skills.push({ name: skill.name, description: "", path: skill.path });
+    }
+    progress.tick();
+  }
+  progress.complete();
+  console.log(`Found ${skills.length} skills.
+`);
+  let selectedSkills = skills;
+  if (!options.all) {
+    const selectedNames = await promptSkillsToInstall(skills);
+    if (selectedNames.length === 0) {
+      console.log("No skills selected");
+      return;
+    }
+    selectedSkills = skills.filter((s) => selectedNames.includes(s.name));
+  }
+  console.log(`
+Downloading ${selectedSkills.length} skills...`);
+  const targetBase = join6(SKILLS_MANAGER_DIR, "official", "anthropic");
+  for (const skill of selectedSkills) {
+    const targetDir = join6(targetBase, skill.name);
+    process.stdout.write(`  ${skill.name}...`);
+    await githubService.downloadSkill(owner, repo, skill.path, targetDir);
+    console.log(" \u2713");
+  }
+  console.log(`
+\u2713 Installed ${selectedSkills.length} skills to ${targetBase}`);
+}
+async function installFromGitHubUrl(url, options) {
+  const githubService = new GitHubService();
+  const parsed = githubService.parseGitHubUrl(url);
+  if (!parsed) {
+    return false;
+  }
+  const { owner, repo, path } = parsed;
+  const isAnthropic = owner === "anthropics" && repo === "skills";
+  if (path) {
+    const skillName = path.split("/").pop() || path;
+    const targetDir = githubService.getTargetDir(owner, repo, skillName, options.custom);
+    console.log(`Downloading ${skillName}...`);
+    await githubService.downloadSkill(owner, repo, path, targetDir);
+    console.log(`\u2713 Installed ${skillName} to ${targetDir}`);
+    return true;
+  }
+  console.log(`Fetching available skills from ${owner}/${repo}...`);
+  let skillsList = [];
+  const skillsPaths = ["skills", ".", "src/skills"];
+  for (const skillsPath of skillsPaths) {
+    try {
+      skillsList = await githubService.listSkills(owner, repo, skillsPath);
+      if (skillsList.length > 0) break;
+    } catch {
+      continue;
+    }
+  }
+  if (skillsList.length === 0) {
+    return false;
+  }
+  const defaultBranch = await githubService.getDefaultBranch(owner, repo);
+  const skills = [];
+  const progress = new ProgressBar(skillsList.length, "Fetching skill info");
+  progress.start();
+  for (const skill of skillsList) {
+    try {
+      const response = await fetch(
+        `https://raw.githubusercontent.com/${owner}/${repo}/${defaultBranch}/${skill.path}/SKILL.md`
+      );
+      if (response.ok) {
+        const content = await response.text();
+        const description = parseSkillDescription(content);
+        skills.push({ name: skill.name, description, path: skill.path });
+      }
+    } catch {
+    }
+    progress.tick();
+  }
+  progress.complete();
+  if (skills.length === 0) {
+    return false;
+  }
+  console.log(`Found ${skills.length} skills.
+`);
+  let selectedSkills = skills;
+  if (!options.all) {
+    const selectedNames = await promptSkillsToInstall(skills);
+    if (selectedNames.length === 0) {
+      console.log("No skills selected");
+      return true;
+    }
+    selectedSkills = skills.filter((s) => selectedNames.includes(s.name));
+  }
+  console.log(`
+Downloading ${selectedSkills.length} skills...`);
+  let targetBase;
+  if (isAnthropic) {
+    targetBase = join6(SKILLS_MANAGER_DIR, "official", "anthropic");
+  } else if (options.custom) {
+    targetBase = join6(SKILLS_MANAGER_DIR, "custom", repo);
+  } else {
+    targetBase = join6(SKILLS_MANAGER_DIR, "community", repo);
+  }
+  for (const skill of selectedSkills) {
+    const targetDir = join6(targetBase, skill.name);
+    process.stdout.write(`  ${skill.name}...`);
+    await githubService.downloadSkill(owner, repo, skill.path, targetDir);
+    console.log(" \u2713");
+  }
+  console.log(`
+\u2713 Installed ${selectedSkills.length} skills to ${targetBase}`);
+  return true;
+}
+async function installViaGitClone(source, options) {
+  const gitService = new GitService();
+  if (gitService.isSpecificSkillUrl(source)) {
+    const skillPath = gitService.cloneSpecificSkill(source, options.custom || false);
+    if (skillPath) {
+      console.log(`\u2713 Installed skill to ${skillPath}`);
+    } else {
+      console.log("Failed to parse skill URL");
+      process.exit(1);
+    }
+    return;
+  }
+  const repoPath = gitService.clone(source, options.custom || false);
+  let skillsRoot = repoPath;
+  if (source === "anthropic") {
+    const skillsSubdir = join6(repoPath, "skills");
+    if (fileExists(skillsSubdir)) {
+      skillsRoot = skillsSubdir;
+    }
+  }
+  const skillDirs = getDirectoriesInDir(skillsRoot);
+  const skills = [];
+  for (const dir of skillDirs) {
+    const skillMdPath = join6(dir.path, "SKILL.md");
+    if (fileExists(skillMdPath)) {
+      const content = readFileContent(skillMdPath);
+      const description = parseSkillDescription(content);
+      skills.push({
+        name: dir.name,
+        description,
+        path: dir.path
+      });
+    }
+  }
+  if (skills.length === 0) {
+    console.log("No skills found in repository");
+    return;
+  }
+  console.log(`Found ${skills.length} skills.
+`);
+  if (options.all) {
+    console.log(`\u2713 Installed ${skills.length} skills to ${repoPath}`);
+    return;
+  }
+  const selectedNames = await promptSkillsToInstall(skills);
+  if (selectedNames.length === 0) {
+    console.log("No skills selected");
+    removeDir(repoPath);
+    return;
+  }
+  const unselectedSkills = skills.filter((s) => !selectedNames.includes(s.name));
+  for (const skill of unselectedSkills) {
+    removeDir(skill.path);
+  }
+  console.log(`
+\u2713 Installed ${selectedNames.length} skills to ${repoPath}`);
+}
+async function executeInstall(source, options) {
+  if (!fileExists(SKILLS_MANAGER_DIR)) {
+    console.log("Skills manager not set up. Run: skillsmgr setup");
+    process.exit(1);
+  }
+  try {
+    if (source === "anthropic") {
+      await installFromAnthropic(options);
+      return;
+    }
+    if (source.includes("github.com")) {
+      const success = await installFromGitHubUrl(source, options);
+      if (success) return;
+      console.log("GitHub API failed, falling back to git clone...");
+    }
+    await installViaGitClone(source, options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+var installCommand = new Command2("install").description("Download skills from a repository").argument("<source>", 'Repository URL or "anthropic" for official skills').option("--all", "Install all skills without prompting").option("--custom", "Install to custom/ instead of community/").action(async (source, options) => {
+  await executeInstall(source, options);
+});
+
+// src/commands/list.ts
+import { Command as Command3 } from "commander";
+
+// src/services/skills.ts
+import { join as join7 } from "path";
+var SkillsService = class {
+  constructor(skillsDir) {
+    this.skillsDir = skillsDir;
+  }
+  getAllSkills() {
+    const skills = [];
+    for (const source of SKILL_SOURCES) {
+      const sourceDir = join7(this.skillsDir, source);
+      const sourceSkills = this.getSkillsFromSource(sourceDir, source);
+      skills.push(...sourceSkills);
+    }
+    return skills;
+  }
+  getSkillsBySource(source) {
+    const sourceDir = join7(this.skillsDir, source);
+    return this.getSkillsFromSource(sourceDir, source);
+  }
+  getSkillByName(name) {
+    const allSkills = this.getAllSkills();
+    return allSkills.find((s) => s.name === name);
+  }
+  getSkillsByNames(names) {
+    const allSkills = this.getAllSkills();
+    return names.map((name) => allSkills.find((s) => s.name === name)).filter((s) => s !== void 0);
+  }
+  findSkillsByName(name) {
+    const allSkills = this.getAllSkills();
+    return allSkills.filter((s) => s.name === name);
+  }
+  getSkillsFromSource(sourceDir, sourcePrefix) {
+    const skills = [];
+    if (!fileExists(sourceDir)) {
+      return skills;
+    }
+    if (sourcePrefix === "custom") {
+      const skillDirs = getDirectoriesInDir(sourceDir);
+      for (const skillDir of skillDirs) {
+        const skill = this.loadSkill(skillDir.path, sourcePrefix);
+        if (skill) {
+          skills.push(skill);
+        }
+      }
+    } else {
+      const repoDirs = getDirectoriesInDir(sourceDir);
+      for (const repoDir of repoDirs) {
+        const skillsSubdir = join7(repoDir.path, "skills");
+        const searchDir = fileExists(skillsSubdir) ? skillsSubdir : repoDir.path;
+        const skillDirs = getDirectoriesInDir(searchDir);
+        for (const skillDir of skillDirs) {
+          const source = `${sourcePrefix}/${repoDir.name}`;
+          const skill = this.loadSkill(skillDir.path, source);
+          if (skill) {
+            skills.push(skill);
+          }
+        }
+      }
+    }
+    return skills;
+  }
+  loadSkill(skillPath, source) {
+    const skillMdPath = join7(skillPath, "SKILL.md");
+    if (!fileExists(skillMdPath)) {
+      return void 0;
+    }
+    const content = readFileContent(skillMdPath);
+    const { name, description } = this.parseSkillMd(content);
+    return {
+      name: name || skillPath.split("/").pop() || "",
+      description: description || "",
+      path: skillPath,
+      source
+    };
+  }
+  parseSkillMd(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      return { name: "", description: "" };
+    }
+    const frontmatter = frontmatterMatch[1];
+    const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+    const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    return {
+      name: nameMatch ? nameMatch[1].trim() : "",
+      description: descMatch ? descMatch[1].trim() : ""
+    };
+  }
+};
+
+// src/services/metadata.ts
+import { join as join8 } from "path";
+var MetadataService = class {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.metadataPath = join8(projectDir, METADATA_FILENAME);
+  }
+  metadataPath;
+  load() {
+    if (!fileExists(this.metadataPath)) {
+      return { version: "1.0", tools: {} };
+    }
+    const content = readFileContent(this.metadataPath);
+    return JSON.parse(content);
+  }
+  save(metadata) {
+    writeFile(this.metadataPath, JSON.stringify(metadata, null, 2));
+  }
+  addDeployment(toolName, targetDir, mode, skills) {
+    const metadata = this.load();
+    metadata.tools[toolName] = {
+      targetDir,
+      mode,
+      deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      skills
+    };
+    this.save(metadata);
+  }
+  updateDeployment(toolName, skills) {
+    const metadata = this.load();
+    if (metadata.tools[toolName]) {
+      metadata.tools[toolName].skills = skills;
+      metadata.tools[toolName].deployedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    this.save(metadata);
+  }
+  removeDeployment(toolName) {
+    const metadata = this.load();
+    delete metadata.tools[toolName];
+    this.save(metadata);
+  }
+  getDeployedSkills(toolName) {
+    const metadata = this.load();
+    return metadata.tools[toolName]?.skills || [];
+  }
+  getToolDeployment(toolName) {
+    const metadata = this.load();
+    return metadata.tools[toolName];
+  }
+  getConfiguredTools() {
+    const metadata = this.load();
+    return Object.keys(metadata.tools);
+  }
+  hasMetadata() {
+    return fileExists(this.metadataPath);
+  }
+};
+
+// src/commands/list.ts
+async function executeList(options) {
+  if (options.deployed) {
+    await listDeployed();
+  } else {
+    await listAvailable();
+  }
+}
+async function listAvailable() {
+  if (!fileExists(SKILLS_MANAGER_DIR)) {
+    console.log("Skills manager not set up. Run: skillsmgr setup");
+    process.exit(1);
+  }
+  const service = new SkillsService(SKILLS_MANAGER_DIR);
+  const skills = service.getAllSkills();
+  if (skills.length === 0) {
+    console.log("No skills found in ~/.skills-manager/");
+    console.log("\nRun: skillsmgr install anthropic");
+    return;
+  }
+  console.log("Available skills in ~/.skills-manager/:\n");
+  const grouped = {};
+  for (const skill of skills) {
+    if (!grouped[skill.source]) {
+      grouped[skill.source] = [];
+    }
+    grouped[skill.source].push(skill);
+  }
+  for (const [source, sourceSkills] of Object.entries(grouped)) {
+    console.log(`\u2500\u2500 ${source} (${sourceSkills.length} skill${sourceSkills.length > 1 ? "s" : ""}) \u2500\u2500`);
+    for (const skill of sourceSkills) {
+      console.log(`  ${skill.name.padEnd(20)} ${skill.description}`);
+    }
+    console.log();
+  }
+}
+async function listDeployed() {
+  const metadataService = new MetadataService(process.cwd());
+  if (!metadataService.hasMetadata()) {
+    console.log("No skills deployed in current project.");
+    console.log("\nRun: skillsmgr init");
+    return;
+  }
+  console.log("Deployed skills in current project:\n");
+  const configuredTools = metadataService.getConfiguredTools();
+  for (const toolName of configuredTools) {
+    const deployment = metadataService.getToolDeployment(toolName);
+    if (!deployment) continue;
+    const config = TOOL_CONFIGS[toolName];
+    const displayName = config?.displayName || toolName;
+    console.log(`${displayName} (${deployment.targetDir}/):`);
+    for (const skill of deployment.skills) {
+      const modeStr = skill.deployMode === "link" ? "link" : "copy";
+      console.log(`  \u25C9 ${skill.name.padEnd(16)} (${modeStr}) \u2190 ${skill.source}`);
+    }
+    console.log();
+  }
+}
+var listCommand = new Command3("list").description("List available or deployed skills").option("--deployed", "List deployed skills in current project").action(async (options) => {
+  await executeList(options);
+});
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+
+// src/services/deployer.ts
+import { join as join9 } from "path";
+import { existsSync as existsSync3, rmSync as rmSync2 } from "fs";
+var Deployer = class {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+  }
+  deploySkill(skill, toolConfig, mode, targetMode) {
+    const targetDir = getTargetDir(toolConfig, targetMode);
+    const fullTargetDir = join9(this.projectDir, targetDir);
+    ensureDir(fullTargetDir);
+    const skillTargetPath = join9(fullTargetDir, skill.name);
+    if (mode === "link") {
+      linkDir(skill.path, skillTargetPath);
+    } else {
+      copyDir(skill.path, skillTargetPath);
+    }
+  }
+  deploySkills(skills, toolConfig, mode, targetMode) {
+    for (const skill of skills) {
+      this.deploySkill(skill, toolConfig, mode, targetMode);
+    }
+  }
+  removeSkill(skillName, toolConfig, targetMode) {
+    const targetDir = getTargetDir(toolConfig, targetMode);
+    const skillPath = join9(this.projectDir, targetDir, skillName);
+    if (existsSync3(skillPath)) {
+      rmSync2(skillPath, { recursive: true, force: true });
+    }
+  }
+  getDeployedSkillPath(skillName, toolConfig, targetMode) {
+    const targetDir = getTargetDir(toolConfig, targetMode);
+    return join9(this.projectDir, targetDir, skillName);
+  }
+  isSkillDeployed(skillName, toolConfig, targetMode) {
+    const skillPath = this.getDeployedSkillPath(skillName, toolConfig, targetMode);
+    return existsSync3(skillPath);
+  }
+};
+
+// src/commands/init.ts
+async function executeInit(options) {
+  if (!fileExists(SKILLS_MANAGER_DIR)) {
+    console.log("Skills manager not set up. Run: skillsmgr setup");
+    process.exit(1);
+  }
+  const skillsService = new SkillsService(SKILLS_MANAGER_DIR);
+  const metadataService = new MetadataService(process.cwd());
+  const deployer = new Deployer(process.cwd());
+  const allSkills = skillsService.getAllSkills();
+  if (allSkills.length === 0) {
+    console.log("No skills found. Run: skillsmgr install anthropic");
+    process.exit(1);
+  }
+  const configuredTools = metadataService.getConfiguredTools();
+  const selectedTools = await promptTools(configuredTools);
+  const toolModes = {};
+  for (const toolName of selectedTools) {
+    const config = TOOL_CONFIGS[toolName];
+    if (config.supportsModeSpecific && config.availableModes) {
+      const mode = await promptMode(toolName, config.availableModes);
+      toolModes[toolName] = mode;
+    } else {
+      toolModes[toolName] = "all";
+    }
+  }
+  const deployedSkillNames = /* @__PURE__ */ new Set();
+  for (const toolName of selectedTools) {
+    const deployed = metadataService.getDeployedSkills(toolName);
+    deployed.forEach((s) => deployedSkillNames.add(s.name));
+  }
+  const selectedSkillNames = await promptSkills(
+    allSkills,
+    Array.from(deployedSkillNames)
+  );
+  if (selectedSkillNames.length === 0) {
+    console.log("No skills selected");
+    return;
+  }
+  const selectedSkills = skillsService.getSkillsByNames(selectedSkillNames);
+  const deployMode = options.copy ? "copy" : "link";
+  console.log("\nDeploying skills...\n");
+  for (const toolName of selectedTools) {
+    const config = TOOL_CONFIGS[toolName];
+    const mode = toolModes[toolName];
+    const targetDir = getTargetDir(config, mode);
+    console.log(`${config.displayName}:`);
+    const previouslyDeployed = metadataService.getDeployedSkills(toolName);
+    const previousNames = new Set(previouslyDeployed.map((s) => s.name));
+    const toAdd = selectedSkills.filter((s) => !previousNames.has(s.name));
+    const toKeep = selectedSkills.filter((s) => previousNames.has(s.name));
+    const toRemove = previouslyDeployed.filter(
+      (s) => !selectedSkillNames.includes(s.name)
+    );
+    for (const skill of toRemove) {
+      deployer.removeSkill(skill.name, config, mode);
+      console.log(`  \u2717 ${skill.name} (removed)`);
+    }
+    for (const skill of toKeep) {
+      console.log(`  \xB7 ${skill.name} (unchanged)`);
+    }
+    for (const skill of toAdd) {
+      deployer.deploySkill(skill, config, deployMode, mode);
+      console.log(`  \u2713 ${skill.name} (${deployMode === "link" ? "linked" : "copied"})`);
+    }
+    const newDeployedSkills = selectedSkills.map((skill) => ({
+      name: skill.name,
+      source: skill.source,
+      deployMode
+    }));
+    metadataService.addDeployment(toolName, targetDir, mode, newDeployedSkills);
+    console.log();
+  }
+  console.log(
+    `Done! Deployed ${selectedSkillNames.length} skills to ${selectedTools.length} tool${selectedTools.length > 1 ? "s" : ""}.`
+  );
+}
+var initCommand = new Command4("init").description("Deploy skills to current project").option("--copy", "Copy files instead of creating symlinks").action(async (options) => {
+  await executeInit(options);
+});
+
+// src/commands/add.ts
+import { Command as Command5 } from "commander";
+async function executeAdd(skillName, options) {
+  if (!fileExists(SKILLS_MANAGER_DIR)) {
+    console.log("Skills manager not set up. Run: skillsmgr setup");
+    process.exit(1);
+  }
+  const skillsService = new SkillsService(SKILLS_MANAGER_DIR);
+  const metadataService = new MetadataService(process.cwd());
+  const deployer = new Deployer(process.cwd());
+  const matchingSkills = skillsService.findSkillsByName(skillName);
+  if (matchingSkills.length === 0) {
+    console.log(`Skill '${skillName}' not found`);
+    process.exit(1);
+  }
+  let skill = matchingSkills[0];
+  if (matchingSkills.length > 1) {
+    console.log(`Multiple skills found with name '${skillName}':`);
+    const choices = matchingSkills.map((s, i) => ({
+      name: `${i + 1}. ${s.source}/${s.name}`,
+      value: s.source
+    }));
+    const selectedSource = await promptSelect("Select skill:", choices);
+    skill = matchingSkills.find((s) => s.source === selectedSource);
+  }
+  let targetTools;
+  if (options.tool) {
+    if (!TOOL_CONFIGS[options.tool]) {
+      console.log(`Unknown tool: ${options.tool}`);
+      process.exit(1);
+    }
+    targetTools = [options.tool];
+  } else {
+    targetTools = metadataService.getConfiguredTools();
+    if (targetTools.length === 0) {
+      console.log("No tools configured. Run: skillsmgr init");
+      process.exit(1);
+    }
+  }
+  const deployMode = options.copy ? "copy" : "link";
+  console.log(`Adding ${skillName} to configured tools...`);
+  for (const toolName of targetTools) {
+    const config = TOOL_CONFIGS[toolName];
+    const deployment = metadataService.getToolDeployment(toolName);
+    const mode = deployment?.mode || "all";
+    deployer.deploySkill(skill, config, deployMode, mode);
+    const existingSkills = metadataService.getDeployedSkills(toolName);
+    const alreadyExists = existingSkills.some((s) => s.name === skill.name);
+    if (!alreadyExists) {
+      const newSkill = {
+        name: skill.name,
+        source: skill.source,
+        deployMode
+      };
+      metadataService.updateDeployment(toolName, [...existingSkills, newSkill]);
+    }
+    console.log(
+      `  \u2713 ${config.displayName} (${deployMode === "link" ? "linked" : "copied"})`
+    );
+  }
+}
+var addCommand = new Command5("add").description("Add a skill to the project").argument("<skill>", "Skill name to add").option("--tool <tool>", "Add to specific tool only").option("--copy", "Copy files instead of creating symlinks").action(async (skill, options) => {
+  await executeAdd(skill, options);
+});
+
+// src/commands/remove.ts
+import { Command as Command6 } from "commander";
+async function executeRemove(skillName, options) {
+  const metadataService = new MetadataService(process.cwd());
+  const deployer = new Deployer(process.cwd());
+  if (!metadataService.hasMetadata()) {
+    console.log("No skills deployed in current project.");
+    process.exit(1);
+  }
+  let targetTools;
+  if (options.tool) {
+    if (!TOOL_CONFIGS[options.tool]) {
+      console.log(`Unknown tool: ${options.tool}`);
+      process.exit(1);
+    }
+    targetTools = [options.tool];
+  } else {
+    targetTools = metadataService.getConfiguredTools();
+  }
+  console.log(`Removing ${skillName}...`);
+  let removed = false;
+  for (const toolName of targetTools) {
+    const config = TOOL_CONFIGS[toolName];
+    const deployment = metadataService.getToolDeployment(toolName);
+    if (!deployment) continue;
+    const existingSkills = deployment.skills;
+    const skillToRemove = existingSkills.find((s) => s.name === skillName);
+    if (!skillToRemove) continue;
+    deployer.removeSkill(skillName, config, deployment.mode);
+    const remainingSkills = existingSkills.filter((s) => s.name !== skillName);
+    metadataService.updateDeployment(toolName, remainingSkills);
+    console.log(`  \u2713 Removed from ${config.displayName}`);
+    removed = true;
+  }
+  if (!removed) {
+    console.log(`Skill '${skillName}' not found in any configured tool`);
+  }
+}
+var removeCommand = new Command6("remove").description("Remove a skill from the project").argument("<skill>", "Skill name to remove").option("--tool <tool>", "Remove from specific tool only").action(async (skill, options) => {
+  await executeRemove(skill, options);
+});
+
+// src/commands/sync.ts
+import { Command as Command7 } from "commander";
+import { join as join10 } from "path";
+async function executeSync() {
+  const metadataService = new MetadataService(process.cwd());
+  const deployer = new Deployer(process.cwd());
+  if (!metadataService.hasMetadata()) {
+    console.log("No skills deployed in current project.");
+    process.exit(1);
+  }
+  console.log("Checking deployed skills...\n");
+  const configuredTools = metadataService.getConfiguredTools();
+  let updatedCount = 0;
+  let removedCount = 0;
+  let untrackedCount = 0;
+  for (const toolName of configuredTools) {
+    const config = TOOL_CONFIGS[toolName];
+    const deployment = metadataService.getToolDeployment(toolName);
+    if (!deployment) continue;
+    console.log(`${config.displayName} (${deployment.targetDir}/):`);
+    for (const skill of deployment.skills) {
+      const deployedPath = join10(process.cwd(), deployment.targetDir, skill.name);
+      const sourcePath = join10(SKILLS_MANAGER_DIR, skill.source, skill.name);
+      if (!fileExists(sourcePath)) {
+        console.log(`  \u2717 ${skill.name}: orphaned (source deleted)`);
+        const action = await promptOrphanAction(skill.name);
+        if (action === "remove") {
+          deployer.removeSkill(skill.name, config, deployment.mode);
+          const remaining = deployment.skills.filter((s) => s.name !== skill.name);
+          metadataService.updateDeployment(toolName, remaining);
+          console.log(`  \u2713 Removed ${skill.name}`);
+          removedCount++;
+        }
+        continue;
+      }
+      if (isSymlink(deployedPath)) {
+        console.log(`  \u2713 ${skill.name}: up to date (link)`);
+        continue;
+      }
+      if (skill.deployMode === "copy") {
+        const sourceSkillMd = join10(sourcePath, "SKILL.md");
+        const deployedSkillMd = join10(deployedPath, "SKILL.md");
+        if (fileExists(sourceSkillMd) && fileExists(deployedSkillMd)) {
+          const sourceContent = readFileContent(sourceSkillMd);
+          const deployedContent = readFileContent(deployedSkillMd);
+          if (sourceContent !== deployedContent) {
+            console.log(`  \u26A0 ${skill.name}: source changed (copy)`);
+            const action = await promptSyncAction(skill.name);
+            if (action === "diff") {
+              console.log("\n--- local");
+              console.log(deployedContent.slice(0, 500));
+              console.log("\n+++ source");
+              console.log(sourceContent.slice(0, 500));
+              console.log();
+              const finalAction = await promptSyncAction(skill.name);
+              if (finalAction === "overwrite") {
+                deployer.deploySkill(
+                  { name: skill.name, description: "", path: sourcePath, source: skill.source },
+                  config,
+                  "copy",
+                  deployment.mode
+                );
+                console.log(`  \u2713 Updated ${skill.name}`);
+                updatedCount++;
+              }
+            } else if (action === "overwrite") {
+              deployer.deploySkill(
+                { name: skill.name, description: "", path: sourcePath, source: skill.source },
+                config,
+                "copy",
+                deployment.mode
+              );
+              console.log(`  \u2713 Updated ${skill.name}`);
+              updatedCount++;
+            }
+          } else {
+            console.log(`  \u2713 ${skill.name}: up to date (copy)`);
+          }
+        }
+      }
+    }
+    console.log();
+  }
+  console.log(
+    `Sync complete: ${updatedCount} updated, ${removedCount} removed, ${untrackedCount} untracked`
+  );
+}
+var syncCommand = new Command7("sync").description("Sync and verify deployed skills").action(async () => {
+  await executeSync();
+});
+
+// src/index.ts
+var program = new Command8();
+program.name("skillsmgr").description("Unified skills manager for AI coding tools").version("0.1.0");
+program.addCommand(setupCommand);
+program.addCommand(installCommand);
+program.addCommand(listCommand);
+program.addCommand(initCommand);
+program.addCommand(addCommand);
+program.addCommand(removeCommand);
+program.addCommand(syncCommand);
+program.parse();