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

package/dist/chunk-6TJCUYC5.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 {
+  NoRoomError,
+  ceilingOf,
+  reExecForMemory,
+  roomGuard,
+  streamFacts
+} from "./chunk-7F2RUWPU.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  NoRoomError,
+  ceilingOf,
+  reExecForMemory,
+  roomGuard,
+  streamFacts
+};

package/dist/chunk-6VBXAGJX.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-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 {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.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-73VPWF5R.js

@@ -0,0 +1,415 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  CriticError,
+  act,
+  checkRoundRule,
+  completeLensRun,
+  gateStatus,
+  lensAnswerProblem,
+  lensRunOf,
+  overrideStats,
+  ownerWaitsLine,
+  proposalWords,
+  reviewedGates,
+  roundsUsed,
+  runCritic,
+  waitingLenses
+} from "./chunk-47QE246J.js";
+import {
+  changeFolder,
+  changeStore,
+  loadChangeContext,
+  phaseStage,
+  stageCommand,
+  statePhase
+} from "./chunk-XQ3YIV5R.js";
+import {
+  AiOffError,
+  HandoffRuntime,
+  RuntimeConfigError,
+  runtimeForCli
+} from "./chunk-5XDNUJ4P.js";
+import {
+  CriticQuestion,
+  LEGACY_LENSES,
+  Lens,
+  require_dist,
+  runsDirOf,
+  runsRelOf
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/critic-commands.js
+import { readFile as readFile2, stat } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+var import_yaml2 = __toESM(require_dist(), 1);
+
+// packages/cli/dist/handoff-yaml.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readFile } from "node:fs/promises";
+function yamlProblem(e, file, fenced) {
+  const err = e;
+  const first = err.message.split("\n")[0].replace(/ at line \d+, column \d+:?$/, "");
+  const pos = err.linePos?.[0];
+  const where2 = pos ? ` (line ${pos.line + (fenced ? 1 : 0)}, column ${pos.col})` : "";
+  return `${file} isn't YAML${where2}: ${first}. A value that holds a colon, a #, or a { } [ ] goes in double quotes.`;
+}
+async function yamlAnswerProblems(file, request) {
+  const raw = await readFile(file, "utf8").catch(() => void 0);
+  if (raw === void 0)
+    return [`${request.outputPath} can't be read`];
+  const stripped = raw.replace(/^```(?:ya?ml)?\s*\n|\n```\s*$/g, "");
+  try {
+    (0, import_yaml.parse)(stripped);
+  } catch (e) {
+    return [yamlProblem(e, request.outputPath, stripped !== raw)];
+  }
+  const why = lensRunOf(request) ? lensAnswerProblem(raw) : void 0;
+  return why ? [`${request.outputPath}: ${why}`] : [];
+}
+
+// packages/cli/dist/critic-commands.js
+function fail(io, e) {
+  if (e instanceof RuntimeConfigError) {
+    io.err(e.message);
+    return 2;
+  }
+  if (e instanceof CriticError) {
+    io.err(e.message);
+    return e.code === "invalid" || e.code === "no-gate" ? 2 : 1;
+  }
+  if (e instanceof Error && (e.name === "ChangeError" || e.name === "ChangeFileError")) {
+    io.err(e.message);
+    return 1;
+  }
+  throw e;
+}
+var where = (artifact, line) => line ? `${artifact}:${line}` : artifact;
+var plural = (n, one, many) => n === 1 ? `1 ${one}` : `${n} ${many}`;
+var capital = (t) => t.charAt(0).toUpperCase() + t.slice(1);
+function statusLine(s, change = "<change>") {
+  if (s.waiting.length)
+    return `The ${s.gate} gate is not decided: ${plural(s.waiting.length, "AI lens", "AI lenses")} ${s.waiting.length === 1 ? "is" : "are"} with your assistant. Run atticus handoff done <run> for each, then look at the findings again.`;
+  const counts = `${s.open.blocking} blocking, ${s.open.gaps} open gap${s.open.gaps === 1 ? "" : "s"}`;
+  if (s.mayProceed)
+    return s.checkRound ? `The ${s.gate} gate may proceed: nothing blocking is open. ${capital(roundsUsed(s))}, but ${checkRoundRule(s.round)} (atticus critic ${change} --gate ${s.gate}).` : `The ${s.gate} gate may proceed: nothing blocking is open.`;
+  const owner = ownerWaitsLine(s, change);
+  if (owner)
+    return owner;
+  if (s.humanDecides)
+    return `The ${s.gate} gate is closed (${counts}) and ${roundsUsed(s)}: a person decides now. Once a person acts on round ${s.round}'s findings, ${checkRoundRule(s.round)}.`;
+  return `The ${s.gate} gate is closed: ${counts}. Act on each with atticus finding <id> <action>.`;
+}
+async function runtimeOf(root, mode, deps) {
+  if (deps.runtime)
+    return deps.runtime;
+  const env = deps.env ?? process.env;
+  if (!mode)
+    return void 0;
+  try {
+    return (await runtimeForCli(root, { ...mode ? { mode } : {}, env })).runtime;
+  } catch (e) {
+    if (e instanceof AiOffError)
+      return void 0;
+    throw e;
+  }
+}
+async function stageRefused(root, changeId) {
+  const ctx = await loadChangeContext(root).catch(() => void 0);
+  const change = ctx ? await changeStore(root).read(changeId).catch(() => void 0) : void 0;
+  if (!ctx || !change)
+    return void 0;
+  const phase = statePhase(change.state);
+  if (!phase)
+    return void 0;
+  const step = await phaseStage(ctx, change, phase);
+  if (!step)
+    return void 0;
+  const text = await readFile2(join(changeFolder(root, change.id), ...step.loop.split("/")), "utf8").catch(() => void 0);
+  const state = text === void 0 ? void 0 : (0, import_yaml2.parse)(text)?.state;
+  if (state !== "stopped")
+    return void 0;
+  return `The ${step.stage} stage stopped on its own draft, which doesn't pass the stage's checks, so the critic doesn't review it: fix it and run ${stageCommand(step, change.id)}; the stage runs the gate's critic round once its draft passes.`;
+}
+async function critic(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus critic <change> [--gate <gate>] [--lens <lens>] [--mode <mode>] [--resume] [--json]");
+    return 2;
+  }
+  if (o.resume)
+    return resumeLenses(root, changeId, o, io, deps);
+  if (o.lens && !Lens.safeParse(o.lens).success) {
+    io.err(`Unknown lens ${o.lens}. Use one of: ${CriticQuestion.options.join(", ")} (an old lens name, ${LEGACY_LENSES.join(", ")}, asks the question that took it over).`);
+    return 2;
+  }
+  const refused = await stageRefused(root, changeId);
+  if (refused) {
+    io.err(refused);
+    return 1;
+  }
+  let r;
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    r = await runCritic(root, changeId, {
+      ...o.gate ? { gate: o.gate } : {},
+      ...o.lens ? { lenses: [Lens.parse(o.lens)] } : {},
+      ...runtime ? { runtime } : {},
+      ...deps.now ? { now: deps.now } : {},
+      ...deps.authorModel ? { authorModel: deps.authorModel } : {}
+    });
+  } catch (e) {
+    return fail(io, e);
+  }
+  if (o.json) {
+    io.out(JSON.stringify({
+      change: r.change,
+      gate: r.gate,
+      round: r.round,
+      mayProceed: r.status.mayProceed,
+      humanDecides: r.status.humanDecides,
+      checkRound: r.status.checkRound,
+      ...r.checkRound ? { pastLimit: true } : {},
+      open: r.status.open,
+      findings: r.findings.map((f) => ({
+        id: f.finding.id,
+        layer: f.layer,
+        kind: f.finding.kind,
+        severity: f.finding.severity,
+        rule: f.finding.rule,
+        lens: f.finding.lens,
+        artifact: f.finding.artifact,
+        ...f.finding.locator.line ? { line: f.finding.locator.line } : {},
+        summary: f.finding.summary,
+        state: f.finding.state,
+        path: f.path,
+        ...f.finding.question ? { question: f.finding.question } : {}
+      })),
+      lenses: r.lenses.map((l) => ({
+        lens: l.lens,
+        agent: l.agent,
+        state: l.state,
+        ...l.runId ? { runId: l.runId } : {},
+        ...l.reason ? { reason: l.reason } : {}
+      })),
+      skipped: r.rules.skipped,
+      refused: r.refused,
+      problems: r.problems,
+      discarded: r.discarded,
+      model: r.model
+    }, null, 2));
+    return r.status.mayProceed ? 0 : 1;
+  }
+  for (const p of r.problems)
+    io.err(p);
+  for (const x of r.refused)
+    io.err(`Refused ${x.file}${x.rule ? ` (rule ${x.rule})` : ""}: ${x.reason}`);
+  const s = r.status;
+  io.out(`Critic round ${r.round}${r.checkRound ? `, a checking round past the limit of ${s.maxRounds},` : s.maxRounds !== void 0 ? ` of ${s.maxRounds}` : ""} at the ${r.gate} gate for ${r.change}: ${s.total.blocking} blocking, ${s.total.gaps} gaps, ${s.total.risks} risks, ${s.total.ideas} ideas.`);
+  if (r.findings.length) {
+    for (const line of table(["SEVERITY", "LAYER", "ID", "WHERE", "SUMMARY"], r.findings.map((f) => [
+      f.finding.severity,
+      f.layer === "ai" ? "AI" : "checks",
+      f.finding.id,
+      where(f.finding.artifact, f.finding.locator.line),
+      f.carried ? `${f.finding.summary} (${f.finding.state} in the last round)` : f.finding.summary
+    ])))
+      io.out(line);
+  }
+  for (const l of r.lenses.filter((x) => x.state !== "ran"))
+    io.out(`${l.lens} lens ${l.state}: ${l.reason ?? ""}`.trimEnd());
+  if (r.discarded.length)
+    io.out(`Discarded ${r.discarded.length} AI finding${r.discarded.length > 1 ? "s" : ""} without valid evidence.`);
+  io.out(statusLine(s));
+  return s.mayProceed ? 0 : 1;
+}
+function printCompleted(c, io) {
+  const where2 = `The ${c.lens.lens} lens of round ${c.round} at the ${c.gate} gate`;
+  io.out(c.lens.state === "ran" ? `${where2} raised ${plural(c.findings.length, "finding", "findings")}.` : `${where2} ${c.lens.state}: ${c.lens.reason ?? ""}`.trimEnd());
+  for (const d of c.discarded)
+    io.err(`Discarded: ${d.reason}`);
+  if (c.lens.state === "ran" && c.lens.reason)
+    io.out(`  ${c.lens.reason}`);
+  if (c.waiting.length)
+    io.out(`${plural(c.waiting.length, "AI lens", "AI lenses")} ${c.waiting.length === 1 ? "is" : "are"} still with your assistant: ${c.waiting.map((w) => `${w.lens} (atticus handoff done ${w.runId})`).join(", ")}.`);
+  else
+    io.out(statusLine(c.status));
+  return c.waiting.length === 0;
+}
+async function completeCriticLens(root, run, io, o = {}) {
+  try {
+    const c = await completeLensRun(root, run, o.now ? { now: o.now } : {});
+    printCompleted(c, io);
+    return c.lens.state === "ran" ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function resumeLenses(root, changeId, o, io, deps) {
+  try {
+    await changeStore(root).read(changeId).catch((e) => {
+      throw new CriticError("not-found", e.message);
+    });
+    const gates = o.gate ? [o.gate] : await reviewedGates(root, changeId);
+    const rt = new HandoffRuntime({ root, validate: yamlAnswerProblems });
+    let any = false;
+    let statusPrinted = false;
+    for (const gate of gates) {
+      for (const w of await waitingLenses(root, changeId, gate)) {
+        any = true;
+        let run = await rt.result(w.runId);
+        const file = join(runsDirOf(root), changeId, w.runId, `findings-${w.lens}.yaml`);
+        const written = await stat(file).then(() => true, () => false);
+        if (written && run.state !== "validated")
+          run = await rt.done(w.runId);
+        if (run.state === "failed" && written) {
+          for (const e of run.errors)
+            io.err(e);
+          io.err(`${w.lens} lens: ${runsRelOf(root)}/${changeId}/${w.runId}/findings-${w.lens}.yaml needs fixing; run atticus handoff done ${w.runId} when it's fixed.`);
+        } else if (run.state === "validated") {
+          statusPrinted = printCompleted(await completeLensRun(root, run, deps.now ? { now: deps.now } : {}), io);
+        }
+      }
+    }
+    if (!any)
+      io.out(`No AI lens of ${o.gate ? `the ${o.gate} gate` : "this change"} is waiting for your assistant.`);
+    let mayProceed = false;
+    for (const gate of gates) {
+      const s = await gateStatus(root, changeId, gate);
+      if (!statusPrinted && (any || s.round !== void 0))
+        io.out(statusLine(s));
+      mayProceed = s.mayProceed && s.round !== void 0;
+    }
+    return mayProceed ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function findings(root, changeId, o, io) {
+  if (!changeId) {
+    io.err("Usage: atticus findings <change> [--json]");
+    return 2;
+  }
+  try {
+    await changeStore(root).read(changeId);
+  } catch (e) {
+    io.err(e.message);
+    return 1;
+  }
+  const statuses = [];
+  try {
+    for (const g of await reviewedGates(root, changeId))
+      statuses.push(await gateStatus(root, changeId, g));
+  } catch (e) {
+    return fail(io, e);
+  }
+  if (o.json) {
+    io.out(JSON.stringify(statuses.map((s) => ({
+      gate: s.gate,
+      round: s.round,
+      mayProceed: s.mayProceed,
+      humanDecides: s.humanDecides,
+      checkRound: s.checkRound,
+      open: s.open,
+      findings: s.findings.map((f) => ({
+        ...f.finding,
+        path: f.path,
+        // ADR 0115 addendum (2026-10-25): an assistant's proposal, waiting on a person.
+        ...f.proposal ? { proposal: f.proposal } : {}
+      }))
+    })), null, 2));
+    return 0;
+  }
+  if (statuses.length === 0) {
+    io.out(`No critic findings for ${changeId} yet. Run atticus critic ${changeId}.`);
+    return 0;
+  }
+  for (const s of statuses) {
+    io.out(`${s.gate} gate, round ${s.round ?? 0}:`);
+    for (const line of table(["SEVERITY", "STATE", "ID", "WHERE", "SUMMARY"], s.findings.map((f) => [
+      f.finding.severity,
+      f.proposal ? `open (${proposalWords(f.proposal)})` : f.finding.state,
+      f.finding.id,
+      where(f.finding.artifact, f.finding.locator.line),
+      f.finding.summary
+    ])))
+      io.out(`  ${line}`);
+    io.out(statusLine(s));
+  }
+  return 0;
+}
+async function findingAction(root, changeId, findingId, action, o, io, deps = {}) {
+  if (!changeId || !findingId || !action || !o.by) {
+    io.err("Usage: atticus finding <change> <finding> <apply|edit-and-apply|not-relevant|waive|ask> [--by <you>] [--gate <gate>] [--reason <why>] [--asked-of <who>] [--edit <patch file>]");
+    return 2;
+  }
+  let edit;
+  if (o.edit) {
+    try {
+      edit = await readFile2(isAbsolute(o.edit) ? o.edit : join(root, o.edit), "utf8");
+    } catch {
+      io.err(`Can't read the patch file ${o.edit}.`);
+      return 2;
+    }
+  }
+  try {
+    const r = await act(root, changeId, findingId, action, {
+      by: o.by,
+      ...o.reason ? { reason: o.reason } : {},
+      ...o.askedOf ? { askedOf: o.askedOf } : {},
+      ...edit ? { edit } : {},
+      ...o.gate ? { gate: o.gate } : {},
+      ...deps.now ? { now: deps.now } : {}
+    });
+    io.out(r.message);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function criticStats(root, o, io) {
+  const s = await overrideStats(root, o.threshold ? { threshold: o.threshold } : {});
+  if (o.json) {
+    io.out(JSON.stringify(s, null, 2));
+    return 0;
+  }
+  if (s.rules.length === 0) {
+    io.out("No critic findings yet.");
+    return 0;
+  }
+  io.out(`Override rates across ${s.changes} change${s.changes === 1 ? "" : "s"}:`);
+  for (const line of table(["RULE", "FINDINGS", "DISMISSED", "WAIVED", "OVERRIDDEN"], s.rules.map((r) => [
+    r.rule,
+    String(r.total),
+    String(r.dismissed),
+    String(r.waived),
+    `${Math.round(r.overrideRate * 100)}%`
+  ])))
+    io.out(line);
+  for (const g of s.suggestions) {
+    io.out("");
+    io.out(g.message);
+    if (g.patch)
+      for (const l of g.patch.trimEnd().split("\n"))
+        io.out(`  ${l}`);
+  }
+  return 0;
+}
+
+export {
+  yamlAnswerProblems,
+  statusLine,
+  critic,
+  completeCriticLens,
+  findings,
+  findingAction,
+  criticStats
+};

package/dist/chunk-76WKMA4J.js

@@ -0,0 +1,14 @@
+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 {
+  isMetarepo,
+  notMetarepo
+} from "./chunk-3G4YI4ZU.js";
+import "./chunk-TV45EUGM.js";
+export {
+  isMetarepo,
+  notMetarepo
+};