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

package/dist/chunk-AJYXNTNZ.js

@@ -0,0 +1,317 @@
+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 {
+  HttpError,
+  badRequest,
+  notFound
+} from "./chunk-C3RY6KU6.js";
+import {
+  appendLines
+} from "./chunk-S7FCV7S5.js";
+import {
+  readCorrections
+} from "./chunk-2F4CYZKJ.js";
+import {
+  applyCorrections,
+  correctedFact,
+  correctionFor,
+  outsidePairingFor,
+  repairFormSlips
+} from "./chunk-CXJ6FUKN.js";
+import {
+  FACT_FIXED_FIELDS,
+  FactCorrection,
+  FactId,
+  api_exports,
+  correctionLine,
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  parseAuditFile,
+  parseFactsLines,
+  questionsDirOf,
+  sampleConfirmed
+} from "./chunk-Q2TECDIT.js";
+
+// packages/cli/dist/ui-api-facts.js
+import { mkdir, readFile } from "node:fs/promises";
+
+// packages/cli/dist/file-memo.js
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+var kept = /* @__PURE__ */ new Map();
+async function stampOf(paths) {
+  const parts = await Promise.all(paths.map((p) => stat(p).then((s) => `${s.size}:${s.mtimeMs}`, () => "-")));
+  return parts.join("|");
+}
+var asking = /* @__PURE__ */ new Map();
+function memoByFiles(key, paths, work, o = {}) {
+  const on = asking.get(key);
+  if (on)
+    return on;
+  const p = memoOnce(key, paths, work, o).finally(() => {
+    if (asking.get(key) === p)
+      asking.delete(key);
+  });
+  asking.set(key, p);
+  return p;
+}
+async function memoOnce(key, paths, work, o) {
+  const hit = kept.get(key);
+  if (hit && o.recheckAfterMs && Date.now() - hit.checked < o.recheckAfterMs)
+    return hit.value;
+  const stamp = await stampOf(typeof paths === "function" ? await paths() : paths);
+  if (hit && hit.stamp === stamp) {
+    hit.checked = Date.now();
+    return hit.value;
+  }
+  const value = work();
+  kept.set(key, { stamp, value, checked: Date.now() });
+  value.catch(() => {
+    if (kept.get(key)?.value === value)
+      kept.delete(key);
+  });
+  return value;
+}
+async function filesIn(dir) {
+  const names = await readdir(dir).catch(() => []);
+  return [dir, ...names.sort().map((n) => join(dir, n))];
+}
+async function filesUnder(dir) {
+  const out = [dir];
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+    const p = join(dir, e.name);
+    if (e.isDirectory())
+      out.push(...await filesUnder(p));
+    else
+      out.push(p);
+  }
+  return out;
+}
+function recheckNow(key) {
+  const hit = kept.get(key);
+  if (hit)
+    hit.checked = 0;
+}
+
+// packages/cli/dist/ui-api-facts.js
+import { join as join2 } from "node:path";
+var REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+var fixed = new Set(FACT_FIXED_FIELDS);
+function factLabel(f) {
+  switch (f.kind) {
+    case "entry":
+      return `${f.method ? `${f.method} ` : ""}${f.path}`;
+    case "call":
+      return `${f.method ? `${f.method} ` : ""}${f.path}${f.to ? ` \u2192 ${f.to}` : ""}`;
+    case "store":
+      return `${f.name} (${f.op})`;
+    case "field":
+      return `${f.name}${f.type ? `: ${f.type}` : ""}`;
+    case "deploy":
+      return `${f.platform}${f.resourceName ? ` ${f.resourceName}` : ""}`;
+    case "config":
+      return `${f.key}${f.value !== void 0 ? ` = ${f.value}` : ""}`;
+    // ADR 0124 addendum A-framework: what the repo or the module is built on.
+    case "framework":
+      return `${f.name}${f.version ? ` ${f.version}` : ""}`;
+    case "flow":
+      return f.name;
+    // ADR 0163: a term of the organisation's, with the role a note gave it.
+    case "term":
+      return `${f.term} ${f.value} (${f.role})`;
+    // ADR 0180: what a component is.
+    case "component":
+      return `${f.component ?? f.repo} is a ${f.type}`;
+  }
+}
+function claimOf(f) {
+  const out = {};
+  for (const [k, v] of Object.entries(f))
+    if (!fixed.has(k) && typeof v === "string")
+      out[k] = v;
+  out.value = f.cite.value;
+  return out;
+}
+var spot = (c) => ({
+  file: c.file,
+  line: c.line,
+  value: c.value,
+  ...c.quote ? { quote: c.quote } : {}
+});
+async function readFacts(root, repo) {
+  const file = `${factsRelOf(root)}/${repo}.jsonl`;
+  const text = await readFile(join2(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { file, present: false, facts: [], bad: [] };
+  const read = parseFactsLines(text);
+  const p = repairFormSlips(read.facts, read.bad);
+  return {
+    file,
+    present: true,
+    facts: p.facts,
+    bad: [
+      ...p.slips.map((x) => ({
+        file,
+        message: `slip of form fixed as read (a note; atticus verify ${repo} writes the fix into the facts file): ${x.message}`
+      })),
+      ...p.bad.map((b) => ({
+        file,
+        message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
+      }))
+    ]
+  };
+}
+async function repoFactsView(root, repo) {
+  const dir = factsDirOf(root);
+  return memoByFiles(`facts-view\0${root}\0${repo}`, [
+    ...[`${repo}.jsonl`, `${repo}.corrections.jsonl`, `${repo}.audit.yaml`].map((f) => join2(dir, f)),
+    // Its open questions are part of the view.
+    ...await filesIn(questionsDirOf(root))
+  ], () => repoFactsViewNow(root, repo));
+}
+async function repoFactsViewNow(root, repo) {
+  const f = await readFacts(root, repo);
+  const cFile = `${factsRelOf(root)}/${repo}.corrections.jsonl`;
+  const c = await readCorrections(root, repo);
+  const problems = [
+    ...f.bad,
+    ...c.bad.map((b) => ({
+      file: cFile,
+      message: `line ${b.line} isn't a correction: ${b.message}`
+    }))
+  ];
+  const auditText = await readFile(join2(factsDirOf(root), `${repo}.audit.yaml`), "utf8").catch(() => void 0);
+  const audit = auditText === void 0 ? void 0 : parseAuditFile(auditText);
+  const sampled = sampleConfirmed(audit?.ok ? audit.file : void 0, f.facts);
+  if (audit && !audit.ok)
+    problems.push({
+      file: `${factsRelOf(root)}/${repo}.audit.yaml`,
+      message: `isn't an audit file: ${audit.issues[0] ?? "invalid"}`
+    });
+  const facts = f.facts.map((x) => {
+    const corr = correctionFor(x, c.corrections) ?? outsidePairingFor(x, c.corrections);
+    return {
+      id: x.id,
+      kind: x.kind,
+      label: factLabel(x),
+      claim: claimOf(x),
+      cite: spot(x.cite),
+      ...x.kind === "flow" ? {
+        steps: [
+          ...x.steps.map((s) => ({ ...spot(s.cite), what: s.what })),
+          ...x.errors.map((e) => ({ ...spot(e.cite), what: `${e.when} \u2192 ${e.then}` }))
+        ]
+      } : {},
+      verified: x.verified === "line" && sampled.has(x.id) ? "sample" : x.verified,
+      by: x.by,
+      ...corr ? { correction: corr } : {}
+    };
+  });
+  const staleAll = applyCorrections(f.facts, c.corrections).stale;
+  const stale = staleAll.filter((s) => s.why === "none").map((s) => s.correction.fact);
+  for (const s of staleAll)
+    if (s.why === "invalid")
+      problems.push({ file: cFile, message: s.message });
+  const questions = await listQuestions(root, { repo, state: "open" }).then((l) => l.questions.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })), () => []);
+  return {
+    repo,
+    file: f.file,
+    present: f.present,
+    ...f.facts[0] ? { commit: f.facts[0].commit } : {},
+    facts,
+    corrections: { file: cFile, count: c.corrections.length, stale: [...new Set(stale)].sort() },
+    questions,
+    verify: `atticus verify ${repo}`,
+    problems
+  };
+}
+var repoOf = (v) => {
+  if (!REPO.test(v))
+    throw badRequest(`${JSON.stringify(v)} isn't a repo name.`);
+  return v;
+};
+function uiFactsRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return r.add("GET", "/api/facts/{repo}", async ({ params }) => ({
+    status: 200,
+    body: await repoFactsView(ctx.root, repoOf(params.repo))
+  })).add("GET", "/api/facts/{repo}/preview", async ({ params, query }) => {
+    const repo = repoOf(params.repo);
+    const fact = query.get("fact") || void 0;
+    if (fact && !FactId.safeParse(fact).success)
+      throw badRequest(`${JSON.stringify(fact)} isn't a fact id.`);
+    const { verifyWritePreview } = await import("./chunk-XERYFDB5.js");
+    const v = await verifyWritePreview(ctx.root, repo, fact ? { fact } : {});
+    if (!v)
+      throw notFound(`There are no facts for ${repo} at ${factsRelOf(ctx.root)}/${repo}.jsonl.`);
+    return { status: 200, body: v };
+  }).add("POST", "/api/facts/{repo}/corrections", async ({ params, body }) => {
+    const repo = repoOf(params.repo);
+    const b = api_exports.FactCorrectionRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which fact and what is wrong: { fact, action, set, line, reason }.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const f = await readFacts(ctx.root, repo);
+    if (!f.present)
+      throw notFound(`There are no facts for ${repo} at ${f.file}.`);
+    const fact = f.facts.find((x) => x.id === b.data.fact);
+    if (!fact)
+      throw notFound(`${f.file} has no fact ${b.data.fact}.`);
+    const was = claimOf(fact);
+    const set = Object.fromEntries(Object.entries(b.data.set ?? {}).map(([k, v]) => [k, v.trim()]).filter(([k, v]) => was[k] !== v));
+    const line = b.data.line !== void 0 && b.data.line !== fact.cite.line ? b.data.line : void 0;
+    const c = FactCorrection.safeParse({
+      schemaVersion: 1,
+      fact: fact.id,
+      target: {
+        kind: fact.kind,
+        file: fact.cite.file,
+        line: fact.cite.line,
+        value: fact.cite.value
+      },
+      action: b.data.action,
+      ...b.data.action === "edit" && Object.keys(set).length ? { set } : {},
+      ...b.data.action === "edit" && line !== void 0 ? { line } : {},
+      ...b.data.reason ? { reason: b.data.reason } : {},
+      by: ctx.user,
+      at: now().toISOString()
+    });
+    if (!c.success)
+      throw new HttpError(422, "Atticus can't record that", c.error.issues.map((i) => i.message).join("; "));
+    if (c.data.action === "edit") {
+      const fixedFact = correctedFact(fact, c.data);
+      if (typeof fixedFact === "string")
+        throw new HttpError(422, "That isn't a fact", `The corrected ${fact.kind} isn't one: ${fixedFact}.`);
+    }
+    const rel = `${factsRelOf(ctx.root)}/${repo}.corrections.jsonl`;
+    const written = correctionLine(c.data);
+    await mkdir(factsDirOf(ctx.root), { recursive: true });
+    const cfile = join2(factsDirOf(ctx.root), `${repo}.corrections.jsonl`);
+    await appendLines(cfile, [written]);
+    ctx.events.publish({ type: "file.changed", path: rel });
+    const result = {
+      correction: c.data,
+      file: rel,
+      commit: `git add ${rel}
+git commit -m "${repo}: a person's correction of ${fact.id}"`,
+      verify: `atticus verify ${repo}`,
+      line: written
+    };
+    return { status: 200, body: result };
+  });
+}
+
+export {
+  memoByFiles,
+  filesUnder,
+  recheckNow,
+  factLabel,
+  claimOf,
+  uiFactsRoutes
+};

package/dist/chunk-AVTBS4OW.js

@@ -0,0 +1,49 @@
+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,
+  newerAtticusOf,
+  newerThan,
+  newerWords,
+  readStamp,
+  upgradeCheck,
+  upgradeCommand
+} from "./chunk-P2V7QW4D.js";
+import "./chunk-Z5IA3WDR.js";
+import "./chunk-R7NYHMUU.js";
+import "./chunk-IVBOQAGB.js";
+import "./chunk-ISUAAMGS.js";
+import "./chunk-BEVTIBRH.js";
+import "./chunk-S4PMJU6H.js";
+import "./chunk-IDKCWSM5.js";
+import "./chunk-UUU4CLJG.js";
+import "./chunk-7IGKHZ4Z.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-F3P7N7SF.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+export {
+  MIGRATIONS,
+  STAMP_FILE,
+  newerAtticusOf,
+  newerThan,
+  newerWords,
+  readStamp,
+  upgradeCheck,
+  upgradeCommand
+};

package/dist/{chunk-FHH4I4ZV.js → chunk-BDKC6H5P.js}

@@ -5,23 +5,25 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   targetFlowsOf
-} from "./chunk-TDD55CJH.js";
+} from "./chunk-IH2XURVQ.js";
 import {
   estimateChange,
   loadRelease,
   releaseForecast
-} from "./chunk-BOHJZTEQ.js";
+} from "./chunk-WF7B67YE.js";
 import {
   gateStatus,
   reviewedGates
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-S4PMJU6H.js";
 import {
-  detectConflicts
-} from "./chunk-XY3P7JW7.js";
+  detectConflicts,
+  outsideSystemsOf
+} from "./chunk-IDKCWSM5.js";
 import {
   loadEstimates,
+  loadOrgPack,
   orgPackDirOf
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 
 // packages/cli/dist/change-estimate.js
 import { relative, sep } from "node:path";
@@ -42,6 +44,9 @@ async function estimateOf(root, change, o = {}) {
       systemOf.set(r.id, r.system);
   }
   const boundaryOf = (c) => systems.get(systemOf.get(c) ?? c);
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const outside = op ? outsideSystemsOf(op) : /* @__PURE__ */ new Map();
+  const otherTeam = (c) => boundaryOf(c) !== "vendor" && outside.get(systemOf.get(c) ?? c) === "other-team";
   let openBlocking = 0;
   for (const gate of await reviewedGates(root, change).catch(() => []))
     openBlocking += await gateStatus(root, change, gate).then((s) => s.open.blocking, () => 0);
@@ -76,6 +81,7 @@ async function estimateOf(root, change, o = {}) {
     flows,
     ...estimates ? { table: estimates } : {},
     boundaryOf,
+    otherTeam,
     openBlocking,
     conflicts,
     ...waitDays !== void 0 ? { waitDays } : {}