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

package/dist/chunk-VCTWPLAO.js

@@ -0,0 +1,211 @@
+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 {
+  claimRunDir,
+  makeRunId
+} from "./chunk-P32RUW3B.js";
+import {
+  runsDirOf,
+  runsRelOf
+} from "./chunk-Q2TECDIT.js";
+import {
+  writeFileAtomic
+} from "./chunk-TUULXQRW.js";
+
+// packages/cli/dist/decide-handoff.js
+import { createHash } from "node:crypto";
+import { readdir, readFile } 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();
+  const runId = await claimRunDir(join(runsDirOf(root), o.change), () => makeRunId(now));
+  const dir = runDir(root, o.change, runId);
+  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 matchOf = (from, to) => (r) => r.decide.kind === "links" && r.decide.from === from && (r.decide.to.repo ?? "") === (to.repo ?? "") && (r.decide.to.system ?? "") === (to.system ?? "");
+var openMatchRun = (root, from, to) => openDecideRun(root, matchChangeOf(from), matchOf(from, to));
+async function cancelOpenDecideRuns(root, change, why, o = {}) {
+  const out = [];
+  const ids = (await readdir(join(runsDirOf(root), change)).catch(() => [])).filter((n) => n.startsWith("run-"));
+  for (const id of ids.sort()) {
+    const r = await readRun(join(runsDirOf(root), change, id, "run.json"));
+    if (!r || !open(r) || o.pick && !o.pick(r))
+      continue;
+    out.push(await finishDecideRun(root, r, {
+      state: "cancelled",
+      errors: [why],
+      ...o.now ? { now: o.now } : {}
+    }));
+  }
+  return out;
+}
+var cancelMatchRuns = (root, from, to, why, now) => cancelOpenDecideRuns(root, matchChangeOf(from), why, {
+  pick: matchOf(from, to),
+  ...now ? { now } : {}
+});
+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-KN5BXMWN.js");
+  const { view, facts } = await candidatesOf(root, run.decide.from, run.decide.to);
+  const { matchDone, matchLines } = await import("./chunk-6H3Z5JHH.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-Q4K5WB2W.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-Q4K5WB2W.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-Q4K5WB2W.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,
+  cancelOpenDecideRuns,
+  cancelMatchRuns,
+  finishDecideRun,
+  decideRunDone,
+  proposedSince,
+  decidedAnswerLines
+};