@gonxped31/agent-kit 0.0.0-stage → 0.3.0

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.",
+      });
+  }
+}

package/lib/presets.mjs

@@ -0,0 +1,221 @@
+// Presets: a user's own setup, layered over the kit's. One folder per preset, on the user's machine:
+//
+//   ~/.config/agk/presets/<name>/     ($XDG_CONFIG_HOME/agk/presets when it's set)
+//     preset.json    { name, savedWith, from, defaults: { github, visibility } }
+//     files/         whole files, at their path in a repo (one can replace a kit file)
+//     additions/     additions to the kit's files, at the same paths (see merge.mjs)
+//
+// A preset added from a git repo is a clone of it; git config agk.source in the clone names the
+// repo, and its HEAD is the version in use until `agk preset pull`.
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { RECORD, SETUP_ONLY, hash, inRepo, lf, walk } from "./kit.mjs";
+import { additionsOf, buildAdditions, describeAddition, kindOf, mergeAdditions } from "./merge.mjs";
+import { Failure } from "./ui.mjs";
+
+export function presetsDir() {
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "agk", "presets");
+}
+
+export const validName = (name) => /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) && name.length <= 64;
+/** A preset under this name is used by agk setup unless told otherwise. */
+export const DEFAULT = "default";
+
+const gitOut = (dir, ...args) => {
+  const r = spawnSync("git", args, { cwd: dir, encoding: "utf8" });
+  return r.status === 0 ? r.stdout.trim() : null;
+};
+const isRepo = (dir) => fs.existsSync(path.join(dir, ".git"));
+
+/** The files under a preset's subfolder, as { to, text }. */
+function filesUnder(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return walk(dir).map((rel) => ({ to: rel.split(path.sep).join("/"), text: lf(path.join(dir, rel)) }));
+}
+
+/** The preset in `dir`, named `name`. Throws a Failure if it can't be used. */
+export function loadPresetAt(dir, name) {
+  let meta;
+  try {
+    meta = JSON.parse(fs.readFileSync(path.join(dir, "preset.json"), "utf8"));
+  } catch (e) {
+    throw new Failure(`The preset ${name} has no readable preset.json`, { details: [e.message], hint: `It's in ${dir}.` });
+  }
+  const files = filesUnder(path.join(dir, "files"));
+  const additions = filesUnder(path.join(dir, "additions"));
+  const bad = [...files, ...additions].find((f) => !inRepo(f.to) || f.to === SETUP_ONLY || f.to === RECORD || f.to.endsWith(".kit"));
+  if (bad) throw new Failure(`The preset ${name} has a file agk won't write: ${bad.to}`, { hint: `It's in ${dir}.` });
+  const repo = isRepo(dir);
+  return {
+    name,
+    dir,
+    meta: meta && typeof meta === "object" ? meta : {},
+    files,
+    additions,
+    source: repo ? gitOut(dir, "config", "--get", "agk.source") : null,
+    commit: repo ? gitOut(dir, "rev-parse", "--short", "HEAD") : null,
+  };
+}
+
+/** The preset named `name`, or null if there's none. */
+export function loadPreset(name) {
+  const dir = path.join(presetsDir(), name);
+  return validName(name) && fs.existsSync(path.join(dir, "preset.json")) ? loadPresetAt(dir, name) : null;
+}
+
+/** Every preset, by name. One that can't be read comes with its `error`. */
+export function listPresets() {
+  const dir = presetsDir();
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && validName(e.name) && fs.existsSync(path.join(dir, e.name, "preset.json")))
+    .map((e) => {
+      try {
+        return loadPresetAt(path.join(dir, e.name), e.name);
+      } catch (error) {
+        return { name: e.name, error };
+      }
+    })
+    .sort((a, b) => (a.name < b.name ? -1 : 1));
+}
+
+/**
+ * The files agk writes: the kit's, with a preset's files and additions on top. Each is
+ * { to, text, hash, preset } (preset: the preset added or changed it). A preset's addition to a
+ * file that isn't there is skipped, with a warning.
+ */
+export function compose(kit, preset) {
+  const map = new Map(kit.map((f) => [f.to, { to: f.to, text: f.text, preset: false }]));
+  const warnings = [];
+  if (preset) {
+    for (const f of preset.files) map.set(f.to, { to: f.to, text: f.text, preset: true, replaces: map.has(f.to) });
+    for (const a of preset.additions) {
+      const base = map.get(a.to);
+      if (!base) {
+        warnings.push(`Preset ${preset.name} adds to ${a.to}, which the kit doesn't have: skipped`);
+        continue;
+      }
+      try {
+        map.set(a.to, { ...base, text: mergeAdditions(a.to, base.text, a.text), preset: true, extends: true });
+      } catch (e) {
+        warnings.push(`Preset ${preset.name}'s additions to ${a.to} don't parse (${e.message}): skipped`);
+      }
+    }
+  }
+  const files = [...map.values()].map((f) => ({ ...f, hash: hash(f.text) })).sort((a, b) => (a.to < b.to ? -1 : 1));
+  return { files, warnings };
+}
+
+/** What a preset brings, in words: "2 files of its own, 3 of the kit's extended, 1 replaced". */
+export function presetSummary(files) {
+  const own = files.filter((f) => f.preset && !f.replaces && !f.extends).length;
+  const extended = files.filter((f) => f.extends && !f.replaces).length;
+  const replaced = files.filter((f) => f.replaces).length;
+  const parts = [
+    own && `${own} file${own === 1 ? "" : "s"} of its own`,
+    extended && `${extended} of the kit's extended`,
+    replaced && `${replaced} replaced`,
+  ].filter(Boolean);
+  return parts.length ? parts.join(", ") : "nothing beyond the kit";
+}
+
+/** What the record says about the preset used. */
+export const presetRecord = (preset, files) => ({
+  name: preset.name,
+  ...(preset.source && { source: preset.source }),
+  ...(preset.commit && { commit: preset.commit }),
+  files: files.filter((f) => f.preset).map((f) => f.to),
+});
+
+// ---- Saving: what a repo has beyond the kit
+
+/** Where a repo's agent setup lives: files elsewhere are the project's own, never a preset's. */
+const IN_SETUP = (rel) =>
+  /^(\.claude|\.githooks|\.github|scripts\/hooks)\//.test(rel) || rel === ".gitignore" || rel === ".mcp.json";
+/** Setup files that are never a preset's: the record, personal settings, merges in waiting. */
+const NEVER = (rel) => rel === RECORD || rel === ".claude/settings.local.json" || rel.endsWith(".kit");
+
+/**
+ * What a repo has beyond the kit, as candidates for a preset:
+ * - { type: "file", to, text }: a setup file the kit doesn't have;
+ * - { type: "addition", to, item }: something added to one of the kit's files;
+ * - { type: "replace", to, text }: a kit file changed in a way additions can't hold (code).
+ * Files come from git: tracked, and untracked but not ignored.
+ */
+export function candidates(root, kit) {
+  const r = spawnSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root, encoding: "utf8" });
+  const listed = r.status === 0 ? [...new Set(r.stdout.split("\0").filter(Boolean))].sort() : [];
+  const kitPaths = new Set(kit.map((f) => f.to));
+  const isFile = (rel) => fs.existsSync(path.join(root, rel)) && fs.statSync(path.join(root, rel)).isFile();
+  const out = [];
+  for (const rel of listed) {
+    if (!kitPaths.has(rel) && IN_SETUP(rel) && !NEVER(rel) && isFile(rel)) out.push({ type: "file", to: rel, text: lf(path.join(root, rel)) });
+  }
+  for (const f of kit) {
+    if (f.to === SETUP_ONLY || !isFile(f.to)) continue;
+    const here = lf(path.join(root, f.to));
+    if (here === f.text) continue;
+    const items = additionsOf(f.to, here, f.text);
+    if (items?.length) out.push(...items.map((item) => ({ type: "addition", to: f.to, item })));
+    // CLAUDE.md always differs (the bootstrap fills it in), and the project's own text is no preset's.
+    else if (f.to !== "CLAUDE.md") out.push({ type: "replace", to: f.to, text: here });
+  }
+  return out;
+}
+
+export function describeCandidate(c) {
+  if (c.type === "file") return `file       ${c.to}`;
+  if (c.type === "replace") return `replaces   ${c.to} (the kit's version)`;
+  return `addition   ${c.to}  ${describeAddition(c.to, c.item)}`;
+}
+
+/** Writes a preset from chosen candidates, replacing what the folder had (but a .git). */
+export function writePreset(dir, meta, chosen) {
+  fs.mkdirSync(dir, { recursive: true });
+  for (const e of fs.readdirSync(dir)) if (e !== ".git") fs.rmSync(path.join(dir, e), { recursive: true, force: true });
+  const write = (rel, text) => {
+    fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+    fs.writeFileSync(path.join(dir, rel), text);
+  };
+  write("preset.json", `${JSON.stringify(meta, null, 2)}\n`);
+  const additions = new Map();
+  for (const c of chosen) {
+    if (c.type === "addition") {
+      if (!additions.has(c.to)) additions.set(c.to, []);
+      additions.get(c.to).push(c.item);
+    } else {
+      write(path.posix.join("files", c.to), c.text);
+    }
+  }
+  for (const [to, items] of additions) write(path.posix.join("additions", to), buildAdditions(to, items));
+  return { files: chosen.filter((c) => c.type !== "addition").length, additions: additions.size };
+}
+
+// ---- Trust: what a preset lets run, or lets Claude do
+
+/** The Claude hooks a settings file adds, and the commands it lets Claude run without asking. */
+function settingsPowers(text) {
+  try {
+    const s = JSON.parse(text);
+    const hooks = Object.values(s.hooks ?? {}).flatMap((entries) => (Array.isArray(entries) ? entries : []).flatMap((e) => (e.hooks ?? []).map((h) => h.command).filter(Boolean)));
+    return { hooks, allow: Array.isArray(s.permissions?.allow) ? s.permissions.allow : [] };
+  } catch {
+    return { hooks: [], allow: [] };
+  }
+}
+
+/** What in a preset can run code or widen what Claude may do, to show before using it. */
+export function powersOf(preset) {
+  const all = [...preset.files, ...preset.additions];
+  const code = preset.files.filter((f) => kindOf(f.to) === "code" || f.to.startsWith(".claude/hooks/")).map((f) => f.to);
+  const settings = all.filter((f) => f.to === ".claude/settings.json").map((f) => settingsPowers(f.text));
+  return {
+    code,
+    hooks: settings.flatMap((s) => s.hooks),
+    allow: settings.flatMap((s) => s.allow),
+    mcp: all.some((f) => f.to === ".mcp.json"),
+  };
+}