@iceinvein/agent-skills 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,819 @@
+#!/usr/bin/env bun
+// @bun
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/detect.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var TOOL_MARKERS = {
+  claude: (cwd) => existsSync(join(cwd, ".claude")),
+  cursor: (cwd) => existsSync(join(cwd, ".cursor")),
+  codex: (cwd) => existsSync(join(cwd, "AGENTS.md")),
+  gemini: (cwd) => existsSync(join(cwd, ".gemini"))
+};
+async function detectTools(cwd) {
+  const detected = [];
+  for (const [tool, check] of Object.entries(TOOL_MARKERS)) {
+    if (check(cwd)) {
+      detected.push(tool);
+    }
+  }
+  return detected;
+}
+
+// src/cli/types.ts
+var TOOL_NAMES = ["claude", "cursor", "codex", "gemini"];
+var SKILL_TYPES = ["prompt", "code", "hybrid"];
+function validateManifest(data) {
+  if (typeof data !== "object" || data === null) {
+    return { ok: false, error: "Manifest must be an object" };
+  }
+  const d = data;
+  if (typeof d.name !== "string" || d.name.length === 0) {
+    return { ok: false, error: "Missing or invalid 'name'" };
+  }
+  if (typeof d.version !== "string") {
+    return { ok: false, error: "Missing or invalid 'version'" };
+  }
+  if (typeof d.description !== "string") {
+    return { ok: false, error: "Missing or invalid 'description'" };
+  }
+  if (typeof d.author !== "string") {
+    return { ok: false, error: "Missing or invalid 'author'" };
+  }
+  if (!SKILL_TYPES.includes(d.type)) {
+    return { ok: false, error: `Invalid 'type': must be one of ${SKILL_TYPES.join(", ")}` };
+  }
+  if (!Array.isArray(d.tools) || d.tools.length === 0) {
+    return { ok: false, error: "Missing or empty 'tools' array" };
+  }
+  for (const tool of d.tools) {
+    if (!TOOL_NAMES.includes(tool)) {
+      return { ok: false, error: `Invalid tool '${tool}': must be one of ${TOOL_NAMES.join(", ")}` };
+    }
+  }
+  if (typeof d.install !== "object" || d.install === null) {
+    return { ok: false, error: "Missing 'install' configuration" };
+  }
+  return { ok: true, manifest: d };
+}
+
+// src/cli/github.ts
+var REPO = "iceinvein/agent-skills";
+var BRANCH = "main";
+var BASE = `https://raw.githubusercontent.com/${REPO}/${BRANCH}`;
+function buildRawUrl(skillName, filePath) {
+  return `${BASE}/skills/${skillName}/${filePath}`;
+}
+async function fetchSkillManifest(skillName) {
+  const url = buildRawUrl(skillName, "skill.json");
+  const res = await fetch(url);
+  if (res.status === 404) {
+    return { ok: false, error: `Skill '${skillName}' not found` };
+  }
+  if (!res.ok) {
+    return { ok: false, error: `Failed to fetch manifest: HTTP ${res.status}` };
+  }
+  const data = await res.json();
+  return validateManifest(data);
+}
+async function fetchSkillFile(skillName, filePath) {
+  const url = buildRawUrl(skillName, filePath);
+  const res = await fetch(url);
+  if (!res.ok) {
+    return { ok: false, error: `Failed to fetch '${filePath}': HTTP ${res.status}` };
+  }
+  const content = await res.text();
+  return { ok: true, content };
+}
+async function fetchAllSkillFiles(skillName, manifest) {
+  const files = new Map;
+  if (manifest.files?.prompt) {
+    const result = await fetchSkillFile(skillName, manifest.files.prompt);
+    if (!result.ok)
+      return { error: result.error };
+    files.set(manifest.files.prompt, result.content);
+  }
+  if (manifest.files?.supporting) {
+    for (const supportFile of manifest.files.supporting) {
+      const result = await fetchSkillFile(skillName, supportFile);
+      if (!result.ok)
+        return { error: result.error };
+      files.set(supportFile, result.content);
+    }
+  }
+  return files;
+}
+
+// src/cli/adapters/claude.ts
+import { existsSync as existsSync2, mkdirSync, rmSync, unlinkSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+var claudeAdapter = {
+  name: "claude",
+  async install(cwd, manifest, files) {
+    const installed = [];
+    const config = manifest.install.claude;
+    if (!config)
+      return installed;
+    if (config.prompt && files.has(manifest.files?.prompt ?? "")) {
+      const targetPath = join2(cwd, config.prompt);
+      mkdirSync(dirname(targetPath), { recursive: true });
+      await Bun.write(targetPath, files.get(manifest.files.prompt));
+      installed.push(config.prompt);
+    }
+    if (config.supporting) {
+      for (const [sourceFile, targetRel] of Object.entries(config.supporting)) {
+        if (files.has(sourceFile)) {
+          const targetPath = join2(cwd, targetRel);
+          mkdirSync(dirname(targetPath), { recursive: true });
+          await Bun.write(targetPath, files.get(sourceFile));
+          installed.push(targetRel);
+        }
+      }
+    }
+    if (config.mcpServers) {
+      const settingsPath = join2(cwd, ".claude/settings.json");
+      let settings = {};
+      if (existsSync2(settingsPath)) {
+        settings = await Bun.file(settingsPath).json();
+      }
+      if (!settings.mcpServers)
+        settings.mcpServers = {};
+      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        settings.mcpServers[name] = serverConfig;
+      }
+      await Bun.write(settingsPath, JSON.stringify(settings, null, 2) + `
+`);
+      installed.push(".claude/settings.json");
+    }
+    return installed;
+  },
+  async remove(cwd, manifest, installedFiles) {
+    const config = manifest.install.claude;
+    if (!config)
+      return;
+    for (const file of installedFiles) {
+      if (file === ".claude/settings.json")
+        continue;
+      const fullPath = join2(cwd, file);
+      if (existsSync2(fullPath)) {
+        unlinkSync(fullPath);
+        const dir = dirname(fullPath);
+        try {
+          rmSync(dir, { recursive: false });
+        } catch {}
+      }
+    }
+    if (config.mcpServers) {
+      const settingsPath = join2(cwd, ".claude/settings.json");
+      if (existsSync2(settingsPath)) {
+        const settings = await Bun.file(settingsPath).json();
+        if (settings.mcpServers) {
+          for (const name of Object.keys(config.mcpServers)) {
+            delete settings.mcpServers[name];
+          }
+          await Bun.write(settingsPath, JSON.stringify(settings, null, 2) + `
+`);
+        }
+      }
+    }
+  }
+};
+
+// src/cli/adapters/cursor.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2, rmSync as rmSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+var cursorAdapter = {
+  name: "cursor",
+  async install(cwd, manifest, files) {
+    const installed = [];
+    const config = manifest.install.cursor;
+    if (!config)
+      return installed;
+    if (config.prompt && files.has(manifest.files?.prompt ?? "")) {
+      const targetPath = join3(cwd, config.prompt);
+      mkdirSync2(dirname2(targetPath), { recursive: true });
+      await Bun.write(targetPath, files.get(manifest.files.prompt));
+      installed.push(config.prompt);
+    }
+    if (config.supporting) {
+      for (const [sourceFile, targetRel] of Object.entries(config.supporting)) {
+        if (files.has(sourceFile)) {
+          const targetPath = join3(cwd, targetRel);
+          mkdirSync2(dirname2(targetPath), { recursive: true });
+          await Bun.write(targetPath, files.get(sourceFile));
+          installed.push(targetRel);
+        }
+      }
+    }
+    if (config.mcpServers) {
+      const mcpPath = join3(cwd, ".cursor/mcp.json");
+      let mcpConfig = {};
+      if (existsSync3(mcpPath)) {
+        mcpConfig = await Bun.file(mcpPath).json();
+      }
+      if (!mcpConfig.mcpServers)
+        mcpConfig.mcpServers = {};
+      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        mcpConfig.mcpServers[name] = serverConfig;
+      }
+      await Bun.write(mcpPath, JSON.stringify(mcpConfig, null, 2) + `
+`);
+      installed.push(".cursor/mcp.json");
+    }
+    return installed;
+  },
+  async remove(cwd, manifest, installedFiles) {
+    const config = manifest.install.cursor;
+    if (!config)
+      return;
+    for (const file of installedFiles) {
+      if (file === ".cursor/mcp.json")
+        continue;
+      const fullPath = join3(cwd, file);
+      if (existsSync3(fullPath)) {
+        unlinkSync2(fullPath);
+        try {
+          rmSync2(dirname2(fullPath), { recursive: false });
+        } catch {}
+      }
+    }
+    if (config.mcpServers) {
+      const mcpPath = join3(cwd, ".cursor/mcp.json");
+      if (existsSync3(mcpPath)) {
+        const mcpConfig = await Bun.file(mcpPath).json();
+        if (mcpConfig.mcpServers) {
+          for (const name of Object.keys(config.mcpServers)) {
+            delete mcpConfig.mcpServers[name];
+          }
+          await Bun.write(mcpPath, JSON.stringify(mcpConfig, null, 2) + `
+`);
+        }
+      }
+    }
+  }
+};
+
+// src/cli/adapters/codex.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+var codexAdapter = {
+  name: "codex",
+  async install(cwd, manifest, files) {
+    const installed = [];
+    const config = manifest.install.codex;
+    if (!config)
+      return installed;
+    if (config.mcpServers) {
+      console.warn(`⚠ Codex does not support MCP servers — skipping MCP install for '${manifest.name}'`);
+      return installed;
+    }
+    if (config.append && config.prompt && files.has(manifest.files?.prompt ?? "")) {
+      const agentsPath = join4(cwd, config.prompt);
+      let existing = "";
+      if (existsSync4(agentsPath)) {
+        existing = await Bun.file(agentsPath).text();
+      }
+      const content = files.get(manifest.files.prompt);
+      const section = [
+        `
+<!-- agent-skills:start:${manifest.name} -->`,
+        content,
+        `<!-- agent-skills:end:${manifest.name} -->
+`
+      ].join(`
+`);
+      await Bun.write(agentsPath, existing + section);
+      installed.push("AGENTS.md");
+    }
+    return installed;
+  },
+  async remove(cwd, manifest, _installedFiles) {
+    const config = manifest.install.codex;
+    if (!config)
+      return;
+    if (config.append && config.prompt) {
+      const agentsPath = join4(cwd, config.prompt);
+      if (existsSync4(agentsPath)) {
+        const content = await Bun.file(agentsPath).text();
+        const startMarker = `<!-- agent-skills:start:${manifest.name} -->`;
+        const endMarker = `<!-- agent-skills:end:${manifest.name} -->`;
+        const startIdx = content.indexOf(startMarker);
+        const endIdx = content.indexOf(endMarker);
+        if (startIdx !== -1 && endIdx !== -1) {
+          const before = content.slice(0, startIdx).replace(/\n$/, "");
+          const after = content.slice(endIdx + endMarker.length).replace(/^\n/, "");
+          await Bun.write(agentsPath, before + after);
+        }
+      }
+    }
+  }
+};
+
+// src/cli/adapters/gemini.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3, rmSync as rmSync3 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+var geminiAdapter = {
+  name: "gemini",
+  async install(cwd, manifest, files) {
+    const installed = [];
+    const config = manifest.install.gemini;
+    if (!config)
+      return installed;
+    if (config.prompt && files.has(manifest.files?.prompt ?? "")) {
+      const targetPath = join5(cwd, config.prompt);
+      mkdirSync3(dirname3(targetPath), { recursive: true });
+      await Bun.write(targetPath, files.get(manifest.files.prompt));
+      installed.push(config.prompt);
+    }
+    if (config.supporting) {
+      for (const [sourceFile, targetRel] of Object.entries(config.supporting)) {
+        if (files.has(sourceFile)) {
+          const targetPath = join5(cwd, targetRel);
+          mkdirSync3(dirname3(targetPath), { recursive: true });
+          await Bun.write(targetPath, files.get(sourceFile));
+          installed.push(targetRel);
+        }
+      }
+    }
+    if (config.mcpServers) {
+      const settingsPath = join5(cwd, ".gemini/settings.json");
+      let settings = {};
+      if (existsSync5(settingsPath)) {
+        settings = await Bun.file(settingsPath).json();
+      }
+      if (!settings.mcpServers)
+        settings.mcpServers = {};
+      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        settings.mcpServers[name] = serverConfig;
+      }
+      await Bun.write(settingsPath, JSON.stringify(settings, null, 2) + `
+`);
+      installed.push(".gemini/settings.json");
+    }
+    return installed;
+  },
+  async remove(cwd, manifest, installedFiles) {
+    const config = manifest.install.gemini;
+    if (!config)
+      return;
+    for (const file of installedFiles) {
+      if (file === ".gemini/settings.json")
+        continue;
+      const fullPath = join5(cwd, file);
+      if (existsSync5(fullPath)) {
+        unlinkSync3(fullPath);
+        try {
+          rmSync3(dirname3(fullPath), { recursive: false });
+        } catch {}
+      }
+    }
+    if (config.mcpServers) {
+      const settingsPath = join5(cwd, ".gemini/settings.json");
+      if (existsSync5(settingsPath)) {
+        const settings = await Bun.file(settingsPath).json();
+        if (settings.mcpServers) {
+          for (const name of Object.keys(config.mcpServers)) {
+            delete settings.mcpServers[name];
+          }
+          await Bun.write(settingsPath, JSON.stringify(settings, null, 2) + `
+`);
+        }
+      }
+    }
+  }
+};
+
+// src/cli/adapters/index.ts
+var adapters = {
+  claude: claudeAdapter,
+  cursor: cursorAdapter,
+  codex: codexAdapter,
+  gemini: geminiAdapter
+};
+function getAdapter(tool) {
+  return adapters[tool];
+}
+
+// src/cli/lockfile.ts
+import { join as join6 } from "node:path";
+var LOCKFILE_NAME = ".agent-skills.lock";
+async function readLockfile(cwd) {
+  const path = join6(cwd, LOCKFILE_NAME);
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return { skills: {} };
+  }
+  return file.json();
+}
+async function writeLockfile(cwd, lockfile) {
+  const path = join6(cwd, LOCKFILE_NAME);
+  await Bun.write(path, JSON.stringify(lockfile, null, 2) + `
+`);
+}
+async function addSkillToLockfile(cwd, skillName, entry) {
+  const lockfile = await readLockfile(cwd);
+  lockfile.skills[skillName] = entry;
+  await writeLockfile(cwd, lockfile);
+}
+async function removeSkillFromLockfile(cwd, skillName) {
+  const lockfile = await readLockfile(cwd);
+  delete lockfile.skills[skillName];
+  await writeLockfile(cwd, lockfile);
+}
+
+// src/cli/commands/install.ts
+async function installSkill(cwd, manifest, files, targetTools) {
+  const compatibleTools = targetTools.filter((t) => manifest.tools.includes(t));
+  const skipped = targetTools.filter((t) => !manifest.tools.includes(t));
+  if (compatibleTools.length === 0) {
+    return {
+      ok: false,
+      error: `Skill '${manifest.name}' does not support any of: ${targetTools.join(", ")}. Supported: ${manifest.tools.join(", ")}`
+    };
+  }
+  const installed = {};
+  const allFiles = [];
+  for (const tool of compatibleTools) {
+    const adapter = getAdapter(tool);
+    const toolFiles = await adapter.install(cwd, manifest, files);
+    installed[tool] = toolFiles;
+    allFiles.push(...toolFiles);
+  }
+  await addSkillToLockfile(cwd, manifest.name, {
+    version: manifest.version,
+    tools: compatibleTools,
+    installedAt: new Date().toISOString(),
+    files: allFiles
+  });
+  return { ok: true, installed, skipped };
+}
+
+// src/cli/github.ts
+var REPO2 = "iceinvein/agent-skills";
+var BRANCH2 = "main";
+var BASE2 = `https://raw.githubusercontent.com/${REPO2}/${BRANCH2}`;
+function buildRawUrl2(skillName, filePath) {
+  return `${BASE2}/skills/${skillName}/${filePath}`;
+}
+async function fetchSkillManifest2(skillName) {
+  const url = buildRawUrl2(skillName, "skill.json");
+  const res = await fetch(url);
+  if (res.status === 404) {
+    return { ok: false, error: `Skill '${skillName}' not found` };
+  }
+  if (!res.ok) {
+    return { ok: false, error: `Failed to fetch manifest: HTTP ${res.status}` };
+  }
+  const data = await res.json();
+  return validateManifest(data);
+}
+async function fetchSkillFile2(skillName, filePath) {
+  const url = buildRawUrl2(skillName, filePath);
+  const res = await fetch(url);
+  if (!res.ok) {
+    return { ok: false, error: `Failed to fetch '${filePath}': HTTP ${res.status}` };
+  }
+  const content = await res.text();
+  return { ok: true, content };
+}
+async function fetchAllSkillFiles2(skillName, manifest) {
+  const files = new Map;
+  if (manifest.files?.prompt) {
+    const result = await fetchSkillFile2(skillName, manifest.files.prompt);
+    if (!result.ok)
+      return { error: result.error };
+    files.set(manifest.files.prompt, result.content);
+  }
+  if (manifest.files?.supporting) {
+    for (const supportFile of manifest.files.supporting) {
+      const result = await fetchSkillFile2(skillName, supportFile);
+      if (!result.ok)
+        return { error: result.error };
+      files.set(supportFile, result.content);
+    }
+  }
+  return files;
+}
+
+// src/cli/commands/remove.ts
+async function removeSkill(cwd, skillName) {
+  const lockfile = await readLockfile(cwd);
+  const entry = lockfile.skills[skillName];
+  if (!entry) {
+    return { ok: false, error: `Skill '${skillName}' is not installed` };
+  }
+  const manifestResult = await fetchSkillManifest2(skillName);
+  if (manifestResult.ok) {
+    for (const tool of entry.tools) {
+      const adapter = getAdapter(tool);
+      const toolFiles = entry.files.filter((f) => {
+        const config = manifestResult.manifest.install[tool];
+        if (!config)
+          return false;
+        if (config.prompt && f === config.prompt)
+          return true;
+        if (config.supporting && Object.values(config.supporting).includes(f))
+          return true;
+        if (config.mcpServers && (f.includes(".claude/settings") || f.includes(".cursor/mcp") || f.includes(".gemini/settings")))
+          return true;
+        return false;
+      });
+      await adapter.remove(cwd, manifestResult.manifest, toolFiles);
+    }
+  } else {
+    const { unlinkSync: unlinkSync4, existsSync: existsSync6 } = await import("node:fs");
+    const { join: join7 } = await import("node:path");
+    for (const file of entry.files) {
+      const fullPath = join7(cwd, file);
+      if (existsSync6(fullPath)) {
+        unlinkSync4(fullPath);
+      }
+    }
+  }
+  await removeSkillFromLockfile(cwd, skillName);
+  return { ok: true, removed: entry.files };
+}
+
+// src/cli/commands/list.ts
+var REPO3 = "iceinvein/agent-skills";
+var BRANCH3 = "main";
+var INDEX_URL = `https://raw.githubusercontent.com/${REPO3}/${BRANCH3}/skills/index.json`;
+async function listSkills() {
+  const res = await fetch(INDEX_URL);
+  if (!res.ok) {
+    return { ok: false, error: `Failed to fetch skill index: HTTP ${res.status}` };
+  }
+  const skills = await res.json();
+  return { ok: true, skills };
+}
+
+// src/cli/commands/info.ts
+async function infoSkill(skillName) {
+  return fetchSkillManifest2(skillName);
+}
+
+// src/cli/commands/remove.ts
+async function removeSkill2(cwd, skillName) {
+  const lockfile = await readLockfile(cwd);
+  const entry = lockfile.skills[skillName];
+  if (!entry) {
+    return { ok: false, error: `Skill '${skillName}' is not installed` };
+  }
+  const manifestResult = await fetchSkillManifest2(skillName);
+  if (manifestResult.ok) {
+    for (const tool of entry.tools) {
+      const adapter = getAdapter(tool);
+      const toolFiles = entry.files.filter((f) => {
+        const config = manifestResult.manifest.install[tool];
+        if (!config)
+          return false;
+        if (config.prompt && f === config.prompt)
+          return true;
+        if (config.supporting && Object.values(config.supporting).includes(f))
+          return true;
+        if (config.mcpServers && (f.includes(".claude/settings") || f.includes(".cursor/mcp") || f.includes(".gemini/settings")))
+          return true;
+        return false;
+      });
+      await adapter.remove(cwd, manifestResult.manifest, toolFiles);
+    }
+  } else {
+    const { unlinkSync: unlinkSync4, existsSync: existsSync6 } = await import("node:fs");
+    const { join: join7 } = await import("node:path");
+    for (const file of entry.files) {
+      const fullPath = join7(cwd, file);
+      if (existsSync6(fullPath)) {
+        unlinkSync4(fullPath);
+      }
+    }
+  }
+  await removeSkillFromLockfile(cwd, skillName);
+  return { ok: true, removed: entry.files };
+}
+
+// src/cli/commands/install.ts
+async function installSkill2(cwd, manifest, files, targetTools) {
+  const compatibleTools = targetTools.filter((t) => manifest.tools.includes(t));
+  const skipped = targetTools.filter((t) => !manifest.tools.includes(t));
+  if (compatibleTools.length === 0) {
+    return {
+      ok: false,
+      error: `Skill '${manifest.name}' does not support any of: ${targetTools.join(", ")}. Supported: ${manifest.tools.join(", ")}`
+    };
+  }
+  const installed = {};
+  const allFiles = [];
+  for (const tool of compatibleTools) {
+    const adapter = getAdapter(tool);
+    const toolFiles = await adapter.install(cwd, manifest, files);
+    installed[tool] = toolFiles;
+    allFiles.push(...toolFiles);
+  }
+  await addSkillToLockfile(cwd, manifest.name, {
+    version: manifest.version,
+    tools: compatibleTools,
+    installedAt: new Date().toISOString(),
+    files: allFiles
+  });
+  return { ok: true, installed, skipped };
+}
+
+// src/cli/commands/update.ts
+async function updateSkill(cwd, skillName) {
+  const lockfile = await readLockfile(cwd);
+  const entry = lockfile.skills[skillName];
+  if (!entry) {
+    return { ok: false, error: `Skill '${skillName}' is not installed` };
+  }
+  const oldVersion = entry.version;
+  const tools = entry.tools;
+  const manifestResult = await fetchSkillManifest2(skillName);
+  if (!manifestResult.ok) {
+    return { ok: false, error: manifestResult.error };
+  }
+  const filesResult = await fetchAllSkillFiles2(skillName, manifestResult.manifest);
+  if ("error" in filesResult) {
+    return { ok: false, error: filesResult.error };
+  }
+  await removeSkill2(cwd, skillName);
+  const installResult = await installSkill2(cwd, manifestResult.manifest, filesResult, tools);
+  if (!installResult.ok) {
+    return { ok: false, error: installResult.error };
+  }
+  return { ok: true, from: oldVersion, to: manifestResult.manifest.version };
+}
+
+// src/cli/types.ts
+var TOOL_NAMES2 = ["claude", "cursor", "codex", "gemini"];
+
+// src/cli/index.ts
+function parseArgs(argv) {
+  if (argv.length === 0)
+    return { command: "help", args: [], flags: {} };
+  const command = argv[0];
+  const args = [];
+  const flags = {};
+  for (let i = 1;i < argv.length; i++) {
+    if (argv[i].startsWith("--") && i + 1 < argv.length) {
+      flags[argv[i].slice(2)] = argv[i + 1];
+      i++;
+    } else {
+      args.push(argv[i]);
+    }
+  }
+  return { command, args, flags };
+}
+function printHelp() {
+  console.log(`
+@iceinvein/agent-skills \u2014 Install agent skills into AI coding tools
+
+Usage:
+  agent-skills install <skill>  [--tool <tool>]   Install a skill
+  agent-skills remove  <skill>                     Remove a skill
+  agent-skills update  <skill>                     Update a skill
+  agent-skills list                                List available skills
+  agent-skills info    <skill>                     Show skill details
+
+Tools: ${TOOL_NAMES2.join(", ")}
+
+If --tool is omitted, auto-detects tools in the current directory.
+`);
+}
+function printInstalled(result, skipped) {
+  for (const [tool, files] of Object.entries(result)) {
+    console.log(`  \u2713 ${tool}`);
+    for (const file of files) {
+      console.log(`    \u2192 ${file}`);
+    }
+  }
+  for (const tool of skipped) {
+    console.log(`  \u2298 ${tool} (skill does not support this tool)`);
+  }
+}
+async function main() {
+  const { command, args, flags } = parseArgs(process.argv.slice(2));
+  switch (command) {
+    case "install": {
+      const skillName = args[0];
+      if (!skillName) {
+        console.error("Error: skill name required. Usage: agent-skills install <skill>");
+        process.exit(1);
+      }
+      console.log(`Fetching skill '${skillName}'...`);
+      const manifestResult = await fetchSkillManifest(skillName);
+      if (!manifestResult.ok) {
+        console.error(`Error: ${manifestResult.error}`);
+        process.exit(1);
+      }
+      const filesResult = await fetchAllSkillFiles(skillName, manifestResult.manifest);
+      if ("error" in filesResult) {
+        console.error(`Error: ${filesResult.error}`);
+        process.exit(1);
+      }
+      let tools;
+      if (flags.tool) {
+        if (!TOOL_NAMES2.includes(flags.tool)) {
+          console.error(`Error: unknown tool '${flags.tool}'. Must be one of: ${TOOL_NAMES2.join(", ")}`);
+          process.exit(1);
+        }
+        tools = [flags.tool];
+      } else {
+        tools = await detectTools(process.cwd());
+        if (tools.length === 0) {
+          console.error("Error: no supported tools detected. Use --tool to specify one.");
+          process.exit(1);
+        }
+        console.log(`Detected tools: ${tools.join(", ")}`);
+      }
+      const result = await installSkill(process.cwd(), manifestResult.manifest, filesResult, tools);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(`
+\u2713 Installed '${skillName}' v${manifestResult.manifest.version}:`);
+      printInstalled(result.installed, result.skipped);
+      break;
+    }
+    case "remove": {
+      const skillName = args[0];
+      if (!skillName) {
+        console.error("Error: skill name required. Usage: agent-skills remove <skill>");
+        process.exit(1);
+      }
+      const result = await removeSkill(process.cwd(), skillName);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(`\u2713 Removed '${skillName}'`);
+      break;
+    }
+    case "update": {
+      const skillName = args[0];
+      if (!skillName) {
+        console.error("Error: skill name required. Usage: agent-skills update <skill>");
+        process.exit(1);
+      }
+      console.log(`Updating '${skillName}'...`);
+      const result = await updateSkill(process.cwd(), skillName);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(`\u2713 Updated '${skillName}' from v${result.from} to v${result.to}`);
+      break;
+    }
+    case "list": {
+      console.log(`Fetching available skills...
+`);
+      const result = await listSkills();
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      for (const skill of result.skills) {
+        const typeTag = skill.type === "prompt" ? "\uD83D\uDCDD" : skill.type === "code" ? "\u2699\uFE0F" : "\uD83D\uDD00";
+        console.log(`  ${typeTag} ${skill.name} (v${skill.version})`);
+        console.log(`    ${skill.description}
+`);
+      }
+      break;
+    }
+    case "info": {
+      const skillName = args[0];
+      if (!skillName) {
+        console.error("Error: skill name required. Usage: agent-skills info <skill>");
+        process.exit(1);
+      }
+      const result = await infoSkill(skillName);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      const m = result.manifest;
+      console.log(`
+${m.name} v${m.version}`);
+      console.log(`  ${m.description}`);
+      console.log(`  Author: ${m.author}`);
+      console.log(`  Type:   ${m.type}`);
+      console.log(`  Tools:  ${m.tools.join(", ")}`);
+      if (m.mcp)
+        console.log(`  Package: ${m.mcp.package}`);
+      break;
+    }
+    case "help":
+    default:
+      printHelp();
+      break;
+  }
+}
+main().catch((err) => {
+  console.error("Fatal:", err.message);
+  process.exit(1);
+});
+export {
+  parseArgs
+};