@gonxped31/agent-kit 0.2.0 → 0.3.0

package/lib/merge.mjs

@@ -0,0 +1,225 @@
+// Additions: what a repo added to one of the kit's files, kept apart from the file, so a preset can
+// add it to whatever version of the file the kit has next. Each is a file of the same kind:
+// - JSON: an object holding only the added keys and list entries;
+// - Markdown: the added blocks (a bullet with its lines, a paragraph, a table row), each under the
+//   `## ` heading it goes under;
+// - other text: the added lines.
+// Code (scripts, hooks) doesn't merge by lines: a preset replaces such a file whole.
+
+export function kindOf(rel) {
+  if (/\.json$/i.test(rel)) return "json";
+  if (/\.md$/i.test(rel)) return "markdown";
+  if (/\.(mjs|cjs|js|ts|sh|bash|ps1|py)$/i.test(rel) || rel.startsWith(".githooks/")) return "code";
+  return "lines";
+}
+
+// ---- JSON
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+/** What `repo` has that `kit` hasn't: { keys (the path), value, array (an entry of the list at keys) }. */
+function jsonItems(repo, kit, keys = []) {
+  if (isObject(repo) && isObject(kit)) {
+    return Object.entries(repo).flatMap(([k, v]) => (k in kit ? jsonItems(v, kit[k], [...keys, k]) : [{ keys: [...keys, k], value: v }]));
+  }
+  if (Array.isArray(repo) && Array.isArray(kit)) {
+    return keys.length ? repo.filter((v) => !kit.some((w) => same(v, w))).map((value) => ({ keys, value, array: true })) : [];
+  }
+  return same(repo, kit) || !keys.length ? [] : [{ keys, value: repo }];
+}
+
+function buildJson(items) {
+  const root = {};
+  for (const { keys, value, array } of items) {
+    let node = root;
+    for (const k of keys.slice(0, -1)) node = node[k] ??= {};
+    const last = keys[keys.length - 1];
+    if (array) (node[last] ??= []).push(value);
+    else node[last] = value;
+  }
+  return `${JSON.stringify(root, null, 2)}\n`;
+}
+
+/** Objects merge key by key, lists get the entries they lack, anything else takes the addition. */
+function mergeValue(base, add) {
+  if (isObject(base) && isObject(add)) {
+    const merged = { ...base };
+    for (const [k, v] of Object.entries(add)) merged[k] = k in base ? mergeValue(base[k], v) : v;
+    return merged;
+  }
+  if (Array.isArray(base) && Array.isArray(add)) return [...base, ...add.filter((v) => !base.some((w) => same(v, w)))];
+  return add;
+}
+
+// ---- Markdown
+const START = /^([-*+]|\d+[.)])\s|^\||^#{1,6}\s|^(```|~~~)/;
+const FENCE = /^\s*(```|~~~)/;
+const isItem = (block) => /^([-*+]|\d+[.)])\s/.test(block);
+const key = (block) => block.split("\n").map((l) => l.trimEnd()).join("\n");
+
+/** The text before the first `## ` heading (heading ""), then each `## ` section. */
+function sections(text) {
+  const out = [{ heading: "", lines: [] }];
+  let fence = false;
+  for (const line of text.replace(/\n$/, "").split("\n")) {
+    if (FENCE.test(line)) fence = !fence;
+    if (!fence && /^## /.test(line)) out.push({ heading: line.trim(), lines: [] });
+    else out[out.length - 1].lines.push(line);
+  }
+  return out;
+}
+
+/** A section's blocks: a list item with its indented lines, a paragraph, a table row, a code block. */
+function blocks(lines) {
+  const out = [];
+  let current = null;
+  let fence = false;
+  for (const line of lines) {
+    if (fence) {
+      current.push(line);
+      if (FENCE.test(line)) fence = false;
+      continue;
+    }
+    if (!line.trim()) {
+      current = null;
+      continue;
+    }
+    if (!current || (!/^\s/.test(line) && START.test(line))) {
+      current = [line];
+      out.push(current);
+    } else {
+      current.push(line);
+    }
+    if (FENCE.test(line)) fence = true;
+  }
+  return out.map((b) => b.join("\n"));
+}
+
+function markdownItems(repo, kit, skipTop) {
+  const kitBlocks = new Map(sections(kit).map((s) => [s.heading, new Set(blocks(s.lines).map(key))]));
+  return sections(repo)
+    .filter((s) => !(skipTop && s.heading === ""))
+    .flatMap((s) => {
+      const have = kitBlocks.get(s.heading) ?? new Set();
+      return blocks(s.lines)
+        .filter((b) => !have.has(key(b)))
+        .map((text) => ({ heading: s.heading, text }));
+    });
+}
+
+function joinBlocks(texts) {
+  return texts.reduce((all, b, i) => (i === 0 ? b : `${all}${isItem(texts[i - 1]) && isItem(b) ? "\n" : "\n\n"}${b}`), "");
+}
+
+function buildMarkdown(items) {
+  const groups = new Map();
+  for (const { heading, text } of items) {
+    if (!groups.has(heading)) groups.set(heading, []);
+    groups.get(heading).push(text);
+  }
+  const top = groups.get("") ?? [];
+  groups.delete("");
+  const parts = [...(top.length ? [joinBlocks(top)] : []), ...[...groups].map(([heading, texts]) => `${heading}\n\n${joinBlocks(texts)}`)];
+  return `${parts.join("\n\n")}\n`;
+}
+
+/** Adds a block at the end of a section, keeping lists tight and other blocks a blank line apart. */
+function append(section, block) {
+  const lines = section.lines;
+  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+  const last = blocks(lines).pop();
+  if (!lines.length) {
+    if (section.heading) lines.push("");
+  } else if (!(last && isItem(last) && isItem(block))) {
+    lines.push("");
+  }
+  lines.push(...block.split("\n"));
+}
+
+function mergeMarkdown(baseText, addText) {
+  const base = sections(baseText);
+  const changed = new Set();
+  for (const add of sections(addText)) {
+    const added = blocks(add.lines);
+    if (!added.length) continue;
+    let target = base.find((s) => s.heading === add.heading);
+    if (!target) {
+      target = { heading: add.heading, lines: [] };
+      base.push(target);
+    }
+    const have = new Set(blocks(target.lines).map(key));
+    for (const b of added.filter((b) => !have.has(key(b)))) {
+      append(target, b);
+      have.add(key(b));
+      changed.add(target);
+    }
+  }
+  // A section that grew, or that a new section now follows, ends with a blank line.
+  base.forEach((s, i) => {
+    if (i < base.length - 1 && s.lines.length && s.lines[s.lines.length - 1].trim()) s.lines.push("");
+  });
+  const text = base.flatMap((s) => (s.heading ? [s.heading, ...s.lines] : s.lines)).join("\n");
+  return `${text.replace(/\n+$/, "")}\n`;
+}
+
+// ---- Lines
+const lineSet = (text) => new Set(text.split("\n").map((l) => l.trimEnd()));
+const lineItems = (repo, kit) => {
+  const have = lineSet(kit);
+  return [...new Set(repo.split("\n").map((l) => l.trimEnd()))].filter((l) => l.trim() && !have.has(l)).map((text) => ({ text }));
+};
+function mergeLines(base, add) {
+  const have = lineSet(base);
+  const extra = [...new Set(add.split("\n").map((l) => l.trimEnd()))].filter((l) => l.trim() && !have.has(l));
+  return extra.length ? `${base.replace(/\n*$/, "\n")}${extra.join("\n")}\n` : base;
+}
+
+// ---- By kind
+
+/**
+ * What a repo's version of a kit file adds to the kit's: a list of items, or null for code, which
+ * doesn't merge. CLAUDE.md's text before its first `## ` heading is the project's name and
+ * description, so it never counts.
+ */
+export function additionsOf(rel, repoText, kitText) {
+  switch (kindOf(rel)) {
+    case "json":
+      try {
+        return jsonItems(JSON.parse(repoText), JSON.parse(kitText));
+      } catch {
+        return null;
+      }
+    case "markdown":
+      return markdownItems(repoText, kitText, rel === "CLAUDE.md");
+    case "lines":
+      return lineItems(repoText, kitText);
+    default:
+      return null;
+  }
+}
+
+/** The additions file for chosen items of one file. */
+export function buildAdditions(rel, items) {
+  const kind = kindOf(rel);
+  if (kind === "json") return buildJson(items);
+  if (kind === "markdown") return buildMarkdown(items);
+  return `${items.map((i) => i.text).join("\n")}\n`;
+}
+
+/** A file with an additions file merged in. Throws on JSON that doesn't parse. */
+export function mergeAdditions(rel, baseText, addText) {
+  const kind = kindOf(rel);
+  if (kind === "json") return `${JSON.stringify(mergeValue(JSON.parse(baseText), JSON.parse(addText)), null, 2)}\n`;
+  if (kind === "markdown") return mergeMarkdown(baseText, addText);
+  return mergeLines(baseText, addText);
+}
+
+const clipText = (s, n = 72) => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
+
+/** One line saying what an addition is. */
+export function describeAddition(rel, item) {
+  const kind = kindOf(rel);
+  if (kind === "json") return clipText(`${item.keys.join(".")}${item.array ? "[]" : ""}: ${JSON.stringify(item.value)}`);
+  if (kind === "markdown") return clipText(`${item.heading ? `${item.heading.replace(/^##\s*/, "")}: ` : ""}${item.text.split("\n")[0]}`);
+  return clipText(item.text);
+}

package/lib/preset-commands.mjs

@@ -0,0 +1,320 @@
+// agk preset save | list | remove | add | pull. See presets.mjs for what a preset is.
+import fs from "node:fs";
+import path from "node:path";
+import { NOTHING_CHANGED, confirm, git, parse, repoRoot, run, said } from "./cli.mjs";
+import { VERSION, kitFiles, readRecord } from "./kit.mjs";
+import { kindOf } from "./merge.mjs";
+import { DEFAULT, candidates, describeCandidate, listPresets, loadPreset, loadPresetAt, powersOf, presetsDir, validName, writePreset } from "./presets.mjs";
+import { Failure, ask, blank, count, details, header, interactive, line, list, ok, out, step, warn } from "./ui.mjs";
+
+function checkName(name, command) {
+  if (!name) throw new Failure(`${command} needs a preset name`, { hint: `For example: agk ${command} web` });
+  if (!validName(name)) throw new Failure(`"${name}" can't be a preset name`, { hint: "Use letters, digits, dots, dashes and underscores, starting with a letter or digit." });
+}
+
+/** Numbers like "1,3-5" (from 1 to n), as indexes. */
+function numbers(spec, n) {
+  const picked = new Set();
+  for (const part of spec.split(",").map((p) => p.trim()).filter(Boolean)) {
+    const m = /^(\d+)(?:-(\d+))?$/.exec(part);
+    const [a, b] = m ? [Number(m[1]), Number(m[2] ?? m[1])] : [0, 0];
+    if (!m || a < 1 || b > n || a > b) throw new Failure(`"${spec}" isn't a choice: pick numbers from 1 to ${n}, like 1,3-5`);
+    for (let i = a; i <= b; i++) picked.add(i - 1);
+  }
+  return [...picked].sort((x, y) => x - y);
+}
+
+/**
+ * The candidates the user keeps: --all, --only 1,3-5, or an answer in a terminal. With --list,
+ * or with no terminal to ask in, it lists them and keeps none (null).
+ */
+async function choose(found, opts, vals, again) {
+  if (opts.has("--all")) return found;
+  if (vals["--only"]) return numbers(vals["--only"], found.length).map((i) => found[i]);
+  line(out.bold("What this repo has beyond the kit"));
+  found.forEach((c, i) => line(`  ${out.cyan(String(i + 1).padStart(3))}  ${describeCandidate(c)}`));
+  blank();
+  if (opts.has("--list") || !interactive) {
+    line(`Nothing is saved yet. To save, pick what's generic (not this project's own):`);
+    line(`  ${out.cyan(`${again} --only 1,3-5`)}   or   ${out.cyan(`${again} --all`)}`);
+    blank();
+    return null;
+  }
+  const answer = await ask("Keep which? Numbers like 1,3-5, all, or Enter for none:");
+  if (!answer) return [];
+  return /^all$/i.test(answer) ? found : numbers(answer, found.length).map((i) => found[i]);
+}
+
+/** Lines saying what a preset can run, or let Claude do. */
+function showPowers(preset) {
+  const p = powersOf(preset);
+  const lines = [
+    ...p.code.map((f) => `runs code: ${f}`),
+    ...p.hooks.map((h) => `adds a Claude hook: ${h}`),
+    ...p.allow.map((a) => `lets Claude run without asking: ${a}`),
+    ...(p.mcp ? ["adds MCP servers (.mcp.json)"] : []),
+  ];
+  if (!lines.length) return ok("It runs no code of its own and gives Claude no new permissions");
+  warn(`It can run code or widen what Claude may do. Read these before you agree:`);
+  details(lines);
+}
+
+const filesOf = (preset) => [...preset.files.map((f) => `file      ${f.to}`), ...preset.additions.map((a) => `adds to   ${a.to}`)];
+
+// ---- save
+
+async function save(args) {
+  const { opts, vals, pos } = parse("preset save", args, {
+    flags: ["--list", "--all", "--github", "--public"],
+    values: ["--only"],
+    max: 2,
+    what: "a name and a folder",
+  });
+  const [name, folder = "."] = pos;
+  checkName(name, "preset save");
+  if (opts.has("--public") && !opts.has("--github")) throw new Failure("--public goes with --github");
+  header(VERSION, `Saving preset ${name}`);
+  const root = repoRoot(path.resolve(folder), "preset save");
+  const record = readRecord(root);
+  if (!record) {
+    throw new Failure("This repo has no record of the kit's files", {
+      hint: "Run agk update first: it writes one (or agk setup, if the kit isn't set up here). Nothing was saved.",
+    });
+  }
+  if (record.version !== VERSION) {
+    throw new Failure(`This repo has the kit of agk v${record.version}, and this agk is v${VERSION}`, {
+      hint: "Run agk update first, so the preset holds your changes and not the kit's. Nothing was saved.",
+    });
+  }
+  const existing = loadPreset(name);
+  if (existing?.source) {
+    throw new Failure(`Preset ${name} is a copy of ${existing.source}`, { hint: "Save yours under another name. Nothing was saved." });
+  }
+  const found = candidates(root, kitFiles());
+  if (!found.length) {
+    ok("This repo has nothing beyond the kit to save");
+    blank();
+    return;
+  }
+  const again = `agk preset save ${name}${folder === "." ? "" : ` ${folder}`}`;
+  const chosen = await choose(found, opts, vals, again);
+  if (!chosen) return;
+  if (!chosen.length) {
+    line("Nothing was saved.");
+    blank();
+    return;
+  }
+  const dir = path.join(presetsDir(), name);
+  const meta = {
+    name,
+    savedWith: VERSION,
+    from: path.basename(root),
+    ...(opts.has("--github") && { defaults: { github: true, visibility: opts.has("--public") ? "public" : "private" } }),
+  };
+  const n = writePreset(dir, meta, chosen);
+  ok(`${existing ? "Replaced" : "Saved"} preset ${out.cyan(name)}: ${count(n.files, "file")}, additions to ${count(n.additions, "file")}`);
+  line(`  ${out.dim(dir)}`);
+  list("Next", [
+    `${out.cyan(`agk setup <folder> --preset ${name}`)} sets up a repo with it${name === DEFAULT ? " (agk setup uses it anyway)" : ""}`,
+    `To share it, make its folder a git repo and push it.\nOthers then run agk preset add <its URL>.`,
+  ]);
+}
+
+// ---- list
+
+function listCommand(args) {
+  parse("preset list", args, { max: 0, what: "nothing" });
+  header(VERSION, "Your presets");
+  const presets = listPresets();
+  if (!presets.length) {
+    line("No presets yet. Save one from a repo you've tuned: agk preset save <name>");
+  }
+  for (const p of presets) {
+    if (p.error) {
+      warn(`${p.name}: ${p.error.message}`);
+      continue;
+    }
+    const tag = p.name === DEFAULT ? out.dim(" (used by agk setup)") : "";
+    const where = p.source ? `from ${p.source} at ${p.commit}` : `saved from ${p.meta.from ?? "?"}`;
+    line(`${out.cyan(p.name)}${tag}  ${count(p.files.length, "file")}, additions to ${count(p.additions.length, "file")}  ${out.dim(where)}`);
+  }
+  blank();
+  line(out.dim(presetsDir()));
+  blank();
+}
+
+// ---- remove
+
+async function removeCommand(args) {
+  const { opts, pos } = parse("preset remove", args, { flags: ["--yes"], max: 1, what: "one name" });
+  checkName(pos[0], "preset remove");
+  const preset = loadPreset(pos[0]);
+  header(VERSION, `Removing preset ${pos[0]}`);
+  if (!preset) throw new Failure(`There's no preset named ${pos[0]}`, { hint: "agk preset list shows yours." });
+  line(out.dim(preset.dir));
+  if (!(await confirm(`Delete preset ${preset.name} and its folder?`, opts))) {
+    line("Nothing was deleted.");
+    blank();
+    return;
+  }
+  fs.rmSync(preset.dir, { recursive: true, force: true });
+  ok(`Deleted preset ${preset.name}. Repos set up with it keep their files.`);
+  blank();
+}
+
+// ---- add
+
+async function add(args) {
+  const { opts, vals, pos } = parse("preset add", args, {
+    flags: ["--yes", "--list", "--all"],
+    values: ["--name", "--only"],
+    max: 1,
+    what: "one git URL or folder",
+  });
+  const source = pos[0];
+  if (!source) throw new Failure("preset add needs a git URL or a folder", { hint: "For example: agk preset add https://github.com/someone/agk-web" });
+  if (vals["--name"]) checkName(vals["--name"], "preset add");
+  header(VERSION, "Adding a preset");
+  const dir = presetsDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const incoming = path.join(dir, `.incoming-${process.pid}-${Date.now()}`);
+  try {
+    await step(`Fetching ${source}`, async () => {
+      const r = await run("git", ["clone", "-q", source, incoming]);
+      if (r.error) throw new Failure("git isn't installed, or isn't on the PATH");
+      if (r.status !== 0) throw new Failure(`git couldn't fetch ${source}`, { details: said(r), hint: NOTHING_CHANGED });
+      return `Fetched ${source}`;
+    });
+    if (fs.existsSync(path.join(incoming, "preset.json"))) await addPresetRepo(source, incoming, opts, vals);
+    else if (fs.existsSync(path.join(incoming, ".claude", "agk.json"))) await addFromRepo(source, incoming, opts, vals);
+    else {
+      throw new Failure(`${source} is neither a preset nor a repo set up with agk`, {
+        hint: `A preset has a preset.json at its root; a repo set up with agk has .claude/agk.json. ${NOTHING_CHANGED}`,
+      });
+    }
+  } finally {
+    fs.rmSync(incoming, { recursive: true, force: true });
+  }
+}
+
+/** The name for a preset added from `source`: --name, else what it says, else the last part of its URL. */
+function nameFor(source, vals, said) {
+  const name = vals["--name"] ?? said ?? source.replace(/[\\/]+$/, "").replace(/\.git$/, "").split(/[\\/:]/).pop();
+  if (!validName(name)) throw new Failure(`"${name}" can't be a preset name`, { hint: `Name it with --name. ${NOTHING_CHANGED}` });
+  if (fs.existsSync(path.join(presetsDir(), name))) {
+    throw new Failure(`You have a preset named ${name} already`, { hint: `Name this one with --name. ${NOTHING_CHANGED}` });
+  }
+  return name;
+}
+
+/** A preset someone shared: kept as a clone, pinned at the commit fetched, after the user's OK. */
+async function addPresetRepo(source, incoming, opts, vals) {
+  const preset = loadPresetAt(incoming, "(new)");
+  const name = nameFor(source, vals, typeof preset.meta.name === "string" ? preset.meta.name : undefined);
+  const commit = git(incoming, "rev-parse", "--short", "HEAD").stdout.trim();
+  ok(`Preset ${out.cyan(name)} at ${commit}: ${count(preset.files.length, "file")}, additions to ${count(preset.additions.length, "file")}`);
+  details(filesOf(preset));
+  showPowers(preset);
+  if (!(await confirm(`Add preset ${name}?`, opts))) {
+    line(NOTHING_CHANGED);
+    blank();
+    return;
+  }
+  const final = path.join(presetsDir(), name);
+  fs.renameSync(incoming, final);
+  git(final, "config", "agk.source", source);
+  ok(`Added preset ${out.cyan(name)}, pinned at ${commit}`);
+  list("Next", [
+    `${out.cyan(`agk setup <folder> --preset ${name}`)} sets up a repo with it`,
+    `Later, ${out.cyan(`agk preset pull ${name}`)} fetches its changes, for you to review`,
+  ]);
+}
+
+/** Any repo set up with agk: its setup becomes a preset of the user's own, from the parts they pick. */
+async function addFromRepo(source, incoming, opts, vals) {
+  const name = nameFor(source, vals);
+  const record = readRecord(incoming);
+  if (record.version !== VERSION) {
+    warn(`It has the kit of agk v${record.version} (this is v${VERSION}): some differences may be the kit's own changes`);
+  }
+  const found = candidates(incoming, kitFiles());
+  if (!found.length) {
+    ok("It has nothing beyond the kit to copy");
+    blank();
+    return;
+  }
+  const again = `agk preset add ${source}${vals["--name"] ? ` --name ${name}` : ""}`;
+  const chosen = await choose(found, opts, vals, again);
+  if (!chosen) return;
+  if (!chosen.length) {
+    line("Nothing was saved.");
+    blank();
+    return;
+  }
+  const n = writePreset(path.join(presetsDir(), name), { name, savedWith: VERSION, from: source }, chosen);
+  const saved = loadPreset(name);
+  ok(`Saved preset ${out.cyan(name)} from ${source}: ${count(n.files, "file")}, additions to ${count(n.additions, "file")}`);
+  showPowers(saved);
+  list("Next", [`${out.cyan(`agk setup <folder> --preset ${name}`)} sets up a repo with it`]);
+}
+
+// ---- pull
+
+async function pull(args) {
+  const { opts, pos } = parse("preset pull", args, { flags: ["--yes"], max: 1, what: "one name" });
+  checkName(pos[0], "preset pull");
+  header(VERSION, `Updating preset ${pos[0]}`);
+  const preset = loadPreset(pos[0]);
+  if (!preset) throw new Failure(`There's no preset named ${pos[0]}`, { hint: "agk preset list shows yours." });
+  if (!preset.source) {
+    throw new Failure(`Preset ${preset.name} is your own, not a copy`, { hint: `It changes when you save it again: agk preset save ${preset.name}` });
+  }
+  await step(`Fetching ${preset.source}`, async () => {
+    const r = await run("git", ["fetch", "-q", "origin"], { cwd: preset.dir });
+    if (r.status !== 0) throw new Failure(`git couldn't fetch ${preset.source}`, { details: said(r), hint: NOTHING_CHANGED });
+    return `Fetched ${preset.source}`;
+  });
+  const ahead = Number(git(preset.dir, "rev-list", "--count", "HEAD..@{u}").stdout.trim() || 0);
+  if (!ahead) {
+    ok(`Preset ${preset.name} is up to date (${preset.commit})`);
+    blank();
+    return;
+  }
+  const changed = git(preset.dir, "diff", "--name-only", "HEAD", "@{u}").stdout.split("\n").filter(Boolean);
+  ok(`${count(ahead, "new commit")}, changing ${count(changed.length, "file")}`);
+  details(changed);
+  const risky = changed.filter((f) => kindOf(f) === "code" || /(^|\/)(settings\.json|\.mcp\.json)$/.test(f) || f.includes(".claude/hooks/"));
+  if (risky.length) {
+    warn(`${count(risky.length, "change")} can run code or change what Claude may do. To read ${risky.length === 1 ? "it" : "them"}:`);
+    details([`git -C "${preset.dir}" diff HEAD @{u}`]);
+  }
+  if (!(await confirm(`Take these changes?`, opts))) {
+    line(NOTHING_CHANGED);
+    blank();
+    return;
+  }
+  const r = git(preset.dir, "merge", "-q", "--ff-only", "@{u}");
+  if (r.status !== 0) throw new Failure("The preset's history doesn't follow on from yours", { details: said(r), hint: `Remove it and add it again. ${NOTHING_CHANGED}` });
+  const now = git(preset.dir, "rev-parse", "--short", "HEAD").stdout.trim();
+  ok(`Preset ${out.cyan(preset.name)} is now at ${now}`);
+  list("Next", [`Run ${out.cyan("agk update")} in each repo set up with it`]);
+}
+
+export async function presetCommand([sub, ...args]) {
+  switch (sub) {
+    case "save":
+      return save(args);
+    case "list":
+      return listCommand(args);
+    case "remove":
+      return removeCommand(args);
+    case "add":
+      return add(args);
+    case "pull":
+      return pull(args);
+    default:
+      throw new Failure(sub ? `Unknown preset command '${sub}'` : "agk preset needs a command", {
+        hint: "They are save, list, remove, add and pull: agk help says more.",
+      });
+  }
+}