@maycombhq/atticus 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/{chunk-HE4ZQXZM.js → chunk-P76AW3PA.js}

@@ -4,30 +4,275 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
-  readReviewed
-} from "./chunk-B3O52AUQ.js";
+  repoFor
+} from "./chunk-7VNEDDCC.js";
 import {
-  lineRangeOf
-} from "./chunk-4GZXS6S2.js";
+  frameworkFacts,
+  insideRepo,
+  lineRangeOf,
+  parseReviewed
+} from "./chunk-MLAACAES.js";
 import {
+  changesSince,
+  createGit
+} from "./chunk-RA64IK43.js";
+import {
+  Conventions,
+  DEFAULT_CONVENTIONS,
+  QuestionDraft,
   citedFiles,
   external_exports,
   factsDirOf,
   factsRelOf,
+  isAdopted,
+  isSecretPath,
+  loadOrgPack,
+  orgPackDirOf,
+  parseCorrections,
   parseFacts,
-  require_dist
-} from "./chunk-577AJVRS.js";
+  parseFactsLines,
+  raiseQuestions,
+  require_dist,
+  serializeFacts
+} from "./chunk-U25OX22K.js";
 import {
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-MMB2OHUY.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/map-parts.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// packages/cli/dist/facts-files.js
 var import_yaml = __toESM(require_dist(), 1);
-import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+async function checkoutOf(root, repo, dir) {
+  return dir ?? (isAdopted(root) ? root : (await repoFor(root, repo))?.dir ?? void 0);
+}
+async function headOf(dir) {
+  try {
+    const r = await createGit({ timeoutMs: 3e4 })(["rev-parse", "HEAD"], dir);
+    return r.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function carryOf(dir, facts, commit, git) {
+  if (!commit)
+    return { carry: {}, missing: [] };
+  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))
+    return [];
+  try {
+    const doc = (0, import_yaml.parse)(await readFile(file, "utf8"));
+    return (doc?.exclude ?? []).map((e) => e.path).filter((p) => !!p);
+  } catch {
+    return [];
+  }
+}
+async function raiseReadQuestions(root, repo, lines, source, by) {
+  const drafts = [];
+  const problems = [];
+  for (const raw of lines) {
+    const line = JSON.stringify(raw);
+    const r2 = QuestionDraft.safeParse(raw);
+    if (!r2.success) {
+      problems.push({
+        line,
+        message: `not a question: ${r2.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`
+      });
+      continue;
+    }
+    const bad = r2.data.evidence.find((e) => {
+      const file = e.slice(0, e.lastIndexOf(":"));
+      const n = Number(e.slice(e.lastIndexOf(":") + 1));
+      if (!insideRepo(file) || isSecretPath(file))
+        return true;
+      const text = source.read(file);
+      return text === void 0 || n < 1 || n > text.split(/\r?\n/).length;
+    });
+    if (bad) {
+      problems.push({ line, message: `its evidence ${bad} is no line of the repo` });
+      continue;
+    }
+    drafts.push(r2.data);
+  }
+  if (!drafts.length)
+    return { raised: [], known: [], problems };
+  const r = await raiseQuestions(root, drafts, {
+    step: "map",
+    repo,
+    command: by.command,
+    rerun: `atticus map ${repo}`,
+    ...by.run ? { run: by.run } : {},
+    at: by.at
+  });
+  return { raised: r.raised, known: [...r.known, ...r.reused], problems };
+}
+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 rejectedFile = join(dir, `${repo}.rejected.jsonl`);
+  const lines = [
+    ...report.rejected.map((r) => JSON.stringify({ code: r.code, message: r.message, fact: r.fact })),
+    ...questionProblems.map((q) => JSON.stringify({ code: "bad-question", message: q.message, question: JSON.parse(q.line) })),
+    ...badLines.map((b) => JSON.stringify({ code: "schema", message: b.message, raw: b.raw })),
+    ...reviewedProblems.map((r) => JSON.stringify({ code: "bad-reviewed", message: r.message, reviewed: r.raw }))
+  ];
+  if (lines.length)
+    await writeFile(rejectedFile, lines.join("\n") + "\n", "utf8");
+  else
+    await rm(rejectedFile, { force: true });
+  const summary = {
+    repo,
+    ...commit ? { commit } : {},
+    accepted: report.accepted.length,
+    rejected: report.rejected.length,
+    redacted: report.redacted,
+    ...report.quotesDropped ? { quotesDropped: report.quotesDropped } : {},
+    coverage: {
+      ratio: report.coverage.ratio,
+      read: report.coverage.read.length,
+      ...report.coverage.reviewed.length ? { reviewed: report.coverage.reviewed.length } : {},
+      unknown: report.coverage.unknown,
+      excluded: report.coverage.excluded
+    },
+    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.
+    ...report.corrections.applied.length || report.corrections.stale.length ? {
+      corrections: {
+        applied: report.corrections.applied,
+        stale: report.corrections.stale.map((s) => ({
+          fact: s.correction.fact,
+          why: s.why,
+          message: s.message
+        }))
+      }
+    } : {}
+  };
+  if (report.carried.length) {
+    const by = /* @__PURE__ */ new Map();
+    for (const c of report.carried)
+      by.set(c.from, [...by.get(c.from) ?? [], c.id]);
+    summary.carried = [...by.entries()].sort((a, b) => a[0] < b[0] ? -1 : 1).map(([from, facts]) => ({ from, facts: facts.sort() }));
+  }
+  if (report.entriesNoFlowFollows.length)
+    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);
+  if (fws.length)
+    summary.frameworks = fws.map((f) => ({
+      name: f.name,
+      ...f.version ? { version: f.version } : {},
+      cite: `${f.cite.file}:${f.cite.line}`,
+      ...f.component ? { component: f.component } : {}
+    }));
+  if (report.frameworkGaps.length)
+    summary.frameworkGaps = report.frameworkGaps;
+  await writeFile(join(dir, `${repo}.verify.yaml`), (0, import_yaml.stringify)(summary), "utf8");
+  return summary;
+}
+async function readCorrections(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.corrections.jsonl`), "utf8").catch(() => void 0);
+  return text === void 0 ? { corrections: [], bad: [] } : parseCorrections(text);
+}
+async function readReviewed(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.reviewed.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { entries: [], bad: [] };
+  const r = parseReviewed(text);
+  return {
+    entries: r.entries,
+    bad: r.bad.map((b) => ({ line: b.line, raw: b.raw, message: b.message }))
+  };
+}
+function reviewedProblemsOf(bad, report) {
+  return [
+    ...bad,
+    ...report.reviewedProblems.map((p) => ({
+      ...p.line !== void 0 ? { line: p.line } : {},
+      raw: { path: p.path, why: p.why },
+      message: p.message
+    }))
+  ].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
+}
+
+// packages/cli/dist/map-parts.js
 var ReadStamp = external_exports.strictObject({ at: external_exports.string().min(1), commit: external_exports.string().min(1) });
 var Part = external_exports.strictObject({
   part: external_exports.number().int().positive(),
@@ -57,6 +302,28 @@ var Reported = external_exports.strictObject({
   /** Who reported it (--by), when given. */
   by: external_exports.string().min(1).optional()
 });
+var RulesRecord = external_exports.strictObject({
+  hash: external_exports.string().min(1),
+  sets: external_exports.array(external_exports.string().min(1))
+});
+var TopUpSession = external_exports.strictObject({
+  paths: external_exports.array(external_exports.string().min(1)).min(1),
+  sets: external_exports.array(external_exports.string().min(1)).min(1),
+  files: external_exports.number().int().nonnegative(),
+  tokens: external_exports.number().int().nonnegative(),
+  /** When `atticus map <repo> --rules` last gave it to a reader. */
+  given: external_exports.string().min(1).optional(),
+  /** When a verify that passed after it was given found it done. */
+  done: ReadStamp.optional()
+});
+var TopUp = external_exports.strictObject({
+  commit: external_exports.string().min(1),
+  hash: external_exports.string().min(1),
+  sets: external_exports.array(external_exports.string().min(1)),
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  sessions: external_exports.array(TopUpSession)
+});
 var ReadPlanFile = external_exports.strictObject({
   /** 2 since ADR 0141 (a v1 file reads as v2: `migrateReadPlan`). */
   schemaVersion: external_exports.literal(2),
@@ -82,7 +349,11 @@ var ReadPlanFile = external_exports.strictObject({
   /** ADR 0141: when `atticus verify` first found the whole plan in the facts. */
   read: ReadStamp.extend({ sessions: external_exports.number().int().positive() }).optional(),
   /** ADR 0141: what the reader reported the read took (`atticus map <repo> --spent`). */
-  reported: external_exports.array(Reported).optional()
+  reported: external_exports.array(Reported).optional(),
+  /** ADR 0167: the reading rules the read was given; none when read before they were recorded. */
+  rules: RulesRecord.optional(),
+  /** ADR 0167: a top-up for the rule sets the read lacked, under way. */
+  topUp: TopUp.optional()
 });
 function migrateReadPlan(raw) {
   const v2 = ReadPlanFile.safeParse(raw);
@@ -94,7 +365,7 @@ function migrateReadPlan(raw) {
   return { ...v1.data, schemaVersion: 2 };
 }
 var readPlanRelOf = (root, repo) => `${factsRelOf(root)}/${repo}.read-plan.yaml`;
-var readPlanPath = (root, repo) => join(factsDirOf(root), `${repo}.read-plan.yaml`);
+var readPlanPath = (root, repo) => join2(factsDirOf(root), `${repo}.read-plan.yaml`);
 function unitOf(glob) {
   const range = lineRangeOf(glob);
   if (range)
@@ -116,9 +387,18 @@ function folderOf(path) {
   return { dir: path.slice(0, star).replace(/\/$/, ""), deep: true };
 }
 var under = (dir, of) => of === "" || dir === of || dir.startsWith(`${of}/`);
+function globHolds(glob, file) {
+  const u = unitOf(glob);
+  if (u.range)
+    return u.range.file === file;
+  if (!/[*]/.test(glob))
+    return glob === file;
+  const dir = file.replace(/\/?[^/]*$/, "");
+  return u.deep ? under(dir, u.dir) : dir === u.dir;
+}
 var HEADER = "# The parts this repo is read in (ADR 0124 addendum A-ledger), as atticus map --estimate planned them,\n# and what the read cost (ADR 0141): tokens are estimates, reported numbers are the reader's word.\n# Which part is next is read back from the facts; atticus next says it. Atticus writes this file.\n";
 async function saveReadPlan(root, plan) {
-  await writeFileAtomic(readPlanPath(root, plan.repo), `${HEADER}${(0, import_yaml.stringify)(ReadPlanFile.parse(plan), { lineWidth: 0 })}`);
+  await writeFileAtomic(readPlanPath(root, plan.repo), `${HEADER}${(0, import_yaml2.stringify)(ReadPlanFile.parse(plan), { lineWidth: 0 })}`);
 }
 async function writeReadPlan(root, repo, o) {
   const plan = {
@@ -134,18 +414,19 @@ async function writeReadPlan(root, repo, o) {
       files: p.files,
       tokens: p.tokens
     })),
-    ...o.reported?.length ? { reported: [...o.reported] } : {}
+    ...o.reported?.length ? { reported: [...o.reported] } : {},
+    ...o.rules ? { rules: { hash: o.rules.hash, sets: [...o.rules.sets] } } : {}
   };
   await saveReadPlan(root, plan);
   return plan;
 }
 var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 async function loadReadPlan(root, repo) {
-  const text = await readFile(readPlanPath(root, repo), "utf8").catch(() => void 0);
+  const text = await readFile2(readPlanPath(root, repo), "utf8").catch(() => void 0);
   if (text === void 0)
     return void 0;
   try {
-    return migrateReadPlan((0, import_yaml.parse)(text));
+    return migrateReadPlan((0, import_yaml2.parse)(text));
   } catch {
     return void 0;
   }
@@ -169,7 +450,7 @@ async function coveredOf(root, repo) {
   const reviewed = /* @__PURE__ */ new Set();
   const lines = [];
   const ranges = /* @__PURE__ */ new Set();
-  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  const text = await readFile2(join2(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
   if (text !== void 0) {
     const parsed = parseFacts(text);
     const facts = parsed.ok ? parsed.facts : [];
@@ -378,9 +659,22 @@ async function mapSpent(root, repo, o, io) {
 }
 
 export {
+  checkoutOf,
+  headOf,
+  carryOf,
+  conventionsAt,
+  excludesOf,
+  raiseReadQuestions,
+  estateComponentsOf,
+  slipNoteLines,
+  writeVerifyFiles,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf,
   ReadPlanFile,
   migrateReadPlan,
   readPlanRelOf,
+  globHolds,
   saveReadPlan,
   writeReadPlan,
   loadReadPlan,