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

package/dist/chunk-BHT7QK4G.js

@@ -0,0 +1,162 @@
+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 {
+  gitUser
+} from "./chunk-PKBHS4AA.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/decision-commands.js
+import { parseArgs } from "node:util";
+var DECISIONS_USAGE = "Usage: atticus questions decisions [--json], atticus questions correct <q-id | link:<repo>:<call>> --option <n> | --api <entry> --to <repo> | --none [--no-similar] [--match <rule>] [--preview] [--json], or atticus questions undo <batch> [--json]";
+var pct = (x) => x === null ? "-" : `${Math.round(x * 1e3) / 10}%`;
+function printView(v, io) {
+  const d = v.decide;
+  io.out(`Deciding: pairings ${d.now.links}, questions ${d.now.questions} (runtime.yaml decide: links ${d.configured.links}, questions ${d.configured.questions}, minPrecision ${pct(d.configured.minPrecision)}).`);
+  if (d.paused)
+    io.out(`Paused: ${d.paused.why}`);
+  const n = d.precision.right + d.precision.wrong;
+  io.out(n ? `Sample audit of the AI's decisions: ${pct(d.precision.precision)} right (${d.precision.right} of ${n}; 95% interval ${pct(d.precision.low)} to ${pct(d.precision.high)}).` : "Sample audit of the AI's decisions: none answered yet (atticus verify audit <repo> draws them).");
+  const c = (x) => `${x.fromCode} from code, ${x.byPerson} by a person, ${x.byAi} by AI${x.open !== void 0 ? `, ${x.open} open` : ""}`;
+  io.out(`Links (as last written): ${c(v.links.counts)}.`);
+  io.out(`Questions: ${c(v.questions.counts)}.`);
+  const items = [...v.links.items, ...v.questions.items];
+  if (items.length)
+    io.out("Detected by AI, standing:");
+  for (const i of items)
+    io.out(`  ${i.item}  ${i.what}  [${i.bar ?? "ai"}, run ${i.run}${i.batch ? `, ${i.batch}` : ""}]`);
+  if (v.batches.length)
+    io.out("Batches, newest first:");
+  for (const b of v.batches)
+    io.out(`  ${b.id}  ${b.kind === "ai" ? "AI" : "a correction"} by ${b.by}: ${b.applied} applied, ${b.reverted} taken back${b.correction?.rule ? `, rule ${b.correction.rule.match}` : ""}${b.undone ? ` (undone by ${b.undone.by})` : ""}`);
+  for (const p of v.problems)
+    io.err(`${p.file}: ${p.message}`);
+}
+async function decisionsCli(root, argv, io, deps = {}) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: false,
+    options: {
+      root: { type: "string" },
+      json: { type: "boolean" },
+      option: { type: "string" },
+      api: { type: "string" },
+      to: { type: "string" },
+      none: { type: "boolean" },
+      similar: { type: "boolean" },
+      "no-similar": { type: "boolean" },
+      match: { type: "string" },
+      preview: { type: "boolean" }
+    }
+  });
+  const str = (v) => typeof v === "string" ? v : void 0;
+  const [, command, id] = positionals;
+  const m = await import("./chunk-Q4K5WB2W.js");
+  const fail = (e) => {
+    if (e instanceof m.DecideError) {
+      io.err(e.message);
+      return e.code === "not-found" ? 1 : 2;
+    }
+    throw e;
+  };
+  if (command === "decisions") {
+    const v = await m.decisionsView(root);
+    if (values.json === true)
+      io.out(JSON.stringify(v, null, 2));
+    else
+      printView(v, io);
+    return v.problems.length ? 1 : 0;
+  }
+  const by = async () => (await gitUser(root)).handle;
+  if (command === "correct") {
+    if (!id) {
+      io.err(DECISIONS_USAGE);
+      return 2;
+    }
+    const option = str(values.option);
+    if (option !== void 0 && !/^\d+$/.test(option)) {
+      io.err("--option is a number, from 1.");
+      return 2;
+    }
+    const req = {
+      item: id,
+      ...option ? { option: Number(option) } : {},
+      ...str(values.api) ? { api: str(values.api) } : {},
+      ...str(values.to) ? { repo: str(values.to) } : {},
+      ...values.none === true ? { none: true } : {},
+      similar: values["no-similar"] !== true,
+      ...str(values.match) ? { match: str(values.match) } : {},
+      ...values.preview === true ? { preview: true } : {}
+    };
+    let r;
+    try {
+      r = await m.correctDecision(root, req, {
+        by: await by(),
+        ...deps.now ? { now: deps.now } : {},
+        ...deps.env ? { env: deps.env } : {}
+      });
+    } catch (e) {
+      return fail(e);
+    }
+    if (values.json === true) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(`${r.written ? "Corrected" : "Would correct"} ${r.item}: ${r.answer}, as yours${r.batch ? ` (batch ${r.batch})` : ""}.`);
+    if (r.rule)
+      io.out(`Apply to similar: ${r.rule.derived ? "the rule derived from it" : "your rule"} is ${r.rule.match} (${r.rule.kind}); give another with --match, or --no-similar for this one alone.`);
+    if (r.noRule)
+      io.out(`Nothing spreads: ${r.noRule}.`);
+    for (const s of r.spread)
+      io.out(`  ${s.change}: ${s.item} ${s.what}${s.was ? ` (was ${s.was})` : ""}${s.now ? ` \u2192 ${s.now}` : ""}`);
+    if (r.rule)
+      io.out(`${r.counts.applied} applied, ${r.counts.confirmed} confirmed, ${r.counts.replaced} replaced, ${r.counts.reverted} opened again.`);
+    if (r.makeRule)
+      io.out(`This shape has been corrected ${r.makeRule.corrections} times: make it a reading rule so the next read gets it right (${r.makeRule.command ?? "the app's Make this a rule, on the pairing"}).`);
+    if (r.written) {
+      io.out(`Then: ${r.verify.join("; ")}. Undo: atticus questions undo ${r.batch}.`);
+      io.out(r.commit);
+    } else
+      io.out("Nothing written: run it again without --preview to save it.");
+    return 0;
+  }
+  if (command === "undo") {
+    if (!id) {
+      io.err(DECISIONS_USAGE);
+      return 2;
+    }
+    let r;
+    try {
+      r = await m.undoBatch(root, id, {
+        by: await by(),
+        ...deps.now ? { now: deps.now } : {},
+        ...deps.env ? { env: deps.env } : {}
+      });
+    } catch (e) {
+      return fail(e);
+    }
+    if (values.json === true) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(`Undid ${r.batch}: ${r.removed} taken away, ${r.restored} put back.`);
+    for (const s of r.skipped)
+      io.out(`  ${s}`);
+    if (r.verify.length)
+      io.out(`Then: ${r.verify.join("; ")}.`);
+    io.out(r.commit);
+    return 0;
+  }
+  io.err(DECISIONS_USAGE);
+  return 2;
+}
+export {
+  DECISIONS_USAGE,
+  decisionsCli
+};

package/dist/{chunk-6JUBZBMW.js → chunk-BIGDQDHD.js}

@@ -5,10 +5,12 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   defaultCodeDir
-} from "./chunk-T6AIP7H5.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-ISUAAMGS.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/question-evidence.js

package/dist/{chunk-2BFCZ3RK.js → chunk-BO4KX37X.js}

@@ -3,35 +3,36 @@ 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 "./chunk-GLUX4EEP.js";
+import "./chunk-4EURQWQD.js";
 import {
   loadCatalog
-} from "./chunk-FITWGOJ2.js";
+} from "./chunk-OHNCWBKF.js";
 import {
   repoFor
-} from "./chunk-O3WI5KWW.js";
-import "./chunk-KEM4SDDP.js";
+} from "./chunk-LO6P2VYG.js";
+import "./chunk-O7FDLW7L.js";
 import {
   askHosts
-} from "./chunk-RVH5SUW5.js";
-import "./chunk-ZVM6AKKM.js";
+} from "./chunk-MFR5OPBD.js";
+import "./chunk-PJSJPMJI.js";
+import "./chunk-ISUAAMGS.js";
 import {
   estateFlow,
   estateStepKey,
   fieldLineage,
   joinEstate
-} 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-T6AIP7H5.js";
-import "./chunk-EFHQ3TWP.js";
+} from "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
 import {
   fsRepo
-} from "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
+} from "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
 import {
   listQuestions,
   loadOrgPack,
@@ -45,8 +46,9 @@ import {
   specsRelOf,
   templateRef,
   writeEstateJoins
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/estate-commands.js

package/dist/chunk-BPK5P77O.js

@@ -0,0 +1,115 @@
+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 {
+  NOT_REACHED_WHY,
+  isEntryPointFile,
+  planBatches,
+  reachableModels,
+  readingRank
+} from "./chunk-CXJ6FUKN.js";
+import {
+  neutralise,
+  wrapData
+} from "./chunk-P32RUW3B.js";
+import {
+  estimateTokens
+} from "./chunk-Q2TECDIT.js";
+
+// packages/cli/dist/map-reach.js
+var CLIENT_ONLY_WHY = "reached only from an outbound client; --models reachable reads them";
+var ENTRIES_WHY = "model classes the repo's own entry points don't reach (ADR 0170): left out of the read; those only an outbound client reaches are listed under clientOnly (atticus map <repo> --models reachable reads them), the rest no entry point, call or field fact reaches (--models all reads them)";
+function readPathsOf(source, exclude, conventions) {
+  return planBatches(source, {
+    room: Number.MAX_SAFE_INTEGER,
+    exclude,
+    ...conventions ? { conventions } : {}
+  }).batches.flat().map((x) => x.path);
+}
+function reachPlanOf(o) {
+  const of = (from) => reachableModels({
+    paths: o.paths,
+    read: (p) => o.source.read(p),
+    ...o.facts?.length ? { facts: o.facts } : {},
+    ...from ? { from } : {}
+  });
+  const calls = of();
+  const entries = o.mode === "entries" ? of("entries") : void 0;
+  const reach = entries && entries.roots.length ? entries : calls;
+  const leaveOut = o.mode === "all" ? [] : reach.notReached;
+  const byCall = new Set(calls.reached.map((r) => r.path));
+  const clientOnly = reach === entries ? leaveOut.filter((p) => byCall.has(p)) : [];
+  const tokens = leaveOut.reduce((n, p) => n + estimateTokens(o.source.read(p) ?? ""), 0);
+  return {
+    mode: o.mode,
+    reach,
+    first: [...reach.roots, ...reach.reached.map((r) => r.path)],
+    leaveOut,
+    clientOnly,
+    ...leaveOut.length ? {
+      notReached: {
+        why: clientOnly.length ? ENTRIES_WHY : NOT_REACHED_WHY,
+        files: [...leaveOut],
+        tokens,
+        ...clientOnly.length ? { clientOnly: { why: CLIENT_ONLY_WHY, files: [...clientOnly] } } : {}
+      }
+    } : {}
+  };
+}
+var reachHeadOf = (paths, r) => {
+  const roots = new Set(r.reach.roots);
+  return paths.filter((p) => readingRank(p) <= 1 || roots.has(p));
+};
+var reachedByCalls = (r) => r.reach.roots.some((p) => !isEntryPointFile(p));
+function modelsLine(repo, r) {
+  const { reach } = r;
+  if (!reach.models)
+    return void 0;
+  if (!reach.rooted)
+    return `Model classes (ADR 0169): ${reach.models}; no entry point, client or fact to reach them from, so every one is read.`;
+  const fromEntries = r.mode === "entries" && (r.clientOnly.length > 0 || !reachedByCalls(r));
+  const reached = `${reach.reached.length} reached from the entry points${fromEntries ? "" : " and calls"}, read after them`;
+  if (r.mode === "all")
+    return `Model classes (ADR 0169): ${reach.models}, every one read (--models all); ${reached}.`;
+  const rest = r.leaveOut.length - r.clientOnly.length;
+  return `Model classes (ADR 0169): ${reach.models}; ${reached}${r.clientOnly.length ? `; ${r.clientOnly.length} reached only from an outbound client, left out: atticus map ${repo} --models reachable reads them` : ""}${rest ? `; ${rest} no entry or call reaches, left out: atticus map ${repo} --models all reads them` : ""}.`;
+}
+function grouped(paths) {
+  const by = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const i = p.lastIndexOf("/");
+    const d = i < 0 ? "" : p.slice(0, i + 1);
+    by.set(d, [...by.get(d) ?? [], p.slice(i + 1)]);
+  }
+  return [...by.entries()].map(([d, fs]) => `- ${d || "./"}: ${fs.join(", ")}`);
+}
+function modelsData(repo, r, o = {}) {
+  if (!r.reach.models || !r.reach.rooted)
+    return void 0;
+  const reached = r.reach.reached.filter((x) => !o.only || o.only.has(x.path));
+  if (!reached.length && (o.only || !r.leaveOut.length))
+    return void 0;
+  const lines = [
+    ...reached.length ? ["Reached (read these, and write their fields):"] : [],
+    ...reached.map((x) => `- ${x.path} (${x.types.join(", ")}), from ${x.from}`),
+    ...r.clientOnly.length && !o.only ? [
+      "Reached only from an outbound client (left out; don't read them):",
+      ...grouped(r.clientOnly)
+    ] : [],
+    ...r.leaveOut.length > r.clientOnly.length && !o.only ? [
+      "Not reached by any entry point or call (left out; don't read them):",
+      ...grouped(r.leaveOut.filter((p) => !r.clientOnly.includes(p)))
+    ] : []
+  ];
+  return wrapData({ id: `${repo}.models`, kind: "models", origin: o.origin ?? "atticus/reachable" }, neutralise(lines.join("\n"), void 0, { mark: true }).text);
+}
+
+export {
+  readPathsOf,
+  reachPlanOf,
+  reachHeadOf,
+  modelsLine,
+  modelsData
+};

package/dist/chunk-BQ4SQQC6.js

@@ -0,0 +1,59 @@
+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 {
+  MODELS_MODES,
+  ReadPlanFile,
+  globHolds,
+  loadReadPlan,
+  mapSpent,
+  migrateReadPlan,
+  modelsModeOf,
+  ownStarts,
+  partOfWords,
+  partUnaccounted,
+  readCostOf,
+  readCostWords,
+  readPlanProgress,
+  readPlanRelOf,
+  recordNotReached,
+  recordReadProgress,
+  recordReported,
+  saveReadPlan,
+  tokensWords,
+  writeReadPlan
+} from "./chunk-TYQBFTBR.js";
+import "./chunk-2F4CYZKJ.js";
+import "./chunk-LO6P2VYG.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+export {
+  MODELS_MODES,
+  ReadPlanFile,
+  globHolds,
+  loadReadPlan,
+  mapSpent,
+  migrateReadPlan,
+  modelsModeOf,
+  ownStarts,
+  partOfWords,
+  partUnaccounted,
+  readCostOf,
+  readCostWords,
+  readPlanProgress,
+  readPlanRelOf,
+  recordNotReached,
+  recordReadProgress,
+  recordReported,
+  saveReadPlan,
+  tokensWords,
+  writeReadPlan
+};