codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/review-other-work.js

@@ -0,0 +1,90 @@
+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 review_other_work_exports = {};
+__export(review_other_work_exports, {
+  otherWorkFor: () => otherWorkFor,
+  reviewTarget: () => reviewTarget
+});
+module.exports = __toCommonJS(review_other_work_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_worktree_service = require("./worktree-service");
+var import_awareness_service = require("./awareness-service");
+var import_other_work = require("../../shared/lib/other-work");
+const SHA = /^[0-9a-f]{7,40}$/i;
+const canon = (p) => {
+  if (p.startsWith("branch:")) return p;
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return p;
+  }
+};
+function branchNamed(spec) {
+  if (!spec?.startsWith("commit:")) return null;
+  const ref = spec.slice("commit:".length);
+  return ref && !SHA.test(ref) && !ref.includes("~") && !ref.includes("^") ? ref : null;
+}
+function reviewTarget(projectPath, opts, worktrees = (0, import_worktree_service.listWorktrees)(projectPath)) {
+  const named = branchNamed(opts.after) ?? opts.itemWorkstreams?.find((w) => !!w) ?? null;
+  if (named) {
+    const wt = worktrees.find((w) => w.branch === named);
+    return { root: wt ? wt.path : `branch:${named}`, name: named };
+  }
+  const main = worktrees.find((w) => w.isMain);
+  if (main) return { root: main.path, name: main.branch ?? import_node_path.default.basename(main.path) };
+  return { root: projectPath, name: import_node_path.default.basename(projectPath) };
+}
+function otherWorkFor(projectPath, opts) {
+  let worktrees;
+  try {
+    worktrees = (0, import_worktree_service.listWorktrees)(projectPath);
+  } catch {
+    worktrees = [];
+  }
+  const target = reviewTarget(projectPath, opts, worktrees);
+  const byPath = new Map(worktrees.map((w) => [canon(w.path), w]));
+  const label = (root) => {
+    if (root.startsWith("branch:")) return root.slice("branch:".length);
+    const wt = byPath.get(canon(root));
+    if (wt?.branch) return wt.branch;
+    return root.split(/[\\/]/).filter(Boolean).pop() ?? root;
+  };
+  let signals;
+  try {
+    signals = (0, import_awareness_service.loadSignals)(projectPath);
+  } catch {
+    return null;
+  }
+  return (0, import_other_work.otherWorkInFlight)(target, signals, label, (a, b) => canon(a) === canon(b));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  otherWorkFor,
+  reviewTarget
+});

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

@@ -0,0 +1,147 @@
+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 review_queue_service_exports = {};
+__export(review_queue_service_exports, {
+  reviewQueue: () => reviewQueue
+});
+module.exports = __toCommonJS(review_queue_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_plan_service = require("./plan-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_plan_review_service = require("./plan-review-service");
+var import_worktree_service = require("./worktree-service");
+var import_awareness_service = require("./awareness-service");
+var import_git_safety = require("./git-safety");
+var import_merge_order = require("../../shared/lib/merge-order");
+const DONE = /* @__PURE__ */ new Set(["completed", "archived"]);
+const canon = (p) => {
+  if (p.startsWith("branch:")) return p;
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return p;
+  }
+};
+function statusOf(c, openHigh) {
+  if (openHigh > 0) return { status: "held", statusWords: `A high overlap with other work is still open${openHigh > 1 ? ` (${openHigh})` : ""}.` };
+  if (c.sentBack > 0) return { status: "in-progress", statusWords: `${c.sentBack} ${c.sentBack === 1 ? "criterion was" : "criteria were"} sent back.` };
+  if (c.met === c.total) return { status: "ready", statusWords: c.total ? "Every criterion is met and nothing high overlaps." : "No criteria, and nothing high overlaps." };
+  if (c.met + c.waiting === c.total) return { status: "waiting", statusWords: `${c.waiting} ${c.waiting === 1 ? "criterion is" : "criteria are"} waiting for sign-off.` };
+  return { status: "in-progress", statusWords: `${c.met} of ${c.total} criteria met.` };
+}
+function reviewQueue(projectRoot) {
+  let worktrees = [];
+  try {
+    worktrees = (0, import_worktree_service.listWorktrees)(projectRoot);
+  } catch {
+  }
+  const main = worktrees.find((w) => w.isMain);
+  const base = main?.branch ?? main?.head ?? null;
+  const rootOf = (branch) => worktrees.find((w) => w.branch === branch)?.path ?? `branch:${branch}`;
+  const drafts = [];
+  for (const plan of (0, import_plan_service.listPlans)(projectRoot)) {
+    if (DONE.has(plan.status)) continue;
+    const items = (0, import_plan_item_service.listAllItems)(plan.uid);
+    const branches = [...new Set(items.map((i) => i.workstream).filter((b) => !!b && b !== main?.branch))];
+    for (const branch of branches) {
+      const mine = items.filter((i) => i.workstream === branch);
+      const empty = {
+        planUid: plan.uid,
+        planTitle: plan.title,
+        branch,
+        workstream: rootOf(branch),
+        items: mine.length,
+        criteria: { total: 0, met: 0, waiting: 0, sentBack: 0 },
+        filesChanged: 0,
+        blastRadius: 0,
+        unplannedEdges: 0,
+        openSignals: 0,
+        openHigh: 0,
+        ready: false,
+        status: "unavailable",
+        statusWords: ""
+      };
+      if (!base || !(0, import_git_safety.isSafeGitRef)(branch) || !(0, import_git_safety.isSafeGitRef)(base)) {
+        drafts.push({ ...empty, statusWords: "Could not be reviewed: no branch to compare with.", error: "no base branch" });
+        continue;
+      }
+      const r = (0, import_plan_review_service.reviewPlan)({ planUid: plan.uid, projectPath: projectRoot, before: `commit:${base}`, after: `commit:${branch}` });
+      if (!r.ok) {
+        drafts.push({ ...empty, statusWords: `Could not be reviewed: ${r.error}`, error: r.error });
+        continue;
+      }
+      const uids = new Set(mine.map((i) => i.uid));
+      const criteria = r.review.items.filter((i) => uids.has(i.uid)).reduce((acc, i) => ({
+        total: acc.total + i.criteria.total,
+        met: acc.met + i.criteria.met,
+        waiting: acc.waiting + i.criteria.waiting,
+        sentBack: acc.sentBack + i.criteria.sentBack
+      }), { total: 0, met: 0, waiting: 0, sentBack: 0 });
+      const entries = r.review.otherWork?.entries ?? [];
+      const openHigh = r.review.otherWork?.openHigh ?? 0;
+      const s = statusOf(criteria, openHigh);
+      drafts.push({
+        ...empty,
+        criteria,
+        filesChanged: r.review.summary.filesChanged,
+        blastRadius: r.review.comparison.diff.blastRadius.length,
+        unplannedEdges: r.review.summary.unplannedEdgeCount,
+        openSignals: entries.filter((e) => e.outcome === "open").length,
+        openHigh,
+        ready: s.status === "ready",
+        ...s
+      });
+    }
+  }
+  const keyOf = (d) => `${d.planUid}\0${d.branch}`;
+  const linesAt = (root) => drafts.filter((d) => canon(d.workstream) === canon(root));
+  const deps = [];
+  let signals = [];
+  try {
+    signals = (0, import_awareness_service.loadSignals)(projectRoot);
+  } catch {
+  }
+  for (const s of signals) {
+    if (s.kind !== "contract" || s.state === "resolved" || !s.subject.by) continue;
+    for (const first of linesAt(s.subject.by)) {
+      for (const root of s.workstreams.filter((w) => canon(w) !== canon(s.subject.by))) {
+        for (const then of linesAt(root)) deps.push({ first: keyOf(first), then: keyOf(then), symbol: s.subject.symbol ?? "an export" });
+      }
+    }
+  }
+  const order = (0, import_merge_order.mergeOrder)(drafts.map((d) => ({ key: keyOf(d), name: d.branch, ready: d.ready })), deps);
+  const byKey = new Map(drafts.map((d) => [keyOf(d), d]));
+  return {
+    base,
+    lines: order.map((o) => ({ ...byKey.get(o.key), position: o.position, reason: o.reason }))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reviewQueue
+});

package/src/backend/services/review-risk.js

@@ -0,0 +1,127 @@
+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 review_risk_exports = {};
+__export(review_risk_exports, {
+  relPath: () => relPath,
+  riskInputs: () => riskInputs,
+  riskMarkdown: () => riskMarkdown,
+  riskOf: () => riskOf,
+  riskOrder: () => riskOrder,
+  rulesHolding: () => rulesHolding
+});
+module.exports = __toCommonJS(review_risk_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_architecture_rule = require("./architecture-rule");
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function riskOf(file, i) {
+  let score = 0;
+  const why = [];
+  if (i.tests === "failing") {
+    score += 40;
+    why.push("its tests fail");
+  } else if (i.tests === "stale") {
+    score += 15;
+    why.push("its tests are older than the code");
+  }
+  const block = i.rules.filter((r) => r.strength === "block");
+  const warn = i.rules.filter((r) => r.strength === "warn");
+  if (block.length) {
+    score += 30 * block.length;
+    why.push(`in the scope of ${block.map((r) => r.id).join(", ")} (block)`);
+  }
+  if (warn.length) {
+    score += 10 * warn.length;
+    why.push(`in the scope of ${warn.map((r) => r.id).join(", ")} (warn)`);
+  }
+  if (i.otherWork.length) {
+    score += 20 * i.otherWork.length;
+    why.push(`also changed in ${i.otherWork.join(", ")}`);
+  }
+  if (i.dependents > 0) {
+    score += Math.min(i.dependents, 50);
+    why.push(`imported by ${plural(i.dependents, "file")}`);
+  }
+  if (i.dependents >= 10 && why.length > 1) why.unshift(why.pop());
+  return { path: file, score, why: why.length ? why.join(" \xB7 ") : "nothing depends on it, no rule holds it, and no other work touches it" };
+}
+function riskOrder(files, inputs) {
+  return [...new Set(files)].map((f) => riskOf(f, inputs(f))).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+}
+function rulesHolding(file, rules) {
+  return rules.filter((r) => r.strength !== "guide" && ((0, import_architecture_rule.inPattern)(r.from, file) || (0, import_architecture_rule.inPattern)(r.mayNotImport, file))).map((r) => ({ id: r.id, strength: r.strength }));
+}
+const relPath = (root, p) => (import_node_path.default.isAbsolute(p) ? import_node_path.default.relative(root, p) : p).split(import_node_path.default.sep).join("/").replace(/^\.\//, "");
+async function riskInputs(projectRoot, files, head) {
+  const { getFileDependencies } = await Promise.resolve().then(() => __toESM(require("./database")));
+  const { groundingOf } = await Promise.resolve().then(() => __toESM(require("./tests/grounding")));
+  const { rulesOf } = await Promise.resolve().then(() => __toESM(require("./architecture-rules")));
+  const { listWorkstreams } = await Promise.resolve().then(() => __toESM(require("./workstream-service")));
+  const rules = rulesOf(projectRoot);
+  const others = /* @__PURE__ */ new Map();
+  try {
+    for (const w of await listWorkstreams(projectRoot)) {
+      if (w.main || head && (w.branch === head || w.root === `branch:${head}` || w.branch?.endsWith(`/${head}`))) continue;
+      const label = w.branch ?? import_node_path.default.basename(w.root);
+      for (const f of w.changes.files) {
+        if (!files.includes(f.path)) continue;
+        others.set(f.path, [...others.get(f.path) ?? [], label]);
+      }
+    }
+  } catch {
+  }
+  return (file) => {
+    let dependents = 0;
+    try {
+      dependents = getFileDependencies(file).importedBy.length;
+    } catch {
+      dependents = 0;
+    }
+    let tests = null;
+    try {
+      tests = groundingOf(projectRoot, file).state;
+    } catch {
+      tests = null;
+    }
+    return { dependents, tests, rules: rulesHolding(file, rules), otherWork: [...new Set(others.get(file) ?? [])] };
+  };
+}
+function riskMarkdown(order, limit = 10) {
+  const lines = ["### Review in this order", ""];
+  order.slice(0, limit).forEach((r, n) => lines.push(`${n + 1}. \`${r.path}\` \u2014 ${r.why}`));
+  if (order.length > limit) lines.push("", `\u2026and ${order.length - limit} more, nothing to single out.`);
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  relPath,
+  riskInputs,
+  riskMarkdown,
+  riskOf,
+  riskOrder,
+  rulesHolding
+});

package/src/backend/services/review-task.js

@@ -0,0 +1,121 @@
+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 review_task_exports = {};
+__export(review_task_exports, {
+  itemWords: () => itemWords,
+  taskMarkdown: () => taskMarkdown,
+  taskOutcome: () => taskOutcome
+});
+module.exports = __toCommonJS(review_task_exports);
+var import_node_child_process = require("node:child_process");
+var import_plan_service = require("./plan-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_criteria_service = require("./criteria-service");
+var import_plan_review_service = require("./plan-review-service");
+const DONE = /* @__PURE__ */ new Set(["completed", "archived"]);
+const STATE_WORDS = {
+  met: "met",
+  submitted: "waiting for a person",
+  sent_back: "sent back",
+  stale: "stale",
+  open: "open"
+};
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const list = (xs, max = 5) => xs.length <= max ? xs.join(", ") : `${xs.slice(0, max).join(", ")} and ${xs.length - max} more`;
+function branchOf(projectRoot, head) {
+  if (head !== "HEAD") return head;
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", projectRoot, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return head;
+  }
+}
+function itemWords(i) {
+  const planned = i.landed.length + i.missing.length;
+  const files = i.verdict === "no-targets" ? "planned no files" : i.verdict === "landed" ? `touched every file it planned (${planned})` : i.verdict === "untouched" ? `touched none of the ${plural(planned, "file")} it planned: ${list(i.missing)}` : `touched ${i.landed.length} of the ${planned} files it planned; not ${list(i.missing)}`;
+  const met = i.criteria.filter((c) => c.state === "met").length;
+  const counts = (s) => i.criteria.filter((c) => c.state === s).length;
+  const rest = ["submitted", "sent_back", "stale"].filter((s) => counts(s) > 0).map((s) => `${counts(s)} ${STATE_WORDS[s]}`);
+  const criteria = i.criteria.length === 0 ? "no criteria" : `${met} of ${plural(i.criteria.length, "criterion", "criteria")} met${rest.length ? ` (${rest.join(", ")})` : ""}`;
+  const mark = i.verdict === "landed" && met === i.criteria.length ? "\u2713" : i.verdict === "untouched" || counts("sent_back") > 0 ? "\u2717" : "\u25D0";
+  return `${mark} ${i.title}: ${files}; ${criteria}.`;
+}
+function changedFiles(projectRoot, base, head) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", projectRoot, "diff", "--name-only", `${base}...${head}`, "--"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).split("\n").map((f) => f.trim()).filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+function taskOutcome(projectRoot, base, head) {
+  const branch = branchOf(projectRoot, head);
+  const linked = [];
+  for (const plan of (0, import_plan_service.listPlans)(projectRoot)) {
+    if (DONE.has(plan.status)) continue;
+    const mine = (0, import_plan_item_service.listAllItems)(plan.uid).filter((i) => i.workstream === branch);
+    if (mine.length === 0) continue;
+    const r = (0, import_plan_review_service.reviewPlan)({ planUid: plan.uid, projectPath: projectRoot, before: `commit:${base}`, after: `commit:${head}` });
+    if (!r.ok) continue;
+    for (const item of mine) {
+      const reviewed = r.review.items.find((x) => x.uid === item.uid);
+      if (reviewed) linked.push({ planUid: plan.uid, planTitle: plan.title, item, reviewed });
+    }
+  }
+  if (linked.length === 0) return null;
+  const changed = changedFiles(projectRoot, base, head) ?? [];
+  const targets = [];
+  const items = linked.map(({ planUid, planTitle, item, reviewed }) => {
+    const planned = [...reviewed.landed, ...reviewed.missing];
+    targets.push(...planned);
+    const landed = planned.filter((t) => changed.some((f) => (0, import_plan_review_service.covers)(t, f)));
+    const missing = planned.filter((t) => !landed.includes(t));
+    const verdict = planned.length === 0 ? "no-targets" : landed.length === 0 ? "untouched" : missing.length === 0 ? "landed" : "partial";
+    const o = {
+      planUid,
+      planTitle,
+      uid: item.uid,
+      title: item.title,
+      verdict,
+      criteria: (0, import_criteria_service.listCriteria)(item.uid).map((c) => ({ text: c.text, state: c.state })),
+      landed,
+      missing
+    };
+    return { ...o, words: itemWords(o) };
+  });
+  const unplanned = changed.filter((f) => !targets.some((t) => (0, import_plan_review_service.covers)(t, f)));
+  const rank = (w) => w.startsWith("\u2717") ? 0 : w.startsWith("\u25D0") ? 1 : 2;
+  const words = items.map((i) => i.words).sort((a, b) => rank(a) - rank(b));
+  if (unplanned.length) words.push(`Changed ${plural(unplanned.length, "file")} the task did not plan: ${list(unplanned)}.`);
+  return { branch, items, unplanned, words };
+}
+function taskMarkdown(t) {
+  const lines = ["### Did it do what the task said", ""];
+  for (const w of t.words) lines.push(`- ${w}`);
+  for (const i of t.items) {
+    if (i.criteria.length === 0) continue;
+    lines.push("", `**${i.title}**`, "");
+    for (const c of i.criteria) lines.push(`- ${c.state === "met" ? "\u2713" : c.state === "sent_back" ? "\u2717" : "\u25CB"} ${c.text} (${STATE_WORDS[c.state]})`);
+  }
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  itemWords,
+  taskMarkdown,
+  taskOutcome
+});