@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-B2WLAWNJ.js

@@ -0,0 +1,374 @@
+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 {
+  changeStore
+} from "./chunk-XY3P7JW7.js";
+import {
+  readCatalog
+} from "./chunk-27NKUS3X.js";
+import {
+  catalogDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/site-commands.js
+import { resolve, join as join2 } from "node:path";
+
+// packages/site/dist/guide.js
+var HIDDEN = "a system that isn't on this site";
+function src(r) {
+  const e = r.evidence[0];
+  if (!e)
+    return "";
+  const where = [e.repo, e.path].filter(Boolean).join("/");
+  return where ? `${where}${e.line ? `:${e.line}` : ""}` : e.source;
+}
+var cite = (r) => src(r) ? ` _(${src(r)})_` : "";
+var cell = (s) => String(s ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
+function systemGuide(records, id, o = {}) {
+  const all = records;
+  const by = (kind) => all.filter((r) => r.kind === kind);
+  const sys = by("System").find((r) => r.id === id);
+  if (!sys)
+    throw new Error(`There is no system ${id} in the catalog.`);
+  const visible = o.visible ?? (() => true);
+  const components = by("Component").filter((c) => c.system === id);
+  const compIds = new Set(components.map((c) => c.id));
+  const systemOfComp = new Map(by("Component").map((c) => [c.id, String(c.system)]));
+  const sysOf = (ref) => systemOfComp.get(ref) ?? (by("System").some((s) => s.id === ref) ? ref : void 0);
+  const nameOf = (ref) => {
+    const s = sysOf(ref);
+    if (s && !visible(s))
+      return HIDDEN;
+    return s && s !== ref && s !== id ? `${ref} (${s})` : ref;
+  };
+  const gaps = [];
+  const out = [];
+  out.push(`# ${String(sys.name)} (${id})`, "");
+  out.push(`${cap(String(sys.boundary))} system \xB7 confidence: ${sys.confidence}${sys.owner ? ` \xB7 owner: ${String(sys.owner)}` : ""}${cite(sys)}`, "");
+  if (!sys.owner) {
+    out.push("No owner recorded.", "");
+    gaps.push("owner");
+  }
+  const repos = sys.repos ?? [];
+  if (repos.length)
+    out.push(`Repos: ${repos.join(", ")}`, "");
+  out.push("## What it is made of", "");
+  if (components.length === 0) {
+    out.push("No components in the catalog.", "");
+    gaps.push("components");
+  } else {
+    out.push("| Component | Type | Runs on | Repo |", "| --- | --- | --- | --- |");
+    for (const c of components)
+      out.push(`| ${c.id} | ${cell(c.type)} | ${cell(c.runtime ?? "unknown")} | ${cell(c.repo ?? "")} |`);
+    out.push("");
+  }
+  const ifaces = by("Interface");
+  const outbound = ifaces.filter((i) => compIds.has(String(i.from)) || i.from === id);
+  const inbound = ifaces.filter((i) => (compIds.has(String(i.to)) || i.to === id) && !outbound.includes(i));
+  out.push("## Who it talks to", "");
+  const row = (i, other) => `| ${nameOf(other)} | ${cell(i.method ? `${String(i.method)} ` : "")}${cell(i.normalizedPath)} | ${cell(i.via)} | ${cell(i.auth ?? "not declared")} | ${cell(i.pattern?.code ?? "none")} | ${i.confidence} |`;
+  const head = [
+    "| With | Operation | Via | Auth | Pattern | Confidence |",
+    "| --- | --- | --- | --- | --- | --- |"
+  ];
+  if (outbound.length) {
+    out.push("Calls out:", "", ...head, ...outbound.map((i) => row(i, String(i.to))), "");
+  }
+  if (inbound.length) {
+    out.push("Called by:", "", ...head, ...inbound.map((i) => row(i, String(i.from))), "");
+  }
+  if (!outbound.length && !inbound.length) {
+    out.push("No interfaces in the catalog.", "");
+    gaps.push("interfaces");
+  }
+  const noAuth = [...outbound, ...inbound].filter((i) => !i.auth && i.via !== "event-bus");
+  if (noAuth.length)
+    out.push(`- ${noAuth.length} call${noAuth.length === 1 ? " has" : "s have"} no authentication declared in code or config.`, "");
+  out.push("## Data", "");
+  const stores = by("DataStore").filter((d) => compIds.has(String(d.ownerComponent)));
+  const tables = by("Table").filter((t) => compIds.has(String(t.ownerComponent)));
+  if (!stores.length && !tables.length) {
+    out.push("No data stores in the catalog.", "");
+    gaps.push("data");
+  } else {
+    for (const d of stores)
+      out.push(`- **${d.id}** (${cell(d.storeType)})${cite(d)}`);
+    if (stores.length)
+      out.push("");
+    if (tables.length) {
+      out.push("| Table | Written by | Read by | Classified columns |", "| --- | --- | --- | --- |");
+      for (const t of tables) {
+        const cols = by("Column").filter((c) => c.table === t.id);
+        const classified = cols.filter((c) => c.classification);
+        out.push(`| ${t.id} | ${(t.writers ?? []).map(nameOf).join(", ")} | ${(t.readers ?? []).map(nameOf).join(", ")} | ${classified.length ? classified.map((c) => `${String(c.name)} (${String(c.classification)})`).join(", ") : `none of ${cols.length} tagged`} |`);
+      }
+      out.push("");
+    }
+  }
+  out.push("## Runtime", "");
+  const deps = by("Deployment").filter((d) => compIds.has(String(d.component)));
+  const settings = by("Setting").filter((s) => compIds.has(String(s.component)));
+  const obs = by("ObservabilityAsset").filter((s) => compIds.has(String(s.component)));
+  if (deps.length)
+    for (const d of deps)
+      out.push(`- ${String(d.component)} in ${String(d.env)} on ${String(d.platform)}${d.replicas !== void 0 ? `, ${String(d.replicas)} replicas` : ""}${cite(d)}`);
+  else {
+    out.push("- No deployments in the catalog.");
+    gaps.push("runtime");
+  }
+  for (const s of settings)
+    out.push(`- ${String(s.settingKind)} ${String(s.key)} = ${String(s.valueOrRef)}${s.target ? ` (for ${nameOf(String(s.target))})` : ""}${cite(s)}`);
+  if (obs.length)
+    for (const a of obs)
+      out.push(`- ${String(a.assetKind)}: ${String(a.name)}${cite(a)}`);
+  else {
+    out.push("- No alerts, dashboards or runbooks in the catalog.");
+    gaps.push("observability");
+  }
+  out.push("");
+  const grants = by("AccessGrant").filter((g) => compIds.has(String(g.subject)));
+  if (grants.length) {
+    out.push("## Access", "");
+    for (const g of grants)
+      out.push(`- ${String(g.subject)} (${String(g.subjectKind)}) on ${String(g.resource)}: ${(g.scopesOrPermissions ?? []).join(", ")}${cite(g)}`);
+    out.push("");
+  }
+  out.push("## Decisions", "");
+  const decisions = by("Decision").filter((d) => (d.links?.systems ?? []).includes(id));
+  if (decisions.length)
+    for (const d of decisions)
+      out.push(`- **${String(d.title)}** (${String(d.date)}, ${String(d.decidedBy)}): ${String(d.decision)} Because: ${String(d.reason)}`);
+  else
+    out.push("No recorded decisions.");
+  out.push("");
+  const changes = (o.changes ?? []).filter((c) => c.systems.includes(id));
+  if (o.changes) {
+    out.push("## Changes touching it", "");
+    if (changes.length)
+      for (const c of changes)
+        out.push(`- ${c.title} (${c.id}, ${c.state})`);
+    else
+      out.push("No open changes.");
+    out.push("");
+  }
+  out.push("## What the catalog doesn't know yet", "");
+  if (gaps.length)
+    for (const g of gaps)
+      out.push(`- ${GAP_TEXT[g] ?? g}`);
+  else
+    out.push("Nothing flagged.");
+  out.push("");
+  return { system: id, name: String(sys.name), markdown: out.join("\n"), gaps };
+}
+var GAP_TEXT = {
+  owner: "Who owns this system.",
+  components: "What it is made of: no component has been scanned or named.",
+  interfaces: "Who it talks to.",
+  data: "Where its data lives.",
+  runtime: "Where and how it runs.",
+  observability: "How it is watched: alerts, dashboards, runbooks."
+};
+var cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+
+// packages/site/dist/site.js
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function guideHtml(md) {
+  const out = [];
+  let table = [];
+  let list = [];
+  const inline = (s) => esc(s).replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/_\(([^)]*)\)_/g, '<span class="src">($1)</span>');
+  const flush = () => {
+    if (list.length)
+      out.push(`<ul>${list.map((l) => `<li>${inline(l)}</li>`).join("")}</ul>`);
+    list = [];
+    if (table.length) {
+      const [h, ...rows] = table;
+      out.push(`<table><thead><tr>${h.map((c) => `<th>${inline(c)}</th>`).join("")}</tr></thead><tbody>${rows.map((r) => `<tr>${r.map((c) => `<td>${inline(c)}</td>`).join("")}</tr>`).join("")}</tbody></table>`);
+    }
+    table = [];
+  };
+  for (const line of md.split("\n")) {
+    if (line.startsWith("|")) {
+      if (/^\|\s*-/.test(line))
+        continue;
+      table.push(line.slice(1, -1).split(/(?<!\\)\|/).map((c) => c.trim().replace(/\\\|/g, "|")));
+      continue;
+    }
+    if (table.length)
+      flush();
+    const h = /^(#{1,3}) (.*)$/.exec(line);
+    if (h) {
+      flush();
+      out.push(`<h${h[1].length}>${inline(h[2])}</h${h[1].length}>`);
+    } else if (line.startsWith("- "))
+      list.push(line.slice(2));
+    else if (line.trim()) {
+      flush();
+      out.push(`<p>${inline(line)}</p>`);
+    } else
+      flush();
+  }
+  flush();
+  return out.join("\n");
+}
+var CSS = `body{margin:0;background:#06090d;color:#dfeaf0;font:15px/1.6 system-ui,sans-serif}
+main{max-width:980px;margin:0 auto;padding:24px 16px}a{color:#2ee6f6}
+h1{font-size:26px;letter-spacing:.02em}h2{font-size:15px;text-transform:uppercase;letter-spacing:.12em;color:#7ff4ff;margin-top:28px}
+table{border-collapse:collapse;width:100%;font-size:13px}th,td{text-align:left;padding:6px 8px 6px 0;border-top:1px solid #1a2330;vertical-align:top}
+th{font-weight:400;color:#8fa3b3;font-size:11px;text-transform:uppercase;letter-spacing:.1em}
+.src{color:#6f8394;font-size:12px}.card{border:1px solid #1a2330;border-radius:10px;padding:12px 14px;margin:8px 0}
+input{width:100%;height:40px;background:#0b1016;color:#dfeaf0;border:1px solid #2ee6f6;border-radius:10px;padding:0 12px;font:inherit}
+footer{color:#6f8394;font-size:12px;margin-top:40px}`;
+var SEARCH_JS = `const box=document.getElementById("q"),res=document.getElementById("res");
+fetch("search.json").then(r=>r.json()).then(items=>{box.addEventListener("input",()=>{
+const t=box.value.toLowerCase().trim();res.textContent="";if(t.length<2)return;
+for(const i of items.filter(x=>(x.id+" "+(x.name||"")).toLowerCase().includes(t)).slice(0,30)){
+const li=document.createElement("li"),a=document.createElement("a");a.href=i.href;a.textContent=i.id+" \xB7 "+i.kind;li.append(a);res.append(li)}})});`;
+function page(title, body, depth, script = false) {
+  const up = depth ? "../" : "";
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'self'; script-src 'self'; connect-src 'self'; img-src 'self'">
+<title>${esc(title)}</title><link rel="stylesheet" href="${up}site.css"></head>
+<body><main>${body}<footer>Read-only. Generated from the catalog; it changes nothing. Facts show where they came from.</footer></main>${script ? `<script src="${up}search.js"></script>` : ""}</body></html>
+`;
+}
+async function buildSite(records, dir, o) {
+  const all = records;
+  const systems = all.filter((r) => r.kind === "System").sort((a, b) => a.id.localeCompare(b.id));
+  const open = systems.filter((s) => (s.accessGroup ?? "everyone") === "everyone");
+  const openIds = new Set(open.map((s) => s.id));
+  const visible = (sid) => openIds.has(sid);
+  const compSys = new Map(all.filter((r) => r.kind === "Component").map((c) => [c.id, String(c.system)]));
+  const tableSys = new Map(all.filter((r) => r.kind === "Table").map((t) => [t.id, compSys.get(String(t.ownerComponent))]));
+  const systemOf = (r) => {
+    switch (r.kind) {
+      case "System":
+        return r.id;
+      case "Component":
+        return String(r.system);
+      case "Endpoint":
+      case "Deployment":
+      case "Setting":
+      case "ObservabilityAsset":
+        return compSys.get(String(r.component));
+      case "Table":
+      case "DataStore":
+        return compSys.get(String(r.ownerComponent));
+      case "Column":
+        return tableSys.get(String(r.table));
+      case "Interface": {
+        const a = compSys.get(String(r.from)) ?? String(r.from);
+        const b = compSys.get(String(r.to)) ?? String(r.to);
+        return visible(a) && visible(b) ? a : void 0;
+      }
+      default:
+        return void 0;
+    }
+  };
+  await mkdir(join(dir, "systems"), { recursive: true });
+  await writeFile(join(dir, "site.css"), CSS);
+  await writeFile(join(dir, "search.js"), SEARCH_JS);
+  let files = 2;
+  for (const s of open) {
+    const g = systemGuide(records, s.id, {
+      visible,
+      ...o.changes ? { changes: o.changes } : {}
+    });
+    await writeFile(join(dir, "systems", `${s.id}.html`), page(`${g.name} \xB7 ${o.title}`, `<p><a href="../index.html">\u2190 ${esc(o.title)}</a></p>
+${guideHtml(g.markdown)}`, 1));
+    files += 1;
+  }
+  const byBoundary = ["product", "internal", "vendor"].map((b) => ({
+    b,
+    list: open.filter((s) => s.boundary === b)
+  }));
+  const index = `<h1>${esc(o.title)}</h1>
+<p>Built ${esc(o.builtAt)} \xB7 ${open.length} systems</p>
+<label for="q">Search the catalog</label><input id="q" type="search" autocomplete="off"><ul id="res" aria-live="polite"></ul>
+${byBoundary.filter((x) => x.list.length).map((x) => `<h2>${esc(x.b)} systems</h2>${x.list.map((s) => `<div class="card"><a href="systems/${esc(s.id)}.html">${esc(String(s.name))}</a> <span class="src">${esc(s.id)}${s.owner ? ` \xB7 ${esc(String(s.owner))}` : " \xB7 owner unknown"}</span></div>`).join("")}`).join("\n")}`;
+  await writeFile(join(dir, "index.html"), page(o.title, index, 0, true));
+  const search = all.map((r) => ({ r, sys: systemOf(r) })).filter((x) => x.sys && visible(x.sys)).map(({ r, sys }) => ({
+    id: r.id,
+    kind: r.kind,
+    ...typeof r.name === "string" ? { name: r.name } : {},
+    system: sys,
+    href: `systems/${sys}.html`
+  }));
+  await writeFile(join(dir, "search.json"), JSON.stringify(search));
+  files += 2;
+  return {
+    systems: open.map((s) => s.id),
+    hidden: systems.filter((s) => !openIds.has(s.id)).map((s) => s.id),
+    files
+  };
+}
+
+// packages/cli/dist/site-commands.js
+async function catalogRecords(root, io) {
+  const dir = catalogDirOf(root);
+  const gen = await readCatalog(join2(dir, "generated"), { cacheRoot: root });
+  const cur = await readCatalog(join2(dir, "curated"), { cacheRoot: root });
+  for (const p of [...gen.problems, ...cur.problems])
+    io?.err(`catalog ${p.file}: ${p.message}`);
+  const curated = new Set(cur.records.map((r) => `${r.kind}/${r.id}`));
+  return [...gen.records.filter((r) => !curated.has(`${r.kind}/${r.id}`)), ...cur.records];
+}
+async function openChanges(root) {
+  try {
+    return (await changeStore(root).list()).filter((c) => !["archived", "released", "abandoned"].includes(c.state)).map((c) => ({ id: c.id, title: c.title, state: c.state, systems: c.systems }));
+  } catch {
+    return [];
+  }
+}
+async function guideCommand(root, system, o, io) {
+  if (!system) {
+    io.err("guide needs a system id, for example: atticus guide ledger");
+    return 2;
+  }
+  const records = await catalogRecords(root, io);
+  let g;
+  try {
+    g = systemGuide(records, system, { changes: await openChanges(root) });
+  } catch (e) {
+    io.err(e.message);
+    return 1;
+  }
+  if (o.json)
+    io.out(JSON.stringify(g, null, 2));
+  else
+    for (const l of g.markdown.split("\n"))
+      io.out(l);
+  return 0;
+}
+async function siteBuildCommand(root, dir, o, io) {
+  if (!dir) {
+    io.err("site build needs a folder, for example: atticus site build ./site");
+    return 2;
+  }
+  const out = resolve(dir);
+  const r = await buildSite(await catalogRecords(root, io), out, {
+    title: o.title ?? "Catalog",
+    builtAt: (o.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    changes: await openChanges(root)
+  });
+  io.out(`Wrote the catalog site to ${out}: ${r.systems.length} system${r.systems.length === 1 ? "" : "s"}, ${r.files} files.`);
+  if (r.hidden.length)
+    io.out(`Left out ${r.hidden.length} system${r.hidden.length === 1 ? "" : "s"} not open to everyone (their accessGroup); they aren't named anywhere on the site.`);
+  io.out("It is read-only static files: host it behind your own sign-in.");
+  return 0;
+}
+
+export {
+  systemGuide,
+  buildSite,
+  catalogRecords,
+  openChanges,
+  guideCommand,
+  siteBuildCommand
+};

package/dist/chunk-BKVWTZ6A.js

@@ -0,0 +1,211 @@
+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 {
+  benchFactsCommand
+} from "./chunk-N7IXEHK3.js";
+import {
+  BenchStory,
+  benchKnownFields,
+  benchStoryFromStories,
+  factFieldNames,
+  parseDraftStory,
+  parseReference,
+  parseReferenceStory,
+  scoreStory
+} from "./chunk-CPA6HPVR.js";
+import "./chunk-BOHJZTEQ.js";
+import "./chunk-MVZVGYXH.js";
+import "./chunk-KEM4SDDP.js";
+import "./chunk-2ANOROX3.js";
+import "./chunk-65NYPGRC.js";
+import {
+  draftedStories
+} from "./chunk-CKSITVS4.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-3HI6Z55Y.js";
+import "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  changesDirOf,
+  parseFacts,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/bench-stories-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+var str = (v) => typeof v === "string" && v !== "" ? v : void 0;
+async function benchScoreCli(command, arg, values, io, root) {
+  const common = {
+    ...str(values.bench) ? { bench: str(values.bench) } : {},
+    ...str(values.cache) ? { cache: str(values.cache) } : {},
+    ...str(values.facts) ? { facts: str(values.facts) } : {},
+    json: values.json === true
+  };
+  if (command === "facts") {
+    const repo = arg ?? str(values.repo);
+    const batch = Number(str(values.batch));
+    return benchFactsCommand({ ...common, ...repo ? { repo } : {}, ...batch > 0 ? { batch } : {} }, io);
+  }
+  const change = str(values.change);
+  if (change) {
+    const story = str(values.story);
+    if (!story) {
+      io.err("bench stories --change needs the reference story the change answers: atticus bench stories --change <change> --story <id> (an id in bench/stories).");
+      return 2;
+    }
+    const out = str(values.out);
+    return benchChangeStories({ ...common, change, story, root: root ?? process.cwd(), ...out ? { out } : {} }, io);
+  }
+  const draft = str(values.draft) ?? arg;
+  if (!draft) {
+    io.err("bench stories needs a drafted story: atticus bench stories --draft <file>, or a change's stories: --change <change> --story <id>");
+    return 2;
+  }
+  return benchStories({ ...common, draft }, io);
+}
+function changeAt(value, root) {
+  const dir = resolve(value);
+  if (!existsSync(join(dir, "change.yaml")))
+    return { root: resolve(root), id: value };
+  const id = basename(dir);
+  for (let up = dirname(dir); ; up = dirname(up)) {
+    if (resolve(changesDirOf(up), id) === dir)
+      return { root: up, id };
+    if (dirname(up) === up)
+      break;
+  }
+  throw new Error(`${dir} is a change folder, but not in a metarepo's changes folder.`);
+}
+async function benchChangeStories(o, io) {
+  let draft;
+  try {
+    const { root, id } = changeAt(o.change, o.root);
+    const d = await draftedStories(root, id);
+    draft = BenchStory.parse(benchStoryFromStories({
+      story: o.story,
+      change: d.change.id,
+      title: d.change.title,
+      stories: d.stories,
+      answer: d.answer,
+      ...d.extras.done ? { done: d.extras.done } : {},
+      requests: d.requests
+    }));
+    if (o.out) {
+      await mkdir(dirname(resolve(o.out)), { recursive: true });
+      await writeFile(resolve(o.out), `# The stories atticus plan stories drafted for ${d.change.id}, as a bench story (atticus bench stories --change).
+${(0, import_yaml.stringify)(draft, { lineWidth: 0 })}`);
+    }
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+  return scoreAndReport(draft, o, io, o.out ? resolve(o.out) : void 0);
+}
+var defaultCache = () => process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "atticus", "bench") : join(homedir(), ".cache", "atticus", "bench");
+async function benchStories(o, io) {
+  let draft;
+  try {
+    const draftText = await readFile(resolve(o.draft), "utf8").catch(() => void 0);
+    if (draftText === void 0)
+      throw new Error(`There is no draft at ${resolve(o.draft)}.`);
+    draft = parseDraftStory(draftText);
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+  return scoreAndReport(draft, o, io);
+}
+async function scoreAndReport(draft, o, io, written) {
+  const dir = resolve(o.bench ?? "bench");
+  const cache = resolve(o.cache ?? defaultCache());
+  let score;
+  try {
+    const refText = await readFile(join(dir, "stories", `${draft.story}.yaml`), "utf8").catch(() => void 0);
+    if (refText === void 0)
+      throw new Error(`There is no reference story ${draft.story} in ${join(dir, "stories")}: the draft's story names the reference it answers.`);
+    const ref = parseReferenceStory(refText);
+    const known = [];
+    for (const repo of ref.repos) {
+      const text = await readFile(join(dir, "references", `${repo}.yaml`), "utf8").catch(() => void 0);
+      if (text !== void 0)
+        known.push(...benchKnownFields([parseReference(text)]));
+    }
+    const factFiles = o.facts ? [resolve(o.facts)] : ref.repos.flatMap((r) => [
+      join(cache, r, ".atticus", "facts", `${r}.jsonl`),
+      join(cache, "facts", `${r}.jsonl`)
+    ]);
+    for (const f of factFiles) {
+      if (!existsSync(f)) {
+        if (o.facts)
+          throw new Error(`There is no facts file at ${f}.`);
+        continue;
+      }
+      const parsed = parseFacts(await readFile(f, "utf8"));
+      if (!parsed.ok)
+        throw new Error(`${f} does not read as facts.`);
+      known.push(...factFieldNames(parsed.facts));
+    }
+    score = scoreStory(ref, draft, known);
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+  const code = score.invented.length ? 1 : 0;
+  if (o.json) {
+    io.out(JSON.stringify(score, null, 2));
+    return code;
+  }
+  const pct = (x) => `${Math.round(x * 100)}%`;
+  const row = (what, s) => `${what.padEnd(18)} ${s.found} of ${s.total} (${pct(s.coverage)})`;
+  io.out(`Story ${score.story}`);
+  if (written)
+    io.out(`Draft: ${written}`);
+  io.out(row("Changed steps", score.steps));
+  if (score.steps.missed.length)
+    io.out(`  missed: ${score.steps.missed.join(", ")}`);
+  if (score.steps.extra.length)
+    io.out(`  draft steps no reference step matches: ${score.steps.extra.join(", ")}`);
+  io.out(row("Fields", score.fields));
+  if (score.fields.missed.length)
+    io.out(`  missed: ${score.fields.missed.join(", ")}`);
+  io.out(row("Error cases", score.errors));
+  for (const m of score.errors.missed)
+    io.out(`  missed: ${m}`);
+  io.out(row("  by entry", score.errorsByEntry));
+  for (const m of score.errorsByEntry.missed)
+    io.out(`  missed: ${m}`);
+  io.out(`${"Invented fields".padEnd(18)} ${score.invented.join(", ") || "none"}`);
+  io.out(`${"Rubric sections".padEnd(18)} ${score.sections.present} of ${score.sections.total}`);
+  if (score.sections.missing.length)
+    io.out(`  missing: ${score.sections.missing.join(", ")}`);
+  if (code)
+    io.out("A draft must name only fields the reference, the bench references or the repos' facts know (bench/stories/rubric.md).");
+  return code;
+}
+export {
+  benchChangeStories,
+  benchScoreCli,
+  benchStories
+};