codetrellis 0.0.0-stage → 0.3.0

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

@@ -0,0 +1,357 @@
+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_branches_exports = {};
+__export(git_branches_exports, {
+  FETCH_COMMAND: () => FETCH_COMMAND,
+  PR_COMMAND: () => PR_COMMAND,
+  autoWords: () => autoWords,
+  fetchRemotes: () => fetchRemotes,
+  ghBinary: () => ghBinary,
+  ghStatus: () => ghStatus,
+  keeperDue: () => keeperDue,
+  keeperTick: () => keeperTick,
+  listBranches: () => listBranches,
+  parseTrack: () => parseTrack,
+  pullListing: () => pullListing,
+  pullWords: () => pullWords,
+  readPullRequests: () => readPullRequests,
+  resetBranchState: () => resetBranchState,
+  startRemoteKeeper: () => startRemoteKeeper,
+  toPulls: () => toPulls,
+  trackWords: () => trackWords
+});
+module.exports = __toCommonJS(git_branches_exports);
+var import_node_child_process = require("node:child_process");
+var import_types = require("../../shared/types");
+var import_git_safety = require("./git-safety");
+var import_git_refs = require("./git-refs");
+const FETCH_COMMAND = "git fetch --all --prune";
+const PR_COMMAND = "gh pr list --state all";
+const MAX_BRANCHES = 200;
+const MAX_PULLS = 50;
+const FETCH_TIMEOUT_MS = 12e4;
+const GH_TIMEOUT_MS = 6e4;
+const ghBinary = () => process.env.CODETRELLIS_GH || "gh";
+function run(bin, args, cwd, timeout, env = {}) {
+  return new Promise((resolve) => {
+    (0, import_node_child_process.execFile)(bin, args, {
+      cwd,
+      timeout,
+      maxBuffer: 16 * 1024 * 1024,
+      windowsHide: true,
+      env: { ...process.env, ...env }
+    }, (err, stdout, stderr) => {
+      const e = err;
+      resolve({
+        code: e ? typeof e.code === "number" ? e.code : -1 : 0,
+        stdout: String(stdout ?? ""),
+        stderr: String(stderr ?? ""),
+        missing: e?.code === "ENOENT"
+      });
+    }).stdin?.end();
+  });
+}
+const QUIET_GIT = { GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never", GIT_ASKPASS: "", SSH_ASKPASS: "" };
+const QUIET_GH = { GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1", GH_SPINNER_DISABLED: "1", NO_COLOR: "1", CLICOLOR: "0" };
+const gitSync = (root, args) => run("git", args, root, 3e4, QUIET_GIT);
+function parseTrack(track) {
+  if (/\bgone\b/.test(track)) return { ahead: 0, behind: 0, gone: true };
+  const ahead = /ahead (\d+)/.exec(track);
+  const behind = /behind (\d+)/.exec(track);
+  return { ahead: ahead ? Number(ahead[1]) : 0, behind: behind ? Number(behind[1]) : 0, gone: false };
+}
+const commits = (n) => `${n} commit${n === 1 ? "" : "s"}`;
+function trackWords(upstream, t) {
+  if (!upstream) return { words: "Only here: not pushed anywhere yet", term: "no upstream" };
+  if (t.gone) return { words: `Its upstream ${upstream} was deleted on the remote`, term: "upstream gone" };
+  if (!t.ahead && !t.behind) return { words: `Level with ${upstream}`, term: "up to date" };
+  const parts = [];
+  if (t.ahead) parts.push(`${commits(t.ahead)} not pushed yet`);
+  if (t.behind) parts.push(`${commits(t.behind)} on ${upstream} not here yet`);
+  return {
+    words: parts.join("; "),
+    term: [t.ahead ? `ahead ${t.ahead}` : "", t.behind ? `behind ${t.behind}` : ""].filter(Boolean).join(", ")
+  };
+}
+const REVIEW = {
+  APPROVED: "approved",
+  CHANGES_REQUESTED: "changes requested",
+  REVIEW_REQUIRED: "waiting on review"
+};
+function remoteRefFor(name, remoteRefs2) {
+  return remoteRefs2.find((r) => r === `refs/remotes/origin/${name}`) ?? remoteRefs2.find((r) => r.replace(/^refs\/remotes\/[^/]+\//, "") === name) ?? null;
+}
+function toPulls(rows, remoteRefs2, now) {
+  return rows.slice(0, MAX_PULLS).map((p) => {
+    const state = p.state === "MERGED" ? "merged" : p.state === "CLOSED" ? "closed" : p.isDraft ? "draft" : "open";
+    const review = state === "open" ? REVIEW[p.reviewDecision ?? ""] ?? null : null;
+    const updatedAt = p.updatedAt ? Date.parse(p.updatedAt) || null : null;
+    const head = remoteRefFor(p.headRefName, remoteRefs2);
+    const base = remoteRefFor(p.baseRefName, remoteRefs2);
+    const stateWords = state === "open" ? review ? `Open, ${review}` : "Open" : state === "draft" ? "Draft, not ready for review" : state === "merged" ? "Merged" : "Closed without merging";
+    return {
+      number: p.number,
+      title: p.title,
+      state,
+      head: p.headRefName,
+      base: p.baseRefName,
+      author: p.author?.login ?? null,
+      updatedAt,
+      url: typeof p.url === "string" && /^https:\/\//.test(p.url) ? p.url : null,
+      review,
+      words: `${stateWords} \xB7 ${p.headRefName} into ${p.baseRefName}${p.author?.login ? ` \xB7 ${p.author.login}` : ""}${updatedAt ? ` \xB7 ${(0, import_git_refs.whenWords)(updatedAt, now)}` : ""}`,
+      compare: head && base ? { before: `merge-base:${base}...${head}`, after: `commit:${head}` } : null
+    };
+  });
+}
+function ghStatus(r) {
+  if (r.missing) return { status: "no-gh", detail: "" };
+  const said = `${r.stderr}
+${r.stdout}`;
+  if (r.code === 4 || /gh auth login|not logged in|authentication required|GH_TOKEN/i.test(said)) return { status: "signed-out", detail: "" };
+  if (/none of the git remotes|no git remotes|known GitHub host|unable to determine|not a git repository/i.test(said)) return { status: "not-github", detail: "" };
+  return { status: "error", detail: said.trim().split("\n").find(Boolean)?.slice(0, 200) ?? `gh exited with ${r.code}` };
+}
+function pullWords(status, pulls, readAt, now, detail = "") {
+  switch (status) {
+    case "never":
+      return "Pull requests are read through the gh CLI when you fetch.";
+    case "no-gh":
+      return "Pull requests need the gh CLI (cli.github.com), installed and signed in. Branches work without it.";
+    case "signed-out":
+      return "gh is installed but not signed in: run gh auth login in a terminal, then fetch again.";
+    case "not-github":
+      return "This repository has no GitHub remote, so there are no pull requests for gh to read.";
+    case "error":
+      return `gh could not read pull requests: ${detail || "it gave no reason"}.`;
+    default: {
+      const open = pulls.filter((p) => p.state === "open" || p.state === "draft").length;
+      const read = `read ${(0, import_git_refs.whenWords)(readAt, now)}`;
+      if (!pulls.length) return `No pull requests on this repository, ${read}.`;
+      return `${open} open of the ${pulls.length} most recent, ${read}.`;
+    }
+  }
+}
+const pullCache = /* @__PURE__ */ new Map();
+async function readPullRequests(projectRoot, now = Date.now()) {
+  const r = await run(ghBinary(), [
+    "pr",
+    "list",
+    "--state",
+    "all",
+    "--limit",
+    String(MAX_PULLS),
+    "--json",
+    "number,title,state,isDraft,headRefName,baseRefName,author,updatedAt,url,reviewDecision"
+  ], projectRoot, GH_TIMEOUT_MS, QUIET_GH);
+  let entry;
+  if (r.code === 0) {
+    let rows = [];
+    try {
+      rows = JSON.parse(r.stdout || "[]");
+    } catch {
+      rows = [];
+    }
+    entry = { status: "ok", readAt: now, pulls: Array.isArray(rows) ? toPulls(rows, await remoteRefs(projectRoot), now) : [], detail: "" };
+  } else {
+    const s = ghStatus(r);
+    const prev = pullCache.get(projectRoot);
+    entry = { status: s.status, readAt: prev?.readAt ?? null, pulls: prev?.pulls ?? [], detail: s.detail };
+  }
+  pullCache.set(projectRoot, entry);
+  return pullListing(projectRoot, now);
+}
+function pullListing(projectRoot, now = Date.now()) {
+  const e = pullCache.get(projectRoot) ?? { status: "never", readAt: null, pulls: [], detail: "" };
+  return { status: e.status, readAt: e.readAt, pulls: e.pulls, words: pullWords(e.status, e.pulls, e.readAt, now, e.detail), command: PR_COMMAND };
+}
+async function remoteRefs(projectRoot) {
+  const r = await gitSync(projectRoot, ["for-each-ref", "--format=%(refname)", "refs/remotes"]);
+  return r.code === 0 ? r.stdout.split("\n").filter((x) => x && (0, import_git_safety.isSafeGitRef)(x) && !x.endsWith("/HEAD")) : [];
+}
+const fetching = /* @__PURE__ */ new Map();
+const fetchError = /* @__PURE__ */ new Map();
+function fetchRemotes(projectRoot) {
+  const running = fetching.get(projectRoot);
+  if (running) return running;
+  const p = (async () => {
+    const remotes = await listRemotes(projectRoot);
+    if (!remotes.length) {
+      fetchError.set(projectRoot, null);
+      return { ok: false, at: (0, import_git_refs.fetchedAt)(projectRoot), words: "This repository has no remote to fetch from.", command: FETCH_COMMAND, error: "no remote" };
+    }
+    const r = await run("git", ["fetch", "--all", "--prune", "--quiet"], projectRoot, FETCH_TIMEOUT_MS, QUIET_GIT);
+    const error = r.code === 0 ? null : (r.stderr.trim().split("\n").filter(Boolean).pop() ?? `git fetch exited with ${r.code}`).slice(0, 300);
+    fetchError.set(projectRoot, error);
+    await readPullRequests(projectRoot);
+    const at = (0, import_git_refs.fetchedAt)(projectRoot);
+    return {
+      ok: !error,
+      at,
+      command: FETCH_COMMAND,
+      error,
+      words: error ? `Could not fetch: ${error}` : `Fetched ${remotes.join(", ")} ${(0, import_git_refs.whenWords)(at, Date.now())}.`
+    };
+  })().finally(() => fetching.delete(projectRoot));
+  fetching.set(projectRoot, p);
+  return p;
+}
+async function listRemotes(projectRoot) {
+  const r = await gitSync(projectRoot, ["remote"]);
+  return r.code === 0 ? r.stdout.split("\n").map((s) => s.trim()).filter(Boolean) : [];
+}
+function autoWords(git) {
+  return git.keepRemotesCurrent ? `Kept current: fetched every ${git.everyMinutes} min while this project is open (Settings \u2192 Git).` : "Remotes are as last fetched. Fetch now, or keep them current in Settings \u2192 Git (off).";
+}
+async function listBranches(projectRoot, git, now = Date.now()) {
+  const empty = (isGit) => ({
+    project: projectRoot,
+    git: isGit,
+    branch: null,
+    remotes: [],
+    branches: [],
+    remoteBranches: [],
+    commands: { branches: "git branch -vv", remoteBranches: "git branch -r" },
+    fetch: { at: null, words: "Never fetched", command: FETCH_COMMAND, running: false, error: null, auto: { on: git.keepRemotesCurrent, everyMinutes: git.everyMinutes, words: autoWords(git) } },
+    pulls: pullListing(projectRoot, now)
+  });
+  if ((await gitSync(projectRoot, ["rev-parse", "--git-dir"])).code !== 0) return empty(false);
+  const listing = empty(true);
+  const head = await gitSync(projectRoot, ["symbolic-ref", "--short", "-q", "HEAD"]);
+  listing.branch = head.code === 0 ? head.stdout.trim() || null : null;
+  listing.remotes = await listRemotes(projectRoot);
+  const rows = await gitSync(projectRoot, [
+    "for-each-ref",
+    "--sort=-committerdate",
+    "--format=%(refname)%00%(objectname:short)%00%(committerdate:unix)%00%(subject)%00%(upstream)%00%(upstream:track)",
+    "refs/heads",
+    "refs/remotes"
+  ]);
+  const trackedBy = /* @__PURE__ */ new Map();
+  const parsed = (rows.code === 0 ? rows.stdout.split("\n").filter(Boolean) : []).map((line) => {
+    const [ref, sha, unix, subject, upstream, track] = line.split("\0");
+    return { ref, sha, at: unix ? Number(unix) * 1e3 : null, subject: subject || null, upstream: upstream || null, track: track ?? "" };
+  }).filter((r) => (0, import_git_safety.isSafeGitRef)(r.ref) && !r.ref.endsWith("/HEAD"));
+  for (const r of parsed) if (r.ref.startsWith("refs/heads/") && r.upstream) trackedBy.set(r.upstream, (0, import_git_refs.shortRefName)(r.ref));
+  const fetched = (0, import_git_refs.fetchedAt)(projectRoot);
+  for (const r of parsed) {
+    const name = (0, import_git_refs.shortRefName)(r.ref);
+    if (r.ref.startsWith("refs/heads/")) {
+      if (listing.branches.length >= MAX_BRANCHES) continue;
+      const upstream = r.upstream ? (0, import_git_refs.shortRefName)(r.upstream) : null;
+      const t = parseTrack(r.track);
+      const said = trackWords(upstream, t);
+      listing.branches.push({
+        spec: `commit:${r.ref}`,
+        kind: "branch",
+        name,
+        sha: r.sha,
+        at: r.at,
+        subject: r.subject,
+        current: name === listing.branch,
+        upstream,
+        ahead: upstream && !t.gone ? t.ahead : null,
+        behind: upstream && !t.gone ? t.behind : null,
+        gone: t.gone,
+        trackedBy: null,
+        words: said.words,
+        term: said.term
+      });
+    } else {
+      if (listing.remoteBranches.length >= MAX_BRANCHES) continue;
+      const [remote, ...rest] = name.split("/");
+      const local = trackedBy.get(r.ref) ?? null;
+      listing.remoteBranches.push({
+        spec: `commit:${r.ref}`,
+        kind: "remote",
+        name,
+        sha: r.sha,
+        at: r.at,
+        subject: r.subject,
+        current: false,
+        upstream: null,
+        ahead: null,
+        behind: null,
+        gone: false,
+        trackedBy: local,
+        words: `${rest.join("/")} on ${remote}, as last fetched${local ? `; your ${local} follows it` : "; no branch here follows it"}`,
+        term: local ? `upstream of ${local}` : "remote-tracking"
+      });
+    }
+  }
+  const error = fetchError.get(projectRoot) ?? null;
+  listing.fetch = {
+    ...listing.fetch,
+    at: fetched,
+    running: fetching.has(projectRoot),
+    error,
+    words: listing.remotes.length === 0 ? "No remote: this repository is only here" : fetched === null ? "Never fetched: remote branches are as they were when cloned" : `Last fetched ${(0, import_git_refs.whenWords)(fetched, now)}`
+  };
+  return listing;
+}
+function keeperDue(git, lastFetched, lastTried, now) {
+  if (!git.keepRemotesCurrent) return false;
+  const every = import_types.FETCH_INTERVAL_CHOICES.includes(git.everyMinutes) ? git.everyMinutes : 15;
+  const since = Math.max(lastFetched ?? -Infinity, lastTried ?? -Infinity);
+  return now - since >= every * 6e4;
+}
+const triedAt = /* @__PURE__ */ new Map();
+function keeperTick(deps) {
+  const root = deps.activeRoot();
+  if (!root || fetching.has(root)) return null;
+  const now = (deps.now ?? Date.now)();
+  if (!keeperDue(deps.settings(), (0, import_git_refs.fetchedAt)(root), triedAt.get(root) ?? null, now)) return null;
+  triedAt.set(root, now);
+  return fetchRemotes(root).then((r) => {
+    deps.onFetched(root, r);
+    return r;
+  });
+}
+function startRemoteKeeper(deps, everyMs = 6e4) {
+  const timer = setInterval(() => {
+    void keeperTick(deps)?.catch(() => {
+    });
+  }, everyMs);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+function resetBranchState() {
+  pullCache.clear();
+  fetchError.clear();
+  triedAt.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FETCH_COMMAND,
+  PR_COMMAND,
+  autoWords,
+  fetchRemotes,
+  ghBinary,
+  ghStatus,
+  keeperDue,
+  keeperTick,
+  listBranches,
+  parseTrack,
+  pullListing,
+  pullWords,
+  readPullRequests,
+  resetBranchState,
+  startRemoteKeeper,
+  toPulls,
+  trackWords
+});

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

@@ -0,0 +1,153 @@
+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_checkout_exports = {};
+__export(git_checkout_exports, {
+  checkoutGitDir: () => checkoutGitDir,
+  currentBranch: () => currentBranch,
+  hasCommits: () => hasCommits,
+  isLinkedWorktreeDir: () => isLinkedWorktreeDir,
+  localBranches: () => localBranches,
+  withoutNestedCheckouts: () => withoutNestedCheckouts
+});
+module.exports = __toCommonJS(git_checkout_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+function readText(file) {
+  try {
+    return import_node_fs.default.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function checkoutGitDir(root) {
+  const dotGit = import_node_path.default.resolve(root, ".git");
+  let st;
+  try {
+    st = import_node_fs.default.statSync(dotGit);
+  } catch {
+    return null;
+  }
+  let dir;
+  if (st.isDirectory()) {
+    dir = dotGit;
+  } else if (st.isFile()) {
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readText(dotGit) ?? "");
+    if (!m) return null;
+    dir = import_node_path.default.resolve(root, m[1]);
+  } else {
+    return null;
+  }
+  return import_node_fs.default.existsSync(import_node_path.default.join(dir, "HEAD")) ? dir : null;
+}
+function commonGitDir(gitDir) {
+  const rel = readText(import_node_path.default.join(gitDir, "commondir"))?.trim();
+  return rel ? import_node_path.default.resolve(gitDir, rel) : gitDir;
+}
+function headRef(gitDir) {
+  const head = readText(import_node_path.default.join(gitDir, "HEAD"))?.trim();
+  if (!head) return null;
+  const m = /^ref:\s*(refs\/\S+)$/.exec(head);
+  if (m) return m[1].split("/").includes("..") ? null : { ref: m[1], detached: false };
+  return /^[0-9a-f]{40,64}$/.test(head) ? { ref: null, detached: true } : null;
+}
+function packedRefs(commonDir) {
+  const out = /* @__PURE__ */ new Set();
+  for (const line of (readText(import_node_path.default.join(commonDir, "packed-refs")) ?? "").split("\n")) {
+    const m = /^[0-9a-f]{40,64} (refs\/\S+)$/.exec(line.trim());
+    if (m) out.add(m[1]);
+  }
+  return out;
+}
+function currentBranch(root) {
+  const gitDir = checkoutGitDir(root);
+  if (!gitDir) return null;
+  const head = headRef(gitDir);
+  if (!head) return null;
+  if (head.detached) return "detached";
+  return head.ref.replace(/^refs\/heads\//, "");
+}
+function localBranches(root) {
+  const gitDir = checkoutGitDir(root);
+  if (!gitDir) return [];
+  const common = commonGitDir(gitDir);
+  const names = /* @__PURE__ */ new Set();
+  for (const ref of packedRefs(common)) {
+    if (ref.startsWith("refs/heads/")) names.add(ref.slice("refs/heads/".length));
+  }
+  const walk = (dir, prefix) => {
+    let entries;
+    try {
+      entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) walk(import_node_path.default.join(dir, e.name), `${prefix}${e.name}/`);
+      else if (e.isFile()) names.add(`${prefix}${e.name}`);
+    }
+  };
+  walk(import_node_path.default.join(common, "refs", "heads"), "");
+  return [...names].sort();
+}
+function hasCommits(root) {
+  const gitDir = checkoutGitDir(root);
+  if (!gitDir) return false;
+  const head = headRef(gitDir);
+  if (!head) return false;
+  if (head.detached) return true;
+  const common = commonGitDir(gitDir);
+  return import_node_fs.default.existsSync(import_node_path.default.join(common, head.ref)) || packedRefs(common).has(head.ref);
+}
+function isLinkedWorktreeDir(dirPath) {
+  try {
+    const dotGit = import_node_path.default.join(dirPath, ".git");
+    const st = import_node_fs.default.lstatSync(dotGit);
+    if (!st.isFile() || st.size > 4096) return false;
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(import_node_fs.default.readFileSync(dotGit, "utf-8"));
+    if (!m) return false;
+    const target = m[1].replace(/[\\/]+$/, "");
+    return import_node_path.default.basename(import_node_path.default.dirname(target)) === "worktrees";
+  } catch {
+    return false;
+  }
+}
+function withoutNestedCheckouts(projectRoot, entries, pathOf) {
+  return entries.filter((e) => {
+    const p = pathOf(e);
+    return !(p.endsWith("/") && isLinkedWorktreeDir(import_node_path.default.join(projectRoot, p)));
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkoutGitDir,
+  currentBranch,
+  hasCommits,
+  isLinkedWorktreeDir,
+  localBranches,
+  withoutNestedCheckouts
+});

package/src/backend/services/git-commit-service.js

@@ -0,0 +1,91 @@
+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_commit_service_exports = {};
+__export(git_commit_service_exports, {
+  commitManifestChanges: () => commitManifestChanges,
+  composeCommitMessage: () => composeCommitMessage
+});
+module.exports = __toCommonJS(git_commit_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+function composeCommitMessage(opts) {
+  const subject = `[cdev] ${opts.subject.trim()}`;
+  const parts = [subject];
+  if (opts.body && opts.body.length > 0) {
+    parts.push("");
+    parts.push(opts.body.map((line) => line.trim()).filter(Boolean).join("\n\n"));
+  }
+  if (opts.agent) {
+    const agentType = opts.agent.agentType.trim();
+    const model = (opts.agent.model ?? "").trim();
+    const human = (opts.agent.humanIdentity ?? "").trim();
+    parts.push("");
+    const meta = model ? `agent: ${agentType} \xB7 model: ${model}` : `agent: ${agentType}`;
+    parts.push(meta);
+    const display = human ? `${human}'s ${agentType}` : agentType;
+    parts.push(`Co-Authored-By: ${display} <agent@cdev.example>`);
+  }
+  return parts.join("\n") + "\n";
+}
+function commitManifestChanges(opts) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(opts.projectRoot, ".git"))) {
+    throw new Error(`Not a git repository: ${opts.projectRoot}`);
+  }
+  if (opts.paths.length === 0) {
+    throw new Error("No paths supplied \u2014 commit would be empty.");
+  }
+  const message = composeCommitMessage(opts);
+  const safePaths = opts.paths.map((p, i) => (0, import_git_safety.assertSafeGitPathArg)(p, `commitPaths[${i}]`));
+  runGit(["add", "--", ...safePaths], opts.projectRoot);
+  const commitFlags = ["commit", "--file", "-"];
+  if (opts.signed) commitFlags.push("-S");
+  runGit(commitFlags, opts.projectRoot, message);
+  const sha = runGit(["rev-parse", "HEAD"], opts.projectRoot).trim();
+  return { sha, message };
+}
+function runGit(args, cwd, input) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", args, {
+      cwd,
+      encoding: "utf-8",
+      input,
+      stdio: [input === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    const stderr = (err?.stderr ?? "").toString();
+    const message = stderr.trim() || err?.message || "git failed";
+    throw new Error(`git ${args[0]} failed: ${message}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commitManifestChanges,
+  composeCommitMessage
+});