agent-toolbox 0.2.0

package/dist/cli/main.js

@@ -0,0 +1,2700 @@
+#!/usr/bin/env node
+
+// src/cli/main.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve3 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/cli/build-target.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+
+// src/catalog/scanner.ts
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/catalog/frontmatter.ts
+import { parse as parseYaml } from "yaml";
+var FRONTMATTER_REGEX = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+function parseFrontmatter(content) {
+  const normalized = content.startsWith("\uFEFF") ? content.slice(1) : content;
+  const match = FRONTMATTER_REGEX.exec(normalized);
+  if (!match) {
+    throw new Error("Missing YAML frontmatter. Expected content to start with '---'.");
+  }
+  const [, yamlBlock] = match;
+  const body = normalized.slice(match[0].length);
+  let parsed;
+  try {
+    parsed = parseYaml(yamlBlock);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Malformed YAML frontmatter: ${reason}`, { cause: error });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Malformed YAML frontmatter: expected a key-value object.");
+  }
+  return {
+    frontmatter: parsed,
+    body
+  };
+}
+
+// src/schemas/catalog.ts
+import { z as z2 } from "zod";
+
+// src/schemas/common.ts
+import { z } from "zod";
+var SkillName = z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).max(64);
+var HoloceneDate = z.string().regex(/^1\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/);
+var Provenance = z.enum([
+  "ported",
+  "adapted",
+  "synthesized",
+  "original"
+]);
+var CommaSeparatedList = z.string().transform((s) => s.split(",").map((t) => t.trim()).filter(Boolean));
+var AuthorField = z.string().min(1);
+var LicenseField = z.string().default("Sustainable Use License 1.0");
+var TargetTool = z.enum([
+  "claude-code",
+  "opencode",
+  "cursor",
+  "codex",
+  "gemini"
+]);
+
+// src/schemas/catalog.ts
+var SkillMetadata = z2.object({
+  domain: z2.string(),
+  subdomain: z2.string().optional(),
+  tags: CommaSeparatedList.optional(),
+  frameworks: CommaSeparatedList.optional(),
+  author: AuthorField,
+  lastUpdated: HoloceneDate,
+  provenance: Provenance
+});
+var SkillFrontmatter = z2.object({
+  name: SkillName,
+  description: z2.string().max(1024),
+  license: LicenseField,
+  metadata: SkillMetadata
+});
+var ParsedSkill = z2.object({
+  frontmatter: SkillFrontmatter,
+  body: z2.string(),
+  dirName: z2.string(),
+  filePath: z2.string(),
+  hasNotice: z2.boolean(),
+  hasReferences: z2.boolean(),
+  hasScripts: z2.boolean(),
+  hasAssets: z2.boolean(),
+  additionalEntries: z2.array(z2.string()).default([])
+});
+var AgentMetadata = z2.object({
+  domain: z2.string(),
+  subdomain: z2.string().optional(),
+  tags: CommaSeparatedList.optional(),
+  author: AuthorField,
+  lastUpdated: HoloceneDate,
+  provenance: Provenance
+});
+var AgentFrontmatter = z2.object({
+  name: SkillName,
+  description: z2.string().max(1024),
+  license: LicenseField,
+  metadata: AgentMetadata
+});
+var CommandMetadata = z2.object({
+  domain: z2.string(),
+  subdomain: z2.string().optional(),
+  tags: CommaSeparatedList.optional(),
+  author: AuthorField,
+  lastUpdated: HoloceneDate,
+  provenance: Provenance
+});
+var CommandFrontmatter = z2.object({
+  name: SkillName,
+  description: z2.string().max(1024),
+  license: LicenseField,
+  trigger: z2.string().regex(/^\/[a-z0-9-]+$/),
+  metadata: CommandMetadata
+});
+var HookEvent = z2.enum([
+  "SessionStart",
+  "SessionEnd",
+  "BeforeTool",
+  "AfterTool",
+  "BeforeModel",
+  "AfterModel",
+  "Notification",
+  "Stop",
+  "SubagentStart",
+  "SubagentEnd",
+  "PreToolExecution"
+]);
+var HookMetadata = z2.object({
+  domain: z2.string(),
+  subdomain: z2.string().optional(),
+  tags: CommaSeparatedList.optional(),
+  author: AuthorField,
+  lastUpdated: HoloceneDate,
+  provenance: Provenance
+});
+var HookFrontmatter = z2.object({
+  name: SkillName,
+  description: z2.string().max(1024),
+  license: LicenseField,
+  events: z2.array(HookEvent),
+  type: z2.enum(["command", "script", "module"]),
+  metadata: HookMetadata
+});
+var McpTransport = z2.enum(["stdio", "sse", "streamable-http"]);
+var McpMetadata = z2.object({
+  domain: z2.string(),
+  subdomain: z2.string().optional(),
+  tags: CommaSeparatedList.optional(),
+  author: AuthorField,
+  lastUpdated: HoloceneDate,
+  provenance: Provenance
+});
+var McpServerFrontmatter = z2.object({
+  name: SkillName,
+  description: z2.string().max(1024),
+  license: LicenseField,
+  transport: McpTransport,
+  command: z2.string(),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string(), z2.string()).optional(),
+  metadata: McpMetadata
+});
+var CatalogItemType = z2.enum([
+  "skill",
+  "agent",
+  "command",
+  "hook",
+  "mcp"
+]);
+var SkillIndexEntry = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  domain: z2.string(),
+  subdomain: z2.string().optional(),
+  provenance: Provenance,
+  author: z2.string(),
+  lastUpdated: z2.string(),
+  license: z2.string()
+});
+var SkillIndex = z2.object({
+  version: z2.literal(2),
+  generatedAt: z2.string(),
+  skills: z2.array(SkillIndexEntry),
+  tags: z2.record(z2.string(), z2.array(z2.string())).default({}),
+  frameworks: z2.record(z2.string(), z2.array(z2.string())).default({})
+});
+
+// src/catalog/scanner.ts
+async function scanSkills(catalogDir) {
+  const skills = [];
+  const errors = [];
+  const skillsRoot = join(catalogDir, "skills");
+  let skillDirs;
+  try {
+    const entries = await readdir(skillsRoot, { withFileTypes: true });
+    skillDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return {
+      skills,
+      errors: [
+        {
+          path: skillsRoot,
+          error: `Failed to scan skills directory: ${reason}`
+        }
+      ]
+    };
+  }
+  for (const dirName of skillDirs) {
+    const skillDir = join(skillsRoot, dirName);
+    const skillPath = join(skillDir, "SKILL.md");
+    try {
+      const skillContent = await readFile(skillPath, "utf8");
+      const { frontmatter, body } = parseFrontmatter(skillContent);
+      const parsedFrontmatter = SkillFrontmatter.safeParse(frontmatter);
+      if (!parsedFrontmatter.success) {
+        for (const issue of parsedFrontmatter.error.issues) {
+          const field = issue.path.length > 0 ? issue.path.join(".") : "frontmatter";
+          errors.push({
+            path: skillPath,
+            error: `Frontmatter validation failed at '${field}': ${issue.message}`
+          });
+        }
+        continue;
+      }
+      const entryNames = await readdir(skillDir);
+      const entrySet = new Set(entryNames);
+      const hasNotice = entrySet.has("NOTICE.md");
+      const hasReferences = entrySet.has("references");
+      const hasScripts = entrySet.has("scripts");
+      const hasAssets = entrySet.has("assets");
+      const additionalEntries = entryNames.filter((name) => ![
+        "SKILL.md",
+        "NOTICE.md",
+        "references",
+        "scripts",
+        "assets"
+      ].includes(name)).sort((a, b) => a.localeCompare(b));
+      const parsedSkill = {
+        frontmatter: parsedFrontmatter.data,
+        body,
+        dirName,
+        filePath: skillPath,
+        hasNotice,
+        hasReferences,
+        hasScripts,
+        hasAssets,
+        additionalEntries
+      };
+      skills.push(parsedSkill);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      errors.push({
+        path: skillPath,
+        error: reason
+      });
+    }
+  }
+  return { skills, errors };
+}
+
+// src/generators/claude-code/generator.ts
+import { mkdir as mkdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// src/generators/copy-utils.ts
+import { mkdir, readFile as readFile2, readdir as readdir2, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+async function copyDirectoryRecursive(src, dest) {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir2(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join2(src, entry.name);
+    const destPath = join2(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      const content = await readFile2(srcPath);
+      await writeFile(destPath, content);
+    }
+  }
+}
+
+// src/generators/claude-code/generator.ts
+class ClaudeCodeGenerator {
+  target = "claude-code";
+  async generate(options) {
+    const { skills, outputDir, catalogDir, version } = options;
+    const artifacts = [];
+    const warnings = [];
+    await rm(outputDir, { recursive: true, force: true });
+    await mkdir2(outputDir, { recursive: true });
+    const pluginDir = join3(outputDir, ".claude-plugin");
+    await mkdir2(pluginDir, { recursive: true });
+    const pluginManifest = {
+      name: "agent-toolbox",
+      version,
+      description: "Cross-tool distribution system for agent skills, plugins, and MCP servers"
+    };
+    await writeFile2(join3(pluginDir, "plugin.json"), JSON.stringify(pluginManifest, null, 2) + `
+`, "utf8");
+    artifacts.push(".claude-plugin/plugin.json");
+    const skillsDir = join3(outputDir, "skills");
+    await mkdir2(skillsDir, { recursive: true });
+    for (const skill of skills) {
+      const srcDir = join3(catalogDir, "skills", skill.dirName);
+      const destDir = join3(skillsDir, skill.dirName);
+      await copyDirectoryRecursive(srcDir, destDir);
+      artifacts.push(`skills/${skill.dirName}/`);
+    }
+    await mkdir2(join3(outputDir, "agents"), { recursive: true });
+    await writeFile2(join3(outputDir, "agents", ".gitkeep"), "", "utf8");
+    artifacts.push("agents/");
+    await mkdir2(join3(outputDir, "commands"), { recursive: true });
+    await writeFile2(join3(outputDir, "commands", ".gitkeep"), "", "utf8");
+    artifacts.push("commands/");
+    const hooksDir = join3(outputDir, "hooks");
+    await mkdir2(hooksDir, { recursive: true });
+    await writeFile2(join3(hooksDir, "hooks.json"), JSON.stringify({ hooks: {} }, null, 2) + `
+`, "utf8");
+    artifacts.push("hooks/hooks.json");
+    return {
+      target: "claude-code",
+      skillCount: skills.length,
+      outputDir,
+      artifacts,
+      warnings
+    };
+  }
+}
+
+// src/generators/codex/generator.ts
+import { mkdir as mkdir3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { stringify as stringifyYaml } from "yaml";
+function generateInstallMd() {
+  return [
+    "# Codex Installation",
+    "",
+    "## Prerequisites",
+    "- Codex CLI installed (OpenAI)",
+    "",
+    "## Installation",
+    "",
+    "### macOS/Linux",
+    "```bash",
+    "# Symlink skills directory",
+    "ln -sf /path/to/dist/targets/codex/skills ~/.agents/skills",
+    "```",
+    "",
+    "### Windows",
+    "```cmd",
+    ":: Use junctions (no Developer Mode required)",
+    'mklink /J "%USERPROFILE%\\.agents\\skills" "\\path\\to\\dist\\targets\\codex\\skills"',
+    "```",
+    ""
+  ].join(`
+`);
+}
+
+class CodexGenerator {
+  target = "codex";
+  async generate(options) {
+    const { skills, outputDir, catalogDir } = options;
+    const artifacts = [];
+    const warnings = [];
+    await rm2(outputDir, { recursive: true, force: true });
+    await mkdir3(outputDir, { recursive: true });
+    const skillsDir = join4(outputDir, "skills");
+    await mkdir3(skillsDir, { recursive: true });
+    for (const skill of skills) {
+      const srcDir = join4(catalogDir, "skills", skill.dirName);
+      const destDir = join4(skillsDir, skill.dirName);
+      await copyDirectoryRecursive(srcDir, destDir);
+      artifacts.push(`skills/${skill.dirName}/`);
+    }
+    const agentsDir = join4(outputDir, "agents");
+    await mkdir3(agentsDir, { recursive: true });
+    const openAiMetadata = {
+      display_name: "Awesome Agent Toolbox",
+      icon: "toolbox",
+      brand_color: "#2563eb",
+      policy: "You have access to skills from the agent-toolbox catalog. Read the relevant SKILL.md when a user's request matches a skill's description."
+    };
+    await writeFile3(join4(agentsDir, "openai.yaml"), stringifyYaml(openAiMetadata), "utf8");
+    artifacts.push("agents/openai.yaml");
+    await writeFile3(join4(outputDir, "INSTALL.md"), generateInstallMd(), "utf8");
+    artifacts.push("INSTALL.md");
+    return {
+      target: "codex",
+      skillCount: skills.length,
+      outputDir,
+      artifacts,
+      warnings
+    };
+  }
+}
+
+// src/generators/cursor/generator.ts
+import { mkdir as mkdir4, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+class CursorGenerator {
+  target = "cursor";
+  async generate(options) {
+    const { skills, outputDir, catalogDir, version } = options;
+    const artifacts = [];
+    const warnings = [];
+    await rm3(outputDir, { recursive: true, force: true });
+    await mkdir4(outputDir, { recursive: true });
+    const pluginDir = join5(outputDir, ".cursor-plugin");
+    await mkdir4(pluginDir, { recursive: true });
+    const pluginManifest = {
+      name: "agent-toolbox",
+      version,
+      description: "Cross-tool distribution system for agent skills, plugins, and MCP servers",
+      skills: "./skills/",
+      agents: "./agents/",
+      commands: "./commands/",
+      hooks: "./hooks/hooks.json"
+    };
+    await writeFile4(join5(pluginDir, "plugin.json"), `${JSON.stringify(pluginManifest, null, 2)}
+`, "utf8");
+    artifacts.push(".cursor-plugin/plugin.json");
+    const skillsDir = join5(outputDir, "skills");
+    await mkdir4(skillsDir, { recursive: true });
+    for (const skill of skills) {
+      const srcDir = join5(catalogDir, "skills", skill.dirName);
+      const destDir = join5(skillsDir, skill.dirName);
+      await copyDirectoryRecursive(srcDir, destDir);
+      artifacts.push(`skills/${skill.dirName}/`);
+    }
+    const agentsDir = join5(outputDir, "agents");
+    await mkdir4(agentsDir, { recursive: true });
+    await writeFile4(join5(agentsDir, ".gitkeep"), "", "utf8");
+    artifacts.push("agents/");
+    const commandsDir = join5(outputDir, "commands");
+    await mkdir4(commandsDir, { recursive: true });
+    await writeFile4(join5(commandsDir, ".gitkeep"), "", "utf8");
+    artifacts.push("commands/");
+    const hooksDir = join5(outputDir, "hooks");
+    await mkdir4(hooksDir, { recursive: true });
+    await writeFile4(join5(hooksDir, "hooks.json"), `${JSON.stringify({ hooks: {} }, null, 2)}
+`, "utf8");
+    artifacts.push("hooks/hooks.json");
+    return {
+      target: "cursor",
+      skillCount: skills.length,
+      outputDir,
+      artifacts,
+      warnings
+    };
+  }
+}
+
+// src/generators/gemini/generator.ts
+import { mkdir as mkdir5, rm as rm4, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+var GEMINI_HOOK_EVENTS = [
+  "SessionStart",
+  "SessionEnd",
+  "BeforeTool",
+  "AfterTool",
+  "BeforeModel",
+  "AfterModel",
+  "Notification",
+  "Stop",
+  "SubagentStart",
+  "SubagentEnd",
+  "PreToolExecution"
+];
+function groupSkillsByDomain(skills) {
+  const byDomain = new Map;
+  for (const skill of skills) {
+    const domain = skill.frontmatter.metadata.domain;
+    const existing = byDomain.get(domain);
+    if (existing) {
+      existing.push(skill);
+    } else {
+      byDomain.set(domain, [skill]);
+    }
+  }
+  return byDomain;
+}
+function generateGeminiContext(skills) {
+  const byDomain = groupSkillsByDomain(skills);
+  const sortedDomains = [...byDomain.keys()].sort((a, b) => a.localeCompare(b));
+  const lines = [
+    "# agent-toolbox Skills",
+    "",
+    "You have access to the following skills. Read the relevant SKILL.md when a user's request matches.",
+    "",
+    "## Skills by Domain",
+    ""
+  ];
+  for (const domain of sortedDomains) {
+    const domainSkills = byDomain.get(domain) ?? [];
+    const sortedSkills = [...domainSkills].sort((a, b) => a.frontmatter.name.localeCompare(b.frontmatter.name));
+    lines.push(`### ${domain} (${sortedSkills.length} skills)`);
+    for (const skill of sortedSkills) {
+      const description = skill.frontmatter.description.replace(/\s+/g, " ").trim();
+      lines.push(`- ${skill.frontmatter.name}: ${description}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function generateHooksConfig() {
+  const hooks = {};
+  for (const event of GEMINI_HOOK_EVENTS) {
+    hooks[event] = [];
+  }
+  return { hooks };
+}
+
+class GeminiGenerator {
+  target = "gemini";
+  async generate(options) {
+    const { skills, outputDir, catalogDir, version } = options;
+    const artifacts = [];
+    const warnings = [];
+    await rm4(outputDir, { recursive: true, force: true });
+    await mkdir5(outputDir, { recursive: true });
+    const extensionManifest = {
+      name: "agent-toolbox",
+      version,
+      description: "Cross-tool distribution system for agent skills, plugins, and MCP servers",
+      contextFileName: "GEMINI.md",
+      skills: "./skills/",
+      commands: "./commands/",
+      hooks: "./hooks/hooks.json"
+    };
+    await writeFile5(join6(outputDir, "gemini-extension.json"), `${JSON.stringify(extensionManifest, null, 2)}
+`, "utf8");
+    artifacts.push("gemini-extension.json");
+    const skillsDir = join6(outputDir, "skills");
+    await mkdir5(skillsDir, { recursive: true });
+    for (const skill of skills) {
+      const srcDir = join6(catalogDir, "skills", skill.dirName);
+      const destDir = join6(skillsDir, skill.dirName);
+      await copyDirectoryRecursive(srcDir, destDir);
+      artifacts.push(`skills/${skill.dirName}/`);
+    }
+    const commandsDir = join6(outputDir, "commands");
+    await mkdir5(commandsDir, { recursive: true });
+    await writeFile5(join6(commandsDir, ".gitkeep"), "", "utf8");
+    artifacts.push("commands/");
+    const hooksDir = join6(outputDir, "hooks");
+    await mkdir5(hooksDir, { recursive: true });
+    await writeFile5(join6(hooksDir, "hooks.json"), `${JSON.stringify(generateHooksConfig(), null, 2)}
+`, "utf8");
+    artifacts.push("hooks/hooks.json");
+    await writeFile5(join6(outputDir, "GEMINI.md"), `${generateGeminiContext(skills)}
+`, "utf8");
+    artifacts.push("GEMINI.md");
+    return {
+      target: "gemini",
+      skillCount: skills.length,
+      outputDir,
+      artifacts,
+      warnings
+    };
+  }
+}
+
+// src/generators/opencode/generator.ts
+import { mkdir as mkdir6, rm as rm5, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+function generateOpenCodePlugin(skillList) {
+  return [
+    `// agent-toolbox.js - OpenCode plugin bootstrap`,
+    `// Injects skill catalog awareness into the system prompt`,
+    ``,
+    `import path from "path";`,
+    `import { fileURLToPath } from "url";`,
+    ``,
+    `const __dirname = path.dirname(fileURLToPath(import.meta.url));`,
+    ``,
+    `const SKILL_CATALOG = ${JSON.stringify([
+      "## Available Skills (agent-toolbox)",
+      "",
+      "You have access to skills from agent-toolbox. Each skill has a SKILL.md",
+      "with instructions. Read the relevant SKILL.md when a user's request matches a skill's",
+      "description.",
+      "",
+      "### Installed Skills:",
+      skillList,
+      ""
+    ].join(`
+`))};`,
+    ``,
+    `export const AwesomeAgentToolboxPlugin = async ({ directory }) => {`,
+    `  return {`,
+    `    "experimental.chat.system.transform": async (_input, output) => {`,
+    `      (output.system ||= []).push(SKILL_CATALOG);`,
+    `    },`,
+    `  };`,
+    `};`,
+    ``
+  ].join(`
+`);
+}
+function generateInstallMd2() {
+  return [
+    "# OpenCode Installation",
+    "",
+    "## Prerequisites",
+    "- OpenCode installed (https://github.com/anomalyco/opencode)",
+    "",
+    "## Installation",
+    "",
+    "### 1. Link skills",
+    "```bash",
+    "# macOS/Linux",
+    "mkdir -p ~/.config/opencode/skills",
+    "ln -sf /path/to/dist/targets/opencode/skills ~/.config/opencode/skills/agent-toolbox",
+    "",
+    "# Windows (PowerShell as Admin)",
+    'New-Item -ItemType Junction -Path "$env:APPDATA\\opencode\\skills\\agent-toolbox" -Target "\\path\\to\\dist\\targets\\opencode\\skills"',
+    "```",
+    "",
+    "### 2. Install plugin",
+    "```bash",
+    "# macOS/Linux",
+    "mkdir -p ~/.config/opencode/plugins",
+    "ln -sf /path/to/dist/targets/opencode/plugins/agent-toolbox.js ~/.config/opencode/plugins/agent-toolbox.js",
+    "",
+    "# Windows (copy)",
+    'copy "\\path\\to\\dist\\targets\\opencode\\plugins\\agent-toolbox.js" "%APPDATA%\\opencode\\plugins\\"',
+    "```",
+    ""
+  ].join(`
+`);
+}
+
+class OpenCodeGenerator {
+  target = "opencode";
+  async generate(options) {
+    const { skills, outputDir, catalogDir } = options;
+    const artifacts = [];
+    const warnings = [];
+    await rm5(outputDir, { recursive: true, force: true });
+    await mkdir6(outputDir, { recursive: true });
+    const skillsDir = join7(outputDir, "skills");
+    await mkdir6(skillsDir, { recursive: true });
+    for (const skill of skills) {
+      const srcDir = join7(catalogDir, "skills", skill.dirName);
+      const destDir = join7(skillsDir, skill.dirName);
+      await copyDirectoryRecursive(srcDir, destDir);
+      artifacts.push(`skills/${skill.dirName}/`);
+    }
+    const skillListLines = [...skills].sort((a, b) => a.frontmatter.name.localeCompare(b.frontmatter.name)).map((skill) => `- **${skill.frontmatter.name}** (${skill.frontmatter.metadata.domain}): ${skill.frontmatter.description}`).join(`
+`);
+    const pluginsDir = join7(outputDir, "plugins");
+    await mkdir6(pluginsDir, { recursive: true });
+    const pluginJs = generateOpenCodePlugin(skillListLines);
+    await writeFile6(join7(pluginsDir, "agent-toolbox.js"), pluginJs, "utf8");
+    artifacts.push("plugins/agent-toolbox.js");
+    const installMd = generateInstallMd2();
+    await writeFile6(join7(outputDir, "INSTALL.md"), installMd, "utf8");
+    artifacts.push("INSTALL.md");
+    return {
+      target: "opencode",
+      skillCount: skills.length,
+      outputDir,
+      artifacts,
+      warnings
+    };
+  }
+}
+
+// src/cli/utils.ts
+var RESET = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var CYAN = "\x1B[36m";
+function green(text) {
+  return `${GREEN}${text}${RESET}`;
+}
+function red(text) {
+  return `${RED}${text}${RESET}`;
+}
+function yellow(text) {
+  return `${YELLOW}${text}${RESET}`;
+}
+function dim(text) {
+  return `${DIM}${text}${RESET}`;
+}
+function bold(text) {
+  return `${BOLD}${text}${RESET}`;
+}
+function cyan(text) {
+  return `${CYAN}${text}${RESET}`;
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0;i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    const key = token.slice(2);
+    const nextToken = argv[i + 1];
+    const value = nextToken && !nextToken.startsWith("--") ? nextToken : "true";
+    if (key === "skill") {
+      const current = args[key];
+      if (!Array.isArray(current)) {
+        args[key] = current ? [String(current)] : [];
+      }
+      if (value !== "true") {
+        const arr = args[key];
+        arr.push(value);
+      }
+    } else {
+      args[key] = value;
+    }
+    if (value !== "true") {
+      i += 1;
+    }
+  }
+  return args;
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function truncate(text, maxWidth) {
+  if (text.length <= maxWidth) {
+    return text;
+  }
+  return text.slice(0, maxWidth - 3) + "...";
+}
+function formatTable(headers, rows, options) {
+  const maxColWidth = options?.maxColWidth ?? 60;
+  const padding = options?.padding ?? 2;
+  const truncatedHeaders = headers.map((h) => truncate(h, maxColWidth));
+  const truncatedRows = rows.map((row) => row.map((cell) => truncate(cell, maxColWidth)));
+  const colWidths = truncatedHeaders.map((h) => stripAnsi(h).length);
+  for (const row of truncatedRows) {
+    for (let i = 0;i < row.length; i += 1) {
+      const cellWidth = stripAnsi(row[i]).length;
+      if (i < colWidths.length && cellWidth > colWidths[i]) {
+        colWidths[i] = cellWidth;
+      }
+    }
+  }
+  const pad = " ".repeat(padding);
+  const lines = [];
+  const headerLine = truncatedHeaders.map((h, i) => {
+    const visible = stripAnsi(h).length;
+    return h + " ".repeat(Math.max(0, colWidths[i] - visible));
+  }).join(pad);
+  lines.push(bold(headerLine));
+  const separator = colWidths.map((w) => "─".repeat(w)).join(pad);
+  lines.push(dim(separator));
+  for (const row of truncatedRows) {
+    const rowLine = row.map((cell, i) => {
+      const visible = stripAnsi(cell).length;
+      const width = i < colWidths.length ? colWidths[i] : visible;
+      return cell + " ".repeat(Math.max(0, width - visible));
+    }).join(pad);
+    lines.push(rowLine);
+  }
+  return lines.join(`
+`);
+}
+
+// src/cli/build-target.ts
+var ALL_TARGETS = [
+  "claude-code",
+  "opencode",
+  "cursor",
+  "codex",
+  "gemini"
+];
+function getGenerator(target) {
+  const generators = {
+    "claude-code": new ClaudeCodeGenerator,
+    opencode: new OpenCodeGenerator,
+    cursor: new CursorGenerator,
+    codex: new CodexGenerator,
+    gemini: new GeminiGenerator
+  };
+  const generator = generators[target];
+  if (!generator) {
+    throw new Error(`Generator for '${target}' not yet implemented`);
+  }
+  return generator;
+}
+async function runBuildTarget(rootDir, target) {
+  const catalogDir = join8(rootDir, "catalog");
+  const targetParse = TargetTool.safeParse(target);
+  if (!targetParse.success) {
+    console.error(`Invalid target: ${target}. Valid targets: claude-code, opencode, cursor, codex, gemini`);
+    process.exit(1);
+  }
+  const generator = getGenerator(targetParse.data);
+  console.log("Scanning catalog...");
+  const { skills, errors } = await scanSkills(catalogDir);
+  if (errors.length > 0) {
+    console.error(`Found ${errors.length} scan errors:`);
+    for (const err of errors) {
+      console.error(`  ${err.path}: ${err.error}`);
+    }
+  }
+  if (skills.length === 0) {
+    console.error("No skills found in catalog");
+    process.exit(1);
+  }
+  const pkg = JSON.parse(await readFile3(join8(rootDir, "package.json"), "utf8"));
+  const version = pkg.version;
+  const outputDir = join8(rootDir, "dist", "targets", targetParse.data);
+  console.log(`Generating ${targetParse.data} artifacts...`);
+  const result = await generator.generate({
+    skills,
+    outputDir,
+    catalogDir,
+    version
+  });
+  console.log(`${green("✓")} Generated ${result.skillCount} skills for ${result.target}`);
+  console.log(`  Output: ${result.outputDir}`);
+  console.log(`  Artifacts: ${result.artifacts.length} items`);
+  if (result.warnings.length > 0) {
+    console.log(`
+Warnings:`);
+    for (const warning of result.warnings) {
+      console.log(`  ${yellow("!")} ${warning}`);
+    }
+  }
+}
+async function runBuildAll(rootDir) {
+  for (const target of ALL_TARGETS) {
+    await runBuildTarget(rootDir, target);
+    console.log("");
+  }
+}
+if (false) {}
+
+// src/cli/build-index.ts
+import { resolve } from "node:path";
+
+// src/catalog/index-builder.ts
+import { mkdir as mkdir7, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+import { DELIMITERS, encode } from "@toon-format/toon";
+function buildSkillIndex(skills) {
+  const skillEntries = skills.map((skill) => ({
+    name: skill.frontmatter.name,
+    description: skill.frontmatter.description,
+    domain: skill.frontmatter.metadata.domain,
+    subdomain: skill.frontmatter.metadata.subdomain,
+    provenance: skill.frontmatter.metadata.provenance,
+    author: skill.frontmatter.metadata.author,
+    lastUpdated: skill.frontmatter.metadata.lastUpdated,
+    license: skill.frontmatter.license
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const tags = {};
+  const frameworks = {};
+  for (const skill of skills) {
+    const skillTags = skill.frontmatter.metadata.tags;
+    if (skillTags && skillTags.length > 0) {
+      tags[skill.frontmatter.name] = skillTags;
+    }
+    const skillFrameworks = skill.frontmatter.metadata.frameworks;
+    if (skillFrameworks && skillFrameworks.length > 0) {
+      frameworks[skill.frontmatter.name] = skillFrameworks;
+    }
+  }
+  return SkillIndex.parse({
+    version: 2,
+    generatedAt: new Date().toISOString(),
+    skills: skillEntries,
+    tags,
+    frameworks
+  });
+}
+async function writeSkillIndex(index, outputPath) {
+  await mkdir7(dirname2(outputPath), { recursive: true });
+  const json = `${JSON.stringify(index, null, 2)}
+`;
+  await writeFile7(outputPath, json, "utf8");
+}
+async function writeSkillIndexToon(index, outputPath) {
+  await mkdir7(dirname2(outputPath), { recursive: true });
+  const toon = encode(index, { delimiter: DELIMITERS.tab });
+  await writeFile7(outputPath, toon, "utf8");
+}
+
+// src/cli/build-index.ts
+async function runBuildIndex(rootDir) {
+  const catalogDir = resolve(rootDir, "catalog");
+  const outputPath = resolve(catalogDir, "metadata/skill-index.json");
+  const toonOutputPath = resolve(catalogDir, "metadata/skill-index.toon");
+  const scanResult = await scanSkills(catalogDir);
+  if (scanResult.errors.length > 0) {
+    for (const error of scanResult.errors) {
+      console.error(`${red("✗")} ${error.path}: ${error.error}`);
+    }
+    process.exit(1);
+  }
+  const index = buildSkillIndex(scanResult.skills);
+  await writeSkillIndex(index, outputPath);
+  await writeSkillIndexToon(index, toonOutputPath);
+  console.log(`${green("✓")} Generated skill-index.json with ${index.skills.length} skills`);
+  console.log(`${green("✓")} Generated skill-index.toon with ${index.skills.length} skills`);
+}
+if (false) {}
+
+// src/cli/check.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readdir as readdir4 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+
+// src/install/checker.ts
+import { join as join11 } from "node:path";
+
+// src/catalog/provider.ts
+import { execFile as execFileCb } from "node:child_process";
+import { existsSync } from "node:fs";
+import {
+  mkdir as mkdir8,
+  readFile as readFile4,
+  readdir as readdir3,
+  rename,
+  rm as rm6,
+  writeFile as writeFile8
+} from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { promisify } from "node:util";
+import { z as z3 } from "zod";
+var DEFAULT_SOURCE = {
+  owner: "yunseo-kim",
+  repo: "agent-toolbox",
+  branch: "main"
+};
+var USER_AGENT = "agent-toolbox-cli";
+var execFileAsync = promisify(execFileCb);
+var CatalogSourceSchema = z3.object({
+  owner: z3.string().min(1),
+  repo: z3.string().min(1),
+  branch: z3.string().min(1)
+});
+var CatalogResolveOptionsSchema = z3.object({
+  rootDir: z3.string().min(1),
+  remote: z3.boolean().optional(),
+  refresh: z3.boolean().optional(),
+  offline: z3.boolean().optional(),
+  source: CatalogSourceSchema.partial().optional()
+});
+var CommitShaSchema = z3.string().regex(/^[0-9a-f]{40}$/i, "Invalid commit SHA");
+var CacheMetaSchema = z3.object({
+  commitSha: CommitShaSchema,
+  etag: z3.string().nullable(),
+  fetchedAt: z3.iso.datetime({ offset: true }),
+  source: CatalogSourceSchema
+});
+function getCacheDir() {
+  const xdgCacheHome = process.env.XDG_CACHE_HOME;
+  if (xdgCacheHome) {
+    return join9(xdgCacheHome, "agent-toolbox");
+  }
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA ?? join9(home, "AppData", "Local");
+    return join9(localAppData, "agent-toolbox");
+  }
+  return join9(home, ".cache", "agent-toolbox");
+}
+async function fetchWithETag(url, cachedEtag, headers) {
+  const requestHeaders = {
+    "User-Agent": USER_AGENT,
+    ...headers
+  };
+  if (cachedEtag) {
+    requestHeaders["If-None-Match"] = cachedEtag;
+  }
+  const response = await fetch(url, {
+    headers: requestHeaders,
+    redirect: "follow"
+  });
+  if (response.status === 304) {
+    return {
+      status: 304,
+      body: null,
+      etag: cachedEtag
+    };
+  }
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} fetching ${url}: ${response.statusText}`);
+  }
+  return {
+    status: response.status,
+    body: await response.text(),
+    etag: response.headers.get("etag")
+  };
+}
+async function fetchCommitShaFromApi(source, cachedEtag) {
+  const url = `https://api.github.com/repos/${source.owner}/${source.repo}/commits/${source.branch}`;
+  const result = await fetchWithETag(url, cachedEtag, {
+    Accept: "application/vnd.github.sha",
+    "X-GitHub-Api-Version": "2022-11-28"
+  });
+  if (result.status === 304) {
+    return {
+      notModified: true,
+      etag: result.etag
+    };
+  }
+  const sha = CommitShaSchema.parse((result.body ?? "").trim());
+  return {
+    notModified: false,
+    sha,
+    etag: result.etag
+  };
+}
+async function checkCatalogFreshness(source, cachedEtag) {
+  const rawUrl = `https://raw.githubusercontent.com/${source.owner}/${source.repo}/${source.branch}/catalog/metadata/skill-index.json`;
+  try {
+    const rawResult = await fetchWithETag(rawUrl, cachedEtag, {
+      Accept: "application/json"
+    });
+    if (rawResult.status === 304) {
+      return {
+        notModified: true,
+        etag: rawResult.etag
+      };
+    }
+    return await fetchCommitShaFromApi(source, null);
+  } catch (primaryError) {
+    try {
+      return await fetchCommitShaFromApi(source, cachedEtag);
+    } catch (secondaryError) {
+      const primaryReason = primaryError instanceof Error ? primaryError.message : String(primaryError);
+      const secondaryReason = secondaryError instanceof Error ? secondaryError.message : String(secondaryError);
+      throw new Error(`Failed to check catalog updates via raw.githubusercontent.com (${primaryReason}) and GitHub API (${secondaryReason})`, { cause: secondaryError });
+    }
+  }
+}
+async function fetchLatestCommitSha(source) {
+  const latest = await fetchCommitShaFromApi(source, null);
+  if (latest.notModified) {
+    throw new Error("Unexpected 304 response while fetching latest commit SHA");
+  }
+  return latest.sha;
+}
+async function downloadAndExtractCatalog(source, sha, cacheRoot) {
+  const tarUrl = `https://codeload.github.com/${source.owner}/${source.repo}/tar.gz/${sha}`;
+  const response = await fetch(tarUrl, {
+    headers: { "User-Agent": USER_AGENT },
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download catalog archive: HTTP ${response.status}`);
+  }
+  const tmpRoot = join9(cacheRoot, ".tmp-catalog");
+  const archivePath = join9(tmpRoot, "catalog.tar.gz");
+  const stageDir = join9(cacheRoot, "catalog.next");
+  const catalogDir = join9(cacheRoot, "catalog");
+  await rm6(tmpRoot, { recursive: true, force: true });
+  await rm6(stageDir, { recursive: true, force: true });
+  await mkdir8(tmpRoot, { recursive: true });
+  const archive = await response.arrayBuffer();
+  await writeFile8(archivePath, Buffer.from(archive));
+  try {
+    await execFileAsync("tar", ["xzf", archivePath, "-C", tmpRoot]);
+  } catch (error) {
+    const execError = error;
+    throw new Error(`Catalog archive extraction failed (exit ${execError.code ?? 1}): ${(execError.stderr ?? "").trim()}`, { cause: error });
+  }
+  const extractedEntries = await readdir3(tmpRoot, { withFileTypes: true });
+  const repoDir = extractedEntries.find((entry) => entry.isDirectory())?.name;
+  if (!repoDir) {
+    throw new Error("Catalog archive did not contain repository directory");
+  }
+  const extractedCatalogDir = join9(tmpRoot, repoDir, "catalog");
+  if (!existsSync(extractedCatalogDir)) {
+    throw new Error("Catalog archive does not contain catalog/ directory");
+  }
+  await rename(extractedCatalogDir, stageDir);
+  await rm6(catalogDir, { recursive: true, force: true });
+  await rename(stageDir, catalogDir);
+  await rm6(tmpRoot, { recursive: true, force: true });
+}
+async function readCacheMeta(cacheRoot) {
+  const path = join9(cacheRoot, "cache-meta.json");
+  try {
+    const content = await readFile4(path, "utf8");
+    const raw = JSON.parse(content);
+    return CacheMetaSchema.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCacheMeta(cacheRoot, meta) {
+  const path = join9(cacheRoot, "cache-meta.json");
+  await mkdir8(cacheRoot, { recursive: true });
+  await writeFile8(path, JSON.stringify(meta, null, 2), "utf8");
+}
+function isRunningFromPackageManager() {
+  const npmExecPath = process.env.npm_execpath ?? "";
+  const npmUserAgent = process.env.npm_config_user_agent ?? "";
+  const bunxMode = process.env.BUN_INSTALL_BIN ?? "";
+  return npmExecPath.includes("npx") || npmExecPath.includes("npm-cli") || npmExecPath.includes("bunx") || npmUserAgent.includes("npm/") || npmUserAgent.includes("bun/") || bunxMode.length > 0;
+}
+async function resolveCatalogDir(options) {
+  const parsedOptions = CatalogResolveOptionsSchema.parse(options);
+  const source = CatalogSourceSchema.parse({
+    ...DEFAULT_SOURCE,
+    ...parsedOptions.source
+  });
+  const shouldUseRemote = parsedOptions.remote ?? isRunningFromPackageManager();
+  if (!shouldUseRemote) {
+    return join9(parsedOptions.rootDir, "catalog");
+  }
+  const cacheRoot = getCacheDir();
+  const catalogDir = join9(cacheRoot, "catalog");
+  const hasCachedCatalog = existsSync(catalogDir);
+  if (parsedOptions.offline) {
+    if (!hasCachedCatalog) {
+      throw new Error("No cached catalog found. Run once without --offline to download catalog data.");
+    }
+    return catalogDir;
+  }
+  const cacheMeta = await readCacheMeta(cacheRoot);
+  if (!parsedOptions.refresh && hasCachedCatalog && cacheMeta) {
+    try {
+      const freshness = await checkCatalogFreshness(source, cacheMeta.etag);
+      if (freshness.notModified) {
+        return catalogDir;
+      }
+      if (freshness.sha === cacheMeta.commitSha) {
+        await writeCacheMeta(cacheRoot, {
+          ...cacheMeta,
+          etag: freshness.etag ?? cacheMeta.etag,
+          fetchedAt: new Date().toISOString(),
+          source
+        });
+        return catalogDir;
+      }
+    } catch (error) {
+      if (hasCachedCatalog) {
+        const reason = error instanceof Error ? error.message : String(error);
+        console.warn(`Could not refresh catalog metadata (${reason}). Using cached catalog.`);
+        return catalogDir;
+      }
+      throw error;
+    }
+  }
+  try {
+    const sha = await fetchLatestCommitSha(source);
+    if (!parsedOptions.refresh && cacheMeta?.commitSha === sha && hasCachedCatalog) {
+      await writeCacheMeta(cacheRoot, {
+        ...cacheMeta,
+        commitSha: sha,
+        fetchedAt: new Date().toISOString(),
+        source
+      });
+      return catalogDir;
+    }
+    await mkdir8(cacheRoot, { recursive: true });
+    await downloadAndExtractCatalog(source, sha, cacheRoot);
+    await writeCacheMeta(cacheRoot, {
+      commitSha: sha,
+      etag: cacheMeta?.etag ?? null,
+      fetchedAt: new Date().toISOString(),
+      source
+    });
+    return catalogDir;
+  } catch (error) {
+    if (hasCachedCatalog) {
+      const reason = error instanceof Error ? error.message : String(error);
+      console.warn(`Failed to update catalog (${reason}). Using cached catalog.`);
+      return catalogDir;
+    }
+    throw error;
+  }
+}
+
+// src/schemas/install.ts
+import { z as z4 } from "zod";
+var InstallFilters = z4.object({
+  target: TargetTool,
+  domain: z4.string().optional(),
+  subdomain: z4.string().optional(),
+  framework: z4.string().optional(),
+  tag: z4.string().optional(),
+  preset: z4.string().optional(),
+  skill: z4.array(z4.string()).optional(),
+  interactive: z4.boolean().default(false),
+  dryRun: z4.boolean().default(false),
+  refresh: z4.boolean().optional().default(false),
+  offline: z4.boolean().optional().default(false)
+});
+
+// src/install/filter.ts
+function filterSkills(skills, rawFilters) {
+  const filters = InstallFilters.parse(rawFilters);
+  let matched = [...skills];
+  const appliedFilters = [];
+  const total = skills.length;
+  if (filters.domain) {
+    matched = matched.filter((skill) => skill.frontmatter.metadata.domain === filters.domain);
+    appliedFilters.push(`domain=${filters.domain}`);
+  }
+  if (filters.subdomain) {
+    matched = matched.filter((skill) => skill.frontmatter.metadata.subdomain === filters.subdomain);
+    appliedFilters.push(`subdomain=${filters.subdomain}`);
+  }
+  if (filters.framework) {
+    const framework = filters.framework.toLowerCase();
+    matched = matched.filter((skill) => {
+      const frameworks = skill.frontmatter.metadata.frameworks;
+      if (!frameworks) {
+        return false;
+      }
+      return frameworks.some((entry) => entry.toLowerCase() === framework);
+    });
+    appliedFilters.push(`framework=${filters.framework}`);
+  }
+  if (filters.tag) {
+    const tag = filters.tag.toLowerCase();
+    matched = matched.filter((skill) => {
+      const tags = skill.frontmatter.metadata.tags;
+      if (!tags) {
+        return false;
+      }
+      return tags.some((entry) => entry.toLowerCase() === tag);
+    });
+    appliedFilters.push(`tag=${filters.tag}`);
+  }
+  if (filters.skill && filters.skill.length > 0) {
+    const names = new Set(filters.skill.map((name) => name.toLowerCase()));
+    matched = matched.filter((skill) => names.has(skill.frontmatter.name.toLowerCase()));
+    appliedFilters.push(`skill=${filters.skill.join(",")}`);
+  }
+  return { matched, total, appliedFilters };
+}
+
+// src/install/manifest.ts
+import { mkdir as mkdir9, readFile as readFile5, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname4, join as join10 } from "node:path";
+
+// src/schemas/manifest.ts
+import { z as z5 } from "zod";
+var InstallManifestSkill = z5.object({
+  name: z5.string(),
+  domain: z5.string(),
+  subdomain: z5.string().optional(),
+  lastUpdated: z5.string()
+});
+var InstallManifestFilters = z5.object({
+  domain: z5.string().optional(),
+  subdomain: z5.string().optional(),
+  framework: z5.string().optional(),
+  tag: z5.string().optional(),
+  preset: z5.string().optional(),
+  skill: z5.array(z5.string()).optional()
+});
+var InstallManifest = z5.object({
+  version: z5.literal(1),
+  target: TargetTool,
+  installedAt: z5.string(),
+  catalogSource: z5.enum(["local", "remote"]),
+  filters: InstallManifestFilters,
+  skills: z5.array(InstallManifestSkill)
+});
+
+// src/install/manifest.ts
+var MANIFEST_FILENAME = ".install-manifest.json";
+async function readManifest(targetDir) {
+  const path = join10(targetDir, MANIFEST_FILENAME);
+  try {
+    const content = await readFile5(path, "utf8");
+    const raw = JSON.parse(content);
+    return InstallManifest.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeManifest(targetDir, manifest) {
+  const path = join10(targetDir, MANIFEST_FILENAME);
+  await mkdir9(dirname4(path), { recursive: true });
+  await writeFile9(path, JSON.stringify(manifest, null, 2) + `
+`, "utf8");
+}
+async function removeSkillsFromManifest(targetDir, skillNames) {
+  const manifest = await readManifest(targetDir);
+  if (!manifest) {
+    return null;
+  }
+  const namesToRemove = new Set(skillNames.map((n) => n.toLowerCase()));
+  const updated = {
+    ...manifest,
+    skills: manifest.skills.filter((s) => !namesToRemove.has(s.name.toLowerCase()))
+  };
+  await writeManifest(targetDir, updated);
+  return updated;
+}
+
+// src/install/checker.ts
+async function checkInstallStatus(rootDir, target, options = {}) {
+  const targetDir = join11(rootDir, "dist", "targets", target);
+  const manifest = await readManifest(targetDir);
+  if (!manifest) {
+    throw new Error(`No install manifest found for '${target}'. Run 'agent-toolbox install --target ${target}' first.`);
+  }
+  const catalogDir = await resolveCatalogDir({
+    rootDir,
+    refresh: options.refresh,
+    offline: options.offline
+  });
+  const { skills: catalogSkills } = await scanSkills(catalogDir);
+  const currentMatch = filterSkills(catalogSkills, {
+    target: manifest.target,
+    domain: manifest.filters.domain,
+    subdomain: manifest.filters.subdomain,
+    framework: manifest.filters.framework,
+    tag: manifest.filters.tag,
+    skill: manifest.filters.skill
+  });
+  const catalogMap = new Map;
+  for (const skill of currentMatch.matched) {
+    catalogMap.set(skill.frontmatter.name.toLowerCase(), skill);
+  }
+  const installedMap = new Map;
+  for (const skill of manifest.skills) {
+    installedMap.set(skill.name.toLowerCase(), skill);
+  }
+  const entries = [];
+  const summary = {
+    upToDate: 0,
+    outdated: 0,
+    removedFromCatalog: 0,
+    newInCatalog: 0
+  };
+  for (const installed of manifest.skills) {
+    const catalogSkill = catalogMap.get(installed.name.toLowerCase());
+    if (!catalogSkill) {
+      entries.push({
+        name: installed.name,
+        status: "removed-from-catalog",
+        installedDate: installed.lastUpdated
+      });
+      summary.removedFromCatalog += 1;
+    } else if (catalogSkill.frontmatter.metadata.lastUpdated !== installed.lastUpdated) {
+      entries.push({
+        name: installed.name,
+        status: "outdated",
+        installedDate: installed.lastUpdated,
+        catalogDate: catalogSkill.frontmatter.metadata.lastUpdated
+      });
+      summary.outdated += 1;
+    } else {
+      entries.push({
+        name: installed.name,
+        status: "up-to-date",
+        installedDate: installed.lastUpdated,
+        catalogDate: catalogSkill.frontmatter.metadata.lastUpdated
+      });
+      summary.upToDate += 1;
+    }
+  }
+  for (const [name, catalogSkill] of catalogMap) {
+    if (!installedMap.has(name)) {
+      entries.push({
+        name: catalogSkill.frontmatter.name,
+        status: "new-in-catalog",
+        catalogDate: catalogSkill.frontmatter.metadata.lastUpdated
+      });
+      summary.newInCatalog += 1;
+    }
+  }
+  const statusOrder = {
+    outdated: 0,
+    "new-in-catalog": 1,
+    "removed-from-catalog": 2,
+    "up-to-date": 3
+  };
+  entries.sort((a, b) => (statusOrder[a.status] ?? 99) - (statusOrder[b.status] ?? 99));
+  return {
+    target: manifest.target,
+    installedAt: manifest.installedAt,
+    entries,
+    summary
+  };
+}
+
+// src/cli/check.ts
+var NAME = "agent-toolbox";
+function printCheckHelp() {
+  console.log(`
+USAGE
+  ${NAME} check [options]
+
+DESCRIPTION
+  Check if installed skills are outdated compared to the current catalog.
+  Without --target, checks all targets that have an install manifest.
+
+OPTIONS
+  --target <tool>     Check specific target only
+  --json              Output as JSON
+  --refresh           Force re-download catalog for comparison
+  --offline           Use cached catalog only
+
+EXAMPLES
+  ${NAME} check
+  ${NAME} check --target claude-code
+  ${NAME} check --refresh
+  ${NAME} check --json
+`.trimStart());
+}
+async function discoverTargets(rootDir) {
+  const targetsDir = join12(rootDir, "dist", "targets");
+  if (!existsSync2(targetsDir)) {
+    return [];
+  }
+  const entries = await readdir4(targetsDir, { withFileTypes: true });
+  const targets = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const manifestPath = join12(targetsDir, entry.name, MANIFEST_FILENAME);
+    if (existsSync2(manifestPath)) {
+      targets.push(entry.name);
+    }
+  }
+  return targets;
+}
+async function runCheck(rootDir, argv) {
+  const args = parseArgs(argv);
+  if (args.help === "true" || args.h === "true") {
+    printCheckHelp();
+    process.exit(0);
+  }
+  const refresh = args.refresh === "true";
+  const offline = args.offline === "true";
+  const jsonMode = args.json === "true";
+  let targets;
+  if (typeof args.target === "string" && args.target !== "true") {
+    const targetParse = TargetTool.safeParse(args.target);
+    if (!targetParse.success) {
+      console.error(`${red("Error:")} Invalid target: ${args.target}. Valid: claude-code, opencode, cursor, codex, gemini`);
+      process.exit(1);
+    }
+    targets = [targetParse.data];
+  } else {
+    targets = await discoverTargets(rootDir);
+    if (targets.length === 0) {
+      console.log(`No install manifests found. Run '${NAME} install --target <tool>' first.`);
+      process.exit(0);
+    }
+  }
+  const allResults = [];
+  let hasOutdated = false;
+  for (const target of targets) {
+    try {
+      const result = await checkInstallStatus(rootDir, target, {
+        refresh,
+        offline
+      });
+      allResults.push(result);
+      if (result.summary.outdated > 0 || result.summary.newInCatalog > 0) {
+        hasOutdated = true;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!jsonMode) {
+        console.error(`${yellow("Warning:")} ${target}: ${message}`);
+      }
+    }
+  }
+  if (jsonMode) {
+    console.log(JSON.stringify(allResults, null, 2));
+    process.exit(hasOutdated ? 1 : 0);
+  }
+  for (const result of allResults) {
+    const { summary } = result;
+    console.log(`
+${bold(result.target)} ${dim(`(installed: ${result.installedAt})`)}`);
+    if (summary.upToDate > 0) {
+      console.log(`  ${green("✓")} ${summary.upToDate} skill(s) up to date`);
+    }
+    if (summary.outdated > 0) {
+      const outdatedNames = result.entries.filter((e) => e.status === "outdated").map((e) => e.name);
+      console.log(`  ${yellow("↑")} ${summary.outdated} skill(s) outdated: ${outdatedNames.join(", ")}`);
+    }
+    if (summary.newInCatalog > 0) {
+      const newNames = result.entries.filter((e) => e.status === "new-in-catalog").map((e) => e.name);
+      console.log(`  ${cyan("+")} ${summary.newInCatalog} new skill(s) available: ${newNames.join(", ")}`);
+    }
+    if (summary.removedFromCatalog > 0) {
+      const removedNames = result.entries.filter((e) => e.status === "removed-from-catalog").map((e) => e.name);
+      console.log(`  ${red("-")} ${summary.removedFromCatalog} skill(s) removed from catalog: ${removedNames.join(", ")}`);
+    }
+  }
+  if (hasOutdated) {
+    const targetHint = targets.length === 1 ? ` --target ${targets[0]}` : "";
+    console.log(`
+Run '${NAME} update${targetHint}' to update.`);
+  } else if (allResults.length > 0) {
+    console.log(`
+${green("✓")} All installed skills are up to date.`);
+  }
+  process.exit(hasOutdated ? 1 : 0);
+}
+if (false) {}
+
+// src/catalog/search.ts
+function searchSkills(skills, query) {
+  if (!query || query.trim() === "") {
+    return skills.map((skill) => ({ skill, score: 0, matchedFields: [] }));
+  }
+  const q = query.toLowerCase().trim();
+  const results = [];
+  for (const skill of skills) {
+    let score = 0;
+    const matchedFields = [];
+    const name = skill.frontmatter.name.toLowerCase();
+    const description = skill.frontmatter.description.toLowerCase();
+    const domain = skill.frontmatter.metadata.domain.toLowerCase();
+    const subdomain = skill.frontmatter.metadata.subdomain?.toLowerCase() ?? "";
+    const tags = skill.frontmatter.metadata.tags ?? [];
+    const frameworks = skill.frontmatter.metadata.frameworks ?? [];
+    if (name === q) {
+      score += 100;
+      matchedFields.push("name");
+    } else if (name.includes(q)) {
+      score += 50;
+      matchedFields.push("name");
+    }
+    for (const tag of tags) {
+      if (tag.toLowerCase() === q) {
+        score += 30;
+        matchedFields.push("tags");
+        break;
+      }
+    }
+    for (const fw of frameworks) {
+      if (fw.toLowerCase() === q) {
+        score += 30;
+        matchedFields.push("frameworks");
+        break;
+      }
+    }
+    if (domain === q || domain.includes(q)) {
+      score += 20;
+      matchedFields.push("domain");
+    }
+    if (subdomain && (subdomain === q || subdomain.includes(q))) {
+      score += 20;
+      matchedFields.push("subdomain");
+    }
+    if (description.includes(q)) {
+      score += 10;
+      matchedFields.push("description");
+    }
+    if (score > 0) {
+      results.push({ skill, score, matchedFields });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+
+// src/cli/find.ts
+var NAME2 = "agent-toolbox";
+var DEFAULT_LIMIT = 20;
+function printFindHelp() {
+  console.log(`
+USAGE
+  ${NAME2} find <query> [options]
+
+DESCRIPTION
+  Search catalog skills by keyword. Matches against name, description,
+  domain, subdomain, tags, and frameworks with weighted scoring.
+
+OPTIONS
+  --domain <d>       Pre-filter by domain before searching
+  --limit <n>        Max results (default: ${DEFAULT_LIMIT})
+  --json             Output as JSON
+  --refresh          Force re-download catalog from remote
+  --offline          Use cached catalog only
+
+EXAMPLES
+  ${NAME2} find git
+  ${NAME2} find react --domain development
+  ${NAME2} find "ci-cd" --json
+  ${NAME2} find testing --limit 5
+`.trimStart());
+}
+async function runFind(rootDir, argv) {
+  const args = parseArgs(argv);
+  if (args.help === "true" || args.h === "true") {
+    printFindHelp();
+    process.exit(0);
+  }
+  const query = argv.find((arg, idx) => !arg.startsWith("--") && (idx === 0 || !argv[idx - 1]?.startsWith("--")));
+  if (!query) {
+    console.error(`${red("Error:")} Missing search query.`);
+    console.error(`Usage: ${NAME2} find <query> [options]`);
+    process.exit(1);
+  }
+  const catalogDir = await resolveCatalogDir({
+    rootDir,
+    refresh: args.refresh === "true",
+    offline: args.offline === "true"
+  });
+  const { skills, errors } = await scanSkills(catalogDir);
+  if (errors.length > 0) {
+    for (const err of errors) {
+      console.error(`${yellow("Warning:")} ${err.path}: ${err.error}`);
+    }
+  }
+  let searchPool = skills;
+  if (typeof args.domain === "string" && args.domain !== "true") {
+    const result = filterSkills(skills, {
+      target: "claude-code",
+      domain: args.domain
+    });
+    searchPool = result.matched;
+  }
+  const results = searchSkills(searchPool, query);
+  const limitStr = typeof args.limit === "string" ? args.limit : undefined;
+  const limit = limitStr ? parseInt(limitStr, 10) : DEFAULT_LIMIT;
+  const limited = results.slice(0, limit);
+  if (args.json === "true") {
+    const entries = limited.map((r) => ({
+      name: r.skill.frontmatter.name,
+      description: r.skill.frontmatter.description,
+      domain: r.skill.frontmatter.metadata.domain,
+      subdomain: r.skill.frontmatter.metadata.subdomain ?? null,
+      score: r.score,
+      matchedFields: r.matchedFields
+    }));
+    console.log(JSON.stringify(entries, null, 2));
+    process.exit(0);
+  }
+  if (results.length === 0) {
+    console.log(`No skills found matching ${bold(`"${query}"`)}.`);
+    process.exit(0);
+  }
+  const domainNote = typeof args.domain === "string" && args.domain !== "true" ? ` in ${cyan(args.domain)}` : "";
+  console.log(`
+${bold("Search results")} for ${cyan(`"${query}"`)}${domainNote} ${dim(`(${results.length} found, showing ${limited.length})`)}`);
+  console.log();
+  const headers = ["Name", "Domain", "Score", "Matched", "Description"];
+  const rows = limited.map((r) => [
+    r.skill.frontmatter.name,
+    r.skill.frontmatter.metadata.domain,
+    String(r.score),
+    r.matchedFields.join(", "),
+    r.skill.frontmatter.description
+  ]);
+  console.log(formatTable(headers, rows, { maxColWidth: 45 }));
+  if (results.length > limit) {
+    console.log(`
+${dim(`Showing ${limit} of ${results.length} results. Use --limit to see more.`)}`);
+  }
+}
+if (false) {}
+
+// src/install/installer.ts
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+
+// src/install/presets.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { parse as parseYaml2 } from "yaml";
+
+// src/schemas/presets.ts
+import { z as z6 } from "zod";
+var PresetEntry = z6.object({
+  name: z6.string(),
+  description: z6.string(),
+  items: z6.array(z6.string())
+});
+var PresetsSchema = z6.object({
+  presets: z6.array(PresetEntry)
+});
+
+// src/install/presets.ts
+async function loadPresets(presetsPath) {
+  const content = await readFile6(presetsPath, "utf8");
+  const raw = parseYaml2(content);
+  return PresetsSchema.parse(raw);
+}
+function resolvePreset(config, presetName) {
+  const preset = config.presets.find((entry) => entry.name === presetName);
+  return preset ? preset.items : null;
+}
+
+// src/install/installer.ts
+var generatorMap = {
+  "claude-code": () => new ClaudeCodeGenerator,
+  opencode: () => new OpenCodeGenerator,
+  cursor: () => new CursorGenerator,
+  codex: () => new CodexGenerator,
+  gemini: () => new GeminiGenerator
+};
+async function install(rootDir, rawFilters) {
+  const filters = InstallFilters.parse(rawFilters);
+  const catalogResolveOptions = {
+    rootDir,
+    remote: undefined,
+    refresh: filters.refresh,
+    offline: filters.offline
+  };
+  const catalogDir = await resolveCatalogDir(catalogResolveOptions);
+  const isRemoteCatalog = !catalogDir.startsWith(rootDir);
+  const presetsPath = join13(catalogDir, "metadata", "presets.yaml");
+  const { skills, errors } = await scanSkills(catalogDir);
+  if (errors.length > 0) {
+    console.error(`Scan errors: ${errors.length}`);
+    for (const err of errors) {
+      console.error(`  ${err.path}: ${err.error}`);
+    }
+  }
+  const resolvedFilters = { ...filters };
+  if (filters.preset) {
+    const presets = await loadPresets(presetsPath);
+    const presetSkills = resolvePreset(presets, filters.preset);
+    if (!presetSkills) {
+      throw new Error(`Preset '${filters.preset}' not found in presets.yaml`);
+    }
+    resolvedFilters.skill = [...resolvedFilters.skill ?? [], ...presetSkills];
+  }
+  const filterResult = filterSkills(skills, resolvedFilters);
+  if (filters.dryRun) {
+    return { filterResult, generatorResult: null, dryRun: true };
+  }
+  const createGenerator = generatorMap[filters.target];
+  if (!createGenerator) {
+    throw new Error(`Generator for '${filters.target}' not yet implemented. Available: ${Object.keys(generatorMap).join(", ")}`);
+  }
+  const generator = createGenerator();
+  const outputDir = join13(rootDir, "dist", "targets", filters.target);
+  const pkg = JSON.parse(await readFile7(join13(rootDir, "package.json"), "utf8"));
+  const generatorResult = await generator.generate({
+    skills: filterResult.matched,
+    outputDir,
+    catalogDir,
+    version: pkg.version
+  });
+  await writeManifest(outputDir, {
+    version: 1,
+    target: filters.target,
+    installedAt: new Date().toISOString(),
+    catalogSource: isRemoteCatalog ? "remote" : "local",
+    filters: {
+      domain: filters.domain,
+      subdomain: filters.subdomain,
+      framework: filters.framework,
+      tag: filters.tag,
+      preset: filters.preset,
+      skill: filters.skill
+    },
+    skills: filterResult.matched.map((s) => ({
+      name: s.frontmatter.name,
+      domain: s.frontmatter.metadata.domain,
+      subdomain: s.frontmatter.metadata.subdomain,
+      lastUpdated: s.frontmatter.metadata.lastUpdated
+    }))
+  });
+  return { filterResult, generatorResult, dryRun: false };
+}
+
+// src/cli/install.ts
+async function runInstall(rootDir, argv) {
+  const args = parseArgs(argv);
+  if (!args.target || args.target === "true") {
+    console.error("Usage: agent-toolbox install --target <tool> [options]");
+    console.error("");
+    console.error("Options:");
+    console.error("  --target <tool>       Required. claude-code, opencode, cursor, codex, gemini");
+    console.error("  --domain <domain>     Filter by domain");
+    console.error("  --subdomain <sub>     Filter by subdomain");
+    console.error("  --framework <fw>      Filter by framework");
+    console.error("  --tag <tag>           Filter by tag");
+    console.error("  --preset <name>       Install preset bundle");
+    console.error("  --skill <name>        Install specific skill(s) (repeatable)");
+    console.error("  --dry-run             Preview without installing");
+    console.error("  --interactive         Interactive selection (future)");
+    console.error("  --refresh             Force re-download catalog from remote");
+    console.error("  --offline             Use cached catalog only, no network");
+    process.exit(1);
+  }
+  const targetParse = TargetTool.safeParse(args.target);
+  if (!targetParse.success) {
+    console.error(`Invalid target: ${String(args.target)}. Valid: claude-code, opencode, cursor, codex, gemini`);
+    process.exit(1);
+  }
+  const filters = {
+    target: targetParse.data,
+    domain: typeof args.domain === "string" && args.domain !== "true" ? args.domain : undefined,
+    subdomain: typeof args.subdomain === "string" && args.subdomain !== "true" ? args.subdomain : undefined,
+    framework: typeof args.framework === "string" && args.framework !== "true" ? args.framework : undefined,
+    tag: typeof args.tag === "string" && args.tag !== "true" ? args.tag : undefined,
+    preset: typeof args.preset === "string" && args.preset !== "true" ? args.preset : undefined,
+    skill: Array.isArray(args.skill) ? args.skill : undefined,
+    dryRun: args["dry-run"] === "true",
+    interactive: args.interactive === "true",
+    refresh: args.refresh === "true",
+    offline: args.offline === "true"
+  };
+  const result = await install(rootDir, {
+    target: filters.target,
+    domain: filters.domain,
+    subdomain: filters.subdomain,
+    framework: filters.framework,
+    tag: filters.tag,
+    preset: filters.preset,
+    skill: filters.skill,
+    dryRun: filters.dryRun,
+    interactive: filters.interactive,
+    refresh: filters.refresh,
+    offline: filters.offline
+  });
+  if (result.filterResult.appliedFilters.length > 0) {
+    console.log(`Filters: ${result.filterResult.appliedFilters.join(", ")}`);
+  }
+  console.log(`Matched: ${result.filterResult.matched.length}/${result.filterResult.total} skills`);
+  if (result.dryRun) {
+    console.log(`
+${yellow("[DRY RUN]")} Would install these skills:`);
+    for (const skill of result.filterResult.matched) {
+      console.log(`  - ${skill.frontmatter.name} (${skill.frontmatter.metadata.domain})`);
+    }
+  } else if (result.generatorResult) {
+    console.log(`
+${green("✓")} Installed ${result.generatorResult.skillCount} skills for ${result.generatorResult.target}`);
+    console.log(`  Output: ${result.generatorResult.outputDir}`);
+  }
+}
+if (false) {}
+
+// src/cli/list.ts
+import { join as join14 } from "node:path";
+var NAME3 = "agent-toolbox";
+function printListHelp() {
+  console.log(`
+USAGE
+  ${NAME3} list [options]
+
+DESCRIPTION
+  List skills in the agent-toolbox catalog. By default lists all catalog skills.
+  Use --installed --target <tool> to list skills installed for a specific target.
+
+OPTIONS
+  --domain <d>       Filter by domain
+  --subdomain <s>    Filter by subdomain
+  --framework <fw>   Filter by framework
+  --tag <tag>        Filter by tag
+  --provenance <p>   Filter by provenance (ported|adapted|synthesized|original)
+  --installed        List installed skills (requires --target)
+  --target <tool>    Target tool for --installed mode
+  --json             Output as JSON
+  --count            Show count only
+  --refresh          Force re-download catalog from remote
+  --offline          Use cached catalog only
+
+EXAMPLES
+  ${NAME3} list
+  ${NAME3} list --domain devops
+  ${NAME3} list --provenance ported --count
+  ${NAME3} list --installed --target claude-code
+  ${NAME3} list --json
+`.trimStart());
+}
+async function runList(rootDir, argv) {
+  const args = parseArgs(argv);
+  if (args.help === "true" || args.h === "true") {
+    printListHelp();
+    process.exit(0);
+  }
+  const isInstalled = args.installed === "true";
+  if (isInstalled) {
+    if (!args.target || args.target === "true") {
+      console.error(`${red("Error:")} --installed requires --target <tool>`);
+      process.exit(1);
+    }
+    const targetParse = TargetTool.safeParse(args.target);
+    if (!targetParse.success) {
+      console.error(`${red("Error:")} Invalid target: ${String(args.target)}. Valid: claude-code, opencode, cursor, codex, gemini`);
+      process.exit(1);
+    }
+    const targetDir = join14(rootDir, "dist", "targets", targetParse.data);
+    const manifest = await readManifest(targetDir);
+    if (!manifest) {
+      console.log(`No skills installed for ${bold(targetParse.data)}. Run '${NAME3} install --target ${targetParse.data}' first.`);
+      process.exit(0);
+    }
+    if (args.count === "true") {
+      console.log(manifest.skills.length);
+      process.exit(0);
+    }
+    if (args.json === "true") {
+      console.log(JSON.stringify(manifest.skills, null, 2));
+      process.exit(0);
+    }
+    console.log(`
+${bold("Installed skills")} for ${cyan(targetParse.data)} ${dim(`(${manifest.installedAt})`)}`);
+    console.log();
+    const headers2 = ["Name", "Domain", "Subdomain", "Last Updated"];
+    const rows2 = manifest.skills.map((s) => [
+      s.name,
+      s.domain,
+      s.subdomain ?? "",
+      s.lastUpdated
+    ]);
+    console.log(formatTable(headers2, rows2));
+    console.log(`
+${dim(`Total: ${manifest.skills.length} skills`)}`);
+    return;
+  }
+  const catalogDir = await resolveCatalogDir({
+    rootDir,
+    refresh: args.refresh === "true",
+    offline: args.offline === "true"
+  });
+  const { skills, errors } = await scanSkills(catalogDir);
+  if (errors.length > 0) {
+    for (const err of errors) {
+      console.error(`${yellow("Warning:")} ${err.path}: ${err.error}`);
+    }
+  }
+  const filterResult = filterSkills(skills, {
+    target: "claude-code",
+    domain: typeof args.domain === "string" && args.domain !== "true" ? args.domain : undefined,
+    subdomain: typeof args.subdomain === "string" && args.subdomain !== "true" ? args.subdomain : undefined,
+    framework: typeof args.framework === "string" && args.framework !== "true" ? args.framework : undefined,
+    tag: typeof args.tag === "string" && args.tag !== "true" ? args.tag : undefined
+  });
+  let matched = filterResult.matched;
+  if (typeof args.provenance === "string" && args.provenance !== "true") {
+    const prov = args.provenance.toLowerCase();
+    matched = matched.filter((s) => s.frontmatter.metadata.provenance === prov);
+  }
+  matched.sort((a, b) => a.frontmatter.name.localeCompare(b.frontmatter.name));
+  if (args.count === "true") {
+    console.log(matched.length);
+    process.exit(0);
+  }
+  if (args.json === "true") {
+    const entries = matched.map((s) => ({
+      name: s.frontmatter.name,
+      description: s.frontmatter.description,
+      domain: s.frontmatter.metadata.domain,
+      subdomain: s.frontmatter.metadata.subdomain ?? null,
+      provenance: s.frontmatter.metadata.provenance,
+      author: s.frontmatter.metadata.author,
+      lastUpdated: s.frontmatter.metadata.lastUpdated
+    }));
+    console.log(JSON.stringify(entries, null, 2));
+    process.exit(0);
+  }
+  const appliedFilters = [...filterResult.appliedFilters];
+  if (typeof args.provenance === "string" && args.provenance !== "true") {
+    appliedFilters.push(`provenance=${args.provenance}`);
+  }
+  if (appliedFilters.length > 0) {
+    console.log(`${dim("Filters:")} ${appliedFilters.join(", ")}`);
+  }
+  console.log(`
+${bold("Catalog Skills")} ${dim(`(${matched.length}/${filterResult.total})`)}`);
+  console.log();
+  const headers = ["Name", "Domain", "Provenance", "Description"];
+  const rows = matched.map((s) => [
+    s.frontmatter.name,
+    s.frontmatter.metadata.domain,
+    s.frontmatter.metadata.provenance,
+    s.frontmatter.description
+  ]);
+  console.log(formatTable(headers, rows, { maxColWidth: 50 }));
+  const domainCounts = new Map;
+  for (const s of matched) {
+    const d = s.frontmatter.metadata.domain;
+    domainCounts.set(d, (domainCounts.get(d) ?? 0) + 1);
+  }
+  const domainSummary = [...domainCounts.entries()].sort((a, b) => b[1] - a[1]).map(([d, c]) => `${d} ${dim(`(${c})`)}`).join("  ");
+  console.log(`
+${dim("Domains:")} ${domainSummary}`);
+  console.log(`${dim("Total:")} ${cyan(String(matched.length))} skills`);
+}
+if (false) {}
+
+// src/cli/remove.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readdir as readdir5, rm as rm7 } from "node:fs/promises";
+import { join as join15 } from "node:path";
+var NAME4 = "agent-toolbox";
+function printRemoveHelp() {
+  console.log(`
+USAGE
+  ${NAME4} remove --target <tool> [options]
+
+DESCRIPTION
+  Remove installed skills from a target's generated output directory.
+  Removed skills will be restored on the next 'install' run.
+
+OPTIONS
+  --target <tool>     Required. claude-code | opencode | cursor | codex | gemini
+  --skill <name>      Skill(s) to remove (repeatable)
+  --all               Remove all installed skills for target
+  --dry-run           Preview without removing
+
+EXAMPLES
+  ${NAME4} remove --target claude-code --skill git-master
+  ${NAME4} remove --target gemini --skill docs-writer --skill mcp-builder
+  ${NAME4} remove --target opencode --all
+  ${NAME4} remove --target cursor --all --dry-run
+`.trimStart());
+}
+async function runRemove(rootDir, argv) {
+  const args = parseArgs(argv);
+  if (args.help === "true" || args.h === "true") {
+    printRemoveHelp();
+    process.exit(0);
+  }
+  if (!args.target || args.target === "true") {
+    console.error(`${red("Error:")} --target is required.`);
+    printRemoveHelp();
+    process.exit(1);
+  }
+  const targetParse = TargetTool.safeParse(args.target);
+  if (!targetParse.success) {
+    console.error(`${red("Error:")} Invalid target: ${String(args.target)}. Valid: claude-code, opencode, cursor, codex, gemini`);
+    process.exit(1);
+  }
+  const removeAll = args.all === "true";
+  const skillNames = Array.isArray(args.skill) ? args.skill : [];
+  const dryRun = args["dry-run"] === "true";
+  if (!removeAll && skillNames.length === 0) {
+    console.error(`${red("Error:")} Specify --skill <name> or --all to remove skills.`);
+    process.exit(1);
+  }
+  const target = targetParse.data;
+  const targetDir = join15(rootDir, "dist", "targets", target);
+  const skillsDir = join15(targetDir, "skills");
+  if (!existsSync3(skillsDir)) {
+    console.log(`No skills installed for ${bold(target)}. Nothing to remove.`);
+    process.exit(0);
+  }
+  const entries = await readdir5(skillsDir, { withFileTypes: true });
+  const installedSkills = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  let toRemove;
+  if (removeAll) {
+    toRemove = installedSkills;
+  } else {
+    const installed = new Set(installedSkills.map((n) => n.toLowerCase()));
+    const notFound = skillNames.filter((n) => !installed.has(n.toLowerCase()));
+    if (notFound.length > 0) {
+      console.error(`${red("Error:")} Skills not found in ${target}: ${notFound.join(", ")}`);
+      console.error(`${dim("Installed:")} ${installedSkills.join(", ") || "(none)"}`);
+      process.exit(1);
+    }
+    toRemove = skillNames;
+  }
+  if (toRemove.length === 0) {
+    console.log(`No skills to remove for ${bold(target)}.`);
+    process.exit(0);
+  }
+  if (dryRun) {
+    console.log(`
+${yellow("[DRY RUN]")} Would remove ${toRemove.length} skill(s) from ${cyan(target)}:`);
+    for (const name of toRemove) {
+      console.log(`  - ${name}`);
+    }
+    return;
+  }
+  let removedCount = 0;
+  for (const name of toRemove) {
+    const skillDir = join15(skillsDir, name);
+    if (existsSync3(skillDir)) {
+      await rm7(skillDir, { recursive: true, force: true });
+      removedCount += 1;
+    }
+  }
+  await removeSkillsFromManifest(targetDir, toRemove);
+  console.log(`
+${green("✓")} Removed ${removedCount} skill(s) from ${cyan(target)}`);
+  for (const name of toRemove) {
+    console.log(`  - ${name}`);
+  }
+  console.log(`
+${dim(`Note: Removed skills will be restored on next '${NAME4} install --target ${target}'.`)}`);
+}
+if (false) {}
+
+// src/cli/update.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { readdir as readdir6 } from "node:fs/promises";
+import { join as join16 } from "node:path";
+var NAME5 = "agent-toolbox";
+function printUpdateHelp() {
+  console.log(`
+USAGE
+  ${NAME5} update [options]
+
+DESCRIPTION
+  Update installed skills to the latest catalog versions.
+  Re-installs using the original install filters from the manifest.
+  Without --target, updates all targets that have an install manifest.
+
+OPTIONS
+  --target <tool>     Update specific target only
+  --dry-run           Preview what would be updated
+  --refresh           Force re-download catalog
+  --offline           Use cached catalog only
+
+EXAMPLES
+  ${NAME5} update
+  ${NAME5} update --target claude-code
+  ${NAME5} update --dry-run
+  ${NAME5} update --refresh
+`.trimStart());
+}
+async function discoverTargets2(rootDir) {
+  const targetsDir = join16(rootDir, "dist", "targets");
+  if (!existsSync4(targetsDir)) {
+    return [];
+  }
+  const entries = await readdir6(targetsDir, { withFileTypes: true });
+  const targets = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const manifestPath = join16(targetsDir, entry.name, MANIFEST_FILENAME);
+    if (existsSync4(manifestPath)) {
+      targets.push(entry.name);
+    }
+  }
+  return targets;
+}
+async function runUpdate(rootDir, argv) {
+  const args = parseArgs(argv);
+  if (args.help === "true" || args.h === "true") {
+    printUpdateHelp();
+    process.exit(0);
+  }
+  const dryRun = args["dry-run"] === "true";
+  const refresh = args.refresh === "true";
+  const offline = args.offline === "true";
+  let targets;
+  if (typeof args.target === "string" && args.target !== "true") {
+    const targetParse = TargetTool.safeParse(args.target);
+    if (!targetParse.success) {
+      console.error(`${red("Error:")} Invalid target: ${args.target}. Valid: claude-code, opencode, cursor, codex, gemini`);
+      process.exit(1);
+    }
+    targets = [targetParse.data];
+  } else {
+    targets = await discoverTargets2(rootDir);
+    if (targets.length === 0) {
+      console.log(`No install manifests found. Run '${NAME5} install --target <tool>' first.`);
+      process.exit(0);
+    }
+  }
+  for (const target of targets) {
+    const targetDir = join16(rootDir, "dist", "targets", target);
+    const manifest = await readManifest(targetDir);
+    if (!manifest) {
+      console.error(`${yellow("Warning:")} No manifest for ${target}. Skipping.`);
+      continue;
+    }
+    let checkResult;
+    try {
+      checkResult = await checkInstallStatus(rootDir, target, {
+        refresh,
+        offline
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`${yellow("Warning:")} ${target}: ${message}`);
+      continue;
+    }
+    const { summary } = checkResult;
+    const hasChanges = summary.outdated > 0 || summary.newInCatalog > 0 || summary.removedFromCatalog > 0;
+    if (!hasChanges) {
+      console.log(`${green("✓")} ${bold(target)}: All ${summary.upToDate} skill(s) up to date.`);
+      continue;
+    }
+    console.log(`
+${bold(target)}:`);
+    if (summary.outdated > 0) {
+      const names = checkResult.entries.filter((e) => e.status === "outdated").map((e) => e.name);
+      console.log(`  ${yellow("↑")} ${summary.outdated} outdated: ${names.join(", ")}`);
+    }
+    if (summary.newInCatalog > 0) {
+      const names = checkResult.entries.filter((e) => e.status === "new-in-catalog").map((e) => e.name);
+      console.log(`  ${cyan("+")} ${summary.newInCatalog} new: ${names.join(", ")}`);
+    }
+    if (summary.removedFromCatalog > 0) {
+      const names = checkResult.entries.filter((e) => e.status === "removed-from-catalog").map((e) => e.name);
+      console.log(`  ${red("-")} ${summary.removedFromCatalog} removed from catalog: ${names.join(", ")}`);
+    }
+    if (dryRun) {
+      console.log(`  ${yellow("[DRY RUN]")} Would re-install with original filters.`);
+      continue;
+    }
+    const result = await install(rootDir, {
+      target: manifest.target,
+      domain: manifest.filters.domain,
+      subdomain: manifest.filters.subdomain,
+      framework: manifest.filters.framework,
+      tag: manifest.filters.tag,
+      skill: manifest.filters.skill,
+      preset: manifest.filters.preset,
+      dryRun: false,
+      interactive: false,
+      refresh: true,
+      offline
+    });
+    if (result.generatorResult) {
+      console.log(`  ${green("✓")} Updated ${result.generatorResult.skillCount} skills for ${target}`);
+    }
+  }
+}
+if (false) {}
+
+// src/cli/validate.ts
+import { basename as basename2, dirname as dirname10, resolve as resolve2 } from "node:path";
+
+// src/catalog/validator.ts
+import { readdir as readdir7 } from "node:fs/promises";
+import { basename, dirname as dirname9, join as join17 } from "node:path";
+
+// src/catalog/taxonomy.ts
+import { readFile as readFile8 } from "node:fs/promises";
+import { parse as parseYaml3 } from "yaml";
+
+// src/schemas/taxonomy.ts
+import { z as z7 } from "zod";
+var SubdomainList = z7.array(z7.string());
+var DomainEntry = z7.object({
+  description: z7.string(),
+  subdomains: SubdomainList
+});
+var TaxonomySchema = z7.object({
+  domains: z7.record(z7.string(), DomainEntry)
+});
+
+// src/catalog/taxonomy.ts
+async function loadTaxonomy(taxonomyPath) {
+  let content;
+  try {
+    content = await readFile8(taxonomyPath, "utf8");
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read taxonomy file '${taxonomyPath}': ${reason}`, { cause: error });
+  }
+  let rawTaxonomy;
+  try {
+    rawTaxonomy = parseYaml3(content);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Malformed taxonomy YAML at '${taxonomyPath}': ${reason}`, {
+      cause: error
+    });
+  }
+  try {
+    return TaxonomySchema.parse(rawTaxonomy);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid taxonomy schema at '${taxonomyPath}': ${reason}`, {
+      cause: error
+    });
+  }
+}
+function validateDomain(taxonomy, domain) {
+  return Object.hasOwn(taxonomy.domains, domain);
+}
+function validateSubdomain(taxonomy, domain, subdomain) {
+  const domainEntry = taxonomy.domains[domain];
+  if (!domainEntry) {
+    return false;
+  }
+  return domainEntry.subdomains.includes(subdomain);
+}
+
+// src/catalog/validator.ts
+var HOLOCENE_DATE_REGEX = /^1\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
+var VALID_PROVENANCE = new Set([
+  "ported",
+  "adapted",
+  "synthesized",
+  "original"
+]);
+function skillKeyFromPath(path) {
+  if (path.endsWith("SKILL.md")) {
+    return basename(dirname9(path));
+  }
+  return basename(path);
+}
+async function validateCatalog(catalogDir, taxonomyPath) {
+  const errors = [];
+  const warnings = [];
+  const invalidSkillKeys = new Set;
+  const domainCounts = {};
+  const taxonomy = await loadTaxonomy(taxonomyPath);
+  const scanResult = await scanSkills(catalogDir);
+  for (const scanError of scanResult.errors) {
+    errors.push({
+      path: scanError.path,
+      message: scanError.error
+    });
+    invalidSkillKeys.add(skillKeyFromPath(scanError.path));
+  }
+  for (const skill of scanResult.skills) {
+    const skillPath = join17(catalogDir, "skills", skill.dirName);
+    const metadata = skill.frontmatter.metadata;
+    const description = skill.frontmatter.description;
+    domainCounts[metadata.domain] = (domainCounts[metadata.domain] ?? 0) + 1;
+    if (!skill.frontmatter.name) {
+      errors.push({
+        path: skillPath,
+        field: "name",
+        message: "Missing required field: name"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!skill.frontmatter.description) {
+      errors.push({
+        path: skillPath,
+        field: "description",
+        message: "Missing required field: description"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!skill.frontmatter.license) {
+      errors.push({
+        path: skillPath,
+        field: "license",
+        message: "Missing required field: license"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!metadata.domain) {
+      errors.push({
+        path: skillPath,
+        field: "metadata.domain",
+        message: "Missing required field: metadata.domain"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!metadata.author) {
+      errors.push({
+        path: skillPath,
+        field: "metadata.author",
+        message: "Missing required field: metadata.author"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!metadata.lastUpdated) {
+      errors.push({
+        path: skillPath,
+        field: "metadata.lastUpdated",
+        message: "Missing required field: metadata.lastUpdated"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!metadata.provenance) {
+      errors.push({
+        path: skillPath,
+        field: "metadata.provenance",
+        message: "Missing required field: metadata.provenance"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!validateDomain(taxonomy, metadata.domain)) {
+      errors.push({
+        path: skillPath,
+        field: "metadata.domain",
+        message: `Invalid domain '${metadata.domain}'`
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (metadata.subdomain) {
+      if (!validateSubdomain(taxonomy, metadata.domain, metadata.subdomain)) {
+        errors.push({
+          path: skillPath,
+          field: "metadata.subdomain",
+          message: `Invalid subdomain '${metadata.subdomain}' for domain '${metadata.domain}'`
+        });
+        invalidSkillKeys.add(skill.dirName);
+      }
+    } else {
+      warnings.push({
+        path: skillPath,
+        field: "metadata.subdomain",
+        message: "Missing optional field: metadata.subdomain"
+      });
+    }
+    if (!VALID_PROVENANCE.has(metadata.provenance)) {
+      errors.push({
+        path: skillPath,
+        field: "metadata.provenance",
+        message: `Invalid provenance '${metadata.provenance}'`
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!skill.hasNotice) {
+      errors.push({
+        path: skillPath,
+        field: "NOTICE.md",
+        message: "Missing required file: NOTICE.md"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (skill.dirName !== skill.frontmatter.name) {
+      errors.push({
+        path: skillPath,
+        field: "name",
+        message: `Skill directory '${skill.dirName}' does not match name '${skill.frontmatter.name}'`
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (!HOLOCENE_DATE_REGEX.test(metadata.lastUpdated)) {
+      errors.push({
+        path: skillPath,
+        field: "metadata.lastUpdated",
+        message: `Invalid Holocene date '${metadata.lastUpdated}'`
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (description.length > 1024) {
+      errors.push({
+        path: skillPath,
+        field: "description",
+        message: "Description exceeds 1024 characters"
+      });
+      invalidSkillKeys.add(skill.dirName);
+    }
+    if (description.trim().length === 0) {
+      warnings.push({
+        path: skillPath,
+        field: "description",
+        message: "Description is empty"
+      });
+    }
+    if (metadata.tags === undefined) {
+      warnings.push({
+        path: skillPath,
+        field: "metadata.tags",
+        message: "Missing optional field: metadata.tags"
+      });
+    }
+    if (metadata.frameworks === undefined) {
+      warnings.push({
+        path: skillPath,
+        field: "metadata.frameworks",
+        message: "Missing optional field: metadata.frameworks"
+      });
+    }
+  }
+  let totalSkills;
+  try {
+    const skillRoot = join17(catalogDir, "skills");
+    const entries = await readdir7(skillRoot, { withFileTypes: true });
+    totalSkills = entries.filter((entry) => entry.isDirectory()).length;
+  } catch {
+    totalSkills = scanResult.skills.length;
+  }
+  const invalidSkills = invalidSkillKeys.size;
+  const validSkills = Math.max(totalSkills - invalidSkills, 0);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    stats: {
+      totalSkills,
+      validSkills,
+      invalidSkills,
+      domains: Object.fromEntries(Object.entries(domainCounts).sort(([a], [b]) => a.localeCompare(b)))
+    }
+  };
+}
+
+// src/cli/validate.ts
+function skillKeyFromPath2(path) {
+  if (path.endsWith("SKILL.md")) {
+    return basename2(dirname10(path));
+  }
+  return basename2(path);
+}
+async function runValidate(rootDir) {
+  const catalogDir = resolve2(rootDir, "catalog");
+  const taxonomyPath = resolve2(catalogDir, "metadata/taxonomy.yaml");
+  console.log(`Validating catalog...
+`);
+  const result = await validateCatalog(catalogDir, taxonomyPath);
+  const scan = await scanSkills(catalogDir);
+  const invalidMessages = new Map;
+  for (const error of result.errors) {
+    const key = skillKeyFromPath2(error.path);
+    if (!invalidMessages.has(key)) {
+      invalidMessages.set(key, error.message);
+    }
+  }
+  const parsedSkillNames = new Set(scan.skills.map((skill) => skill.dirName));
+  for (const skill of [...scan.skills].sort((a, b) => a.frontmatter.name.localeCompare(b.frontmatter.name))) {
+    const failure = invalidMessages.get(skill.dirName);
+    if (failure) {
+      console.log(`${red("✗")} ${skill.frontmatter.name}: ${failure}`);
+    } else {
+      console.log(`${green("✓")} ${skill.frontmatter.name} (${skill.frontmatter.metadata.domain})`);
+    }
+  }
+  for (const [skillName, message] of [...invalidMessages.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    if (!parsedSkillNames.has(skillName)) {
+      console.log(`${red("✗")} ${skillName}: ${message}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log(`
+Warnings:`);
+    for (const warning of result.warnings) {
+      const fieldSuffix = warning.field ? ` (${warning.field})` : "";
+      console.log(`  ${yellow("!")} ${skillKeyFromPath2(warning.path)}${fieldSuffix}: ${warning.message}`);
+    }
+  }
+  console.log(`
+Results:`);
+  console.log(`  Total: ${result.stats.totalSkills}`);
+  console.log(`  Valid: ${result.stats.validSkills}`);
+  console.log(`  Invalid: ${result.stats.invalidSkills}`);
+  console.log(`
+  Domains:`);
+  for (const [domain, count] of Object.entries(result.stats.domains).sort(([a], [b]) => a.localeCompare(b))) {
+    console.log(`    ${domain}: ${count}`);
+  }
+  process.exit(result.valid ? 0 : 1);
+}
+if (false) {}
+
+// src/cli/main.ts
+var NAME6 = "agent-toolbox";
+async function getVersion(rootDir) {
+  try {
+    const pkg = JSON.parse(await readFile9(resolve3(rootDir, "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function printHelp() {
+  console.log(`
+${NAME6} — Cross-tool distribution system for agent skills
+
+USAGE
+  ${NAME6} <command> [options]
+
+COMMANDS
+  install       Install skills to a target tool
+  list          List skills in the catalog
+  find          Search catalog skills by keyword
+  remove        Remove installed skills from a target
+  check         Check for outdated installed skills
+  update        Update installed skills to latest catalog
+  build         Build target artifacts
+  build-index   Generate skill-index.json and skill-index.toon
+  validate      Validate catalog against taxonomy
+
+  --help, -h    Show help
+  --version, -v Show version
+
+BUILD OPTIONS
+  --target <tool>   claude-code | opencode | cursor | codex | gemini | all
+
+INSTALL OPTIONS
+  --target <tool>   Required. claude-code | opencode | cursor | codex | gemini
+  --domain <d>      Filter by domain
+  --subdomain <s>   Filter by subdomain
+  --framework <fw>  Filter by framework
+  --tag <tag>       Filter by tag
+  --preset <name>   Install preset bundle
+  --skill <name>    Specific skill(s), repeatable
+  --dry-run         Preview without installing
+  --interactive     Interactive selection (future)
+  --refresh           Force re-download catalog from remote
+  --offline           Use cached catalog only, no network
+
+EXAMPLES
+  ${NAME6} install --target opencode --domain devops
+  ${NAME6} install --target claude-code --dry-run
+  ${NAME6} list
+  ${NAME6} list --domain devops
+  ${NAME6} find git
+  ${NAME6} check --target claude-code
+  ${NAME6} update --target opencode
+  ${NAME6} remove --target cursor --skill git-master
+  ${NAME6} build --target all
+  ${NAME6} build --target opencode
+  ${NAME6} validate
+  ${NAME6} build-index
+`.trimStart());
+}
+function printBuildHelp() {
+  console.log(`
+USAGE
+  ${NAME6} build --target <tool>
+
+TARGETS
+  claude-code   Generate Claude Code plugin artifacts
+  opencode      Generate OpenCode plugin + skills
+  cursor        Generate Cursor plugin artifacts
+  codex         Generate Codex skill directories
+  gemini        Generate Gemini CLI extension
+  all           Build all targets sequentially
+
+EXAMPLES
+  ${NAME6} build --target opencode
+  ${NAME6} build --target all
+`.trimStart());
+}
+async function main() {
+  const rootDir = resolve3(dirname11(fileURLToPath(import.meta.url)), "../..");
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+  if (command === "--version" || command === "-v") {
+    const version = await getVersion(rootDir);
+    console.log(version);
+    process.exit(0);
+  }
+  switch (command) {
+    case "validate":
+      await runValidate(rootDir);
+      break;
+    case "build-index":
+      await runBuildIndex(rootDir);
+      break;
+    case "build": {
+      const subArgs = args.slice(1);
+      if (subArgs[0] === "index") {
+        await runBuildIndex(rootDir);
+        break;
+      }
+      if (subArgs[0] === "--help" || subArgs[0] === "-h") {
+        printBuildHelp();
+        process.exit(0);
+      }
+      const targetIdx = subArgs.indexOf("--target");
+      const target = targetIdx >= 0 ? subArgs[targetIdx + 1] : undefined;
+      if (!target) {
+        printBuildHelp();
+        process.exit(1);
+      }
+      if (target === "all") {
+        await runBuildAll(rootDir);
+      } else {
+        await runBuildTarget(rootDir, target);
+      }
+      break;
+    }
+    case "install":
+      await runInstall(rootDir, args.slice(1));
+      break;
+    case "list":
+    case "ls":
+      await runList(rootDir, args.slice(1));
+      break;
+    case "find":
+    case "search":
+      await runFind(rootDir, args.slice(1));
+      break;
+    case "remove":
+    case "rm":
+      await runRemove(rootDir, args.slice(1));
+      break;
+    case "check":
+      await runCheck(rootDir, args.slice(1));
+      break;
+    case "update":
+      await runUpdate(rootDir, args.slice(1));
+      break;
+    default:
+      console.error(`${red("Error:")} Unknown command '${command}'`);
+      console.error(`Run '${NAME6} --help' for available commands.`);
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  const reason = error instanceof Error ? error.message : String(error);
+  console.error(`${red("Error:")} ${reason}`);
+  process.exit(1);
+});