agentspec-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1786 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/info.ts
+import { Command } from "commander";
+import pc3 from "picocolors";
+
+// src/lib/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var AGENTSPEC_HOME = process.env["AGENTSPEC_HOME"] ?? join(homedir(), ".agentspec");
+var AGENTSPEC_STORE = join(AGENTSPEC_HOME, "store");
+var AGENTSPEC_BACKUPS = join(AGENTSPEC_HOME, "backups");
+var AGENTSPEC_PROJECTS = join(AGENTSPEC_HOME, "projects");
+var AGENTSPEC_GLOBAL_STATE = join(AGENTSPEC_HOME, "global-state.json");
+var API_BASE = process.env["AGENTSPEC_API_URL"] ?? "https://api.agentspec.sh";
+var FRAMEWORK_FILE_PATHS = {
+  Codex: "codex.toml",
+  OpenCode: "opencode.json",
+  ClaudeCode: ".claude/settings.json"
+};
+var SKILL_FRAMEWORK_DIRS = {
+  ClaudeCode: ".claude/skills",
+  Codex: ".codex/skills",
+  OpenCode: ".opencode/skills",
+  Windsurf: ".windsurf/skills",
+  Universal: "skills"
+};
+var RULE_FILE_PATHS = {
+  cursorrules: ".cursorrules",
+  "cursor-rules": ".cursor/rules/",
+  "claude-md": "CLAUDE.md",
+  "agents-md": "AGENTS.md",
+  "copilot-instructions": ".github/copilot-instructions.md",
+  windsurfrules: ".windsurfrules",
+  "windsurf-rules": ".windsurf/rules/",
+  clinerules: ".clinerules",
+  "gemini-md": "GEMINI.md"
+};
+var GLOBAL_FRAMEWORK_FILE_PATHS = {
+  ClaudeCode: join(homedir(), ".claude", "settings.json"),
+  OpenCode: join(homedir(), ".config", "opencode", "opencode.json"),
+  Codex: join(homedir(), ".codex", "codex.toml")
+};
+var GLOBAL_SKILL_FRAMEWORK_DIRS = {
+  ClaudeCode: join(homedir(), ".claude", "skills"),
+  Codex: join(homedir(), ".codex", "skills"),
+  OpenCode: join(homedir(), ".opencode", "skills")
+};
+var RULE_FILE_LABELS = {
+  cursorrules: "Cursor (.cursorrules)",
+  "cursor-rules": "Cursor (.cursor/rules/)",
+  "claude-md": "Claude Code (CLAUDE.md)",
+  "agents-md": "Codex / Claude Code (AGENTS.md)",
+  "copilot-instructions": "GitHub Copilot (.github/copilot-instructions.md)",
+  windsurfrules: "Windsurf (.windsurfrules)",
+  "windsurf-rules": "Windsurf (.windsurf/rules/)",
+  clinerules: "Cline (.clinerules)",
+  "gemini-md": "Gemini (GEMINI.md)"
+};
+var SKILL_FRAMEWORK_LABELS = {
+  ClaudeCode: "Claude Code (.claude/skills/)",
+  Codex: "Codex (.codex/skills/)",
+  OpenCode: "OpenCode (.opencode/skills/)",
+  Windsurf: "Windsurf (.windsurf/skills/)",
+  Universal: "Universal (skills/)"
+};
+var GLOBAL_SUPPORTED_FRAMEWORKS = /* @__PURE__ */ new Set(["ClaudeCode", "OpenCode", "Codex"]);
+
+// src/lib/api.ts
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+async function apiFetch(path) {
+  const url = `${API_BASE}${path}`;
+  const res = await fetch(url, {
+    headers: { "User-Agent": "agentspec-cli/0.1.0", Accept: "application/json" }
+  });
+  if (!res.ok) {
+    let message = `HTTP ${res.status}`;
+    try {
+      const body = await res.json();
+      if (body.message) message = body.message;
+    } catch {
+    }
+    throw new ApiError(res.status, message);
+  }
+  return res.json();
+}
+async function resolve(id) {
+  const { data } = await apiFetch(`/api/resolve/${id}`);
+  return data;
+}
+async function getConfig(id) {
+  const { data } = await apiFetch(`/api/templates/${id}`);
+  return data;
+}
+async function getSkill(id) {
+  const { data } = await apiFetch(`/api/skills/${id}`);
+  return data;
+}
+async function getRule(id) {
+  const { data } = await apiFetch(`/api/rules/${id}`);
+  return data;
+}
+async function getSpec(id) {
+  const { data } = await apiFetch(`/api/specs/${id}`);
+  return data;
+}
+async function getPlugin(id) {
+  const { data } = await apiFetch(`/api/plugins/${id}`);
+  return data;
+}
+async function listItems(type, opts = {}) {
+  const endpoint = type === "configs" ? "templates" : type;
+  const params = new URLSearchParams();
+  if (opts.sort) params.set("sort", opts.sort);
+  if (opts.framework) params.set("framework", opts.framework);
+  if (opts.fileType) params.set("fileType", opts.fileType);
+  if (opts.limit != null) params.set("limit", String(opts.limit));
+  if (opts.offset != null) params.set("offset", String(opts.offset));
+  const qs = params.toString();
+  const raw = await apiFetch(
+    `/api/${endpoint}${qs ? `?${qs}` : ""}`
+  );
+  const data = raw.data.map((item) => ({
+    ...item,
+    title: item.title ?? item.name ?? ""
+  }));
+  return { data, total: raw.total };
+}
+async function search(query, opts = {}) {
+  const params = new URLSearchParams({ q: query });
+  if (opts.type) params.set("type", opts.type);
+  if (opts.limit != null) params.set("limit", String(opts.limit));
+  return apiFetch(`/api/search?${params.toString()}`);
+}
+function trackInstall(type, id) {
+  const pathMap = { config: "templates", skill: "skills", rule: "rules", spec: "specs" };
+  const path = `/${pathMap[type]}/${id}/install`;
+  fetch(`${API_BASE}${path}`, { headers: { "User-Agent": "agentspec-cli/0.1.0" } }).catch(() => {
+  });
+}
+
+// src/lib/prompts.ts
+import { confirm, isCancel, select, spinner as clackSpinner } from "@clack/prompts";
+import pc from "picocolors";
+var IS_TTY = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+function assertNotCancel(value) {
+  if (isCancel(value)) {
+    console.log(pc.dim("\nCancelled."));
+    process.exit(0);
+  }
+  return value;
+}
+async function promptScope(opts) {
+  if (!IS_TTY) return "project";
+  const result = await select({
+    message: "Install to:",
+    options: [
+      { value: "project", label: "This project", hint: opts.projectLabel },
+      { value: "global", label: "Global (symlink)", hint: opts.globalLabel }
+    ]
+  });
+  return assertNotCancel(result);
+}
+async function promptConfirm(message, initialValue = true) {
+  if (!IS_TTY) {
+    console.log(
+      pc.dim(
+        `  ${message} ${initialValue ? "[Y/n]" : "[y/N]"} \u2192 ${initialValue ? "yes" : "no"} (non-interactive)`
+      )
+    );
+    return initialValue;
+  }
+  const result = await confirm({ message, initialValue });
+  return assertNotCancel(result);
+}
+async function promptFramework(frameworks, labels) {
+  if (!IS_TTY) return frameworks[0];
+  const result = await select({
+    message: "Select target framework:",
+    options: frameworks.map((fw) => ({ value: fw, label: labels[fw] ?? fw }))
+  });
+  return assertNotCancel(result);
+}
+async function promptFileType(fileTypes, labels) {
+  if (!IS_TTY) return fileTypes[0];
+  const result = await select({
+    message: "Select target file type:",
+    options: fileTypes.map((ft) => ({ value: ft, label: labels[ft] ?? ft }))
+  });
+  return assertNotCancel(result);
+}
+async function promptUninstallAction(targetPath) {
+  if (!IS_TTY) return "keep";
+  const result = await select({
+    message: `${pc.yellow(targetPath)} was installed as a copy and may have been modified.`,
+    options: [
+      {
+        value: "keep",
+        label: "Keep the file",
+        hint: "just stop tracking it with agentspec"
+      },
+      { value: "delete", label: "Delete the file", hint: "removes it from disk" }
+    ]
+  });
+  return assertNotCancel(result);
+}
+function createSpinner() {
+  if (!IS_TTY) {
+    return {
+      start(msg) {
+        process.stdout.write(`${msg}...
+`);
+      },
+      stop(msg) {
+        process.stdout.write(`\u2713 ${msg}
+`);
+      },
+      fail(msg) {
+        process.stderr.write(`\u2717 ${msg}
+`);
+      }
+    };
+  }
+  const s = clackSpinner();
+  return {
+    start(msg) {
+      s.start(msg);
+    },
+    stop(msg) {
+      s.stop(msg);
+    },
+    fail(msg) {
+      s.stop(pc.red(`\u2717 ${msg}`));
+    }
+  };
+}
+
+// src/lib/ui.ts
+import pc2 from "picocolors";
+var log = {
+  info: (msg) => console.log(msg),
+  success: (msg) => console.log(`${pc2.green("\u2713")} ${msg}`),
+  warn: (msg) => console.warn(`${pc2.yellow("!")} ${msg}`),
+  error: (msg) => console.error(`${pc2.red("\u2717")} ${msg}`),
+  step: (msg) => console.log(`  ${pc2.dim("\u2192")} ${msg}`),
+  tip: (msg) => console.log(pc2.dim(`  ${msg}`))
+};
+function printTable(headers, rows) {
+  if (rows.length === 0) return;
+  const colWidths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => stripAnsi(r[i] ?? "").length));
+    return Math.max(h.length, maxRow);
+  });
+  const divider2 = colWidths.map((w) => "\u2500".repeat(w + 2)).join("\u253C");
+  const fmt = (cells, bold = false) => cells.map((c, i) => {
+    const visible = stripAnsi(c);
+    const padded = c + " ".repeat(Math.max(0, (colWidths[i] ?? 0) - visible.length));
+    return bold ? pc2.bold(padded) : padded;
+  }).join("  ");
+  console.log(fmt(headers, true));
+  console.log(pc2.dim(divider2));
+  for (const row of rows) {
+    console.log(fmt(row));
+  }
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+function formatDate(dateStr) {
+  const date = new Date(dateStr);
+  const now = Date.now();
+  const diffMs = now - date.getTime();
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffDays === 0) return "today";
+  if (diffDays === 1) return "yesterday";
+  if (diffDays < 30) return `${diffDays}d ago`;
+  if (diffDays < 365) return `${Math.floor(diffDays / 30)}mo ago`;
+  return `${Math.floor(diffDays / 365)}y ago`;
+}
+function formatScore(up, down) {
+  const net = up - down;
+  const sign = net >= 0 ? "+" : "";
+  return `${sign}${net}`;
+}
+function typeLabel(type) {
+  const labels = {
+    config: "config",
+    skill: "skill",
+    rule: "rule",
+    spec: "spec",
+    plugin: "plugin"
+  };
+  return labels[type] ?? type;
+}
+function typeBadge(type) {
+  const colors = {
+    config: pc2.blue,
+    skill: pc2.magenta,
+    rule: pc2.yellow,
+    spec: pc2.cyan,
+    plugin: pc2.green
+  };
+  const color = colors[type] ?? pc2.white;
+  return color(typeLabel(type));
+}
+
+// src/commands/info.ts
+var infoCommand = new Command("info").description("Show details for a config, skill, rule, spec, or plugin").argument("<id>", "Content UUID").option("--type <type>", "Skip auto-detect: config|skill|rule|spec|plugin").action(async (id, opts) => {
+  let contentType = opts.type;
+  if (!contentType) {
+    const spinner = createSpinner();
+    spinner.start(`Resolving ${pc3.cyan(id)}`);
+    try {
+      const resolved = await resolve(id);
+      spinner.stop(`${pc3.bold(resolved.title)} (${pc3.dim(resolved.type)})`);
+      contentType = resolved.type;
+    } catch (err) {
+      spinner.fail(
+        `Could not resolve ${id}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  try {
+    switch (contentType) {
+      case "config":
+        await showConfig(id);
+        break;
+      case "skill":
+        await showSkill(id);
+        break;
+      case "rule":
+        await showRule(id);
+        break;
+      case "spec":
+        await showSpec(id);
+        break;
+      case "plugin":
+        await showPlugin(id);
+        break;
+      default:
+        log.error(`Unknown content type: ${contentType}`);
+        process.exit(1);
+    }
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+function field(label, value) {
+  if (value == null || value === "") return;
+  const pad = 14;
+  console.log(`  ${pc3.dim(label.padEnd(pad))} ${value}`);
+}
+function divider(title) {
+  if (title) {
+    console.log(`
+${pc3.bold(title)}`);
+    console.log(pc3.dim("\u2500".repeat(title.length)));
+  } else {
+    console.log(pc3.dim("\u2500".repeat(48)));
+  }
+}
+function previewContent(content, lines = 12) {
+  const preview = content.split("\n").slice(0, lines).join("\n");
+  const hasMore = content.split("\n").length > lines;
+  for (const line of preview.split("\n")) {
+    console.log(`  ${pc3.dim(line)}`);
+  }
+  if (hasMore) {
+    console.log(pc3.dim("  [...]"));
+  }
+}
+async function showConfig(id) {
+  const spinner = createSpinner();
+  spinner.start("Fetching config...");
+  const config = await getConfig(id);
+  spinner.stop(pc3.bold(config.title));
+  divider();
+  field("Type", "config");
+  if (config.slug) field("Slug", pc3.cyan(config.slug));
+  field("Framework", config.framework);
+  field("Format", config.format);
+  field("Installs to", FRAMEWORK_FILE_PATHS[config.framework]);
+  field("Author", config.author.name);
+  field("Votes", formatScore(config.upvoteCount, config.downvoteCount));
+  field("Installs", String(config.installCount));
+  field("Created", formatDate(config.createdAt));
+  if (config.description) {
+    console.log();
+    console.log(`  ${config.description}`);
+  }
+  divider("Preview");
+  previewContent(config.configuration);
+  console.log();
+  const configRef = config.slug ?? id;
+  log.tip(`Install with: agentspec install ${configRef}`);
+}
+async function showSkill(id) {
+  const spinner = createSpinner();
+  spinner.start("Fetching skill...");
+  const skill = await getSkill(id);
+  spinner.stop(pc3.bold(skill.name));
+  const dirsPreview = skill.frameworks.map((fw) => `${fw} \u2192 ${SKILL_FRAMEWORK_DIRS[fw] ?? "?"}/${skill.name}/SKILL.md`).join(", ");
+  divider();
+  field("Type", "skill");
+  if (skill.slug) field("Slug", pc3.cyan(skill.slug));
+  field("Frameworks", skill.frameworks.join(", "));
+  field("Installs to", dirsPreview);
+  field("Author", skill.author.name);
+  field("Votes", formatScore(skill.upvoteCount, skill.downvoteCount));
+  field("Installs", String(skill.installCount + skill.externalInstalls));
+  field("Created", formatDate(skill.createdAt));
+  if (skill.description) {
+    console.log();
+    console.log(`  ${skill.description}`);
+  }
+  divider("Preview");
+  previewContent(skill.skillContent);
+  console.log();
+  const skillRef = skill.slug ?? id;
+  log.tip(`Install with: agentspec install ${skillRef}`);
+  if (skill.frameworks.length > 1) {
+    log.tip(`Pick framework: agentspec install ${skillRef} --framework <name>`);
+  }
+}
+async function showRule(id) {
+  const spinner = createSpinner();
+  spinner.start("Fetching rule...");
+  const rule = await getRule(id);
+  spinner.stop(pc3.bold(rule.title));
+  const pathsPreview = rule.fileTypes.map((ft) => `${ft} \u2192 ${RULE_FILE_PATHS[ft] ?? "?"}`).join(", ");
+  divider();
+  field("Type", "rule");
+  if (rule.slug) field("Slug", pc3.cyan(rule.slug));
+  field("File types", rule.fileTypes.join(", "));
+  field("Installs to", pathsPreview);
+  field("Author", rule.author.name);
+  field("Votes", formatScore(rule.upvoteCount, rule.downvoteCount));
+  field("Installs", String(rule.installCount));
+  field("Created", formatDate(rule.createdAt));
+  if (rule.description) {
+    console.log();
+    console.log(`  ${rule.description}`);
+  }
+  divider("Preview");
+  previewContent(rule.content);
+  console.log();
+  const ruleRef = rule.slug ?? id;
+  log.tip(`Install with: agentspec install ${ruleRef}`);
+  if (rule.fileTypes.length > 1) {
+    log.tip(`Pick file type: agentspec install ${ruleRef} --file-type <type>`);
+  }
+}
+async function showSpec(id) {
+  const spinner = createSpinner();
+  spinner.start("Fetching spec...");
+  const spec = await getSpec(id);
+  spinner.stop(pc3.bold(spec.title));
+  divider();
+  field("Type", "spec");
+  if (spec.slug) field("Slug", pc3.cyan(spec.slug));
+  field("Framework", spec.framework);
+  field("Items", String(spec.items.length));
+  field("Author", spec.author.name);
+  field("Votes", formatScore(spec.upvoteCount, spec.downvoteCount));
+  field("Installs", String(spec.installCount));
+  field("Created", formatDate(spec.createdAt));
+  if (spec.description) {
+    console.log();
+    console.log(`  ${spec.description}`);
+  }
+  if (spec.items.length > 0) {
+    divider("Included items");
+    for (const item of spec.items) {
+      const data = item.data;
+      const itemTitle = data.title ?? data.name ?? item.data.id;
+      console.log(`  ${pc3.dim(`[${item.targetType}]`)} ${itemTitle}`);
+    }
+  }
+  console.log();
+  const specRef = spec.slug ?? id;
+  log.tip(`Install everything: agentspec install ${specRef}`);
+}
+async function showPlugin(id) {
+  const spinner = createSpinner();
+  spinner.start("Fetching plugin...");
+  const plugin = await getPlugin(id);
+  spinner.stop(pc3.bold(plugin.name));
+  divider();
+  field("Type", "plugin (MCP server)");
+  field("Slug", plugin.slug);
+  field("Frameworks", plugin.frameworks.join(", "));
+  field("Tags", plugin.tags.join(", "));
+  field("Author", plugin.author.name);
+  field("Votes", formatScore(plugin.upvoteCount, plugin.downvoteCount));
+  field("Repo", plugin.repoUrl ?? "\u2014");
+  field("Homepage", plugin.homepageUrl ?? "\u2014");
+  field("Created", formatDate(plugin.createdAt));
+  if (plugin.description) {
+    console.log();
+    console.log(`  ${plugin.description}`);
+  }
+  if (plugin.installation) {
+    divider("Installation");
+    previewContent(plugin.installation);
+  }
+  console.log();
+  log.tip(`View full details: https://agentspec.sh/plugins/${plugin.slug}`);
+}
+
+// src/commands/install.ts
+import { intro, outro } from "@clack/prompts";
+import { Command as Command2 } from "commander";
+import pc4 from "picocolors";
+
+// src/lib/installer.ts
+import { copyFile, mkdir as mkdir2, readlink, rm as rm2, stat as stat2, symlink, unlink, writeFile as writeFile2 } from "fs/promises";
+import { dirname, join as join3, resolve as resolve2 } from "path";
+
+// src/lib/store.ts
+import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+function storeDir(slug) {
+  return join2(AGENTSPEC_STORE, slug);
+}
+function storeContentPath(slug) {
+  return join2(storeDir(slug), "content");
+}
+function storeMetaPath(slug) {
+  return join2(storeDir(slug), "meta.json");
+}
+async function exists(p) {
+  return stat(p).then(
+    () => true,
+    () => false
+  );
+}
+async function hasStoreItem(slug) {
+  return exists(storeContentPath(slug));
+}
+async function storeItem(slug, content, meta) {
+  const dir = storeDir(slug);
+  await mkdir(dir, { recursive: true });
+  await Promise.all([
+    writeFile(storeContentPath(slug), content, "utf8"),
+    writeFile(storeMetaPath(slug), JSON.stringify(meta, null, 2), "utf8")
+  ]);
+}
+async function readStoreMeta(slug) {
+  const raw = await readFile(storeMetaPath(slug), "utf8");
+  return JSON.parse(raw);
+}
+async function listStoreItems() {
+  const { readdir } = await import("fs/promises");
+  if (!await exists(AGENTSPEC_STORE)) return [];
+  const entries = await readdir(AGENTSPEC_STORE, { withFileTypes: true });
+  const metas = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const metaPath = join2(AGENTSPEC_STORE, entry.name, "meta.json");
+    if (await exists(metaPath)) {
+      try {
+        const raw = await readFile(metaPath, "utf8");
+        metas.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+  }
+  return metas;
+}
+function storeContentAbsPath(slug) {
+  return storeContentPath(slug);
+}
+
+// src/lib/installer.ts
+async function fileExists(p) {
+  return stat2(p).then(
+    () => true,
+    () => false
+  );
+}
+async function isSymlink(p) {
+  return readlink(p).then(
+    () => true,
+    () => false
+  );
+}
+function globalBackupPath(targetAbsPath) {
+  const flat = targetAbsPath.replace(/^\//, "").replace(/\//g, "__");
+  return join3(AGENTSPEC_BACKUPS, flat);
+}
+async function ensureParentDir(absPath) {
+  await mkdir2(dirname(absPath), { recursive: true });
+}
+async function installToProject(dest, content, opts = {}) {
+  const absPath = resolve2(process.cwd(), dest);
+  let backupPath = null;
+  const exists2 = await fileExists(absPath);
+  const alreadyLink = exists2 && await isSymlink(absPath);
+  if (!opts.dryRun) {
+    await ensureParentDir(absPath);
+    if (exists2 && !alreadyLink) {
+      backupPath = `${absPath}.agentspec-orig`;
+      await copyFile(absPath, backupPath);
+    }
+    if (alreadyLink) {
+      await unlink(absPath);
+    }
+    await writeFile2(absPath, content, "utf8");
+  }
+  return { targetPath: absPath, backupPath, scope: "project", mode: "copy" };
+}
+async function installToProjectDir(destDir, title, content, opts = {}) {
+  const safeName = title.replace(/[^a-z0-9_-]/gi, "-").replace(/-+/g, "-").toLowerCase();
+  const dest = `${destDir.replace(/\/$/, "")}/${safeName}.md`;
+  return installToProject(dest, content, opts);
+}
+async function installToGlobal(slug, globalDest, opts = {}) {
+  const storePath = storeContentAbsPath(slug);
+  let backupPath = null;
+  const exists2 = await fileExists(globalDest);
+  const alreadyLink = exists2 && await isSymlink(globalDest);
+  if (!opts.dryRun) {
+    await ensureParentDir(globalDest);
+    if (exists2 && !alreadyLink) {
+      backupPath = globalBackupPath(globalDest);
+      await mkdir2(dirname(backupPath), { recursive: true });
+      await copyFile(globalDest, backupPath);
+      await unlink(globalDest);
+    } else if (alreadyLink) {
+      await unlink(globalDest);
+    }
+    await symlink(storePath, globalDest);
+  } else {
+    if (exists2 && !alreadyLink) {
+      backupPath = globalBackupPath(globalDest);
+    }
+  }
+  return { targetPath: globalDest, backupPath, scope: "global", mode: "symlink" };
+}
+async function uninstallFromProject(targetPath, action) {
+  if (action === "delete" && await fileExists(targetPath)) {
+    await rm2(targetPath, { force: true });
+  }
+}
+async function uninstallFromGlobal(targetPath, backupPath) {
+  const isLink = await isSymlink(targetPath);
+  if (isLink) {
+    await unlink(targetPath);
+  }
+  if (backupPath && await fileExists(backupPath)) {
+    await ensureParentDir(targetPath);
+    await copyFile(backupPath, targetPath);
+    await rm2(backupPath, { force: true });
+  }
+}
+
+// src/lib/manifest.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+function projectHash(dir) {
+  return createHash("sha256").update(dir).digest("hex").slice(0, 12);
+}
+function projectStatePath(dir) {
+  return join4(AGENTSPEC_PROJECTS, projectHash(dir), "state.json");
+}
+async function readJson(path, defaultValue) {
+  try {
+    const raw = await readFile2(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return defaultValue;
+  }
+}
+async function writeJson(path, data) {
+  await mkdir3(dirname2(path), { recursive: true });
+  await writeFile3(path, JSON.stringify(data, null, 2), "utf8");
+}
+var defaultGlobalState = () => ({ version: 1, activeSpec: null, links: {} });
+var defaultProjectState = (dir) => ({
+  version: 1,
+  projectDir: dir,
+  activeSpec: null,
+  links: {}
+});
+async function readGlobalState() {
+  return readJson(AGENTSPEC_GLOBAL_STATE, defaultGlobalState());
+}
+async function writeGlobalState(state) {
+  await writeJson(AGENTSPEC_GLOBAL_STATE, state);
+}
+async function readProjectState(projectDir = process.cwd()) {
+  return readJson(projectStatePath(projectDir), defaultProjectState(projectDir));
+}
+async function writeProjectState(state, projectDir = process.cwd()) {
+  await writeJson(projectStatePath(projectDir), state);
+}
+async function registerLink(scope, slug, record, projectDir = process.cwd()) {
+  if (scope === "global") {
+    const state = await readGlobalState();
+    state.links[slug] = record;
+    await writeGlobalState(state);
+  } else {
+    const state = await readProjectState(projectDir);
+    state.links[slug] = record;
+    await writeProjectState(state, projectDir);
+  }
+}
+async function unregisterLink(scope, slug, projectDir = process.cwd()) {
+  if (scope === "global") {
+    const state = await readGlobalState();
+    const record = state.links[slug] ?? null;
+    delete state.links[slug];
+    await writeGlobalState(state);
+    return record;
+  } else {
+    const state = await readProjectState(projectDir);
+    const record = state.links[slug] ?? null;
+    delete state.links[slug];
+    await writeProjectState(state, projectDir);
+    return record;
+  }
+}
+async function findLink(slug, projectDir = process.cwd()) {
+  const projectState = await readProjectState(projectDir);
+  if (projectState.links[slug]) return projectState.links[slug];
+  const globalState = await readGlobalState();
+  return globalState.links[slug] ?? null;
+}
+async function getActiveSpec(scope, projectDir = process.cwd()) {
+  if (scope === "global") {
+    return (await readGlobalState()).activeSpec;
+  }
+  return (await readProjectState(projectDir)).activeSpec;
+}
+async function setActiveSpec(scope, specSlug, projectDir = process.cwd()) {
+  if (scope === "global") {
+    const state = await readGlobalState();
+    state.activeSpec = specSlug;
+    await writeGlobalState(state);
+  } else {
+    const state = await readProjectState(projectDir);
+    state.activeSpec = specSlug;
+    await writeProjectState(state, projectDir);
+  }
+}
+
+// src/commands/install.ts
+function die(msg) {
+  log.error(msg);
+  process.exit(1);
+  throw new Error(msg);
+}
+var installCommand = new Command2("install").description("Install a config, skill, rule, or spec by ID or slug").argument("<id>", "Content UUID or slug").option("--type <type>", "Skip auto-detect: config|skill|rule|spec").option("--framework <name>", "Target framework for skills").option("--file-type <type>", "Target file type for rules").option("--global", "Install globally as symlink (default: prompt)", false).option("--project", "Install to this project as a file copy (default: prompt)", false).option("--dry-run", "Preview without writing files", false).action(
+  async (id, opts) => {
+    const { dryRun } = opts;
+    intro(pc4.bold("agentspec install"));
+    if (dryRun) log.warn("Dry run \u2014 no files will be written");
+    let contentType = opts.type;
+    let contentId = id;
+    let title = id;
+    if (!contentType) {
+      const spinner = createSpinner();
+      spinner.start(`Resolving ${pc4.cyan(id)}...`);
+      try {
+        const resolved = await resolve(id);
+        spinner.stop(`Found: ${pc4.bold(resolved.title)} ${pc4.dim(`(${resolved.type})`)}`);
+        contentType = resolved.type;
+        contentId = resolved.id;
+        title = resolved.title;
+      } catch (err) {
+        spinner.fail(
+          `Could not resolve ${id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exit(1);
+      }
+    }
+    try {
+      switch (contentType) {
+        case "config":
+          await installConfig(contentId, title, opts);
+          break;
+        case "skill":
+          await installSkill(contentId, title, opts);
+          break;
+        case "rule":
+          await installRule(contentId, title, opts);
+          break;
+        case "spec":
+          await installSpec(contentId, title, opts);
+          break;
+        case "plugin":
+          log.error("Plugins require manual MCP server setup.");
+          log.tip(`See: https://agentspec.sh/plugins/${id}`);
+          process.exit(1);
+          break;
+        default:
+          die(`Unknown content type: ${contentType}`);
+      }
+      if (contentType !== "spec") {
+        trackInstall(contentType, contentId);
+      }
+    } catch (err) {
+      die(err instanceof Error ? err.message : String(err));
+    }
+    outro(pc4.green(`Done! Installed ${pc4.bold(title)}`));
+  }
+);
+async function installConfig(id, title, opts) {
+  const spinner = createSpinner();
+  spinner.start("Fetching config...");
+  let config;
+  try {
+    config = await getConfig(id);
+  } catch (err) {
+    spinner.fail(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  spinner.stop(`${pc4.bold(config.title)} ${pc4.dim(`(${config.framework}, ${config.format})`)}`);
+  const projectDest = FRAMEWORK_FILE_PATHS[config.framework];
+  const globalDest = GLOBAL_FRAMEWORK_FILE_PATHS[config.framework];
+  if (!projectDest) die(`No install path for framework: ${config.framework}`);
+  const scope = await resolveScope(opts, {
+    hasGlobal: !!globalDest && GLOBAL_SUPPORTED_FRAMEWORKS.has(config.framework),
+    projectLabel: projectDest,
+    globalLabel: globalDest ? tilde(globalDest) : ""
+  });
+  const targetLabel = scope === "global" ? tilde(globalDest) : projectDest;
+  const ok = await promptConfirm(`Install "${config.title}" to ${pc4.cyan(targetLabel)}?`);
+  if (!ok) {
+    log.info("Aborted.");
+    process.exit(0);
+  }
+  const configSlug = config.slug ?? id;
+  const meta = {
+    id: config.id,
+    slug: configSlug,
+    type: "config",
+    title: config.title,
+    framework: config.framework,
+    contentHash: config.contentHash,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!opts.dryRun) await storeItem(configSlug, config.configuration, meta);
+  if (scope === "global") {
+    const result = await installToGlobal(configSlug, globalDest, { dryRun: opts.dryRun });
+    logResult(result, scope);
+    if (!opts.dryRun)
+      await registerLink(
+        "global",
+        configSlug,
+        makeLink(config.id, configSlug, "config", config.title, scope, result, config.contentHash)
+      );
+  } else {
+    const result = await installToProject(projectDest, config.configuration, {
+      dryRun: opts.dryRun
+    });
+    logResult(result, scope);
+    if (!opts.dryRun)
+      await registerLink(
+        "project",
+        configSlug,
+        makeLink(config.id, configSlug, "config", config.title, scope, result, config.contentHash)
+      );
+  }
+}
+async function installSkill(id, title, opts) {
+  const spinner = createSpinner();
+  spinner.start("Fetching skill...");
+  let skill;
+  try {
+    skill = await getSkill(id);
+  } catch (err) {
+    spinner.fail(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  spinner.stop(`${pc4.bold(skill.name)} ${pc4.dim(`(${skill.frameworks.join(", ")})`)}`);
+  let fw = opts.framework;
+  if (!fw) {
+    if (skill.frameworks.length === 1) {
+      fw = skill.frameworks[0];
+    } else {
+      fw = await promptFramework(skill.frameworks, SKILL_FRAMEWORK_LABELS);
+    }
+  }
+  if (!fw) die("Could not determine target framework");
+  const projectDir = SKILL_FRAMEWORK_DIRS[fw];
+  const globalDir = GLOBAL_SKILL_FRAMEWORK_DIRS[fw];
+  if (!projectDir) die(`Unknown framework: ${fw}`);
+  const projectDest = `${projectDir}/${skill.name}/SKILL.md`;
+  const globalDest = globalDir ? `${globalDir}/${skill.name}/SKILL.md` : void 0;
+  const scope = await resolveScope(opts, {
+    hasGlobal: !!globalDir && GLOBAL_SUPPORTED_FRAMEWORKS.has(fw),
+    projectLabel: projectDest,
+    globalLabel: globalDest ? tilde(globalDest) : ""
+  });
+  const targetLabel = scope === "global" ? tilde(globalDest) : projectDest;
+  const ok = await promptConfirm(`Install "${skill.name}" to ${pc4.cyan(targetLabel)}?`);
+  if (!ok) {
+    log.info("Aborted.");
+    process.exit(0);
+  }
+  const skillSlug = skill.slug ?? id;
+  const skillMeta = {
+    id: skill.id,
+    slug: skillSlug,
+    type: "skill",
+    title: skill.name,
+    framework: fw,
+    contentHash: skill.contentHash,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!opts.dryRun) await storeItem(skillSlug, skill.skillContent, skillMeta);
+  if (scope === "global") {
+    const result = await installToGlobal(skillSlug, globalDest, { dryRun: opts.dryRun });
+    logResult(result, scope);
+    if (!opts.dryRun)
+      await registerLink(
+        "global",
+        skillSlug,
+        makeLink(skill.id, skillSlug, "skill", skill.name, scope, result, skill.contentHash)
+      );
+  } else {
+    const result = await installToProject(projectDest, skill.skillContent, { dryRun: opts.dryRun });
+    logResult(result, scope);
+    if (!opts.dryRun)
+      await registerLink(
+        "project",
+        skillSlug,
+        makeLink(skill.id, skillSlug, "skill", skill.name, scope, result, skill.contentHash)
+      );
+  }
+}
+async function installRule(id, title, opts) {
+  const spinner = createSpinner();
+  spinner.start("Fetching rule...");
+  let rule;
+  try {
+    rule = await getRule(id);
+  } catch (err) {
+    spinner.fail(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  spinner.stop(`${pc4.bold(rule.title)} ${pc4.dim(`(${rule.fileTypes.join(", ")})`)}`);
+  let ft = opts.fileType;
+  if (!ft) {
+    if (rule.fileTypes.length === 1) {
+      ft = rule.fileTypes[0];
+    } else {
+      ft = await promptFileType(rule.fileTypes, RULE_FILE_LABELS);
+    }
+  }
+  if (!ft) die("Could not determine target file type");
+  const destPath = RULE_FILE_PATHS[ft];
+  if (!destPath) die(`Unknown file type: ${ft}`);
+  const ok = await promptConfirm(`Install "${rule.title}" to ${pc4.cyan(destPath)}?`);
+  if (!ok) {
+    log.info("Aborted.");
+    process.exit(0);
+  }
+  const ruleSlug = rule.slug ?? id;
+  const ruleMeta = {
+    id: rule.id,
+    slug: ruleSlug,
+    type: "rule",
+    title: rule.title,
+    contentHash: rule.contentHash,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!opts.dryRun) await storeItem(ruleSlug, rule.content, ruleMeta);
+  let result;
+  if (destPath.endsWith("/")) {
+    result = await installToProjectDir(destPath, rule.title, rule.content, { dryRun: opts.dryRun });
+  } else {
+    result = await installToProject(destPath, rule.content, { dryRun: opts.dryRun });
+  }
+  logResult(result, "project");
+  if (!opts.dryRun)
+    await registerLink(
+      "project",
+      ruleSlug,
+      makeLink(rule.id, ruleSlug, "rule", rule.title, "project", result, rule.contentHash)
+    );
+}
+async function installSpec(id, title, opts) {
+  const spinner = createSpinner();
+  spinner.start("Fetching spec...");
+  let spec;
+  try {
+    spec = await getSpec(id);
+  } catch (err) {
+    spinner.fail(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  spinner.stop(
+    `${pc4.bold(spec.title)} ${pc4.dim(`(${spec.framework}, ${spec.items.length} items)`)}`
+  );
+  const hasGlobal = GLOBAL_SUPPORTED_FRAMEWORKS.has(spec.framework);
+  const scope = await resolveScope(opts, {
+    hasGlobal,
+    projectLabel: "this project",
+    globalLabel: "~/.config/agentspec (global)"
+  });
+  const ok = await promptConfirm(
+    `Install all ${spec.items.length} items from "${spec.title}" ${scope === "global" ? "globally" : "to this project"}?`
+  );
+  if (!ok) {
+    log.info("Aborted.");
+    process.exit(0);
+  }
+  const total = spec.items.length;
+  let step = 0;
+  for (const item of spec.items) {
+    step++;
+    const prefix = pc4.dim(`[${step}/${total}]`);
+    if (item.targetType === "plugin") {
+      log.warn(`${prefix} Skipping plugin \u2014 manual setup required`);
+      continue;
+    }
+    console.log(`
+${prefix} Installing ${item.targetType}...`);
+    if (item.targetType === "config") {
+      const data = item.data;
+      const itemSlug = data.slug ?? data.id;
+      const projectDest = FRAMEWORK_FILE_PATHS[data.framework];
+      const globalDest = scope === "global" ? GLOBAL_FRAMEWORK_FILE_PATHS[data.framework] : void 0;
+      if (!projectDest) {
+        log.warn(`Unknown framework ${data.framework} \u2014 skipping`);
+        continue;
+      }
+      if (scope === "global" && globalDest) {
+        const meta = {
+          id: data.id,
+          slug: itemSlug,
+          type: "config",
+          title: data.title,
+          framework: data.framework,
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (!opts.dryRun) await storeItem(itemSlug, data.configuration, meta);
+        const result = await installToGlobal(itemSlug, globalDest, { dryRun: opts.dryRun });
+        logResult(result, scope);
+        if (!opts.dryRun)
+          await registerLink(
+            "global",
+            itemSlug,
+            makeLink(data.id, itemSlug, "config", data.title, scope, result)
+          );
+      } else {
+        const result = await installToProject(projectDest, data.configuration, {
+          dryRun: opts.dryRun
+        });
+        logResult(result, "project");
+        if (!opts.dryRun)
+          await registerLink(
+            "project",
+            itemSlug,
+            makeLink(data.id, itemSlug, "config", data.title, "project", result)
+          );
+      }
+      trackInstall("config", data.id);
+    } else if (item.targetType === "skill") {
+      const data = item.data;
+      const itemSlug = data.slug ?? data.id;
+      const fw = opts.framework ?? data.frameworks[0] ?? data.framework;
+      const projectDest = `${SKILL_FRAMEWORK_DIRS[fw] ?? ".claude/skills"}/${data.name}/SKILL.md`;
+      const globalDest = scope === "global" && GLOBAL_SKILL_FRAMEWORK_DIRS[fw] ? `${GLOBAL_SKILL_FRAMEWORK_DIRS[fw]}/${data.name}/SKILL.md` : void 0;
+      if (scope === "global" && globalDest) {
+        const meta = {
+          id: data.id,
+          slug: itemSlug,
+          type: "skill",
+          title: data.name,
+          framework: fw,
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (!opts.dryRun) await storeItem(itemSlug, data.skillContent, meta);
+        const result = await installToGlobal(itemSlug, globalDest, { dryRun: opts.dryRun });
+        logResult(result, scope);
+        if (!opts.dryRun)
+          await registerLink(
+            "global",
+            itemSlug,
+            makeLink(data.id, itemSlug, "skill", data.name, scope, result)
+          );
+      } else {
+        const result = await installToProject(projectDest, data.skillContent, {
+          dryRun: opts.dryRun
+        });
+        logResult(result, "project");
+        if (!opts.dryRun)
+          await registerLink(
+            "project",
+            itemSlug,
+            makeLink(data.id, itemSlug, "skill", data.name, "project", result)
+          );
+      }
+      trackInstall("skill", data.id);
+    } else if (item.targetType === "rule") {
+      const data = item.data;
+      const itemSlug = data.slug ?? data.id;
+      const ft = opts.fileType ?? data.fileTypes[0] ?? data.fileType;
+      const destPath = RULE_FILE_PATHS[ft];
+      if (!destPath) {
+        log.warn(`Unknown file type ${ft} \u2014 skipping`);
+        continue;
+      }
+      let result;
+      if (destPath.endsWith("/")) {
+        result = await installToProjectDir(destPath, data.title, data.content, {
+          dryRun: opts.dryRun
+        });
+      } else {
+        result = await installToProject(destPath, data.content, { dryRun: opts.dryRun });
+      }
+      logResult(result, "project");
+      if (!opts.dryRun)
+        await registerLink(
+          "project",
+          itemSlug,
+          makeLink(data.id, itemSlug, "rule", data.title, "project", result)
+        );
+      trackInstall("rule", data.id);
+    }
+  }
+  trackInstall("spec", id);
+}
+async function resolveScope(opts, config) {
+  if (opts.global) return "global";
+  if (opts.project) return "project";
+  if (!config.hasGlobal) return "project";
+  return promptScope({ projectLabel: config.projectLabel, globalLabel: config.globalLabel });
+}
+function tilde(p) {
+  const home = process.env["HOME"] ?? "";
+  return home ? p.replace(home, "~") : p;
+}
+function logResult(result, scope) {
+  if (scope === "global") {
+    log.step(`Symlinked ${pc4.cyan(tilde(result.targetPath))}`);
+  } else {
+    log.step(`Wrote ${pc4.cyan(result.targetPath)}`);
+  }
+  if (result.backupPath) {
+    log.step(`Backed up original \u2192 ${pc4.dim(result.backupPath)}`);
+  }
+}
+function makeLink(id, slug, type, title, scope, result, contentHash) {
+  return {
+    id,
+    slug,
+    type,
+    title,
+    scope,
+    targetPath: result.targetPath,
+    backupPath: result.backupPath,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    contentHash
+  };
+}
+
+// src/commands/list.ts
+import { Command as Command3 } from "commander";
+import pc5 from "picocolors";
+var LIST_TYPES = ["configs", "skills", "rules", "specs"];
+var listCommand = new Command3("list").description("Browse configs, skills, rules, or specs").argument("<type>", "Content type: configs|skills|rules|specs").option("--sort <sort>", "Sort order: hot|new|top|installs", "hot").option("--framework <name>", "Filter by framework (e.g. ClaudeCode, Codex)").option("--file-type <type>", "Filter rules by file type (e.g. claude-md)").option("--limit <n>", "Number of results to show", "20").option("--offset <n>", "Pagination offset", "0").action(
+  async (type, opts) => {
+    if (!LIST_TYPES.includes(type)) {
+      log.error(`Invalid type "${type}". Choose from: ${LIST_TYPES.join(", ")}`);
+      process.exit(1);
+    }
+    const limit = Math.min(parseInt(opts.limit, 10) || 20, 100);
+    const offset = parseInt(opts.offset, 10) || 0;
+    const spinner = createSpinner();
+    spinner.start(`Loading ${type}...`);
+    let result;
+    try {
+      result = await listItems(type, {
+        sort: opts.sort,
+        framework: opts.framework,
+        fileType: opts.fileType,
+        limit,
+        offset
+      });
+    } catch (err) {
+      spinner.fail(`Failed to load ${type}: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    spinner.stop(
+      `${pc5.bold(type)} \u2014 ${result.total} total, showing ${offset + 1}\u2013${Math.min(offset + limit, result.total)} (sorted by ${opts.sort})`
+    );
+    if (result.data.length === 0) {
+      log.tip("No results found.");
+      return;
+    }
+    console.log();
+    const typeLabel2 = type === "configs" ? "config" : type.slice(0, -1);
+    printTable(
+      ["#", "ID", "TITLE", "FRAMEWORK", "SCORE", "INSTALLS", "CREATED"],
+      result.data.map((item, i) => [
+        pc5.dim(String(offset + i + 1)),
+        pc5.dim(item.id),
+        truncate(item.title, 36),
+        pc5.dim(
+          item.framework ?? item.fileType ?? item.frameworks?.join(", ") ?? item.fileTypes?.join(", ") ?? "\u2014"
+        ),
+        pc5.dim(formatScore(item.upvoteCount, item.downvoteCount)),
+        pc5.dim(String(item.installCount)),
+        pc5.dim(formatDate(item.createdAt))
+      ])
+    );
+    console.log();
+    if (offset + limit < result.total) {
+      log.tip(
+        `Next page: agentspec list ${type} --offset ${offset + limit} --limit ${limit}${opts.framework ? ` --framework ${opts.framework}` : ""}`
+      );
+    }
+    log.tip(`Install with: agentspec install <id>`);
+    log.tip(`Details:      agentspec info <id>`);
+    if (typeLabel2 !== type) {
+      console.log();
+      console.log(
+        `  Type badges: ${typeBadge("config")}  ${typeBadge("skill")}  ${typeBadge("rule")}  ${typeBadge("spec")}`
+      );
+    }
+  }
+);
+
+// src/commands/search.ts
+import { Command as Command4 } from "commander";
+import pc6 from "picocolors";
+var searchCommand = new Command4("search").description("Semantic search across configs, skills, rules, specs, and plugins").argument("<query>", "Search query").option("--type <type>", "Filter by type: all|config|skill|rule|spec|plugin", "all").option("--limit <n>", "Max results to return", "10").action(async (query, opts) => {
+  const limit = Math.min(parseInt(opts.limit, 10) || 10, 50);
+  const spinner = createSpinner();
+  spinner.start(`Searching for "${pc6.cyan(query)}"`);
+  let result;
+  try {
+    result = await search(query, { type: opts.type, limit });
+  } catch (err) {
+    spinner.fail(`Search failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  spinner.stop(`Found ${result.data.length} results for "${pc6.cyan(query)}"`);
+  if (result.data.length === 0) {
+    log.tip("No results. Try a broader query or different type filter.");
+    return;
+  }
+  console.log();
+  printTable(
+    ["TYPE", "ID", "TITLE", "SCORE"],
+    result.data.map((item) => [
+      typeBadge(item.itemType),
+      pc6.dim(item.id),
+      truncate(item.title, 40),
+      pc6.dim(formatScore(item.score, 0))
+    ])
+  );
+  console.log();
+  log.tip(`Install with: agentspec install <id>`);
+  log.tip(`Get details:  agentspec info <id>`);
+});
+
+// src/commands/status.ts
+import { Command as Command5 } from "commander";
+import pc7 from "picocolors";
+import { homedir as homedir2 } from "os";
+function tilde2(p) {
+  return p.replace(homedir2(), "~");
+}
+var statusCommand = new Command5("status").description("Show installed items and active spec").option("--global", "Show global installation state", false).option("--store", "List all items in the local store (~/.agentspec/store/)", false).action(async (opts) => {
+  if (opts.store) {
+    const items = await listStoreItems();
+    if (items.length === 0) {
+      log.info("Store is empty. Install something with: agentspec install <slug>");
+      return;
+    }
+    console.log(pc7.bold(`
+  ~/.agentspec/store/ \u2014 ${items.length} item(s)
+`));
+    printTable(
+      ["SLUG", "TYPE", "TITLE", "FETCHED"],
+      items.map((m) => [
+        pc7.cyan(m.slug),
+        pc7.dim(m.type),
+        truncate(m.title, 40),
+        pc7.dim(new Date(m.fetchedAt).toLocaleDateString())
+      ])
+    );
+    return;
+  }
+  if (opts.global) {
+    const state2 = await readGlobalState();
+    const links2 = Object.values(state2.links);
+    console.log();
+    console.log(pc7.bold("  Global state") + pc7.dim(` (~/.agentspec/global-state.json)`));
+    if (state2.activeSpec) {
+      console.log(`  Active spec: ${pc7.cyan(state2.activeSpec)}`);
+    }
+    console.log();
+    if (links2.length === 0) {
+      log.info("Nothing installed globally. Use: agentspec install <slug> --global");
+      return;
+    }
+    printTable(
+      ["SLUG", "TYPE", "TARGET", "MODE"],
+      links2.map((r) => [
+        pc7.cyan(r.slug),
+        pc7.dim(r.type),
+        tilde2(r.targetPath),
+        r.scope === "global" ? pc7.magenta("symlink") : pc7.dim("copy")
+      ])
+    );
+    return;
+  }
+  const state = await readProjectState();
+  const links = Object.values(state.links);
+  console.log();
+  console.log(pc7.bold("  Project: ") + pc7.dim(process.cwd()));
+  if (state.activeSpec) {
+    console.log(`  Active spec: ${pc7.cyan(state.activeSpec)}`);
+  }
+  console.log();
+  if (links.length === 0) {
+    log.info("Nothing tracked in this project. Install with: agentspec install <slug>");
+    log.tip("Or check global installs with: agentspec status --global");
+    return;
+  }
+  printTable(
+    ["SLUG", "TYPE", "TARGET", "MODE", "INSTALLED"],
+    links.map((r) => [
+      pc7.cyan(r.slug),
+      pc7.dim(r.type),
+      truncate(r.targetPath, 40),
+      r.scope === "global" ? pc7.magenta("symlink") : pc7.dim("copy"),
+      pc7.dim(new Date(r.installedAt).toLocaleDateString())
+    ])
+  );
+  console.log();
+  log.tip("Remove an item:      agentspec uninstall <slug>");
+  log.tip("Switch agent setup:  agentspec use <spec-slug>");
+});
+
+// src/commands/uninstall.ts
+import { intro as intro2, outro as outro2 } from "@clack/prompts";
+import { Command as Command6 } from "commander";
+import pc8 from "picocolors";
+function die2(msg) {
+  log.error(msg);
+  process.exit(1);
+  throw new Error(msg);
+}
+var uninstallCommand = new Command6("uninstall").description("Remove an installed config, skill, or rule").argument("<id>", "Slug or UUID of the installed item").option("--global", "Uninstall from global scope", false).option("--project", "Uninstall from this project", false).action(async (id, opts) => {
+  intro2(pc8.bold("agentspec uninstall"));
+  const record = await findLink(id);
+  if (!record) {
+    die2(
+      `"${id}" is not tracked by agentspec in this project or globally.
+  If you installed it manually, remove the file directly.`
+    );
+  }
+  const scopeLabel = record.scope === "global" ? pc8.cyan("global") + pc8.dim(" (symlink)") : pc8.cyan("project") + pc8.dim(" (file copy)");
+  console.log();
+  console.log(`  ${pc8.bold(record.title)}`);
+  console.log(`  ${pc8.dim("\u2192")} ${record.targetPath}`);
+  console.log(`  ${pc8.dim("scope:")} ${scopeLabel}`);
+  console.log();
+  if (record.scope === "global") {
+    const ok = await promptConfirm(
+      `Remove symlink and restore original${record.backupPath ? " from backup" : ""}?`
+    );
+    if (!ok) {
+      log.info("Aborted.");
+      process.exit(0);
+    }
+    await uninstallFromGlobal(record.targetPath, record.backupPath);
+    await unregisterLink("global", id);
+    log.step(`Removed symlink ${pc8.dim(record.targetPath)}`);
+    if (record.backupPath) {
+      log.step(`Restored original from backup`);
+    }
+  } else {
+    const action = await promptUninstallAction(record.targetPath);
+    await uninstallFromProject(record.targetPath, action);
+    await unregisterLink("project", id);
+    if (action === "delete") {
+      log.step(`Deleted ${pc8.dim(record.targetPath)}`);
+    } else {
+      log.step(`Untracked \u2014 file kept at ${pc8.dim(record.targetPath)}`);
+    }
+  }
+  outro2(pc8.green(`Uninstalled ${pc8.bold(record.title)}`));
+});
+
+// src/commands/update.ts
+import { intro as intro3, outro as outro3 } from "@clack/prompts";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3 } from "fs/promises";
+import { Command as Command7 } from "commander";
+import pc9 from "picocolors";
+function sha256(content) {
+  return createHash2("sha256").update(content, "utf8").digest("hex");
+}
+async function fetchLatest(id, type) {
+  switch (type) {
+    case "config": {
+      const d = await getConfig(id);
+      return { content: d.configuration, contentHash: d.contentHash, title: d.title };
+    }
+    case "skill": {
+      const d = await getSkill(id);
+      return { content: d.skillContent, contentHash: d.contentHash, title: d.name };
+    }
+    case "rule": {
+      const d = await getRule(id);
+      return { content: d.content, contentHash: d.contentHash, title: d.title };
+    }
+    default:
+      throw new Error(`Cannot update type "${type}" \u2014 only config, skill, rule supported`);
+  }
+}
+async function updateOne(slug, opts) {
+  if (!await hasStoreItem(slug)) return "skipped";
+  const meta = await readStoreMeta(slug);
+  if (!["config", "skill", "rule"].includes(meta.type)) return "skipped";
+  const latest = await fetchLatest(meta.id, meta.type);
+  const remoteHash = latest.contentHash;
+  if (meta.contentHash && meta.contentHash === remoteHash) {
+    return "up-to-date";
+  }
+  const storePath = storeContentAbsPath(slug);
+  let localContent = null;
+  try {
+    localContent = await readFile3(storePath, "utf8");
+  } catch {
+  }
+  if (localContent !== null && meta.contentHash) {
+    const localHash = sha256(localContent);
+    if (localHash !== meta.contentHash && !opts.force) {
+      return "local-modified";
+    }
+  }
+  if (!opts.dryRun) {
+    await storeItem(slug, latest.content, {
+      ...meta,
+      contentHash: remoteHash,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return "updated";
+}
+var updateCommand = new Command7("update").description("Update installed items to their latest version from agentspec.sh").argument("[slug]", "Slug of the item to update (omit to update all store items)").option("--all", "Update all items in the store", false).option("--check", "Only check for updates without applying them", false).option("--force", "Overwrite even if local store copy was manually modified", false).option("--dry-run", "Preview without writing anything", false).action(
+  async (slug, opts) => {
+    intro3(pc9.bold("agentspec update"));
+    const dryRun = opts.dryRun || opts.check;
+    if (dryRun)
+      log.warn(
+        opts.check ? "Check mode \u2014 not applying changes" : "Dry run \u2014 no files will be written"
+      );
+    let slugs;
+    if (slug) {
+      slugs = [slug];
+    } else if (opts.all || !slug) {
+      const items = await listStoreItems();
+      slugs = items.map((m) => m.slug);
+      if (slugs.length === 0) {
+        log.info("Store is empty \u2014 nothing to update.");
+        log.tip("Install something first: agentspec install <slug>");
+        process.exit(0);
+      }
+    } else {
+      slugs = [slug];
+    }
+    const results = [];
+    const spinner = createSpinner();
+    spinner.start(`Checking ${slugs.length} item(s)...`);
+    let checked = 0;
+    for (const s of slugs) {
+      try {
+        const result = await updateOne(s, { dryRun, force: opts.force });
+        let title;
+        try {
+          title = (await readStoreMeta(s)).title;
+        } catch {
+        }
+        results.push({ slug: s, result, title });
+      } catch (err) {
+        results.push({ slug: s, result: "skipped", title: void 0 });
+        log.warn(`  ${s}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      checked++;
+    }
+    spinner.stop(`Checked ${checked} item(s)`);
+    const updated = results.filter((r) => r.result === "updated");
+    const upToDate = results.filter((r) => r.result === "up-to-date");
+    const localModified = results.filter((r) => r.result === "local-modified");
+    const skipped = results.filter((r) => r.result === "skipped");
+    console.log();
+    if (results.length > 1) {
+      printTable(
+        ["SLUG", "STATUS", "TITLE"],
+        results.map(({ slug: s, result, title }) => [
+          pc9.cyan(s),
+          result === "updated" ? pc9.green("updated") : result === "up-to-date" ? pc9.dim("up-to-date") : result === "local-modified" ? pc9.yellow("local modified") : pc9.dim("skipped"),
+          pc9.dim(title ?? "\u2014")
+        ])
+      );
+      console.log();
+    }
+    if (updated.length > 0) {
+      log.success(`${updated.length} item(s) updated`);
+      if (updated.length <= 5) {
+        for (const r of updated) log.step(r.slug);
+      }
+    }
+    if (localModified.length > 0) {
+      log.warn(`${localModified.length} item(s) have local modifications \u2014 skipped`);
+      for (const r of localModified) {
+        log.step(`${pc9.yellow(r.slug)} \u2014 run with ${pc9.dim("--force")} to overwrite`);
+      }
+    }
+    if (upToDate.length > 0 && results.length === 1) {
+      log.info(`${pc9.cyan(upToDate[0].slug)} is already up-to-date`);
+    }
+    if (updated.length > 0) {
+      console.log();
+      log.tip("Global installs (symlinks) already reflect the update.");
+      log.tip("Project copies need re-installation: agentspec install <slug> --project");
+    }
+    outro3(pc9.green("Done"));
+  }
+);
+
+// src/commands/use.ts
+import { intro as intro4, outro as outro4 } from "@clack/prompts";
+import { Command as Command8 } from "commander";
+import pc10 from "picocolors";
+var useCommand = new Command8("use").description("Activate a spec \u2014 links all its items in one shot").argument("<spec>", 'Spec slug or UUID (use "--none" to deactivate)').option("--global", "Activate globally", false).option("--project", "Activate for this project only", false).option("--none", "Deactivate the current spec", false).option("--dry-run", "Preview without writing files", false).action(
+  async (specId, opts) => {
+    intro4(pc10.bold("agentspec use"));
+    if (opts.dryRun) log.warn("Dry run \u2014 no files will be written");
+    if (opts.none) {
+      const scope2 = opts.global ? "global" : "project";
+      const current = await getActiveSpec(scope2);
+      if (!current) {
+        log.info("No active spec to deactivate.");
+        process.exit(0);
+      }
+      await deactivateSpec(current, scope2, opts.dryRun);
+      await setActiveSpec(scope2, null);
+      outro4(pc10.green("Deactivated."));
+      return;
+    }
+    const spinner = createSpinner();
+    spinner.start(`Resolving ${pc10.cyan(specId)}...`);
+    let resolved;
+    try {
+      resolved = await resolve(specId);
+    } catch (err) {
+      spinner.fail(`Could not resolve: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    if (resolved.type !== "spec") {
+      spinner.fail(`"${specId}" is a ${resolved.type}, not a spec`);
+      process.exit(1);
+    }
+    spinner.stop(`${pc10.bold(resolved.title)} ${pc10.dim(`(${resolved.type})`)}`);
+    const hasGlobal = GLOBAL_SUPPORTED_FRAMEWORKS.has(resolved.framework ?? "");
+    let scope;
+    if (opts.global) {
+      scope = "global";
+    } else if (opts.project) {
+      scope = "project";
+    } else if (!hasGlobal) {
+      scope = "project";
+    } else {
+      scope = await promptScope({
+        projectLabel: "this project only",
+        globalLabel: "global (affects all projects)"
+      });
+    }
+    const scopeLabel = scope === "global" ? "globally" : "for this project";
+    const ok = await promptConfirm(`Activate "${resolved.title}" ${scopeLabel}?`);
+    if (!ok) {
+      log.info("Aborted.");
+      process.exit(0);
+    }
+    const specSpinner = createSpinner();
+    specSpinner.start("Loading spec items...");
+    let spec;
+    try {
+      spec = await getSpec(resolved.id);
+    } catch (err) {
+      specSpinner.fail(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    specSpinner.stop(`${spec.items.length} items to activate`);
+    const currentSpec = await getActiveSpec(scope);
+    if (currentSpec && currentSpec !== resolved.id) {
+      log.info(`
+Deactivating previous spec: ${pc10.dim(currentSpec)}`);
+      await deactivateSpec(currentSpec, scope, opts.dryRun);
+    }
+    console.log();
+    const total = spec.items.length;
+    let step = 0;
+    for (const item of spec.items) {
+      step++;
+      const prefix = pc10.dim(`[${step}/${total}]`);
+      if (item.targetType === "plugin") {
+        log.warn(`${prefix} Skipping plugin \u2014 manual setup required`);
+        continue;
+      }
+      if (item.targetType === "config") {
+        const data = item.data;
+        const itemSlug = data.slug ?? data.id;
+        const projectDest = FRAMEWORK_FILE_PATHS[data.framework];
+        const globalDest = GLOBAL_FRAMEWORK_FILE_PATHS[data.framework];
+        if (!projectDest) {
+          log.warn(`${prefix} Unknown framework ${data.framework} \u2014 skipping`);
+          continue;
+        }
+        if (!opts.dryRun) {
+          const meta = {
+            id: data.id,
+            slug: itemSlug,
+            type: "config",
+            title: data.title,
+            framework: data.framework,
+            fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          if (!await hasStoreItem(itemSlug))
+            await storeItem(itemSlug, data.configuration, meta);
+        }
+        if (scope === "global" && globalDest) {
+          const result = await installToGlobal(itemSlug, globalDest, { dryRun: opts.dryRun });
+          log.step(`${prefix} ${pc10.cyan(tilde3(globalDest))} ${pc10.dim("(symlink)")}`);
+          if (!opts.dryRun)
+            await registerLink(
+              scope,
+              itemSlug,
+              makeLink2(data.id, itemSlug, "config", data.title, scope, result, resolved.id)
+            );
+        } else {
+          const result = await installToProject(projectDest, data.configuration, {
+            dryRun: opts.dryRun
+          });
+          log.step(`${prefix} ${pc10.cyan(projectDest)} ${pc10.dim("(copy)")}`);
+          if (!opts.dryRun)
+            await registerLink(
+              scope,
+              itemSlug,
+              makeLink2(data.id, itemSlug, "config", data.title, scope, result, resolved.id)
+            );
+        }
+        trackInstall("config", data.id);
+      } else if (item.targetType === "skill") {
+        const data = item.data;
+        const itemSlug = data.slug ?? data.id;
+        const fw = data.frameworks[0] ?? data.framework;
+        const projectDest = `${SKILL_FRAMEWORK_DIRS[fw] ?? ".claude/skills"}/${data.name}/SKILL.md`;
+        const globalDest = GLOBAL_SKILL_FRAMEWORK_DIRS[fw] ? `${GLOBAL_SKILL_FRAMEWORK_DIRS[fw]}/${data.name}/SKILL.md` : void 0;
+        if (!opts.dryRun) {
+          const meta = {
+            id: data.id,
+            slug: itemSlug,
+            type: "skill",
+            title: data.name,
+            framework: fw,
+            fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          if (!await hasStoreItem(itemSlug)) await storeItem(itemSlug, data.skillContent, meta);
+        }
+        if (scope === "global" && globalDest) {
+          const result = await installToGlobal(itemSlug, globalDest, { dryRun: opts.dryRun });
+          log.step(`${prefix} ${pc10.cyan(tilde3(globalDest))} ${pc10.dim("(symlink)")}`);
+          if (!opts.dryRun)
+            await registerLink(
+              scope,
+              itemSlug,
+              makeLink2(data.id, itemSlug, "skill", data.name, scope, result, resolved.id)
+            );
+        } else {
+          const result = await installToProject(projectDest, data.skillContent, {
+            dryRun: opts.dryRun
+          });
+          log.step(`${prefix} ${pc10.cyan(projectDest)} ${pc10.dim("(copy)")}`);
+          if (!opts.dryRun)
+            await registerLink(
+              scope,
+              itemSlug,
+              makeLink2(data.id, itemSlug, "skill", data.name, scope, result, resolved.id)
+            );
+        }
+        trackInstall("skill", data.id);
+      } else if (item.targetType === "rule") {
+        const data = item.data;
+        const itemSlug = data.slug ?? data.id;
+        const ft = data.fileTypes[0] ?? data.fileType;
+        const destPath = RULE_FILE_PATHS[ft];
+        if (!destPath) {
+          log.warn(`${prefix} Unknown file type ${ft} \u2014 skipping`);
+          continue;
+        }
+        let result;
+        if (destPath.endsWith("/")) {
+          result = await installToProjectDir(destPath, data.title, data.content, {
+            dryRun: opts.dryRun
+          });
+        } else {
+          result = await installToProject(destPath, data.content, { dryRun: opts.dryRun });
+        }
+        log.step(`${prefix} ${pc10.cyan(destPath)} ${pc10.dim("(copy)")}`);
+        if (!opts.dryRun)
+          await registerLink(
+            "project",
+            itemSlug,
+            makeLink2(data.id, itemSlug, "rule", data.title, "project", result, resolved.id)
+          );
+        trackInstall("rule", data.id);
+      }
+    }
+    if (!opts.dryRun) {
+      await setActiveSpec(scope, resolved.id);
+    }
+    trackInstall("spec", resolved.id);
+    outro4(pc10.green(`Activated ${pc10.bold(resolved.title)} ${pc10.dim(`(${scope})`)} `));
+  }
+);
+async function deactivateSpec(specId, scope, dryRun) {
+  const state = scope === "global" ? await readGlobalState() : await readProjectState();
+  for (const [slug, record] of Object.entries(state.links)) {
+    if (record.scope !== scope) continue;
+    if (record.installedBySpec !== specId) continue;
+    if (record.scope === "global") {
+      if (!dryRun) await uninstallFromGlobal(record.targetPath, record.backupPath);
+      log.step(`Unlinked ${pc10.dim(tilde3(record.targetPath))}`);
+    } else {
+      log.step(`Untracked ${pc10.dim(record.targetPath)}`);
+    }
+    if (!dryRun) await unregisterLink(scope, slug);
+  }
+}
+function tilde3(p) {
+  const home = process.env["HOME"] ?? "";
+  return home ? p.replace(home, "~") : p;
+}
+function makeLink2(id, slug, type, title, scope, result, specSlug) {
+  return {
+    id,
+    slug,
+    type,
+    title,
+    scope,
+    targetPath: result.targetPath,
+    backupPath: result.backupPath,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    installedBySpec: specSlug
+  };
+}
+
+// src/index.ts
+var program = new Command9().name("agentspec").description("Install AI agent configs, skills, and rules from agentspec.sh").version("0.1.0");
+program.addCommand(installCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(updateCommand);
+program.addCommand(useCommand);
+program.addCommand(statusCommand);
+program.addCommand(searchCommand);
+program.addCommand(listCommand);
+program.addCommand(infoCommand);
+program.parse(process.argv);