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

package/dist/chunk-U6YKL7SI.js

@@ -0,0 +1,334 @@
+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 "./chunk-NIYB5K5B.js";
+import {
+  loadCatalog
+} from "./chunk-BUWSOQLU.js";
+import {
+  repoFor
+} from "./chunk-LDIARP6F.js";
+import {
+  recordFact,
+  verifyScan
+} from "./chunk-XKJRPVJO.js";
+import {
+  stepJudges
+} from "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import "./chunk-T6ESD5KM.js";
+import "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.js";
+import {
+  checkScanSettings
+} from "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-YVCOQ5TZ.js";
+import "./chunk-XNRPCI23.js";
+import "./chunk-XZJE6WIT.js";
+import {
+  fsRepo
+} from "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  SCAN_VERIFY_SCHEMA_VERSION,
+  ScanSettings,
+  ScanVerifyProposal,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  proposalsDirOf,
+  proposalsRelOf,
+  questionsRelOf,
+  raiseQuestions,
+  require_dist,
+  reusedLine
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/scan-verify-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var KIND_WORDS = {
+  "entry-point": "entry point",
+  call: "call",
+  table: "table",
+  deployment: "deployment",
+  other: "fact"
+};
+var fixWords = (f) => "settings" in f ? "a scan settings entry" : "question" in f ? "a question for a person" : "a reader must change";
+var sentence = (s) => {
+  const t = s.trim();
+  return `${t.charAt(0).toUpperCase()}${t.slice(1)}${/[.!?]$/.test(t) ? "" : "."}`;
+};
+var proposalFile = (root, repo) => join(proposalsDirOf(root), "scan", `${repo}.yaml`);
+var findingsFile = (root, repo) => join(proposalsDirOf(root), "scan", `${repo}.findings.md`);
+var EMPTY = { exclude: [], prefixes: [], clients: [] };
+function newEntries(have, add) {
+  const ex = (e) => e.path;
+  const px = (p) => `${p.paths.join(",")} ${p.prefix}`;
+  const cl = (c) => `${c.paths.join(",")} ${c.base} ${c.names.join(",")}`;
+  const fresh = (had, more, key) => {
+    const seen = new Set(had.map(key));
+    return more.filter((x) => {
+      const k = key(x);
+      if (seen.has(k))
+        return false;
+      seen.add(k);
+      return true;
+    });
+  };
+  return {
+    exclude: fresh(have.exclude, add.exclude, ex),
+    prefixes: fresh(have.prefixes, add.prefixes, px),
+    clients: fresh(have.clients, add.clients, cl)
+  };
+}
+var merge = (a, b) => {
+  const n = newEntries(a, b);
+  return {
+    exclude: [...a.exclude, ...n.exclude],
+    prefixes: [...a.prefixes, ...n.prefixes],
+    clients: [...a.clients, ...n.clients]
+  };
+};
+var size = (s) => s.exclude.length + s.prefixes.length + s.clients.length;
+var describeSettings = (s) => [
+  s.exclude.length ? plural(s.exclude.length, "folder") + " left out" : "",
+  s.prefixes.length ? plural(s.prefixes.length, "prefix", "prefixes") : "",
+  s.clients.length ? plural(s.clients.length, "client base") : ""
+].filter(Boolean).join(", ");
+async function readProposal(root, repo) {
+  const text = await readFile(proposalFile(root, repo), "utf8").catch(() => void 0);
+  return text === void 0 ? void 0 : ScanVerifyProposal.parse((0, import_yaml.parse)(text));
+}
+async function writeProposal(root, p) {
+  await mkdir(join(proposalsDirOf(root), "scan"), { recursive: true });
+  await writeFile(proposalFile(root, p.repo), `# From atticus scan verify (ADR 0082): every item was checked against the code. Accept the settings with atticus scan verify ${p.repo} --accept.
+${(0, import_yaml.stringify)(ScanVerifyProposal.parse(p))}`, "utf8");
+}
+var ofRepo = (records, repo) => records.filter((r) => r.evidence.some((e) => e.repo === repo));
+async function pin(repo, r) {
+  const e = r.evidence.find((x) => x.path) ?? r.evidence[0];
+  if (!e?.path)
+    return { record: r.id, at: "?" };
+  if (!e.line)
+    return { record: r.id, at: e.path };
+  const text = await repo.readText(e.path).catch(() => void 0);
+  const line = text?.replace(/\r\n?/g, "\n").split("\n")[e.line - 1];
+  return {
+    record: r.id,
+    at: `${e.path}:${e.line}`,
+    ...line !== void 0 ? { line: createHash("sha256").update(line.trim()).digest("hex").slice(0, 12) } : {}
+  };
+}
+function findings(repo, r, now, records) {
+  const a = r.answer;
+  const items = [];
+  for (const m of a.missed)
+    if ("reader" in m.fix)
+      items.push(`- Missed the ${KIND_WORDS[m.kind]} ${m.method ? `${m.method} ` : ""}${m.name} at ${m.at}. ${sentence(m.why)} What must change: ${sentence(m.fix.reader)}`);
+  for (const w of a.wrong)
+    if ("reader" in w.fix) {
+      const rec = records.find((x) => x.id === w.record);
+      const f = rec ? recordFact(rec) : void 0;
+      items.push(`- Wrong: ${w.record}${f ? ` (the ${KIND_WORDS[f.kind]} ${f.method ? `${f.method} ` : ""}${f.name})` : ""}, shown by ${w.at}. ${sentence(w.why)} What must change: ${sentence(w.fix.reader)}`);
+    }
+  const text = [
+    `# What the scan of ${repo} reads wrong`,
+    "",
+    `Found by atticus scan verify on ${now.toISOString().slice(0, 10)}${r.runId ? ` (run ${r.runId})` : ""}. No scan setting can put these right: each needs a change to a built-in reader or a scanner plugin (ADR 0080). Atticus checked that each cited line says what is quoted.`,
+    "",
+    ...items.length ? items : ["Nothing this time."],
+    ""
+  ].join("\n");
+  return { text, count: items.length };
+}
+async function scanVerify(root, target, o, deps, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+    return 2;
+  }
+  const { records: all } = await loadCatalog(root, { out: () => {
+  }, err: (l) => io.err(l) });
+  const records = ofRepo(all, repo.id);
+  if (records.length === 0) {
+    io.err(`The catalog has nothing from ${repo.id} yet: run atticus scan first.`);
+    return 1;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const settings = op.scanSettings.find((s) => s.repo === repo.id);
+  const before = await listQuestions(root, { repo: repo.id }).then((l) => ({
+    ...l,
+    questions: l.questions.filter((q) => q.state !== "retired")
+  }));
+  const handle = fsRepo(repo.id, repo.dir, "0".repeat(40));
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const r = await verifyScan(handle, {
+    repoId: repo.id,
+    runtime: deps.runtime,
+    records,
+    ...settings ? { settings } : {},
+    orgPack: op,
+    maxAttempts: o.attempts ?? 3,
+    questions: before.questions,
+    now,
+    ...o.resume ? { resume: o.resume } : {}
+  });
+  if (r.status === "waiting") {
+    io.out(`Handed the check to your assistant (run ${r.runId}). When it is done: atticus handoff done ${r.runId}, then atticus scan verify ${repo.id} --resume ${r.runId}`);
+    return 0;
+  }
+  const handedBack = r.attempts.filter((x, n) => x.problems.length > 0 && n < r.attempts.length - 1);
+  if (r.status !== "checked" || !r.answer) {
+    if (o.json)
+      io.out(JSON.stringify({ status: r.status, attempts: r.attempts }, null, 2));
+    else {
+      for (const a2 of r.attempts) {
+        io.out(`Attempt ${a2.attempt}: ${plural(a2.problems.length, "problem")}:`);
+        for (const p of a2.problems)
+          io.out(`  - ${p}`);
+      }
+      io.out(`No answer could be read in ${plural(r.attempts.length, "attempt")}; nothing was written.`);
+    }
+    return 1;
+  }
+  const a = r.answer;
+  let fixes = EMPTY;
+  for (const item of [...a.missed, ...a.wrong])
+    if ("settings" in item.fix)
+      fixes = merge(fixes, item.fix.settings);
+  const earlier = await readProposal(root, repo.id).catch(() => void 0);
+  const proposed = newEntries(settings ?? EMPTY, merge(earlier?.settings ?? EMPTY, fixes));
+  const drafts = [...a.missed, ...a.wrong].flatMap((x) => "question" in x.fix ? [x.fix.question] : []);
+  const judges = stepJudges(root, deps.runtime, repo.id, now);
+  const { raised, known, reused } = await raiseQuestions(root, drafts, {
+    step: "scan-verify",
+    repo: repo.id,
+    command: `atticus scan verify ${repo.id}`,
+    rerun: `atticus scan verify ${repo.id}`,
+    ...r.runId ? { run: r.runId } : {},
+    at: now.toISOString()
+  }, judges);
+  const byId = new Map(records.map((x) => [x.id, x]));
+  const verified = await Promise.all(a.confirmed.map((c) => c.record).sort().map((id) => pin(handle, byId.get(id))));
+  const proposal = {
+    schemaVersion: SCAN_VERIFY_SCHEMA_VERSION,
+    repo: repo.id,
+    ...r.runId ? { run: r.runId } : {},
+    at: now.toISOString(),
+    settings: proposed,
+    missed: a.missed,
+    wrong: a.wrong.map((w) => ({ ...w, ...recordFact(byId.get(w.record)) })),
+    verified,
+    questions: [...new Set([...raised, ...known].map((q) => q.id))].sort(),
+    ...earlier?.accepted ? { accepted: earlier.accepted } : {}
+  };
+  await writeProposal(root, proposal);
+  const f = findings(repo.id, r, now, records);
+  await writeFile(findingsFile(root, repo.id), f.text, "utf8");
+  const rel = proposalsRelOf(root);
+  if (o.json) {
+    io.out(JSON.stringify({
+      status: r.status,
+      proposal,
+      refused: r.refused,
+      attempts: r.attempts,
+      questions: { raised: raised.map((q) => q.id), known: known.map((q) => q.id) },
+      files: {
+        proposal: `${rel}/scan/${repo.id}.yaml`,
+        findings: `${rel}/scan/${repo.id}.findings.md`
+      }
+    }, null, 2));
+    return 0;
+  }
+  io.out(`Checked ${repo.id} against its last scan: ${a.missed.length} missed, ${a.wrong.length} wrong, ${a.confirmed.length} confirmed.`);
+  for (const at of handedBack) {
+    io.out(`Attempt ${at.attempt}: ${plural(at.problems.length, "problem")}, handed back:`);
+    for (const p of at.problems)
+      io.out(`  - ${p}`);
+  }
+  if (r.refused.length) {
+    io.out("Left out, because the last attempt still failed its checks:");
+    for (const p of r.refused)
+      io.out(`  - ${p}`);
+  }
+  for (const m of a.missed)
+    io.out(`  missed: ${KIND_WORDS[m.kind]} ${m.method ? `${m.method} ` : ""}${m.name} (${m.at}); ${fixWords(m.fix)}`);
+  for (const w of a.wrong)
+    io.out(`  wrong: ${w.record} (${w.at}); ${fixWords(w.fix)}`);
+  io.out(`Wrote ${rel}/scan/${repo.id}.yaml: ${plural(size(proposed), "settings entry", "settings entries")} to accept, ${plural(verified.length, "record")} confirmed.`);
+  if (f.count)
+    io.out(`Wrote ${rel}/scan/${repo.id}.findings.md: ${plural(f.count, "thing")} a reader or a scanner plugin must read differently.`);
+  const waiting = known.filter((q) => q.state === "open");
+  if (raised.length) {
+    io.out(`${plural(raised.length, "question")} for a person, in ${questionsRelOf(root)}/:`);
+    for (const q of raised)
+      io.out(`  ${q.id} ${q.question}`);
+  }
+  for (const q of reused)
+    io.out(reusedLine(q));
+  if (waiting.length)
+    io.out(`${plural(waiting.length, "question")} still waiting for an answer: ${waiting.map((q) => q.id).join(", ")}`);
+  if (raised.length + waiting.length)
+    io.out(`Answer with atticus questions answer <id> --option <n>, or on the app's Questions page; then run atticus scan verify ${repo.id} again.`);
+  io.out(size(proposed) ? `Next: review ${rel}/scan/${repo.id}.yaml, then atticus scan verify ${repo.id} --accept, and atticus scan.` : `Next: nothing to accept; see ${rel}/scan/${repo.id}.findings.md for what a reader must change.`);
+  return 0;
+}
+async function scanVerifyAccept(root, target, o, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+    return 2;
+  }
+  const proposal = await readProposal(root, repo.id);
+  if (!proposal) {
+    io.err(`There is no proposal for ${repo.id} yet: run atticus scan verify ${repo.id} first.`);
+    return 1;
+  }
+  if (size(proposal.settings) === 0) {
+    io.out(`Nothing to accept for ${repo.id}: the proposal has no settings entries.`);
+    return 0;
+  }
+  const file = join(orgPackDirOf(root), "scan", `${repo.id}.yaml`);
+  const text = await readFile(file, "utf8").catch(() => void 0);
+  const have = text ? ScanSettings.parse((0, import_yaml.parse)(text)) : ScanSettings.parse({ schemaVersion: 1, repo: repo.id });
+  const added = newEntries(have, proposal.settings);
+  const next = ScanSettings.parse({ ...have, ...merge(have, added) });
+  const checked = await checkScanSettings(next, fsRepo(repo.id, repo.dir, "0".repeat(40)));
+  if (checked.problems.length) {
+    io.err(`The settings no longer check out against the code, so nothing was merged:`);
+    for (const p of checked.problems)
+      io.err(`  - ${p}`);
+    return 1;
+  }
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  await mkdir(join(orgPackDirOf(root), "scan"), { recursive: true });
+  await writeFile(file, `# Scan settings for ${repo.id} (ADR 0075); entries accepted from atticus scan verify on ${now.toISOString().slice(0, 10)} by ${o.by} (ADR 0082). Review it like any org-pack change.
+${(0, import_yaml.stringify)(next)}`, "utf8");
+  await writeProposal(root, {
+    ...proposal,
+    settings: EMPTY,
+    accepted: { at: now.toISOString(), by: o.by, entries: size(added) }
+  });
+  io.out(`Merged ${plural(size(added), "entry", "entries")} into org-pack/scan/${repo.id}.yaml${size(added) ? `: ${describeSettings(added)}` : ""}. Review it in a pull request, then run atticus scan.`);
+  return 0;
+}
+export {
+  scanVerify,
+  scanVerifyAccept
+};