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

package/dist/chunk-J4K3KVLD.js

@@ -0,0 +1,131 @@
+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-GLUX4EEP.js";
+import "./chunk-FITWGOJ2.js";
+import {
+  repoFor
+} from "./chunk-O3WI5KWW.js";
+import "./chunk-KEM4SDDP.js";
+import "./chunk-ZVM6AKKM.js";
+import {
+  draftRepoType,
+  matchRepoType
+} from "./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 {
+  fsRepo
+} from "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  RecordId,
+  loadOrgPack,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-type-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var pct = (n) => `${Math.round(n * 100)}%`;
+var notFound = (target) => `${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`;
+function verdictLine(id, r) {
+  const best = r.matches.find((m) => m.type === r.best);
+  switch (r.verdict) {
+    case "clear":
+      return `${id} is a clear match for ${best.name} (${best.type}), ${pct(best.score)}. Reuse it: atticus scan survey ${id} hands its settings and skills to your assistant.`;
+    case "partial":
+      return `${id} is a partial match for ${best.name} (${best.type}), ${pct(best.score)}. Reuse it, and extend the type with what this repo does differently.`;
+    case "tie":
+      return `${id} matches ${r.tied.join(" and ")} about as well.${r.fromDescription ? ` Its description says "${r.fromDescription.words}", so ${r.fromDescription.type} is the likelier of them; a person still decides.` : ""} A person decides which it is; then change the types so their fingerprints tell them apart.`;
+    case "none":
+      return `${id} matches no known repo type.${r.fromDescription ? ` Its description says "${r.fromDescription.words}", so ${r.fromDescription.type} may be it, though nothing in its files says so.` : ""} Draft one: atticus repo-type new <id> --from ${id}`;
+  }
+}
+function typeYaml(t) {
+  const doc = new import_yaml.Document(t);
+  (0, import_yaml.visit)(doc, {
+    Seq(_, node) {
+      if (node.items.every((i) => (0, import_yaml.isScalar)(i)))
+        node.flow = true;
+    }
+  });
+  return doc.toString({ lineWidth: 0, flowCollectionPadding: false });
+}
+async function repoTypeDetect(root, target, o, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(notFound(target));
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const said = op.profiles.flatMap((p) => p.repos?.repos ?? []).find((x) => x.id === repo.id)?.description?.text;
+  const r = await matchRepoType(fsRepo(repo.id, repo.dir, "0".repeat(40)), op.repoTypes, {
+    ...said ? { description: said } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify({ repo: repo.id, ...r }, null, 2));
+    return 0;
+  }
+  if (op.repoTypes.length === 0) {
+    io.out(`The org pack has no repo types yet (org-pack/repo-types/<id>/type.yaml). Draft one: atticus repo-type new <id> --from ${repo.id}`);
+    return 0;
+  }
+  io.out(verdictLine(repo.id, r));
+  for (const m of r.matches) {
+    io.out(`  ${m.type}  ${pct(m.score)} (${m.got} of ${m.total})${m.ruledOut ? ", ruled out: a required signal is missing" : ""}`);
+    for (const s of m.signals)
+      io.out(`    ${s.found ? "found  " : "missing"}  ${s.label} (${s.weight}${s.required ? ", required" : ""})${s.found ? `: ${s.evidence.join(", ")}` : ""}`);
+  }
+  return 0;
+}
+async function repoTypeNew(root, id, o, io) {
+  if (!RecordId.safeParse(id).success || !o.from) {
+    io.err("Usage: atticus repo-type new <id> --from <repo> [--force]. The id is a lowercase slug, like forge-spring-service.");
+    return 2;
+  }
+  const repo = await repoFor(root, o.from);
+  if (!repo) {
+    io.err(notFound(o.from));
+    return 2;
+  }
+  const dir = join(orgPackDirOf(root), "repo-types", id);
+  const file = join(dir, "type.yaml");
+  if (!o.force && await stat(file).catch(() => void 0)) {
+    io.err(`The repo type ${id} already exists (org-pack/repo-types/${id}/type.yaml). Re-run with --force to draft it again.`);
+    return 1;
+  }
+  const t = await draftRepoType(fsRepo(repo.id, repo.dir, "0".repeat(40)), id);
+  if (!t) {
+    io.out(`${repo.id} has no build file, dependency, framework marker or known folder to fingerprint; nothing was written. Write the type by hand.`);
+    return 1;
+  }
+  await mkdir(dir, { recursive: true });
+  const date = (o.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  await writeFile(file, `# Drafted from ${repo.id} by atticus repo-type new on ${date} (ADR 0077). Edit it: name what kind
+# of repo this is, keep the signals every repo of the kind has, set the weights, add skills.
+${typeYaml(t)}`, "utf8");
+  const kinds = /* @__PURE__ */ new Map();
+  for (const s of t.fingerprint)
+    kinds.set(s.kind, (kinds.get(s.kind) ?? 0) + 1);
+  io.out(`Wrote org-pack/repo-types/${id}/type.yaml from ${repo.id}: ${[...kinds].map(([k, n]) => `${n} ${k}`).join(", ")} ${t.fingerprint.length === 1 ? "signal" : "signals"}, ${t.settings.prefixes.length} prefix ${t.settings.prefixes.length === 1 ? "rule" : "rules"}.`);
+  io.out(`Next: edit it, check it with atticus repo-type detect ${repo.id} and atticus orgpack validate, then review it in a pull request.`);
+  return 0;
+}
+export {
+  repoTypeDetect,
+  repoTypeNew
+};

package/dist/chunk-JBTK5OP2.js

@@ -0,0 +1,55 @@
+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 {
+  external_exports,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  ensureLocalIgnore
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/me-file.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var ME_FILE = ".atticus/me.yaml";
+var MeNotify = external_exports.object({
+  /** Where the digest goes; default a direct message to the person. */
+  channel: external_exports.string().min(1).optional(),
+  /** How often the person wants the digest; Atticus sends it only when they (or their own scheduled job) ask. */
+  digest: external_exports.enum(["off", "daily", "weekly"]).default("off")
+});
+var MeFile = external_exports.object({
+  notify: MeNotify.optional(),
+  /** Changes the person follows: the digest and the editors say how each is doing. */
+  watch: external_exports.array(external_exports.string().min(1)).default([])
+});
+async function readMe(root) {
+  try {
+    const r = MeFile.safeParse((0, import_yaml.parse)(await readFile(join(root, ME_FILE), "utf8")) ?? {});
+    return r.success ? r.data : { watch: [] };
+  } catch {
+    return { watch: [] };
+  }
+}
+async function writeMe(root, me) {
+  await ensureLocalIgnore(root);
+  const file = join(root, ME_FILE);
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, (0, import_yaml.stringify)({
+    ...me.notify ? { notify: me.notify } : {},
+    ...me.watch.length ? { watch: [...new Set(me.watch)].sort() } : {}
+  }), "utf8");
+}
+
+export {
+  ME_FILE,
+  readMe,
+  writeMe
+};

package/dist/chunk-JCZIKA4C.js

@@ -0,0 +1,163 @@
+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 {
+  ASSISTANT_FORMATS,
+  assistantTier,
+  probeFileOf,
+  probeTier,
+  writeProbe
+} from "./chunk-IPKHE5D6.js";
+import "./chunk-EFHQ3TWP.js";
+import {
+  AssistantId,
+  external_exports,
+  loadOrgPack,
+  orgPackDirOf,
+  runsDirOf,
+  runsRelOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/probe-commands.js
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var OPEN_HOURS = 24;
+var Challenge = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  assistant: AssistantId,
+  code: external_exports.string().regex(/^[0-9a-f]{8}$/),
+  started: external_exports.iso.datetime(),
+  maxTokens: external_exports.number().int().min(1e3).optional()
+});
+var probeDir = (root) => join(runsDirOf(root), "probe");
+var probeRel = (root) => `${runsRelOf(root)}/probe`;
+function startIn(id) {
+  const f = ASSISTANT_FORMATS[id];
+  return id === "agents-md" ? `In ${f.typeIn}, ask it to follow ${f.commandPath("atticus-probe")}.` : `In ${f.typeIn}, run /atticus-probe.`;
+}
+async function probeCommand(root, o, io, deps = {}) {
+  const rt = (await loadOrgPack(orgPackDirOf(root))).runtime;
+  if (rt.ai === "off") {
+    io.err("AI is off here (runtime.yaml): there is no assistant to probe.");
+    return 1;
+  }
+  const want = o.assistant ?? rt.assistants.default;
+  const id = AssistantId.safeParse(want);
+  if (!id.success || !rt.assistants.allowed.includes(id.data)) {
+    io.err(`runtime.yaml doesn't allow ${want} here: it allows ${rt.assistants.allowed.join(", ")}.`);
+    return 2;
+  }
+  const assistant = id.data;
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  const challenge = {
+    schemaVersion: 1,
+    assistant,
+    code: deps.code?.() ?? randomBytes(4).toString("hex"),
+    started: now.toISOString(),
+    ...o.maxTokens !== void 0 ? { maxTokens: o.maxTokens } : {}
+  };
+  const dir = probeDir(root);
+  await rm(dir, { recursive: true, force: true });
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "probe.json"), `${JSON.stringify(challenge, null, 2)}
+`, "utf8");
+  await writeFile(join(dir, "challenge.md"), [
+    "# Atticus capability probe",
+    "",
+    `Code: ${challenge.code}`,
+    "",
+    `Atticus wrote this file at ${challenge.started} for /atticus-probe. The steps of /atticus-probe say what to do with the code.`,
+    ""
+  ].join("\n"), "utf8");
+  const rel = probeRel(root);
+  const name = ASSISTANT_FORMATS[assistant].name;
+  const result = probeFileOf(assistant);
+  if (o.json) {
+    io.out(JSON.stringify({
+      assistant,
+      challenge: `${rel}/challenge.md`,
+      answerFile: `${rel}/answer.txt`,
+      result,
+      started: challenge.started,
+      expires: new Date(now.getTime() + OPEN_HOURS * 36e5).toISOString(),
+      ...o.maxTokens !== void 0 ? { maxTokens: o.maxTokens } : {}
+    }, null, 2));
+    return 0;
+  }
+  io.out(`Probing ${name} (another assistant runtime.yaml allows: --assistant <id>).`);
+  io.out(`${startIn(assistant)} It asks the assistant to open ${rel}/challenge.md, write the code it holds to ${rel}/answer.txt, and run atticus probe answer <code> itself.`);
+  io.out("An assistant that can't run commands gives you a line to paste in this terminal instead: atticus probe answer <code> --pasted.");
+  io.out("A chat with no /atticus-probe (a web chat) can't open files here: run atticus probe answer none --pasted.");
+  if (o.maxTokens === void 0)
+    io.out("Give your model's limit, the most tokens it takes in one prompt, with --max-tokens <n> on the answer if you know it: Atticus never guesses it.");
+  else
+    io.out(`Model limit: ${o.maxTokens} tokens, as you stated it.`);
+  io.out(`The probe is open for ${OPEN_HOURS} hours. Nothing leaves this machine: the answer is checked here and kept in ${result}.`);
+  return 0;
+}
+var yesNo = (b) => b ? "yes" : "no";
+async function probeAnswerCommand(root, given, o, io, deps = {}) {
+  if (!given) {
+    io.err("Usage: atticus probe answer <code|none> [--pasted] [--max-tokens n] [--json]");
+    return 2;
+  }
+  const dir = probeDir(root);
+  const rel = probeRel(root);
+  const parsed = Challenge.safeParse(await readFile(join(dir, "probe.json"), "utf8").then((t2) => JSON.parse(t2)).catch(() => void 0));
+  if (!parsed.success) {
+    io.err("No probe is under way here: start one with atticus probe.");
+    return 1;
+  }
+  const c = parsed.data;
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  if (now.getTime() - Date.parse(c.started) > OPEN_HOURS * 36e5) {
+    io.err(`The probe started at ${c.started} is more than ${OPEN_HOURS} hours old: start a new one with atticus probe.`);
+    return 1;
+  }
+  const code = given.trim().toLowerCase();
+  if (code !== "none" && code !== c.code) {
+    io.err(`${given.trim()} isn't the code in ${rel}/challenge.md: the assistant didn't read that file. Nothing was recorded. Run /atticus-probe again, or answer none if the assistant can't open files.`);
+    return 1;
+  }
+  const answerFile = join(dir, "answer.txt");
+  const written = existsSync(answerFile) ? (await readFile(answerFile, "utf8").catch(() => "")).trim().toLowerCase() : void 0;
+  const read = code === c.code;
+  const write = written === c.code;
+  const run = o.pasted !== true;
+  const maxTokens = o.maxTokens ?? c.maxTokens;
+  const result = {
+    schemaVersion: 1,
+    assistant: c.assistant,
+    measured: now.toISOString(),
+    tier: probeTier({ read, write, run }),
+    read,
+    write,
+    run,
+    answered: run ? "command" : "pasted",
+    ...maxTokens !== void 0 ? { maxTokens } : {}
+  };
+  const file = await writeProbe(root, result);
+  await rm(dir, { recursive: true, force: true });
+  const rt = (await loadOrgPack(orgPackDirOf(root))).runtime;
+  const t = assistantTier({ ...rt, assistants: { allowed: [c.assistant], default: c.assistant } }, { probes: [result], now });
+  if (o.json) {
+    io.out(JSON.stringify({ ...result, file, how: t.how }, null, 2));
+    return 0;
+  }
+  const name = ASSISTANT_FORMATS[c.assistant].name;
+  io.out(`Measured ${name}: opened the file Atticus wrote: ${yesNo(read)}; wrote a file: ${write ? "yes" : written === void 0 ? "no" : `no (${rel}/answer.txt doesn't hold the code)`}; ran a command itself: ${run ? "yes" : "no (the line was pasted)"}. That is ${result.tier === 1 ? "agentic (tier 1)" : result.tier === 2 ? "batched hand-off (tier 2)" : "copy-paste (tier 3)"}.`);
+  io.out(`The first read of a repo: ${t.how}`);
+  io.out(maxTokens !== void 0 ? `Model limit: ${maxTokens} tokens, as stated.` : "No model limit was stated: atticus probe --max-tokens <n> measures again with it, or give --max-tokens <n> on each atticus map.");
+  io.out(`Kept in ${file}, on this machine only (never committed). atticus doctor, init, adopt and map --estimate say this tier from now on.`);
+  return 0;
+}
+export {
+  probeAnswerCommand,
+  probeCommand
+};

package/dist/chunk-JGZCG5VM.js

@@ -0,0 +1,189 @@
+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 {
+  askHosts
+} from "./chunk-RVH5SUW5.js";
+import {
+  driftAfterScan
+} from "./chunk-OT2O76OS.js";
+import {
+  diffCatalogs,
+  diffIsEmpty,
+  readCatalog,
+  scanEstate,
+  writeCatalog
+} from "./chunk-27NKUS3X.js";
+import {
+  loadRepos
+} from "./chunk-EFHQ3TWP.js";
+import {
+  catalogDirOf
+} from "./chunk-S2A7YC3Q.js";
+import {
+  LockHeldError,
+  acquireLock
+} from "./chunk-D3PO4DOZ.js";
+
+// packages/cli/dist/scan-commands.js
+import { join } from "node:path";
+function diffLines(d) {
+  if (diffIsEmpty(d))
+    return ["No catalog changes."];
+  const lines = [
+    `${d.added.length} added, ${d.removed.length} removed, ${d.changed.length} changed, ${d.evidenceOnly.length} with new evidence only`,
+    ...d.added.map((r) => `+ ${r.kind}/${r.id}`),
+    ...d.removed.map((r) => `- ${r.kind}/${r.id}`),
+    ...d.changed.map((r) => `~ ${r.kind}/${r.id} (${r.fields.join(", ")})`)
+  ];
+  return lines;
+}
+function driftLine(d) {
+  const head = `Drift check for ${d.change} (${d.state})`;
+  if (d.error)
+    return `${head} couldn't run: ${d.error}`;
+  if (d.round === void 0)
+    return `${head}: no drift.`;
+  const what = `${d.open} open finding${d.open === 1 ? "" : "s"}${d.blocking ? ` (${d.blocking} blocking)` : ""}`;
+  return `${head}: ${what} in review/drift/${d.round}${d.unchanged ? ", nothing new" : ""}.`;
+}
+async function scanCommand(root, o, io) {
+  if (o.repos && o.repos.length > 0) {
+    const known = new Set((await loadRepos(root)).map((r) => r.id));
+    const unknown = o.repos.filter((r) => !known.has(r));
+    if (unknown.length > 0) {
+      io.err(`Not in any repos.manifest.yaml: ${unknown.join(", ")}`);
+      return 2;
+    }
+  }
+  let lock;
+  if (!o.dryRun) {
+    try {
+      lock = await acquireLock(root, "scan", "scan");
+    } catch (e) {
+      if (e instanceof LockHeldError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+    if (lock.interrupted)
+      io.err(`The last scan (started ${lock.interrupted.startedAt}) stopped before it finished; this one brings the catalog up to date.`);
+  }
+  try {
+    if (o.ref) {
+      const { scanBranch } = await import("./chunk-ZCJDOK2S.js");
+      return await scanBranch(root, o.ref, {
+        ...o.repos ? { repos: o.repos } : {},
+        ...o.full ? { full: true } : {},
+        ...o.json ? { json: true } : {}
+      }, io);
+    }
+    return await scanLocked(root, o, io);
+  } finally {
+    await lock?.release();
+  }
+}
+async function scanLocked(root, o, io) {
+  const out = join(catalogDirOf(root), "generated");
+  const before = await readCatalog(out, { cacheRoot: root });
+  const started = Date.now();
+  const scan = await scanEstate({
+    root,
+    ...o.repos ? { repos: o.repos } : {},
+    ...o.full ? { cache: null } : {}
+  });
+  const diff = diffCatalogs(before.records, scan.records);
+  const write = o.dryRun ? void 0 : await writeCatalog(out, scan.records);
+  const drift = write && !o.noDrift ? await driftAfterScan(root) : [];
+  const hosts = write ? await askHosts(root, scan.records, { command: "atticus scan" }) : { raised: [], open: [], lines: [] };
+  const problems = [
+    ...before.problems.map((p) => ({ source: `catalog/generated/${p.file}`, message: p.message })),
+    ...scan.problems
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const warnings = scan.repos.flatMap((r) => r.warnings.map((w) => ({ repo: r.repo, ...w })).filter((w) => {
+    const k = `${w.repo}\0${w.path ?? ""}\0${w.message}`;
+    if (seen.has(k))
+      return false;
+    seen.add(k);
+    return true;
+  }));
+  if (o.json) {
+    io.out(JSON.stringify({
+      stats: scan.stats,
+      diff,
+      problems,
+      warnings,
+      coverage: scan.coverage,
+      unmodelled: scan.unmodelled,
+      notes: scan.notes,
+      written: write !== void 0,
+      files: write ?? null,
+      drift,
+      questions: [...hosts.raised, ...hosts.open].map((q) => q.id)
+    }, null, 2));
+  } else {
+    const s = scan.stats;
+    io.out(`Scanned ${s.repos} repos in ${((Date.now() - started) / 1e3).toFixed(1)}s (${s.ranRuns} extractor runs, ${s.cachedRuns} from cache)`);
+    io.out(`${s.records} records: ${s.interfaces} interfaces (${s.verified} verified), ${s.unresolved} loose ends`);
+    const joined = scan.coverage.reduce((n, c) => n + c.joined, 0);
+    const found = joined + scan.coverage.reduce((n, c) => n + c.open, 0);
+    const unread = scan.coverage.reduce((n, c) => n + c.unreadFiles, 0);
+    io.out(`Joined ${joined} of ${found} calls, listeners and endpoints found (${found ? Math.round(joined / found * 100) : 100}%)` + (unread ? `; ${unread} file${unread === 1 ? " uses" : "s use"} a client library with nothing read (atticus scan --warnings)` : ""));
+    for (const c of scan.coverage)
+      for (const r of c.redraft)
+        io.out(`Rule ${r.dialect} on ${c.repo} ${r.why === "tests-fail" ? "fails its own tests, so this scan didn't use it" : "read nothing there"}; have your assistant re-draft it: atticus onboard ${c.repo} --name ${r.dialect} (then onboard accept ${r.dialect} --replace)`);
+    const toOnboard = scan.coverage.filter((c) => c.needsOnboarding);
+    if (toOnboard.length)
+      io.out(`Read nothing from ${toOnboard.length === 1 ? "1 repo" : `${toOnboard.length} repos`} whose files no reader knows: ${toOnboard.map((c) => `${c.repo} (${c.unreadConfig.length} file${c.unreadConfig.length === 1 ? "" : "s"})`).join(", ")}. Have your assistant draft a dialect: atticus onboard ${toOnboard[0].repo}`);
+    for (const f of scan.unmodelled)
+      io.out(`House framework ${f.framework} is imported by ${f.repos.length} repos and no framework model covers it: ${f.repos.join(", ")}. Onboard it: atticus onboard framework ${f.name} --from <its source, JAR or package> --users ${f.repos.join(",")}`);
+    const idle = /* @__PURE__ */ new Map();
+    for (const c of scan.coverage)
+      for (const r of c.redraftFrameworks)
+        idle.set(r.framework, [...idle.get(r.framework) ?? [], c.repo]);
+    for (const [framework, repos] of idle)
+      io.out(`Framework model ${framework} read nothing in ${repos.join(", ")}, which import${repos.length === 1 ? "s" : ""} it; the framework may have changed. Have your assistant re-draft it: atticus onboard framework ${framework} --from <its source, JAR or package> --users ${repos.join(",")} (then onboard accept framework ${framework} --replace)`);
+    for (const l of diffLines(diff))
+      io.out(l);
+    if (write)
+      io.out(`catalog/generated: ${write.written} written, ${write.unchanged} unchanged, ${write.removed} removed`);
+    else
+      io.out("Dry run: nothing written.");
+    for (const d of drift)
+      io.out(driftLine(d));
+    for (const l of hosts.lines)
+      io.out(l);
+    for (const n of scan.notes)
+      io.out(`note: ${n}`);
+    if (o.warnings)
+      for (const w of warnings)
+        io.out(`warning: ${w.repo}: ${w.path ? `${w.path}: ` : ""}${w.message}`);
+    else if (warnings.length)
+      io.out(`${warnings.length} warning${warnings.length === 1 ? "" : "s"}: atticus scan --warnings lists ${warnings.length === 1 ? "it" : "them"}`);
+    for (const p of problems)
+      io.err(`${"repo" in p && p.repo ? `${p.repo}: ` : ""}${p.source}: ${p.message}`);
+  }
+  return problems.length > 0 ? 1 : 0;
+}
+async function catalogDiff(a, b, json, io) {
+  const [x, y] = await Promise.all([readCatalog(a), readCatalog(b)]);
+  for (const p of [...x.problems, ...y.problems])
+    io.err(`${p.file}: ${p.message}`);
+  const d = diffCatalogs(x.records, y.records);
+  if (json)
+    io.out(JSON.stringify(d, null, 2));
+  else
+    for (const l of diffLines(d))
+      io.out(l);
+  return diffIsEmpty(d) && x.problems.length + y.problems.length === 0 ? 0 : 1;
+}
+
+export {
+  diffLines,
+  scanCommand,
+  catalogDiff
+};