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

package/dist/{chunk-C6EKFH7J.js → chunk-XD75VZIH.js}

@@ -3,9 +3,6 @@ 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 {
-  table
-} from "./chunk-VOGCSYOI.js";
 import {
   QueryError,
   askLookup,
@@ -13,10 +10,15 @@ import {
   openIndex,
   runContextTool,
   translate
-} from "./chunk-T6AIP7H5.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-ISUAAMGS.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.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";
 
 // packages/cli/dist/index-commands.js

package/dist/chunk-XERYFDB5.js

@@ -0,0 +1,297 @@
+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 {
+  claimOf,
+  factLabel
+} from "./chunk-AJYXNTNZ.js";
+import "./chunk-C3RY6KU6.js";
+import {
+  safeMessage
+} from "./chunk-S7FCV7S5.js";
+import {
+  verifyInputsOf
+} from "./chunk-RGERPOIV.js";
+import "./chunk-OUBGGKDU.js";
+import "./chunk-XI2LCCYQ.js";
+import "./chunk-BPK5P77O.js";
+import "./chunk-WXFLMQSR.js";
+import "./chunk-TYQBFTBR.js";
+import {
+  checkoutOf
+} from "./chunk-2F4CYZKJ.js";
+import "./chunk-LO6P2VYG.js";
+import {
+  repoContractsOf
+} from "./chunk-ZQ3ON2VQ.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 {
+  dirSource,
+  repairFormSlips,
+  verifyFacts
+} from "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-UPS2DGFC.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  headFromFiles,
+  layoutOf,
+  loadOrgPack,
+  mapDirOf,
+  mapRelOf,
+  orgPackDirOf,
+  pairsFromCorrections,
+  parseFactsLines,
+  questionsRelOf,
+  recordPath,
+  specRelOf,
+  stackHelpersOff
+} from "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/verify-preview.js
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+var sameCommit = (a, b) => a.startsWith(b) || b.startsWith(a);
+var slugPart = (s) => s.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+function prCommand(host, branch) {
+  switch (host) {
+    case "github":
+      return `gh pr create --fill --head ${branch}`;
+    case "gitlab":
+      return `glab mr create --fill --source-branch ${branch}`;
+    case "azure-repos":
+      return `az repos pr create --source-branch ${branch}`;
+    default:
+      return void 0;
+  }
+}
+function editedFields(was, now) {
+  const a = { ...claimOf(was), line: String(was.cite.line) };
+  const b = { ...claimOf(now), line: String(now.cite.line) };
+  return [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].sort().filter((k) => a[k] !== b[k]).map((k) => ({
+    name: k,
+    ...a[k] !== void 0 ? { was: a[k] } : {},
+    ...b[k] !== void 0 ? { now: b[k] } : {}
+  }));
+}
+function stepsOf(root, repo, o) {
+  const branch = `correct/${slugPart(repo)}${o.fact ? `-${slugPart(o.fact)}` : ""}`;
+  const message = safeMessage(o.fact ? `${repo}: a correction by a person of ${o.fact}, applied by atticus verify --write` : `${repo}: corrections by a person, applied by atticus verify --write`);
+  const pr = prCommand(o.host, branch);
+  return {
+    branch,
+    steps: [
+      { step: "verify", command: `atticus verify ${repo} --write` },
+      { step: "branch", command: `git switch -c ${branch}` },
+      { step: "add", command: `git add ${o.files.join(" ")}` },
+      { step: "commit", command: `git commit -m "${message}"` },
+      { step: "push", command: `git push -u origin ${branch}` },
+      { step: "pr", ...pr ? { command: pr } : {} }
+    ]
+  };
+}
+var linkView = (l) => ({
+  id: l.id,
+  from: l.from,
+  to: l.to,
+  ...l.method ? { method: l.method } : {},
+  path: l.path,
+  confidence: l.confidence,
+  ...l.how ? { how: l.how } : {},
+  ...l.flags?.length ? { flags: [...l.flags] } : {},
+  ...l.was ? { was: l.was } : {}
+});
+async function verifyWritePreview(root, repo, o = {}) {
+  const rel = factsRelOf(root);
+  const wrote = `${rel}/${repo}.corrections.jsonl`;
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const host = op?.runtime.adapters.gitHost?.type;
+  const base = [wrote, `${rel}/${repo}.jsonl`, `${rel}/${repo}.verify.yaml`];
+  const plain = (files2, unavailable) => ({
+    repo,
+    wrote,
+    ...stepsOf(root, repo, {
+      ...o.fact ? { fact: o.fact } : {},
+      ...host ? { host } : {},
+      files: files2
+    }),
+    ...unavailable ? { unavailable } : {}
+  });
+  const read = parseFactsLines(text);
+  const repaired = repairFormSlips(read.facts, read.bad);
+  if (!repaired.facts.length)
+    return plain(base, "unreadable-facts");
+  const before = repaired.facts;
+  const dir = await checkoutOf(root, repo);
+  if (!dir || !existsSync(dir))
+    return plain(base, "no-checkout");
+  const commit = [...new Set(before.map((f) => f.commit))].sort()[0];
+  const head = await headFromFiles(dir);
+  const off = stackHelpersOff();
+  const inputs = await verifyInputsOf(root, repo, dir);
+  const report = await verifyFacts({
+    facts: before,
+    source: dirSource(dir),
+    ...off.has("derived-names") ? { derivedNames: false } : {},
+    ...off.has("readers") ? { readers: false } : {},
+    exclude: inputs.exclude,
+    corrections: [...inputs.corrections.corrections, ...o.extra ?? []],
+    reviewed: inputs.reviewed.entries,
+    ...inputs.estate ? { estate: inputs.estate } : {},
+    conventions: inputs.conventions,
+    notes: inputs.notes,
+    componentTypes: inputs.componentTypes,
+    notReached: inputs.notReached
+  });
+  const kept = new Map(report.accepted.map((f) => [f.id, f]));
+  const wrong = new Set(report.corrections.applied.filter((a) => a.action === "wrong").map((a) => a.fact));
+  const rejected = new Map(report.rejected.map((r) => [r.fact.id, r]));
+  const facts = {
+    dropped: before.filter((f) => !kept.has(f.id)).map((f) => ({
+      id: f.id,
+      kind: f.kind,
+      label: factLabel(f),
+      why: wrong.has(f.id) ? "wrong" : "rejected",
+      ...!wrong.has(f.id) && rejected.get(f.id) ? { message: rejected.get(f.id).message } : {}
+    })),
+    edited: before.flatMap((f) => {
+      const now = kept.get(f.id);
+      const fields = now ? editedFields(f, now) : [];
+      return now && fields.length ? [{ id: f.id, kind: f.kind, label: factLabel(now), fields }] : [];
+    }),
+    kept: report.accepted.length
+  };
+  const staleCorrections = [
+    ...new Set(report.corrections.stale.filter((s) => s.why === "none").map((s) => s.correction.fact))
+  ].sort();
+  const headMoved = head && commit && !sameCommit(head, commit) ? { head: head.slice(0, 12), commit } : void 0;
+  const files = [...base];
+  if (report.rejected.length || existsSync(join(factsDirOf(root), `${repo}.rejected.jsonl`)))
+    files.push(`${rel}/${repo}.rejected.jsonl`);
+  if (report.rejected.length) {
+    return {
+      ...plain(files),
+      preview: {
+        facts,
+        blocked: { rejected: report.rejected.length },
+        ...headMoved ? { headMoved } : {},
+        staleCorrections
+      }
+    };
+  }
+  const { projectFactsIntoCatalog } = await import("./chunk-Y2EQNWKV.js");
+  const contracts = await repoContractsOf(root, repo, dir, report.accepted);
+  const companion = join(factsDirOf(root), `${repo}.contracts.yaml`);
+  const onDisk = await readFile(companion, "utf8").catch(() => void 0);
+  const next = contracts.entries.length ? (0, import_yaml.stringify)(contracts, { lineWidth: 0 }) : void 0;
+  if (onDisk !== next)
+    files.push(`${rel}/${repo}.contracts.yaml`);
+  const p = await projectFactsIntoCatalog(root, repo, report.accepted, {
+    ...op ? { op } : {},
+    contracts,
+    cache: false,
+    ...o.extra?.length ? { extraPairs: pairsFromCorrections(report.accepted, o.extra) } : {}
+  });
+  const catalogRel = layoutOf(root).catalog.replace(/\/+$/, "");
+  const recordFiles = [
+    ...p.diff.added,
+    ...p.diff.changed,
+    ...p.diff.removed,
+    ...p.diff.evidenceOnly
+  ].map((r) => `${catalogRel}/generated/${recordPath(r)}`).sort();
+  files.push(...new Set(recordFiles));
+  if (p.result.flows.length || existsSync(join(root, ...specRelOf(root, repo).split("/"))))
+    files.push(specRelOf(root, repo));
+  if (existsSync(join(mapDirOf(root), repo)) || p.result.records.some((r) => r.kind === "Component"))
+    files.push(`${mapRelOf(root)}/${repo}`);
+  if (existsSync(join(root, ...questionsRelOf(root).split("/"))))
+    files.push(questionsRelOf(root));
+  const key = (l) => `${l.from}|${l.method ?? ""}|${l.path}`;
+  const added = p.links.added.map(linkView);
+  const removed = p.links.removed.map(linkView);
+  const ifaces = (rs) => rs.filter((r) => r.kind === "Interface");
+  const callerHere = (r) => r.evidence.some((e) => e.repo === repo && e.side !== "callee");
+  const after = new Map(ifaces(p.result.records).map((r) => [r.id, r]));
+  const moved = [];
+  for (const a of added) {
+    const old = ifaces(p.existing).find((r) => r.to !== a.to && callerHere(r) && key({ from: r.from, method: r.method, path: r.normalizedPath }) === key(a) && !(after.get(r.id) && callerHere(after.get(r.id))));
+    if (old)
+      moved.push({
+        from: a.from,
+        ...a.method ? { method: a.method } : {},
+        path: a.path,
+        was: old.to,
+        to: a.to
+      });
+  }
+  const movedIds = /* @__PURE__ */ new Set();
+  for (const m of moved) {
+    const old = ifaces(p.existing).find((r) => r.to === m.was && key({ from: r.from, method: r.method, path: r.normalizedPath }) === key(m));
+    if (old)
+      movedIds.add(old.id);
+  }
+  const unmade = ifaces(p.existing).filter((r) => callerHere(r) && after.has(r.id) && !callerHere(after.get(r.id))).filter((r) => !movedIds.has(r.id)).map((r) => ({
+    id: r.id,
+    from: r.from,
+    to: r.to,
+    ...r.method ? { method: r.method } : {},
+    path: r.normalizedPath,
+    confidence: after.get(r.id).confidence,
+    ...r.flags?.length ? { flags: [...r.flags] } : {}
+  })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const movedKeys = new Set(moved.map((m) => `${m.from}|${m.method ?? ""}|${m.path}`));
+  return {
+    ...plain(files),
+    preview: {
+      facts,
+      catalog: {
+        added: p.diff.added.length,
+        changed: p.diff.changed.length,
+        removed: p.diff.removed.length,
+        evidenceOnly: p.diff.evidenceOnly.length,
+        files: [...new Set(recordFiles)]
+      },
+      links: {
+        added: added.filter((l) => !movedKeys.has(key(l))),
+        removed: removed.filter((l) => !movedKeys.has(key(l))),
+        changed: p.links.changed.map(linkView),
+        unmade,
+        moved
+      },
+      ...headMoved ? { headMoved } : {},
+      staleCorrections
+    }
+  };
+}
+export {
+  prCommand,
+  verifyWritePreview
+};