codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,273 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_changes_service_exports = {};
+__export(plan_changes_service_exports, {
+  getChange: () => getChange,
+  listProposedChanges: () => listProposedChanges,
+  summarizeChanges: () => summarizeChanges
+});
+module.exports = __toCommonJS(plan_changes_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_database = require("./database");
+var import_plan_service = require("./plan-service");
+var import_plan_item_service = require("./plan-item-service");
+function listProposedChanges(planUid) {
+  const live = loadLiveState((0, import_plan_service.getPlan)(planUid)?.projectPath);
+  const v2Items = (0, import_plan_item_service.listAllItems)(planUid).filter((it) => it.kind === "action");
+  const tasks = (0, import_plan_service.getTasksByPlan)(planUid);
+  const migratedTaskUids = /* @__PURE__ */ new Set();
+  for (const it of v2Items) {
+    if (it.migratedFrom?.startsWith("tasks:")) {
+      migratedTaskUids.add(it.migratedFrom.slice("tasks:".length));
+    }
+  }
+  const changes = [];
+  for (const item of v2Items) {
+    pushItemChanges(item, changes, live);
+  }
+  for (const task of tasks) {
+    if (migratedTaskUids.has(task.uid)) continue;
+    pushTaskChanges(task, changes, live);
+  }
+  return changes;
+}
+function pushItemChanges(item, out, live) {
+  const adapter = adaptItemToTaskShape(item);
+  for (const fs of item.fileSpecs ?? []) {
+    const target = fs.action === "move" && fs.moveTo ? `${fs.path} \u2192 ${fs.moveTo}` : fs.path;
+    const detail = fs.edits && fs.edits.length > 0 ? `${fs.edits.length} edit${fs.edits.length === 1 ? "" : "s"}${fs.description ? " \xB7 " + fs.description : ""}` : fs.description;
+    out.push(makeChange(adapter, "file", fileSpecToOperation(fs.action), target, detail, live));
+  }
+  for (const spec of item.symbolSpecs ?? []) {
+    out.push(makeChange(
+      adapter,
+      "symbol",
+      spec.action,
+      formatSymbolTarget(spec),
+      formatSymbolDetail(spec),
+      live
+    ));
+  }
+  for (const edge of item.newConnections ?? []) {
+    out.push(makeChange(adapter, "connection", "add", `${edge.from} \u2192 ${edge.to}`, void 0, live));
+  }
+  for (const edge of item.removedConnections ?? []) {
+    out.push(makeChange(adapter, "connection", "remove", `${edge.from} \u2192 ${edge.to}`, void 0, live));
+  }
+}
+function pushTaskChanges(task, out, live) {
+  for (const file of task.affectedFiles) {
+    out.push(makeChange(task, "file", "modify", file, void 0, live));
+  }
+  for (const spec of task.symbolSpecs ?? []) {
+    out.push(makeChange(
+      task,
+      "symbol",
+      spec.action,
+      formatSymbolTarget(spec),
+      formatSymbolDetail(spec),
+      live
+    ));
+  }
+  for (const edge of task.newConnections) {
+    out.push(makeChange(task, "connection", "add", `${edge.from} \u2192 ${edge.to}`, void 0, live));
+  }
+  for (const edge of task.removedConnections) {
+    out.push(makeChange(task, "connection", "remove", `${edge.from} \u2192 ${edge.to}`, void 0, live));
+  }
+}
+function adaptItemToTaskShape(item) {
+  return {
+    uid: item.uid,
+    planUid: item.planUid,
+    sortOrder: item.sortOrder,
+    description: item.title,
+    status: item.status ?? "pending",
+    assignee: item.assignee ?? null,
+    assigneeType: item.assigneeType ?? null,
+    assigneeModel: item.assigneeModel ?? null,
+    affectedFiles: (item.fileSpecs ?? []).map((f) => f.path),
+    affectedSymbols: (item.symbolSpecs ?? []).map((s) => s.name),
+    newConnections: item.newConnections ?? [],
+    removedConnections: item.removedConnections ?? [],
+    dependencies: item.dependencies ?? [],
+    fileSpec: void 0,
+    symbolSpecs: item.symbolSpecs ?? [],
+    phaseUid: null,
+    parentTaskUid: item.parentUid,
+    body: item.body,
+    prompt: void 0,
+    scopePath: item.scopePath ?? null,
+    fileSpecs: item.fileSpecs ?? [],
+    progressPercent: item.progressPercent ?? null,
+    blockedReason: item.blockedReason ?? null,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt
+  };
+}
+function fileSpecToOperation(a) {
+  if (a === "create") return "add";
+  if (a === "delete") return "remove";
+  return a;
+}
+function getChange(planUid, changeId) {
+  return listProposedChanges(planUid).find((c) => c.id === changeId) ?? null;
+}
+function summarizeChanges(planUid) {
+  const changes = listProposedChanges(planUid);
+  const byStatus = {
+    planned: 0,
+    in_progress: 0,
+    satisfied: 0,
+    missing: 0,
+    unexpected: 0
+  };
+  const byKind = { file: 0, symbol: 0, connection: 0 };
+  const byOperation = { add: 0, modify: 0, remove: 0, move: 0 };
+  for (const c of changes) {
+    byStatus[c.driftStatus]++;
+    byKind[c.kind]++;
+    byOperation[c.operation]++;
+  }
+  return { total: changes.length, byStatus, byKind, byOperation };
+}
+function loadLiveState(projectPath) {
+  const db = (0, import_database.getDb)();
+  const filePaths = /* @__PURE__ */ new Set();
+  const symbolNames = /* @__PURE__ */ new Set();
+  const edges = /* @__PURE__ */ new Set();
+  try {
+    const fr = db.exec(`SELECT path, relative_path FROM files`);
+    if (fr[0]) {
+      for (const row of fr[0].values) {
+        filePaths.add(row[0]);
+        if (row[1]) filePaths.add(row[1]);
+      }
+    }
+    const sr = db.exec(`SELECT name FROM symbols`);
+    if (sr[0]) {
+      for (const row of sr[0].values) {
+        symbolNames.add(row[0]);
+      }
+    }
+    const er = db.exec(`
+      SELECT f.relative_path, i.resolved_path
+      FROM imports i JOIN files f ON i.file_id = f.id
+      WHERE i.resolved_path IS NOT NULL
+    `);
+    if (er[0]) {
+      for (const row of er[0].values) {
+        edges.add(`${row[0]}\0${row[1]}`);
+      }
+    }
+  } catch {
+  }
+  return { filePaths, symbolNames, edges, changedFiles: loadChangedFiles(projectPath) };
+}
+function loadChangedFiles(projectPath) {
+  const out = /* @__PURE__ */ new Set();
+  if (!projectPath) return out;
+  try {
+    const porcelain = (0, import_node_child_process.execFileSync)("git", ["status", "--porcelain", "--", "."], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    });
+    for (const line of porcelain.split("\n")) {
+      if (line.length < 4) continue;
+      const rel = line.slice(3).split(" -> ").pop().trim().replace(/^"|"$/g, "");
+      if (rel) out.add(rel);
+    }
+  } catch {
+  }
+  return out;
+}
+function makeChange(task, kind, operation, target, detail, live) {
+  const id = `${task.uid}:${kind}:${operation}:${target}`;
+  const driftStatus = computeDrift(kind, operation, target, task, live);
+  return {
+    id,
+    taskUid: task.uid,
+    taskDescription: task.description,
+    taskStatus: task.status,
+    phaseUid: task.phaseUid,
+    operation,
+    kind,
+    target,
+    detail,
+    driftStatus
+  };
+}
+function computeDrift(kind, operation, target, task, live) {
+  const taskInFlight = task.status === "assigned" || task.status === "in_progress";
+  let satisfied = false;
+  if (kind === "file") {
+    const present = isFilePresent(target, live);
+    if (operation === "remove") satisfied = !present;
+    else if (operation === "modify") {
+      satisfied = present && isFileChanged(target, live);
+    } else satisfied = present;
+  } else if (kind === "symbol") {
+    const symbolName = target.includes("#") ? target.split("#").pop() : target.split("::").pop() ?? target;
+    const present = live.symbolNames.has(symbolName);
+    if (operation === "remove") satisfied = !present;
+    else satisfied = present;
+  } else if (kind === "connection") {
+    const [from, to] = target.split(" \u2192 ");
+    const present = !!from && !!to && live.edges.has(`${from}\0${to}`);
+    if (operation === "remove") satisfied = !present;
+    else satisfied = present;
+  }
+  if (task.status === "done") {
+    return satisfied ? "satisfied" : "missing";
+  }
+  if (satisfied) return "satisfied";
+  if (taskInFlight) return "in_progress";
+  return "planned";
+}
+function isFileChanged(target, live) {
+  if (live.changedFiles.has(target)) return true;
+  for (const p of live.changedFiles) {
+    if (p.endsWith(target) || target.endsWith(p)) return true;
+  }
+  return false;
+}
+function isFilePresent(target, live) {
+  if (live.filePaths.has(target)) return true;
+  for (const p of live.filePaths) {
+    if (p.endsWith(target) || target.endsWith(p)) return true;
+  }
+  return false;
+}
+function formatSymbolTarget(spec) {
+  return spec.kind === "method" ? `${spec.kind}:${spec.name}` : spec.name;
+}
+function formatSymbolDetail(spec) {
+  const parts = [];
+  if (spec.signature) parts.push(spec.signature);
+  if (spec.moveTo) parts.push(`\u2192 ${spec.moveTo}`);
+  if (spec.description) parts.push(spec.description);
+  return parts.length ? parts.join(" \xB7 ") : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChange,
+  listProposedChanges,
+  summarizeChanges
+});

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

@@ -0,0 +1,288 @@
+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_conflict_service_exports = {};
+__export(plan_conflict_service_exports, {
+  detectManifestConflicts: () => detectManifestConflicts,
+  extractConflictSide: () => extractConflictSide,
+  resolveFileConflict: () => resolveFileConflict,
+  resolveFileConflictBySide: () => resolveFileConflictBySide
+});
+module.exports = __toCommonJS(plan_conflict_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_confined_fs = require("./confined-fs");
+var import_git_checkout = require("./git-checkout");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+function detectManifestConflicts(projectRoot) {
+  const gitDir = (0, import_git_checkout.checkoutGitDir)(projectRoot);
+  if (!gitDir || !import_node_fs.default.existsSync(import_node_path.default.join(gitDir, "MERGE_HEAD"))) {
+    return { hasConflicts: false, files: [], totalConflicts: 0, autoResolvable: 0 };
+  }
+  let conflictedPaths;
+  try {
+    const raw = runGitArgs(["diff", "--name-only", "--diff-filter=U", "--", ".codetrellis/"], projectRoot);
+    conflictedPaths = raw.trim().split("\n").filter(Boolean);
+  } catch {
+    return { hasConflicts: false, files: [], totalConflicts: 0, autoResolvable: 0 };
+  }
+  if (conflictedPaths.length === 0) {
+    return { hasConflicts: false, files: [], totalConflicts: 0, autoResolvable: 0 };
+  }
+  const files = [];
+  let autoResolvable = 0;
+  for (const filePath of conflictedPaths) {
+    const fullPath = (0, import_confined_fs.resolveWithin)(projectRoot, filePath, "resolveFileConflict(filePath)");
+    if (!import_node_fs.default.existsSync(fullPath)) continue;
+    const rawContent = import_node_fs.default.readFileSync(fullPath, "utf-8");
+    const planSlug = extractPlanSlug(filePath);
+    const entityType = classifyConflictFile(filePath);
+    let fields = null;
+    if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+      fields = parseYamlConflictFields(rawContent);
+    } else if (filePath.endsWith(".json")) {
+      fields = parseJsonConflictFields(rawContent);
+    }
+    if (fields) {
+      autoResolvable += fields.filter((f) => f.autoResolvable).length;
+    }
+    files.push({
+      filePath,
+      planSlug,
+      entityType,
+      fields,
+      rawContent,
+      resolved: false
+    });
+  }
+  return {
+    hasConflicts: true,
+    files,
+    totalConflicts: conflictedPaths.length,
+    autoResolvable
+  };
+}
+function resolveFileConflict(projectRoot, filePath, resolutions) {
+  const fullPath = (0, import_confined_fs.resolveWithin)(projectRoot, filePath, "resolveFileConflict(filePath)");
+  if (!import_node_fs.default.existsSync(fullPath)) {
+    return { resolved: false, error: `File not found: ${filePath}` };
+  }
+  const rawContent = import_node_fs.default.readFileSync(fullPath, "utf-8");
+  const ours = extractConflictSide(rawContent, "ours");
+  const theirs = extractConflictSide(rawContent, "theirs");
+  if (!ours || !theirs) {
+    return { resolved: false, error: "Could not parse conflict markers in file" };
+  }
+  let merged;
+  try {
+    const isJson = filePath.endsWith(".json");
+    if (isJson) {
+      merged = JSON.parse(ours);
+    } else {
+      const { parse } = require("yaml");
+      merged = parse(ours) ?? {};
+    }
+  } catch {
+    return { resolved: false, error: "Could not parse our side of the conflict" };
+  }
+  let theirsParsed;
+  try {
+    const isJson = filePath.endsWith(".json");
+    if (isJson) {
+      theirsParsed = JSON.parse(theirs);
+    } else {
+      const { parse } = require("yaml");
+      theirsParsed = parse(theirs) ?? {};
+    }
+  } catch {
+    return { resolved: false, error: "Could not parse their side of the conflict" };
+  }
+  for (const res of resolutions) {
+    if (res.pick === "theirs") {
+      merged[res.field] = theirsParsed[res.field];
+    } else if (res.pick === "custom" && res.customValue !== void 0) {
+      merged[res.field] = res.customValue;
+    }
+  }
+  try {
+    const isJson = filePath.endsWith(".json");
+    if (isJson) {
+      (0, import_confined_fs.writeFileWithin)(projectRoot, fullPath, JSON.stringify(merged, null, 2), "conflict resolve (json)");
+    } else {
+      const { stringify } = require("yaml");
+      (0, import_confined_fs.writeFileWithin)(projectRoot, fullPath, stringify(merged), "conflict resolve (yaml)");
+    }
+  } catch (err) {
+    return { resolved: false, error: `Failed to write resolved file: ${err}` };
+  }
+  try {
+    runGitArgs(["add", "--", filePath], projectRoot);
+  } catch (err) {
+    return { resolved: false, error: `Failed to stage resolved file: ${err}` };
+  }
+  return { resolved: true };
+}
+function resolveFileConflictBySide(projectRoot, filePath, side) {
+  (0, import_confined_fs.resolveWithin)(projectRoot, filePath, "resolveFileConflictBySide(filePath)");
+  if (side !== "ours" && side !== "theirs") {
+    return { resolved: false, error: `Invalid side: ${String(side)}` };
+  }
+  try {
+    const flag = side === "ours" ? "--ours" : "--theirs";
+    runGitArgs(["checkout", flag, "--", filePath], projectRoot);
+    runGitArgs(["add", "--", filePath], projectRoot);
+    return { resolved: true };
+  } catch (err) {
+    return { resolved: false, error: `Failed to resolve by side: ${err}` };
+  }
+}
+function runGitArgs(args, cwd) {
+  return (0, import_node_child_process.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 1e4
+  });
+}
+function extractPlanSlug(filePath) {
+  const match = filePath.match(/\.codetrellis\/plans\/([^/]+)\//);
+  return match ? match[1] : null;
+}
+function classifyConflictFile(filePath) {
+  if (filePath.includes("/plans/") && filePath.endsWith("/plan.yaml")) return "plan";
+  if (filePath.includes("/items/")) return "item";
+  if (filePath.includes("/channels/")) return "channel-event";
+  if (filePath.endsWith("config.json")) return "config";
+  return "unknown";
+}
+function extractConflictSide(content, side) {
+  const lines = content.split("\n");
+  const result = [];
+  let inConflict = false;
+  let inOurSide = false;
+  let inTheirSide = false;
+  for (const line of lines) {
+    if (line.startsWith("<<<<<<<")) {
+      inConflict = true;
+      inOurSide = true;
+      inTheirSide = false;
+      continue;
+    }
+    if (line.startsWith("|||||||") && inConflict) {
+      inOurSide = false;
+      inTheirSide = false;
+      continue;
+    }
+    if (line.startsWith("=======") && inConflict) {
+      inOurSide = false;
+      inTheirSide = true;
+      continue;
+    }
+    if (line.startsWith(">>>>>>>") && inConflict) {
+      inConflict = false;
+      inOurSide = false;
+      inTheirSide = false;
+      continue;
+    }
+    if (!inConflict) {
+      result.push(line);
+    } else if (side === "ours" && inOurSide) {
+      result.push(line);
+    } else if (side === "theirs" && inTheirSide) {
+      result.push(line);
+    }
+  }
+  return result.join("\n") || null;
+}
+function parseYamlConflictFields(rawContent) {
+  const ours = extractConflictSide(rawContent, "ours");
+  const theirs = extractConflictSide(rawContent, "theirs");
+  if (!ours || !theirs) return null;
+  try {
+    const { parse } = require("yaml");
+    const oursParsed = parse(ours);
+    const theirsParsed = parse(theirs);
+    if (!oursParsed || !theirsParsed) return null;
+    return diffFields(oursParsed, theirsParsed);
+  } catch {
+    return null;
+  }
+}
+function parseJsonConflictFields(rawContent) {
+  const ours = extractConflictSide(rawContent, "ours");
+  const theirs = extractConflictSide(rawContent, "theirs");
+  if (!ours || !theirs) return null;
+  try {
+    const oursParsed = JSON.parse(ours);
+    const theirsParsed = JSON.parse(theirs);
+    return diffFields(oursParsed, theirsParsed);
+  } catch {
+    return null;
+  }
+}
+const STRUCTURED_FIELDS = /* @__PURE__ */ new Set([
+  "status",
+  "assignee",
+  "assigneeType",
+  "assigneeModel",
+  "visibility",
+  "visibility_override",
+  "kind",
+  "sort_order",
+  "sortOrder",
+  "parentUid",
+  "parent_uid",
+  "requires_approval",
+  "defaultVisibility",
+  "attachmentLocation",
+  "repoRole"
+]);
+function diffFields(ours, theirs) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(ours), ...Object.keys(theirs)]);
+  const fields = [];
+  for (const key of allKeys) {
+    const oVal = ours[key];
+    const tVal = theirs[key];
+    if (JSON.stringify(oVal) === JSON.stringify(tVal)) continue;
+    const isStructured = STRUCTURED_FIELDS.has(key);
+    fields.push({
+      field: key,
+      type: isStructured ? "structured" : "freetext",
+      ours: oVal,
+      theirs: tVal,
+      autoResolvable: isStructured
+    });
+  }
+  return fields;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectManifestConflicts,
+  extractConflictSide,
+  resolveFileConflict,
+  resolveFileConflictBySide
+});

package/src/backend/services/plan-dependencies.js

@@ -0,0 +1,91 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_dependencies_exports = {};
+__export(plan_dependencies_exports, {
+  dependencyProblem: () => dependencyProblem,
+  dependencyState: () => dependencyState,
+  isSettled: () => isSettled,
+  waitSentence: () => waitSentence
+});
+module.exports = __toCommonJS(plan_dependencies_exports);
+function isSettled(item) {
+  return item.status === "done" || item.status === "skipped";
+}
+function dependencyState(item, lookup, local) {
+  const waits = [];
+  for (const uid of item.dependencies ?? []) {
+    const dep = local?.get(uid) ?? lookup.getItem(uid);
+    if (!dep) {
+      waits.push({
+        uid,
+        problem: "missing",
+        title: null,
+        status: null,
+        planUid: null,
+        planTitle: null,
+        words: `waits on an item that no longer exists (${uid})`
+      });
+      continue;
+    }
+    const elsewhere = dep.planUid !== item.planUid;
+    const planTitle = elsewhere ? lookup.planTitle(dep.planUid) : null;
+    const where = elsewhere ? ` in plan "${planTitle ?? dep.planUid}"` : "";
+    if (dep.kind !== "action") {
+      waits.push({
+        uid,
+        problem: "page",
+        title: dep.title,
+        status: null,
+        planUid: dep.planUid,
+        planTitle,
+        words: `depends on the page "${dep.title}"${where}, which has no status to finish`
+      });
+      continue;
+    }
+    if (isSettled(dep)) continue;
+    waits.push({
+      uid,
+      problem: "unfinished",
+      title: dep.title,
+      status: dep.status ?? null,
+      planUid: dep.planUid,
+      planTitle,
+      words: `waits on "${dep.title}"${where}`
+    });
+  }
+  return { met: waits.length === 0, waits };
+}
+function waitSentence(title, state) {
+  return `"${title}" ${state.waits.map((w) => w.words).join(", and ")}.`;
+}
+function dependencyProblem(itemUid, dependencies, getItem) {
+  for (const uid of dependencies) {
+    if (itemUid && uid === itemUid) return "An item cannot depend on itself.";
+    const dep = getItem(uid);
+    if (!dep) return `No item has the uid ${uid}.`;
+    if (dep.kind !== "action") return `"${dep.title}" is a page, not a task: it has no status to finish, so nothing could ever start after it.`;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dependencyProblem,
+  dependencyState,
+  isSettled,
+  waitSentence
+});