codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/item-git-state.js

@@ -0,0 +1,208 @@
+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 item_git_state_exports = {};
+__export(item_git_state_exports, {
+  branchGitState: () => branchGitState,
+  planGitStates: () => planGitStates,
+  planGitStatesFresh: () => planGitStatesFresh,
+  refreshPlanHostStates: () => refreshPlanHostStates
+});
+module.exports = __toCommonJS(item_git_state_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+var import_branch_workstreams = require("./branch-workstreams");
+var import_plan_service = require("./plan-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_worktree_service = require("./worktree-service");
+var import_trusted_roots = require("./trusted-roots");
+var import_section_workstreams = require("./section-workstreams");
+var import_git_state_words = require("../../shared/lib/git-state-words");
+var import_host_state = require("./review-host/host-state");
+const SHA = /^[0-9a-f]{40}$/;
+const KEY_WINDOW_DAYS = 90;
+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
+  });
+}
+function tryGit(repo, args) {
+  try {
+    return git(repo, args);
+  } catch {
+    return null;
+  }
+}
+const commitTime = (repo, sha) => Number(tryGit(repo, ["show", "-s", "--format=%ct", sha])?.trim()) || null;
+const isAncestor = (repo, a, b) => tryGit(repo, ["merge-base", "--is-ancestor", a, b]) !== null;
+function createdAt(repo, branch) {
+  const out = tryGit(repo, ["reflog", "show", "--format=%H", `refs/heads/${branch}`]);
+  const lines = out?.trim().split("\n").filter((l) => SHA.test(l)) ?? [];
+  return lines.length ? lines[lines.length - 1] : null;
+}
+function mergeCommitOf(repo, head, baseHead) {
+  const out = tryGit(repo, ["rev-list", "--merges", "--ancestry-path", "--parents", "--reverse", `${head}..${baseHead}`]);
+  for (const line of out?.trim().split("\n") ?? []) {
+    const [commit, , ...others] = line.split(" ");
+    if (others.includes(head)) return commit;
+  }
+  return null;
+}
+function lastTouch(repo, baseHead, path, sinceSec) {
+  const out = tryGit(repo, ["log", baseHead, `--since=@${Math.max(0, sinceSec)}`, "-1", "--format=%H", "--", path]);
+  const sha = out?.trim() ?? "";
+  return SHA.test(sha) ? sha : null;
+}
+function commitNaming(repo, baseHead, keys, sinceSec) {
+  const clean = keys.filter((k) => /^[A-Za-z0-9][A-Za-z0-9_.#-]{3,63}$/.test(k));
+  if (clean.length === 0) return null;
+  const args = ["log", baseHead, `--since=@${Math.max(0, sinceSec)}`, "--max-count=50", "--format=%H%x00%B%x1e", "-i", "-F"];
+  for (const k of clean) args.push(`--grep=${k}`);
+  const words = clean.map((k) => new RegExp(`(^|[^A-Za-z0-9_])${k.replace(/[.#-]/g, (c) => `\\${c}`)}($|[^A-Za-z0-9_])`, "i"));
+  for (const entry of (tryGit(repo, args) ?? "").split("")) {
+    const [sha, message = ""] = entry.replace(/^\s+/, "").split("\0");
+    if (SHA.test(sha) && words.some((w) => w.test(message))) return sha;
+  }
+  return null;
+}
+function refsOf(all, branch) {
+  const local = all.find((r) => r.ref === `refs/heads/${branch}`) ?? null;
+  const remote = all.find((r) => r.ref.startsWith("refs/remotes/") && !r.ref.endsWith("/HEAD") && r.short.split("/").slice(1).join("/") === branch) ?? null;
+  return { local, remote };
+}
+function baseHeads(all, base) {
+  const { local, remote } = refsOf(all, base);
+  return [...new Set([local?.head, remote?.head].filter((h) => !!h && SHA.test(h)))];
+}
+function mergedInto(repo, branch, head, headTime, bases) {
+  for (const baseHead of bases) {
+    if (isAncestor(repo, head, baseHead)) {
+      const merge = head !== baseHead ? mergeCommitOf(repo, head, baseHead) : null;
+      if (merge) return { commit: merge, how: "merge" };
+      const made = createdAt(repo, branch);
+      if (made ? made !== head : head !== baseHead) return { commit: head, how: "fast-forward" };
+      continue;
+    }
+    const since = headTime - 86400;
+    const versions = (0, import_branch_workstreams.branchVersions)(repo, baseHead, head);
+    if ((0, import_branch_workstreams.isMergedInto)(versions, (0, import_branch_workstreams.mainVersionsSince)(repo, baseHead, since))) {
+      return { commit: lastTouch(repo, baseHead, versions[0].path, since) ?? baseHead, how: "squash-or-rebase" };
+    }
+  }
+  return null;
+}
+function branchGitState(repo, branch, base, keys, opts = {}) {
+  const out = { state: "none", source: "git", branch, base, commit: null, at: null };
+  if (!(0, import_git_safety.isSafeGitRef)(branch)) return out;
+  const all = opts.refs ?? (0, import_branch_workstreams.listBranchRefs)(repo);
+  const { local, remote } = refsOf(all, branch);
+  const bases = base && (0, import_git_safety.isSafeGitRef)(base) ? baseHeads(all, base) : [];
+  const head = local?.head ?? remote?.head ?? null;
+  if (!head) {
+    const since = (opts.nowSec ?? Math.floor(Date.now() / 1e3)) - KEY_WINDOW_DAYS * 86400;
+    for (const baseHead of bases) {
+      const named = commitNaming(repo, baseHead, keys, since);
+      if (named) return { ...out, state: "merged", commit: named, at: commitTime(repo, named), how: "names-key" };
+    }
+    return out;
+  }
+  const headTime = (local ?? remote).committedAt || commitTime(repo, head) || 0;
+  const merged = bases.length ? mergedInto(repo, branch, head, headTime, bases) : null;
+  if (merged) return { ...out, state: "merged", commit: merged.commit, at: commitTime(repo, merged.commit), how: merged.how };
+  if (remote) {
+    const unpushed = local && local.head !== remote.head ? Number(tryGit(repo, ["rev-list", "--count", `${remote.head}..${local.head}`])?.trim()) || 0 : 0;
+    return {
+      ...out,
+      state: "pushed",
+      commit: remote.head,
+      at: remote.committedAt || null,
+      remote: remote.short.split("/")[0],
+      ...unpushed ? { unpushed } : {}
+    };
+  }
+  return { ...out, state: "building", commit: head, at: headTime || null };
+}
+function planGitStates(planUid, opts = {}) {
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan) return null;
+  let root;
+  try {
+    root = (0, import_trusted_roots.resolveTrustedProjectRoot)(plan.projectPath, "plan git state");
+  } catch {
+    return { base: null, items: [] };
+  }
+  let repo = root;
+  let mainBranch = null;
+  try {
+    const main = (0, import_worktree_service.listWorktrees)(root).find((w) => w.isMain);
+    if (main) {
+      repo = main.path;
+      mainBranch = main.branch;
+    }
+  } catch {
+  }
+  const base = (0, import_section_workstreams.usableBase)(plan.baseRef) ?? mainBranch;
+  const refs = (0, import_branch_workstreams.listBranchRefs)(repo);
+  const seen = /* @__PURE__ */ new Map();
+  const items = [];
+  for (const item of (0, import_plan_item_service.listAllItems)(planUid)) {
+    const section = (0, import_section_workstreams.resolveSection)(item, import_plan_item_service.getItem);
+    if (!section) continue;
+    const keys = [.../* @__PURE__ */ new Set([item.uid.slice(0, 8), section.fromUid.slice(0, 8)])];
+    const k = `${section.branch}\0${keys.join("\0")}`;
+    const git2 = seen.get(k) ?? branchGitState(repo, section.branch, base, keys, { refs, nowSec: opts.nowSec });
+    seen.set(k, git2);
+    const state = (0, import_host_state.overlayHost)(git2, (0, import_host_state.cachedHostRead)(root, section.branch));
+    items.push({ ...state, itemUid: item.uid, fromUid: section.fromUid, words: (0, import_git_state_words.gitStateWords)(state) });
+  }
+  return { base, items };
+}
+function planBranches(planUid) {
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan) return null;
+  let root;
+  try {
+    root = (0, import_trusted_roots.resolveTrustedProjectRoot)(plan.projectPath, "plan git state");
+  } catch {
+    return null;
+  }
+  const branches = /* @__PURE__ */ new Set();
+  for (const item of (0, import_plan_item_service.listAllItems)(planUid)) {
+    const section = (0, import_section_workstreams.resolveSection)(item, import_plan_item_service.getItem);
+    if (section && (0, import_git_safety.isSafeGitRef)(section.branch)) branches.add(section.branch);
+  }
+  return { root, branches: [...branches] };
+}
+async function planGitStatesFresh(planUid, opts = {}) {
+  const b = planBranches(planUid);
+  if (b && b.branches.length) await (0, import_host_state.refreshHostReads)(b.root, b.branches);
+  return planGitStates(planUid, opts);
+}
+function refreshPlanHostStates(planUid) {
+  const b = planBranches(planUid);
+  if (b && b.branches.length) void (0, import_host_state.refreshHostReads)(b.root, b.branches);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  branchGitState,
+  planGitStates,
+  planGitStatesFresh,
+  refreshPlanHostStates
+});

package/src/backend/services/line-changes.js

@@ -0,0 +1,232 @@
+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 line_changes_exports = {};
+__export(line_changes_exports, {
+  MAX_DIFF_CHARS: () => MAX_DIFF_CHARS,
+  MAX_FILE_BYTES: () => MAX_FILE_BYTES,
+  cleanRelPath: () => cleanRelPath,
+  countLines: () => countLines,
+  functionsIn: () => functionsIn,
+  isBinaryDiff: () => isBinaryDiff,
+  lineChangesFor: () => lineChangesFor,
+  lineChangesOf: () => lineChangesOf,
+  parseHunkHeaders: () => parseHunkHeaders,
+  readWorkstreamCopy: () => readWorkstreamCopy,
+  symbolRanges: () => symbolRanges,
+  toHunks: () => toHunks
+});
+module.exports = __toCommonJS(line_changes_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_confined_fs = require("./confined-fs");
+var import_git_safety = require("./git-safety");
+var import_branch_workstreams = require("./branch-workstreams");
+const MAX_FILE_BYTES = 1e6;
+const MAX_DIFF_CHARS = 2e4;
+const SHA = /^[0-9a-f]{40}$/;
+const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+function parseHunkHeaders(diff) {
+  const out = [];
+  for (const m of diff.matchAll(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/gm)) {
+    out.push({
+      oldStart: Number(m[1]),
+      oldLines: m[2] === void 0 ? 1 : Number(m[2]),
+      newStart: Number(m[3]),
+      newLines: m[4] === void 0 ? 1 : Number(m[4])
+    });
+  }
+  return out;
+}
+function isBinaryDiff(diff) {
+  return /^Binary files .* differ$/m.test(diff) || /^GIT binary patch$/m.test(diff);
+}
+const QUALIFIED = /[.#)]/;
+function symbolRanges(symbols) {
+  const out = [];
+  const visit = (list, parent) => {
+    for (const s of list) {
+      const name = parent && !QUALIFIED.test(s.name) ? `${parent}.${s.name}` : s.name;
+      out.push({ name, start: s.startLine, end: s.endLine });
+      if (s.children.length) visit(s.children, name);
+    }
+  };
+  visit(symbols, null);
+  return out;
+}
+function functionsIn(ranges, start, end) {
+  const hit = ranges.filter((r) => r.start <= end && r.end >= start);
+  const inner = hit.filter((r) => !hit.some((o) => o !== r && o.start >= r.start && o.end <= r.end && (o.start > r.start || o.end < r.end)));
+  return [...new Set(inner.sort((a, b) => a.start - b.start).map((r) => r.name))];
+}
+function newSpan(h) {
+  return h.newLines > 0 ? [h.newStart, h.newStart + h.newLines - 1] : [h.newStart, h.newStart + 1];
+}
+function toHunks(whole, uncommitted, placeNew, placeOld) {
+  return whole.map((h) => {
+    const kind = h.oldLines === 0 ? "added" : h.newLines === 0 ? "removed" : "changed";
+    const [a, b] = newSpan(h);
+    const committed = uncommitted === "all" ? false : uncommitted === "none" ? true : !uncommitted.some((u) => {
+      const [c, d] = newSpan(u);
+      return c <= b && d >= a;
+    });
+    const functions = kind === "removed" ? placeOld(h.oldStart, h.oldStart + h.oldLines - 1) : placeNew(h.newStart, h.newStart + h.newLines - 1);
+    return { kind, old: { start: h.oldStart, lines: h.oldLines }, new: { start: h.newStart, lines: h.newLines }, functions, committed };
+  });
+}
+function countLines(hunks) {
+  return hunks.reduce((n, h) => ({ added: n.added + h.new.lines, removed: n.removed + h.old.lines }), { added: 0, removed: 0 });
+}
+function cleanRelPath(raw) {
+  if (typeof raw !== "string") return null;
+  const p = raw.trim().replace(/\\/g, "/").replace(/^(\.\/)+/, "");
+  if (!p || p.length > 300 || p.includes("\0") || p.startsWith("/") || p.startsWith("-") || /^[A-Za-z]:/.test(p)) return null;
+  if (p.split("/").some((seg) => seg === ".." || seg === "")) return null;
+  return p;
+}
+function git(folder, args) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", folder, ...args], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3,
+      maxBuffer: 8 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+}
+const DIFF = ["diff", "--no-color", "--no-ext-diff", "--no-renames"];
+function placer(parse, file, text) {
+  if (!parse || text === null) return () => [];
+  let ranges = [];
+  try {
+    ranges = symbolRanges(parse(file, text) ?? []);
+  } catch {
+  }
+  return (s, e) => functionsIn(ranges, s, e);
+}
+const lineCount = (text) => text === "" ? 0 : text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+function lineChangesOf(w, repo, rel, parse, opts = {}) {
+  (0, import_git_safety.assertSafeGitPathArg)(rel, "line changes");
+  const out = { workstream: w.root, branch: w.branch, path: rel, status: "unchanged", hunks: [], added: 0, removed: 0 };
+  const base = w.changes?.base && SHA.test(w.changes.base) ? w.changes.base : EMPTY_TREE;
+  const isBranch = w.root.startsWith("branch:");
+  const folder = isBranch ? repo : w.root;
+  let current;
+  let range;
+  let uncommitted = "none";
+  if (isBranch) {
+    const head = w.head && SHA.test(w.head) ? w.head : null;
+    if (!head) return out;
+    current = (0, import_branch_workstreams.showAt)(repo, head, rel);
+    range = [base, head];
+  } else {
+    let size = -1;
+    try {
+      const abs = (0, import_confined_fs.resolveWithin)(folder, rel, "line changes");
+      size = import_node_fs.default.existsSync(abs) ? import_node_fs.default.statSync(abs).size : -1;
+    } catch {
+      return { ...out, status: "unreadable" };
+    }
+    if (size > MAX_FILE_BYTES) return { ...out, status: "too-large" };
+    try {
+      const buf = size < 0 ? null : (0, import_confined_fs.readFileWithin)(folder, rel, "line changes");
+      if (buf && buf.includes(0)) return { ...out, status: "binary" };
+      current = buf ? buf.toString("utf-8") : null;
+    } catch {
+      return { ...out, status: "unreadable" };
+    }
+    range = [base];
+  }
+  const baseText = base === EMPTY_TREE ? null : (0, import_branch_workstreams.showAt)(folder, base, rel);
+  if ((baseText?.length ?? 0) > MAX_FILE_BYTES) return { ...out, status: "too-large" };
+  let whole = git(folder, [...DIFF, "-U0", ...range, "--", rel]) ?? "";
+  if (isBinaryDiff(whole)) return { ...out, status: "binary" };
+  let hunks = parseHunkHeaders(whole);
+  if (!isBranch) {
+    const tracked = git(folder, ["ls-files", "--error-unmatch", "--", rel]) !== null;
+    if (!tracked && current !== null) {
+      const n = lineCount(current);
+      hunks = baseText === null && n > 0 ? [{ oldStart: 0, oldLines: 0, newStart: 1, newLines: n }] : hunks;
+      uncommitted = "all";
+      whole = "";
+    } else {
+      uncommitted = parseHunkHeaders(git(folder, [...DIFF, "-U0", "HEAD", "--", rel]) ?? "");
+    }
+  }
+  if (!hunks.length) return out;
+  const file = import_node_path.default.join(folder, rel);
+  const lineHunks = toHunks(hunks, uncommitted, placer(parse, file, current), placer(parse, file, baseText));
+  const counts = countLines(lineHunks);
+  const result = { ...out, status: "changed", hunks: lineHunks, ...counts };
+  if (opts.diff) {
+    const text = uncommitted === "all" && current !== null ? `new file, not tracked by git yet
+${current.split("\n").map((l) => `+${l}`).join("\n")}` : git(folder, [...DIFF, "-U3", ...range, "--", rel]) ?? "";
+    result.diff = text.slice(0, MAX_DIFF_CHARS);
+    if (text.length > MAX_DIFF_CHARS) result.diffTruncated = true;
+  }
+  return result;
+}
+function lineChangesFor(workstreams, rel, parse, opts = {}) {
+  const main = workstreams.find((w) => w.main);
+  const repo = main?.root ?? workstreams.find((w) => !w.root.startsWith("branch:"))?.root;
+  if (!repo) return [];
+  const chosen = opts.workstream ? workstreams.filter((w) => w.root === opts.workstream || w.branch === opts.workstream).slice(0, 1) : workstreams.filter((w) => w.changes.files.some((f) => f.path === rel) && !opts.exclude?.(w));
+  return chosen.map((w) => lineChangesOf(w, repo, rel, parse, { diff: opts.diff }));
+}
+function readWorkstreamCopy(workstreams, id, rel) {
+  const w = workstreams.find((x) => x.root === id) ?? workstreams.find((x) => x.branch === id);
+  if (!w) return null;
+  const label = w.branch ?? import_node_path.default.basename(w.root);
+  if (w.root.startsWith("branch:")) {
+    const repo = workstreams.find((x) => x.main)?.root;
+    const head = w.head && SHA.test(w.head) ? w.head : null;
+    (0, import_git_safety.assertSafeGitPathArg)(rel, "workstream copy");
+    return { content: repo && head ? (0, import_branch_workstreams.showAt)(repo, head, rel) : null, label };
+  }
+  const abs = (0, import_confined_fs.resolveWithin)(w.root, rel, "workstream copy");
+  if (!import_node_fs.default.existsSync(abs)) return { content: null, label };
+  if (import_node_fs.default.statSync(abs).size > MAX_FILE_BYTES) throw new Error(`${label}'s copy of ${rel} is too large to compare`);
+  return { content: (0, import_confined_fs.readFileWithin)(w.root, rel, "workstream copy").toString("utf-8"), label };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_DIFF_CHARS,
+  MAX_FILE_BYTES,
+  cleanRelPath,
+  countLines,
+  functionsIn,
+  isBinaryDiff,
+  lineChangesFor,
+  lineChangesOf,
+  parseHunkHeaders,
+  readWorkstreamCopy,
+  symbolRanges,
+  toHunks
+});

package/src/backend/services/line-history.js

@@ -0,0 +1,174 @@
+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 line_history_exports = {};
+__export(line_history_exports, {
+  LineHistoryError: () => LineHistoryError,
+  hunksOf: () => hunksOf,
+  lineHistory: () => lineHistory,
+  lineWords: () => lineWords,
+  parseBlame: () => parseBlame
+});
+module.exports = __toCommonJS(line_history_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+var import_git_refs = require("./git-refs");
+var import_source_control = require("./source-control");
+var import_commit_attribution = require("./commit-attribution");
+const SHA = /^[0-9a-f]{40,64}$/;
+const UNCOMMITTED = /^0+$/;
+const MAX_LINES = 2e4;
+class LineHistoryError extends Error {
+}
+function parseBlame(out) {
+  const lines = [];
+  const info = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const raw of out.split("\n")) {
+    if (raw.startsWith("	")) {
+      if (current) lines.push(current);
+      continue;
+    }
+    const head = raw.match(/^([0-9a-f]{40,64}) \d+ (\d+)/);
+    if (head) {
+      current = head[1];
+      if (!info.has(current)) info.set(current, { author: "", email: "", at: 0, summary: "" });
+      continue;
+    }
+    if (!current) continue;
+    const entry = info.get(current);
+    const sp = raw.indexOf(" ");
+    const key = sp < 0 ? raw : raw.slice(0, sp);
+    const value = sp < 0 ? "" : raw.slice(sp + 1);
+    if (key === "author") entry.author = value;
+    else if (key === "author-mail") entry.email = value.replace(/^<|>$/g, "");
+    else if (key === "author-time") entry.at = Number(value) * 1e3;
+    else if (key === "summary") entry.summary = value;
+  }
+  return { lines, info };
+}
+function hunksOf(lines) {
+  const hunks = [];
+  lines.forEach((sha, i) => {
+    const s = UNCOMMITTED.test(sha) ? null : sha;
+    const last = hunks[hunks.length - 1];
+    if (last && last.sha === s) last.end = i + 1;
+    else hunks.push({ start: i + 1, end: i + 1, sha: s });
+  });
+  return hunks;
+}
+function blameTarget(projectRoot, spec, relativePath, workstreams) {
+  if (spec === "live") return { cwd: projectRoot, rev: null, file: relativePath, checkout: projectRoot, name: "" };
+  if (spec.startsWith("commit:")) {
+    const ref = spec.slice("commit:".length);
+    if (!(0, import_git_safety.isSafeGitRef)(ref)) throw new LineHistoryError(`\u201C${ref}\u201D is not a ref this app passes to git.`);
+    return { cwd: projectRoot, rev: ref, file: relativePath, checkout: null, name: (0, import_git_refs.shortRefName)(ref) };
+  }
+  const mb = (0, import_git_refs.parseMergeBase)(spec);
+  if (mb) {
+    const sha = (0, import_git_refs.mergeBase)(projectRoot, mb.a, mb.b);
+    if (!sha) throw new LineHistoryError(`${(0, import_git_refs.shortRefName)(mb.a)} and ${(0, import_git_refs.shortRefName)(mb.b)} share no history here.`);
+    return { cwd: projectRoot, rev: sha, file: relativePath, checkout: null, name: sha.slice(0, 7) };
+  }
+  if (spec.startsWith("workstream:")) {
+    const w = (0, import_git_refs.findWorkstream)(workstreams, spec.slice("workstream:".length));
+    if (!w) throw new LineHistoryError("No such worktree in this project.");
+    if (w.root.startsWith("branch:")) {
+      if (!w.head || !SHA.test(w.head)) throw new LineHistoryError("That branch has no commit here.");
+      return { cwd: projectRoot, rev: w.head, file: relativePath, checkout: null, name: w.branch ?? w.head.slice(0, 7) };
+    }
+    return { cwd: w.root, rev: null, file: `${(0, import_source_control.projectPrefix)(projectRoot)}${relativePath}`, checkout: w.root, name: "" };
+  }
+  throw new LineHistoryError("Line history reads a commit, a branch, a tag or a working copy.");
+}
+function bodiesOf(cwd, shas) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < shas.length; i += 200) {
+    const batch = shas.slice(i, i + 200);
+    try {
+      const raw = (0, import_node_child_process.execFileSync)("git", ["show", "-s", "--format=%x1e%H%x1f%B", ...batch], { cwd, encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+      for (const chunk of raw.split("")) {
+        const [sha, body = ""] = chunk.split("");
+        if (sha && SHA.test(sha.trim())) out.set(sha.trim(), body);
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function lineHistory(projectRoot, spec, relativePath, workstreams, know = import_commit_attribution.NO_KNOWLEDGE) {
+  const t = blameTarget(projectRoot, spec, relativePath, workstreams);
+  let out;
+  try {
+    out = (0, import_node_child_process.execFileSync)("git", ["blame", "--porcelain", ...t.rev ? [t.rev] : [], "--", t.file], {
+      cwd: t.cwd,
+      encoding: "utf-8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    throw new LineHistoryError(`git has no history for ${relativePath} here: it is new, or not in this repository.`);
+  }
+  const { lines, info } = parseBlame(out);
+  if (lines.length > MAX_LINES) throw new LineHistoryError(`${relativePath} has ${lines.length} lines; line history reads up to ${MAX_LINES}.`);
+  const shas = [...info.keys()].filter((s) => !UNCOMMITTED.test(s));
+  const bodies = bodiesOf(t.cwd, shas);
+  const attributed = (0, import_commit_attribution.attributeCommits)(shas.map((sha) => ({ sha, at: info.get(sha).at, body: bodies.get(sha) ?? "" })), t.checkout, know);
+  const commits = {};
+  for (const sha of shas) {
+    const i = info.get(sha);
+    commits[sha] = { sha, short: sha.slice(0, 7), author: i.author, email: i.email, at: i.at, subject: i.summary, attribution: attributed.get(sha) ?? null };
+  }
+  return {
+    at: spec,
+    path: relativePath,
+    lineCount: lines.length,
+    hunks: hunksOf(lines),
+    commits,
+    uncommitted: lines.filter((s) => UNCOMMITTED.test(s)).length,
+    command: t.cwd === projectRoot ? `git blame ${t.rev ? `${t.name} ` : ""}-- ${relativePath}` : `git -C ${t.cwd} blame -- ${t.file}`
+  };
+}
+const ago = (ms, now) => {
+  const days = Math.round((now - ms) / 864e5);
+  if (days < 1) {
+    const hours = Math.round((now - ms) / 36e5);
+    return hours < 1 ? "just now" : `${hours} h ago`;
+  }
+  return days === 1 ? "yesterday" : `${days} days ago`;
+};
+function lineWords(h, line, now = Date.now()) {
+  const hunk = h.hunks.find((x) => line >= x.start && line <= x.end);
+  if (!hunk) return `Line ${line} is not in ${h.path} (it has ${h.lineCount} lines).`;
+  if (!hunk.sha) return `Line ${line} is changed in the working copy and not yet committed.`;
+  const c = h.commits[hunk.sha];
+  const parts = [`Line ${line}: ${c.author} \xB7 ${ago(c.at, now)} \xB7 \u201C${c.subject}\u201D (${c.short})`];
+  if (c.attribution) {
+    parts.push(c.attribution.words);
+    if (c.attribution.sessionId) parts.push(`session ${c.attribution.sessionId}`);
+    if (c.attribution.task) parts.push(`task \u201C${c.attribution.task.title}\u201D${c.attribution.plan ? ` in the plan \u201C${c.attribution.plan.title}\u201D` : ""}`);
+  }
+  return `${parts.join("; ")}.`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LineHistoryError,
+  hunksOf,
+  lineHistory,
+  lineWords,
+  parseBlame
+});

package/src/backend/services/local-api-changes.js

@@ -0,0 +1,40 @@
+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 local_api_changes_exports = {};
+__export(local_api_changes_exports, {
+  LOCAL_API_CHANGES_REFUSAL: () => LOCAL_API_CHANGES_REFUSAL,
+  LOCAL_API_CHANGES_WHERE: () => LOCAL_API_CHANGES_WHERE,
+  refusesLocalApiChange: () => refusesLocalApiChange
+});
+module.exports = __toCommonJS(local_api_changes_exports);
+const READS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+const LOCAL_API_CHANGES_WHERE = "Settings \u2192 MCP Server \u2192 Local API";
+const LOCAL_API_CHANGES_REFUSAL = `Changes over the local API are turned off. Turn them back on in the CodeTrellis app, ${LOCAL_API_CHANGES_WHERE}.`;
+function refusesLocalApiChange(req, accept, testSettingsPath = false) {
+  if (accept !== false) return false;
+  if (req.fromAppWindow || READS.has(req.method.toUpperCase())) return false;
+  if (!req.path.startsWith("/api/")) return false;
+  if (testSettingsPath && req.path === "/api/settings") return false;
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOCAL_API_CHANGES_REFUSAL,
+  LOCAL_API_CHANGES_WHERE,
+  refusesLocalApiChange
+});