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

package/dist/chunk-ASKDCMW5.js

@@ -0,0 +1,275 @@
+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 {
+  repoFor
+} from "./chunk-LDIARP6F.js";
+import {
+  frameworkFacts,
+  insideRepo,
+  parseReviewed
+} from "./chunk-XPWSNKF3.js";
+import {
+  changesSince,
+  createGit
+} from "./chunk-XZJE6WIT.js";
+import {
+  Conventions,
+  DEFAULT_CONVENTIONS,
+  QuestionDraft,
+  factsDirOf,
+  isAdopted,
+  isSecretPath,
+  loadOrgPack,
+  orgPackDirOf,
+  parseCorrections,
+  parseFactsLines,
+  raiseQuestions,
+  require_dist,
+  serializeFacts
+} from "./chunk-JMOLB347.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/facts-files.js
+var import_yaml = __toESM(require_dist(), 1);
+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));
+}
+
+export {
+  checkoutOf,
+  headOf,
+  carryOf,
+  conventionsAt,
+  excludesOf,
+  raiseReadQuestions,
+  estateComponentsOf,
+  slipNoteLines,
+  writeVerifyFiles,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf
+};

package/dist/chunk-ATNG5VOZ.js

@@ -0,0 +1,122 @@
+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 {
+  estateRepos,
+  joinReposOf,
+  outsideSystems
+} from "./chunk-IILZ7J3L.js";
+import {
+  factIdPart,
+  factsDirOf,
+  joinConventions,
+  joinFacts,
+  loadOrgPack,
+  orgPackDirOf,
+  parseFacts
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/onboarding-queue.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var reasonOf = (r) => r.started ? "started" : r.callers?.length ? "called" : r.gateway ? "gateway" : r.places ? "places" : "next";
+function queueOrder(a, b) {
+  const rank = (r) => ["started", "called", "gateway", "places", "next"].indexOf(reasonOf(r));
+  return rank(a) - rank(b) || (b.callers?.length ?? 0) - (a.callers?.length ?? 0) || Number(!!b.gateway) - Number(!!a.gateway) || a.index - b.index;
+}
+function queueWhy(r) {
+  const callers = r.callers ?? [];
+  const named = callers.length > 3 ? `${callers.slice(0, 3).join(", ")} and ${callers.length - 3} more` : callers.join(", ");
+  switch (reasonOf(r)) {
+    case "started":
+      return "Its read is under way: finish it first.";
+    case "called":
+      return `${callers.length} read ${callers.length === 1 ? "repo calls" : "repos call"} it (${named})${r.gateway ? ", and it is a gateway" : ""}: read it next and ${callers.length === 1 ? "that link lands" : "those links land"}.`;
+    case "gateway":
+      return "It is a gateway (its manifest type): the calls through it join once it is read, so it goes before its callers.";
+    case "places":
+      return "It is a deploy or config repo (its manifest type): its Routes and values say where other repos are reached, so their links land once it is read.";
+    default:
+      return "Nothing read yet calls it: in the manifests' order.";
+  }
+}
+var firstLine = (e) => String(e?.message ?? e).split("\n")[0];
+function callersOf(op, read, waiting) {
+  const out = /* @__PURE__ */ new Map();
+  if (!read.length || !waiting.length)
+    return /* @__PURE__ */ new Map();
+  const manifests = estateRepos(op);
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const id of waiting) {
+    const m = manifests.find((r) => r.id === id);
+    byTarget.set(factIdPart(id), id);
+    if (m?.component)
+      byTarget.set(factIdPart(m.component), id);
+    for (const mod of m?.modules ?? [])
+      byTarget.set(factIdPart(mod.component), id);
+  }
+  const repos = joinReposOf(op, [
+    ...read,
+    ...waiting.filter((id) => !read.some((r) => r.repo === id)).map((repo) => ({ repo, facts: [] }))
+  ]);
+  const join2 = joinFacts({ repos, outside: outsideSystems(op), ...joinConventions(op) });
+  for (const m of join2.misses) {
+    const to = byTarget.get(factIdPart(m.target));
+    if (!to || to === m.call.repo)
+      continue;
+    out.set(to, (out.get(to) ?? /* @__PURE__ */ new Set()).add(m.call.repo));
+  }
+  return new Map([...out].map(([k, v]) => [k, [...v].sort()]));
+}
+async function onboardingQueue(root, waiting) {
+  const problems = [];
+  let op;
+  try {
+    op = await loadOrgPack(orgPackDirOf(root));
+  } catch (e) {
+    problems.push({ file: "org-pack", message: firstLine(e) });
+  }
+  const manifests = op ? estateRepos(op) : [];
+  const ids = waiting.map((w) => w.repo);
+  let callers = /* @__PURE__ */ new Map();
+  if (op) {
+    const read = [];
+    for (const m of manifests) {
+      const text = await readFile(join(factsDirOf(root), `${m.id}.jsonl`), "utf8").catch(() => void 0);
+      if (!text?.trim())
+        continue;
+      const p = parseFacts(text);
+      if (p.ok)
+        read.push({ repo: m.id, facts: p.facts });
+    }
+    try {
+      callers = callersOf(op, read, ids);
+    } catch (e) {
+      problems.push({
+        file: "facts",
+        message: `the join couldn't rank the queue: ${firstLine(e)}`
+      });
+    }
+  }
+  const queue = waiting.map((w, index) => {
+    const m = manifests.find((r) => r.id === w.repo);
+    const by = callers.get(w.repo) ?? [];
+    return {
+      repo: w.repo,
+      index,
+      ...w.started ? { started: true } : {},
+      ...m && /^gateway(-|$)/.test(m.type) ? { gateway: true } : {},
+      ...m && /^(deploy|config)(-|$)/.test(m.type) ? { places: true } : {},
+      ...by.length ? { callers: by } : {}
+    };
+  }).sort(queueOrder);
+  return { queue, problems };
+}
+
+export {
+  reasonOf,
+  queueWhy,
+  onboardingQueue
+};

package/dist/chunk-B3QOYE74.js

@@ -0,0 +1,58 @@
+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 {
+  excludesOf
+} from "./chunk-ASKDCMW5.js";
+import {
+  dirSource,
+  houseImportsUntaught,
+  readRulesOf
+} from "./chunk-XPWSNKF3.js";
+import {
+  globToRegExp
+} from "./chunk-FMRMTI7W.js";
+import {
+  conventionsOf,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/house-imports.js
+async function houseUntaughtOf(root, repo, o) {
+  const op = o.op ?? await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const conventions = conventionsOf(op);
+  if (!conventions.housePrefixes.length)
+    return [];
+  const exclude = o.exclude ?? await excludesOf(root, repo);
+  return houseImportsUntaught(o.source ?? dirSource(o.dir), {
+    prefixes: conventions.housePrefixes,
+    taught: (op?.frameworks ?? []).flatMap((m) => m.packages),
+    rules: readRulesOf(conventions),
+    exclude: exclude.map(globToRegExp)
+  });
+}
+function houseUntaughtLines(repo, found) {
+  if (!found.length)
+    return [];
+  const one = found.length === 1;
+  return [
+    `Teach first: ${repo} imports ${one ? "a house package" : `${found.length} house packages`} no framework taught to Atticus covers (the org pack's housePrefixes). Read without ${one ? "it" : "them"}, ${one ? "its" : "their"} annotations and wrapper calls are ordinary code to the reader; teach ${one ? "it" : "each"} before the first read, then run this again:`,
+    ...found.map((h) => `  - ${h.package} (${h.files} ${h.files === 1 ? "file" : "files"}, first at ${h.first}): ${h.command}`)
+  ];
+}
+function houseUntaughtWords(repo, found) {
+  if (!found.length)
+    return "";
+  const shown = found.slice(0, 3).map((h) => h.package);
+  const more = found.length > shown.length ? ` and ${found.length - shown.length} more` : "";
+  return ` Teach first: ${repo} imports ${shown.join(", ")}${more}, ${found.length === 1 ? "a house package" : "house packages"} no taught framework covers; run ${found[0].command}${found.length > 1 ? " (one per package; atticus map " + repo + " --estimate lists them)" : ""} before reading it.`;
+}
+
+export {
+  houseUntaughtOf,
+  houseUntaughtLines,
+  houseUntaughtWords
+};

package/dist/chunk-B3UHYXHU.js

@@ -0,0 +1,41 @@
+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 {
+  MIGRATIONS,
+  STAMP_FILE,
+  readStamp,
+  upgradeCheck,
+  upgradeCommand
+} from "./chunk-LUPW4WLK.js";
+import "./chunk-NG5R2WIY.js";
+import "./chunk-6RGIM2ZH.js";
+import "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import "./chunk-T6ESD5KM.js";
+import "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XNRPCI23.js";
+import "./chunk-7RUMD56V.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  MIGRATIONS,
+  STAMP_FILE,
+  readStamp,
+  upgradeCheck,
+  upgradeCommand
+};