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

package/dist/chunk-JBSD57N7.js

@@ -0,0 +1,324 @@
+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 {
+  contextFlags,
+  contextLines
+} from "./chunk-R6RY4Q5T.js";
+import {
+  runDesignBench
+} from "./chunk-NELU7LSL.js";
+import "./chunk-7A7IG7OA.js";
+import "./chunk-Z46OXTBE.js";
+import "./chunk-XKJRPVJO.js";
+import "./chunk-PQW7PYUR.js";
+import "./chunk-SKMHS4CL.js";
+import {
+  TARGET_DIR,
+  architectureStage,
+  checkStageDraft,
+  featureStage,
+  formatDraftProblems,
+  smallStage,
+  stageEnd,
+  stageGate,
+  storiesStage
+} from "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import {
+  gateStatus,
+  ownerWaitsLine
+} from "./chunk-T6ESD5KM.js";
+import {
+  changeFolder,
+  loadChangeContext
+} from "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XNRPCI23.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import {
+  RuntimeConfigError,
+  runtimeForCli
+} from "./chunk-BKFGGJKA.js";
+import {
+  changesRelOf,
+  orgPackDirOf
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/stage-commands.js
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var str = (v) => typeof v === "string" && v.trim() ? v : void 0;
+async function runtimeOf(root, mode, io) {
+  try {
+    return (await runtimeForCli(root, mode ? { mode } : {})).runtime;
+  } catch (e) {
+    if (e instanceof RuntimeConfigError) {
+      io.err(e.message);
+      return void 0;
+    }
+    throw e;
+  }
+}
+var NAMES = {
+  feature: "feature",
+  architecture: "architecture",
+  stories: "stories",
+  small: "fast path"
+};
+async function stageCheck(root, change, stage, file, io) {
+  const stages = ["feature", "architecture", "stories", "small"];
+  if (!change || !stage || !file || !stages.includes(stage)) {
+    io.err(`Usage: atticus stage check <change> <${stages.join("|")}> <file>, for example: atticus stage check add-fraud-check architecture .runs/add-fraud-check/<run>/architecture-answer.yaml`);
+    return 2;
+  }
+  const text = await readFile(resolve(root, file), "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`${file} doesn't exist: write the draft there first.`);
+    return 2;
+  }
+  try {
+    const problems = await checkStageDraft(root, change, stage, text);
+    io.out(formatDraftProblems(problems));
+    return problems.length ? 1 : 0;
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+var WORDS = {
+  feature: "feature placement",
+  architecture: "target flows",
+  stories: "stories",
+  small: "plan"
+};
+function wroteLines(r) {
+  if (!r.files.length)
+    return [];
+  if (!r.changed)
+    return [`Wrote ${r.files.join(", ")}.`];
+  if (!r.changed.length)
+    return [`Kept ${r.byPerson ? "your" : "the"} ${WORDS[r.stage]}: nothing changed.`];
+  const kept = r.files.filter((f) => !r.changed.includes(f));
+  return [
+    `Wrote ${r.changed.join(", ")}${kept.length ? ` (${kept.join(", ")} ${kept.length === 1 ? "is" : "are"} as it was)` : ""}.`.replace(/are as it was\)/, "are as they were)")
+  ];
+}
+async function ownerLine(root, r) {
+  if (r.state !== "done")
+    return void 0;
+  const gate = stageGate(await loadChangeContext(root), r.stage);
+  if (!gate)
+    return void 0;
+  const s = await gateStatus(root, r.change, gate).catch(() => void 0);
+  return s ? ownerWaitsLine(s, r.change) : void 0;
+}
+function printStage(r, rerun, io, extra = [], owner) {
+  for (const n of r.notes)
+    io.out(n);
+  for (const l of contextLines(r.context))
+    io.out(l);
+  const current = r.findings.filter((f) => f.blocking && !f.question);
+  if (r.state === "waiting") {
+    if (current.length) {
+      io.out(`The last draft went back to your assistant with ${plural(current.length, "finding")}:`);
+      for (const f of current)
+        io.out(`  ${f.message}`);
+    }
+    const w = r.waiting;
+    io.report?.({ handoff: { runId: w.runId, ...w.lens ? { lens: w.lens } : {} } });
+    io.out(w.lens ? `Handed the critic's ${w.lens} lens to your assistant to review the ${NAMES[r.stage]} draft (run ${w.runId}). When it is done, run: atticus handoff done ${w.runId}, then ${rerun} --resume ${w.runId}` : `Handed the ${NAMES[r.stage]} draft to your assistant (run ${w.runId}). When it is done, run: atticus handoff done ${w.runId}, then ${rerun} --resume ${w.runId}`);
+    return 1;
+  }
+  if (r.state === "questions") {
+    for (const l of stageEnd(r, rerun))
+      io.out(l);
+    return 1;
+  }
+  io.out(
+    // B-place: a run that resumes the last draft's review, or finds nothing to draft, drafts none.
+    `The ${NAMES[r.stage]} stage is done after ${plural(r.iteration, "draft")} (${r.drafts ? `${plural(r.drafts, "draft")} this run` : "none drafted this run"}): nothing blocking is open and no question is waiting.`
+  );
+  if (owner)
+    io.out(owner);
+  for (const l of wroteLines(r))
+    io.out(l);
+  for (const l of extra)
+    io.out(l);
+  io.out(`Open the stage's pull request for a person to approve: ${r.pr}`);
+  return 0;
+}
+async function stageCli(root, positionals, values, io, deps = {}) {
+  const [group, command, arg] = positionals;
+  const json = values.json === true;
+  const isStage = group === "change" && (command === "feature" || command === "architecture" || command === "small") || group === "plan" && command === "stories" && !!arg && existsSync(join(changeFolder(root, arg), TARGET_DIR));
+  if (group === "bench" && command === "design")
+    return benchDesign(root, values, io, deps);
+  if (!isStage)
+    return void 0;
+  if (!arg) {
+    io.err(`change ${command} needs a change id, for example: atticus change ${command} add-fraud-check`);
+    return 2;
+  }
+  const flags = contextFlags(values);
+  if ("error" in flags) {
+    io.err(flags.error);
+    return 2;
+  }
+  const runtime = deps.runtime ?? await runtimeOf(root, str(values.mode), io);
+  if (!runtime)
+    return 2;
+  const o = {
+    context: flags.context,
+    runtime,
+    ...deps.criticRuntime !== void 0 ? { criticRuntime: deps.criticRuntime } : {},
+    ...deps.now ? { now: deps.now } : {},
+    ...str(values.resume) ? { resume: str(values.resume) } : {},
+    ...values.force === true ? { force: true } : {}
+  };
+  try {
+    if (command === "feature") {
+      const figma = str(values["from-figma"]);
+      const r2 = await featureStage(root, arg, {
+        ...o,
+        ...figma ? { fromFigma: resolve(figma) } : {}
+      });
+      if (json)
+        return out(io, r2);
+      const a = r2.answer;
+      const extra = a ? [
+        `Touches ${plural(a.features.length, "feature")} and ${plural(a.flows.length, "flow")}; needs ${plural(a.newFlows.length, "new flow")}; ${plural(a.gaps.length, "gap")}; ${plural(a.conflicts.length, "other change")} in flight on the same flows or systems.`,
+        `Next: atticus change architecture ${arg} (or /atticus-architecture ${arg}) once the feature PR is merged.`
+      ] : [];
+      return printStage(r2, `atticus change feature ${arg}`, io, extra, await ownerLine(root, r2));
+    }
+    if (command === "architecture") {
+      const r2 = await architectureStage(root, arg, o);
+      if (json)
+        return out(io, r2);
+      const extra = r2.answer ? [
+        `Target flows: ${r2.answer.flows.map((d) => `${d.flow} (${d.change}, ${plural(d.steps.length, "step")})`).join(", ")}, in ${changesRelOf(root)}/${arg}/${TARGET_DIR}/.`,
+        `Next: atticus plan stories ${arg} (or /atticus-stories ${arg}) once the architecture PR is merged.`
+      ] : [];
+      return printStage(r2, `atticus change architecture ${arg}`, io, extra, await ownerLine(root, r2));
+    }
+    if (command === "small") {
+      const r2 = await smallStage(root, arg, o);
+      if (json)
+        return out(io, r2);
+      const tasks2 = r2.stories.reduce((n, s) => n + s.tasks.length, 0);
+      const extra = r2.answer ? [
+        `Placed on ${plural(r2.answer.flows.length, "flow")}; ${plural(r2.answer.targetFlows.length, "target flow")}; ${r2.stories.length} ${r2.stories.length === 1 ? "story" : "stories"} and ${plural(tasks2, "task")}, from the target flows; ${r2.requests.length} ${r2.requests.length === 1 ? "request or process" : "requests and processes"} suggested in requests.md. A person raises each one.`,
+        `Next: once the pull request is merged, the tasks (atticus task context ${arg} <task>, or /atticus-task ${arg} <task>).`
+      ] : [];
+      return printStage(r2, `atticus change small ${arg}`, io, extra, await ownerLine(root, r2));
+    }
+    const r = await storiesStage(root, arg, o);
+    if (json)
+      return out(io, r);
+    const tasks = r.stories.reduce((n, s) => n + s.tasks.length, 0);
+    return printStage(r, `atticus plan stories ${arg}`, io, [
+      `${r.stories.length} ${r.stories.length === 1 ? "story" : "stories"} and ${plural(tasks, "task")} in ${plural(new Set(r.stories.map((s) => s.repo)).size, "repo")}, from the target flows; ${r.requests.length} ${r.requests.length === 1 ? "request or process" : "requests and processes"} suggested from the knowledge items, in requests.md. A person raises each one.`
+    ], await ownerLine(root, r));
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError", "ChangeFileError", "RuntimeConfigError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+function out(io, r) {
+  io.out(JSON.stringify(r, null, 2));
+  return r.state === "done" ? 0 : 1;
+}
+var defaultCache = () => process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "atticus", "bench") : join(homedir(), ".cache", "atticus", "bench");
+var pct = (x) => `${Math.round(x * 100)}%`;
+function printDesignScore(s, io) {
+  io.out(`Screens: ${s.screens.found} of ${s.screens.of} found${s.screens.missed.length ? ` (missed: ${s.screens.missed.join(", ")})` : ""}`);
+  io.out(`Fields: ${s.fields.found} of ${s.fields.of} found; precision ${pct(s.fields.precision)}, recall ${pct(s.fields.recall)}${s.fields.extra.length ? `; ${s.fields.extra.length} not in the reference` : ""}`);
+  io.out(`Backing: ${s.backing.correct} of ${s.backing.of} found fields classified right`);
+  for (const w of s.backing.wrong)
+    io.out(`  ${w.figmaId} "${w.label}": ${w.why}`);
+  io.out(`Actions: ${s.actions.found} of ${s.actions.of} found, ${s.actions.mapped} mapped right`);
+  for (const w of s.actions.wrong)
+    io.out(`  ${w.figmaId} "${w.label}": ${w.why}`);
+  io.out(`Gaps: ${s.gaps.found} of ${s.gaps.of} flagged; precision ${pct(s.gaps.precision)} of ${s.gaps.flagged} flagged`);
+  for (const g of s.gaps.missed)
+    io.out(`  missed: ${g}`);
+}
+async function benchDesign(root, values, io, deps) {
+  const bench = resolve(str(values.bench) ?? "bench");
+  if (!existsSync(join(bench, "design", "reference.yaml"))) {
+    io.err(`There is no design bench at ${join(bench, "design")}: run this from the Atticus repo, or give --bench <dir>.`);
+    return 2;
+  }
+  const cache = resolve(str(values.cache) ?? defaultCache());
+  const work = join(cache, "design");
+  const stateFile = join(work, "bench-state.json");
+  const resume = str(values.resume);
+  if (resume) {
+    const state = JSON.parse(await readFile(stateFile, "utf8").catch(() => "{}") || "{}");
+    if (state.runId !== resume) {
+      io.err(`${resume} isn't the run the design bench is waiting for${state.runId ? ` (it waits for ${state.runId})` : ""}.`);
+      return 2;
+    }
+  } else {
+    await mkdir(join(work, "org-pack"), { recursive: true });
+    await copyFile(join(orgPackDirOf(root), "runtime.yaml"), join(work, "org-pack", "runtime.yaml")).catch(() => {
+    });
+  }
+  const runtime = deps.runtime ?? await runtimeOf(work, str(values.mode), io);
+  if (!runtime)
+    return 2;
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const r = await runDesignBench({ bench, runtime, now, ...resume ? { resume } : {} });
+  if (r.status === "waiting") {
+    await writeFile(stateFile, `${JSON.stringify({ runId: r.runId })}
+`, "utf8");
+    io.out(`Handed the design to your assistant (run ${r.runId}, in ${work}). When it is done: atticus handoff done ${r.runId} --root ${JSON.stringify(work)}, then atticus bench design --resume ${r.runId}`);
+    return 0;
+  }
+  const results = join(cache, "design-results");
+  await mkdir(results, { recursive: true });
+  const stamp = now.toISOString().replace(/\.\d{3}Z$/, "Z");
+  const file = join(results, `${stamp.replace(/[:.]/g, "-")}.json`);
+  await writeFile(file, `${JSON.stringify({ at: stamp, ...r }, null, 2)}
+`, "utf8");
+  await writeFile(stateFile, "{}\n", "utf8").catch(() => {
+  });
+  if (values.json === true) {
+    io.out(JSON.stringify(r.score, null, 2));
+    return 0;
+  }
+  io.out(`Design bench: ${join(bench, "design")} (${r.read.screens} screens, ${r.read.candidates} fields and actions read; ${plural(r.drafts, "draft")})`);
+  printDesignScore(r.score, io);
+  if (r.problems.length)
+    io.out(`The last draft still had ${plural(r.problems.length, "problem")} the checks found; they are in the results file.`);
+  io.out(`Details: ${file}`);
+  return 0;
+}
+export {
+  printDesignScore,
+  stageCheck,
+  stageCli,
+  wroteLines
+};

package/dist/chunk-JEUXCIRD.js

@@ -0,0 +1,120 @@
+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 {
+  loadCatalog
+} from "./chunk-BUWSOQLU.js";
+import {
+  TARGET_DIR,
+  mergeDelta,
+  readDeltas
+} from "./chunk-EV4TEFOD.js";
+import {
+  changeStore
+} from "./chunk-3LU6YCSQ.js";
+import {
+  changeView,
+  toDrawio,
+  toMermaid
+} from "./chunk-XPWSNKF3.js";
+import {
+  changesDirOf,
+  changesRelOf,
+  readRepoSpec,
+  specRepos
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/change-map.js
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+async function targetFlowsOf(root, change) {
+  const dir = join(changesDirOf(root), change);
+  if (!await stat(join(dir, "change.yaml")).catch(() => void 0))
+    return void 0;
+  const title = await changeStore(root).read(change).then((c) => c.title).catch(() => change);
+  const { deltas, problems } = await readDeltas(dir);
+  const repos = new Set(await specRepos(root));
+  const specs = /* @__PURE__ */ new Map();
+  const merged = [];
+  for (const d of deltas) {
+    if (repos.has(d.repo) && !specs.has(d.repo))
+      specs.set(d.repo, await readRepoSpec(root, d.repo, { cacheRoot: root }));
+    const m = mergeDelta(d, specs.get(d.repo)?.flows.find((f) => f.id === d.flow));
+    problems.push(...m.problems);
+    merged.push(m);
+  }
+  const { records } = await loadCatalog(root, { out: () => void 0, err: () => void 0 });
+  const known = /* @__PURE__ */ new Set();
+  for (const repo of repos) {
+    const spec = specs.get(repo) ?? await readRepoSpec(root, repo, { cacheRoot: root });
+    for (const f of spec.flows)
+      known.add(f.component);
+  }
+  return {
+    title,
+    source: `${changesRelOf(root)}/${change}/${TARGET_DIR}`,
+    merged,
+    deltas,
+    problems,
+    records,
+    known
+  };
+}
+async function changeMapOf(root, change) {
+  const t = await targetFlowsOf(root, change);
+  if (!t)
+    return void 0;
+  return {
+    view: changeView(t.records, { id: change, title: t.title, source: t.source }, t.merged, t.known),
+    title: t.title,
+    source: t.source,
+    flows: t.merged.length,
+    problems: t.problems
+  };
+}
+function changeMapBody(change, m) {
+  return {
+    change,
+    title: m.title,
+    source: m.source,
+    groups: m.view.groups,
+    nodes: m.view.nodes,
+    edges: m.view.edges,
+    mermaid: toMermaid(m.view),
+    flows: m.flows,
+    problems: m.problems
+  };
+}
+async function changeMapCommand(root, change, o, io) {
+  const format = o.format ?? "mermaid";
+  if (format !== "mermaid" && format !== "drawio") {
+    io.err(`Unknown format "${format}": use mermaid or drawio.`);
+    return 2;
+  }
+  const m = await changeMapOf(root, change);
+  if (!m) {
+    io.err(`There is no change ${change}.`);
+    return 2;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(changeMapBody(change, m), null, 2));
+    return 0;
+  }
+  for (const p of m.problems)
+    io.err(p);
+  if (!m.flows) {
+    io.err(`${change} has no target flows yet, so there is nothing to draw: the architecture stage writes them (atticus change architecture ${change}).`);
+    return 1;
+  }
+  io.out((format === "drawio" ? toDrawio(m.view) : toMermaid(m.view)).replace(/\n$/, ""));
+  return 0;
+}
+
+export {
+  targetFlowsOf,
+  changeMapOf,
+  changeMapBody,
+  changeMapCommand
+};