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

package/dist/chunk-3G6S7LAA.js

@@ -0,0 +1,43 @@
+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 {
+  effectiveRules,
+  exampleOf,
+  kindGlob,
+  orgRulesLacking,
+  readingRulesText,
+  ruleFromPairing,
+  ruleId,
+  ruleIds,
+  ruleMatches,
+  rulesDirOf,
+  rulesLackingAll
+} from "./chunk-GIFMBCTW.js";
+import "./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 "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+export {
+  effectiveRules,
+  exampleOf,
+  kindGlob,
+  orgRulesLacking,
+  readingRulesText,
+  ruleFromPairing,
+  ruleId,
+  ruleIds,
+  ruleMatches,
+  rulesDirOf,
+  rulesLackingAll
+};

package/dist/chunk-3J5I7ZOU.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-Q46QDDMF.js";
+import {
+  dirSource,
+  houseImportsUntaught,
+  readRulesOf
+} from "./chunk-JYMIB5XY.js";
+import {
+  globToRegExp
+} from "./chunk-7AB6OWTV.js";
+import {
+  conventionsOf,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-PAINMSID.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-65NYPGRC.js → chunk-3LZ6P5EP.js}

@@ -5,7 +5,7 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   require_dist
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-PAINMSID.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/chunk-3SSTNB4E.js

@@ -0,0 +1,191 @@
+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 {
+  makeRunId
+} from "./chunk-QHJJMZLX.js";
+import {
+  runsDirOf,
+  runsRelOf
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.js";
+
+// packages/cli/dist/decide-handoff.js
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+var DECIDE_AGENTS = {
+  questions: "decide-propose",
+  links: "decide-match"
+};
+var PROPOSE_CHANGE = "questions-propose";
+var matchChangeOf = (from) => `match-${from}`;
+var sha256 = (text) => createHash("sha256").update(text).digest("hex");
+var runDir = (root, change, runId) => join(runsDirOf(root), change, runId);
+async function startDecideRun(root, o) {
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  let runId = makeRunId(now);
+  while (await stat(runDir(root, o.change, runId)).catch(() => void 0))
+    runId = makeRunId(now);
+  const dir = runDir(root, o.change, runId);
+  await mkdir(dir, { recursive: true });
+  await writeFileAtomic(join(dir, "prompt.md"), o.prompt.endsWith("\n") ? o.prompt : `${o.prompt}
+`);
+  const run = {
+    runId,
+    request: { change: o.change, agent: DECIDE_AGENTS[o.kind], outputPath: o.outputPath },
+    runtime: "hand-off",
+    state: "waiting",
+    attempt: 1,
+    startedAt: now.toISOString(),
+    errors: [],
+    decide: o.decide
+  };
+  await saveRun(root, run);
+  return { ...run, promptRel: `${runsRelOf(root)}/${o.change}/${runId}/prompt.md` };
+}
+async function saveRun(root, run) {
+  await writeFileAtomic(join(runDir(root, run.request.change, run.runId), "run.json"), JSON.stringify(run, null, 2) + "\n");
+}
+var isDecide = (x) => {
+  const r = x;
+  return r?.runtime === "hand-off" && !!r.decide && (r.request?.agent === DECIDE_AGENTS.questions || r.request?.agent === DECIDE_AGENTS.links);
+};
+async function readRun(file) {
+  const text = await readFile(file, "utf8").catch(() => void 0);
+  if (!text)
+    return void 0;
+  try {
+    const r = JSON.parse(text);
+    return isDecide(r) ? r : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function findDecideRun(root, runId) {
+  if (!/^run-[0-9a-z-]+$/.test(runId))
+    return void 0;
+  for (const change of await readdir(runsDirOf(root)).catch(() => [])) {
+    const r = await readRun(join(runsDirOf(root), change, runId, "run.json"));
+    if (r)
+      return r;
+  }
+  return void 0;
+}
+var open = (r) => r.state === "waiting" || r.state === "prepared" || r.state === "failed";
+async function openDecideRun(root, change, pick = () => true) {
+  const ids = (await readdir(join(runsDirOf(root), change)).catch(() => [])).filter((n) => n.startsWith("run-")).sort().reverse();
+  for (const id of ids) {
+    const r = await readRun(join(runsDirOf(root), change, id, "run.json"));
+    if (r && open(r) && pick(r))
+      return r;
+  }
+  return void 0;
+}
+var openMatchRun = (root, from, to) => openDecideRun(root, matchChangeOf(from), (r) => r.decide.kind === "links" && r.decide.from === from && (r.decide.to.repo ?? "") === (to.repo ?? "") && (r.decide.to.system ?? "") === (to.system ?? ""));
+async function finishDecideRun(root, run, o) {
+  const done = {
+    ...run,
+    state: o.state,
+    finishedAt: (o.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    errors: o.errors ?? []
+  };
+  await saveRun(root, done);
+  return done;
+}
+async function decideRunDone(root, runId, io, o = {}) {
+  const run = await findDecideRun(root, runId);
+  if (!run) {
+    io.err(`There is no hand-off run ${runId} to decide from.`);
+    return 2;
+  }
+  if (!open(run)) {
+    io.err(`Run ${runId} is already ${run.state}.`);
+    return 2;
+  }
+  if (run.decide.kind === "questions")
+    return proposeDone(root, run, io, o);
+  const { candidatesOf } = await import("./chunk-PRZ7KMWL.js");
+  const { view, facts } = await candidatesOf(root, run.decide.from, run.decide.to);
+  const { matchDone, matchLines } = await import("./chunk-JU4QNJSR.js");
+  const m = await matchDone(root, { view, facts, run, ...o.now ? { now: o.now } : {} });
+  if (m.state !== "done") {
+    io.err(m.error ?? `The answer isn't written yet: ${m.answer ?? "the answer file"}.`);
+    return 1;
+  }
+  for (const l of matchLines(m, run.decide.from, view.toName, run.decide.to))
+    io.out(l);
+  return 0;
+}
+async function proposedSince(root, before) {
+  const { proposalsSnapshot } = await import("./chunk-LU4MQVAL.js");
+  const after = await proposalsSnapshot(root);
+  return new Set([...after].filter(([id, text]) => before[id] !== sha256(text)).map(([id]) => id));
+}
+async function proposeDone(root, run, io, o) {
+  if (run.decide.kind !== "questions")
+    return 2;
+  const { inAcpSession } = await import("./chunk-LU4MQVAL.js");
+  if (inAcpSession()) {
+    io.err(`Run ${run.runId} decides as the AI only on a person's Done: press Done in the app, or run atticus handoff done ${run.runId} outside the Copilot session.`);
+    return 1;
+  }
+  const ids = await proposedSince(root, run.decide.before);
+  if (!ids.size) {
+    const why = "No proposal was written or changed since this hand-off: run /atticus-propose in a new Copilot Chat (agent mode) or Claude Code session, then Done again.";
+    await finishDecideRun(root, run, {
+      state: "failed",
+      errors: [why],
+      ...o.now ? { now: o.now } : {}
+    });
+    io.err(why);
+    return 1;
+  }
+  const { decideAnswers } = await import("./chunk-LU4MQVAL.js");
+  const d = await decideAnswers(root, {
+    run: run.runId,
+    runtime: "hand-off",
+    ids,
+    ...o.now ? { now: o.now } : {}
+  });
+  await finishDecideRun(root, run, { state: "validated", ...o.now ? { now: o.now } : {} });
+  io.out(`Read ${ids.size} proposal${ids.size === 1 ? "" : "s"} from hand-off run ${run.runId}.`);
+  for (const l of decidedAnswerLines(d, run.runId))
+    io.out(l);
+  return 0;
+}
+function decidedAnswerLines(d, runId) {
+  const out = [];
+  if (!d)
+    out.push("runtime.yaml's decide.questions is propose: each proposal waits on its question for a person to accept or answer otherwise.");
+  if (d?.paused)
+    out.push(`Deciding is paused: ${d.paused}`);
+  if (d?.applied.length) {
+    out.push(`Detected by AI: ${d.applied.length} answer${d.applied.length === 1 ? "" : "s"} applied in batch ${d.batch} (by AI, run ${runId}):`);
+    for (const a of d.applied)
+      out.push(`  ${a.id}: option ${a.option} (${a.bar})`);
+    out.push(`Correct one with atticus questions correct <id> --option <n> | --none; undo them all with atticus questions undo ${d.batch}.`);
+  }
+  for (const k of d?.kept ?? [])
+    out.push(`  kept as a proposal: ${k.id} (${k.why})`);
+  return out;
+}
+
+export {
+  DECIDE_AGENTS,
+  PROPOSE_CHANGE,
+  matchChangeOf,
+  sha256,
+  startDecideRun,
+  findDecideRun,
+  openDecideRun,
+  openMatchRun,
+  finishDecideRun,
+  decideRunDone,
+  proposedSince,
+  decidedAnswerLines
+};

package/dist/chunk-3TD6S4TC.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 {
+  AUDIT_WORDS,
+  answerAudit,
+  auditCommand,
+  auditLines,
+  defaultAuditSeed,
+  precisionOf,
+  prepareAudit,
+  tallyWords,
+  writeAudit
+} from "./chunk-7FUIVIBG.js";
+import "./chunk-LN77DXBM.js";
+import "./chunk-L4CESDPB.js";
+import "./chunk-U3NBK4EU.js";
+import "./chunk-455SYIIE.js";
+import "./chunk-GIFMBCTW.js";
+import "./chunk-MD7KUEJ3.js";
+import "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
+import "./chunk-3AQ2R5NL.js";
+import "./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-API5TOUB.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+export {
+  AUDIT_WORDS,
+  answerAudit,
+  auditCommand,
+  auditLines,
+  defaultAuditSeed,
+  precisionOf,
+  prepareAudit,
+  tallyWords,
+  writeAudit
+};

package/dist/{chunk-3C7EYRFZ.js → chunk-3UTYPHN3.js}

@@ -10,7 +10,7 @@ function draftCheckTool(root, request) {
   if (!request.selfCheck || !/^(feature|architecture|stories|small)-answer\.yaml$/.test(request.outputPath))
     return void 0;
   let box;
-  const planner = () => box ??= import("./chunk-UNM6ZOKP.js").then((p) => p.draftCheckBox(root, request));
+  const planner = () => box ??= import("./chunk-NTAVOWYD.js").then((p) => p.draftCheckBox(root, request));
   return {
     definitions: [
       {

package/dist/{chunk-G2B4ZQGH.js → chunk-3WON4G3M.js}

@@ -8,11 +8,11 @@ import {
   changesDirOf,
   orgPackDirOf,
   require_dist
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-PAINMSID.js";
 import {
   ensureLocalIgnore,
   redactText
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-S3QNRWYR.js → chunk-42EPP7OB.js}

@@ -6,18 +6,18 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   aliasCommand,
   reconcileCommand
-} from "./chunk-R6XF6UR3.js";
-import "./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";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-YZDZOEV4.js";
+import "./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 "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 export {
   aliasCommand,

package/dist/chunk-455SYIIE.js

@@ -0,0 +1,113 @@
+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-JYMIB5XY.js";
+import {
+  estimateTokens,
+  neutralise,
+  wrapData
+} from "./chunk-QHJJMZLX.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
+};