@maycombhq/atticus 2.0.0-beta.26 → 2.0.0-beta.27

package/dist/bin.js

@@ -6,7 +6,7 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   VERSION
-} from "./chunk-MTIRNHRJ.js";
+} from "./chunk-T2MN24LZ.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/bin.js
@@ -25,7 +25,7 @@ else if ((await import("./chunk-QBNWF5ZU.js")).nodeTooOld(process.versions.node)
   process.exitCode = 1;
 } else {
   if (process.env.ATTICUS_MAX_OLD_SPACE) {
-    const { reExecForMemory } = await import("./chunk-YXKCE5BA.js");
+    const { reExecForMemory } = await import("./chunk-VWCNMDMZ.js");
     const again = reExecForMemory(process.env, process.execArgv);
     if (again) {
       const { spawnSync } = await import("node:child_process");
@@ -33,7 +33,7 @@ else if ((await import("./chunk-QBNWF5ZU.js")).nodeTooOld(process.versions.node)
       process.exit(r.status ?? 1);
     }
   }
-  const { main } = await import("./chunk-TYN5SG5H.js");
+  const { main } = await import("./chunk-FS4E7F6O.js");
   await main(
     argv,
     {

package/dist/chunk-22A2K555.js

@@ -0,0 +1,653 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  buildPlanOf,
+  pageChanged,
+  prunePlanHash,
+  undoPlanHash
+} from "./chunk-QCRQNYGI.js";
+import {
+  UPGRADE_UNDONE,
+  applyUndo,
+  baselineTarget,
+  buildAndWrite,
+  buildCatalog,
+  buildLines,
+  filesUnder,
+  generatedBeforeUpgradeDirOf,
+  guardBuild,
+  listUndo,
+  loadBuildInputs,
+  planUndo,
+  readBuildManifest,
+  takeUndoCopy,
+  undoDirOf,
+  undoHandEdits,
+  writeCuratedEdits
+} from "./chunk-QC6GSNIK.js";
+import "./chunk-YIGSUTW2.js";
+import "./chunk-N5DLB74D.js";
+import {
+  sha256Of
+} from "./chunk-UWBODTY7.js";
+import {
+  gitUser
+} from "./chunk-X5B7KYPD.js";
+import "./chunk-IPSZDVLI.js";
+import "./chunk-2MRYL45Z.js";
+import "./chunk-ELJ5Q4J2.js";
+import "./chunk-XZY4GTCX.js";
+import "./chunk-3M3MDBOG.js";
+import {
+  catalogDirOf,
+  deserializeRecord,
+  parseRecord,
+  recordPath,
+  serializeRecord
+} from "./chunk-WJWSB65O.js";
+import {
+  LockHeldError,
+  acquireLock,
+  writeFileAtomic
+} from "./chunk-SMFFUFMN.js";
+import {
+  cmpText
+} from "./chunk-A3LVMCA5.js";
+import "./chunk-NWMFVPEP.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-R4TUWD4C.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/catalog-build-commands.js
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, rm } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+var posix = (p) => p.split(sep).join("/");
+var listHooks = {};
+async function afterListed() {
+  const hook = listHooks.afterList;
+  listHooks.afterList = void 0;
+  await hook?.();
+}
+async function locked(root, what, io, run) {
+  await afterListed();
+  let lock;
+  try {
+    lock = await acquireLock(root, "scan", what);
+  } catch (e) {
+    if (e instanceof LockHeldError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  try {
+    return await run();
+  } finally {
+    await lock.release();
+  }
+}
+function buildJson(r) {
+  return {
+    written: r.write !== void 0,
+    files: r.write ? { written: r.write.written, unchanged: r.write.unchanged, removed: r.write.removed } : null,
+    slots: r.write?.slots ?? [],
+    sources: r.build.sources,
+    removed: (r.write?.removals ?? []).map((x) => ({
+      kind: x.kind,
+      id: x.id,
+      repos: x.repos,
+      explainedBy: x.explainedBy,
+      reasons: x.reasons
+    })),
+    retired: r.build.retired,
+    orphaned: r.build.orphaned,
+    orphanedDecisions: r.build.orphanedDecisions,
+    ...r.write?.undo !== void 0 ? { undo: r.write.undo } : {},
+    ...r.guard.refused ? { refused: r.guard.refused } : {}
+  };
+}
+function refusalHint(r, command) {
+  if (r.reasons.includes("not-upgraded"))
+    return "This catalog was written before beta.27: run atticus upgrade (it shows what it would do; atticus upgrade --yes applies it).";
+  if (r.reasons.includes("hand-edits"))
+    return `Files under catalog/generated were changed by hand. Make them curated: atticus catalog edits --curate, or discard them: ${command} --discard-edits ${r.discardEdits ?? 0}.`;
+  if (r.reasons.includes("unexplained-removals"))
+    return "The build would remove records nothing explains (a bug): nothing was written. The list is in the command's output.";
+  if (r.reasons.includes("large-removals"))
+    return `The build would remove ${r.allowRemovals ?? 0} records, more than the limit: confirm exactly these with ${command} --allow-removals ${r.allowRemovals ?? 0}.`;
+  if (r.reasons.includes("empty"))
+    return "The build has no record from any repo's code, so the catalog is left as it was.";
+  return r.message.split("\n")[0] ?? "Nothing written.";
+}
+function refuseChanged(io, json, message) {
+  io.err(message);
+  if (json)
+    io.out(JSON.stringify({ refused: { reasons: ["changed"], message } }, null, 2));
+  return 1;
+}
+async function catalogBuild(root, o, io) {
+  const command = "atticus catalog build";
+  const run = async () => {
+    let build;
+    if (o.plan !== void 0 && !o.check) {
+      const listed = await buildAndWrite(root, { command, check: true });
+      if (buildPlanOf(listed.guard) !== o.plan)
+        return refuseChanged(io, o.json, pageChanged("what the build would remove or discard"));
+      build = listed.build;
+    }
+    const r = await buildAndWrite(root, {
+      command,
+      ...build ? { build } : {},
+      ...o.check ? { check: true } : {},
+      ...o.allowRemovals !== void 0 ? { allowRemovals: o.allowRemovals } : {},
+      ...o.discardEdits !== void 0 ? { discardEdits: o.discardEdits } : {}
+    });
+    if (o.check) {
+      if (o.json)
+        io.out(JSON.stringify({ upToDate: r.upToDate, sources: r.build.sources }, null, 2));
+      else
+        io.out(r.upToDate ? "catalog/generated is what the slots and inputs build." : "catalog/generated isn't what the slots and inputs build: run atticus catalog build.");
+      return r.upToDate ? 0 : 1;
+    }
+    if (o.json)
+      io.out(JSON.stringify(buildJson(r), null, 2));
+    else {
+      for (const s of r.build.sources)
+        io.out(`${s.repo}: ${s.source === "none" ? "no slot yet" : `${s.source}${s.commit ? ` at ${s.commit.slice(0, 7)}` : ""}`}`);
+      for (const l of buildLines(root, r))
+        (r.guard.refused ? io.err : io.out)(l);
+    }
+    for (const p of r.build.problems)
+      if (!o.json)
+        io.err(`${p.repo ? `${p.repo}: ` : ""}${p.source}: ${p.message}`);
+    return r.guard.refused ? 1 : 0;
+  };
+  const code = o.check ? await run() : await locked(root, command, io, run);
+  return code;
+}
+function undoneRenames(copies) {
+  return netRenames(copies.map((c) => c.command)).map(({ from, to }) => ({
+    from,
+    to,
+    message: renameUndone(from, to)
+  }));
+}
+function netRenames(commandsNewestFirst) {
+  const chain = [];
+  for (const command of [...commandsNewestFirst].reverse()) {
+    const m = /^atticus repo rename (\S+) (\S+)(?: |$)/.exec(command);
+    if (!m)
+      continue;
+    const [, from, to] = m;
+    const was = chain.find((r) => r.to === from);
+    if (was)
+      was.to = to;
+    else
+      chain.push({ from, to });
+  }
+  return chain.filter((r) => r.from !== r.to);
+}
+var renameUndone = (from, to) => `This undoes the rename's build, not the rename: the manifest still names ${to}. Rename back with atticus repo rename ${to} ${from} to read the old slot again.`;
+async function catalogUndo(root, o, io) {
+  const undoDir = await undoDirOf(root);
+  const list = await listUndo(undoDir);
+  const plan = await planUndo(undoDir, o.n);
+  if ("problem" in plan) {
+    if (o.json)
+      io.out(JSON.stringify({ copies: list, problem: plan.problem }, null, 2));
+    else
+      io.err(plan.problem);
+    return 1;
+  }
+  const renames = undoneRenames(plan.copies);
+  if (!o.yes) {
+    if (o.json)
+      io.out(JSON.stringify({ copies: list, plan, renames }, null, 2));
+    else {
+      io.out(`The last ${list.length} builds kept here, newest first:`);
+      list.forEach((c, i) => io.out(`  ${i + 1}: ${c.command} (${c.at}, ${c.files.length} files)`));
+      io.out(`atticus catalog undo${o.n !== void 0 ? ` ${o.n}` : ""} --yes would put back ${plan.files.length} ${plan.files.length === 1 ? "file" : "files"} as they were before ${plan.copies.length === 1 ? `the latest build (${plan.copies[0].command})` : `the ${plan.copies.length} latest builds`}:`);
+      for (const f of plan.files.slice(0, 30))
+        io.out(`  ${f.to === "absent" ? "remove" : "restore"} ${f.path}`);
+      if (plan.files.length > 30)
+        io.out(`  and ${plan.files.length - 30} more`);
+      for (const x of renames)
+        io.out(x.message);
+    }
+    return 0;
+  }
+  return locked(root, "atticus catalog undo", io, async () => {
+    const again = await planUndo(undoDir, o.n);
+    if ("problem" in again || JSON.stringify(again) !== JSON.stringify(plan)) {
+      const why = changedMeanwhile("atticus catalog undo");
+      io.err(why);
+      if (o.json)
+        io.out(JSON.stringify({ refused: { reasons: ["changed"], message: why } }, null, 2));
+      return 1;
+    }
+    if (o.plan !== void 0 && undoPlanHash(again) !== o.plan)
+      return refuseChanged(io, o.json, pageChanged("what the undo puts back"));
+    const b = await buildCatalog(await loadBuildInputs(root));
+    const g = await guardBuild(b, { undoDir, command: "atticus catalog build" });
+    if (g.refused?.reasons.includes("hand-edits")) {
+      io.err("Nothing undone: files under catalog/generated were changed by hand since the last build. Make them curated (atticus catalog edits --curate) or discard them (atticus catalog build --discard-edits <count>) first.");
+      if (o.json)
+        io.out(JSON.stringify({ refused: { reasons: ["hand-edits"], edits: g.refused.edits } }, null, 2));
+      return 1;
+    }
+    if (g.refused?.reasons.includes("not-upgraded")) {
+      const edited = await undoHandEdits(root, plan);
+      if (edited.length) {
+        io.err(`Nothing undone: ${edited.length} ${edited.length === 1 ? "file was" : "files were"} changed since ${plan.copies[0].command} wrote ${edited.length === 1 ? "it" : "them"}: ${edited.slice(0, 10).join(", ")}${edited.length > 10 ? ` and ${edited.length - 10} more` : ""}. Put ${edited.length === 1 ? "it" : "them"} back as ${edited.length === 1 ? "it was" : "they were"}, or keep ${edited.length === 1 ? "it" : "them"} and run atticus upgrade --yes.`);
+        if (o.json)
+          io.out(JSON.stringify({ refused: { reasons: ["hand-edits"], edits: edited.map((path) => ({ path })) } }, null, 2));
+        return 1;
+      }
+    }
+    const r = await applyUndo(root, undoDir, plan, `atticus catalog undo${o.n !== void 0 ? ` ${o.n}` : ""}`);
+    const m = await readBuildManifest(baselineTarget(root).manifest);
+    const bad = [];
+    for (const f of m.manifest?.files ?? []) {
+      const text = await readFile(join(root, ...f.path.split("/")), "utf8").catch(() => void 0);
+      if (text === void 0 || sha256Of(text.replace(/\r\n?/g, "\n")) !== f.sha256)
+        bad.push(f.path);
+    }
+    if (o.json)
+      io.out(JSON.stringify({ restored: r.restored, undo: r.undo, handEdits: bad, renames }, null, 2));
+    else {
+      io.out(`Put back ${r.restored.length} ${r.restored.length === 1 ? "file" : "files"} as ${r.restored.length === 1 ? "it was" : "they were"} before ${plan.copies.map((c) => c.command).join(", then ")}.`);
+      if (r.undo !== void 0)
+        io.out(`This undo can be undone too: atticus catalog undo --yes (copy ${r.undo}).`);
+      if (plan.copies.some((c) => c.command.startsWith("atticus upgrade")))
+        io.out(UPGRADE_UNDONE);
+      for (const x of renames)
+        io.out(x.message);
+      if (bad.length)
+        io.out(`${bad.length} restored ${bad.length === 1 ? "file is a hand edit" : "files are hand edits"} again, as before (the next build lists ${bad.length === 1 ? "it" : "them"}: atticus catalog edits --curate keeps ${bad.length === 1 ? "it" : "them"}): ${bad.join(", ")}`);
+    }
+    return 0;
+  });
+}
+var changedMeanwhile = (command) => `Nothing written: what ${command} would change isn't what it listed any more (another command wrote meanwhile). Run it again to list it.`;
+async function pruneList(root) {
+  const b = await buildCatalog(await loadBuildInputs(root));
+  return [
+    ...b.orphaned.flatMap((x) => x.files.map((f) => ({
+      path: f,
+      why: x.why === "archived" ? `${x.repo} is archived` : `${x.repo} isn't in the manifests`
+    }))),
+    ...(await filesUnder(generatedBeforeUpgradeDirOf(root))).map((p) => ({
+      path: posix(relative(root, p)),
+      why: "the copy the upgrade kept of the catalog before it"
+    }))
+  ].sort((a, x) => cmpText(a.path, x.path));
+}
+async function catalogPrune(root, o, io) {
+  const files = await pruneList(root);
+  if (!files.length) {
+    if (o.json)
+      io.out(JSON.stringify({ files: [], removed: [] }, null, 2));
+    else
+      io.out("Nothing to prune: every slot file is one a build reads.");
+    return 0;
+  }
+  if (!o.yes) {
+    if (o.json)
+      io.out(JSON.stringify({ files, removed: [] }, null, 2));
+    else {
+      io.out(`${files.length} ${files.length === 1 ? "file" : "files"} no build reads:`);
+      for (const f of files)
+        io.out(`  ${f.path} (${f.why})`);
+      io.out("Nothing removed. atticus catalog prune --yes removes exactly these (atticus catalog undo and git keep them).");
+    }
+    return 0;
+  }
+  return locked(root, "atticus catalog prune", io, async () => {
+    const again = await pruneList(root);
+    if (o.plan !== void 0 && prunePlanHash(again) !== o.plan)
+      return refuseChanged(io, o.json, pageChanged("what prune removes"));
+    if (JSON.stringify(again) !== JSON.stringify(files)) {
+      const why = changedMeanwhile("atticus catalog prune");
+      io.err(why);
+      if (o.json)
+        io.out(JSON.stringify({ files, removed: [], refused: { reasons: ["changed"], message: why } }, null, 2));
+      return 1;
+    }
+    const undoDir = await undoDirOf(root);
+    const touched = files.map((f) => ({ path: join(root, ...f.path.split("/")), text: null }));
+    const undo = await takeUndoCopy(root, undoDir, "atticus catalog prune", touched);
+    for (const t of touched)
+      await rm(t.path, { force: true });
+    if (o.json)
+      io.out(JSON.stringify({ files, removed: files.map((f) => f.path), undo }, null, 2));
+    else {
+      io.out(`Removed ${files.length} ${files.length === 1 ? "file" : "files"}:`);
+      for (const f of files)
+        io.out(`  ${f.path}`);
+      if (undo !== void 0)
+        io.out(`atticus catalog undo --yes puts them back (copy ${undo}).`);
+    }
+    return 0;
+  });
+}
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
+var PROTECTED = /* @__PURE__ */ new Set(["kind", "id", "schemaVersion", "confidence", "evidence"]);
+function cantSay(p) {
+  const removed = p.removed ?? [];
+  const changed = (p.fields ?? []).filter((f) => !removed.includes(f));
+  const what = [
+    ...changed.length ? [`changes ${changed.join(", ")}`] : [],
+    ...removed.length ? [`removes ${removed.join(", ")}`] : []
+  ].join(" and ");
+  const verb = changed.length && removed.length ? "set or remove" : removed.length ? "remove" : "set";
+  return `${what}, which a curated decision can't ${verb}`;
+}
+async function planEdits(root, undoDir) {
+  const inputs = await loadBuildInputs(root);
+  const b = await buildCatalog(inputs);
+  const g = await guardBuild(b, { undoDir, command: "atticus catalog build" });
+  const edits = g.refused?.reasons.includes("hand-edits") ? g.refused.edits ?? [] : [];
+  const built = new Map(b.records.map((r) => [recordPath(r), r]));
+  const genRel = posix(relative(root, join(catalogDirOf(root), "generated")));
+  let restored;
+  const asLastBuilt = async (rel) => {
+    if (!restored) {
+      restored = /* @__PURE__ */ new Map();
+      const op = inputs.op;
+      const listed = new Set(op.profiles.flatMap((p) => (p.repos?.repos ?? []).map((r) => r.id)));
+      const archived = new Set(op.profiles.flatMap((p) => (p.repos?.repos ?? []).filter((r) => r.archived)));
+      const removed = [...inputs.slots.readers].filter(([repo]) => !listed.has(repo)).flatMap(([repo, x]) => {
+        const c = "slot" in x ? x.slot.records.find((r) => r.kind === "Component") : void 0;
+        return c && typeof c.type === "string" ? [
+          {
+            id: repo,
+            url: repo,
+            defaultBranch: "main",
+            branches: [],
+            type: c.type,
+            owner: "unknown",
+            component: c.id,
+            ...typeof c.system === "string" ? { system: c.system } : {},
+            extractors: [],
+            dialects: [],
+            sparse: [],
+            archived: false,
+            hosts: [],
+            modules: []
+          }
+        ] : [];
+      });
+      const at = op.profiles.findIndex((p) => p.repos);
+      if ((archived.size || removed.length) && at >= 0) {
+        const back = {
+          ...op,
+          profiles: op.profiles.map((p, k) => p.repos ? {
+            ...p,
+            repos: {
+              ...p.repos,
+              repos: [
+                ...p.repos.repos.map((r) => r.archived ? { ...r, archived: false } : r),
+                ...k === at ? removed : []
+              ]
+            }
+          } : p)
+        };
+        const a = await buildCatalog({ ...inputs, op: back });
+        const m = await readBuildManifest(baselineTarget(root).manifest);
+        const shas = new Map((m.manifest?.files ?? []).map((f) => [f.path, f.sha256]));
+        const fromRemoved = new Set(removed.map((r) => r.id));
+        for (const r of a.records) {
+          const p = recordPath(r);
+          const ev = new Set((r.evidence ?? []).map((e) => e.repo).filter(Boolean));
+          if ([...ev].some((x) => fromRemoved.has(String(x)))) {
+            const text = a.files.get(p);
+            const want = shas.get(`${genRel}/${p}`);
+            if (text === void 0 || want === void 0 || sha256Of(text) !== want)
+              continue;
+          }
+          restored.set(p, r);
+        }
+      }
+    }
+    return restored.get(rel);
+  };
+  const out = [];
+  Object.defineProperty(out, "buildPlan", {
+    value: buildPlanOf(g),
+    enumerable: false
+  });
+  for (const e of edits) {
+    const rel = e.path.startsWith(`${genRel}/`) ? e.path.slice(genRel.length + 1) : e.path;
+    const derivedNow = built.get(rel);
+    const plan = (x) => out.push({ path: e.path, how: e.how, ...x });
+    if (e.how === "deleted") {
+      const id = derivedNow?.id ?? (rel.split("/").pop() ?? "").replace(/\.ya?ml$/, "");
+      plan({ decision: { action: "suppress", target: id, value: null } });
+      continue;
+    }
+    if (e.how === "added") {
+      plan({
+        why: derivedNow ? "the build makes a record of its id: change that record instead" : "an added record can't be a curated decision (a decision changes or suppresses a record the build makes); discard it, or say it where the build reads it: a fact in facts/<repo>.jsonl that verify --write checks, or a rule in the org pack"
+      });
+      continue;
+    }
+    const text = await readFile(join(root, ...e.path.split("/")), "utf8").catch(() => "");
+    const p = deserializeRecord(text);
+    const fromSlot = () => {
+      if (!p.ok)
+        return void 0;
+      const { kind, id } = p.record;
+      const held = [
+        ...[...inputs.slots.readers.values()].flatMap((x) => "slot" in x ? x.slot.records : []),
+        ...inputs.slots.legacy && "slot" in inputs.slots.legacy ? inputs.slots.legacy.slot.records : []
+      ];
+      return held.find((r) => r.kind === kind && r.id === id);
+    };
+    const derived = derivedNow ?? await asLastBuilt(rel) ?? fromSlot();
+    if (!p.ok || !derived) {
+      plan({ why: "it doesn't read as a record, or the build no longer makes it" });
+      continue;
+    }
+    const now = p.record;
+    const was = derived;
+    const value = {};
+    const bad = [];
+    const removed = [];
+    for (const k of [.../* @__PURE__ */ new Set([...Object.keys(now), ...Object.keys(was)])].sort(cmpText)) {
+      if (JSON.stringify(now[k]) === JSON.stringify(was[k]))
+        continue;
+      if (!(k in now))
+        removed.push(k);
+      if (PROTECTED.has(k) || !(k in now))
+        bad.push(k);
+      else
+        value[k] = now[k];
+    }
+    const said = { fields: bad, ...removed.length ? { removed } : {} };
+    if (bad.length && !Object.keys(value).length) {
+      plan({ why: `it only ${cantSay(said)}`, ...said });
+      continue;
+    }
+    if (!Object.keys(value).length) {
+      plan({
+        why: "its record says the same as the build's (a comment or the layout): discard it"
+      });
+      continue;
+    }
+    plan({
+      decision: { action: "assert", target: derived.id, value },
+      ...bad.length ? said : {}
+    });
+  }
+  return out;
+}
+async function catalogEdits(root, o, io) {
+  const undoDir = await undoDirOf(root);
+  const listed = await planEdits(root, undoDir);
+  const edits = listed.map((p) => ({ path: p.path, how: p.how }));
+  if (!edits.length) {
+    if (o.json)
+      io.out(JSON.stringify({ edits: [], decisions: [] }, null, 2));
+    else
+      io.out("No file under catalog/generated was changed by hand since the last build.");
+    return 0;
+  }
+  const dropping = listed.filter((p) => p.decision && p.fields?.length);
+  if (!o.curate) {
+    if (o.json)
+      io.out(JSON.stringify({
+        edits,
+        decisions: [],
+        ...dropping.length ? { dropFields: dropping.length, fields: dropping.map((p) => pick(p)) } : {}
+      }, null, 2));
+    else {
+      io.out(`${edits.length} ${edits.length === 1 ? "file was" : "files were"} changed by hand since the last build:`);
+      for (const e of listed)
+        io.out(`  ${e.how}: ${e.path}${e.fields?.length ? ` (${cantSay(e)})` : ""}`);
+      io.out(`Make them curated decisions: atticus catalog edits --curate${dropping.length ? ` --drop-fields ${dropping.length}` : ""}. Or discard them: atticus catalog build --discard-edits ${edits.length}.`);
+    }
+    return 1;
+  }
+  return locked(root, "atticus catalog edits --curate", io, async () => {
+    const plans = await planEdits(root, undoDir);
+    if (JSON.stringify(plans) !== JSON.stringify(listed)) {
+      const why = "Nothing written: the hand edits changed while this ran (another command wrote meanwhile). Run atticus catalog edits again to list them.";
+      io.err(why);
+      if (o.json)
+        io.out(JSON.stringify({ edits, decisions: [], refused: { message: why } }, null, 2));
+      return 1;
+    }
+    if (o.plan !== void 0 && plans.buildPlan !== o.plan)
+      return refuseChanged(io, o.json, pageChanged("the hand edits"));
+    const by = o.by ?? (await gitUser(root)).handle;
+    const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+    const curatedDir = join(catalogDirOf(root), "curated");
+    const written = [];
+    const curated = [];
+    const left = [];
+    const kept = [];
+    const confirmed = o.dropFields === dropping.length;
+    for (const p of plans) {
+      if (!p.decision) {
+        left.push({ path: p.path, why: p.why ?? "it can't be made curated" });
+        continue;
+      }
+      if (p.fields?.length && !confirmed) {
+        left.push({
+          path: p.path,
+          why: `it also ${cantSay(p)} (the next build would put ${p.fields.length === 1 ? "it" : "them"} back): make it curated without ${p.fields.length === 1 ? "it" : "them"} with atticus catalog edits --curate --drop-fields ${dropping.length}`,
+          fields: p.fields
+        });
+        continue;
+      }
+      const placed = await decisionFor(curatedDir, slug(`cd-edit-${String(p.decision.action)}-${String(p.decision.target)}`), p.decision, at);
+      if ("keep" in placed) {
+        kept.push({
+          path: p.path,
+          decision: `${posix(relative(root, curatedDir))}/curateddecision/${placed.keep}`
+        });
+        curated.push(p.path);
+        continue;
+      }
+      const record = parseRecord({
+        kind: "CuratedDecision",
+        id: placed.id,
+        schemaVersion: 2,
+        status: "current",
+        confidence: "asserted",
+        ...p.decision,
+        reason: `A hand edit to ${p.path}, made curated (atticus catalog edits --curate).`,
+        by,
+        at: placed.at
+      });
+      if (!record.ok) {
+        left.push({ path: p.path, why: record.issues.map((i) => i.message).join("; ") });
+        continue;
+      }
+      const full = join(curatedDir, ...recordPath(record.record).split("/"));
+      await mkdir(dirname(full), { recursive: true });
+      await writeFileAtomic(full, serializeRecord(record.record));
+      written.push(posix(relative(root, full)));
+      curated.push(p.path);
+    }
+    if (o.dropFields !== void 0 && !confirmed)
+      left.push({
+        path: "--drop-fields",
+        why: `${o.dropFields} doesn't name the ${dropping.length} listed`
+      });
+    await writeCuratedEdits(root, undoDir, curated);
+    if (o.json)
+      io.out(JSON.stringify({
+        edits,
+        decisions: written,
+        ...kept.length ? { kept } : {},
+        left,
+        ...dropping.length ? { dropFields: dropping.length } : {},
+        ...confirmed && dropping.length ? { dropped: dropping.map((p) => pick(p)) } : {}
+      }, null, 2));
+    else {
+      for (const w of written)
+        io.out(`Wrote ${w}: propose it in a pull request so every build keeps the edit.`);
+      for (const k of kept)
+        io.out(`${k.path}: ${k.decision} already says this edit (left as it is).`);
+      if (confirmed)
+        for (const d of dropping)
+          io.out(`${d.path}: made curated without ${d.fields.join(", ")}, which the next build puts back as it makes ${d.fields.length === 1 ? "it" : "them"}.`);
+      for (const l of left)
+        io.err(`${l.path}: not made curated: ${l.why}.`);
+      if (written.length)
+        io.out("atticus catalog build (or the next scan) builds with them, and replaces the edited files; their bytes are kept for atticus catalog undo.");
+      if (left.length)
+        io.err(`What isn't curated stays a hand edit: discard it with atticus catalog build --discard-edits <count> (a copy is kept for undo).`);
+    }
+    return left.length ? 1 : 0;
+  });
+}
+var pick = (p) => ({
+  path: p.path,
+  fields: p.fields ?? [],
+  ...p.removed?.length ? { removed: p.removed } : {}
+});
+async function decisionFor(curatedDir, id, decision, now) {
+  const dir = join(curatedDir, "curateddecision");
+  const held = [];
+  for (const n of (await readdir(dir).catch(() => [])).sort(cmpText)) {
+    if (!/\.ya?ml$/.test(n))
+      continue;
+    const p = deserializeRecord(await readFile(join(dir, n), "utf8").catch(() => ""));
+    const d = p.ok ? p.record : void 0;
+    if (d?.kind === "CuratedDecision" && d.target === decision.target)
+      held.push({ file: n, d });
+  }
+  const same = held.find(({ d }) => decision.action === "suppress" && d.action === "suppress" && d.status === "current" && (d.value ?? null) === null);
+  if (same)
+    return { keep: same.file };
+  let at = now;
+  const latest = held.map(({ d }) => typeof d.at === "string" ? Date.parse(d.at) : NaN).filter((x) => !Number.isNaN(x)).reduce((m, x) => Math.max(m, x), -Infinity);
+  if (latest !== -Infinity && Date.parse(at) <= latest)
+    at = new Date(Math.floor(latest / 1e3) * 1e3 + 1e3).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const fileOf = (x) => join(dir, `${x}.yaml`);
+  if (!existsSync(fileOf(id)))
+    return { id, at };
+  for (let n = 2; ; n++)
+    if (!existsSync(fileOf(`${id}-${n}`)))
+      return { id: `${id}-${n}`, at };
+}
+export {
+  afterListed,
+  buildJson,
+  catalogBuild,
+  catalogEdits,
+  catalogPrune,
+  catalogUndo,
+  listHooks,
+  netRenames,
+  pruneList,
+  refusalHint,
+  renameUndone,
+  undoneRenames
+};

package/dist/{chunk-UTZMF5CV.js → chunk-23TTURB2.js}

@@ -5,7 +5,7 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   external_exports
-} from "./chunk-LZFKJ2BR.js";
+} from "./chunk-A3LVMCA5.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";