@zot24/add-skill 1.0.10

package/dist/index.js

@@ -0,0 +1,1120 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+
+// src/git.ts
+import simpleGit from "simple-git";
+import { join } from "path";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+function parseSource(input) {
+  const githubTreeMatch = input.match(
+    /github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/
+  );
+  if (githubTreeMatch) {
+    const [, owner, repo, , subpath] = githubTreeMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      subpath
+    };
+  }
+  const githubRepoMatch = input.match(/github\.com\/([^/]+)\/([^/]+)/);
+  if (githubRepoMatch) {
+    const [, owner, repo] = githubRepoMatch;
+    const cleanRepo = repo.replace(/\.git$/, "");
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${cleanRepo}.git`
+    };
+  }
+  const gitlabTreeMatch = input.match(
+    /gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)\/(.+)/
+  );
+  if (gitlabTreeMatch) {
+    const [, owner, repo, , subpath] = gitlabTreeMatch;
+    return {
+      type: "gitlab",
+      url: `https://gitlab.com/${owner}/${repo}.git`,
+      subpath
+    };
+  }
+  const gitlabRepoMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)/);
+  if (gitlabRepoMatch) {
+    const [, owner, repo] = gitlabRepoMatch;
+    const cleanRepo = repo.replace(/\.git$/, "");
+    return {
+      type: "gitlab",
+      url: `https://gitlab.com/${owner}/${cleanRepo}.git`
+    };
+  }
+  const shorthandMatch = input.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
+  if (shorthandMatch && !input.includes(":")) {
+    const [, owner, repo, subpath] = shorthandMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      subpath
+    };
+  }
+  return {
+    type: "git",
+    url: input
+  };
+}
+async function cloneRepo(url) {
+  const tempDir = await mkdtemp(join(tmpdir(), "add-skill-"));
+  const git = simpleGit();
+  await git.clone(url, tempDir, ["--depth", "1"]);
+  return tempDir;
+}
+async function cloneRepoAtVersion(url, version2) {
+  const tempDir = await mkdtemp(join(tmpdir(), "add-skill-"));
+  const git = simpleGit();
+  if (!version2) {
+    await git.clone(url, tempDir, ["--depth", "1"]);
+    const repoGit2 = simpleGit(tempDir);
+    const log3 = await repoGit2.log(["-1", "--format=%H"]);
+    return {
+      tempDir,
+      resolvedRef: log3.latest?.hash || "HEAD"
+    };
+  }
+  const tagVariants = [`v${version2}`, version2];
+  for (const tag of tagVariants) {
+    try {
+      await git.clone(url, tempDir, ["--depth", "1", "--branch", tag]);
+      const repoGit2 = simpleGit(tempDir);
+      const log3 = await repoGit2.log(["-1", "--format=%H"]);
+      return {
+        tempDir,
+        resolvedRef: log3.latest?.hash || "HEAD"
+      };
+    } catch {
+      await rm(tempDir, { recursive: true, force: true }).catch(() => {
+      });
+      await mkdtemp(join(tmpdir(), "add-skill-")).then((dir) => {
+      });
+    }
+  }
+  const fallbackDir = await mkdtemp(join(tmpdir(), "add-skill-"));
+  await git.clone(url, fallbackDir, ["--depth", "1"]);
+  const repoGit = simpleGit(fallbackDir);
+  const log2 = await repoGit.log(["-1", "--format=%H"]);
+  return {
+    tempDir: fallbackDir,
+    resolvedRef: log2.latest?.hash || "HEAD"
+  };
+}
+async function cleanupTempDir(dir) {
+  await rm(dir, { recursive: true, force: true });
+}
+
+// src/skills.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join as join2, basename, dirname } from "path";
+import matter from "gray-matter";
+var SKIP_DIRS = ["node_modules", ".git", "dist", "build", "__pycache__"];
+async function hasSkillMd(dir) {
+  try {
+    const skillPath = join2(dir, "SKILL.md");
+    const stats = await stat(skillPath);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function parseSkillMd(skillMdPath) {
+  try {
+    const content = await readFile(skillMdPath, "utf-8");
+    const { data } = matter(content);
+    if (!data.name || !data.description) {
+      return null;
+    }
+    let version2;
+    if (data.version && typeof data.version === "string") {
+      version2 = {
+        version: data.version,
+        source: "frontmatter"
+      };
+    }
+    return {
+      name: data.name,
+      description: data.description,
+      path: dirname(skillMdPath),
+      metadata: data.metadata,
+      version: version2
+    };
+  } catch {
+    return null;
+  }
+}
+async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
+  const skillDirs = [];
+  if (depth > maxDepth) return skillDirs;
+  try {
+    if (await hasSkillMd(dir)) {
+      skillDirs.push(dir);
+    }
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !SKIP_DIRS.includes(entry.name)) {
+        const subDirs = await findSkillDirs(join2(dir, entry.name), depth + 1, maxDepth);
+        skillDirs.push(...subDirs);
+      }
+    }
+  } catch {
+  }
+  return skillDirs;
+}
+async function discoverSkills(basePath, subpath) {
+  const skills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const searchPath = subpath ? join2(basePath, subpath) : basePath;
+  if (await hasSkillMd(searchPath)) {
+    const skill = await parseSkillMd(join2(searchPath, "SKILL.md"));
+    if (skill) {
+      skills.push(skill);
+      return skills;
+    }
+  }
+  const prioritySearchDirs = [
+    searchPath,
+    join2(searchPath, "skills"),
+    join2(searchPath, "skills/.curated"),
+    join2(searchPath, "skills/.experimental"),
+    join2(searchPath, "skills/.system"),
+    join2(searchPath, ".codex/skills"),
+    join2(searchPath, ".claude/skills"),
+    join2(searchPath, ".opencode/skill"),
+    join2(searchPath, ".cursor/skills"),
+    join2(searchPath, ".agents/skills"),
+    join2(searchPath, ".kilocode/skills"),
+    join2(searchPath, ".roo/skills"),
+    join2(searchPath, ".goose/skills"),
+    join2(searchPath, ".agent/skills")
+  ];
+  for (const dir of prioritySearchDirs) {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillDir = join2(dir, entry.name);
+          if (await hasSkillMd(skillDir)) {
+            const skill = await parseSkillMd(join2(skillDir, "SKILL.md"));
+            if (skill && !seenNames.has(skill.name)) {
+              skills.push(skill);
+              seenNames.add(skill.name);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (skills.length === 0) {
+    const allSkillDirs = await findSkillDirs(searchPath);
+    for (const skillDir of allSkillDirs) {
+      const skill = await parseSkillMd(join2(skillDir, "SKILL.md"));
+      if (skill && !seenNames.has(skill.name)) {
+        skills.push(skill);
+        seenNames.add(skill.name);
+      }
+    }
+  }
+  return skills;
+}
+function getSkillDisplayName(skill) {
+  return skill.name || basename(skill.path);
+}
+function validateSkillVersion(skill, requestedVersion) {
+  const actual = skill.version?.version;
+  if (!actual) {
+    return {
+      valid: true,
+      // Allow unversioned skills with a warning
+      actual: void 0,
+      message: `Skill "${skill.name}" has no version in SKILL.md. Installing from repository tag/branch.`
+    };
+  }
+  if (actual === requestedVersion) {
+    return { valid: true, actual };
+  }
+  return {
+    valid: false,
+    actual,
+    message: `Version mismatch for "${skill.name}": requested ${requestedVersion}, found ${actual}`
+  };
+}
+
+// src/installer.ts
+import { mkdir, cp, access, readdir as readdir2 } from "fs/promises";
+import { join as join4, basename as basename2 } from "path";
+
+// src/agents.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { existsSync } from "fs";
+var home = homedir();
+var agents = {
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: ".opencode/skill",
+    globalSkillsDir: join3(home, ".config/opencode/skill"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".config/opencode")) || existsSync(join3(home, ".claude/skills"));
+    }
+  },
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    skillsDir: ".claude/skills",
+    globalSkillsDir: join3(home, ".claude/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".claude"));
+    }
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    skillsDir: ".codex/skills",
+    globalSkillsDir: join3(home, ".codex/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".codex"));
+    }
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: ".cursor/skills",
+    globalSkillsDir: join3(home, ".cursor/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".cursor"));
+    }
+  },
+  amp: {
+    name: "amp",
+    displayName: "Amp",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join3(home, ".config/agents/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".config/amp"));
+    }
+  },
+  kilo: {
+    name: "kilo",
+    displayName: "Kilo Code",
+    skillsDir: ".kilocode/skills",
+    globalSkillsDir: join3(home, ".kilocode/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".kilocode"));
+    }
+  },
+  roo: {
+    name: "roo",
+    displayName: "Roo Code",
+    skillsDir: ".roo/skills",
+    globalSkillsDir: join3(home, ".roo/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".roo"));
+    }
+  },
+  goose: {
+    name: "goose",
+    displayName: "Goose",
+    skillsDir: ".goose/skills",
+    globalSkillsDir: join3(home, ".config/goose/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(home, ".config/goose"));
+    }
+  },
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDir: ".agent/skills",
+    globalSkillsDir: join3(home, ".gemini/antigravity/skills"),
+    detectInstalled: async () => {
+      return existsSync(join3(process.cwd(), ".agent")) || existsSync(join3(home, ".gemini/antigravity"));
+    }
+  }
+};
+async function detectInstalledAgents() {
+  const installed = [];
+  for (const [type, config] of Object.entries(agents)) {
+    if (await config.detectInstalled()) {
+      installed.push(type);
+    }
+  }
+  return installed;
+}
+
+// src/installer.ts
+async function installSkillForAgent(skill, agentType, options = {}) {
+  const agent = agents[agentType];
+  const skillName = skill.name || basename2(skill.path);
+  const targetBase = options.global ? agent.globalSkillsDir : join4(options.cwd || process.cwd(), agent.skillsDir);
+  const targetDir = join4(targetBase, skillName);
+  try {
+    await mkdir(targetDir, { recursive: true });
+    await copyDirectory(skill.path, targetDir);
+    return { success: true, path: targetDir };
+  } catch (error) {
+    return {
+      success: false,
+      path: targetDir,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+var EXCLUDE_FILES = /* @__PURE__ */ new Set([
+  "README.md",
+  "metadata.json"
+]);
+var isExcluded = (name) => {
+  if (EXCLUDE_FILES.has(name)) return true;
+  if (name.startsWith("_")) return true;
+  return false;
+};
+async function copyDirectory(src, dest) {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir2(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (isExcluded(entry.name)) {
+      continue;
+    }
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await cp(srcPath, destPath);
+    }
+  }
+}
+async function isSkillInstalled(skillName, agentType, options = {}) {
+  const agent = agents[agentType];
+  const targetBase = options.global ? agent.globalSkillsDir : join4(options.cwd || process.cwd(), agent.skillsDir);
+  const skillDir = join4(targetBase, skillName);
+  try {
+    await access(skillDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getInstallPath(skillName, agentType, options = {}) {
+  const agent = agents[agentType];
+  const targetBase = options.global ? agent.globalSkillsDir : join4(options.cwd || process.cwd(), agent.skillsDir);
+  return join4(targetBase, skillName);
+}
+
+// src/telemetry.ts
+var TELEMETRY_URL = "https://add-skill.vercel.sh/t";
+var cliVersion = null;
+function isCI() {
+  return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.BUILDKITE || process.env.JENKINS_URL || process.env.TEAMCITY_VERSION);
+}
+function isEnabled() {
+  return !process.env.DISABLE_TELEMETRY && !process.env.DO_NOT_TRACK;
+}
+function setVersion(version2) {
+  cliVersion = version2;
+}
+function track(data) {
+  if (!isEnabled()) return;
+  try {
+    const params = new URLSearchParams();
+    if (cliVersion) {
+      params.set("v", cliVersion);
+    }
+    if (isCI()) {
+      params.set("ci", "1");
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (value !== void 0 && value !== null) {
+        params.set(key, String(value));
+      }
+    }
+    fetch(`${TELEMETRY_URL}?${params.toString()}`).catch(() => {
+    });
+  } catch {
+  }
+}
+
+// src/manifest.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { parse, stringify } from "smol-toml";
+var ManifestParseError = class extends Error {
+  constructor(message, filePath) {
+    super(message);
+    this.filePath = filePath;
+    this.name = "ManifestParseError";
+  }
+};
+var SkillNotFoundError = class extends Error {
+  constructor(skillName, source, availableSkills) {
+    super(`Skill "${skillName}" not found in ${source}. Available: ${availableSkills.join(", ") || "none"}`);
+    this.skillName = skillName;
+    this.source = source;
+    this.availableSkills = availableSkills;
+    this.name = "SkillNotFoundError";
+  }
+};
+async function parseManifestFile(filePath) {
+  let content;
+  try {
+    content = await readFile2(filePath, "utf-8");
+  } catch (error) {
+    throw new ManifestParseError(
+      `Could not read manifest file: ${error.message}`,
+      filePath
+    );
+  }
+  let parsed;
+  try {
+    parsed = parse(content);
+  } catch (error) {
+    throw new ManifestParseError(
+      `Invalid TOML: ${error.message}`,
+      filePath
+    );
+  }
+  if (!parsed.skills || !Array.isArray(parsed.skills)) {
+    throw new ManifestParseError(
+      "Manifest must contain a [[skills]] array",
+      filePath
+    );
+  }
+  const skills = [];
+  for (let i = 0; i < parsed.skills.length; i++) {
+    const entry = parsed.skills[i];
+    if (!entry || typeof entry !== "object") {
+      throw new ManifestParseError(
+        `Invalid skill entry at index ${i}`,
+        filePath
+      );
+    }
+    if (!entry.source || typeof entry.source !== "string") {
+      throw new ManifestParseError(
+        `Skill entry ${i} missing required "source" field`,
+        filePath
+      );
+    }
+    if (!entry.name || typeof entry.name !== "string") {
+      throw new ManifestParseError(
+        `Skill entry ${i} missing required "name" field`,
+        filePath
+      );
+    }
+    const manifestEntry = {
+      source: entry.source,
+      name: entry.name
+    };
+    if (entry.version && typeof entry.version === "string") {
+      manifestEntry.version = entry.version;
+    }
+    validateManifestEntry(manifestEntry);
+    skills.push(manifestEntry);
+  }
+  if (skills.length === 0) {
+    throw new ManifestParseError(
+      "Manifest file contains no skill entries",
+      filePath
+    );
+  }
+  return { skills };
+}
+function validateManifestEntry(entry) {
+  const isShorthand = /^[^/]+\/[^/]+$/.test(entry.source);
+  const isUrl = entry.source.includes("://") || entry.source.startsWith("git@");
+  if (!isShorthand && !isUrl) {
+    throw new Error(
+      `Invalid source "${entry.source}". Use "owner/repo" or a full git URL.`
+    );
+  }
+  if (entry.version && entry.version !== "latest") {
+    const semverRegex = /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/;
+    if (!semverRegex.test(entry.version)) {
+      throw new Error(
+        `Invalid version "${entry.version}" for skill "${entry.name}". Use semantic versioning (e.g., 1.0.0) or "latest".`
+      );
+    }
+  }
+}
+function getLockFilePath(manifestPath) {
+  const dir = dirname2(manifestPath);
+  const baseName = manifestPath.replace(/\.toml$/, "");
+  return `${baseName}-lock.toml`;
+}
+async function writeLockFile(lockPath, entries) {
+  const lockFile = {
+    lockVersion: 1,
+    skills: entries.map((entry) => ({
+      source: entry.source,
+      name: entry.name,
+      version: entry.version,
+      resolvedRef: entry.resolvedRef,
+      installedAt: entry.installedAt
+    }))
+  };
+  const tomlContent = stringify(lockFile);
+  await writeFile(lockPath, tomlContent, "utf-8");
+}
+function groupSkillsBySource(skills) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const key = skill.version ? `${skill.source}@${skill.version}` : skill.source;
+    const existing = grouped.get(key) || [];
+    existing.push(skill);
+    grouped.set(key, existing);
+  }
+  return grouped;
+}
+
+// package.json
+var package_default = {
+  name: "@zot24/add-skill",
+  version: "1.0.10",
+  description: "Install agent skills onto coding agents (OpenCode, Claude Code, Codex, Cursor)",
+  type: "module",
+  bin: {
+    "add-skill": "./dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup src/index.ts --format esm --dts --clean",
+    dev: "tsx src/index.ts",
+    prepublishOnly: "npm run build"
+  },
+  keywords: [
+    "cli",
+    "skills",
+    "opencode",
+    "claude-code",
+    "codex",
+    "cursor",
+    "antigravity",
+    "ai-agents"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/vercel-labs/add-skill.git"
+  },
+  homepage: "https://github.com/vercel-labs/add-skill#readme",
+  bugs: {
+    url: "https://github.com/vercel-labs/add-skill/issues"
+  },
+  author: "",
+  license: "MIT",
+  dependencies: {
+    "@clack/prompts": "^0.9.1",
+    chalk: "^5.4.1",
+    commander: "^13.1.0",
+    "gray-matter": "^4.0.3",
+    "simple-git": "^3.27.0",
+    "smol-toml": "^1.3.1"
+  },
+  devDependencies: {
+    "@types/node": "^22.10.0",
+    tsup: "^8.3.5",
+    tsx: "^4.19.2",
+    typescript: "^5.7.2"
+  },
+  engines: {
+    node: ">=18"
+  }
+};
+
+// src/index.ts
+var version = package_default.version;
+setVersion(version);
+program.name("add-skill").description("Install skills onto coding agents (OpenCode, Claude Code, Codex, Cursor, Antigravity)").version(version).argument("[source]", "Git repo URL, GitHub shorthand (owner/repo), or direct path to skill").option("-g, --global", "Install skill globally (user-level) instead of project-level").option("-a, --agent <agents...>", "Specify agents to install to (opencode, claude-code, codex, cursor)").option("-s, --skill <skills...>", "Specify skill names to install (skip selection prompt)").option("-l, --list", "List available skills in the repository without installing").option("-y, --yes", "Skip confirmation prompts").option("-f, --from-file <path>", "Install skills from a TOML manifest file").option("--no-lock", "Skip generating/updating lock file when using --from-file").action(async (source, options) => {
+  if (options.fromFile) {
+    await installFromManifest(options.fromFile, options);
+  } else if (source) {
+    await main(source, options);
+  } else {
+    p.log.error("Missing required argument: source");
+    p.log.info("Usage: add-skill <source> or add-skill --from-file <path>");
+    process.exit(1);
+  }
+});
+program.parse();
+async function main(source, options) {
+  console.log();
+  p.intro(chalk.bgCyan.black(" add-skill "));
+  let tempDir = null;
+  try {
+    const spinner2 = p.spinner();
+    spinner2.start("Parsing source...");
+    const parsed = parseSource(source);
+    spinner2.stop(`Source: ${chalk.cyan(parsed.url)}${parsed.subpath ? ` (${parsed.subpath})` : ""}`);
+    spinner2.start("Cloning repository...");
+    tempDir = await cloneRepo(parsed.url);
+    spinner2.stop("Repository cloned");
+    spinner2.start("Discovering skills...");
+    const skills = await discoverSkills(tempDir, parsed.subpath);
+    if (skills.length === 0) {
+      spinner2.stop(chalk.red("No skills found"));
+      p.outro(chalk.red("No valid skills found. Skills require a SKILL.md with name and description."));
+      await cleanup(tempDir);
+      process.exit(1);
+    }
+    spinner2.stop(`Found ${chalk.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+    if (options.list) {
+      console.log();
+      p.log.step(chalk.bold("Available Skills"));
+      for (const skill of skills) {
+        p.log.message(`  ${chalk.cyan(getSkillDisplayName(skill))}`);
+        p.log.message(`    ${chalk.dim(skill.description)}`);
+      }
+      console.log();
+      p.outro("Use --skill <name> to install specific skills");
+      await cleanup(tempDir);
+      process.exit(0);
+    }
+    let selectedSkills;
+    if (options.skill && options.skill.length > 0) {
+      selectedSkills = skills.filter(
+        (s) => options.skill.some(
+          (name) => s.name.toLowerCase() === name.toLowerCase() || getSkillDisplayName(s).toLowerCase() === name.toLowerCase()
+        )
+      );
+      if (selectedSkills.length === 0) {
+        p.log.error(`No matching skills found for: ${options.skill.join(", ")}`);
+        p.log.info("Available skills:");
+        for (const s of skills) {
+          p.log.message(`  - ${getSkillDisplayName(s)}`);
+        }
+        await cleanup(tempDir);
+        process.exit(1);
+      }
+      p.log.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => chalk.cyan(getSkillDisplayName(s))).join(", ")}`);
+    } else if (skills.length === 1) {
+      selectedSkills = skills;
+      const firstSkill = skills[0];
+      p.log.info(`Skill: ${chalk.cyan(getSkillDisplayName(firstSkill))}`);
+      p.log.message(chalk.dim(firstSkill.description));
+    } else if (options.yes) {
+      selectedSkills = skills;
+      p.log.info(`Installing all ${skills.length} skills`);
+    } else {
+      const skillChoices = skills.map((s) => ({
+        value: s,
+        label: getSkillDisplayName(s),
+        hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+      }));
+      const selected = await p.multiselect({
+        message: "Select skills to install",
+        options: skillChoices,
+        required: true
+      });
+      if (p.isCancel(selected)) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+      selectedSkills = selected;
+    }
+    let targetAgents;
+    if (options.agent && options.agent.length > 0) {
+      const validAgents = ["opencode", "claude-code", "codex", "cursor", "antigravity"];
+      const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+      if (invalidAgents.length > 0) {
+        p.log.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+        p.log.info(`Valid agents: ${validAgents.join(", ")}`);
+        await cleanup(tempDir);
+        process.exit(1);
+      }
+      targetAgents = options.agent;
+    } else {
+      spinner2.start("Detecting installed agents...");
+      const installedAgents = await detectInstalledAgents();
+      spinner2.stop(`Detected ${installedAgents.length} agent${installedAgents.length !== 1 ? "s" : ""}`);
+      if (installedAgents.length === 0) {
+        if (options.yes) {
+          targetAgents = ["opencode", "claude-code", "codex", "cursor", "antigravity"];
+          p.log.info("Installing to all agents (none detected)");
+        } else {
+          p.log.warn("No coding agents detected. You can still install skills.");
+          const allAgentChoices = Object.entries(agents).map(([key, config]) => ({
+            value: key,
+            label: config.displayName
+          }));
+          const selected = await p.multiselect({
+            message: "Select agents to install skills to",
+            options: allAgentChoices,
+            required: true
+          });
+          if (p.isCancel(selected)) {
+            p.cancel("Installation cancelled");
+            await cleanup(tempDir);
+            process.exit(0);
+          }
+          targetAgents = selected;
+        }
+      } else if (installedAgents.length === 1 || options.yes) {
+        targetAgents = installedAgents;
+        if (installedAgents.length === 1) {
+          const firstAgent = installedAgents[0];
+          p.log.info(`Installing to: ${chalk.cyan(agents[firstAgent].displayName)}`);
+        } else {
+          p.log.info(`Installing to: ${installedAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ")}`);
+        }
+      } else {
+        const agentChoices = installedAgents.map((a) => ({
+          value: a,
+          label: agents[a].displayName,
+          hint: `${options.global ? agents[a].globalSkillsDir : agents[a].skillsDir}`
+        }));
+        const selected = await p.multiselect({
+          message: "Select agents to install skills to",
+          options: agentChoices,
+          required: true,
+          initialValues: installedAgents
+        });
+        if (p.isCancel(selected)) {
+          p.cancel("Installation cancelled");
+          await cleanup(tempDir);
+          process.exit(0);
+        }
+        targetAgents = selected;
+      }
+    }
+    let installGlobally = options.global ?? false;
+    if (options.global === void 0 && !options.yes) {
+      const scope = await p.select({
+        message: "Installation scope",
+        options: [
+          { value: false, label: "Project", hint: "Install in current directory (committed with your project)" },
+          { value: true, label: "Global", hint: "Install in home directory (available across all projects)" }
+        ]
+      });
+      if (p.isCancel(scope)) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+      installGlobally = scope;
+    }
+    console.log();
+    p.log.step(chalk.bold("Installation Summary"));
+    for (const skill of selectedSkills) {
+      p.log.message(`  ${chalk.cyan(getSkillDisplayName(skill))}`);
+      for (const agent of targetAgents) {
+        const path = getInstallPath(skill.name, agent, { global: installGlobally });
+        const installed = await isSkillInstalled(skill.name, agent, { global: installGlobally });
+        const status = installed ? chalk.yellow(" (will overwrite)") : "";
+        p.log.message(`    ${chalk.dim("\u2192")} ${agents[agent].displayName}: ${chalk.dim(path)}${status}`);
+      }
+    }
+    console.log();
+    if (!options.yes) {
+      const confirmed = await p.confirm({ message: "Proceed with installation?" });
+      if (p.isCancel(confirmed) || !confirmed) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+    }
+    spinner2.start("Installing skills...");
+    const results = [];
+    for (const skill of selectedSkills) {
+      for (const agent of targetAgents) {
+        const result = await installSkillForAgent(skill, agent, { global: installGlobally });
+        results.push({
+          skill: getSkillDisplayName(skill),
+          agent: agents[agent].displayName,
+          ...result
+        });
+      }
+    }
+    spinner2.stop("Installation complete");
+    console.log();
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    track({
+      event: "install",
+      source,
+      skills: selectedSkills.map((s) => s.name).join(","),
+      agents: targetAgents.join(","),
+      ...installGlobally && { global: "1" }
+    });
+    if (successful.length > 0) {
+      p.log.success(chalk.green(`Successfully installed ${successful.length} skill${successful.length !== 1 ? "s" : ""}`));
+      for (const r of successful) {
+        p.log.message(`  ${chalk.green("\u2713")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.path)}`);
+      }
+    }
+    if (failed.length > 0) {
+      console.log();
+      p.log.error(chalk.red(`Failed to install ${failed.length} skill${failed.length !== 1 ? "s" : ""}`));
+      for (const r of failed) {
+        p.log.message(`  ${chalk.red("\u2717")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.error)}`);
+      }
+    }
+    console.log();
+    p.outro(chalk.green("Done!"));
+  } catch (error) {
+    p.log.error(error instanceof Error ? error.message : "Unknown error occurred");
+    p.outro(chalk.red("Installation failed"));
+    process.exit(1);
+  } finally {
+    await cleanup(tempDir);
+  }
+}
+async function cleanup(tempDir) {
+  if (tempDir) {
+    try {
+      await cleanupTempDir(tempDir);
+    } catch {
+    }
+  }
+}
+async function installFromManifest(manifestPath, options) {
+  console.log();
+  p.intro(chalk.bgCyan.black(" add-skill ") + chalk.dim(" (manifest mode)"));
+  const tempDirs = [];
+  try {
+    const spinner2 = p.spinner();
+    if (options.skill && options.skill.length > 0) {
+      p.log.error("Cannot use --skill with --from-file. Skills are specified in the manifest file.");
+      process.exit(1);
+    }
+    if (options.list) {
+      p.log.error("Cannot use --list with --from-file. Use without --from-file to list skills.");
+      process.exit(1);
+    }
+    spinner2.start("Parsing manifest file...");
+    let manifest;
+    try {
+      manifest = await parseManifestFile(manifestPath);
+    } catch (error) {
+      spinner2.stop(chalk.red("Failed to parse manifest"));
+      if (error instanceof ManifestParseError) {
+        p.log.error(error.message);
+      } else {
+        p.log.error(error.message);
+      }
+      process.exit(1);
+    }
+    spinner2.stop(`Found ${chalk.green(manifest.skills.length)} skill${manifest.skills.length !== 1 ? "s" : ""} in manifest`);
+    const skillsBySource = groupSkillsBySource(manifest.skills);
+    p.log.info(`From ${chalk.cyan(skillsBySource.size)} source${skillsBySource.size !== 1 ? "s" : ""}`);
+    const skillsToInstall = [];
+    const lockEntries = [];
+    for (const [sourceKey, entries] of skillsBySource) {
+      const firstEntry = entries[0];
+      const source = firstEntry.source;
+      const version2 = firstEntry.version;
+      spinner2.start(`Cloning ${chalk.cyan(source)}${version2 ? ` @ ${version2}` : ""}...`);
+      const parsed = parseSource(source);
+      const { tempDir, resolvedRef } = await cloneRepoAtVersion(parsed.url, version2);
+      tempDirs.push(tempDir);
+      spinner2.stop(`Cloned ${chalk.cyan(source)} (${chalk.dim(resolvedRef.slice(0, 7))})`);
+      spinner2.start("Discovering skills...");
+      const discoveredSkills = await discoverSkills(tempDir, parsed.subpath);
+      spinner2.stop(`Found ${discoveredSkills.length} skill${discoveredSkills.length !== 1 ? "s" : ""}`);
+      for (const entry of entries) {
+        const skill = discoveredSkills.find(
+          (s) => s.name.toLowerCase() === entry.name.toLowerCase()
+        );
+        if (!skill) {
+          throw new SkillNotFoundError(
+            entry.name,
+            entry.source,
+            discoveredSkills.map((s) => s.name)
+          );
+        }
+        if (entry.version) {
+          const validation = validateSkillVersion(skill, entry.version);
+          if (validation.message) {
+            p.log.warn(validation.message);
+          }
+        }
+        skillsToInstall.push({ skill, entry, resolvedRef });
+        lockEntries.push({
+          source: entry.source,
+          name: entry.name,
+          version: entry.version || skill.version?.version || "latest",
+          resolvedRef,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+    let targetAgents;
+    if (options.agent && options.agent.length > 0) {
+      const validAgents = ["opencode", "claude-code", "codex", "cursor", "antigravity"];
+      const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+      if (invalidAgents.length > 0) {
+        p.log.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+        p.log.info(`Valid agents: ${validAgents.join(", ")}`);
+        await cleanupAll(tempDirs);
+        process.exit(1);
+      }
+      targetAgents = options.agent;
+    } else {
+      spinner2.start("Detecting installed agents...");
+      const installedAgents = await detectInstalledAgents();
+      spinner2.stop(`Detected ${installedAgents.length} agent${installedAgents.length !== 1 ? "s" : ""}`);
+      if (installedAgents.length === 0) {
+        if (options.yes) {
+          targetAgents = ["opencode", "claude-code", "codex", "cursor", "antigravity"];
+          p.log.info("Installing to all agents (none detected)");
+        } else {
+          p.log.warn("No coding agents detected. You can still install skills.");
+          const allAgentChoices = Object.entries(agents).map(([key, config]) => ({
+            value: key,
+            label: config.displayName
+          }));
+          const selected = await p.multiselect({
+            message: "Select agents to install skills to",
+            options: allAgentChoices,
+            required: true
+          });
+          if (p.isCancel(selected)) {
+            p.cancel("Installation cancelled");
+            await cleanupAll(tempDirs);
+            process.exit(0);
+          }
+          targetAgents = selected;
+        }
+      } else if (installedAgents.length === 1 || options.yes) {
+        targetAgents = installedAgents;
+        p.log.info(`Installing to: ${targetAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ")}`);
+      } else {
+        const agentChoices = installedAgents.map((a) => ({
+          value: a,
+          label: agents[a].displayName,
+          hint: `${options.global ? agents[a].globalSkillsDir : agents[a].skillsDir}`
+        }));
+        const selected = await p.multiselect({
+          message: "Select agents to install skills to",
+          options: agentChoices,
+          required: true,
+          initialValues: installedAgents
+        });
+        if (p.isCancel(selected)) {
+          p.cancel("Installation cancelled");
+          await cleanupAll(tempDirs);
+          process.exit(0);
+        }
+        targetAgents = selected;
+      }
+    }
+    let installGlobally = options.global ?? false;
+    if (options.global === void 0 && !options.yes) {
+      const scope = await p.select({
+        message: "Installation scope",
+        options: [
+          { value: false, label: "Project", hint: "Install in current directory" },
+          { value: true, label: "Global", hint: "Install in home directory" }
+        ]
+      });
+      if (p.isCancel(scope)) {
+        p.cancel("Installation cancelled");
+        await cleanupAll(tempDirs);
+        process.exit(0);
+      }
+      installGlobally = scope;
+    }
+    console.log();
+    p.log.step(chalk.bold("Installation Summary"));
+    for (const { skill, entry } of skillsToInstall) {
+      const versionStr = entry.version ? ` @ ${entry.version}` : "";
+      p.log.message(`  ${chalk.cyan(getSkillDisplayName(skill))}${chalk.dim(versionStr)}`);
+      p.log.message(`    ${chalk.dim("from")} ${entry.source}`);
+      for (const agent of targetAgents) {
+        const path = getInstallPath(skill.name, agent, { global: installGlobally });
+        const installed = await isSkillInstalled(skill.name, agent, { global: installGlobally });
+        const status = installed ? chalk.yellow(" (will overwrite)") : "";
+        p.log.message(`    ${chalk.dim("\u2192")} ${agents[agent].displayName}: ${chalk.dim(path)}${status}`);
+      }
+    }
+    console.log();
+    if (!options.yes) {
+      const confirmed = await p.confirm({ message: "Proceed with installation?" });
+      if (p.isCancel(confirmed) || !confirmed) {
+        p.cancel("Installation cancelled");
+        await cleanupAll(tempDirs);
+        process.exit(0);
+      }
+    }
+    spinner2.start("Installing skills...");
+    const results = [];
+    for (const { skill } of skillsToInstall) {
+      for (const agent of targetAgents) {
+        const result = await installSkillForAgent(skill, agent, { global: installGlobally });
+        results.push({
+          skill: getSkillDisplayName(skill),
+          agent: agents[agent].displayName,
+          ...result
+        });
+      }
+    }
+    spinner2.stop("Installation complete");
+    if (options.lock !== false) {
+      const lockPath = getLockFilePath(manifestPath);
+      await writeLockFile(lockPath, lockEntries);
+      p.log.info(`Lock file written to ${chalk.dim(lockPath)}`);
+    }
+    console.log();
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    track({
+      event: "install",
+      source: `manifest:${manifest.skills.length}`,
+      skills: skillsToInstall.map((s) => s.skill.name).join(","),
+      agents: targetAgents.join(","),
+      ...installGlobally && { global: "1" }
+    });
+    if (successful.length > 0) {
+      p.log.success(chalk.green(`Successfully installed ${successful.length} skill${successful.length !== 1 ? "s" : ""}`));
+      for (const r of successful) {
+        p.log.message(`  ${chalk.green("\u2713")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.path)}`);
+      }
+    }
+    if (failed.length > 0) {
+      console.log();
+      p.log.error(chalk.red(`Failed to install ${failed.length} skill${failed.length !== 1 ? "s" : ""}`));
+      for (const r of failed) {
+        p.log.message(`  ${chalk.red("\u2717")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.error)}`);
+      }
+    }
+    console.log();
+    p.outro(chalk.green("Done!"));
+  } catch (error) {
+    if (error instanceof SkillNotFoundError) {
+      p.log.error(error.message);
+      if (error.availableSkills.length > 0) {
+        p.log.info("Available skills:");
+        for (const name of error.availableSkills) {
+          p.log.message(`  - ${name}`);
+        }
+      }
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error occurred");
+    }
+    p.outro(chalk.red("Installation failed"));
+    process.exit(1);
+  } finally {
+    await cleanupAll(tempDirs);
+  }
+}
+async function cleanupAll(tempDirs) {
+  for (const dir of tempDirs) {
+    await cleanup(dir);
+  }
+}