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

package/dist/chunk-KM2FBM3T.js

@@ -0,0 +1,659 @@
+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 {
+  linkEvidenceAbout,
+  linkEvidenceLines,
+  loadLinkEvidence,
+  writeRepoContracts
+} from "./chunk-GXJVY6WT.js";
+import {
+  diffLines
+} from "./chunk-7TGYNOXD.js";
+import {
+  askHosts
+} from "./chunk-LRS573EX.js";
+import "./chunk-IDGSU7JF.js";
+import "./chunk-LK44ULGI.js";
+import "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import {
+  TARGETS_STEP,
+  catalogWithFacts,
+  diffCatalogs,
+  diffIsEmpty,
+  estateFacts,
+  estateRepos,
+  groupedTargetDrafts,
+  isPrototypeRepo,
+  prototypeLeftOut,
+  readCatalog,
+  ruledTargets,
+  splitTargetGroups,
+  staleTargetQuestions,
+  targetQuestionFor,
+  targetsFromAnswers,
+  writeCatalog
+} from "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import {
+  codeLinkerFor,
+  frameworkFacts,
+  frameworkGaps,
+  renderMap,
+  trustOf
+} from "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  SPEC_HEADER_SCHEMA_VERSION,
+  catalogDirOf,
+  factsDirOf,
+  factsRelOf,
+  flowFiles,
+  isAdopted,
+  isGuessedJoin,
+  listQuestions,
+  loadOrgPack,
+  mapDirOf,
+  mapRelOf,
+  orgPackDirOf,
+  parseFacts,
+  parseRecord,
+  questionId,
+  questionsRelOf,
+  raiseQuestions,
+  readRepoSpec,
+  readSharedMaps,
+  removeFlow,
+  require_dist,
+  retireQuestion,
+  specFileHash,
+  specRelOf,
+  writeFlow,
+  writeSpecHeader
+} from "./chunk-577AJVRS.js";
+import {
+  LockHeldError,
+  acquireLock,
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/map-render-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { readFile, readdir, rm } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var FACTS_TEMPLATE = "facts@1";
+var posix = (p) => p.split(sep).join("/");
+var HOW_WORDS = {
+  answer: "a person's answer",
+  named: "name",
+  repo: "the repo's name",
+  host: "host",
+  path: "path",
+  topic: "topic"
+};
+function linkChanges(repo, join2, before, after) {
+  const mine = (xs) => (xs ?? []).filter((x) => x.call.repo === repo);
+  const joined = mine(join2?.joins);
+  const how = new Map((join2?.joins ?? []).map((j) => [j.interface, j.how]));
+  const ifaces = (rs) => new Map(rs.filter((r) => r.kind === "Interface").map((r) => [r.id, r]));
+  const was = ifaces(before);
+  const now = ifaces(after);
+  const linked = new Set([...now.values()].flatMap((r) => r.evidence.filter((e) => e.side !== "callee").map((e) => `${e.repo}|${e.path}:${e.line}`)));
+  const line = (r, found) => {
+    const h = found ? how.get(r.id) : void 0;
+    return {
+      id: r.id,
+      from: r.from,
+      to: r.to,
+      ...r.method ? { method: r.method } : {},
+      path: r.normalizedPath,
+      confidence: r.confidence,
+      ...h ? { how: h } : {},
+      ...r.flags?.length ? { flags: [...r.flags] } : {}
+    };
+  };
+  const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  const flagsOf = (r) => [...r.flags ?? []].sort().join(",");
+  const changed = [];
+  for (const [id, r] of now) {
+    const old = was.get(id);
+    if (!old || old.confidence === r.confidence && flagsOf(old) === flagsOf(r))
+      continue;
+    changed.push({
+      ...line(r, true),
+      was: {
+        confidence: old.confidence,
+        ...old.flags?.length ? { flags: [...old.flags] } : {}
+      }
+    });
+  }
+  return {
+    calls: {
+      joined: joined.length,
+      inferred: joined.filter(isGuessedJoin).length,
+      asked: mine(join2?.asks).filter((a) => !linked.has(`${a.call.repo}|${a.call.at}`)).length,
+      outside: mine(join2?.outside).length,
+      missed: mine(join2?.misses).length
+    },
+    added: [...now.values()].filter((r) => !was.has(r.id)).map((r) => line(r, true)).sort(byId),
+    removed: [...was.values()].filter((r) => !now.has(r.id)).map((r) => line(r, false)).sort(byId),
+    changed: changed.sort(byId)
+  };
+}
+var LINKS_SHOWN = 5;
+function linkLines(l, report, o = {}) {
+  const c = l.calls;
+  const calls = `${c.joined} call${c.joined === 1 ? "" : "s"} joined${c.inferred ? ` (${c.inferred} inferred)` : ""}, ${c.asked} asked, ${c.outside} outside the estate, ${c.missed} not joined`;
+  const counts = [
+    l.added.length ? `+${l.added.length}` : "",
+    l.removed.length ? `-${l.removed.length}` : "",
+    l.changed.length ? `~${l.changed.length}` : ""
+  ].filter(Boolean);
+  if (!counts.length)
+    return [`  Links: ${calls}; no Interface added or removed.`];
+  const out = [`  Links: ${calls}; Interfaces ${counts.join(" ")} (all under links in ${report}).`];
+  const text = (sign, x) => {
+    const what = [x.method, x.path].filter(Boolean).join(" ");
+    const conf = x.was ? `${x.confidence}, was ${x.was.confidence}` : x.confidence;
+    const flags = x.flags?.join(", ");
+    const found = x.how ? `found by ${HOW_WORDS[x.how]}${flags ? `: ${flags}` : ""}` : flags ?? "";
+    return `    ${sign} ${x.from} \u2192 ${x.to} ${what} (${conf}${found ? `; ${found}` : ""})`;
+  };
+  const all = [
+    ...l.added.map((x) => text("+", x)),
+    ...l.removed.map((x) => text("-", x)),
+    ...l.changed.map((x) => text("~", x))
+  ];
+  const shown = o.verbose ? all : all.slice(0, LINKS_SHOWN);
+  out.push(...shown);
+  if (shown.length < all.length)
+    out.push(`    ... and ${all.length - shown.length} more (links in ${report})`);
+  return out;
+}
+async function writeLinksIntoReport(root, repo, links, exposure = [], evidence, shared) {
+  const file = join(factsDirOf(root), `${repo}.verify.yaml`);
+  const text = await readFile(file, "utf8").catch(() => void 0);
+  if (text === void 0)
+    return;
+  let report;
+  try {
+    report = (0, import_yaml.parse)(text);
+  } catch {
+    return;
+  }
+  if (!report || typeof report !== "object" || Array.isArray(report))
+    return;
+  const { exposure: _old, contracts: _c, traffic: _t, shared: _s, ...rest } = report;
+  const c = evidence?.contracts;
+  const t = evidence?.traffic;
+  await writeFileAtomic(file, (0, import_yaml.stringify)({
+    ...rest,
+    links,
+    ...exposure.length ? {
+      exposure: exposure.map((x) => ({
+        reason: x.reason,
+        fact: x.exposure.fact,
+        at: x.exposure.at,
+        message: x.message
+      }))
+    } : {},
+    ...c && (c.confirmed.length || c.findings.length) ? { contracts: c } : {},
+    ...t && (t.seen.length || t.findings.length || t.unknownApps.length) ? { traffic: t } : {},
+    ...shared && (shared.joined.length || shared.unmatched.length || shared.asked.length) ? { shared } : {}
+  }));
+}
+function sharedReport(r, maps) {
+  const commit = (team) => maps.find((m) => m.team === team)?.commit ?? "";
+  return {
+    joined: r.matches.map((m) => ({
+      call: m.call.fact,
+      at: m.call.at,
+      team: m.team,
+      commit: commit(m.team),
+      repo: m.entry.repo,
+      entry: m.entry.fact,
+      entryAt: m.entry.at
+    })),
+    unmatched: r.gaps.map((g) => ({
+      call: g.call.fact,
+      at: g.call.at,
+      team: g.team,
+      commit: commit(g.team),
+      message: g.message
+    })),
+    asked: r.asks.map((a) => ({
+      call: a.call.fact,
+      at: a.call.at,
+      team: a.team,
+      question: a.question
+    }))
+  };
+}
+function sharedLines(repo, s, verbose) {
+  const out = [];
+  const teams = [...new Set([...s.joined, ...s.unmatched, ...s.asked].map((x) => x.team))].sort();
+  for (const team of teams) {
+    const j = s.joined.filter((x) => x.team === team);
+    const u = s.unmatched.filter((x) => x.team === team);
+    const a = s.asked.filter((x) => x.team === team);
+    const c = (j[0] ?? u[0])?.commit.slice(0, 7);
+    out.push(`Shared map: ${j.length} of ${repo}'s calls joined to ${team}'s map${c ? ` (their commit ${c})` : ""}, each citing their entry; ${u.length} it has no entry for${a.length ? `; ${a.length} two of its entries answer` : ""}. Their entries are theirs: a wrong one is theirs to correct.`);
+    for (const x of verbose ? j : [])
+      out.push(`  ${x.at} \u2192 ${x.repo} ${x.entryAt} (${x.entry})`);
+    for (const x of verbose ? u : u.slice(0, 5))
+      out.push(`  ${x.at}: ${x.message}`);
+    for (const x of a)
+      out.push(`  ${x.at}: ${x.question}`);
+  }
+  return out;
+}
+function countByKind(d) {
+  const out = {};
+  const of = (k) => out[k] ??= { added: 0, changed: 0, removed: 0 };
+  for (const r of d.added)
+    of(r.kind).added++;
+  for (const r of [...d.changed, ...d.evidenceOnly])
+    of(r.kind).changed++;
+  for (const r of d.removed)
+    of(r.kind).removed++;
+  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a < b ? -1 : 1));
+}
+function kindLine(byKind) {
+  const parts = Object.entries(byKind).map(([kind, c]) => [
+    kind,
+    c.added ? `+${c.added}` : "",
+    c.changed ? `~${c.changed}` : "",
+    c.removed ? `-${c.removed}` : ""
+  ].filter(Boolean).join(" "));
+  return parts.join(", ");
+}
+async function projectFactsIntoCatalog(root, repo, facts, given = {}) {
+  const op = given.op ?? await loadOrgPack(orgPackDirOf(root));
+  const cacheOpts = given.cache === false ? {} : { cacheRoot: root };
+  const existing = given.existing ?? (await readCatalog(join(catalogDirOf(root), "generated"), cacheOpts)).records;
+  const curated = await readCatalog(join(catalogDirOf(root), "curated"), cacheOpts);
+  const everyTarget = (await listQuestions(root, { step: TARGETS_STEP })).questions;
+  const answered = everyTarget.filter((q) => q.repo === repo);
+  const repoType = estateRepos(op).find((r) => r.id === repo)?.type;
+  const targetsOpts = repoType ? { repoType } : {};
+  const targets = targetsFromAnswers(repo, facts, everyTarget, targetsOpts);
+  const ruled = ruledTargets(repo, facts, everyTarget, targetsOpts);
+  const estate = await estateFacts(root, op, repo);
+  const onFile = await loadLinkEvidence(root);
+  const evidence = given.contracts ? {
+    ...onFile,
+    contracts: [
+      ...onFile.contracts.filter((c) => c.repo !== repo),
+      ...given.contracts.entries.length ? [given.contracts] : []
+      // In the companions' file order, as `loadLinkEvidence` reads them.
+    ].sort((a, b) => {
+      const [x, y] = [`${a.repo}.contracts.yaml`, `${b.repo}.contracts.yaml`];
+      return x < y ? -1 : x > y ? 1 : 0;
+    })
+  } : onFile;
+  const shared = await readSharedMaps(root);
+  const result = catalogWithFacts({
+    repo,
+    facts,
+    existing: [...existing],
+    op,
+    decisions: curated.records,
+    targets,
+    estate: estate.repos,
+    estateTargets: estate.targets,
+    linkEvidence: { contracts: evidence.contracts, traffic: evidence.traffic },
+    ...shared.maps.length ? { shared: shared.maps } : {}
+  });
+  const diff = diffCatalogs([...existing], result.records);
+  const links = linkChanges(repo, result.join, existing, result.records);
+  return {
+    op,
+    existing,
+    answered,
+    targets,
+    ruled,
+    estate,
+    result,
+    diff,
+    links,
+    evidenceProblems: [...evidence.problems, ...shared.problems.map((p) => p.message)],
+    sharedMaps: shared.maps
+  };
+}
+async function writeFactsIntoCatalog(root, repo, facts, o, io) {
+  let lock;
+  try {
+    lock = await acquireLock(root, "scan", o.command);
+  } catch (e) {
+    if (e instanceof LockHeldError) {
+      io.err(e.message);
+      return void 0;
+    }
+    throw e;
+  }
+  try {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const generated = join(catalogDirOf(root), "generated");
+    const existing = await readCatalog(generated, { cacheRoot: root });
+    if (isPrototypeRepo(op, repo)) {
+      for (const n of prototypeLeftOut({ repo, facts, existing: [], op, decisions: [] }).notes)
+        io.out(n);
+      const none = diffCatalogs(existing.records, existing.records);
+      return {
+        written: { written: 0, unchanged: 0, removed: 0 },
+        flows: [],
+        questions: [],
+        map: [],
+        changes: { ...none, byKind: {} },
+        links: {
+          calls: { joined: 0, inferred: 0, asked: 0, outside: 0, missed: 0 },
+          added: [],
+          removed: [],
+          changed: []
+        }
+      };
+    }
+    const rerun = `atticus verify ${repo} --write`;
+    await writeRepoContracts(root, repo, o.dir, facts, (n) => io.err(n));
+    const { answered, targets, ruled, estate, result, diff, links, evidenceProblems, sharedMaps } = await projectFactsIntoCatalog(root, repo, facts, { op, existing: existing.records });
+    for (const p of evidenceProblems)
+      io.err(p);
+    for (const i of result.invalid)
+      io.err(`A merged record isn't valid C1 (a bug): ${i.issues.map((x) => `${x.path}: ${x.message}`).join("; ")}`);
+    const written = await writeCatalog(generated, result.records);
+    const flows = result.flows.filter((f) => {
+      const p = parseRecord(f);
+      if (p.ok)
+        return true;
+      io.err(`The flow ${f.id} isn't written to ${specRelOf(root, repo)}/: ${p.issues.map((i) => `${i.path}: ${i.message}`).join("; ")}. Have your assistant fix its flow fact (each call-out step's ref names the call it makes), then run ${rerun}.`);
+      return false;
+    });
+    const spec = await readRepoSpec(root, repo, { cacheRoot: root });
+    const ids = new Set(flows.map((f) => f.id));
+    for (const f of spec.flows)
+      if (f.template === FACTS_TEMPLATE && !ids.has(f.id))
+        await removeFlow(root, repo, f.id);
+    const flowPaths = [];
+    for (const f of flows)
+      flowPaths.push(await writeFlow(root, repo, f));
+    const files = {};
+    for (const f of flows)
+      for (const p of flowFiles(f)) {
+        const text = await readFile(join(o.dir, ...p.split("/")), "utf8").catch(() => void 0);
+        if (text !== void 0)
+          files[p] = specFileHash(text);
+      }
+    const commit = facts.map((f) => f.commit).sort()[0];
+    const kept = spec.flows.filter((f) => f.template !== FACTS_TEMPLATE).map((f) => f.id);
+    const header = spec.header;
+    await writeSpecHeader(root, {
+      schemaVersion: SPEC_HEADER_SCHEMA_VERSION,
+      repo,
+      template: header?.template ?? FACTS_TEMPLATE,
+      templateReviewed: header?.templateReviewed ?? false,
+      ...commit ? { commit } : {},
+      ...header?.drafted ? { drafted: header.drafted } : {},
+      flows: [.../* @__PURE__ */ new Set([...kept, ...ids])].sort(),
+      files: Object.fromEntries(Object.entries({ ...header?.files ?? {}, ...files }).sort(([a], [b]) => a < b ? -1 : 1)),
+      questions: header?.questions ?? []
+    });
+    const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+    const hosts = await askHosts(root, result.records, { command: o.command, rerun, now: o.now });
+    const loose = new Set(result.unresolved.map((u) => u.factId));
+    const ambiguous = new Set((result.join?.asks ?? []).filter((a) => a.reason === "ambiguous" && a.call.repo === repo).map((a) => a.call.fact));
+    const named = new Set(facts.filter((f) => f.kind === "call" && f.to).map((f) => f.id));
+    const raised = [...hosts.raised];
+    const lines = [...hosts.lines];
+    const asked = new Set([...loose, ...ambiguous].filter((id) => targets[id] === void 0 && !answered.some((q) => q.state === "answered" && q.id === targetId(facts, repo, id))));
+    const drafted = groupedTargetDrafts(facts, result.records, op, result.join?.asks, {
+      ask: asked,
+      split: splitTargetGroups(answered)
+    });
+    for (const t of drafted) {
+      const r = await raiseQuestions(root, [t.draft], {
+        step: TARGETS_STEP,
+        repo,
+        command: o.command,
+        rerun,
+        at
+      });
+      for (const q of r.raised) {
+        raised.push(q);
+        lines.push(t.factIds.length > 1 ? `${t.factIds.length} calls go the same way and name no target the estate has: asked once, ${q.id}: ${q.question} One answer names the target of all of them. Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : named.has(t.factId) ? `A call names a target the estate doesn't have, and more than one entry serves it: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : `A call names no target: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.`);
+      }
+    }
+    for (const s of staleTargetQuestions({
+      repo,
+      facts,
+      open: answered.filter((q) => q.state === "open"),
+      drafted,
+      asked,
+      ruled,
+      ...result.join ? { join: result.join } : {}
+    })) {
+      await retireQuestion(root, s.id, {
+        why: s.why,
+        at,
+        ...s.replacedBy ? { replacedBy: s.replacedBy } : {}
+      });
+      lines.push(`Retired ${s.id}: ${s.why}.`);
+    }
+    const byKind = countByKind(diff);
+    io.out(`Wrote the catalog for ${repo}: ${written.written} files written, ${written.removed} removed, ${written.unchanged} unchanged.`);
+    io.out(diffIsEmpty(diff) ? "  No catalog changes." : `  Records: ${kindLine(byKind)}.`);
+    if (o.verbose)
+      for (const l of diffLines(diff).slice(1))
+        io.out(`    ${l}`);
+    const specsRel = specRelOf(root, repo);
+    io.out(`  Flows: ${flowPaths.length} in ${specsRel}/.`);
+    if (o.verbose)
+      for (const p of flowPaths)
+        io.out(`    ${p}`);
+    else if (!diffIsEmpty(diff) || flowPaths.length)
+      io.out(`  atticus verify ${repo} --write --verbose lists each record and flow.`);
+    for (const p of result.curated.problems)
+      io.out(`Curated decision ${p.decision} no longer applies: ${p.message}`);
+    for (const p of result.projectionIssues)
+      io.out(`  ${p.code}: ${p.message}`);
+    for (const l of joinLines(repo, result.join, estate.notes, { verbose: o.verbose === true }))
+      io.out(l);
+    for (const l of linkLines(links, `${factsRelOf(root)}/${repo}.verify.yaml`, {
+      verbose: o.verbose === true
+    }))
+      io.out(l);
+    const about = result.linkEvidence ? linkEvidenceAbout(repo, result.linkEvidence, result.join) : void 0;
+    if (about)
+      for (const l of linkEvidenceLines(about, `${factsRelOf(root)}/${repo}.verify.yaml`, {
+        verbose: o.verbose === true
+      }))
+        io.out(l);
+    const sharedAbout = result.shared ? sharedReport(result.shared, sharedMaps) : void 0;
+    if (sharedAbout)
+      for (const l of sharedLines(repo, sharedAbout, o.verbose === true))
+        io.out(l);
+    await writeLinksIntoReport(root, repo, links, result.join?.exposure, about, sharedAbout);
+    for (const l of lines)
+      io.out(l);
+    const map = await renderRepoMap(root, repo, io);
+    return {
+      written,
+      flows: flowPaths,
+      questions: raised.map((q) => q.id),
+      map: map ?? [],
+      changes: { ...diff, byKind },
+      links
+    };
+  } finally {
+    await lock.release();
+  }
+}
+function targetId(facts, repo, id) {
+  const f = facts.find((x) => x.id === id);
+  const q = f ? targetQuestionFor(f) : void 0;
+  return q ? questionId({ step: TARGETS_STEP, repo, ...q }) : void 0;
+}
+function joinLines(repo, join2, notes = [], o = {}) {
+  if (!join2)
+    return [...notes];
+  const out = [...notes];
+  const mine = join2.joins.filter((j) => j.call.repo === repo && j.call.repo !== j.entry.repo);
+  const into = join2.joins.filter((j) => j.entry.repo === repo && j.call.repo !== repo);
+  if (mine.length || into.length)
+    out.push(`Joined across repos: ${mine.length} of ${repo}'s calls to the entries that serve them, ${into.length} calls of other repos into ${repo}, each citing both ends.`);
+  const guessed = join2.joins.filter((j) => j.call.repo === repo && j.inferred);
+  if (guessed.length) {
+    const own = guessed.filter((j) => j.inferred.within === "repo").length;
+    const where = [
+      own ? `${own} in ${repo} itself` : "",
+      guessed.length - own ? `${guessed.length - own} in another repo${guessed.length - own === 1 ? "" : "s"}` : ""
+    ].filter(Boolean).join(", ");
+    out.push(`Joined by method and path, inferred: ${guessed.length} of ${repo}'s calls name no target the estate has, so each joined the one entry that serves it (${where}).`);
+    if (o.verbose)
+      for (const j of guessed) {
+        const what = j.method ? `${j.method} ${j.path}` : j.path;
+        const named = j.inferred.named ? ` (named ${j.inferred.named})` : "";
+        const there = j.entry.repo === repo ? "" : ` (${j.entry.repo})`;
+        out.push(`  ${j.call.at} ${what}${named} \u2192 ${j.entry.component}${there}`);
+      }
+  }
+  for (const m of join2.misses)
+    out.push(`Not joined: ${m.message} (${m.call.at}).`);
+  for (const x of join2.exposure ?? [])
+    out.push(`Exposure: ${x.message}.`);
+  for (const g of join2.gaps.slice(0, 10))
+    out.push(`Field gap: ${g.message}.`);
+  return out;
+}
+async function renderRepoMap(root, repo, io) {
+  const records = (await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root })).records;
+  const spec = await readRepoSpec(root, repo, { cacheRoot: root });
+  const ofRepo = records.some((r) => r.kind === "Component" && r.repo === repo);
+  if (!ofRepo && spec.flows.length === 0) {
+    io.err(`Nothing of ${repo} is in the catalog yet. Have your assistant read it (/atticus map), then run atticus verify ${repo} --write.`);
+    return void 0;
+  }
+  let trust;
+  const report = join(factsDirOf(root), `${repo}.verify.yaml`);
+  if (existsSync(report)) {
+    try {
+      trust = trustOf((0, import_yaml.parse)(await readFile(report, "utf8")));
+    } catch {
+      trust = void 0;
+    }
+  }
+  const open = (await listQuestions(root, { state: "open", repo })).questions;
+  const manifest = (await loadRepos(root).catch(() => [])).find((r) => r.id === repo);
+  const adopted = isAdopted(root);
+  const url = manifest?.url && manifest.url !== "." && !manifest.url.startsWith("./") ? manifest.url : void 0;
+  const codeLink = codeLinkerFor(url ? { url } : { dir: adopted ? "" : posix(relative(root, baseClonePath(root, repo))) });
+  const rel = `${mapRelOf(root)}/${repo}`;
+  const files = renderMap({
+    repo,
+    records,
+    flows: spec.flows,
+    ...trust ? { trust } : {},
+    // What a person says the repo is (ADR 0128), above the trust line.
+    ...manifest?.description ? {
+      about: {
+        text: manifest.description.text,
+        trust: manifest.description.trust,
+        ...manifest.description.by ? { by: manifest.description.by } : {}
+      }
+    } : {},
+    // What the repo is built on (ADR 0124 addendum A-framework): read from the facts, since no
+    // catalog record holds a framework.
+    ...builtOnOf(await factsOf(root, repo)),
+    questions: open.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })),
+    paths: { map: rel, questions: questionsRelOf(root), specs: specRelOf(root, repo) },
+    codeLink
+  });
+  const dir = join(mapDirOf(root), repo);
+  for (const old of await listFiles(dir))
+    if (!(old in files))
+      await rm(join(dir, ...old.split("/")), { force: true });
+  for (const [path, text] of Object.entries(files)) {
+    const full = join(dir, ...path.split("/"));
+    const now = await readFile(full, "utf8").catch(() => void 0);
+    if (now !== text)
+      await writeFileAtomic(full, text);
+  }
+  const paths = Object.keys(files).map((p) => `${rel}/${p}`);
+  io.out(`Map: ${rel}/map.md (${Object.keys(files).length} files; review them in the PR).`);
+  return paths;
+}
+async function factsOf(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return [];
+  const p = parseFacts(text);
+  return p.ok ? p.facts : [];
+}
+function builtOnOf(facts) {
+  const built = frameworkFacts(facts).map((f) => ({
+    name: f.name,
+    ...f.version ? { version: f.version } : {},
+    ...f.component ? { component: f.component } : {},
+    cite: { path: f.cite.file, line: f.cite.line, commit: f.commit }
+  }));
+  if (!built.length)
+    return {};
+  const gaps = frameworkGaps(facts).map((g) => ({ framework: g.framework, question: g.question }));
+  return { frameworks: { built, ...gaps.length ? { gaps } : {} } };
+}
+async function listFiles(dir) {
+  const out = [];
+  const walk = async (d, prefix) => {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries)
+      if (e.isDirectory())
+        await walk(join(d, e.name), `${prefix}${e.name}/`);
+      else
+        out.push(`${prefix}${e.name}`);
+  };
+  await walk(dir, "");
+  return out.sort();
+}
+async function mapRenderCommand(root, repo, o, io) {
+  const quiet = o.json ? { ...io, out: () => void 0 } : io;
+  const written = await renderRepoMap(root, repo, quiet);
+  if (!written)
+    return 2;
+  if (o.json)
+    io.out(JSON.stringify({ repo, files: written }, null, 2));
+  return 0;
+}
+export {
+  builtOnOf,
+  countByKind,
+  joinLines,
+  kindLine,
+  linkChanges,
+  linkLines,
+  mapRenderCommand,
+  projectFactsIntoCatalog,
+  sharedLines,
+  sharedReport,
+  writeFactsIntoCatalog
+};

package/dist/chunk-KQDZXGNR.js

@@ -0,0 +1,14 @@
+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 {
+  isCritic,
+  isHandoffStep
+} from "./chunk-4Q3NN7VF.js";
+import "./chunk-TV45EUGM.js";
+export {
+  isCritic,
+  isHandoffStep
+};