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

package/dist/{chunk-GLUX4EEP.js → chunk-K6JB6XTX.js}

@@ -5,10 +5,10 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   loadCatalog
-} from "./chunk-FITWGOJ2.js";
+} from "./chunk-5QUOPNLN.js";
 import {
   repoFor
-} from "./chunk-O3WI5KWW.js";
+} from "./chunk-TGVVUKTG.js";
 import {
   checkDraft,
   checkFrameworkDraft,
@@ -22,25 +22,25 @@ import {
   proposalYaml,
   reviewRepo,
   surveyRepo
-} from "./chunk-KEM4SDDP.js";
+} from "./chunk-P2VBXX7N.js";
 import {
   offerCodeDir
-} from "./chunk-ZVM6AKKM.js";
+} from "./chunk-ZOSD4FXV.js";
 import {
   matchRepoType
-} from "./chunk-27NKUS3X.js";
+} from "./chunk-4SLBCEPD.js";
 import {
   modelCovers,
   repoImports,
   runDialectTests,
   runFrameworkTests
-} from "./chunk-MC3H7736.js";
+} from "./chunk-TWQRPM76.js";
 import {
   baseClonePath
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-XOL3GFW2.js";
 import {
   fsRepo
-} from "./chunk-GQ4N4WKF.js";
+} from "./chunk-7AB6OWTV.js";
 import {
   Dialect,
   FrameworkModel,
@@ -52,7 +52,7 @@ import {
   raiseQuestions,
   require_dist,
   reusedLine
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-PAINMSID.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/chunk-KDAHXQIE.js

@@ -0,0 +1,294 @@
+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-QOOEYDNJ.js";
+import "./chunk-HK3VOHIE.js";
+import {
+  safeMessage
+} from "./chunk-THN26IEF.js";
+import {
+  verifyInputsOf
+} from "./chunk-LN77DXBM.js";
+import "./chunk-L4CESDPB.js";
+import "./chunk-U3NBK4EU.js";
+import "./chunk-455SYIIE.js";
+import {
+  repoContractsOf
+} from "./chunk-LPV6T362.js";
+import "./chunk-GIFMBCTW.js";
+import "./chunk-MD7KUEJ3.js";
+import {
+  checkoutOf
+} from "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
+import "./chunk-3AQ2R5NL.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import {
+  dirSource,
+  repairFormSlips,
+  verifyFacts
+} from "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-API5TOUB.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  headFromFiles,
+  layoutOf,
+  loadOrgPack,
+  mapDirOf,
+  mapRelOf,
+  orgPackDirOf,
+  pairsFromCorrections,
+  parseFactsLines,
+  questionsRelOf,
+  recordPath,
+  require_dist,
+  specRelOf,
+  stackHelpersOff
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.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-MZGRDONP.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
+};

package/dist/chunk-KYZMRSPS.js

@@ -0,0 +1,93 @@
+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 {
+  QUESTION_ROLES,
+  changesDirOf,
+  orgPackDirOf,
+  require_dist,
+  roleOfQuestion,
+  roleOfStep,
+  rolesOfPerson
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/change-roles.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var STAGE_FILES = ["feature", "architecture", "stories", "small"];
+var yamlOf = async (path) => {
+  const text = await readFile(path, "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  try {
+    return (0, import_yaml.parse)(text);
+  } catch {
+    return void 0;
+  }
+};
+async function stageQuestions(root, only) {
+  const out = /* @__PURE__ */ new Map();
+  const changes = only ? [only] : await readdir(changesDirOf(root), { withFileTypes: true }).then((d) => d.filter((x) => x.isDirectory()).map((x) => x.name), () => []);
+  for (const change of changes.sort())
+    for (const stage of STAGE_FILES) {
+      const y = await yamlOf(join(changesDirOf(root), change, "stage", `${stage}.yaml`));
+      const ids = Array.isArray(y?.questions) ? y.questions : [];
+      for (const id of ids)
+        if (typeof id === "string" && !out.has(id))
+          out.set(id, { change, role: roleOfStep(`change-${stage}`) });
+    }
+  return out;
+}
+function roleWithStage(q, stages) {
+  return roleOfQuestion(q) ?? stages.get(q.id)?.role;
+}
+function isChangeQuestion(q, change, o) {
+  return q.repo === change || o.stages.get(q.id)?.change === change || !!o.restsOn?.includes(change);
+}
+async function customRoles(root) {
+  const y = await yamlOf(join(orgPackDirOf(root), "roles.yaml"));
+  if (!Array.isArray(y?.custom))
+    return [];
+  return y.custom.flatMap((c) => {
+    const x = c;
+    return typeof x?.id === "string" && typeof x.basedOn === "string" ? [{ id: x.id, basedOn: x.basedOn }] : [];
+  });
+}
+async function personsRoles(root, change, handle) {
+  if (!handle)
+    return [];
+  const y = await yamlOf(join(changesDirOf(root), change, "change.yaml"));
+  const owners = y?.owners;
+  if (!owners || typeof owners !== "object" || Array.isArray(owners))
+    return [];
+  const lists = {};
+  for (const [k, v] of Object.entries(owners))
+    if (Array.isArray(v))
+      lists[k] = v.filter((h) => typeof h === "string");
+  return rolesOfPerson(handle, lists, await customRoles(root));
+}
+function countByRole(questions, roleOf) {
+  const out = {};
+  for (const r of QUESTION_ROLES) {
+    const of = questions.filter((q) => roleOf(q) === r);
+    if (!of.length)
+      continue;
+    const k = (s) => of.filter((q) => q.state === s).length;
+    out[r] = { open: k("open"), answered: k("answered"), retired: k("retired"), total: of.length };
+  }
+  return out;
+}
+export {
+  countByRole,
+  isChangeQuestion,
+  personsRoles,
+  roleWithStage,
+  stageQuestions
+};

package/dist/chunk-L4CESDPB.js

@@ -0,0 +1,22 @@
+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 {
+  effectiveComponentTypes,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-PAINMSID.js";
+
+// packages/cli/dist/component-types.js
+async function componentTypesAt(root, given) {
+  const op = given ?? await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  return effectiveComponentTypes(op?.componentTypes ?? []);
+}
+var componentTypeIds = (types) => new Set(types.map((t) => t.id));
+
+export {
+  componentTypesAt,
+  componentTypeIds
+};

package/dist/{chunk-NXFPS2LR.js → chunk-LEBR5NHW.js}

@@ -5,28 +5,28 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   runPluginTests
-} from "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-EFHQ3TWP.js";
+} 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-XOL3GFW2.js";
+import {
+  SHIPPED_MODEL_PROVIDER_PLUGINS
+} from "./chunk-PRW3HXM3.js";
+import "./chunk-QHJJMZLX.js";
 import {
   pluginEntryHash,
   runTranslator
-} from "./chunk-GQ4N4WKF.js";
-import {
-  SHIPPED_MODEL_PROVIDER_PLUGINS
-} from "./chunk-YEDDOYSC.js";
-import "./chunk-CNUKCS2T.js";
+} from "./chunk-7AB6OWTV.js";
 import {
   ModelProviderPlugin,
   ScannerPlugin,
   orgPackDirOf,
   require_dist
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";