codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/git-env.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 git_env_exports = {};
+__export(git_env_exports, {
+  GIT_CONCURRENCY: () => GIT_CONCURRENCY,
+  REFRESH_EVERY_MS: () => REFRESH_EVERY_MS,
+  gitAsync: () => gitAsync,
+  gitAsyncLoad: () => gitAsyncLoad,
+  inBackground: () => inBackground,
+  quietGitLocks: () => quietGitLocks,
+  refreshIndexOccasionally: () => refreshIndexOccasionally,
+  refreshIndexOccasionallyAsync: () => refreshIndexOccasionallyAsync
+});
+module.exports = __toCommonJS(git_env_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_async_hooks = require("node:async_hooks");
+function quietGitLocks(env = process.env) {
+  if (env.GIT_OPTIONAL_LOCKS === void 0) env.GIT_OPTIONAL_LOCKS = "0";
+}
+quietGitLocks();
+const REFRESH_EVERY_MS = 10 * 60 * 1e3;
+const refreshedAt = /* @__PURE__ */ new Map();
+function refreshIndexOccasionally(folder, now = Date.now()) {
+  if (now - (refreshedAt.get(folder) ?? -Infinity) < REFRESH_EVERY_MS) return false;
+  refreshedAt.set(folder, now);
+  try {
+    (0, import_node_child_process.execFileSync)("git", ["-C", folder, "update-index", "-q", "--refresh"], {
+      stdio: "ignore",
+      timeout: 3e4,
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: "1" }
+    });
+  } catch {
+  }
+  return true;
+}
+async function refreshIndexOccasionallyAsync(folder, now = Date.now()) {
+  if (now - (refreshedAt.get(folder) ?? -Infinity) < REFRESH_EVERY_MS) return false;
+  refreshedAt.set(folder, now);
+  await gitAsync(folder, ["update-index", "-q", "--refresh"], { timeout: 3e4, env: { ...process.env, GIT_OPTIONAL_LOCKS: "1" } }).catch(() => {
+  });
+  return true;
+}
+const GIT_CONCURRENCY = 4;
+let running = 0;
+const queued = [];
+const behind = [];
+const background = new import_node_async_hooks.AsyncLocalStorage();
+function inBackground(fn) {
+  return background.run(true, fn);
+}
+function next() {
+  if (running >= GIT_CONCURRENCY) return;
+  const now = queued.shift() ?? (running < GIT_CONCURRENCY - 1 ? behind.shift() : void 0);
+  if (now) {
+    running += 1;
+    now();
+  }
+}
+function release() {
+  running -= 1;
+  next();
+}
+async function slot() {
+  if (background.getStore()) {
+    if (!queued.length && !behind.length && running < GIT_CONCURRENCY - 1) {
+      running += 1;
+      return;
+    }
+    await new Promise((resolve) => behind.push(resolve));
+    return;
+  }
+  if (!queued.length && running < GIT_CONCURRENCY) {
+    running += 1;
+    return;
+  }
+  await new Promise((resolve) => queued.push(resolve));
+}
+function gitAsyncLoad() {
+  return { running, queued: queued.length + behind.length, behind: behind.length };
+}
+async function gitAsync(cwd, args, opts = {}) {
+  await slot();
+  try {
+    return await new Promise((resolve, reject) => {
+      (0, import_node_child_process.execFile)("git", ["-C", cwd, ...args], {
+        encoding: "utf-8",
+        timeout: opts.timeout ?? 5e3,
+        maxBuffer: opts.maxBuffer ?? 16 * 1024 * 1024,
+        ...opts.env ? { env: opts.env } : {}
+      }, (err, out) => err ? reject(err) : resolve(out)).stdin?.end();
+    });
+  } finally {
+    release();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GIT_CONCURRENCY,
+  REFRESH_EVERY_MS,
+  gitAsync,
+  gitAsyncLoad,
+  inBackground,
+  quietGitLocks,
+  refreshIndexOccasionally,
+  refreshIndexOccasionallyAsync
+});

package/src/backend/services/git-identity.js

@@ -0,0 +1,84 @@
+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 git_identity_exports = {};
+__export(git_identity_exports, {
+  getNormalisedOriginUrl: () => getNormalisedOriginUrl,
+  getOriginUrl: () => getOriginUrl,
+  normaliseRepoUrl: () => normaliseRepoUrl
+});
+module.exports = __toCommonJS(git_identity_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"));
+function getOriginUrl(projectPath) {
+  try {
+    if (!import_node_fs.default.existsSync(import_node_path.default.join(projectPath, ".git"))) return null;
+    const url = (0, import_node_child_process.execFileSync)("git", ["remote", "get-url", "origin"], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+function normaliseRepoUrl(raw) {
+  if (!raw) return "";
+  let s = String(raw).trim();
+  if (!s) return "";
+  const shortSsh = s.match(/^git@([^:]+):(.+)$/);
+  if (shortSsh) {
+    s = `https://${shortSsh[1]}/${shortSsh[2]}`;
+  }
+  const longSsh = s.match(/^ssh:\/\/(?:[^@/]+@)?([^/]+)\/(.+)$/);
+  if (longSsh) {
+    s = `https://${longSsh[1]}/${longSsh[2]}`;
+  }
+  s = s.replace(/\.git\/?$/, "");
+  s = s.replace(/\/+$/, "");
+  try {
+    const u = new URL(s);
+    u.host = u.host.toLowerCase();
+    const path2 = u.pathname.replace(/\/+$/, "");
+    s = `${u.protocol}//${u.host}${path2}`;
+  } catch {
+  }
+  return s;
+}
+function getNormalisedOriginUrl(projectPath) {
+  const raw = getOriginUrl(projectPath);
+  if (!raw) return null;
+  return normaliseRepoUrl(raw);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNormalisedOriginUrl,
+  getOriginUrl,
+  normaliseRepoUrl
+});

package/src/backend/services/git-refs.js

@@ -0,0 +1,386 @@
+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 git_refs_exports = {};
+__export(git_refs_exports, {
+  diffCommand: () => diffCommand,
+  fetchedAt: () => fetchedAt,
+  filesBetween: () => filesBetween,
+  findWorkstream: () => findWorkstream,
+  listRefs: () => listRefs,
+  mergeBase: () => mergeBase,
+  parseMergeBase: () => parseMergeBase,
+  shortRefName: () => shortRefName,
+  sideLabel: () => sideLabel,
+  treeOf: () => treeOf,
+  whenWords: () => whenWords,
+  workingCopyTree: () => workingCopyTree,
+  worktreesForCompare: () => worktreesForCompare
+});
+module.exports = __toCommonJS(git_refs_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_git_safety = require("./git-safety");
+var import_source_control = require("./source-control");
+var import_worktree_service = require("./worktree-service");
+const MAX_PER_KIND = 200;
+const MAX_FILES = 1e3;
+const SHA = /^[0-9a-f]{7,64}$/;
+function git(cwd, args, env) {
+  return (0, import_node_child_process.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf-8",
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "ignore"],
+    ...env ? { env: { ...process.env, ...env } } : {}
+  });
+}
+const trim = (p) => p.replace(/[\\/]+$/, "");
+const short = (sha) => sha ? sha.slice(0, 7) : "";
+function shortRefName(ref) {
+  if (ref.startsWith("refs/heads/")) return ref.slice("refs/heads/".length);
+  if (ref.startsWith("refs/remotes/")) return ref.slice("refs/remotes/".length);
+  if (ref.startsWith("refs/tags/")) return ref.slice("refs/tags/".length);
+  return ref;
+}
+function parseMergeBase(spec) {
+  if (!spec.startsWith("merge-base:")) return null;
+  const parts = spec.slice("merge-base:".length).split("...");
+  if (parts.length !== 2 || !(0, import_git_safety.isSafeGitRef)(parts[0]) || !(0, import_git_safety.isSafeGitRef)(parts[1])) return null;
+  return { a: parts[0], b: parts[1] };
+}
+function mergeBase(projectRoot, a, b) {
+  if (!(0, import_git_safety.isSafeGitRef)(a) || !(0, import_git_safety.isSafeGitRef)(b)) return null;
+  try {
+    const sha = git(projectRoot, ["merge-base", a, b]).trim();
+    return SHA.test(sha) ? sha : null;
+  } catch {
+    return null;
+  }
+}
+function findWorkstream(workstreams, id) {
+  const exact = workstreams.find((w) => w.root === id);
+  if (exact || !import_node_path.default.isAbsolute(id)) return exact ?? null;
+  const real = (p) => {
+    try {
+      return import_node_fs.default.realpathSync.native(p);
+    } catch {
+      return null;
+    }
+  };
+  const target = real(id);
+  if (!target) return null;
+  return workstreams.find((w) => import_node_path.default.isAbsolute(w.root) && real(w.root) === target) ?? null;
+}
+function worktreesForCompare(projectRoot) {
+  try {
+    return (0, import_worktree_service.listWorktrees)(projectRoot).filter((w) => !w.bare && !w.prunable).map((w) => ({
+      root: w.path,
+      branch: w.branch,
+      head: w.head,
+      main: w.isMain,
+      shape: "worktree",
+      agents: [],
+      idle: false,
+      changes: { base: null, files: [], truncated: false }
+    }));
+  } catch {
+    return [];
+  }
+}
+function workingCopyTree(root) {
+  let tmp = null;
+  try {
+    const indexPath = import_node_path.default.resolve(root, git(root, ["rev-parse", "--git-path", "index"]).trim());
+    tmp = import_node_path.default.join(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "ct-tree-")), "index");
+    if (import_node_fs.default.existsSync(indexPath)) {
+      import_node_fs.default.copyFileSync(indexPath, tmp);
+      const st = import_node_fs.default.statSync(indexPath);
+      import_node_fs.default.utimesSync(tmp, st.atime, st.mtime);
+    }
+    const env = { GIT_INDEX_FILE: tmp };
+    git(root, ["add", "-A", "--", ":/"], env);
+    const tree = git(root, ["write-tree"], env).trim();
+    return SHA.test(tree) ? tree : null;
+  } catch {
+    return null;
+  } finally {
+    if (tmp) import_node_fs.default.rmSync(import_node_path.default.dirname(tmp), { recursive: true, force: true });
+  }
+}
+function indexTree(root) {
+  try {
+    const tree = git(root, ["write-tree"]).trim();
+    return SHA.test(tree) ? tree : null;
+  } catch {
+    return null;
+  }
+}
+function treeOf(projectRoot, spec, workstreams) {
+  if (spec === "live") return workingCopyTree(projectRoot);
+  if (spec === "index") return indexTree(projectRoot);
+  if (spec === "none") {
+    try {
+      return git(projectRoot, ["hash-object", "-t", "tree", "--stdin"]).trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  if (spec.startsWith("commit:")) {
+    const ref = spec.slice("commit:".length);
+    if (!(0, import_git_safety.isSafeGitRef)(ref)) return null;
+    try {
+      const sha = git(projectRoot, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).trim();
+      return SHA.test(sha) ? sha : null;
+    } catch {
+      return null;
+    }
+  }
+  const mb = parseMergeBase(spec);
+  if (mb) return mergeBase(projectRoot, mb.a, mb.b);
+  if (spec.startsWith("workstream:")) {
+    const w = findWorkstream(workstreams, spec.slice("workstream:".length));
+    if (!w) return null;
+    if (w.root.startsWith("branch:")) return w.head && SHA.test(w.head) ? w.head : null;
+    if (trim(w.root) === trim(projectRoot)) return workingCopyTree(projectRoot);
+    return workingCopyTree(w.root);
+  }
+  return null;
+}
+function gitName(spec, workstreams) {
+  if (spec.startsWith("commit:")) return shortRefName(spec.slice("commit:".length));
+  const mb = parseMergeBase(spec);
+  if (mb) return `$(git merge-base ${shortRefName(mb.a)} ${shortRefName(mb.b)})`;
+  if (spec.startsWith("workstream:")) {
+    const w = findWorkstream(workstreams, spec.slice("workstream:".length));
+    return w?.branch ?? null;
+  }
+  return null;
+}
+function diffCommand(before, after, workstreams, file) {
+  const tail = file ? ` -- ${file}` : "";
+  const mb = parseMergeBase(before);
+  if (mb && after.startsWith("commit:") && shortRefName(after.slice("commit:".length)) === shortRefName(mb.b)) {
+    return `git diff ${shortRefName(mb.a)}...${shortRefName(mb.b)}${tail}`;
+  }
+  if (before === "index" && after === "live") return `git diff${tail}`;
+  if (before === "commit:HEAD" && after === "index") return `git diff --cached${tail}`;
+  const b = gitName(before, workstreams);
+  if (after === "live" && b && !before.startsWith("workstream:")) return `git diff ${b}${tail}`;
+  if (after === "index" && b && !before.startsWith("workstream:")) return `git diff --cached ${b}${tail}`;
+  if (after.startsWith("workstream:")) {
+    const w = findWorkstream(workstreams, after.slice("workstream:".length));
+    if (w && !w.root.startsWith("branch:") && b && !before.startsWith("workstream:")) return `git -C ${w.root} diff ${b}${tail}`;
+  }
+  const a = gitName(after, workstreams);
+  if (b && a && !before.startsWith("workstream:") && !after.startsWith("workstream:")) return `git diff ${b} ${a}${tail}`;
+  return null;
+}
+function sideLabel(projectRoot, spec, workstreams) {
+  if (spec === "live") return "Your working copy";
+  if (spec === "index") return "Staged";
+  if (spec === "none") return "Nothing";
+  if (spec === "commit:HEAD") {
+    try {
+      return `Last commit (${short(git(projectRoot, ["rev-parse", "HEAD"]).trim())})`;
+    } catch {
+      return "Last commit";
+    }
+  }
+  const mb = parseMergeBase(spec);
+  if (mb) {
+    const sha = mergeBase(projectRoot, mb.a, mb.b);
+    return `Where ${shortRefName(mb.a)} and ${shortRefName(mb.b)} split${sha ? ` (${short(sha)})` : ""}`;
+  }
+  if (spec.startsWith("workstream:")) {
+    const w = findWorkstream(workstreams, spec.slice("workstream:".length));
+    return w ? `${w.branch ?? import_node_path.default.basename(w.root)}, its working copy` : "A worktree";
+  }
+  if (spec.startsWith("commit:")) {
+    const ref = spec.slice("commit:".length);
+    if (ref.startsWith("refs/remotes/")) return `${shortRefName(ref)} (remote, as last fetched)`;
+    if (ref.startsWith("refs/tags/")) return `Tag ${shortRefName(ref)}`;
+    if (ref.startsWith("refs/heads/")) return shortRefName(ref);
+    return SHA.test(ref) ? `Commit ${short(ref)}` : ref;
+  }
+  return spec;
+}
+function filesBetween(projectRoot, before, after, workstreams) {
+  const a = treeOf(projectRoot, before, workstreams);
+  if (!a) return { ok: false, error: `Could not read \u201C${sideLabel(projectRoot, before, workstreams)}\u201D: it is not a ref, worktree or point this repository has.` };
+  const b = treeOf(projectRoot, after, workstreams);
+  if (!b) return { ok: false, error: `Could not read \u201C${sideLabel(projectRoot, after, workstreams)}\u201D: it is not a ref, worktree or point this repository has.` };
+  let out;
+  try {
+    out = git(projectRoot, ["diff-tree", "-r", "-z", "-M", "--name-status", "--relative", a, b]);
+  } catch {
+    return { ok: false, error: "git could not compare these two." };
+  }
+  const files = (0, import_source_control.parseNameStatus)(out, "");
+  return { ok: true, files: files.slice(0, MAX_FILES), truncated: files.length > MAX_FILES };
+}
+function fetchedAt(projectRoot) {
+  try {
+    const p = import_node_path.default.resolve(projectRoot, git(projectRoot, ["rev-parse", "--git-path", "FETCH_HEAD"]).trim());
+    return import_node_fs.default.existsSync(p) ? import_node_fs.default.statSync(p).mtimeMs : null;
+  } catch {
+    return null;
+  }
+}
+function whenWords(ms, now) {
+  if (ms === null) return "never";
+  const mins = Math.round((now - ms) / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins} min ago`;
+  const hours = Math.round(mins / 60);
+  if (hours < 48) return `${hours} h ago`;
+  return `${Math.round(hours / 24)} days ago`;
+}
+function listRefs(projectRoot, workstreams, now = Date.now()) {
+  let branch = null;
+  let head = null;
+  try {
+    head = git(projectRoot, ["rev-parse", "HEAD"]).trim();
+  } catch {
+  }
+  try {
+    branch = git(projectRoot, ["symbolic-ref", "--short", "-q", "HEAD"]).trim() || null;
+  } catch {
+  }
+  try {
+    git(projectRoot, ["rev-parse", "--git-dir"]);
+  } catch {
+    return { project: projectRoot, git: false, branch: null, groups: [], fetchedAt: null };
+  }
+  const groups = [];
+  const headSubject = head ? (() => {
+    try {
+      return git(projectRoot, ["log", "-1", "--format=%s"]).trim();
+    } catch {
+      return null;
+    }
+  })() : null;
+  groups.push({
+    kind: "checkout",
+    title: "This checkout",
+    words: `Your working copy, what is staged, and the last commit${branch ? ` on ${branch}` : ""}`,
+    git: { term: "HEAD", command: "git status" },
+    refs: [
+      { spec: "live", kind: "checkout", name: "Working copy", words: "Your files as they are now, saved or not committed", term: "working tree", sha: null, at: null, subject: null },
+      { spec: "index", kind: "checkout", name: "Staged", words: "What goes into the next commit", term: "index", sha: null, at: null, subject: null },
+      ...head ? [{ spec: "commit:HEAD", kind: "checkout", name: "Last commit", words: `${short(head)} \u201C${headSubject ?? ""}\u201D`, term: "HEAD", sha: short(head), at: null, subject: headSubject }] : []
+    ]
+  });
+  const fetched = fetchedAt(projectRoot);
+  let rows = [];
+  try {
+    rows = git(projectRoot, [
+      "for-each-ref",
+      "--sort=-creatordate",
+      "--format=%(refname)%00%(objectname)%00%(*objectname)%00%(creatordate:unix)%00%(subject)",
+      "refs/heads",
+      "refs/remotes",
+      "refs/tags"
+    ]).split("\n").filter(Boolean);
+  } catch {
+  }
+  const byKind = { branch: [], remote: [], tag: [] };
+  for (const row of rows) {
+    const [ref, obj, peeled, unix, subject] = row.split("\0");
+    if (!(0, import_git_safety.isSafeGitRef)(ref) || ref.endsWith("/HEAD")) continue;
+    const kind = ref.startsWith("refs/heads/") ? "branch" : ref.startsWith("refs/remotes/") ? "remote" : "tag";
+    if (byKind[kind].length >= MAX_PER_KIND) continue;
+    const name = shortRefName(ref);
+    const at = unix ? Number(unix) * 1e3 : null;
+    const sha = short(peeled || obj);
+    const when = whenWords(at, now);
+    byKind[kind].push({
+      spec: `commit:${ref}`,
+      kind,
+      name,
+      sha,
+      at,
+      subject: subject || null,
+      current: kind === "branch" && name === branch,
+      term: kind === "remote" ? "remote-tracking branch" : kind,
+      words: kind === "branch" ? `A branch here, last changed ${when}` : kind === "remote" ? `${name.split("/")[0]}'s ${name.split("/").slice(1).join("/")}, as last fetched (${whenWords(fetched, now)})` : `A tag, made ${when}`
+    });
+  }
+  groups.push({ kind: "branch", title: "Branches", words: "Branches in this repository", git: { term: "branch", command: "git branch" }, refs: byKind.branch });
+  if (byKind.remote.length) {
+    groups.push({
+      kind: "remote",
+      title: "Remote branches",
+      words: `Other copies' branches as this repository last fetched them: ${fetched === null ? "never fetched" : `fetched ${whenWords(fetched, now)}`}`,
+      git: { term: "remote-tracking", command: "git branch -r" },
+      refs: byKind.remote
+    });
+  }
+  if (byKind.tag.length) groups.push({ kind: "tag", title: "Tags", words: "Named points, usually releases", git: { term: "tag", command: "git tag" }, refs: byKind.tag });
+  const worktrees = workstreams.filter((w) => !w.root.startsWith("branch:") && !w.main && trim(w.root) !== trim(projectRoot) && !trim(projectRoot).startsWith(`${trim(w.root)}/`));
+  if (worktrees.length) {
+    groups.push({
+      kind: "worktree",
+      title: "Worktrees",
+      words: "Other working copies of this repository, as they are now, saved or not committed",
+      git: { term: "worktree", command: "git worktree list" },
+      refs: worktrees.map((w) => {
+        const agents = [...new Set(w.agents.map((a) => a.agentType))];
+        return {
+          spec: `workstream:${w.root}`,
+          kind: "worktree",
+          name: w.branch ?? import_node_path.default.basename(w.root),
+          sha: w.head ? short(w.head) : null,
+          at: null,
+          subject: null,
+          term: "worktree",
+          agents,
+          words: `A worktree at ${w.root}${agents.length ? `, worked on by ${agents.join(" and ")}` : ""}: its files now, committed or not`
+        };
+      })
+    });
+  }
+  return { project: projectRoot, git: true, branch, groups, fetchedAt: fetched };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffCommand,
+  fetchedAt,
+  filesBetween,
+  findWorkstream,
+  listRefs,
+  mergeBase,
+  parseMergeBase,
+  shortRefName,
+  sideLabel,
+  treeOf,
+  whenWords,
+  workingCopyTree,
+  worktreesForCompare
+});

package/src/backend/services/git-safety.js

@@ -0,0 +1,58 @@
+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 git_safety_exports = {};
+__export(git_safety_exports, {
+  assertSafeGitPathArg: () => assertSafeGitPathArg,
+  assertSafeGitRef: () => assertSafeGitRef,
+  isSafeGitRef: () => isSafeGitRef
+});
+module.exports = __toCommonJS(git_safety_exports);
+const SAFE_REF = /^(?!-)(?!\.)[A-Za-z0-9_][A-Za-z0-9._/~^@-]{0,254}$/;
+const RANGE = /\.\./;
+function isSafeGitRef(value) {
+  if (typeof value !== "string") return false;
+  if (value.length === 0) return false;
+  if (RANGE.test(value)) return false;
+  return SAFE_REF.test(value);
+}
+function assertSafeGitRef(value, label) {
+  if (!isSafeGitRef(value)) {
+    const shown = typeof value === "string" ? value.slice(0, 80) : typeof value;
+    throw new Error(
+      `${label}: refusing to pass "${shown}" to git \u2014 not a valid commit or ref. Refs must not start with "-" or ".", contain ".." ranges, whitespace, colons or shell metacharacters.`
+    );
+  }
+  return value;
+}
+function assertSafeGitPathArg(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${label}: expected a non-empty path`);
+  }
+  if (value.startsWith("-")) {
+    throw new Error(
+      `${label}: refusing to pass "${value.slice(0, 80)}" to git \u2014 a leading "-" would be parsed as an option.`
+    );
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertSafeGitPathArg,
+  assertSafeGitRef,
+  isSafeGitRef
+});