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

package/dist/chunk-BMCKL3VQ.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-AWECWW5Y.js";
+import "./chunk-5YIBJXGB.js";
+import "./chunk-UYYN2IUZ.js";
+import "./chunk-Y5PZHS4K.js";
+import "./chunk-7YYEKTYF.js";
+import "./chunk-XEG3FE2R.js";
+import {
+  TARGET_DIR,
+  architectureStage,
+  checkStageDraft,
+  featureStage,
+  formatDraftProblems,
+  smallStage,
+  stageEnd,
+  stageGate,
+  storiesStage
+} from "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import {
+  gateStatus,
+  ownerWaitsLine
+} from "./chunk-47QE246J.js";
+import {
+  changeFolder,
+  loadChangeContext
+} from "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import {
+  RuntimeConfigError,
+  runtimeForCli
+} from "./chunk-5XDNUJ4P.js";
+import {
+  changesRelOf,
+  orgPackDirOf
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.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-BMHGA7WD.js

@@ -0,0 +1,25 @@
+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 {
+  aliasCommand,
+  reconcileCommand
+} from "./chunk-F7UQR4ZX.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  aliasCommand,
+  reconcileCommand
+};

package/dist/chunk-BUYJL3GJ.js

@@ -0,0 +1,287 @@
+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 {
+  aliasArgv,
+  isLegacy
+} from "./chunk-4SVJNVEE.js";
+import {
+  isHandoffStep
+} from "./chunk-4Q3NN7VF.js";
+
+// packages/cli/dist/command-catalog.js
+var AREAS = [
+  { id: "start", title: "Set up and keep healthy" },
+  { id: "repos", title: "Repos, scans and specs" },
+  { id: "knowledge", title: "Knowledge and documents" },
+  { id: "catalog", title: "The catalog" },
+  { id: "changes", title: "Changes, findings and questions" },
+  { id: "plan", title: "Plans, tasks and work items" },
+  { id: "release", title: "Release" },
+  { id: "developer", title: "For Atticus's own quality" }
+];
+var AREA_BY_WORD = {
+  init: "start",
+  adopt: "start",
+  unadopt: "start",
+  setup: "start",
+  doctor: "start",
+  probe: "start",
+  secret: "start",
+  upgrade: "start",
+  support: "start",
+  sandbox: "start",
+  learn: "start",
+  explain: "start",
+  executors: "start",
+  openspec: "start",
+  "assistant-files": "start",
+  ui: "start",
+  mcp: "start",
+  index: "start",
+  schema: "start",
+  orgpack: "start",
+  templates: "start",
+  commands: "start",
+  legacy: "start",
+  next: "changes",
+  scan: "repos",
+  verify: "repos",
+  join: "repos",
+  map: "repos",
+  spec: "repos",
+  estate: "repos",
+  "repo-type": "repos",
+  repo: "repos",
+  repos: "repos",
+  workspace: "repos",
+  frameworks: "repos",
+  dialect: "repos",
+  onboard: "repos",
+  baseline: "repos",
+  drift: "repos",
+  stub: "repos",
+  ci: "repos",
+  sources: "knowledge",
+  standards: "knowledge",
+  knowledge: "knowledge",
+  patterns: "knowledge",
+  absorb: "knowledge",
+  intake: "knowledge",
+  triage: "knowledge",
+  glossary: "knowledge",
+  domain: "knowledge",
+  catalog: "catalog",
+  query: "catalog",
+  context: "catalog",
+  cites: "catalog",
+  impact: "catalog",
+  ask: "catalog",
+  guide: "catalog",
+  diagram: "catalog",
+  reconcile: "catalog",
+  coverage: "catalog",
+  feature: "catalog",
+  alias: "catalog",
+  site: "catalog",
+  digest: "changes",
+  change: "changes",
+  finding: "changes",
+  findings: "changes",
+  stage: "changes",
+  critic: "changes",
+  handoff: "changes",
+  questions: "changes",
+  plan: "plan",
+  task: "plan",
+  stories: "plan",
+  todo: "plan",
+  needs: "changes",
+  waiting: "changes",
+  watch: "changes",
+  runs: "changes",
+  history: "changes",
+  ado: "plan",
+  tests: "plan",
+  trace: "plan",
+  initiative: "plan",
+  outcome: "plan",
+  release: "release",
+  bench: "developer",
+  eval: "developer",
+  defences: "developer",
+  plugin: "developer",
+  conformance: "developer"
+};
+var AREA_BY_ID = {
+  "spec hand-down": "changes",
+  "spec hand-up": "changes",
+  "ci archive-gate": "release"
+};
+var KIND_BY_NAME = {
+  repo: "repo",
+  repos: "repo",
+  change: "change",
+  flow: "flow",
+  system: "system",
+  file: "path",
+  files: "path",
+  dir: "path",
+  path: "path",
+  a: "path",
+  b: "path"
+};
+var KIND_BY_COMMAND = {
+  "questions answer": ["question"],
+  "change status": ["change"],
+  "change handoff": ["change"],
+  "change sync": ["change"],
+  "change return": ["change"],
+  "change archive": ["change"],
+  finding: ["change", "finding"],
+  findings: ["change"],
+  impact: ["record"],
+  drift: ["change"],
+  trace: ["change"]
+};
+var SERVES = /* @__PURE__ */ new Set(["ui", "stub serve", "mcp"]);
+var APPROVE_FLAGS = ["--approve", "--send"];
+var isWord = (t) => /^[a-z][a-z-]*$/.test(t);
+function parseArgs(id, usage) {
+  const out = [];
+  const kinds = KIND_BY_COMMAND[id];
+  const re = /(\[|"?<)([a-z][a-z|-]*?)(\.\.\.)?(>"?|\])(\.\.\.)?/g;
+  for (const m of usage.matchAll(re)) {
+    const before = usage.slice(0, m.index).trimEnd();
+    if (/--[a-z-]+$/.test(before) || /--[a-z-]+ ?\|?$/.test(before))
+      continue;
+    if (m[1] === "[" && !/^[a-z]+$/.test(m[2]))
+      continue;
+    const raw = m[2];
+    const parts = raw.split("|");
+    const isChoice = parts.length >= 3;
+    const name = isChoice ? "choice" : parts[0];
+    const kind = kinds?.[out.length] ?? (isChoice ? "choice" : KIND_BY_NAME[name] ?? "text");
+    out.push({
+      name,
+      kind,
+      optional: m[1] === "[",
+      many: !!(m[3] || m[5]),
+      ...isChoice ? { choices: parts } : {}
+    });
+  }
+  return out;
+}
+function parseFlags(text, summaries) {
+  const out = /* @__PURE__ */ new Map();
+  const re = /(--[a-z][a-z-]*)(?:[ =]("[^"]*"|<[^>]+>|[A-Za-z0-9][\w.,=-]*(?:\|[\w.-]+)*))?/g;
+  for (const m of text.matchAll(re)) {
+    const name = m[1];
+    if (out.has(name))
+      continue;
+    const before = text.slice(0, m.index);
+    const opened = (before.match(/\[/g) ?? []).length - (before.match(/\]/g) ?? []).length;
+    let value = m[2]?.replace(/^<|>$/g, "");
+    if (value?.startsWith("--") || value && /^[a-z]+$/.test(value) && !m[2].startsWith("<"))
+      value = /^(m|n|t|s|k|f|c|d|o|p|file|dir|id)$/.test(value) ? value : void 0;
+    const summary = summaries.get(name);
+    out.set(name, {
+      name,
+      ...value ? { value } : {},
+      // `<folder> | --org <org>`: the option is given instead of the argument, not as well.
+      required: opened <= 0 && !/(<[^>]+>|"[^"]*")\s*\|\s*$/.test(before),
+      ...summary ? { summary } : {}
+    });
+  }
+  return [...out.values()];
+}
+function parseHelp(help) {
+  const out = [];
+  let current;
+  const blocks = [];
+  for (const l of help.split("\n")) {
+    if (/^ {2}atticus /.test(l)) {
+      current = { line: l.trim(), more: [] };
+      blocks.push(current);
+    } else if (current && /^ {6,}\[?--|^ {6,}\(/.test(l))
+      current.more.push(l.trim());
+    else if (current && !current.more.length && current.below === void 0 && /^ {6,}\S/.test(l))
+      current.below = l.trim();
+    else if (!/^ {6,}/.test(l))
+      current = void 0;
+  }
+  for (const b of blocks) {
+    if (/^atticus (--help|--version|<step>)/.test(b.line))
+      continue;
+    const cut = b.line.search(/ {2,}/);
+    const usage = cut > 0 ? b.line.slice(0, cut) : b.line;
+    const written = cut > 0 ? b.line.slice(cut).trim() : b.below ?? "";
+    const summary = written.replace(/(\s*\[[^\]]*--[^\]]*\](\.\.\.)?)+\s*$/, "");
+    const tokens = usage.split(" ").slice(1);
+    const words = [];
+    for (const t of tokens) {
+      if (!isWord(t))
+        break;
+      words.push(t);
+    }
+    const id = words.join(" ");
+    const summaries = /* @__PURE__ */ new Map();
+    for (const m of b.more) {
+      const c = m.search(/ {2,}/);
+      const opt = c > 0 ? m.slice(0, c) : m;
+      const what = c > 0 ? m.slice(c).trim() : "";
+      for (const f of opt.matchAll(/--[a-z][a-z-]*/g))
+        if (what)
+          summaries.set(f[0], what);
+    }
+    const optionText = [
+      `${usage} `,
+      written,
+      // Each option line's option part only: its description may hold brackets of its own.
+      ...b.more.map((m) => {
+        const c = m.search(/ {2,}/);
+        return `[${(c > 0 ? m.slice(0, c) : m).replace(/^\[|\]$/g, "")}]`;
+      })
+    ].join(" ");
+    out.push({
+      id,
+      words,
+      usage,
+      summary,
+      args: parseArgs(id, usage.slice(`atticus ${id}`.length)),
+      flags: parseFlags(optionText, summaries)
+    });
+  }
+  return out;
+}
+function commandCatalog(help) {
+  const seen = /* @__PURE__ */ new Set();
+  return parseHelp(help).map((parsed) => {
+    let c = parsed;
+    if (seen.has(c.id)) {
+      const mark = c.flags.find((f) => f.required) ?? c.flags[0];
+      if (mark)
+        c = { ...c, id: `${c.id} ${mark.name}` };
+    }
+    seen.add(c.id);
+    const area = AREA_BY_ID[c.id] ?? AREA_BY_WORD[c.words[0] ?? ""] ?? "";
+    const approve = APPROVE_FLAGS.find((f) => c.flags.some((x) => x.name === f));
+    const [w0, w1] = aliasArgv(c.words, c.words.map((_, i) => i));
+    const runs = isHandoffStep(w0, w1) || c.id === "critic" || c.id === "map" ? "ai" : SERVES.has(c.id) ? "serve" : approve ? "shared" : "local";
+    return {
+      ...c,
+      area,
+      runs,
+      ...approve && runs === "shared" ? { approve } : {},
+      legacy: isLegacy(c.words[0])
+    };
+  });
+}
+
+export {
+  AREAS,
+  parseHelp,
+  commandCatalog
+};

package/dist/chunk-BXIX7S7O.js

@@ -0,0 +1,32 @@
+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 {
+  catalogRecords,
+  guideCommand,
+  openChanges,
+  siteBuildCommand
+} from "./chunk-DPHCFZ7W.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  catalogRecords,
+  guideCommand,
+  openChanges,
+  siteBuildCommand
+};

package/dist/chunk-CHC5FKTU.js

@@ -0,0 +1,26 @@
+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));
+
+// packages/cli/dist/version.js
+var VERSION = "2.0.0-beta.10";
+function versionAtLeast(v, min) {
+  const a = v.replace(/^v/, "").split(/[.+-]/).map(Number);
+  const b = min.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (Number.isNaN(x))
+      return false;
+    if (x !== y)
+      return x > y;
+  }
+  return true;
+}
+
+export {
+  VERSION,
+  versionAtLeast
+};