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

package/dist/chunk-3G4YI4ZU.js

@@ -0,0 +1,16 @@
+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));
+
+// packages/cli/dist/metarepo-guard.js
+import { existsSync } from "node:fs";
+import { join, sep } from "node:path";
+var isMetarepo = (root) => existsSync(join(root, "org-pack")) || existsSync(join(root, ".atticus", "org-pack"));
+var notMetarepo = (root) => isMetarepo(join(root, "metarepo")) ? `${root} isn't an Atticus metarepo: the metarepo is in .${sep}metarepo. Run cd metarepo, then run the command again.` : `${root} isn't an Atticus metarepo. Make one with atticus init <folder>, use Atticus in an existing repo with atticus adopt <path>, or open the folder of one you have.`;
+
+export {
+  isMetarepo,
+  notMetarepo
+};

package/dist/chunk-3GTZ2OON.js

@@ -0,0 +1,362 @@
+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 {
+  recordReadProgress
+} from "./chunk-HE4ZQXZM.js";
+import {
+  carryOf,
+  checkoutOf,
+  conventionsAt,
+  estateComponentsOf,
+  excludesOf,
+  headOf,
+  raiseReadQuestions,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf,
+  slipNoteLines,
+  writeVerifyFiles
+} from "./chunk-B3O52AUQ.js";
+import {
+  dirSource,
+  frameworkFacts,
+  frameworksToLearn,
+  repairFormSlips,
+  verifyFacts
+} from "./chunk-4GZXS6S2.js";
+import {
+  NoRoomError,
+  roomGuard,
+  streamFacts
+} from "./chunk-7F2RUWPU.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  stackHelpersOff
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/verify-commands.js
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function frameworksKnownTo(root) {
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  return (op?.frameworks ?? []).flatMap((f) => [f.name, ...f.artifacts]);
+}
+var SHOWN = 5;
+function questionLines(text) {
+  const lines = [];
+  const problems = [];
+  for (const raw of text.split(/\r?\n/)) {
+    if (!raw.trim())
+      continue;
+    try {
+      lines.push(JSON.parse(raw));
+    } catch (e) {
+      problems.push({
+        line: JSON.stringify(raw),
+        message: `not JSON: ${e.message}`
+      });
+    }
+  }
+  return { lines, problems };
+}
+var FACTS_SIDE_FILES = /\.(questions|reviewed|rejected|corrections)\.jsonl$/;
+async function factsRepos(root) {
+  const names = await readdir(factsDirOf(root)).catch(() => []);
+  return names.filter((n) => n.endsWith(".jsonl") && !FACTS_SIDE_FILES.test(n)).map((n) => n.slice(0, -".jsonl".length)).sort();
+}
+async function verifyAllCommand(root, o, io) {
+  const repos = await factsRepos(root);
+  if (!repos.length) {
+    io.err(`No repo has facts yet (${factsRelOf(root)}/<repo>.jsonl). Read one first: /atticus-map <repo> in your assistant.`);
+    return 2;
+  }
+  const failed = [];
+  for (const repo of repos) {
+    const code = await verifyCommand(root, repo, o, io);
+    if (code !== 0)
+      failed.push(repo);
+  }
+  const passed = repos.length - failed.length;
+  io.out(`Verified ${repos.length === 1 ? "1 repo" : `${repos.length} repos`}: ${passed} passed${failed.length ? `, ${failed.length} with something to fix (${failed.join(", ")})` : ""}.`);
+  return failed.length ? 1 : 0;
+}
+async function verifyInputsOf(root, repo) {
+  return {
+    corrections: await readCorrections(root, repo),
+    reviewed: await readReviewed(root, repo),
+    estate: await estateComponentsOf(root),
+    conventions: await conventionsAt(root),
+    exclude: await excludesOf(root, repo)
+  };
+}
+async function verifyCommand(root, repo, o, io) {
+  const off = stackHelpersOff();
+  const rel = factsRelOf(root);
+  const file = join(factsDirOf(root), `${repo}.jsonl`);
+  if (!existsSync(file)) {
+    io.err(`No facts for ${repo} at ${rel}/${repo}.jsonl. Run /atticus-map ${repo} in your assistant first (or atticus map ${repo} to read it in batches); it writes that file.`);
+    return 2;
+  }
+  const room = roomGuard({
+    what: `${repo}'s facts`,
+    ...o.ceilingBytes !== void 0 ? { ceilingBytes: o.ceilingBytes } : {}
+  });
+  let parsed;
+  try {
+    parsed = await streamFacts(file, room);
+  } catch (e) {
+    if (!(e instanceof NoRoomError))
+      throw e;
+    io.err(`atticus verify ${repo}: ${e.message}`);
+    return 2;
+  }
+  const repaired = repairFormSlips(parsed.facts, parsed.bad);
+  parsed = { facts: repaired.facts, bad: repaired.bad };
+  const slips = repaired.slips;
+  if (!parsed.facts.length && parsed.bad.length) {
+    io.err(`${rel}/${repo}.jsonl does not read as facts:`);
+    for (const b of parsed.bad.slice(0, 20))
+      io.err(`  line ${b.line}: ${b.issues.map((i) => i.message).join("; ")}`);
+    if (parsed.bad.length > 20)
+      io.err(`  ... and ${parsed.bad.length - 20} more (no line of the file is a fact)`);
+    return 2;
+  }
+  const dir = await checkoutOf(root, repo, o.dir);
+  if (!dir) {
+    io.err(`No checkout of ${repo}: clone it (atticus workspace sync) or give its folder with --dir.`);
+    return 2;
+  }
+  const commit = o.commit ?? await headOf(dir);
+  const source = dirSource(dir);
+  const { carry, missing } = await carryOf(dir, parsed.facts, commit, o.git);
+  const inputs = await verifyInputsOf(root, repo);
+  const { corrections, reviewed, estate, conventions } = inputs;
+  for (const b of corrections.bad.slice(0, SHOWN))
+    io.err(`${rel}/${repo}.corrections.jsonl line ${b.line} isn't a correction: ${b.message}`);
+  if (corrections.bad.length > SHOWN)
+    io.err(`... and ${corrections.bad.length - SHOWN} more lines of ${rel}/${repo}.corrections.jsonl that aren't corrections`);
+  let report;
+  try {
+    report = await verifyFacts({
+      facts: parsed.facts,
+      source,
+      // G4: the stack helpers this run switched off (ATTICUS_HELPERS_OFF).
+      ...off.has("derived-names") ? { derivedNames: false } : {},
+      ...off.has("readers") ? { readers: false } : {},
+      ...commit ? { commit, carry } : {},
+      ...o.routed ? { routed: o.routed } : {},
+      exclude: inputs.exclude,
+      corrections: corrections.corrections,
+      reviewed: reviewed.entries,
+      room,
+      // J1 (ADR 0143): an exposure read here names a component the manifest lists.
+      ...estate ? { estate } : {},
+      conventions
+    });
+  } catch (e) {
+    if (!(e instanceof NoRoomError))
+      throw e;
+    io.err(`atticus verify ${repo}: ${e.message}`);
+    return 2;
+  }
+  const reviewedBad = reviewedProblemsOf(reviewed.bad, report).map((p) => ({
+    ...p,
+    message: `${rel}/${repo}.reviewed.jsonl ${p.message}`
+  }));
+  const qFile = join(factsDirOf(root), `${repo}.questions.jsonl`);
+  let raised = 0;
+  let known = 0;
+  let qLines = 0;
+  const qProblems = [];
+  const hasQuestions = existsSync(qFile);
+  if (hasQuestions) {
+    const q = questionLines(await readFile(qFile, "utf8"));
+    qLines = q.lines.length + q.problems.length;
+    qProblems.push(...q.problems);
+    const r = await raiseReadQuestions(root, repo, q.lines, source, {
+      command: `atticus verify ${repo}`,
+      at: (o.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    });
+    raised = r.raised.length;
+    known = r.known.length;
+    qProblems.push(...r.problems);
+  }
+  const open = hasQuestions ? (await listQuestions(root, { repo, state: "open" })).questions : [];
+  const badLines = parsed.bad.map((b) => ({
+    line: b.line,
+    raw: b.raw,
+    message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
+  }));
+  const summary = await writeVerifyFiles(root, repo, report, commit, qProblems, badLines, reviewedBad, slips);
+  const failed = report.rejected.length + qProblems.length + badLines.length + reviewedBad.length > 0;
+  await recordReadProgress(root, repo, {
+    commit,
+    kept: report.accepted.length,
+    ...o.now ? {
+      now: o.now().toISOString().replace(/\.\d{3}Z$/, "Z")
+    } : {}
+  });
+  const rejectedNote = `Nothing written to the catalog: ${report.rejected.length} facts were rejected. Fix them and run atticus verify ${repo} --write again.`;
+  if (o.json) {
+    let written2;
+    if (o.write && !failed) {
+      const { writeFactsIntoCatalog: writeFactsIntoCatalog2 } = await import("./chunk-KM2FBM3T.js");
+      written2 = await writeFactsIntoCatalog2(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write` }, { ...io, out: () => void 0 });
+      if (!written2)
+        return 1;
+    } else if (o.write)
+      io.err(rejectedNote);
+    io.out(JSON.stringify({
+      ...summary,
+      questions: {
+        lines: qLines,
+        raised,
+        known,
+        refused: qProblems.length,
+        open: open.length,
+        problems: qProblems
+      },
+      ...reviewedBad.length ? { reviewedProblems: reviewedBad } : {},
+      ...written2 ? { written: written2 } : {}
+    }, null, 2));
+    return failed ? 1 : 0;
+  }
+  const pct = Math.round(report.coverage.ratio * 100);
+  const cov = report.coverage;
+  io.out(`${repo}: ${report.accepted.length} facts kept, ${report.rejected.length} rejected; coverage ${pct}% (${cov.read.length} read, ${cov.reviewed.length ? `${cov.reviewed.length} reviewed with nothing to record, ` : ""}${cov.unknown.length} unknown${cov.excluded.length ? `, ${cov.excluded.length} excluded` : ""}).`);
+  const verifyYaml = `${rel}/${repo}.verify.yaml`;
+  const rejectedFile = `${rel}/${repo}.rejected.jsonl`;
+  const show = (lines, more) => {
+    for (const l of lines.slice(0, SHOWN))
+      io.out(`  ${l}`);
+    if (lines.length > SHOWN)
+      io.out(`  ... and ${lines.length - SHOWN} more ${more}`);
+  };
+  if (report.carried.length) {
+    const from = [...new Set(report.carried.map((c) => c.from.slice(0, 12)))];
+    io.out(`${report.carried.length} of them carried to ${commit.slice(0, 12)} from ${from.slice(0, SHOWN).join(", ")}${from.length > SHOWN ? ` and ${from.length - SHOWN} more commits` : ""}: every file they cite is unchanged since, and their lines were checked again (listed under carried in ${verifyYaml}).`);
+  }
+  const changed = report.rejected.filter((r) => r.code === "cite-changed").length;
+  if (changed)
+    io.out(`${changed} cite a file that changed since they were read: read those files again (atticus map ${repo} --estimate lists them), then rewrite or drop each fact.`);
+  if (missing.length) {
+    io.out(`Facts of ${missing.length === 1 ? "a commit" : `${missing.length} commits`} this clone doesn't have can't be compared with ${commit.slice(0, 12)}: they are rejected as wrong-commit; read them again.`);
+    show(missing.map((c) => c.slice(0, 12)), "commits");
+  }
+  const fixed = report.corrections.applied;
+  if (fixed.length) {
+    io.out(`${fixed.length} ${fixed.length === 1 ? "correction" : "corrections"} by a person applied (${rel}/${repo}.corrections.jsonl; listed under corrections in ${verifyYaml}):`);
+    show(fixed.map((a) => `${a.fact} ${a.action === "wrong" ? "left out as wrong" : "as corrected"}`), `(corrections in ${verifyYaml})`);
+  }
+  const stale = report.corrections.stale;
+  if (stale.length)
+    show(stale.map((s) => `correction: ${s.message}`), `corrections meeting no fact (corrections.stale in ${verifyYaml})`);
+  show(report.rejected.map((r) => `${r.code}: ${r.message}`), `rejected (all in ${rejectedFile})`);
+  if (hasQuestions) {
+    io.out(`${raised} question${raised === 1 ? "" : "s"} raised for a person now${known ? `, ${known} raised before` : ""}${qProblems.length ? `, ${qProblems.length} refused` : ""} (of ${qLines} line${qLines === 1 ? "" : "s"} in ${rel}/${repo}.questions.jsonl).`);
+    if (open.length) {
+      io.out(`${open.length} question${open.length === 1 ? "" : "s"} open for ${repo}, waiting for a person's answer (atticus questions list --state open lists them all; a person answers, never the assistant):`);
+      show(open.map((q) => `${q.id}: ${q.question}`), "open");
+    }
+  }
+  show(qProblems.map((q) => `bad-question: ${q.message}`), `refused questions (all in ${rejectedFile})`);
+  show(badLines.map((b) => `schema: ${b.message}`), `lines that aren't facts (all in ${rejectedFile})`);
+  show(reviewedBad.map((b) => `bad-reviewed: ${b.message}`), `refused reviewed lines (all in ${rejectedFile})`);
+  if (failed)
+    io.out(`Fix them from ${rel}/${repo}.rejected.jsonl (read the lines again, then rewrite or drop each fact, question or reviewed line) and run atticus verify ${repo} again.`);
+  else if (cov.unknown.length)
+    io.out(`Next: read the ${cov.unknown.length} unknown files (listed in ${rel}/${repo}.verify.yaml). A file you read and found nothing to record in goes in ${rel}/${repo}.reviewed.jsonl ({"path": "<file or glob>", "why": "..."} per line); generated code is excluded in org-pack/scan/${repo}.yaml.`);
+  else
+    io.out(`The read is complete: every source file is read (${cov.read.length})${cov.reviewed.length ? ` or reviewed with nothing to record (${cov.reviewed.length}, each with why in ${rel}/${repo}.verify.yaml)` : ""}.`);
+  for (const l of slipNoteLines(slips, verifyYaml, SHOWN))
+    io.out(l);
+  const dropped = report.reviewedDropped;
+  if (dropped.length) {
+    io.out(`${dropped.length} reviewed ${dropped.length === 1 ? "glob matches" : "globs match"} no file and ${dropped.length === 1 ? "was" : "were"} dropped (a note, not a refusal; under reviewedDropped in ${verifyYaml}):`);
+    show(dropped.map((d) => d.message), `(reviewedDropped in ${verifyYaml})`);
+  }
+  const unseen = report.methodUnseen;
+  if (unseen.length) {
+    io.out(`${unseen.length} ${unseen.length === 1 ? "entry or call claims" : "entries or calls claim"} an HTTP method ${unseen.length === 1 ? "its" : "their"} lines don't write (a warning, not a rejection; under methodUnseen in ${verifyYaml}):`);
+    show(unseen.map((m) => m.message), `(methodUnseen in ${verifyYaml})`);
+  }
+  const all = o.skipped === true;
+  const list = (lines, more) => {
+    if (all)
+      for (const l of lines)
+        io.out(`  ${l}`);
+    else
+      show(lines, more);
+  };
+  const seeAll = `atticus verify ${repo} --skipped prints every one`;
+  const skippedLines = report.skipped;
+  if (skippedLines.length) {
+    io.out(`${skippedLines.length} ${skippedLines.length === 1 ? "line of the files read writes" : "lines of the files read write"} a path, URL or topic no fact cites (a note for the reader to check, not a rejection; under skipped in ${verifyYaml}; ${seeAll}):`);
+    list(skippedLines.map((x) => `${x.cite} ${x.kind} ${x.value}`), `(${seeAll})`);
+  }
+  const holds = report.reviewedHolds;
+  if (holds.length) {
+    io.out(`${holds.length} reviewed ${holds.length === 1 ? "glob holds" : "globs hold"} lines that write a path, URL or topic (a note; under reviewedHolds in ${verifyYaml}): read them, then write their facts or say why there are none:`);
+    list(holds.map((h) => h.message), `(reviewedHolds in ${verifyYaml})`);
+  }
+  const ops = report.specOpsUncovered;
+  if (ops.length) {
+    io.out(`${ops.length} ${ops.length === 1 ? "operation the repo's OpenAPI spec declares has" : "operations the repo's OpenAPI specs declare have"} no entry (a note, not a rejection; under specOpsUncovered in ${verifyYaml}; ${seeAll}):`);
+    list(ops.map((x) => x.message), `(${seeAll})`);
+  }
+  if (report.redacted)
+    io.out(`${report.redacted} quotes had a secret value redacted.`);
+  if (report.quotesDropped)
+    io.out(`${report.quotesDropped} ${report.quotesDropped === 1 ? "quote was" : "quotes were"} left off (the cited line is minified, a notebook, binary or over 1,000 characters, and the quote doesn't match it); the claim itself was still checked on the line.`);
+  const noAuth = report.authUncited;
+  if (noAuth.length) {
+    io.out(`${noAuth.length} ${noAuth.length === 1 ? "entry's" : "entries'"} auth rests on no cited line (all under authUncited in ${verifyYaml}). ${noAuth.length === 1 ? "It is" : "They are"} kept in ${rel}/${repo}.jsonl, as the reader wrote ${noAuth.length === 1 ? "it" : "them"}, and left out of the catalog, so the map never says an auth nothing shows. To record ${noAuth.length === 1 ? "it" : "them"}: give each entry an authCite \u2014 the file and line that sets the auth and what it writes there \u2014 and run atticus verify ${repo} again:`);
+    show(noAuth.map((a) => `${a.id} (${a.auth}, ${a.cite})`), `(authUncited in ${verifyYaml})`);
+  }
+  const unfollowed = report.entriesNoFlowFollows;
+  if (unfollowed.length) {
+    io.out(`${unfollowed.length} ${unfollowed.length === 1 ? "entry" : "entries"} no flow follows (a note, not a rejection; listed under entriesNoFlowFollows in ${verifyYaml}): write a flow for each that does real work.`);
+    show(unfollowed.map((e) => `${e.entryType === "rest" && e.method ? e.method : e.entryType} ${e.path} (${e.id}, ${e.cite})`), `(entriesNoFlowFollows in ${verifyYaml})`);
+  }
+  const fws = frameworkFacts(report.accepted);
+  if (fws.length)
+    io.out(`Built on ${fws.map((f) => `${f.name}${f.version ? ` ${f.version}` : ""}`).join(", ")} (frameworks in ${verifyYaml}).`);
+  const gaps = report.frameworkGaps;
+  if (gaps.length) {
+    io.out(`${gaps.length} ${gaps.length === 1 ? "framework" : "frameworks"} this repo declares ${gaps.length === 1 ? "shows" : "show"} none of its patterns in the facts (a question for a person, not a rejection; under frameworkGaps in ${verifyYaml}):`);
+    show(gaps.map((g) => g.question), `(frameworkGaps in ${verifyYaml})`);
+  }
+  const learn = off.has("framework-models") ? [] : frameworksToLearn(report.accepted, await frameworksKnownTo(root), (await conventionsAt(root)).frameworks);
+  if (learn.length) {
+    io.out(`${learn.length} ${learn.length === 1 ? "framework" : "frameworks"} of the house nothing here can read yet: teach ${learn.length === 1 ? "it" : "them"} once, rather than having each repo's annotations read as ordinary code.`);
+    show(learn.map((l) => `${l.why} Learn it: ${l.command}`), "");
+  }
+  if (failed) {
+    if (o.write)
+      io.err(rejectedNote);
+    return 1;
+  }
+  if (!o.write) {
+    io.out(`When the read is complete: atticus verify ${repo} --write puts the facts in the catalog, the flows in specs/${repo}/, and renders the map.`);
+    return 0;
+  }
+  const { writeFactsIntoCatalog } = await import("./chunk-KM2FBM3T.js");
+  const written = await writeFactsIntoCatalog(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write`, verbose: o.verbose === true }, io);
+  return written ? 0 : 1;
+}
+
+export {
+  SHOWN,
+  factsRepos,
+  verifyAllCommand,
+  verifyInputsOf,
+  verifyCommand
+};

package/dist/chunk-3QAKDIEU.js

@@ -0,0 +1,108 @@
+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 {
+  ConformError,
+  conformChange,
+  conformanceOf
+} from "./chunk-XB5RFZHH.js";
+import "./chunk-IDGSU7JF.js";
+import "./chunk-LK44ULGI.js";
+import "./chunk-7YYEKTYF.js";
+import "./chunk-XEG3FE2R.js";
+import "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/change-conform.js
+var CITE = (c) => `${c.repo ? `${c.repo}:` : ""}${c.path}${c.line ? `:${c.line}` : ""}`;
+var LABEL = {
+  found: "found",
+  missing: "MISSING",
+  "still-there": "STILL THERE",
+  unexpected: "NOT IN THE DESIGN"
+};
+function print(results, io) {
+  for (const r of results) {
+    const n = r.counts;
+    io.out(`${r.repo} at ${r.ref} (${r.commit.slice(0, 12)}, from ${r.base.slice(0, 12)})${r.task ? `, task ${r.task}` : ""}: ${n.found} found, ${n.missing} missing, ${n.stillThere} still there, ${n.unexpected} not in the design.`);
+    for (const i of r.items)
+      io.out(`  ${LABEL[i.status]}  ${i.what}  ${i.at.map(CITE).join(", ")}${i.finding && i.finding.state !== "open" ? ` (${i.finding.state})` : ""}`);
+    if (r.unchecked.length) {
+      io.out("  Not checked by a scan (a person or a test checks these):");
+      for (const u of r.unchecked)
+        io.out(`    ${u.flow}${u.item ? ` item ${u.item}` : " trigger"} (${u.kind}): ${u.why}`);
+    }
+    for (const p of r.problems)
+      io.err(`${r.repo}: ${p}`);
+  }
+}
+async function changeConformCommand(root, change, o, io) {
+  if (o.latest) {
+    const v = await conformanceOf(root, change);
+    if (!v) {
+      io.err(`There is no change ${change}.`);
+      return 2;
+    }
+    if (o.json) {
+      io.out(JSON.stringify(v, null, 2));
+      return 0;
+    }
+    for (const p of v.problems)
+      io.err(p);
+    if (!v.results.length)
+      io.out(v.flows ? `${change} hasn't been checked against its target flows yet: atticus change conform ${change}.` : `${change} has no target flows yet, so there is nothing to check the code against.`);
+    print(v.results, io);
+    return 0;
+  }
+  try {
+    const run = await conformChange(root, change, {
+      ...o.repo ? { repo: o.repo } : {},
+      ...o.ref ? { ref: o.ref } : {},
+      ...o.task ? { task: o.task } : {}
+    });
+    const bad = run.results.some((r) => r.counts.missing + r.counts.stillThere + r.counts.unexpected > 0);
+    if (o.json) {
+      io.out(JSON.stringify(await conformanceOf(root, change), null, 2));
+      return run.results.length && !bad ? 0 : 1;
+    }
+    for (const p of run.problems)
+      io.err(p);
+    if (!run.flows) {
+      io.err(`${change} has no target flows yet, so there is nothing to check the code against: the architecture stage writes them (atticus change architecture ${change}).`);
+      return 1;
+    }
+    if (!run.results.length)
+      return 1;
+    print(run.results, io);
+    io.out(bad ? `The findings are on the conform gate${run.round ? ` (round ${run.round})` : ""}: atticus findings ${change} lists them; dismiss one with atticus finding ${change} <id> not-relevant --reason "...".` : "The code has everything its target flows add, and nothing they don't name.");
+    return bad ? 1 : 0;
+  } catch (e) {
+    if (e instanceof ConformError) {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+}
+export {
+  changeConformCommand
+};