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

package/dist/chunk-4ONORLK5.js

@@ -0,0 +1,234 @@
+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 {
+  BUILT_IN_GATES,
+  BUILT_IN_TEMPLATES,
+  CAPTURE_SCHEMA_VERSION,
+  CHANGES_DIR,
+  CHANGE_FILE,
+  CHANGE_POLICY_FILE,
+  CODEOWNERS_PATHS,
+  ChangeError,
+  ChangeFileError,
+  ChangePolicy,
+  DEFAULT_CHANGE_POLICY,
+  DraftCapture,
+  LEARN_SCHEMA_VERSION,
+  SIGNAL_FACTORS,
+  StageStep,
+  TEMPLATE_VARIABLES,
+  TREND_MIN,
+  TREND_STEP,
+  TemplateMeta,
+  archiveChange,
+  artifactFiles,
+  artifactPhase,
+  assess,
+  canAdvance,
+  captureHandoff,
+  capturePaths,
+  captureStageOf,
+  changeFilePath,
+  changeFolder,
+  changeFootprint,
+  changeReport,
+  changeSize,
+  changeStore,
+  changeTypeOf,
+  checkArtifacts,
+  checkFindings,
+  checkMandatoryRounds,
+  checkStage,
+  completeCaptures,
+  countLines,
+  detectConflicts,
+  draftedPath,
+  formatLearn,
+  gitHandoffPublisher,
+  handoff,
+  handoffName,
+  hunksOf,
+  isFilled,
+  learnFromPairs,
+  learnReport,
+  lineDiff,
+  liveHandoff,
+  loadChangeContext,
+  loadChangePolicy,
+  loadTemplates,
+  mandatoryGates,
+  measurePair,
+  metarepoOrigin,
+  newChange,
+  nextState,
+  openspecStores,
+  outsideKindOf,
+  outsideSystemsOf,
+  outsideWords,
+  ownersFor,
+  pairTouches,
+  parseCodeowners,
+  pastCorrections,
+  personalLevels,
+  phaseArtifacts,
+  phaseFindingGates,
+  phaseGates,
+  phaseStage,
+  phaseState,
+  pickTemplate,
+  prApprovers,
+  privacyImpact,
+  readCodeowners,
+  readDraftPairs,
+  readStory,
+  readTables,
+  referenceMetarepoIn,
+  renderTemplate,
+  requireValid,
+  requiredArtifacts,
+  returnToPo,
+  scoreRisk,
+  serializeChange,
+  sha256,
+  slugify,
+  stageCommand,
+  stageCompletion,
+  stageFiles,
+  stagePathOf,
+  statePhase,
+  storeDirOf,
+  storeSpecLookup,
+  syncHandoff,
+  tableWith,
+  testPlanFor,
+  testsFor,
+  trendOf,
+  wordsOf,
+  workProgress
+} 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-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import {
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  BUILT_IN_GATES,
+  BUILT_IN_TEMPLATES,
+  CAPTURE_SCHEMA_VERSION,
+  CHANGES_DIR,
+  CHANGE_FILE,
+  CHANGE_POLICY_FILE,
+  CODEOWNERS_PATHS,
+  ChangeError,
+  ChangeFileError,
+  ChangePolicy,
+  DEFAULT_CHANGE_POLICY,
+  DraftCapture,
+  LEARN_SCHEMA_VERSION,
+  SIGNAL_FACTORS,
+  StageStep,
+  TEMPLATE_VARIABLES,
+  TREND_MIN,
+  TREND_STEP,
+  TemplateMeta,
+  archiveChange,
+  artifactFiles,
+  artifactPhase,
+  assess,
+  canAdvance,
+  captureHandoff,
+  capturePaths,
+  captureStageOf,
+  changeFilePath,
+  changeFolder,
+  changeFootprint,
+  changeReport,
+  changeSize,
+  changeStore,
+  changeTypeOf,
+  checkArtifacts,
+  checkFindings,
+  checkMandatoryRounds,
+  checkStage,
+  completeCaptures,
+  countLines,
+  detectConflicts,
+  draftedPath,
+  formatLearn,
+  gitHandoffPublisher,
+  handoff,
+  handoffName,
+  hunksOf,
+  isFilled,
+  learnFromPairs,
+  learnReport,
+  lineDiff,
+  liveHandoff,
+  loadChangeContext,
+  loadChangePolicy,
+  loadTemplates,
+  mandatoryGates,
+  measurePair,
+  metarepoOrigin,
+  newChange,
+  nextState,
+  openspecStores,
+  outsideKindOf,
+  outsideSystemsOf,
+  outsideWords,
+  ownersFor,
+  pairTouches,
+  parseCodeowners,
+  pastCorrections,
+  personalLevels,
+  phaseArtifacts,
+  phaseFindingGates,
+  phaseGates,
+  phaseStage,
+  phaseState,
+  pickTemplate,
+  prApprovers,
+  privacyImpact,
+  readCodeowners,
+  readDraftPairs,
+  readStory,
+  readTables,
+  referenceMetarepoIn,
+  renderTemplate,
+  requireValid,
+  requiredArtifacts,
+  returnToPo,
+  scoreRisk,
+  serializeChange,
+  sha256,
+  slugify,
+  stageCommand,
+  stageCompletion,
+  stageFiles,
+  stagePathOf,
+  statePhase,
+  storeDirOf,
+  storeSpecLookup,
+  syncHandoff,
+  tableWith,
+  testPlanFor,
+  testsFor,
+  trendOf,
+  wordsOf,
+  workProgress,
+  writeFileAtomic
+};

package/dist/chunk-4Q3NN7VF.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));
+
+// packages/cli/dist/handoff-steps.js
+var STEPS = /* @__PURE__ */ new Set([
+  "scan survey",
+  "scan verify",
+  "spec draft",
+  "knowledge scan",
+  // ADR 0087: the feature and architecture stages (plan stories already takes it).
+  "change feature",
+  "change architecture",
+  // ADR 0113: the fast path's one step.
+  "change small",
+  "change draft",
+  "plan stories",
+  // ADR 0101: what a change needs from the organisation.
+  "change needs",
+  "knowledge find",
+  "knowledge ask"
+]);
+var isHandoffStep = (group, command) => STEPS.has(`${group ?? ""} ${command ?? ""}`) || isCritic(group, command) || // ADR 0124 §4: atticus map <repo>, the batched read, one batch per hand-off.
+group === "map" && !!command && !command.startsWith("-");
+var isCritic = (group, command) => group === "critic" && !!command && command !== "stats";
+
+export {
+  isHandoffStep,
+  isCritic
+};

package/dist/chunk-4SKZDI62.js

@@ -0,0 +1,22 @@
+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 {
+  distance,
+  flagNames,
+  nearest,
+  nearestCommand,
+  unknownFlagMessages,
+  unknownFlags
+} from "./chunk-7EFILTCI.js";
+import "./chunk-TV45EUGM.js";
+export {
+  distance,
+  flagNames,
+  nearest,
+  nearestCommand,
+  unknownFlagMessages,
+  unknownFlags
+};

package/dist/chunk-4URR24DD.js

@@ -0,0 +1,189 @@
+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 {
+  askHosts
+} from "./chunk-XR5DD5DQ.js";
+import {
+  driftAfterScan
+} from "./chunk-EI4KQYJ3.js";
+import {
+  diffCatalogs,
+  diffIsEmpty,
+  readCatalog,
+  scanEstate,
+  writeCatalog
+} from "./chunk-IILZ7J3L.js";
+import {
+  loadRepos
+} from "./chunk-XZJE6WIT.js";
+import {
+  catalogDirOf
+} from "./chunk-JMOLB347.js";
+import {
+  LockHeldError,
+  acquireLock
+} from "./chunk-MMB2OHUY.js";
+
+// packages/cli/dist/scan-commands.js
+import { join } from "node:path";
+function diffLines(d) {
+  if (diffIsEmpty(d))
+    return ["No catalog changes."];
+  const lines = [
+    `${d.added.length} added, ${d.removed.length} removed, ${d.changed.length} changed, ${d.evidenceOnly.length} with new evidence only`,
+    ...d.added.map((r) => `+ ${r.kind}/${r.id}`),
+    ...d.removed.map((r) => `- ${r.kind}/${r.id}`),
+    ...d.changed.map((r) => `~ ${r.kind}/${r.id} (${r.fields.join(", ")})`)
+  ];
+  return lines;
+}
+function driftLine(d) {
+  const head = `Drift check for ${d.change} (${d.state})`;
+  if (d.error)
+    return `${head} couldn't run: ${d.error}`;
+  if (d.round === void 0)
+    return `${head}: no drift.`;
+  const what = `${d.open} open finding${d.open === 1 ? "" : "s"}${d.blocking ? ` (${d.blocking} blocking)` : ""}`;
+  return `${head}: ${what} in review/drift/${d.round}${d.unchanged ? ", nothing new" : ""}.`;
+}
+async function scanCommand(root, o, io) {
+  if (o.repos && o.repos.length > 0) {
+    const known = new Set((await loadRepos(root)).map((r) => r.id));
+    const unknown = o.repos.filter((r) => !known.has(r));
+    if (unknown.length > 0) {
+      io.err(`Not in any repos.manifest.yaml: ${unknown.join(", ")}`);
+      return 2;
+    }
+  }
+  let lock;
+  if (!o.dryRun) {
+    try {
+      lock = await acquireLock(root, "scan", "scan");
+    } catch (e) {
+      if (e instanceof LockHeldError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+    if (lock.interrupted)
+      io.err(`The last scan (started ${lock.interrupted.startedAt}) stopped before it finished; this one brings the catalog up to date.`);
+  }
+  try {
+    if (o.ref) {
+      const { scanBranch } = await import("./chunk-KU4T2CXJ.js");
+      return await scanBranch(root, o.ref, {
+        ...o.repos ? { repos: o.repos } : {},
+        ...o.full ? { full: true } : {},
+        ...o.json ? { json: true } : {}
+      }, io);
+    }
+    return await scanLocked(root, o, io);
+  } finally {
+    await lock?.release();
+  }
+}
+async function scanLocked(root, o, io) {
+  const out = join(catalogDirOf(root), "generated");
+  const before = await readCatalog(out, { cacheRoot: root });
+  const started = Date.now();
+  const scan = await scanEstate({
+    root,
+    ...o.repos ? { repos: o.repos } : {},
+    ...o.full ? { cache: null } : {}
+  });
+  const diff = diffCatalogs(before.records, scan.records);
+  const write = o.dryRun ? void 0 : await writeCatalog(out, scan.records);
+  const drift = write && !o.noDrift ? await driftAfterScan(root) : [];
+  const hosts = write ? await askHosts(root, scan.records, { command: "atticus scan" }) : { raised: [], open: [], lines: [] };
+  const problems = [
+    ...before.problems.map((p) => ({ source: `catalog/generated/${p.file}`, message: p.message })),
+    ...scan.problems
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const warnings = scan.repos.flatMap((r) => r.warnings.map((w) => ({ repo: r.repo, ...w })).filter((w) => {
+    const k = `${w.repo}\0${w.path ?? ""}\0${w.message}`;
+    if (seen.has(k))
+      return false;
+    seen.add(k);
+    return true;
+  }));
+  if (o.json) {
+    io.out(JSON.stringify({
+      stats: scan.stats,
+      diff,
+      problems,
+      warnings,
+      coverage: scan.coverage,
+      unmodelled: scan.unmodelled,
+      notes: scan.notes,
+      written: write !== void 0,
+      files: write ?? null,
+      drift,
+      questions: [...hosts.raised, ...hosts.open].map((q) => q.id)
+    }, null, 2));
+  } else {
+    const s = scan.stats;
+    io.out(`Scanned ${s.repos} repos in ${((Date.now() - started) / 1e3).toFixed(1)}s (${s.ranRuns} extractor runs, ${s.cachedRuns} from cache)`);
+    io.out(`${s.records} records: ${s.interfaces} interfaces (${s.verified} verified), ${s.unresolved} loose ends`);
+    const joined = scan.coverage.reduce((n, c) => n + c.joined, 0);
+    const found = joined + scan.coverage.reduce((n, c) => n + c.open, 0);
+    const unread = scan.coverage.reduce((n, c) => n + c.unreadFiles, 0);
+    io.out(`Joined ${joined} of ${found} calls, listeners and endpoints found (${found ? Math.round(joined / found * 100) : 100}%)` + (unread ? `; ${unread} file${unread === 1 ? " uses" : "s use"} a client library with nothing read (atticus scan --warnings)` : ""));
+    for (const c of scan.coverage)
+      for (const r of c.redraft)
+        io.out(`Rule ${r.dialect} on ${c.repo} ${r.why === "tests-fail" ? "fails its own tests, so this scan didn't use it" : "read nothing there"}; have your assistant re-draft it: atticus onboard ${c.repo} --name ${r.dialect} (then onboard accept ${r.dialect} --replace)`);
+    const toOnboard = scan.coverage.filter((c) => c.needsOnboarding);
+    if (toOnboard.length)
+      io.out(`Read nothing from ${toOnboard.length === 1 ? "1 repo" : `${toOnboard.length} repos`} whose files no reader knows: ${toOnboard.map((c) => `${c.repo} (${c.unreadConfig.length} file${c.unreadConfig.length === 1 ? "" : "s"})`).join(", ")}. Have your assistant draft a dialect: atticus onboard ${toOnboard[0].repo}`);
+    for (const f of scan.unmodelled)
+      io.out(`House framework ${f.framework} is imported by ${f.repos.length} repos and no framework model covers it: ${f.repos.join(", ")}. Onboard it: atticus onboard framework ${f.name} --from <its source, JAR or package> --users ${f.repos.join(",")}`);
+    const idle = /* @__PURE__ */ new Map();
+    for (const c of scan.coverage)
+      for (const r of c.redraftFrameworks)
+        idle.set(r.framework, [...idle.get(r.framework) ?? [], c.repo]);
+    for (const [framework, repos] of idle)
+      io.out(`Framework model ${framework} read nothing in ${repos.join(", ")}, which import${repos.length === 1 ? "s" : ""} it; the framework may have changed. Have your assistant re-draft it: atticus onboard framework ${framework} --from <its source, JAR or package> --users ${repos.join(",")} (then onboard accept framework ${framework} --replace)`);
+    for (const l of diffLines(diff))
+      io.out(l);
+    if (write)
+      io.out(`catalog/generated: ${write.written} written, ${write.unchanged} unchanged, ${write.removed} removed`);
+    else
+      io.out("Dry run: nothing written.");
+    for (const d of drift)
+      io.out(driftLine(d));
+    for (const l of hosts.lines)
+      io.out(l);
+    for (const n of scan.notes)
+      io.out(`note: ${n}`);
+    if (o.warnings)
+      for (const w of warnings)
+        io.out(`warning: ${w.repo}: ${w.path ? `${w.path}: ` : ""}${w.message}`);
+    else if (warnings.length)
+      io.out(`${warnings.length} warning${warnings.length === 1 ? "" : "s"}: atticus scan --warnings lists ${warnings.length === 1 ? "it" : "them"}`);
+    for (const p of problems)
+      io.err(`${"repo" in p && p.repo ? `${p.repo}: ` : ""}${p.source}: ${p.message}`);
+  }
+  return problems.length > 0 ? 1 : 0;
+}
+async function catalogDiff(a, b, json, io) {
+  const [x, y] = await Promise.all([readCatalog(a), readCatalog(b)]);
+  for (const p of [...x.problems, ...y.problems])
+    io.err(`${p.file}: ${p.message}`);
+  const d = diffCatalogs(x.records, y.records);
+  if (json)
+    io.out(JSON.stringify(d, null, 2));
+  else
+    for (const l of diffLines(d))
+      io.out(l);
+  return diffIsEmpty(d) && x.problems.length + y.problems.length === 0 ? 0 : 1;
+}
+
+export {
+  diffLines,
+  scanCommand,
+  catalogDiff
+};

package/dist/chunk-4UZJOQYK.js

@@ -0,0 +1,70 @@
+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 {
+  acceptOrgPackDraft,
+  draftOrgPack
+} from "./chunk-TEBBD4XH.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/orgpack-draft-commands.js
+async function orgPackDraftCli(root, command, arg, values, io) {
+  const str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+  const json = values.json === true;
+  try {
+    if (command === "draft") {
+      const d = await draftOrgPack(root, {
+        ...str(values.platform) ? { platform: str(values.platform) } : {}
+      });
+      if (json) {
+        io.out(JSON.stringify(d, null, 2));
+        return 0;
+      }
+      if (!d.proposals.length) {
+        io.out(`The ${d.platform} profile already has every system the knowledge items name.`);
+        return 0;
+      }
+      io.out(`${d.proposals.length} system${d.proposals.length === 1 ? "" : "s"} for the ${d.platform} profile, from the knowledge items:`);
+      for (const p of d.proposals)
+        io.out(`  ${p.action === "add" ? "add   " : "update"} ${p.system.id}: ${p.system.name}${p.action === "add" ? ` (${p.system.boundary}${p.system.owner ? `, ${p.system.owner}` : ""})` : ` gains ${[p.adds?.aliases?.length ? `aliases ${p.adds.aliases.join(", ")}` : "", p.adds?.owner ? `owner ${p.adds.owner}` : ""].filter(Boolean).join(" and ")}`}${p.verified ? " \u2713" : ""}`);
+      if (d.proposals.some((p) => p.verified))
+        io.out("\u2713 a person verified the knowledge item it comes from");
+      io.out(`Written to ${d.file} and ${d.file.replace(/\.yaml$/, ".md")}. Accept them with atticus orgpack accept ${d.platform} [--only id,id] [--verified-only].`);
+      return 0;
+    }
+    if (!arg) {
+      io.err("Usage: atticus orgpack accept <platform> [--only id,id] [--verified-only] [--dry-run]");
+      return 2;
+    }
+    const only = str(values.only)?.split(",").map((x) => x.trim()).filter(Boolean);
+    const r = await acceptOrgPackDraft(root, arg, {
+      ...only ? { only } : {},
+      ...values["verified-only"] === true ? { verifiedOnly: true } : {},
+      ...values["dry-run"] === true ? { dryRun: true } : {}
+    });
+    if (json) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    const would = values["dry-run"] === true;
+    io.out(`${would ? "Would add" : "Added"} ${r.added.length ? r.added.join(", ") : "no system"} and ${would ? "would update" : "updated"} ${r.updated.length ? r.updated.join(", ") : "none"} in ${r.file}; ${r.left} left in the draft.`);
+    if (!would && (r.added.length || r.updated.length))
+      io.out("Commit profile.yaml through a pull request: merging it is the approval.");
+    return 0;
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+}
+export {
+  orgPackDraftCli
+};

package/dist/chunk-4Y4FY34K.js

@@ -0,0 +1,34 @@
+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 {
+  catalogDiff,
+  diffLines,
+  scanCommand
+} from "./chunk-4URR24DD.js";
+import "./chunk-XR5DD5DQ.js";
+import "./chunk-EI4KQYJ3.js";
+import "./chunk-6RGIM2ZH.js";
+import "./chunk-T6ESD5KM.js";
+import "./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-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  catalogDiff,
+  diffLines,
+  scanCommand
+};

package/dist/chunk-4YWRU7JK.js

@@ -0,0 +1,80 @@
+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 {
+  readMe,
+  writeMe
+} from "./chunk-ORZSD2KD.js";
+import {
+  changeStore
+} 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-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/watch-commands.js
+async function watchLine(root, change) {
+  const { cockpit } = await import("./chunk-27EDZN52.js");
+  try {
+    const c = await cockpit(root, change);
+    const parts = [
+      `in ${c.state}`,
+      ...c.reasons.length ? [`${c.reasons.length} thing${c.reasons.length === 1 ? "" : "s"} block it`] : [],
+      ...c.openQuestions ? [`${c.openQuestions} question${c.openQuestions === 1 ? "" : "s"} wait`] : []
+    ];
+    return `${change}: ${parts.join("; ")}. Next: ${c.nextStep}`;
+  } catch {
+    return `${change}: no longer there (archived or removed); atticus watch ${change} --off stops watching it.`;
+  }
+}
+async function watchCommand(root, change, o, io) {
+  const me = await readMe(root);
+  if (!change) {
+    if (o.off) {
+      io.err("Say which change to stop watching: atticus watch <change> --off");
+      return 2;
+    }
+    const lines = [];
+    for (const c of me.watch)
+      lines.push(await watchLine(root, c));
+    if (o.json)
+      io.out(JSON.stringify({ watching: me.watch, lines }, null, 2));
+    else if (!lines.length)
+      io.out("You watch no change. atticus watch <change> starts.");
+    else
+      for (const l of lines)
+        io.out(l);
+    return 0;
+  }
+  if (o.off) {
+    await writeMe(root, { ...me, watch: me.watch.filter((c) => c !== change) });
+    io.out(`You no longer watch ${change}.`);
+    return 0;
+  }
+  const known = await changeStore(root).read(change).then(() => true, () => false);
+  if (!known) {
+    io.err(`There is no change ${change}: atticus change list shows them.`);
+    return 1;
+  }
+  await writeMe(root, { ...me, watch: [...me.watch, change] });
+  io.out(`You watch ${change}: your digest and atticus watch say how it is doing.`);
+  io.out(await watchLine(root, change));
+  return 0;
+}
+export {
+  watchCommand,
+  watchLine
+};