@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/{chunk-CR3MTH32.js → chunk-Q46QDDMF.js}

@@ -5,27 +5,31 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   repoFor
-} from "./chunk-O3WI5KWW.js";
+} from "./chunk-TGVVUKTG.js";
 import {
   frameworkFacts,
   insideRepo,
   parseReviewed
-} from "./chunk-PAMPPUR6.js";
+} from "./chunk-JYMIB5XY.js";
 import {
   changesSince,
   createGit
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-XOL3GFW2.js";
 import {
+  Conventions,
+  DEFAULT_CONVENTIONS,
   QuestionDraft,
   factsDirOf,
   isAdopted,
   isSecretPath,
+  loadOrgPack,
   orgPackDirOf,
   parseCorrections,
+  parseFactsLines,
   raiseQuestions,
   require_dist,
   serializeFacts
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-PAINMSID.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -52,6 +56,17 @@ async function carryOf(dir, facts, commit, git) {
   const r = await changesSince(dir, facts.map((f) => f.commit), commit, git);
   return { carry: r.changes, missing: r.missing };
 }
+async function conventionsAt(root) {
+  const file = join(orgPackDirOf(root), "conventions.yaml");
+  if (!existsSync(file))
+    return DEFAULT_CONVENTIONS;
+  try {
+    const r = Conventions.safeParse((0, import_yaml.parse)(await readFile(file, "utf8")));
+    return r.success ? r.data : DEFAULT_CONVENTIONS;
+  } catch {
+    return DEFAULT_CONVENTIONS;
+  }
+}
 async function excludesOf(root, repo) {
   const file = join(orgPackDirOf(root), "scan", `${repo}.yaml`);
   if (!existsSync(file))
@@ -102,10 +117,43 @@ async function raiseReadQuestions(root, repo, lines, source, by) {
   });
   return { raised: r.raised, known: [...r.known, ...r.reused], problems };
 }
-async function writeVerifyFiles(root, repo, report, commit, questionProblems = [], badLines = [], reviewedProblems = []) {
+async function estateComponentsOf(root) {
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const repos = (op?.profiles ?? []).flatMap((p) => p.repos?.repos ?? []);
+  if (!repos.length)
+    return void 0;
+  const components = repos.flatMap((r) => [
+    r.id,
+    ...r.component ? [r.component] : [],
+    ...(r.modules ?? []).map((m) => m.component)
+  ]);
+  const repoComponents = {};
+  for (const r of repos) {
+    const text = await readFile(join(factsDirOf(root), `${r.id}.jsonl`), "utf8").catch(() => void 0);
+    if (text === void 0)
+      continue;
+    const named = parseFactsLines(text).facts.flatMap((f) => f.component ? [f.component] : []);
+    repoComponents[r.id] = [
+      .../* @__PURE__ */ new Set([r.component ?? r.id, ...(r.modules ?? []).map((m) => m.component), ...named])
+    ].sort();
+  }
+  return { components: [...new Set(components)].sort(), repoComponents };
+}
+var SKIPPED_LISTED = 100;
+function slipNoteLines(slips, verifyYaml, shown = 5) {
+  if (!slips.length)
+    return [];
+  return [
+    `${slips.length} ${slips.length === 1 ? "slip" : "slips"} of form fixed in the facts (a note, not a rejection; under slips in ${verifyYaml}):`,
+    ...slips.slice(0, shown).map((x) => `  ${x.message}`),
+    ...slips.length > shown ? [`  ... and ${slips.length - shown} more (slips in ${verifyYaml})`] : []
+  ];
+}
+async function writeVerifyFiles(root, repo, report, commit, questionProblems = [], badLines = [], reviewedProblems = [], slips = []) {
   const dir = factsDirOf(root);
   await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, `${repo}.jsonl`), serializeFacts(report.accepted), "utf8");
+  const otherCommit = report.rejected.filter((r) => r.code === "wrong-commit").map((r) => r.fact);
+  await writeFile(join(dir, `${repo}.jsonl`), serializeFacts([...report.accepted, ...otherCommit]), "utf8");
   const rejectedFile = join(dir, `${repo}.rejected.jsonl`);
   const lines = [
     ...report.rejected.map((r) => JSON.stringify({ code: r.code, message: r.message, fact: r.fact })),
@@ -129,7 +177,8 @@ async function writeVerifyFiles(root, repo, report, commit, questionProblems = [
       read: report.coverage.read.length,
       ...report.coverage.reviewed.length ? { reviewed: report.coverage.reviewed.length } : {},
       unknown: report.coverage.unknown,
-      excluded: report.coverage.excluded
+      excluded: report.coverage.excluded,
+      ...report.coverage.notReached.length ? { notReached: report.coverage.notReached } : {}
     },
     rejections: report.rejected.map((r) => ({ id: r.fact.id, code: r.code, message: r.message })),
     // ADR 0124 addendum D-app: a person's corrections, said only when there are some.
@@ -154,6 +203,24 @@ async function writeVerifyFiles(root, repo, report, commit, questionProblems = [
     summary.entriesNoFlowFollows = report.entriesNoFlowFollows;
   if (report.reviewed.length)
     summary.reviewed = report.reviewed;
+  if (report.reviewedDropped.length)
+    summary.reviewedDropped = report.reviewedDropped;
+  if (report.methodUnseen.length) {
+    summary.methodUnseenCount = report.methodUnseen.length;
+    summary.methodUnseen = report.methodUnseen;
+  }
+  if (report.skipped.length) {
+    summary.skippedCount = report.skipped.length;
+    summary.skipped = report.skipped.slice(0, SKIPPED_LISTED);
+  }
+  if (report.reviewedHolds.length)
+    summary.reviewedHolds = report.reviewedHolds;
+  if (report.specOpsUncovered.length) {
+    summary.specOpsUncoveredCount = report.specOpsUncovered.length;
+    summary.specOpsUncovered = report.specOpsUncovered.slice(0, SKIPPED_LISTED);
+  }
+  if (slips.length)
+    summary.slips = [...slips];
   if (report.authUncited.length)
     summary.authUncited = report.authUncited;
   const fws = frameworkFacts(report.accepted);
@@ -198,8 +265,11 @@ export {
   checkoutOf,
   headOf,
   carryOf,
+  conventionsAt,
   excludesOf,
   raiseReadQuestions,
+  estateComponentsOf,
+  slipNoteLines,
   writeVerifyFiles,
   readCorrections,
   readReviewed,

package/dist/chunk-QBNWF5ZU.js

@@ -0,0 +1,19 @@
+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-TV45EUGM.js";
+
+// packages/cli/dist/node-version.js
+var NODE_NEEDED = "22.13";
+function nodeTooOld(version) {
+  const [major = 0, minor = 0] = version.split(".").map(Number);
+  return major < 22 || major === 22 && minor < 13;
+}
+var nodeTooOldMessage = (version) => `Atticus needs Node.js ${NODE_NEEDED} or later; this is Node ${version}. Install a newer Node (from your company's software portal, or nodejs.org), then run atticus again.`;
+export {
+  NODE_NEEDED,
+  nodeTooOld,
+  nodeTooOldMessage
+};

package/dist/chunk-QE527XRY.js

@@ -0,0 +1,342 @@
+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 {
+  FRESH_STATES,
+  estateFreshness
+} from "./chunk-LWDNKE4X.js";
+import "./chunk-4FOAYLI4.js";
+import "./chunk-GX74YWR7.js";
+import "./chunk-G6IQYM25.js";
+import "./chunk-LPV6T362.js";
+import "./chunk-GIFMBCTW.js";
+import {
+  loadReadPlan,
+  readCostOf
+} from "./chunk-MD7KUEJ3.js";
+import "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
+import "./chunk-TQ4TG57V.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  componentRenames,
+  estateFacts,
+  isPrototypeRepo,
+  joinReposOf,
+  outsideSystems
+} from "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-VUVGX5L2.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import {
+  HOSTS_STEP,
+  LINK_QUESTION_STEPS,
+  TARGETS_STEP_ID,
+  TERM_STEP,
+  TOPICS_STEP_ID,
+  factsDirOf,
+  factsFileOf,
+  helperOn,
+  isGuessedJoin,
+  joinConventions,
+  joinFacts,
+  joinGuessesOf,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  parseFacts,
+  require_dist
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/doctor-counts.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var QUESTION_STEPS = /* @__PURE__ */ new Set([
+  "map",
+  "scan-survey",
+  "scan-verify",
+  "spec-draft",
+  "spec-check",
+  HOSTS_STEP,
+  TARGETS_STEP_ID,
+  TOPICS_STEP_ID,
+  TERM_STEP,
+  ...LINK_QUESTION_STEPS,
+  // The planner's, a change's stages (planner/src/stages) and its gaps; the knowledge conflicts.
+  "change-feature",
+  "change-architecture",
+  "change-stories",
+  "change-small",
+  "context-gap",
+  "knowledge-conflict"
+]);
+var OTHER_STEP = "other";
+var bump = (m, k, n = 1) => {
+  m[k] = (m[k] ?? 0) + n;
+};
+var sorted = (m) => Object.fromEntries(Object.entries(m).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+var LISTENS = /^(subscribe|consume|listen)$/i;
+async function doctorCounts(root, o = {}) {
+  let problems = 0;
+  const qs = await listQuestions(root, { state: "open" }).catch(() => {
+    problems++;
+    return { questions: [], problems: [] };
+  });
+  problems += qs.problems.length;
+  const byKind = {};
+  for (const q of qs.questions)
+    bump(byKind, QUESTION_STEPS.has(q.askedBy.step) ? q.askedBy.step : OTHER_STEP);
+  const targets = {
+    open: 0,
+    calls: 0,
+    alone: 0,
+    groups: 0,
+    inGroups: 0,
+    bySize: {}
+  };
+  for (const q of qs.questions) {
+    if (q.askedBy.step !== TARGETS_STEP_ID)
+      continue;
+    const n = Math.max(1, new Set(q.evidence).size);
+    targets.open++;
+    targets.calls += n;
+    if (n === 1)
+      targets.alone++;
+    else {
+      targets.groups++;
+      targets.inGroups += n;
+    }
+    bump(targets.bySize, n === 1 ? "1" : n <= 4 ? "2-4" : n <= 9 ? "5-9" : "10+");
+  }
+  const fresh = await estateFreshness(root, o.git ? { git: o.git } : {}).catch(() => {
+    problems++;
+    return { repos: [], problems: [] };
+  });
+  problems += fresh.problems.length;
+  const byState = Object.fromEntries(FRESH_STATES.map((s) => [s, 0]));
+  for (const r of fresh.repos)
+    byState[r.state]++;
+  const total = fresh.repos.length;
+  const facts = { accepted: 0, rejected: 0, notVerified: 0, filesNotRead: 0 };
+  const dir = factsDirOf(root);
+  const names = (await readdir(dir).catch(() => [])).sort();
+  const read = async (n) => readFile(join(dir, n), "utf8").catch(() => void 0);
+  for (const n of names) {
+    const of = factsFileOf(n);
+    if (!of)
+      continue;
+    const text = await read(n);
+    if (text === void 0) {
+      problems++;
+      continue;
+    }
+    if (of.facts) {
+      const p = parseFacts(text);
+      if (!p.ok) {
+        problems++;
+        continue;
+      }
+      for (const f of p.facts)
+        if (f.verified === "none")
+          facts.notVerified++;
+        else
+          facts.accepted++;
+    } else if (n.endsWith(".rejected.jsonl"))
+      facts.rejected += text.split("\n").filter((l) => l.trim()).length;
+    else if (n.endsWith(".verify.yaml"))
+      try {
+        const v = (0, import_yaml.parse)(text);
+        const u = v?.coverage?.unknown;
+        facts.filesNotRead += Array.isArray(u) ? u.length : typeof u === "number" ? u : 0;
+      } catch {
+        problems++;
+      }
+  }
+  const tokens = { reported: 0, reports: 0, repos: 0 };
+  for (const r of fresh.repos) {
+    const plan = await Promise.resolve().then(() => loadReadPlan(root, r.repo)).catch(() => {
+      problems++;
+      return void 0;
+    });
+    const cost = plan ? readCostOf(plan).reported : void 0;
+    if (!cost)
+      continue;
+    tokens.repos++;
+    tokens.reports += cost.reports;
+    tokens.reported += cost.tokens ?? 0;
+  }
+  const links = {
+    verified: 0,
+    inferred: 0,
+    inferredBy: {},
+    asked: 0,
+    askedBy: {},
+    outside: 0,
+    unresolved: 0,
+    unresolvedBy: {}
+  };
+  let op;
+  try {
+    op = await loadOrgPack(orgPackDirOf(root));
+  } catch {
+    if (total)
+      problems++;
+  }
+  if (op)
+    try {
+      Object.assign(links, await linkCounts(root, op));
+    } catch {
+      problems++;
+    }
+  return {
+    questions: {
+      open: qs.questions.length,
+      byKind: sorted(byKind),
+      targets: { ...targets, bySize: bySizeOrder(targets.bySize) }
+    },
+    links,
+    repos: {
+      total,
+      read: total - byState["not-read"],
+      unread: byState["not-read"],
+      stale: byState.stale,
+      byState
+    },
+    facts,
+    tokens,
+    problems
+  };
+}
+async function linkCounts(root, op) {
+  const estate = await estateFacts(root, op, "");
+  const repos = estate.repos.filter((x) => !isPrototypeRepo(op, x.repo));
+  const join2 = joinFacts({
+    repos: joinReposOf(op, repos, componentRenames(repos, op)),
+    ...Object.keys(estate.targets).length ? { targets: estate.targets } : {},
+    ...Object.keys(estate.pairs).length ? { pairs: estate.pairs } : {},
+    ...Object.keys(estate.aiTargets).length ? { aiTargets: estate.aiTargets } : {},
+    outside: outsideSystems(op),
+    ...joinConventions(op),
+    walkGateways: helperOn("gateway-walk"),
+    // Why each call was left, in the join's own words, for unresolvedBy.
+    explain: true
+  });
+  const factOf = /* @__PURE__ */ new Map();
+  for (const r of repos)
+    for (const f of r.facts)
+      factOf.set(`${r.repo}\0${f.id}`, f);
+  const key = (e) => `${e.repo}\0${e.fact}`;
+  const declared = (e) => factOf.get(key(e))?.conf === "declared";
+  const out = {
+    verified: 0,
+    inferred: 0,
+    inferredBy: {},
+    asked: 0,
+    askedBy: {},
+    outside: 0,
+    unresolved: 0,
+    unresolvedBy: {}
+  };
+  const answered = /* @__PURE__ */ new Set();
+  const why = new Map((join2.left ?? []).map((l) => [key(l.call), l.reason]));
+  for (const j of join2.joins) {
+    answered.add(key(j.call));
+    if (!isGuessedJoin(j) && declared(j.call) && declared(j.entry))
+      out.verified++;
+    else {
+      out.inferred++;
+      const flags = joinGuessesOf(j);
+      if (flags.length)
+        for (const f of flags)
+          bump(out.inferredBy, f);
+      else
+        bump(out.inferredBy, "one-end-inferred");
+    }
+  }
+  for (const a of join2.asks) {
+    if (answered.has(key(a.call)))
+      continue;
+    answered.add(key(a.call));
+    out.asked++;
+    bump(out.askedBy, a.reason);
+  }
+  for (const x of join2.outside ?? []) {
+    if (answered.has(key(x.call)))
+      continue;
+    answered.add(key(x.call));
+    out.outside++;
+  }
+  for (const r of repos)
+    for (const f of r.facts) {
+      if (f.kind !== "call" || LISTENS.test(f.method ?? ""))
+        continue;
+      const k = `${r.repo}\0${f.id}`;
+      if (answered.has(k))
+        continue;
+      out.unresolved++;
+      bump(out.unresolvedBy, why.get(k) ?? "other");
+    }
+  out.inferredBy = sorted(out.inferredBy);
+  out.askedBy = sorted(out.askedBy);
+  out.unresolvedBy = sorted(out.unresolvedBy);
+  return out;
+}
+var kv = (m) => Object.entries(m).filter(([, n]) => n > 0).map(([k, n]) => `${k} ${n}`).join(", ");
+var SIZES = ["1", "2-4", "5-9", "10+"];
+var bySizeOrder = (m) => Object.fromEntries(SIZES.filter((k) => m[k]).map((k) => [k, m[k]]));
+function countsLines(c) {
+  const by = kv(c.questions.byKind);
+  const inferred = kv(c.links.inferredBy);
+  const states = kv(c.repos.byState);
+  const askedBy = kv(c.links.askedBy);
+  const unresolvedBy = kv(c.links.unresolvedBy);
+  const t = c.questions.targets;
+  const sizes = kv(t.bySize);
+  return [
+    `Questions: ${c.questions.open} open${by ? ` (${by})` : ""}`,
+    ...t.open ? [
+      `Target questions: ${t.open} open, covering ${t.calls} calls: ${t.alone} asked alone, ${t.groups} groups holding ${t.inGroups}${sizes ? ` (by calls each: ${sizes})` : ""}`
+    ] : [],
+    `Links: ${c.links.verified} verified, ${c.links.inferred} inferred${inferred ? ` (${inferred})` : ""}, ${c.links.asked} asked, ${c.links.outside} to outside systems, ${c.links.unresolved} unresolved calls`,
+    ...askedBy || unresolvedBy ? [
+      `Calls ${[askedBy ? `asked by why: ${askedBy}` : "", unresolvedBy ? `unresolved by why: ${unresolvedBy}` : ""].filter(Boolean).join("; ")}`
+    ] : [],
+    `Repos: ${c.repos.total} in all, ${c.repos.read} read, ${c.repos.unread} unread, ${c.repos.stale} stale${states ? ` (${states})` : ""}`,
+    `Facts: ${c.facts.accepted} accepted, ${c.facts.rejected} rejected, ${c.facts.notVerified} not verified; ${c.facts.filesNotRead} source files not read`,
+    `Tokens reported: ${c.tokens.reported} tokens over ${c.tokens.reports} reports for ${c.tokens.repos} repos`,
+    "Counts and flags only: nothing here names a repo, system, host or file, so it is safe to paste."
+  ];
+}
+async function doctorCountsCommand(root, o, io, deps = {}) {
+  const { problems, ...c } = await doctorCounts(root, deps);
+  if (o.json)
+    io.out(JSON.stringify({ ...c, problems }, null, 2));
+  else {
+    for (const l of countsLines(c))
+      io.out(l);
+    if (problems)
+      io.out(`${problems} file${problems === 1 ? "" : "s"} didn't read; atticus doctor and atticus estate fresh say which.`);
+  }
+  return 0;
+}
+export {
+  OTHER_STEP,
+  QUESTION_STEPS,
+  countsLines,
+  doctorCounts,
+  doctorCountsCommand
+};