codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/awareness-signals.js

@@ -0,0 +1,267 @@
+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 awareness_signals_exports = {};
+__export(awareness_signals_exports, {
+  computeSignals: () => computeSignals,
+  contractCandidates: () => contractCandidates,
+  draft: () => draft,
+  importableName: () => importableName,
+  newlySerious: () => newlySerious,
+  outsideScope: () => outsideScope,
+  reconcileSignals: () => reconcileSignals,
+  workstreamLabel: () => workstreamLabel
+});
+module.exports = __toCommonJS(awareness_signals_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_path = __toESM(require("node:path"));
+var import_architecture_rule = require("./architecture-rule");
+var import_rule_pattern = require("../../shared/lib/rule-pattern");
+var import_check_words = require("../../shared/lib/check-words");
+const NEVER_DRIFT = /^\.codetrellis\//;
+function outsideScope(files, scope) {
+  const paths = new Set(scope.paths);
+  const dirs = scope.dirs.map((d) => d.replace(/\/+$/, "") + "/");
+  const inside = (p) => paths.has(p) || dirs.some((d) => p.startsWith(d));
+  return [...new Set(files.flatMap((f) => {
+    if (NEVER_DRIFT.test(f.path)) return [];
+    const ends = f.status === "renamed" && f.from ? [f.from, f.path] : [f.path];
+    return ends.every(inside) ? [] : [f.path];
+  }))].sort();
+}
+const importableName = (symbol) => symbol.replace(/^\((\w+)\)/, "$1").split(/[.#]/)[0];
+function contractCandidates(files) {
+  const out = [];
+  for (const f of files) {
+    for (const s of f.symbols ?? []) {
+      if (!s.exported) continue;
+      if (s.change === "modified" && s.signature) out.push({ file: f.path, symbol: s.name, change: "signature", signature: s.signature });
+      else if (s.change === "removed") out.push({ file: f.status === "renamed" && f.from ? f.from : f.path, symbol: s.name, change: "removed" });
+    }
+  }
+  return out;
+}
+const signalId = (kind, subject, workstreams) => (0, import_node_crypto.createHash)("sha1").update(`${kind}\0${subject}\0${workstreams.join("\0")}`).digest("hex").slice(0, 16);
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+const workstreamLabel = (w) => w.branch ?? import_node_path.default.basename(w.root);
+function draft(kind, severity, subjectKey, subject, roots, summary, shapeOf = subject) {
+  const workstreams = [...roots].sort();
+  const shape = (0, import_node_crypto.createHash)("sha1").update(JSON.stringify(shapeOf)).digest("hex").slice(0, 16);
+  return { id: signalId(kind, subjectKey, workstreams), kind, severity, subject, workstreams, summary, shape };
+}
+function collisionShape(w, file, symbol) {
+  const changed = (w.files.find((f) => f.path === file)?.symbols ?? []).filter((s) => !symbol || s.name === symbol).map((s) => s.signature ? `${s.name}:${s.signature.after}` : s.name);
+  const declared = (w.intended ?? []).filter((d) => d.path === file).flatMap((d) => d.symbols).filter((n) => !symbol || n === symbol);
+  return [.../* @__PURE__ */ new Set([...changed, ...declared.filter((n) => !changed.some((c) => c === n || c.startsWith(`${n}:`)))])].sort();
+}
+function touches(w) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of w.files) out.set(f.path, { file: true, changed: new Set((f.symbols ?? []).map((s) => s.name)), declared: /* @__PURE__ */ new Set() });
+  for (const d of w.intended ?? []) {
+    const t = out.get(d.path) ?? { file: false, changed: /* @__PURE__ */ new Set(), declared: /* @__PURE__ */ new Set() };
+    for (const s of d.symbols) t.declared.add(s);
+    out.set(d.path, t);
+  }
+  return out;
+}
+function computeSignals(footprints) {
+  const out = [];
+  const ordered = [...footprints].sort((a, b) => a.root.localeCompare(b.root));
+  for (let i = 0; i < ordered.length; i++) {
+    for (let j = i + 1; j < ordered.length; j++) {
+      const a = ordered[i];
+      const b = ordered[j];
+      const sa = touches(a);
+      const sb = touches(b);
+      for (const [file, ta] of sa) {
+        const tb = sb.get(file);
+        if (!tb) continue;
+        const shared = [.../* @__PURE__ */ new Set([...ta.changed, ...ta.declared])].filter((n) => tb.changed.has(n) || tb.declared.has(n)).sort();
+        const onlyDeclared = (t, symbol) => symbol ? !t.changed.has(symbol) : !t.file;
+        const said = (symbol) => [onlyDeclared(ta, symbol) ? a.root : null, onlyDeclared(tb, symbol) ? b.root : null].filter((r) => r !== null);
+        const words = (subject, symbol) => {
+          const [da, db] = [onlyDeclared(ta, symbol), onlyDeclared(tb, symbol)];
+          const [la, lb] = [`\`${workstreamLabel(a)}\``, `\`${workstreamLabel(b)}\``];
+          if (!da && !db) return `${la} and ${lb} both change ${subject}`;
+          if (da && db) return `${la} and ${lb} both mean to change ${subject} (declared; nothing changed yet)`;
+          return da ? `${la} means to change ${subject} (declared), and ${lb} changes it` : `${lb} means to change ${subject} (declared), and ${la} changes it`;
+        };
+        if (shared.length > 0) {
+          for (const symbol of shared) {
+            const intended = said(symbol);
+            out.push(draft(
+              "collision",
+              "high",
+              `${file}#${symbol}`,
+              { file, symbol, ...intended.length ? { intended } : {} },
+              [a.root, b.root],
+              words(`${file} \u2192 ${symbol}`, symbol),
+              [collisionShape(a, file, symbol), collisionShape(b, file, symbol)]
+            ));
+          }
+        } else {
+          const intended = said();
+          out.push(draft(
+            "collision",
+            "medium",
+            file,
+            { file, ...intended.length ? { intended } : {} },
+            [a.root, b.root],
+            words(file),
+            [collisionShape(a, file), collisionShape(b, file)]
+          ));
+        }
+      }
+    }
+  }
+  for (const a of ordered) {
+    for (const c of a.contracts ?? []) {
+      for (const b of ordered) {
+        if (b === a) continue;
+        const theirs = new Set(b.files.filter((f) => f.status !== "deleted").map((f) => f.path));
+        const hits = c.importers.filter((i) => theirs.has(i.path) && i.path !== c.file);
+        if (hits.length === 0) continue;
+        const possibly = hits.every((i) => i.possibly);
+        const importers = hits.map((i) => i.path).sort();
+        const what = c.change === "removed" ? `removed ${c.symbol} from ${c.file}` : `changed ${c.symbol} in ${c.file}: ${c.signature.before} \u2192 ${c.signature.after}`;
+        const uses = possibly ? `may use it in ${plural(importers.length, "file")} (it imports the module as a whole)` : `imports it in ${plural(importers.length, "file")}`;
+        out.push(draft("contract", possibly ? "medium" : "high", `${a.root}>${c.file}#${c.symbol}`, {
+          file: c.file,
+          symbol: c.symbol,
+          by: a.root,
+          change: c.change,
+          ...c.signature ? { signature: c.signature } : {},
+          importers,
+          ...possibly ? { possibly: true } : {}
+        }, [a.root, b.root], `\`${workstreamLabel(a)}\` ${what}. \`${workstreamLabel(b)}\` ${uses}`));
+      }
+    }
+  }
+  for (const w of ordered) {
+    if (!w.scope || w.scope.paths.length === 0 && w.scope.dirs.length === 0) continue;
+    const files = outsideScope(w.files, w.scope);
+    if (files.length === 0) continue;
+    const from = [
+      w.scope.items.length ? w.scope.items.length === 1 ? "its claimed item" : "its claimed items" : null,
+      w.scope.declared ? "its declared intent" : null
+    ].filter(Boolean).join(" and ");
+    const shown = files.length <= 3 ? files.join(", ") : `${files.slice(0, 3).join(", ")} and ${files.length - 3} more`;
+    const rules = (w.rules ?? []).map((r) => ({ id: r.id, suite: r.suite ?? "architecture", words: r.words, strength: r.strength ?? "block", files: files.filter((f) => (0, import_rule_pattern.ruleCovers)(r, f)) })).filter((r) => r.files.length > 0).sort((a, b) => a.id.localeCompare(b.id));
+    const ruleWords = rules.length === 0 ? "" : `. ${rules.length === 1 ? "A rule is" : `${rules.length} rules are`} about ${files.length === 1 ? "it" : "them"}: ${rules.map((r) => `${r.id} (${r.suite}, ${r.strength})`).join(", ")}`;
+    out.push(draft(
+      "drift",
+      "medium",
+      w.root,
+      { files, ...w.scope.items.length ? { items: [...w.scope.items].sort() } : {}, ...rules.length ? { rules } : {} },
+      [w.root],
+      `\`${workstreamLabel(w)}\` changes ${plural(files.length, "file")} outside the scope ${from} give${from.includes(" and ") || w.scope.items.length > 1 ? "" : "s"} it: ${shown}${ruleWords}`
+    ));
+  }
+  for (const w of ordered) {
+    for (const { rule, edges } of w.ruleBreaches ?? []) {
+      if (edges.length === 0) continue;
+      const sorted = [...edges].sort((x, y) => x.from.localeCompare(y.from) || x.to.localeCompare(y.to));
+      const shown = sorted.slice(0, 2).map((e) => `${e.from} \u2192 ${e.to}`).join(", ") + (sorted.length > 2 ? ` and ${sorted.length - 2} more` : "");
+      const what = !rule.kind || rule.kind === "imports" ? ` now imports ${rule.mayNotImport} from ${rule.from} (${shown})` : `: ${sorted.slice(0, 2).map((e) => `${e.from} ${(0, import_check_words.reachWords)(e.to)}`).join(", ")}${sorted.length > 2 ? ` and ${sorted.length - 2} more` : ""}`;
+      const words = (0, import_architecture_rule.ruleStatement)({ ...rule, except: [] });
+      out.push(draft(
+        "rule",
+        rule.strength === "warn" ? "medium" : "high",
+        `${w.root}\0${rule.id}`,
+        {
+          files: [...new Set(sorted.map((e) => e.from))],
+          rule: { id: rule.id, words, because: rule.because },
+          edges: sorted
+        },
+        [w.root],
+        `\`${workstreamLabel(w)}\`${what}, which the rule \u201C${words}\u201D forbids${rule.because ? `: ${rule.because}` : ""}`,
+        sorted.map((e) => `${e.from}>${e.to}`).join(",")
+      ));
+    }
+  }
+  for (const w of ordered) {
+    if (w.main || w.mainSinceBase.length === 0) continue;
+    const touched = new Set(w.files.map((f) => f.path));
+    const files = [...new Set(w.mainSinceBase)].filter((p) => touched.has(p)).sort();
+    if (files.length === 0) continue;
+    const shown = files.length <= 3 ? files.join(", ") : `${files.slice(0, 3).join(", ")} and ${files.length - 3} more`;
+    out.push(draft(
+      "stale-base",
+      "low",
+      w.root,
+      { files },
+      [w.root],
+      `main changed ${shown} since \`${workstreamLabel(w)}\` branched, and \`${workstreamLabel(w)}\` changes ${files.length === 1 ? "it" : "them"} too`
+    ));
+  }
+  const rank = { high: 0, medium: 1, low: 2 };
+  return out.sort((x, y) => rank[x.severity] - rank[y.severity] || x.id.localeCompare(y.id));
+}
+function reconcileSignals(previous, drafts, now) {
+  const known = new Map(previous.map((s) => [s.id, s]));
+  const upserts = [];
+  const reopened = [];
+  for (const d of drafts) {
+    const was = known.get(d.id);
+    if (!was) {
+      upserts.push({ ...d, firstSeen: now, lastSeen: now, state: "open" });
+      continue;
+    }
+    const reshaped = !!was.shape && was.shape !== d.shape;
+    if (reshaped && (was.state === "acknowledged" || was.state === "intended")) {
+      const { stateBy: _by, stateAt: _at, ...rest } = was;
+      upserts.push({ ...rest, ...d, state: "open", lastSeen: now, reopened: { from: was.state, at: now } });
+      reopened.push(d.id);
+      continue;
+    }
+    const state = was.state === "resolved" ? "open" : was.state;
+    const moved = state !== was.state || was.summary !== d.summary || was.severity !== d.severity || was.shape !== d.shape || JSON.stringify(was.subject) !== JSON.stringify(d.subject);
+    if (moved) upserts.push({ ...was, ...d, state, lastSeen: now });
+  }
+  const live = new Set(drafts.map((d) => d.id));
+  const resolved = previous.filter((s) => s.state !== "resolved" && !live.has(s.id)).map((s) => s.id);
+  return { upserts, resolved, reopened };
+}
+function newlySerious(previous, upserts, reopened) {
+  const was = new Map(previous.map((s) => [s.id, s]));
+  return upserts.filter((u) => {
+    if (u.severity !== "high" || u.state !== "open") return false;
+    const p = was.get(u.id);
+    return !p || p.state === "resolved" || reopened.includes(u.id) || p.state === "open" && p.severity !== "high";
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeSignals,
+  contractCandidates,
+  draft,
+  importableName,
+  newlySerious,
+  outsideScope,
+  reconcileSignals,
+  workstreamLabel
+});

package/src/backend/services/baseline-store.js

@@ -0,0 +1,83 @@
+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 baseline_store_exports = {};
+__export(baseline_store_exports, {
+  baselineFromJson: () => baselineFromJson,
+  baselineToJson: () => baselineToJson,
+  sqliteBaselineStore: () => sqliteBaselineStore
+});
+module.exports = __toCommonJS(baseline_store_exports);
+var import_database = require("./database");
+function baselineToJson(b) {
+  const stored = {
+    files: [...b.files.entries()],
+    edges: [...b.edges],
+    timestamp: b.timestamp,
+    commitHash: b.commitHash ?? null,
+    shortCommitHash: b.shortCommitHash ?? null,
+    source: b.source,
+    dirty: b.dirty,
+    capturedAt: b.capturedAt
+  };
+  return JSON.stringify(stored);
+}
+function baselineFromJson(json, projectPath) {
+  let s;
+  try {
+    s = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(s.files) || !Array.isArray(s.edges) || typeof s.capturedAt !== "number") return null;
+  if (s.source !== "scan" && s.source !== "commit" && s.source !== "working-tree") return null;
+  return {
+    files: new Map(s.files),
+    edges: new Set(s.edges),
+    timestamp: typeof s.timestamp === "number" ? s.timestamp : s.capturedAt,
+    commitHash: s.commitHash ?? null,
+    shortCommitHash: s.shortCommitHash ?? null,
+    source: s.source,
+    dirty: s.dirty === true,
+    capturedAt: s.capturedAt,
+    projectPath
+  };
+}
+const sqliteBaselineStore = {
+  save(b) {
+    if (!b.projectPath) return;
+    (0, import_database.getDb)().run(
+      `INSERT INTO project_baselines (project_path, data_json, updated_at) VALUES (?, ?, ?)
+       ON CONFLICT(project_path) DO UPDATE SET data_json = excluded.data_json, updated_at = excluded.updated_at`,
+      [b.projectPath, baselineToJson(b), Date.now()]
+    );
+  },
+  load(projectPath) {
+    const res = (0, import_database.getDb)().exec("SELECT data_json FROM project_baselines WHERE project_path = ?", [projectPath]);
+    const json = res[0]?.values[0]?.[0];
+    return typeof json === "string" ? baselineFromJson(json, projectPath) : null;
+  },
+  remove(projectPath) {
+    (0, import_database.getDb)().run("DELETE FROM project_baselines WHERE project_path = ?", [projectPath]);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  baselineFromJson,
+  baselineToJson,
+  sqliteBaselineStore
+});

package/src/backend/services/branch-workstreams.js

@@ -0,0 +1,341 @@
+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 branch_workstreams_exports = {};
+__export(branch_workstreams_exports, {
+  INLINE_BRANCHES: () => INLINE_BRANCHES,
+  INLINE_MS: () => INLINE_MS,
+  branchVersions: () => branchVersions,
+  branchWorkstreamsOf: () => branchWorkstreamsOf,
+  branchWorkstreamsWarmed: () => branchWorkstreamsWarmed,
+  isMergedInto: () => isMergedInto,
+  listBranchRefs: () => listBranchRefs,
+  mainVersionsSince: () => mainVersionsSince,
+  mainVersionsSinceAsync: () => mainVersionsSinceAsync,
+  notifyBranchesWarmed: () => notifyBranchesWarmed,
+  parseForEachRef: () => parseForEachRef,
+  parseRawZ: () => parseRawZ,
+  resetBranchWorkstreamCache: () => resetBranchWorkstreamCache,
+  selectBranchWorkstreams: () => selectBranchWorkstreams,
+  setBranchWorkstreamsWarmedListener: () => setBranchWorkstreamsWarmedListener,
+  showAt: () => showAt,
+  showAtAsync: () => showAtAsync
+});
+module.exports = __toCommonJS(branch_workstreams_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+var import_git_env = require("./git-env");
+var import_workstream_watch_service = require("./workstream-watch-service");
+function git(repo, args) {
+  return (0, import_node_child_process.execFileSync)("git", ["-C", repo, ...args], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 5e3,
+    maxBuffer: 16 * 1024 * 1024
+  });
+}
+const gitAsync = (repo, args) => (0, import_git_env.gitAsync)(repo, args);
+function parseForEachRef(out) {
+  return out.split("\n").flatMap((line) => {
+    const [ref, short, head, when] = line.split("\0");
+    if (!ref || !short || !head) return [];
+    return [{ ref, short, head, committedAt: Number(when) || 0 }];
+  });
+}
+function selectBranchWorkstreams(refs, opts) {
+  const local = new Set(refs.filter((r) => r.ref.startsWith("refs/heads/")).map((r) => r.short));
+  const cutoff = opts.nowSec - opts.windowDays * 86400;
+  return refs.filter((r) => {
+    if (r.ref.endsWith("/HEAD")) return false;
+    const name = r.ref.startsWith("refs/remotes/") ? r.short.split("/").slice(1).join("/") : r.short;
+    if (r.ref.startsWith("refs/remotes/") && local.has(name)) return false;
+    if (name === opts.mainBranch || opts.checkedOut.has(name)) return false;
+    if (r.committedAt < cutoff) return false;
+    return opts.aheadOf(r);
+  });
+}
+const ZERO = /^0{40}$/;
+function parseRawZ(out) {
+  const parts = out.split("\0");
+  const changes = [];
+  for (let i = 0; i < parts.length; i++) {
+    const meta = parts[i].replace(/^\n+/, "");
+    if (!meta.startsWith(":")) continue;
+    const fields = meta.slice(1).split(" ");
+    const path = parts[++i];
+    if (!path || fields.length < 5) continue;
+    changes.push({ path, blob: ZERO.test(fields[3]) || fields[4].startsWith("D") ? null : fields[3] });
+  }
+  return changes;
+}
+function isMergedInto(branch, mainLeft) {
+  return branch.length > 0 && branch.every((c) => mainLeft.has(`${c.path}\0${c.blob ?? "deleted"}`));
+}
+function mainVersionsSince(repo, mainHead, sinceSec) {
+  const out = /* @__PURE__ */ new Set();
+  if (!/^[0-9a-f]{40}$/.test(mainHead)) return out;
+  try {
+    const log = git(repo, [
+      "log",
+      mainHead,
+      `--since=@${Math.max(0, Math.floor(sinceSec))}`,
+      "--max-count=5000",
+      "--format=",
+      "--raw",
+      "-z",
+      "--no-renames",
+      "--no-abbrev"
+    ]);
+    for (const c of parseRawZ(log)) out.add(`${c.path}\0${c.blob ?? "deleted"}`);
+  } catch {
+  }
+  return out;
+}
+async function mainVersionsSinceAsync(repo, mainHead, sinceSec) {
+  const out = /* @__PURE__ */ new Set();
+  if (!/^[0-9a-f]{40}$/.test(mainHead)) return out;
+  try {
+    const log = await gitAsync(repo, [
+      "log",
+      mainHead,
+      `--since=@${Math.max(0, Math.floor(sinceSec))}`,
+      "--max-count=5000",
+      "--format=",
+      "--raw",
+      "-z",
+      "--no-renames",
+      "--no-abbrev"
+    ]);
+    for (const c of parseRawZ(log)) out.add(`${c.path}\0${c.blob ?? "deleted"}`);
+  } catch {
+  }
+  return out;
+}
+function branchVersions(repo, mainHead, head) {
+  if (!/^[0-9a-f]{40}$/.test(mainHead) || !/^[0-9a-f]{40}$/.test(head)) return [];
+  try {
+    const base = git(repo, ["merge-base", mainHead, head]).trim();
+    return parseRawZ(git(repo, ["diff", "--raw", "-z", "--no-renames", "--no-abbrev", base, head, "--"]));
+  } catch {
+    return [];
+  }
+}
+function listBranchRefs(repo) {
+  try {
+    return parseForEachRef(git(repo, [
+      "for-each-ref",
+      "--format=%(refname)%00%(refname:short)%00%(objectname)%00%(committerdate:unix)",
+      "refs/heads",
+      "refs/remotes"
+    ]));
+  } catch {
+    return [];
+  }
+}
+async function listBranchRefsAsync(repo) {
+  try {
+    return parseForEachRef(await gitAsync(repo, [
+      "for-each-ref",
+      "--format=%(refname)%00%(refname:short)%00%(objectname)%00%(committerdate:unix)",
+      "refs/heads",
+      "refs/remotes"
+    ]));
+  } catch {
+    return [];
+  }
+}
+function showAt(repo, commit, relPath) {
+  if (!/^[0-9a-f]{40}$/.test(commit) || relPath.startsWith("-")) return null;
+  try {
+    return git(repo, ["show", `${commit}:${relPath}`]);
+  } catch {
+    return null;
+  }
+}
+async function showAtAsync(repo, commit, relPath) {
+  if (!/^[0-9a-f]{40}$/.test(commit) || relPath.startsWith("-")) return null;
+  try {
+    return await gitAsync(repo, ["show", `${commit}:${relPath}`]);
+  } catch {
+    return null;
+  }
+}
+const cache = /* @__PURE__ */ new Map();
+const mainCache = /* @__PURE__ */ new Map();
+const INLINE_BRANCHES = 8;
+const INLINE_MS = 1500;
+const WARM_CONCURRENCY = 4;
+let onWarmed = () => {
+};
+function setBranchWorkstreamsWarmedListener(listener) {
+  onWarmed = listener;
+}
+function notifyBranchesWarmed(repo) {
+  onWarmed(repo);
+}
+const warming = /* @__PURE__ */ new Map();
+function branchWorkstreamsWarmed(repo) {
+  return warming.get(repo) ?? Promise.resolve();
+}
+function resetBranchWorkstreamCache() {
+  cache.clear();
+  mainCache.clear();
+}
+const inflight = /* @__PURE__ */ new Map();
+function entryFor(repo, mainHead, head, mainLeft) {
+  const k = `${repo}\0${head}\0${mainHead}`;
+  const hit = cache.get(k);
+  if (hit) return Promise.resolve(hit);
+  let p = inflight.get(k);
+  if (!p) {
+    p = (0, import_git_env.inBackground)(() => computeEntry(repo, mainHead, head, mainLeft)).then((e) => {
+      cache.set(k, e);
+      return e;
+    }).finally(() => inflight.delete(k));
+    inflight.set(k, p);
+  }
+  return p;
+}
+function within(p, ms) {
+  if (ms <= 0) return Promise.resolve(null);
+  let timer;
+  const late = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(null), ms);
+    timer.unref?.();
+  });
+  return Promise.race([p, late]).finally(() => clearTimeout(timer));
+}
+async function computeEntry(repo, mainHead, head, mainLeft) {
+  const entry = { ahead: false, merged: null, changes: null };
+  try {
+    entry.ahead = Number((await gitAsync(repo, ["rev-list", "--count", `${mainHead}..${head}`])).trim()) > 0;
+  } catch {
+    return entry;
+  }
+  if (!entry.ahead) return entry;
+  let base = "";
+  try {
+    base = (await gitAsync(repo, ["merge-base", mainHead, head])).trim();
+  } catch {
+    return entry;
+  }
+  try {
+    const versions = parseRawZ(await gitAsync(repo, ["diff", "--raw", "-z", "--no-renames", "--no-abbrev", base, head, "--"]));
+    entry.merged = isMergedInto(versions, await mainLeft());
+  } catch {
+    entry.merged = false;
+  }
+  if (entry.merged) return entry;
+  try {
+    let files = (0, import_workstream_watch_service.parseNameStatusZ)(await gitAsync(repo, ["diff", "--name-status", "-z", "-M", base, head, "--"]));
+    files = (0, import_workstream_watch_service.withLineCounts)(files, (0, import_workstream_watch_service.parseNumstatZ)(await gitAsync(repo, ["diff", "--numstat", "-z", "-M", base, head, "--"])));
+    entry.changes = { base, ...(0, import_workstream_watch_service.combineChanges)(files, []) };
+  } catch {
+    entry.changes = { base, ...(0, import_workstream_watch_service.combineChanges)([], []) };
+  }
+  return entry;
+}
+function warm(repo, mainHead, heads, mainLeft) {
+  if (warming.has(repo) || heads.length === 0) return;
+  const todo = [...new Set(heads)];
+  const run = (0, import_git_env.inBackground)(async () => {
+    const worker = async () => {
+      for (let head = todo.shift(); head; head = todo.shift()) {
+        await entryFor(repo, mainHead, head, mainLeft);
+      }
+    };
+    await Promise.all(Array.from({ length: WARM_CONCURRENCY }, worker));
+  }).finally(() => {
+    warming.delete(repo);
+    onWarmed(repo);
+  });
+  warming.set(repo, run);
+}
+async function branchWorkstreamsOf(repo, opts) {
+  if (!opts.mainRef || !(0, import_git_safety.isSafeGitRef)(opts.mainRef)) return [];
+  let mainHead;
+  try {
+    mainHead = (await gitAsync(repo, ["rev-parse", "--verify", opts.mainRef])).trim();
+  } catch {
+    return [];
+  }
+  if (cache.size > 2e3 && !warming.size) cache.clear();
+  if (mainCache.size > 50) mainCache.clear();
+  const nowSec = opts.nowSec ?? Math.floor(Date.now() / 1e3);
+  const since = nowSec - (opts.windowDays + 1) * 86400;
+  const mainKey = `${repo}\0${mainHead}\0${Math.floor(since / 86400)}`;
+  const mainLeft = async () => {
+    let v = mainCache.get(mainKey);
+    if (!v) {
+      v = await mainVersionsSinceAsync(repo, mainHead, since);
+      mainCache.set(mainKey, v);
+    }
+    return v;
+  };
+  const candidates = selectBranchWorkstreams(await listBranchRefsAsync(repo), {
+    mainBranch: opts.mainBranch,
+    checkedOut: opts.checkedOut,
+    windowDays: opts.windowDays,
+    nowSec,
+    aheadOf: () => true
+  });
+  let budget = opts.inline ?? INLINE_BRANCHES;
+  const deadline = Date.now() + (opts.inlineMs ?? INLINE_MS);
+  const later = [];
+  const selected = [];
+  for (const r of candidates) {
+    const k = `${repo}\0${r.head}\0${mainHead}`;
+    let hit = cache.get(k);
+    if (!hit) {
+      if (budget <= 0 || warming.has(repo)) {
+        later.push(r.head);
+        continue;
+      }
+      budget--;
+      hit = await within(entryFor(repo, mainHead, r.head, mainLeft), deadline - Date.now()) ?? void 0;
+      if (!hit) {
+        budget = 0;
+        later.push(r.head);
+        continue;
+      }
+    }
+    if (!hit.ahead || hit.merged) continue;
+    selected.push({ ...r, changes: hit.changes ?? { base: null, files: [], truncated: false } });
+  }
+  warm(repo, mainHead, later, mainLeft);
+  return selected;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INLINE_BRANCHES,
+  INLINE_MS,
+  branchVersions,
+  branchWorkstreamsOf,
+  branchWorkstreamsWarmed,
+  isMergedInto,
+  listBranchRefs,
+  mainVersionsSince,
+  mainVersionsSinceAsync,
+  notifyBranchesWarmed,
+  parseForEachRef,
+  parseRawZ,
+  resetBranchWorkstreamCache,
+  selectBranchWorkstreams,
+  setBranchWorkstreamsWarmedListener,
+  showAt,
+  showAtAsync
+});