codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/plan-phases-service.js

@@ -0,0 +1,182 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_phases_service_exports = {};
+__export(plan_phases_service_exports, {
+  createPhase: () => createPhase,
+  deletePhase: () => deletePhase,
+  getPhase: () => getPhase,
+  listPhases: () => listPhases,
+  updatePhase: () => updatePhase
+});
+module.exports = __toCommonJS(plan_phases_service_exports);
+var _lazy___plan_file_service = __toESM(require("./plan-file-service"));
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+function notifyMutation(planUid) {
+  try {
+    const { scheduleWriteThrough } = _lazy___plan_file_service;
+    scheduleWriteThrough(planUid);
+  } catch {
+  }
+}
+function createPhase(input) {
+  const db = (0, import_database.getDb)();
+  const uid = (0, import_node_crypto.randomUUID)();
+  const now = Date.now();
+  let phaseNumber = input.phaseNumber;
+  if (phaseNumber == null) {
+    const r = db.exec(
+      `SELECT COALESCE(MAX(phase_number), 0) + 1 FROM plan_phases WHERE plan_uid = ?`,
+      [input.planUid]
+    );
+    phaseNumber = r[0]?.values[0]?.[0] ?? 1;
+  }
+  const status = input.status ?? "pending";
+  db.run(
+    `INSERT INTO plan_phases (uid, plan_uid, phase_number, title, scope, prerequisites, git_checkpoint, acceptance_criteria, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      uid,
+      input.planUid,
+      phaseNumber,
+      input.title,
+      input.scope ?? "",
+      input.prerequisites ?? "",
+      input.gitCheckpoint ?? null,
+      input.acceptanceCriteria ?? "",
+      status,
+      now,
+      now
+    ]
+  );
+  (0, import_persistence.markDirty)();
+  notifyMutation(input.planUid);
+  return {
+    uid,
+    planUid: input.planUid,
+    phaseNumber,
+    title: input.title,
+    scope: input.scope ?? "",
+    prerequisites: input.prerequisites ?? "",
+    gitCheckpoint: input.gitCheckpoint ?? null,
+    acceptanceCriteria: input.acceptanceCriteria ?? "",
+    status,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function getPhase(uid) {
+  const r = (0, import_database.getDb)().exec(
+    `SELECT uid, plan_uid, phase_number, title, scope, prerequisites, git_checkpoint, acceptance_criteria, status, created_at, updated_at
+     FROM plan_phases WHERE uid = ?`,
+    [uid]
+  );
+  if (!r[0]?.values[0]) return null;
+  return rowToPhase(r[0].values[0]);
+}
+function listPhases(planUid) {
+  const r = (0, import_database.getDb)().exec(
+    `SELECT uid, plan_uid, phase_number, title, scope, prerequisites, git_checkpoint, acceptance_criteria, status, created_at, updated_at
+     FROM plan_phases WHERE plan_uid = ? ORDER BY phase_number ASC, created_at ASC`,
+    [planUid]
+  );
+  if (!r[0]) return [];
+  return r[0].values.map(rowToPhase);
+}
+function updatePhase(uid, updates) {
+  const existing = getPhase(uid);
+  if (!existing) return null;
+  const now = Date.now();
+  const sets = ["updated_at = ?"];
+  const params = [now];
+  if (updates.phaseNumber !== void 0) {
+    sets.push("phase_number = ?");
+    params.push(updates.phaseNumber);
+  }
+  if (updates.title !== void 0) {
+    sets.push("title = ?");
+    params.push(updates.title);
+  }
+  if (updates.scope !== void 0) {
+    sets.push("scope = ?");
+    params.push(updates.scope);
+  }
+  if (updates.prerequisites !== void 0) {
+    sets.push("prerequisites = ?");
+    params.push(updates.prerequisites);
+  }
+  if (updates.gitCheckpoint !== void 0) {
+    sets.push("git_checkpoint = ?");
+    params.push(updates.gitCheckpoint);
+  }
+  if (updates.acceptanceCriteria !== void 0) {
+    sets.push("acceptance_criteria = ?");
+    params.push(updates.acceptanceCriteria);
+  }
+  if (updates.status !== void 0) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  params.push(uid);
+  (0, import_database.getDb)().run(`UPDATE plan_phases SET ${sets.join(", ")} WHERE uid = ?`, params);
+  (0, import_persistence.markDirty)();
+  if (existing) notifyMutation(existing.planUid);
+  return getPhase(uid);
+}
+function deletePhase(uid) {
+  const db = (0, import_database.getDb)();
+  const before = getPhase(uid);
+  db.run(`UPDATE tasks SET phase_uid = NULL WHERE phase_uid = ?`, [uid]);
+  db.run(`DELETE FROM plan_phases WHERE uid = ?`, [uid]);
+  (0, import_persistence.markDirty)();
+  if (before) notifyMutation(before.planUid);
+}
+function rowToPhase(r) {
+  return {
+    uid: r[0],
+    planUid: r[1],
+    phaseNumber: r[2],
+    title: r[3],
+    scope: r[4],
+    prerequisites: r[5],
+    gitCheckpoint: r[6] ?? null,
+    acceptanceCriteria: r[7],
+    status: r[8],
+    createdAt: r[9],
+    updatedAt: r[10]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPhase,
+  deletePhase,
+  getPhase,
+  listPhases,
+  updatePhase
+});

package/src/backend/services/plan-progress-service.js

@@ -0,0 +1,134 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_progress_service_exports = {};
+__export(plan_progress_service_exports, {
+  _setListPlansProviderForTest: () => _setListPlansProviderForTest,
+  clearSuggestionMemory: () => clearSuggestionMemory,
+  recordFileChange: () => recordFileChange
+});
+module.exports = __toCommonJS(plan_progress_service_exports);
+var planService = __toESM(require("./plan-service"));
+var planItemService = __toESM(require("./plan-item-service"));
+var planChangesService = __toESM(require("./plan-changes-service"));
+var import_server = require("../server");
+const suggestedDone = /* @__PURE__ */ new Set();
+let listPlansProvider = () => planService.listPlans();
+function _setListPlansProviderForTest(fn) {
+  listPlansProvider = fn;
+}
+function recordFileChange(relativePath) {
+  if (!relativePath) return;
+  const plans = listPlansProvider().filter(
+    (p) => p.status === "approved" || p.status === "in_progress" || p.status === "draft" || p.status === "review"
+  );
+  if (plans.length === 0) return;
+  for (const plan of plans) {
+    const planWithTasks = planService.getPlan(plan.uid);
+    if (!planWithTasks) continue;
+    const tasks = planWithTasks.tasks;
+    let advanced = false;
+    for (const task of tasks) {
+      if (task.status === "done" || task.status === "skipped" || task.status === "blocked") continue;
+      if (!touchesTask(task.affectedFiles, relativePath)) continue;
+      if (task.status === "pending" || task.status === "assigned") {
+        planService.updateTask(task.uid, { status: "in_progress" });
+        (0, import_server.broadcast)("task-updated", {
+          planUid: plan.uid,
+          taskUid: task.uid,
+          status: "in_progress",
+          source: "auto-progress"
+        });
+        advanced = true;
+        suggestedDone.delete(`${plan.uid}:${task.uid}`);
+      }
+    }
+    for (const item of planItemService.listAllItems(plan.uid)) {
+      if (item.kind !== "action") continue;
+      if (item.status !== "pending" && item.status !== "assigned") continue;
+      const paths = (item.fileSpecs ?? []).flatMap((spec) => [spec.path, spec.moveTo].filter((p) => !!p));
+      if (!touchesTask(paths, relativePath)) continue;
+      if (!planItemService.updateItem(item.uid, { status: "in_progress", author: "auto-progress", authorType: "system" })) continue;
+      (0, import_server.broadcast)("plan-item-updated", {
+        planUid: plan.uid,
+        itemUid: item.uid,
+        kind: "action",
+        changes: { status: "in_progress" },
+        source: "auto-progress"
+      });
+    }
+    if (advanced || tasks.some((t) => t.status === "in_progress")) {
+      maybeSuggestCompletions(plan.uid);
+    }
+  }
+}
+function maybeSuggestCompletions(planUid) {
+  const allChanges = planChangesService.listProposedChanges(planUid);
+  if (allChanges.length === 0) return;
+  const byTask = /* @__PURE__ */ new Map();
+  for (const c of allChanges) {
+    const bucket = byTask.get(c.taskUid) ?? [];
+    bucket.push(c);
+    byTask.set(c.taskUid, bucket);
+  }
+  for (const [taskUid, taskChanges] of byTask) {
+    const key = `${planUid}:${taskUid}`;
+    if (suggestedDone.has(key)) continue;
+    if (taskChanges.some((c) => c.taskStatus !== "in_progress")) continue;
+    const allSatisfied = taskChanges.every((c) => c.driftStatus === "satisfied");
+    if (!allSatisfied) continue;
+    suggestedDone.add(key);
+    (0, import_server.broadcast)("task-completion-suggested", {
+      planUid,
+      taskUid,
+      changeCount: taskChanges.length
+    });
+  }
+}
+function touchesTask(affectedFiles, changedRelative) {
+  if (!affectedFiles.length) return false;
+  for (const f of affectedFiles) {
+    if (f === changedRelative) return true;
+    if (changedRelative.endsWith(f) || f.endsWith(changedRelative)) return true;
+  }
+  return false;
+}
+function clearSuggestionMemory(planUid) {
+  if (!planUid) {
+    suggestedDone.clear();
+    return;
+  }
+  for (const key of suggestedDone) {
+    if (key.startsWith(`${planUid}:`)) suggestedDone.delete(key);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _setListPlansProviderForTest,
+  clearSuggestionMemory,
+  recordFileChange
+});

package/src/backend/services/plan-review-service.js

@@ -0,0 +1,262 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_review_service_exports = {};
+__export(plan_review_service_exports, {
+  covers: () => covers,
+  renderReviewMarkdown: () => renderReviewMarkdown,
+  reviewPlan: () => reviewPlan,
+  withArchitecture: () => withArchitecture
+});
+module.exports = __toCommonJS(plan_review_service_exports);
+var import_review_architecture = require("./review-architecture");
+var import_plan_item_service = require("./plan-item-service");
+var import_trusted_roots = require("./trusted-roots");
+var import_node_path = __toESM(require("node:path"));
+var import_snapshot_compare_service = require("./snapshot-compare-service");
+var import_pricing = require("./pricing");
+var import_budget_service = require("./budget-service");
+var import_criteria_service = require("./criteria-service");
+var import_signoff_rows = require("./signoff-rows");
+var import_review_other_work = require("./review-other-work");
+var import_other_work = require("../../shared/lib/other-work");
+function criteriaOf(item) {
+  const all = (0, import_criteria_service.listCriteria)(item.uid);
+  return {
+    criteria: {
+      total: all.length,
+      met: all.filter((c) => c.state === "met").length,
+      waiting: all.filter((c) => c.state === "submitted").length,
+      sentBack: all.filter((c) => c.state === "sent_back").length
+    },
+    signoffs: all.map((c) => (0, import_signoff_rows.rowsForCriterion)(item, c))
+  };
+}
+function normalise(p) {
+  return p.replace(/^\.\//, "").replace(/^\/+/, "").toLowerCase();
+}
+function covers(target, changed) {
+  const t = normalise(target);
+  const c = normalise(changed);
+  if (!t) return false;
+  if (t === c) return true;
+  return c.startsWith(t.endsWith("/") ? t : `${t}/`);
+}
+function targetsOf(item, projectPath) {
+  return (item.fileSpecs ?? []).map((f) => f.path).filter(Boolean).map((t) => import_node_path.default.isAbsolute(t) ? (0, import_trusted_roots.projectRelative)(projectPath, t) || t : t);
+}
+function edgeKey(source, target) {
+  return `${normalise(source)}->${normalise(target)}`;
+}
+function defaultComparand(projectPath) {
+  try {
+    const newestCommit = (0, import_snapshot_compare_service.listComparands)(projectPath, 1).find((c) => c.kind === "commit");
+    if (newestCommit) return newestCommit.spec;
+  } catch {
+  }
+  return "baseline";
+}
+function reviewPlan(params) {
+  const compared = (0, import_snapshot_compare_service.compareSnapshots)(
+    params.before ?? defaultComparand(params.projectPath),
+    params.after ?? "live",
+    params.projectPath
+  );
+  if (!compared.ok) return compared;
+  const comparison = compared.result;
+  const changedFiles = [
+    ...comparison.diff.addedFiles,
+    ...comparison.diff.modifiedFiles,
+    ...comparison.diff.removedFiles
+  ];
+  const items = (0, import_plan_item_service.listAllItems)(params.planUid);
+  const reviewed = items.map((item) => {
+    const targets = targetsOf(item, params.projectPath);
+    if (targets.length === 0) {
+      return {
+        uid: item.uid,
+        title: item.title,
+        status: item.status ?? null,
+        landed: [],
+        missing: [],
+        verdict: "no-targets",
+        ...criteriaOf(item)
+      };
+    }
+    const landed = [];
+    const missing = [];
+    for (const target of targets) {
+      if (changedFiles.some((f) => covers(target, f))) landed.push(target);
+      else missing.push(target);
+    }
+    const verdict = landed.length === 0 ? "untouched" : missing.length === 0 ? "landed" : "partial";
+    return {
+      uid: item.uid,
+      title: item.title,
+      status: item.status ?? null,
+      landed,
+      missing,
+      verdict,
+      ...criteriaOf(item)
+    };
+  });
+  const allTargets = items.flatMap((i) => targetsOf(i, params.projectPath));
+  const unclaimedChanges = changedFiles.filter((f) => !allTargets.some((t) => covers(t, f)));
+  const plannedAdds = /* @__PURE__ */ new Set();
+  const plannedRemovals = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    for (const c of item.newConnections ?? []) plannedAdds.add(edgeKey(c.from, c.to));
+    for (const c of item.removedConnections ?? []) plannedRemovals.add(edgeKey(c.from, c.to));
+  }
+  const unplannedEdges = comparison.edgesComparable ? comparison.diff.addedEdges.filter((e) => !plannedAdds.has(edgeKey(e.source, e.target))) : [];
+  const unremovedEdges = comparison.edgesComparable ? [...plannedRemovals].filter((key) => !comparison.diff.removedEdges.some((e) => edgeKey(e.source, e.target) === key)).map((key) => {
+    const [source, target] = key.split("->");
+    return { source, target };
+  }) : [];
+  return {
+    ok: true,
+    review: {
+      planUid: params.planUid,
+      comparison,
+      items: reviewed,
+      unclaimedChanges,
+      unplannedEdges,
+      unremovedEdges,
+      otherWork: (0, import_review_other_work.otherWorkFor)(params.projectPath, { after: params.after, itemWorkstreams: items.map((i) => i.workstream) }),
+      summary: {
+        itemsLanded: reviewed.filter((i) => i.verdict === "landed").length,
+        itemsPartial: reviewed.filter((i) => i.verdict === "partial").length,
+        itemsUntouched: reviewed.filter((i) => i.verdict === "untouched").length,
+        filesChanged: changedFiles.length,
+        unclaimedCount: unclaimedChanges.length,
+        unplannedEdgeCount: unplannedEdges.length
+      }
+    }
+  };
+}
+function commitOfSpec(spec) {
+  return spec.startsWith("commit:") ? spec.slice("commit:".length) : null;
+}
+async function withArchitecture(review, projectPath) {
+  const base = commitOfSpec(review.comparison.before.spec);
+  const head = commitOfSpec(review.comparison.after.spec);
+  if (!base || !head) return review;
+  const a = await (0, import_review_architecture.architectureOf)(projectPath, base, head);
+  return "error" in a ? review : { ...review, architecture: a };
+}
+function renderReviewMarkdown(review, planTitle) {
+  const lines = [];
+  const s = review.summary;
+  lines.push(`## Plan review${planTitle ? `: ${planTitle}` : ""}`);
+  lines.push("");
+  lines.push(
+    `Comparing **${review.comparison.before.label}** \u2192 **${review.comparison.after.label}** \xB7 ${s.filesChanged} file${s.filesChanged === 1 ? "" : "s"} changed`
+  );
+  lines.push("");
+  if (review.architecture) lines.push((0, import_review_architecture.architectureMarkdown)(review.architecture), "");
+  lines.push(
+    `| Landed | Partial | Untouched | Unclaimed files | Unplanned edges |`,
+    `|---|---|---|---|---|`,
+    `| ${s.itemsLanded} | ${s.itemsPartial} | ${s.itemsUntouched} | ${s.unclaimedCount} | ${s.unplannedEdgeCount} |`,
+    ""
+  );
+  const partial = review.items.filter((i) => i.verdict === "partial");
+  if (partial.length > 0) {
+    lines.push("### Partially landed");
+    lines.push("");
+    for (const item of partial) {
+      lines.push(`- **${item.title}** \u2014 still missing: ${item.missing.map((m) => `\`${m}\``).join(", ")}`);
+    }
+    lines.push("");
+  }
+  const unsigned = review.items.filter((i) => i.criteria.total > 0 && i.criteria.met < i.criteria.total);
+  if (unsigned.length > 0) {
+    lines.push("### Criteria not yet met");
+    lines.push("");
+    for (const item of unsigned) {
+      const c = item.criteria;
+      const parts = [`${c.met}/${c.total} met`];
+      if (c.waiting) parts.push(`${c.waiting} waiting for sign-off`);
+      if (c.sentBack) parts.push(`${c.sentBack} sent back`);
+      lines.push(`- **${item.title}** \u2014 ${parts.join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (review.unclaimedChanges.length > 0) {
+    lines.push("### Changed, but no item claimed them");
+    lines.push("");
+    lines.push("The finding a diff cannot show you: these files changed without any plan item asking for it.");
+    lines.push("");
+    for (const file of review.unclaimedChanges.slice(0, 25)) lines.push(`- \`${file}\``);
+    if (review.unclaimedChanges.length > 25) {
+      lines.push(`- \u2026and ${review.unclaimedChanges.length - 25} more`);
+    }
+    lines.push("");
+  }
+  if (review.unplannedEdges.length > 0) {
+    lines.push("### New dependencies nobody planned");
+    lines.push("");
+    lines.push("Each of these is one import line in the diff, and a new coupling in the architecture.");
+    lines.push("");
+    for (const edge of review.unplannedEdges.slice(0, 25)) {
+      lines.push(`- \`${edge.source}\` \u2192 \`${edge.target}\``);
+    }
+    if (review.unplannedEdges.length > 25) {
+      lines.push(`- \u2026and ${review.unplannedEdges.length - 25} more`);
+    }
+    lines.push("");
+  }
+  if (review.otherWork) lines.push((0, import_other_work.otherWorkMarkdown)(review.otherWork));
+  if (review.unremovedEdges.length > 0) {
+    lines.push("### Dependencies the plan said to remove, still present");
+    lines.push("");
+    for (const edge of review.unremovedEdges.slice(0, 25)) {
+      lines.push(`- \`${edge.source}\` \u2192 \`${edge.target}\``);
+    }
+    lines.push("");
+  }
+  if (!review.comparison.edgesComparable) {
+    lines.push("> Edges were not compared for this range \u2014 see the note below.");
+    lines.push("");
+  }
+  for (const note of review.comparison.notes) lines.push(`> ${note}`);
+  const budget = (0, import_budget_service.getBudgetReport)(review.planUid);
+  if (budget.spentMinutes > 0) {
+    lines.push("");
+    lines.push(
+      `_Spent on this plan: ${budget.spentMinutes.toFixed(0)} minutes` + (budget.spentCostUsd === null ? "" : `, ${(0, import_pricing.formatCost)(budget.spentCostUsd)}`) + "._"
+    );
+  }
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  covers,
+  renderReviewMarkdown,
+  reviewPlan,
+  withArchitecture
+});