@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.3

package/dist/chunk-RZUZ4RJJ.js

@@ -0,0 +1,415 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  CriticError,
+  act,
+  checkRoundRule,
+  completeLensRun,
+  gateStatus,
+  lensAnswerProblem,
+  lensRunOf,
+  overrideStats,
+  ownerWaitsLine,
+  proposalWords,
+  reviewedGates,
+  roundsUsed,
+  runCritic,
+  waitingLenses
+} from "./chunk-7UFQZXZA.js";
+import {
+  changeFolder,
+  changeStore,
+  loadChangeContext,
+  phaseStage,
+  stageCommand,
+  statePhase
+} from "./chunk-56YQ6ROQ.js";
+import {
+  AiOffError,
+  HandoffRuntime,
+  RuntimeConfigError,
+  runtimeForCli
+} from "./chunk-CNUKCS2T.js";
+import {
+  CriticQuestion,
+  LEGACY_LENSES,
+  Lens,
+  require_dist,
+  runsDirOf,
+  runsRelOf
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/critic-commands.js
+import { readFile as readFile2, stat } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+var import_yaml2 = __toESM(require_dist(), 1);
+
+// packages/cli/dist/handoff-yaml.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readFile } from "node:fs/promises";
+function yamlProblem(e, file, fenced) {
+  const err = e;
+  const first = err.message.split("\n")[0].replace(/ at line \d+, column \d+:?$/, "");
+  const pos = err.linePos?.[0];
+  const where2 = pos ? ` (line ${pos.line + (fenced ? 1 : 0)}, column ${pos.col})` : "";
+  return `${file} isn't YAML${where2}: ${first}. A value that holds a colon, a #, or a { } [ ] goes in double quotes.`;
+}
+async function yamlAnswerProblems(file, request) {
+  const raw = await readFile(file, "utf8").catch(() => void 0);
+  if (raw === void 0)
+    return [`${request.outputPath} can't be read`];
+  const stripped = raw.replace(/^```(?:ya?ml)?\s*\n|\n```\s*$/g, "");
+  try {
+    (0, import_yaml.parse)(stripped);
+  } catch (e) {
+    return [yamlProblem(e, request.outputPath, stripped !== raw)];
+  }
+  const why = lensRunOf(request) ? lensAnswerProblem(raw) : void 0;
+  return why ? [`${request.outputPath}: ${why}`] : [];
+}
+
+// packages/cli/dist/critic-commands.js
+function fail(io, e) {
+  if (e instanceof RuntimeConfigError) {
+    io.err(e.message);
+    return 2;
+  }
+  if (e instanceof CriticError) {
+    io.err(e.message);
+    return e.code === "invalid" || e.code === "no-gate" ? 2 : 1;
+  }
+  if (e instanceof Error && (e.name === "ChangeError" || e.name === "ChangeFileError")) {
+    io.err(e.message);
+    return 1;
+  }
+  throw e;
+}
+var where = (artifact, line) => line ? `${artifact}:${line}` : artifact;
+var plural = (n, one, many) => n === 1 ? `1 ${one}` : `${n} ${many}`;
+var capital = (t) => t.charAt(0).toUpperCase() + t.slice(1);
+function statusLine(s, change = "<change>") {
+  if (s.waiting.length)
+    return `The ${s.gate} gate is not decided: ${plural(s.waiting.length, "AI lens", "AI lenses")} ${s.waiting.length === 1 ? "is" : "are"} with your assistant. Run atticus handoff done <run> for each, then look at the findings again.`;
+  const counts = `${s.open.blocking} blocking, ${s.open.gaps} open gap${s.open.gaps === 1 ? "" : "s"}`;
+  if (s.mayProceed)
+    return s.checkRound ? `The ${s.gate} gate may proceed: nothing blocking is open. ${capital(roundsUsed(s))}, but ${checkRoundRule(s.round)} (atticus critic ${change} --gate ${s.gate}).` : `The ${s.gate} gate may proceed: nothing blocking is open.`;
+  const owner = ownerWaitsLine(s, change);
+  if (owner)
+    return owner;
+  if (s.humanDecides)
+    return `The ${s.gate} gate is closed (${counts}) and ${roundsUsed(s)}: a person decides now. Once a person acts on round ${s.round}'s findings, ${checkRoundRule(s.round)}.`;
+  return `The ${s.gate} gate is closed: ${counts}. Act on each with atticus finding <id> <action>.`;
+}
+async function runtimeOf(root, mode, deps) {
+  if (deps.runtime)
+    return deps.runtime;
+  const env = deps.env ?? process.env;
+  if (!mode)
+    return void 0;
+  try {
+    return (await runtimeForCli(root, { ...mode ? { mode } : {}, env })).runtime;
+  } catch (e) {
+    if (e instanceof AiOffError)
+      return void 0;
+    throw e;
+  }
+}
+async function stageRefused(root, changeId) {
+  const ctx = await loadChangeContext(root).catch(() => void 0);
+  const change = ctx ? await changeStore(root).read(changeId).catch(() => void 0) : void 0;
+  if (!ctx || !change)
+    return void 0;
+  const phase = statePhase(change.state);
+  if (!phase)
+    return void 0;
+  const step = await phaseStage(ctx, change, phase);
+  if (!step)
+    return void 0;
+  const text = await readFile2(join(changeFolder(root, change.id), ...step.loop.split("/")), "utf8").catch(() => void 0);
+  const state = text === void 0 ? void 0 : (0, import_yaml2.parse)(text)?.state;
+  if (state !== "stopped")
+    return void 0;
+  return `The ${step.stage} stage stopped on its own draft, which doesn't pass the stage's checks, so the critic doesn't review it: fix it and run ${stageCommand(step, change.id)}; the stage runs the gate's critic round once its draft passes.`;
+}
+async function critic(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus critic <change> [--gate <gate>] [--lens <lens>] [--mode <mode>] [--resume] [--json]");
+    return 2;
+  }
+  if (o.resume)
+    return resumeLenses(root, changeId, o, io, deps);
+  if (o.lens && !Lens.safeParse(o.lens).success) {
+    io.err(`Unknown lens ${o.lens}. Use one of: ${CriticQuestion.options.join(", ")} (an old lens name, ${LEGACY_LENSES.join(", ")}, asks the question that took it over).`);
+    return 2;
+  }
+  const refused = await stageRefused(root, changeId);
+  if (refused) {
+    io.err(refused);
+    return 1;
+  }
+  let r;
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    r = await runCritic(root, changeId, {
+      ...o.gate ? { gate: o.gate } : {},
+      ...o.lens ? { lenses: [Lens.parse(o.lens)] } : {},
+      ...runtime ? { runtime } : {},
+      ...deps.now ? { now: deps.now } : {},
+      ...deps.authorModel ? { authorModel: deps.authorModel } : {}
+    });
+  } catch (e) {
+    return fail(io, e);
+  }
+  if (o.json) {
+    io.out(JSON.stringify({
+      change: r.change,
+      gate: r.gate,
+      round: r.round,
+      mayProceed: r.status.mayProceed,
+      humanDecides: r.status.humanDecides,
+      checkRound: r.status.checkRound,
+      ...r.checkRound ? { pastLimit: true } : {},
+      open: r.status.open,
+      findings: r.findings.map((f) => ({
+        id: f.finding.id,
+        layer: f.layer,
+        kind: f.finding.kind,
+        severity: f.finding.severity,
+        rule: f.finding.rule,
+        lens: f.finding.lens,
+        artifact: f.finding.artifact,
+        ...f.finding.locator.line ? { line: f.finding.locator.line } : {},
+        summary: f.finding.summary,
+        state: f.finding.state,
+        path: f.path,
+        ...f.finding.question ? { question: f.finding.question } : {}
+      })),
+      lenses: r.lenses.map((l) => ({
+        lens: l.lens,
+        agent: l.agent,
+        state: l.state,
+        ...l.runId ? { runId: l.runId } : {},
+        ...l.reason ? { reason: l.reason } : {}
+      })),
+      skipped: r.rules.skipped,
+      refused: r.refused,
+      problems: r.problems,
+      discarded: r.discarded,
+      model: r.model
+    }, null, 2));
+    return r.status.mayProceed ? 0 : 1;
+  }
+  for (const p of r.problems)
+    io.err(p);
+  for (const x of r.refused)
+    io.err(`Refused ${x.file}${x.rule ? ` (rule ${x.rule})` : ""}: ${x.reason}`);
+  const s = r.status;
+  io.out(`Critic round ${r.round}${r.checkRound ? `, a checking round past the limit of ${s.maxRounds},` : s.maxRounds !== void 0 ? ` of ${s.maxRounds}` : ""} at the ${r.gate} gate for ${r.change}: ${s.total.blocking} blocking, ${s.total.gaps} gaps, ${s.total.risks} risks, ${s.total.ideas} ideas.`);
+  if (r.findings.length) {
+    for (const line of table(["SEVERITY", "LAYER", "ID", "WHERE", "SUMMARY"], r.findings.map((f) => [
+      f.finding.severity,
+      f.layer === "ai" ? "AI" : "checks",
+      f.finding.id,
+      where(f.finding.artifact, f.finding.locator.line),
+      f.carried ? `${f.finding.summary} (${f.finding.state} in the last round)` : f.finding.summary
+    ])))
+      io.out(line);
+  }
+  for (const l of r.lenses.filter((x) => x.state !== "ran"))
+    io.out(`${l.lens} lens ${l.state}: ${l.reason ?? ""}`.trimEnd());
+  if (r.discarded.length)
+    io.out(`Discarded ${r.discarded.length} AI finding${r.discarded.length > 1 ? "s" : ""} without valid evidence.`);
+  io.out(statusLine(s));
+  return s.mayProceed ? 0 : 1;
+}
+function printCompleted(c, io) {
+  const where2 = `The ${c.lens.lens} lens of round ${c.round} at the ${c.gate} gate`;
+  io.out(c.lens.state === "ran" ? `${where2} raised ${plural(c.findings.length, "finding", "findings")}.` : `${where2} ${c.lens.state}: ${c.lens.reason ?? ""}`.trimEnd());
+  for (const d of c.discarded)
+    io.err(`Discarded: ${d.reason}`);
+  if (c.lens.state === "ran" && c.lens.reason)
+    io.out(`  ${c.lens.reason}`);
+  if (c.waiting.length)
+    io.out(`${plural(c.waiting.length, "AI lens", "AI lenses")} ${c.waiting.length === 1 ? "is" : "are"} still with your assistant: ${c.waiting.map((w) => `${w.lens} (atticus handoff done ${w.runId})`).join(", ")}.`);
+  else
+    io.out(statusLine(c.status));
+  return c.waiting.length === 0;
+}
+async function completeCriticLens(root, run, io, o = {}) {
+  try {
+    const c = await completeLensRun(root, run, o.now ? { now: o.now } : {});
+    printCompleted(c, io);
+    return c.lens.state === "ran" ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function resumeLenses(root, changeId, o, io, deps) {
+  try {
+    await changeStore(root).read(changeId).catch((e) => {
+      throw new CriticError("not-found", e.message);
+    });
+    const gates = o.gate ? [o.gate] : await reviewedGates(root, changeId);
+    const rt = new HandoffRuntime({ root, validate: yamlAnswerProblems });
+    let any = false;
+    let statusPrinted = false;
+    for (const gate of gates) {
+      for (const w of await waitingLenses(root, changeId, gate)) {
+        any = true;
+        let run = await rt.result(w.runId);
+        const file = join(runsDirOf(root), changeId, w.runId, `findings-${w.lens}.yaml`);
+        const written = await stat(file).then(() => true, () => false);
+        if (written && run.state !== "validated")
+          run = await rt.done(w.runId);
+        if (run.state === "failed" && written) {
+          for (const e of run.errors)
+            io.err(e);
+          io.err(`${w.lens} lens: ${runsRelOf(root)}/${changeId}/${w.runId}/findings-${w.lens}.yaml needs fixing; run atticus handoff done ${w.runId} when it's fixed.`);
+        } else if (run.state === "validated") {
+          statusPrinted = printCompleted(await completeLensRun(root, run, deps.now ? { now: deps.now } : {}), io);
+        }
+      }
+    }
+    if (!any)
+      io.out(`No AI lens of ${o.gate ? `the ${o.gate} gate` : "this change"} is waiting for your assistant.`);
+    let mayProceed = false;
+    for (const gate of gates) {
+      const s = await gateStatus(root, changeId, gate);
+      if (!statusPrinted && (any || s.round !== void 0))
+        io.out(statusLine(s));
+      mayProceed = s.mayProceed && s.round !== void 0;
+    }
+    return mayProceed ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function findings(root, changeId, o, io) {
+  if (!changeId) {
+    io.err("Usage: atticus findings <change> [--json]");
+    return 2;
+  }
+  try {
+    await changeStore(root).read(changeId);
+  } catch (e) {
+    io.err(e.message);
+    return 1;
+  }
+  const statuses = [];
+  try {
+    for (const g of await reviewedGates(root, changeId))
+      statuses.push(await gateStatus(root, changeId, g));
+  } catch (e) {
+    return fail(io, e);
+  }
+  if (o.json) {
+    io.out(JSON.stringify(statuses.map((s) => ({
+      gate: s.gate,
+      round: s.round,
+      mayProceed: s.mayProceed,
+      humanDecides: s.humanDecides,
+      checkRound: s.checkRound,
+      open: s.open,
+      findings: s.findings.map((f) => ({
+        ...f.finding,
+        path: f.path,
+        // ADR 0115 addendum (2026-10-25): an assistant's proposal, waiting on a person.
+        ...f.proposal ? { proposal: f.proposal } : {}
+      }))
+    })), null, 2));
+    return 0;
+  }
+  if (statuses.length === 0) {
+    io.out(`No critic findings for ${changeId} yet. Run atticus critic ${changeId}.`);
+    return 0;
+  }
+  for (const s of statuses) {
+    io.out(`${s.gate} gate, round ${s.round ?? 0}:`);
+    for (const line of table(["SEVERITY", "STATE", "ID", "WHERE", "SUMMARY"], s.findings.map((f) => [
+      f.finding.severity,
+      f.proposal ? `open (${proposalWords(f.proposal)})` : f.finding.state,
+      f.finding.id,
+      where(f.finding.artifact, f.finding.locator.line),
+      f.finding.summary
+    ])))
+      io.out(`  ${line}`);
+    io.out(statusLine(s));
+  }
+  return 0;
+}
+async function findingAction(root, changeId, findingId, action, o, io, deps = {}) {
+  if (!changeId || !findingId || !action || !o.by) {
+    io.err("Usage: atticus finding <change> <finding> <apply|edit-and-apply|not-relevant|waive|ask> [--by <you>] [--gate <gate>] [--reason <why>] [--asked-of <who>] [--edit <patch file>]");
+    return 2;
+  }
+  let edit;
+  if (o.edit) {
+    try {
+      edit = await readFile2(isAbsolute(o.edit) ? o.edit : join(root, o.edit), "utf8");
+    } catch {
+      io.err(`Can't read the patch file ${o.edit}.`);
+      return 2;
+    }
+  }
+  try {
+    const r = await act(root, changeId, findingId, action, {
+      by: o.by,
+      ...o.reason ? { reason: o.reason } : {},
+      ...o.askedOf ? { askedOf: o.askedOf } : {},
+      ...edit ? { edit } : {},
+      ...o.gate ? { gate: o.gate } : {},
+      ...deps.now ? { now: deps.now } : {}
+    });
+    io.out(r.message);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function criticStats(root, o, io) {
+  const s = await overrideStats(root, o.threshold ? { threshold: o.threshold } : {});
+  if (o.json) {
+    io.out(JSON.stringify(s, null, 2));
+    return 0;
+  }
+  if (s.rules.length === 0) {
+    io.out("No critic findings yet.");
+    return 0;
+  }
+  io.out(`Override rates across ${s.changes} change${s.changes === 1 ? "" : "s"}:`);
+  for (const line of table(["RULE", "FINDINGS", "DISMISSED", "WAIVED", "OVERRIDDEN"], s.rules.map((r) => [
+    r.rule,
+    String(r.total),
+    String(r.dismissed),
+    String(r.waived),
+    `${Math.round(r.overrideRate * 100)}%`
+  ])))
+    io.out(line);
+  for (const g of s.suggestions) {
+    io.out("");
+    io.out(g.message);
+    if (g.patch)
+      for (const l of g.patch.trimEnd().split("\n"))
+        io.out(`  ${l}`);
+  }
+  return 0;
+}
+
+export {
+  yamlAnswerProblems,
+  statusLine,
+  critic,
+  completeCriticLens,
+  findings,
+  findingAction,
+  criticStats
+};