agentscamp 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// src/index.ts
+import { homedir as homedir2 } from "node:os";
+
 // src/output.ts
 var useColor = process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
 function paint(code) {
@@ -21,24 +24,35 @@ function printHelp(version) {
 ${c.bold("agentscamp")} v${version} \u2014 install AgentsCamp agents, skills & slash commands into Claude Code
 
 ${c.bold("Usage")}
+  npx agentscamp                  Pick what to install (interactive)
+  npx agentscamp --all            Install the entire catalog
   npx agentscamp <command> [args] [flags]
 
 ${c.bold("Commands")}
-  add <id...>       Install one or more items (e.g. agents/prompt-engineer)
-  list [type]       List everything, or one type (agents | skills | commands)
-  search <query>    Search by name, title, topic, or description
-  info <id>         Show details and install paths for an item
+  install [type...]   Install everything (--all), whole types (agents | skills |
+                      commands), or pick interactively when run with no args
+  add <id...>         Install specific items (e.g. agents/prompt-engineer)
+  list [type]         List everything, or one type (agents | skills | commands)
+  search <query>      Search by name, title, topic, or description
+  info <id>           Show details and install paths for an item
 
 ${c.bold("Flags")}
-  -g, --global      Install to ~/.claude/ (default: ./.claude/ in the current project)
-      --project     Install to ./.claude/ explicitly
+  -a, --all         With install (or no command): install the whole catalog
+  -g, --global      Install to ~/.claude/, available in every project
+      --project     Install to ./.claude/ in the current project
   -f, --force       Overwrite existing files
   -h, --help        Show this help
   -v, --version     Show version
 
+${c.bold("Scope")}
+  install defaults to ~/.claude/ (every project); add defaults to ./.claude/.
+  Pass -g/--project anywhere to override.
+
 ${c.bold("Examples")}
-  npx agentscamp add agents/prompt-engineer
-  npx agentscamp add skills/dependency-audit commands/plan-feature -g
+  npx agentscamp                  ${c.dim("# interactive picker")}
+  npx agentscamp --all            ${c.dim("# everything, into ~/.claude/")}
+  npx agentscamp install agents   ${c.dim("# all agents")}
+  npx agentscamp add skills/dependency-audit commands/plan-feature
   npx agentscamp search "code review"
 
 Browse everything with full docs at ${c.cyan("https://agentscamp.com")}
@@ -53,6 +67,8 @@ var FLAG_MAP = {
   "--project": "project",
   "-f": "force",
   "--force": "force",
+  "-a": "all",
+  "--all": "all",
   "-h": "help",
   "--help": "help",
   "-v": "version",
@@ -63,6 +79,7 @@ function parseArgs(argv) {
     global: false,
     project: false,
     force: false,
+    all: false,
     help: false,
     version: false
   };
@@ -110,14 +127,13 @@ function packageVersion() {
 }
 
 // src/install.ts
-var DEFAULT_SCOPE = "project";
-function resolveScope(flags) {
+function resolveScope(flags, fallback = "project") {
   if (flags.global && flags.project) {
     throw new CliError("Pass either --global or --project, not both.");
   }
   if (flags.global) return "global";
   if (flags.project) return "project";
-  return DEFAULT_SCOPE;
+  return fallback;
 }
 function installRoot(scope) {
   return scope === "global" ? path.join(homedir(), ".claude") : path.resolve(process.cwd(), ".claude");
@@ -139,6 +155,229 @@ function installItem(item, opts) {
   }
 }
 
+// src/prompt.ts
+var out = process.stdout;
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function parseKey(s) {
+  if (s === "") return "ctrl-c";
+  if (s === "\r" || s === "\n") return "enter";
+  if (s === "\x1B[A") return "up";
+  if (s === "\x1B[B") return "down";
+  if (s === "\x1B[C") return "right";
+  if (s === "\x1B[D") return "left";
+  if (s === "\x1B[H" || s === "\x1B[1~") return "home";
+  if (s === "\x1B[F" || s === "\x1B[4~") return "end";
+  if (s === " ") return "space";
+  if (s === "\x1B") return "esc";
+  const l = s.toLowerCase();
+  if (l === "k") return "up";
+  if (l === "j") return "down";
+  if (l === "a") return "a";
+  if (l === "q") return "q";
+  return "other";
+}
+var HIDE = "\x1B[?25l";
+var SHOW = "\x1B[?25h";
+function termWidth() {
+  return Math.max(20, out.columns || 80);
+}
+function clip(s, max) {
+  if (max <= 0) return "";
+  if (s.length <= max) return s;
+  if (max === 1) return "\u2026";
+  return s.slice(0, max - 1) + "\u2026";
+}
+function run(frame, onKey) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    let lastHeight = 0;
+    function moveToFrameTop() {
+      if (lastHeight > 0) {
+        out.write("\r");
+        if (lastHeight > 1) out.write(`\x1B[${lastHeight - 1}A`);
+        out.write("\x1B[J");
+      }
+    }
+    function render() {
+      const f = frame();
+      moveToFrameTop();
+      out.write(f);
+      lastHeight = f.split("\n").length;
+    }
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      if (stdin.isTTY) stdin.setRawMode(false);
+      stdin.pause();
+      moveToFrameTop();
+      out.write(SHOW);
+    }
+    function onData(chunk) {
+      const key = parseKey(String(chunk));
+      if (key === "ctrl-c") {
+        cleanup();
+        out.write(c.dim("Cancelled.") + "\n");
+        process.exit(130);
+      }
+      const action = onKey(key);
+      if (action === "done") {
+        cleanup();
+        resolve();
+      } else if (action === "render") {
+        render();
+      }
+    }
+    out.write(HIDE);
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    render();
+  });
+}
+async function selectOne(message, choices) {
+  let cursor = 0;
+  let cancelled = false;
+  const help = c.dim("(\u2191/\u2193 move \xB7 \u23CE select \xB7 esc cancel)");
+  function frame() {
+    const width = termWidth();
+    const lines = [`${c.bold(message)}  ${help}`];
+    for (let i = 0; i < choices.length; i++) {
+      const ch = choices[i];
+      const active = i === cursor;
+      const ptr = active ? c.cyan("\u276F") : " ";
+      const hintLen = ch.hint ? ch.hint.length + 2 : 0;
+      const label = clip(ch.label, width - 2 - hintLen);
+      const labelC = active ? c.cyan(label) : label;
+      const hint = ch.hint ? "  " + c.dim(ch.hint) : "";
+      lines.push(`${ptr} ${labelC}${hint}`);
+    }
+    return lines.join("\n");
+  }
+  await run(frame, (key) => {
+    switch (key) {
+      case "up":
+        cursor = (cursor - 1 + choices.length) % choices.length;
+        return "render";
+      case "down":
+        cursor = (cursor + 1) % choices.length;
+        return "render";
+      case "home":
+        cursor = 0;
+        return "render";
+      case "end":
+        cursor = choices.length - 1;
+        return "render";
+      case "enter":
+        return "done";
+      case "esc":
+      case "q":
+        cancelled = true;
+        return "done";
+      default:
+        return "ignore";
+    }
+  });
+  return cancelled ? null : choices[cursor].value;
+}
+async function multiSelect(message, entries) {
+  const itemPositions = entries.map((e, i) => e.kind === "item" ? i : -1).filter((i) => i >= 0);
+  if (itemPositions.length === 0) return [];
+  const selected = /* @__PURE__ */ new Set();
+  let ci = 0;
+  let top = 0;
+  let cancelled = false;
+  const viewH = Math.min(entries.length, Math.max(4, (out.rows || 24) - 5));
+  function cursorEntry() {
+    return itemPositions[ci];
+  }
+  function clampWindow() {
+    const cur = cursorEntry();
+    if (cur < top) top = cur;
+    else if (cur >= top + viewH) top = cur - viewH + 1;
+    top = Math.max(0, Math.min(top, Math.max(0, entries.length - viewH)));
+  }
+  function rowFor(entry, gi, width) {
+    if (entry.kind === "header") {
+      return c.dim("  " + clip(entry.label, width - 2));
+    }
+    const active = gi === cursorEntry();
+    const ptr = active ? c.cyan("\u276F") : " ";
+    const box = selected.has(entry.id) ? c.green("\u25C9") : c.dim("\u25EF");
+    const used = 4;
+    const hintLen = entry.hint ? entry.hint.length + 2 : 0;
+    const name = clip(entry.label, width - used - hintLen);
+    const nameC = active ? c.cyan(name) : name;
+    const room = width - used - name.length - 2;
+    const hint = entry.hint && room > 4 ? "  " + c.dim(clip(entry.hint, room)) : "";
+    return `${ptr} ${box} ${nameC}${hint}`;
+  }
+  function frame() {
+    clampWindow();
+    const width = termWidth();
+    const lines = [
+      `${c.bold(message)}  ${c.dim(`(${selected.size} selected)`)}`
+    ];
+    lines.push(
+      top > 0 ? c.dim(`  \u2191 ${top} more above`) : ""
+    );
+    for (let row = 0; row < viewH; row++) {
+      const gi = top + row;
+      lines.push(gi < entries.length ? rowFor(entries[gi], gi, width) : "");
+    }
+    const below = entries.length - (top + viewH);
+    lines.push(below > 0 ? c.dim(`  \u2193 ${below} more below`) : "");
+    lines.push(
+      c.dim("space toggle \xB7 a all/none \xB7 \u2191/\u2193 move \xB7 \u23CE confirm \xB7 esc cancel")
+    );
+    return lines.join("\n");
+  }
+  function move(delta) {
+    ci = (ci + delta + itemPositions.length) % itemPositions.length;
+  }
+  await run(frame, (key) => {
+    switch (key) {
+      case "up":
+        move(-1);
+        return "render";
+      case "down":
+        move(1);
+        return "render";
+      case "home":
+        ci = 0;
+        return "render";
+      case "end":
+        ci = itemPositions.length - 1;
+        return "render";
+      case "space": {
+        const e = entries[cursorEntry()];
+        if (e.kind === "item") {
+          if (selected.has(e.id)) selected.delete(e.id);
+          else selected.add(e.id);
+        }
+        return "render";
+      }
+      case "a": {
+        const allIds = itemPositions.map((p) => entries[p].id);
+        if (selected.size === allIds.length) selected.clear();
+        else for (const id of allIds) selected.add(id);
+        return "render";
+      }
+      case "enter":
+        return "done";
+      case "esc":
+      case "q":
+        cancelled = true;
+        return "done";
+      default:
+        return "ignore";
+    }
+  });
+  if (cancelled) return null;
+  return itemPositions.map((p) => entries[p].id).filter((id) => selected.has(id));
+}
+
 // src/resolve.ts
 var TYPE_ALIASES = {
   agent: "agent",
@@ -203,6 +442,12 @@ var PLURAL = {
   skill: "skills",
   command: "commands"
 };
+var SINGULAR = {
+  agent: "agent",
+  skill: "skill",
+  command: "command"
+};
+var TYPE_ORDER = ["agent", "skill", "command"];
 function requireNode20() {
   const major = Number(process.versions.node.split(".")[0]);
   if (major < 20) {
@@ -212,11 +457,64 @@ function requireNode20() {
     process.exit(1);
   }
 }
+function tilde(p) {
+  const home = homedir2();
+  return p === home || p.startsWith(home + "/") ? "~" + p.slice(home.length) : p;
+}
+function installItems(items, scope, force, opts) {
+  if (items.length === 0) {
+    console.log(c.dim("Nothing to install."));
+    return 0;
+  }
+  const root = installRoot(scope);
+  if (!opts.verbose) {
+    console.log(
+      c.dim(`Installing ${items.length} items into ${tilde(root)} \u2026`)
+    );
+  }
+  let written = 0;
+  let skipped = 0;
+  let failed = 0;
+  const writtenByType = { agent: 0, skill: 0, command: 0 };
+  for (const item of items) {
+    const result = installItem(item, { scope, force });
+    if (result.status === "written") {
+      written++;
+      writtenByType[item.type]++;
+      if (opts.verbose) {
+        console.log(c.green("\u2713 ") + `${item.id} ${c.dim("\u2192")} ${result.dest}`);
+      }
+    } else if (result.status === "exists") {
+      skipped++;
+      if (opts.verbose) {
+        console.log(
+          c.yellow("\u2022 ") + `${item.id} already installed at ${result.dest} ${c.dim("(use --force to overwrite)")}`
+        );
+      }
+    } else {
+      failed++;
+      console.error(c.red("\u2717 ") + `${item.id}: ${result.message}`);
+    }
+  }
+  if (!opts.verbose && written > 0) {
+    const parts = TYPE_ORDER.filter((t) => writtenByType[t] > 0).map(
+      (t) => `${writtenByType[t]} ${writtenByType[t] === 1 ? SINGULAR[t] : PLURAL[t]}`
+    );
+    console.log(c.green("\u2713 ") + `${parts.join(", ")} installed`);
+  }
+  const summary = [`${written} installed`];
+  if (skipped) summary.push(`${skipped} already present`);
+  if (failed) summary.push(`${failed} failed`);
+  console.log(c.dim(`${summary.join(", ")} \xB7 ${tilde(root)}`));
+  return failed > 0 ? 1 : 0;
+}
 function cmdAdd(refs, flags) {
   if (refs.length === 0) {
-    throw new CliError("Nothing to add \u2014 usage: agentscamp add <type>/<slug> [...more]");
+    throw new CliError(
+      "Nothing to add \u2014 usage: agentscamp add <type>/<slug> [...more] (or: agentscamp install)"
+    );
   }
-  const scope = resolveScope(flags);
+  const scope = resolveScope(flags, "project");
   const { items } = loadManifest();
   const resolutions = refs.map((ref) => resolveRef(ref, items));
   let resolutionFailed = false;
@@ -235,30 +533,81 @@ function cmdAdd(refs, flags) {
     }
   }
   if (resolutionFailed) return 1;
-  let written = 0;
-  let skipped = 0;
-  let failed = 0;
-  for (const r of resolutions) {
-    if (r.kind !== "ok") continue;
-    const result = installItem(r.item, { scope, force: flags.force });
-    if (result.status === "written") {
-      written++;
-      console.log(c.green("\u2713 ") + `${r.item.id} ${c.dim("\u2192")} ${result.dest}`);
-    } else if (result.status === "exists") {
-      skipped++;
-      console.log(
-        c.yellow("\u2022 ") + `${r.item.id} already installed at ${result.dest} ${c.dim("(use --force to overwrite)")}`
-      );
-    } else {
-      failed++;
-      console.error(c.red("\u2717 ") + `${r.item.id}: ${result.message}`);
+  const chosen = resolutions.flatMap((r) => r.kind === "ok" ? [r.item] : []);
+  return installItems(chosen, scope, flags.force, { verbose: true });
+}
+function pickerEntries(items) {
+  const entries = [];
+  for (const t of TYPE_ORDER) {
+    const list = items.filter((i) => i.type === t);
+    if (list.length === 0) continue;
+    entries.push({ kind: "header", label: `${PLURAL[t]} (${list.length})` });
+    for (const i of list) {
+      entries.push({ kind: "item", id: i.id, label: i.id, hint: i.title });
     }
   }
-  const summary = [`${written} installed`];
-  if (skipped) summary.push(`${skipped} already present`);
-  if (failed) summary.push(`${failed} failed`);
-  console.log(c.dim(summary.join(", ")));
-  return failed > 0 ? 1 : 0;
+  return entries;
+}
+async function interactiveInstall(items, scope, force) {
+  const count = (t) => items.filter((i) => i.type === t).length;
+  const choice = await selectOne("What do you want to install?", [
+    { value: "all", label: "Everything", hint: `${items.length} items` },
+    { value: "agent", label: "Agents only", hint: String(count("agent")) },
+    { value: "skill", label: "Skills only", hint: String(count("skill")) },
+    { value: "command", label: "Commands only", hint: String(count("command")) },
+    { value: "pick", label: "Pick individual items\u2026" },
+    { value: "cancel", label: "Cancel" }
+  ]);
+  if (choice === null || choice === "cancel") {
+    console.log(c.dim("Nothing installed."));
+    return 0;
+  }
+  let chosen;
+  if (choice === "all") {
+    chosen = items;
+  } else if (choice === "pick") {
+    const ids = await multiSelect("Select items to install", pickerEntries(items));
+    if (ids === null) {
+      console.log(c.dim("Nothing installed."));
+      return 0;
+    }
+    if (ids.length === 0) {
+      console.log(c.dim("No items selected \u2014 nothing installed."));
+      return 0;
+    }
+    const idSet = new Set(ids);
+    chosen = items.filter((i) => idSet.has(i.id));
+  } else {
+    chosen = items.filter((i) => i.type === choice);
+  }
+  return installItems(chosen, scope, force, { verbose: chosen.length <= 12 });
+}
+function cmdInstall(positionals, flags) {
+  const scope = resolveScope(flags, "global");
+  const { items } = loadManifest();
+  if (flags.all) {
+    return installItems(items, scope, flags.force, { verbose: false });
+  }
+  if (positionals.length > 0) {
+    const types = [];
+    for (const p of positionals) {
+      const t = normalizeType(p.toLowerCase());
+      if (!t) {
+        throw new CliError(
+          `"${p}" is not a type \u2014 use agents, skills or commands (to install one item: agentscamp add ${p})`
+        );
+      }
+      if (!types.includes(t)) types.push(t);
+    }
+    const chosen = items.filter((i) => types.includes(i.type));
+    return installItems(chosen, scope, flags.force, { verbose: false });
+  }
+  if (isInteractive()) {
+    return interactiveInstall(items, scope, flags.force);
+  }
+  throw new CliError(
+    "install needs a target in a non-interactive shell \u2014 try: agentscamp install --all (or: agents | skills | commands)"
+  );
 }
 function cmdList(typeArg) {
   const { items } = loadManifest();
@@ -291,7 +640,7 @@ ${c.bold(PLURAL[t])} ${c.dim(`(${list.length})`)}`);
     }
   }
   console.log(c.dim(`
-Install with: npx agentscamp add <id>`));
+Install everything: npx agentscamp --all   \xB7   one item: npx agentscamp add <id>`));
   return 0;
 }
 function cmdSearch(query) {
@@ -346,18 +695,26 @@ Install: ${c.cyan(`npx agentscamp add ${item.id}`)}
 `);
   return 0;
 }
-function main(argv) {
+async function main(argv) {
   requireNode20();
   const { command, positionals, flags } = parseArgs(argv);
   if (flags.version) {
     console.log(packageVersion());
     return 0;
   }
-  if (flags.help || !command) {
+  if (flags.help) {
+    printHelp(packageVersion());
+    return 0;
+  }
+  if (!command) {
+    if (flags.all || isInteractive()) return cmdInstall([], flags);
     printHelp(packageVersion());
     return 0;
   }
   switch (command) {
+    case "install":
+    case "i":
+      return cmdInstall(positionals, flags);
     case "add":
       return cmdAdd(positionals, flags);
     case "list":
@@ -368,17 +725,17 @@ function main(argv) {
       return cmdInfo(positionals[0]);
     default:
       throw new CliError(
-        `Unknown command "${command}" \u2014 commands: add, list, search, info (see --help)`
+        `Unknown command "${command}" \u2014 commands: install, add, list, search, info (see --help)`
       );
   }
 }
-try {
-  process.exitCode = main(process.argv.slice(2));
-} catch (e) {
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((e) => {
   if (e instanceof CliError) {
     console.error(c.red("\u2717 ") + e.message);
     process.exitCode = 1;
   } else {
     throw e;
   }
-}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentscamp",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Install AgentsCamp agents, skills, and slash commands into Claude Code from your terminal.",
   "license": "MIT",
   "type": "module",