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

package/dist/chunk-R77KLRB3.js

@@ -0,0 +1,166 @@
+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 {
+  ADOPTED_FILE,
+  ATTICUS_DIR,
+  ATTICUS_FOLDER_IGNORE,
+  AdoptError,
+  CHECKLISTS_README,
+  MockRepoListing,
+  NOT_TRANSLATABLE,
+  ORG_PACK_DIR,
+  REPO_TYPES,
+  SNAPSHOT_FILE,
+  STARTER_CHECKLISTS_README,
+  STATE_FOLDERS,
+  UNASSIGNED,
+  WALK_SKIP,
+  absorb,
+  acceptAbsorbed,
+  adopt,
+  bodyKey,
+  changeTemplateFrom,
+  checkZeroInstall,
+  copyDir,
+  detect,
+  detectRepoType,
+  exists,
+  federatedChanges,
+  federatedSources,
+  federationConflicts,
+  frontMatter,
+  hashTree,
+  inPlacePath,
+  init,
+  isDir,
+  isLocalState,
+  listDirs,
+  listFiles,
+  markdownItems,
+  openSource,
+  openSpecFrom,
+  orgPackDirOf,
+  packFor,
+  parseConstitution,
+  pathsFor,
+  promptToCommand,
+  readLayout,
+  readText,
+  reference,
+  referencedPaths,
+  refreshAbsorbed,
+  refreshAllAbsorbed,
+  renderZeroInstall,
+  reposDiscover,
+  resolveMetarepo,
+  schemaKind,
+  schemaReference,
+  sha256,
+  slug,
+  summarise,
+  takeSnapshot,
+  toPosix,
+  toSkill,
+  translateCriticItem,
+  typeFromDescription,
+  typeFromFrameworks,
+  typespecOutline,
+  typespecReference,
+  unadopt,
+  writeNew,
+  writeStartingPack,
+  yamlItems,
+  zeroInstallFiles
+} from "./chunk-GDLULHTC.js";
+import "./chunk-IPKHE5D6.js";
+import "./chunk-3HI6Z55Y.js";
+import "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.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";
+import "./chunk-TV45EUGM.js";
+export {
+  ADOPTED_FILE,
+  ATTICUS_DIR,
+  ATTICUS_FOLDER_IGNORE,
+  AdoptError,
+  CHECKLISTS_README,
+  MockRepoListing,
+  NOT_TRANSLATABLE,
+  ORG_PACK_DIR,
+  REPO_TYPES,
+  SNAPSHOT_FILE,
+  STARTER_CHECKLISTS_README,
+  STATE_FOLDERS,
+  UNASSIGNED,
+  WALK_SKIP,
+  absorb,
+  acceptAbsorbed,
+  adopt,
+  bodyKey,
+  changeTemplateFrom,
+  checkZeroInstall,
+  copyDir,
+  detect,
+  detectRepoType,
+  exists,
+  federatedChanges,
+  federatedSources,
+  federationConflicts,
+  frontMatter,
+  hashTree,
+  inPlacePath,
+  init,
+  isDir,
+  isLocalState,
+  listDirs,
+  listFiles,
+  markdownItems,
+  openSource,
+  openSpecFrom,
+  orgPackDirOf,
+  packFor,
+  parseConstitution,
+  pathsFor,
+  promptToCommand,
+  readLayout,
+  readText,
+  reference,
+  referencedPaths,
+  refreshAbsorbed,
+  refreshAllAbsorbed,
+  renderZeroInstall,
+  reposDiscover,
+  resolveMetarepo,
+  schemaKind,
+  schemaReference,
+  sha256,
+  slug,
+  summarise,
+  takeSnapshot,
+  toPosix,
+  toSkill,
+  translateCriticItem,
+  typeFromDescription,
+  typeFromFrameworks,
+  typespecOutline,
+  typespecReference,
+  unadopt,
+  writeNew,
+  writeStartingPack,
+  yamlItems,
+  zeroInstallFiles
+};

package/dist/chunk-RRTKKSLQ.js

@@ -0,0 +1,251 @@
+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 {
+  isCritic
+} from "./chunk-4Q3NN7VF.js";
+import {
+  lensRunOf
+} from "./chunk-3HI6Z55Y.js";
+import {
+  CONTEXT_TOOLS
+} from "./chunk-T6AIP7H5.js";
+import {
+  HandoffRuntime,
+  TOOL_LIMITS,
+  modelEnvOf,
+  stepClassOf
+} from "./chunk-CNUKCS2T.js";
+import {
+  changesRelOf,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  runsDirOf,
+  runsRelOf,
+  stepModelsOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/handoff-flag.js
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var isStage = (group, command) => group === "change" && (command === "feature" || command === "architecture" || command === "small") || group === "plan" && command === "stories";
+async function runStates(root) {
+  const out = /* @__PURE__ */ new Map();
+  const dir = runsDirOf(root);
+  for (const change of await readdir(dir).catch(() => []))
+    for (const id of await readdir(join(dir, change)).catch(() => [])) {
+      const text = await readFile(join(dir, change, id, "run.json"), "utf8").catch(() => "");
+      if (!text)
+        continue;
+      try {
+        const run = JSON.parse(text);
+        out.set(`${change}/${id}`, { key: `${run.state}:${run.attempt}`, run });
+      } catch {
+      }
+    }
+  return out;
+}
+var OWN_MODES = /* @__PURE__ */ new Set(["model", "headless-claude-code"]);
+function modeOf(argv) {
+  const at = argv.findIndex((a) => a === "--mode" || a.startsWith("--mode="));
+  if (at < 0)
+    return "hand-off";
+  const m = argv[at].includes("=") ? argv[at].split("=")[1] : argv[at + 1] ?? "";
+  return OWN_MODES.has(m) ? m : "hand-off";
+}
+function stepArgs(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--handoff" || a === "--json")
+      continue;
+    if (a === "--mode" || a === "--resume") {
+      i++;
+      continue;
+    }
+    if (a.startsWith("--mode=") || a.startsWith("--resume=") || a.startsWith("--handoff="))
+      continue;
+    out.push(a);
+  }
+  return out;
+}
+var shell = (a) => /^[\w./:@=+-]+$/.test(a) ? a : a.includes('"') ? JSON.stringify(a) : `"${a}"`;
+async function handoffStep(root, argv, io, dispatch) {
+  const args = stepArgs(argv);
+  const resumeAt = argv.findIndex((a) => a === "--resume" || a.startsWith("--resume="));
+  const resume = resumeAt < 0 ? [] : argv[resumeAt].includes("=") ? [argv[resumeAt]] : argv.slice(resumeAt, resumeAt + 2);
+  const json = argv.includes("--json");
+  const before = await runStates(root);
+  const asked = json ? await openQuestions(root) : /* @__PURE__ */ new Map();
+  const out = [];
+  const err = [];
+  const facts = [];
+  let code;
+  try {
+    code = await dispatch([...args, ...resume, "--mode", modeOf(argv)], {
+      out: (l) => out.push(l),
+      err: (l) => err.push(l),
+      report: (f) => facts.push(f)
+    });
+  } catch (e) {
+    if (!json)
+      throw e;
+    err.push(e.message.split("\n")[0]);
+    code = 3;
+  }
+  const after = await runStates(root);
+  const byStart = (a, b) => a.startedAt.localeCompare(b.startedAt) || a.runId.localeCompare(b.runId);
+  const critic = isCritic(args[0], args[1]);
+  const stage = isStage(args[0], args[1]);
+  const queue = critic || stage;
+  const changeArg = critic ? args[1] : stage ? args[2] : void 0;
+  const ofChange = (x) => !changeArg || changeArg.startsWith("-") || x.request.change === changeArg;
+  const waiting = [...after].filter(([path, s]) => s.run.state === "waiting" && before.get(path)?.key !== s.key).map(([, s]) => s.run).filter(ofChange).sort(byStart);
+  const resumed = resume.length ? resume.join("=").split("=").at(-1) : void 0;
+  const resumedRun = [...after.values()].find((s) => s.run.runId === resumed)?.run;
+  const named = facts.map((f) => "handoff" in f ? f.handoff.runId : void 0).filter((x) => !!x).at(-1);
+  const namedRun = named ? [...after.values()].find((s) => s.run.runId === named)?.run : void 0;
+  const still = resumedRun && (resumedRun.state === "waiting" || resumedRun.state === "failed" && namedRun?.runId === resumedRun.runId) ? resumedRun : void 0;
+  const next = queue && resumedRun && !still ? [...after.values()].map((s) => s.run).filter((x) => x.state === "waiting" && x.runId !== resumedRun.runId && x.request.change === resumedRun.request.change && x.startedAt >= resumedRun.startedAt && (critic || !!lensRunOf(x.request))).sort(byStart)[0] : void 0;
+  const waitedOn = !resume.length && namedRun && before.get(`${namedRun.request.change}/${namedRun.runId}`) ? namedRun : void 0;
+  const offered = namedRun && ["waiting", "failed"].includes(namedRun.state) ? namedRun : void 0;
+  const run = offered ?? (queue ? waiting[0] : waiting.at(-1)) ?? still ?? next ?? waitedOn ?? void 0;
+  const pagesLeft = facts.map((f) => "pagesLeft" in f ? f.pagesLeft : void 0).filter((x) => x !== void 0).at(-1);
+  const stillOffered = !!run && (run === still || run === waitedOn);
+  if (json)
+    return printJson(root, argv, args, {
+      run,
+      still: stillOffered,
+      code,
+      out,
+      err,
+      asked,
+      ...pagesLeft !== void 0 ? { pagesLeft } : {}
+    }, io);
+  if (!run) {
+    for (const l of out)
+      io.out(l);
+    for (const l of err)
+      io.err(l);
+    return code;
+  }
+  for (const l of err)
+    io.err(l);
+  if (stillOffered)
+    io.out(`Run ${run.runId} is still waiting for its result file.`);
+  const runsRel = runsRelOf(root);
+  io.out(`Prompt: ${HandoffRuntime.promptRel(run, runsRel)}`);
+  io.out(`Result file: ${HandoffRuntime.outputRel(run, changesRelOf(root), runsRel)}`);
+  const expects = await expectedModel(root, run, process.env);
+  if (expects)
+    io.out(expectedLine(expects));
+  io.out("When the result file is written, run:");
+  io.out(`  atticus handoff done ${run.runId}${rootArg(argv)}`);
+  io.out(`  atticus ${[...args, "--handoff", "--resume", run.runId].map(shell).join(" ")}`);
+  return 0;
+}
+async function openQuestions(root) {
+  const r = await listQuestions(root, { state: "open" });
+  return new Map(r.questions.map((q) => [q.id, `${q.askedBy.at}:${q.alsoAskedBy?.length ?? 0}:${q.rerun}`]));
+}
+var questionOut = (q) => ({
+  id: q.id,
+  repo: q.repo,
+  question: q.question,
+  options: q.options,
+  evidence: q.evidence,
+  answer: `atticus questions answer ${q.id}`
+});
+async function printJson(root, argv, args, s, io) {
+  const { run } = s;
+  if (run) {
+    const runsRel = runsRelOf(root);
+    const doneArgs = ["handoff", "done", run.runId, ...rootArgv(argv)];
+    const resumeArgs = [...args, "--handoff", "--json", "--resume", run.runId];
+    const lens = lensRunOf(run.request);
+    const stepClass = run.stepClass ?? stepClassOf(run.request);
+    const orgModel = (await orgModels(root))[stepClass];
+    io.out(JSON.stringify({
+      state: "handoff",
+      runId: run.runId,
+      // ADR 0115: one of the critic's AI lenses, reviewing what the step wrote.
+      ...lens ? { lens } : {},
+      stepClass,
+      ...orgModel ? { orgModel } : {},
+      root,
+      ...s.still ? { stillWaiting: true } : {},
+      promptFile: HandoffRuntime.promptRel(run, runsRel),
+      resultFile: HandoffRuntime.outputRel(run, changesRelOf(root), runsRel),
+      doneCommand: `atticus ${doneArgs.map(shell).join(" ")}`,
+      doneArgs,
+      resumeCommand: `atticus ${resumeArgs.map(shell).join(" ")}`,
+      resumeArgs,
+      // ADR 0107 addendum: the read-only tools the model may call. A tool call runs as
+      // atticus <callArgs> <tool> --input <json> --round <n> --json <runArgs>, kept in the run.
+      tools: {
+        definitions: CONTEXT_TOOLS,
+        limits: TOOL_LIMITS,
+        callArgs: ["context", "call"],
+        runArgs: ["--run", run.runId, ...rootArgv(argv)]
+      },
+      messages: s.out,
+      // ADR 0115 addendum (2026-10-26): what the step said was wrong with an answer it read,
+      // so a tool that runs the loop shows it instead of re-sending the same prompt silently.
+      ...s.err.length ? { errors: s.err } : {}
+    }, null, 2));
+    return 0;
+  }
+  const text = [...s.out, ...s.err].join("\n");
+  const open = (await listQuestions(root, { state: "open" })).questions;
+  const questions = open.filter((q) => {
+    const was = s.asked.get(q.id);
+    return was === void 0 || was !== `${q.askedBy.at}:${q.alsoAskedBy?.length ?? 0}:${q.rerun}` || text.includes(q.id);
+  });
+  const state = questions.length ? "question" : s.code === 0 ? "done" : s.code === 1 ? "stopped" : "failed";
+  io.out(JSON.stringify({
+    state,
+    exitCode: s.code,
+    root,
+    messages: s.out,
+    errors: s.err,
+    questions: questions.map(questionOut),
+    // A batched scan's pages left for the next batch, as data (never read from its words).
+    ...s.pagesLeft !== void 0 ? { pagesLeft: s.pagesLeft } : {}
+  }, null, 2));
+  return s.code;
+}
+async function orgModels(root) {
+  return stepModelsOf(await loadOrgPack(orgPackDirOf(root)).then((op) => op.runtime).catch(() => void 0));
+}
+async function expectedModel(root, run, env) {
+  const stepClass = run.stepClass ?? stepClassOf(run.request);
+  const set = env[modelEnvOf(stepClass)]?.trim();
+  if (set && set !== "atticus")
+    return { stepClass, model: set, from: "setting" };
+  const org = (await orgModels(root))[stepClass];
+  return org ? { stepClass, model: org, from: "runtime.yaml" } : void 0;
+}
+var expectedLine = (e) => `Model: this is a ${e.stepClass} step, which runs on ${e.model} (${e.from === "setting" ? "your setting" : `runtime.yaml models.${e.stepClass}`}). Pick it in your assistant's model picker before you send the prompt.`;
+function rootArgv(argv) {
+  const i = argv.indexOf("--root");
+  if (i >= 0 && argv[i + 1])
+    return ["--root", argv[i + 1]];
+  const eq = argv.find((a) => a.startsWith("--root="));
+  return eq ? [eq] : [];
+}
+function rootArg(argv) {
+  const i = argv.indexOf("--root");
+  if (i >= 0 && argv[i + 1])
+    return ` --root ${shell(argv[i + 1])}`;
+  const eq = argv.find((a) => a.startsWith("--root="));
+  return eq ? ` ${shell(eq)}` : "";
+}
+
+export {
+  handoffStep,
+  expectedModel,
+  expectedLine
+};

package/dist/chunk-RTEYOSJY.js

@@ -0,0 +1,29 @@
+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 {
+  buildDigest,
+  digestCommand
+} from "./chunk-7WD63HU2.js";
+import "./chunk-3HI6Z55Y.js";
+import "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.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";
+import "./chunk-TV45EUGM.js";
+export {
+  buildDigest,
+  digestCommand
+};