@xbzbing/dsh-git-panel 1.5.3 → 1.6.0

package/lib/host/actions.d.ts

@@ -1,6 +1,6 @@
-import type { SnapshotDeps, GitPanelConfig } from './core.ts';
-import { isSafePath } from './validate.ts';
-import type { GitAction, GitActionRequest, GitActionResult, GitErrorCode } from './types.ts';
+import type { SnapshotDeps, GitPanelConfig } from './core.js';
+import { isSafePath } from './validate.js';
+import type { GitAction, GitActionRequest, GitActionResult, GitErrorCode } from './types.js';
 export { isSafePath };
 interface CommandPlan {
     readonly argv: readonly (readonly string[])[];
@@ -22,7 +22,9 @@ export declare function scrubCredentials(text: string): string;
  *    rule below (git keeps the stash entry on conflict → recoverable).
  *  - index.lock busy (another process holds the lock).
  *  - nothing-to-commit / no changes added (a real commit no-op).
- *  - not-found (missing ref / tag / stash).
+ *  - not-found (missing ref / tag / stash, or a checkout target that resolves
+ *    to neither a ref nor a path).
+ *  - branch-in-use (the target branch is checked out in another worktree).
  *  - local-changes-block (a dirty-worktree refusal; neutral wording covers both
  *    `git checkout` and `git stash apply`).
  *  - revert-merge (reverting a merge commit without a mainline parent — git

package/lib/host/actions.js

@@ -0,0 +1,250 @@
+import { join, sep } from "node:path";
+import { mapWorkspaceFailure, resolveWorkspace, runCommand, snapshotForSession } from "./core.js";
+import { isSafeBranchName, isSafePath, isSafeRemoteName, isSafeRev } from "./validate.js";
+function withPaths(prefixes, paths) {
+  if (paths.length === 0) return { error: "invalid-path", message: "no paths given" };
+  for (const path of paths) {
+    if (!isSafePath(path)) return { error: "invalid-path", message: `unsafe path: ${path}` };
+  }
+  return { argv: prefixes.map((prefix) => [...prefix, ...paths]) };
+}
+function planAction(action, unborn) {
+  switch (action.kind) {
+    case "stage":
+      return withPaths([["git", "add", "--"]], action.paths);
+    case "stage-all":
+      return { argv: [["git", "add", "-A"]] };
+    case "unstage":
+      return unborn ? withPaths([["git", "rm", "--cached", "-r", "--"]], action.paths) : withPaths([["git", "restore", "--staged", "--"]], action.paths);
+    case "unstage-all":
+      return unborn ? { argv: [["git", "rm", "--cached", "-r", "--", "."]] } : { argv: [["git", "restore", "--staged", "--", "."]] };
+    case "discard":
+      return withPaths([["git", "restore", "--"]], action.paths);
+    case "commit": {
+      const message = action.message.trim();
+      const amend = action.amend === true;
+      if (message === "" && !amend) return { error: "empty-message" };
+      const amendFlag = amend ? ["--amend"] : [];
+      const msgArgs = message === "" ? ["--no-edit"] : ["-m", message];
+      if (action.paths === void 0 || action.paths.length === 0) {
+        return { argv: [["git", "commit", ...amendFlag, ...msgArgs]] };
+      }
+      const staged = withPaths([["git", "add", "--"]], action.paths);
+      if ("error" in staged) return staged;
+      const commitCmd = ["git", "commit", ...amendFlag, ...msgArgs, "--", ...action.paths];
+      return { argv: [...staged.argv, commitCmd] };
+    }
+    case "branch-checkout": {
+      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe branch name: ${action.name}` };
+      let checkout = ["git", "checkout", "--end-of-options", action.name];
+      if (action.createFrom !== void 0) {
+        if (!isSafeBranchName(action.createFrom)) return { error: "invalid-name", message: `unsafe tracking ref: ${action.createFrom}` };
+        checkout = ["git", "checkout", "-b", action.name, "--track", "--end-of-options", action.createFrom];
+      }
+      const msg = action.stashMessage?.trim() ?? "";
+      return { argv: msg === "" ? [checkout] : [["git", "stash", "push", "-u", "-m", msg], checkout] };
+    }
+    case "fetch":
+      return { argv: [["git", "fetch", "--all", "--prune"]] };
+    case "pull-ff":
+      return { argv: [["git", "pull", "--ff-only"]] };
+    case "push":
+      return { argv: [["git", "push"]] };
+    case "publish":
+      if (!isSafeRemoteName(action.remote)) return { error: "invalid-name", message: `unsafe remote name: ${action.remote}` };
+      return { argv: [["git", "push", "-u", action.remote, "HEAD"]] };
+    case "tag-create": {
+      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe tag name: ${action.name}` };
+      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
+      const msg = action.message?.trim() ?? "";
+      const flags = msg === "" ? [] : ["-a", "-m", msg];
+      return { argv: [["git", "tag", ...flags, "--end-of-options", action.name, action.commit]] };
+    }
+    case "tag-delete":
+      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe tag name: ${action.name}` };
+      return { argv: [["git", "tag", "-d", "--end-of-options", action.name]] };
+    case "stash-push": {
+      const msg = action.message?.trim() ?? "";
+      return { argv: [msg === "" ? ["git", "stash", "push"] : ["git", "stash", "push", "-m", msg]] };
+    }
+    case "stash-apply":
+    case "stash-pop":
+    case "stash-drop": {
+      if (!Number.isInteger(action.index) || action.index < 0) {
+        return { error: "invalid-index", message: `invalid stash index: ${action.index}` };
+      }
+      const verb = action.kind === "stash-apply" ? "apply" : action.kind === "stash-pop" ? "pop" : "drop";
+      return { argv: [["git", "stash", verb, "--end-of-options", `stash@{${action.index}}`]] };
+    }
+    case "revert": {
+      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
+      return { argv: [["git", "revert", "--no-edit", "--end-of-options", action.commit]] };
+    }
+    case "reset": {
+      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
+      if (action.mode !== "soft" && action.mode !== "mixed" && action.mode !== "hard") {
+        return { error: "invalid-name", message: `invalid reset mode: ${String(action.mode)}` };
+      }
+      return { argv: [["git", "reset", `--${action.mode}`, "--end-of-options", action.commit]] };
+    }
+  }
+}
+function isIndexBusy(outcome) {
+  if (!("run" in outcome) || outcome.run.exitCode === 0) return false;
+  return /index\.lock|Unable to create.*index|another git process/i.test(outcome.run.stderr + outcome.run.stdout);
+}
+function scrubCredentials(text) {
+  return text.replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s]*@/gi, "$1");
+}
+function classifyActionFailure(stdout, stderr, exitCode) {
+  const combined = stderr + stdout;
+  const err = scrubCredentials(stderr.trim());
+  if (/CONFLICT|Merge conflict|needs merge|could not restore untracked/i.test(combined)) {
+    return { code: "conflict", message: err || "merge conflict" };
+  }
+  if (/index\.lock|Unable to create.*index|another git process/i.test(combined)) {
+    return { code: "index-busy", message: err };
+  }
+  if (/nothing to commit|no changes added/i.test(combined)) {
+    return { code: "git-error", message: err || "nothing to commit" };
+  }
+  if (/No such ref|not a valid reference|is not a stash|no tag|tag .* not found|unknown revision|bad revision|Could not parse object|ambiguous argument|did not match any file\(s\) known to git/i.test(combined)) {
+    return { code: "not-found", message: err || "not found" };
+  }
+  if (/is already used by worktree|already checked out at/i.test(combined)) {
+    return { code: "branch-in-use", message: err || "branch is checked out in another worktree" };
+  }
+  if (/Authentication failed|could not read (Username|Password)|terminal prompts disabled|Permission denied \(publickey\)|Could not read from remote repository/i.test(combined)) {
+    return { code: "auth-failed", message: err || "authentication failed" };
+  }
+  if (/\[rejected\]|Updates were rejected|failed to push some refs|fetch first|tip of your current branch is behind/i.test(combined)) {
+    return { code: "push-rejected", message: err || "push rejected (remote has new commits; fetch first)" };
+  }
+  if (/Not possible to fast-forward|cannot fast-forward|not a fast-forward|Need to specify how to reconcile divergent branches/i.test(combined)) {
+    return { code: "not-ff", message: err || "cannot fast-forward (branches diverged)" };
+  }
+  if (/would be overwritten by (checkout|merge)|local changes|overwritten by merge|Your local changes/i.test(stderr)) {
+    return { code: "local-changes-block", message: err };
+  }
+  if (/is a merge but no -m|mainline parent/i.test(combined)) {
+    return { code: "revert-merge", message: err || "cannot revert a merge commit from the panel" };
+  }
+  return { code: "git-error", message: err || `git exited ${exitCode}` };
+}
+async function runAction(deps, config, request) {
+  const workspace = await resolveWorkspace(deps, request.sessionId);
+  if (!workspace.ok) return { ok: false, error: mapWorkspaceFailure(workspace.failure) };
+  const root = workspace.root;
+  const headProbe = await runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "head-probe", deps.signal);
+  const unborn = !("run" in headProbe) || headProbe.run.exitCode !== 0;
+  const act = request.action;
+  if (act.kind === "stash-apply" || act.kind === "stash-pop" || act.kind === "stash-drop") {
+    if (!Number.isInteger(act.index) || act.index < 0) {
+      return { ok: false, error: { code: "invalid-index", message: `invalid stash index: ${act.index}` } };
+    }
+    const probe = await runCommand(deps.run, ["git", "rev-parse", "--verify", "--quiet", "--end-of-options", `stash@{${act.index}}`], root, "stash-verify", deps.signal);
+    const sha = "run" in probe && probe.run.exitCode === 0 ? probe.run.stdout.trim() : "";
+    if (sha === "" || sha !== act.sha) {
+      return { ok: false, error: { code: "not-found", message: "stash entry changed; refresh and retry" } };
+    }
+  }
+  if (request.action.kind === "discard") {
+    const removed = await discardUntracked(deps, config, root, request.sessionId, request.action.paths);
+    if (removed !== null) {
+      if (!removed.ok) return removed.result;
+      if (removed.remainingTracked.length === 0) {
+        const snapshot2 = await snapshotForSession(deps, config, request.sessionId);
+        if (!snapshot2.ok) return { ok: false, error: { code: "git-error", message: "snapshot after action failed" } };
+        return { ok: true, snapshot: snapshot2.value, output: "" };
+      }
+      request = { ...request, action: { kind: "discard", paths: removed.remainingTracked } };
+    }
+  }
+  const plan = planAction(request.action, unborn);
+  if ("error" in plan) return { ok: false, error: { code: plan.error, ...plan.message ? { message: plan.message } : {} } };
+  const stashing = request.action.kind === "branch-checkout" && (request.action.stashMessage?.trim() ?? "") !== "";
+  let lastOutput = "";
+  for (let step = 0; step < plan.argv.length; step += 1) {
+    const argv = plan.argv[step];
+    let outcome = await runCommand(deps.run, argv, root, "action", deps.signal);
+    if (isIndexBusy(outcome)) {
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      outcome = await runCommand(deps.run, argv, root, "action-retry", deps.signal);
+    }
+    const where = plan.argv.length > 1 ? ` (step ${step + 1}/${plan.argv.length}: ${argv.join(" ")})` : "";
+    const stashChangedWorkTree = stashing && step > 0;
+    if ("failure" in outcome) {
+      const message = outcome.failure instanceof Error ? outcome.failure.message : String(outcome.failure);
+      return { ok: false, error: { code: stashChangedWorkTree ? "stash-switch-failed" : "git-unavailable", message: message + where } };
+    }
+    if (outcome.run.cancelled) {
+      return { ok: false, error: stashChangedWorkTree ? { code: "stash-switch-failed", message: "cancelled" + where } : { code: "cancelled" } };
+    }
+    if (outcome.run.timedOut) {
+      return { ok: false, error: stashChangedWorkTree ? { code: "stash-switch-failed", message: "timed out" + where } : { code: "timeout" } };
+    }
+    lastOutput = outcome.run.stdout || outcome.run.stderr;
+    if (outcome.run.exitCode !== 0) {
+      const failure = classifyActionFailure(outcome.run.stdout, outcome.run.stderr, outcome.run.exitCode ?? -1);
+      if (stashChangedWorkTree) {
+        return { ok: false, error: { code: "stash-switch-failed", message: failure.message + where } };
+      }
+      if (request.action.kind === "revert" && failure.code === "conflict") {
+        let abort = await runCommand(deps.run, ["git", "revert", "--abort"], root, "revert-abort", deps.signal);
+        if (isIndexBusy(abort)) {
+          await new Promise((resolve) => setTimeout(resolve, 150));
+          abort = await runCommand(deps.run, ["git", "revert", "--abort"], root, "revert-abort-retry", deps.signal);
+        }
+        const aborted = "run" in abort && abort.run.exitCode === 0;
+        return aborted ? { ok: false, error: { code: "revert-conflict", message: failure.message + where } } : { ok: false, error: { code: "revert-stuck", message: failure.message + where } };
+      }
+      return { ok: false, error: { code: failure.code, message: failure.message + where } };
+    }
+    if ((request.action.kind === "stash-push" || stashing) && /No local changes to save/i.test(outcome.run.stdout + outcome.run.stderr)) {
+      const message = (outcome.run.stdout.trim() || "No local changes to save") + where;
+      return { ok: false, error: { code: stashing ? "local-changes-block" : "git-error", message } };
+    }
+  }
+  const snapshot = await snapshotForSession(deps, config, request.sessionId);
+  if (!snapshot.ok) {
+    return { ok: false, error: { code: "git-error", message: "snapshot after action failed" } };
+  }
+  return { ok: true, snapshot: snapshot.value, output: lastOutput.trim() };
+}
+async function discardUntracked(deps, config, root, sessionId, paths) {
+  const snap = await snapshotForSession(deps, config, sessionId);
+  if (!snap.ok) return null;
+  const untrackedSet = new Set(snap.value.changes.filter((c) => c.status === "untracked").map((c) => c.path));
+  const untracked = paths.filter((p) => untrackedSet.has(p));
+  if (untracked.length === 0) return null;
+  const tracked = paths.filter((p) => !untrackedSet.has(p));
+  let rootReal;
+  try {
+    rootReal = await deps.fs.realpath(root);
+  } catch {
+    return { ok: false, result: { ok: false, error: { code: "git-error", message: "repository root unavailable" } } };
+  }
+  for (const path of untracked) {
+    if (!isSafePath(path)) return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `unsafe path: ${path}` } } };
+    const target = join(root, path);
+    let targetReal;
+    try {
+      targetReal = await deps.fs.realpath(target);
+    } catch {
+      continue;
+    }
+    if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep)) {
+      return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `path escapes repository: ${path}` } } };
+    }
+    await deps.fs.remove(target).catch(() => {
+    });
+  }
+  return { ok: true, remainingTracked: tracked };
+}
+export {
+  classifyActionFailure,
+  isSafePath,
+  planAction,
+  runAction,
+  scrubCredentials
+};

package/lib/host/core.d.ts

@@ -1,6 +1,6 @@
-import type { GitRunner } from './git.ts';
-import type { AgentDefaultModelFace, LlmFace } from './llm-face.ts';
-import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult } from './types.ts';
+import type { GitRunner } from './git.js';
+import type { AgentDefaultModelFace, LlmFace } from './llm-face.js';
+import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult } from './types.js';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
     /** Per-command stdout cap; also the per-side image-diff payload cap. */
@@ -15,9 +15,11 @@ export interface GitPanelConfig {
     readonly graphStyle: GraphStyle;
     /** Whether the "AI suggest" button shows in the commit box. */
     readonly suggestEnabled: boolean;
-    /** Max diff bytes sent to the model; beyond this the diff is truncated. */
+    /** Max diff bytes sent to the model; beyond this the diff is truncated. Range 16–512 KiB. */
     readonly suggestMaxBytes: number;
+    /** Model output token budget (reasoning tokens count against it on thinking models). Range 256–16384. */
     readonly suggestMaxOutputTokens: number;
+    /** Timeout for one suggest call. Range 5–120 s. */
     readonly suggestTimeoutMs: number;
     /** Optional provider/model route override; absent → the agent default. */
     readonly suggestProvider?: string;
@@ -46,6 +48,12 @@ export interface SnapshotDeps {
         }>;
         /** Raw bytes (no encoding) — image sides for the image-diff query. */
         readFile(path: string): Promise<Buffer>;
+        /**
+         * A symlink's target text, else null. git stores the LINK as the worktree
+         * blob (mode 120000), so the diff's new side is the target string, not the
+         * file it points at — following the link would describe a different file.
+         */
+        symlinkTarget(path: string): Promise<string | null>;
         /** One directory's entries (name + is-directory) — the file browser. */
         readdir(path: string): Promise<ReadonlyArray<{
             name: string;

package/lib/host/core.js

@@ -0,0 +1,305 @@
+import { dirname, join } from "node:path";
+import { commitFromFields, parseStatus, sumNumstat } from "./parser.js";
+import { parseRemote } from "./remote.js";
+import { isSafePath } from "./validate.js";
+import { SUGGEST_LIMITS } from "./types.js";
+const DEFAULT_CONFIG = {
+  timeoutMs: 8e3,
+  maxBytes: 4 * 1024 * 1024,
+  maxChanges: 1e3,
+  refreshIntervalMs: 3e4,
+  showInputPill: true,
+  defaultDiffView: "unified",
+  graphStyle: "parallel",
+  suggestEnabled: true,
+  suggestMaxBytes: SUGGEST_LIMITS.maxBytes.default,
+  suggestMaxOutputTokens: SUGGEST_LIMITS.maxOutputTokens.default,
+  suggestTimeoutMs: SUGGEST_LIMITS.timeoutMs.default
+};
+function normalizeConfig(raw) {
+  const c = raw ?? {};
+  const num = (v, d) => typeof v === "number" && Number.isFinite(v) && v >= 1 ? Math.floor(v) : d;
+  const clampLimit = (v, limit) => {
+    const raw2 = unwrapVolatile(v);
+    return typeof raw2 === "number" && Number.isFinite(raw2) ? Math.min(limit.max, Math.max(limit.min, Math.floor(raw2))) : limit.default;
+  };
+  const hasProvider = typeof c.suggestProvider === "string" && c.suggestProvider !== "";
+  const hasModel = typeof c.suggestModel === "string" && c.suggestModel !== "";
+  const route = hasProvider && hasModel ? { suggestProvider: c.suggestProvider, suggestModel: c.suggestModel } : {};
+  return {
+    timeoutMs: num(c.timeoutMs, DEFAULT_CONFIG.timeoutMs),
+    maxBytes: num(c.maxBytes, DEFAULT_CONFIG.maxBytes),
+    maxChanges: num(c.maxChanges, DEFAULT_CONFIG.maxChanges),
+    refreshIntervalMs: num(c.refreshIntervalMs, DEFAULT_CONFIG.refreshIntervalMs),
+    showInputPill: readBool(c.showInputPill, DEFAULT_CONFIG.showInputPill),
+    defaultDiffView: readDiffView(c.defaultDiffView, DEFAULT_CONFIG.defaultDiffView),
+    graphStyle: readGraphStyle(c.graphStyle, DEFAULT_CONFIG.graphStyle),
+    suggestEnabled: readBool(c.suggestEnabled, DEFAULT_CONFIG.suggestEnabled),
+    suggestMaxBytes: clampLimit(c.suggestMaxBytes, SUGGEST_LIMITS.maxBytes),
+    suggestMaxOutputTokens: clampLimit(c.suggestMaxOutputTokens, SUGGEST_LIMITS.maxOutputTokens),
+    suggestTimeoutMs: clampLimit(c.suggestTimeoutMs, SUGGEST_LIMITS.timeoutMs),
+    ...route
+  };
+}
+function unwrapVolatile(value) {
+  return value !== null && typeof value === "object" && "get" in value && typeof value.get === "function" ? value.get() : value;
+}
+function readDiffView(value, fallback) {
+  const raw = unwrapVolatile(value);
+  return raw === "unified" || raw === "split" ? raw : fallback;
+}
+function readGraphStyle(value, fallback) {
+  const raw = unwrapVolatile(value);
+  return raw === "parallel" || raw === "compact" ? raw : fallback;
+}
+function readBool(value, fallback) {
+  const raw = unwrapVolatile(value);
+  return typeof raw === "boolean" ? raw : fallback;
+}
+const NEG_CACHE_MS = 15e3;
+function parsePrimaryRemote(stdout) {
+  const fetchUrls = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const line of stdout.split("\n")) {
+    const m = line.match(/^(\S+)\t(\S+)\s+\(fetch\)$/);
+    if (m === null) continue;
+    const name2 = m[1];
+    if (!fetchUrls.has(name2)) {
+      fetchUrls.set(name2, m[2]);
+      order.push(name2);
+    }
+  }
+  if (order.length === 0) return null;
+  const name = fetchUrls.has("origin") ? "origin" : order[0];
+  return parseRemote(name, fetchUrls.get(name));
+}
+const STATS_FANOUT_LIMIT = 200;
+async function resolveBrowseRoot(deps, sessionId) {
+  const ws = await resolveWorkspace(deps, sessionId);
+  if (ws.ok) return { ok: true, root: ws.root, isGitRepo: true };
+  const err = ws.failure.error;
+  if ((err.code === "not-a-git-repo" || err.code === "git-unavailable") && "cwd" in err && err.cwd !== void 0 && err.cwd !== "") {
+    try {
+      return { ok: true, root: await deps.fs.realpath(err.cwd), isGitRepo: false };
+    } catch {
+      return { ok: false, error: { code: "git-error" } };
+    }
+  }
+  return { ok: false, error: mapWorkspaceFailure(ws.failure) };
+}
+async function resolveWorkspace(deps, sessionId) {
+  let cwd = deps.sessions.liveCwd(sessionId);
+  if (cwd === void 0 || cwd === "") {
+    const meta = await deps.sessions.persistedMeta(sessionId);
+    cwd = meta?.cwd;
+  }
+  if (cwd === void 0 || cwd === "") {
+    return { ok: false, failure: { ok: false, error: { code: "cwd-unavailable", sessionId } } };
+  }
+  const cached = deps.rootCache?.get(cwd);
+  if (cached !== void 0) return { ok: true, root: cached };
+  const negAt = deps.rootNegCache?.get(cwd);
+  if (negAt !== void 0) {
+    if (Date.now() < negAt) return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
+    deps.rootNegCache?.delete(cwd);
+  }
+  const top = await runCommand(deps.run, ["git", "rev-parse", "--show-toplevel"], cwd, "toplevel", deps.signal);
+  if ("failure" in top) {
+    return { ok: false, failure: { ok: false, error: { ...mapRunFailure(top.failure), cwd } } };
+  }
+  if (top.run.cancelled) return { ok: false, failure: { ok: false, error: { code: "cancelled" } } };
+  if (top.run.timedOut) return { ok: false, failure: { ok: false, error: { code: "timeout" } } };
+  if (top.run.exitCode !== 0) {
+    deps.rootNegCache?.set(cwd, Date.now() + NEG_CACHE_MS);
+    return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
+  }
+  const raw = top.run.stdout.trim();
+  if (raw === "") {
+    deps.rootNegCache?.set(cwd, Date.now() + NEG_CACHE_MS);
+    return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
+  }
+  let root = raw;
+  try {
+    root = await deps.fs.realpath(raw);
+  } catch {
+  }
+  deps.rootCache?.set(cwd, root);
+  return { ok: true, root };
+}
+async function runCommand(runner, argv, cwd, _label, signal, stdinData) {
+  try {
+    const run = await runner.run(argv, { cwd, ...signal ? { signal } : {}, ...stdinData !== void 0 ? { stdinData } : {} });
+    return { run };
+  } catch (error) {
+    return { failure: error };
+  }
+}
+function mapRunFailure(failure) {
+  const message = failure instanceof Error ? failure.message : String(failure);
+  return { code: "git-unavailable", detail: message };
+}
+async function detectGitRepo(deps, cwd) {
+  let dir;
+  try {
+    dir = await deps.fs.realpath(cwd);
+  } catch {
+    dir = cwd;
+  }
+  for (let i = 0; i < 100; i++) {
+    try {
+      await deps.fs.stat(join(dir, ".git"));
+      return true;
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+function mapWorkspaceFailure(failure) {
+  const error = failure.error;
+  const message = "detail" in error ? error.detail : void 0;
+  return { code: error.code, ...message !== void 0 ? { message } : {} };
+}
+async function snapshotForSession(deps, config, sessionId) {
+  const workspace = await resolveWorkspace(deps, sessionId);
+  if (!workspace.ok) {
+    const failure = workspace.failure;
+    if (failure.error.code === "not-a-git-repo") {
+      return { ok: false, error: { ...failure.error, showInputPill: config.showInputPill } };
+    }
+    if (failure.error.code === "git-unavailable") {
+      const cwd = failure.error.cwd;
+      const isGitRepo = cwd !== void 0 && cwd !== "" ? await detectGitRepo(deps, cwd) : false;
+      return { ok: false, error: { ...failure.error, isGitRepo } };
+    }
+    return failure;
+  }
+  const root = workspace.root;
+  const [branchRes, headRes, statusRes, aheadBehindRes, lastCommitRes, worktreeNumRes, stagedNumRes, remoteRes] = await Promise.all([
+    runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], root, "branch", deps.signal),
+    runCommand(deps.run, ["git", "rev-parse", "--short", "HEAD"], root, "head", deps.signal),
+    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z"], root, "status", deps.signal),
+    runCommand(deps.run, ["git", "rev-list", "--count", "--left-right", "@{upstream}...HEAD"], root, "aheadBehind", deps.signal),
+    runCommand(deps.run, ["git", "log", "-1", "--format=%H%x1f%h%x1f%s%x1f%an%x1f%aI"], root, "lastCommit", deps.signal),
+    runCommand(deps.run, ["git", "diff", "--numstat"], root, "numstat-worktree", deps.signal),
+    runCommand(deps.run, ["git", "diff", "--numstat", "--cached"], root, "numstat-staged", deps.signal),
+    // `git remote -v` lists every remote's fetch/push URL; parsed into the
+    // primary remote (origin, else the first) for the left-column status bar.
+    runCommand(deps.run, ["git", "remote", "-v"], root, "remote", deps.signal)
+  ]);
+  const branch = "run" in branchRes && branchRes.run.exitCode === 0 ? branchRes.run.stdout.trim() || null : null;
+  const unborn = "run" in headRes && headRes.run.exitCode !== 0;
+  const head = "run" in headRes && headRes.run.exitCode === 0 ? headRes.run.stdout.trim() || null : null;
+  let allChanges = [];
+  let statusLossy = false;
+  if ("run" in statusRes && !statusRes.run.timedOut && statusRes.run.exitCode === 0) {
+    allChanges = parseStatus(statusRes.run.stdout);
+    statusLossy = statusRes.run.stdoutLossy;
+  }
+  const truncated = allChanges.length > config.maxChanges || statusLossy;
+  const changes = allChanges.length > config.maxChanges ? allChanges.slice(0, config.maxChanges) : allChanges;
+  let staged = 0;
+  let modified = 0;
+  let untracked = 0;
+  for (const c of allChanges) {
+    if (c.status === "untracked") untracked++;
+    else if (c.staged) staged++;
+    else modified++;
+  }
+  let ahead = 0;
+  let behind = 0;
+  const hasUpstream = "run" in aheadBehindRes && aheadBehindRes.run.exitCode === 0;
+  if (hasUpstream && "run" in aheadBehindRes) {
+    const parts = aheadBehindRes.run.stdout.trim().split(/\s+/);
+    behind = Number(parts[0]) || 0;
+    ahead = Number(parts[1]) || 0;
+  }
+  const remote = "run" in remoteRes && remoteRes.run.exitCode === 0 ? parsePrimaryRemote(remoteRes.run.stdout) : null;
+  let lastCommit = null;
+  if ("run" in lastCommitRes && lastCommitRes.run.exitCode === 0) {
+    lastCommit = commitFromFields(lastCommitRes.run.stdout.trim().split(""));
+  }
+  const wt = "run" in worktreeNumRes && worktreeNumRes.run.exitCode === 0 ? sumNumstat(worktreeNumRes.run.stdout) : { insertions: 0, deletions: 0 };
+  const stg = "run" in stagedNumRes && stagedNumRes.run.exitCode === 0 ? sumNumstat(stagedNumRes.run.stdout) : { insertions: 0, deletions: 0 };
+  const statsDetailed = allChanges.length <= STATS_FANOUT_LIMIT;
+  let untrackedInsertions = 0;
+  if (statsDetailed) {
+    const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
+    const safeUntracked = untrackedPaths.filter(isSafePath);
+    if (safeUntracked.length > 0) {
+      const perFile = await Promise.all(
+        safeUntracked.map((p) => runCommand(deps.run, ["git", "diff", "--numstat", "--no-index", "--", "/dev/null", p], root, "numstat-untracked", deps.signal))
+      );
+      for (const r of perFile) if ("run" in r) untrackedInsertions += sumNumstat(r.run.stdout).insertions;
+    }
+  }
+  const lastChangeAt = statsDetailed ? await maxChangeMtime(deps, root, allChanges) : null;
+  const distinct = new Set(allChanges.map((c) => c.path));
+  const stats = {
+    fileCount: distinct.size,
+    staged,
+    modified,
+    untracked,
+    insertions: wt.insertions + stg.insertions + untrackedInsertions,
+    deletions: wt.deletions + stg.deletions,
+    lastChangeAt,
+    headCommittedAt: lastCommit?.dateIso ?? null,
+    partial: !statsDetailed
+  };
+  const snapshot = {
+    root,
+    branch,
+    head,
+    unborn,
+    dirty: allChanges.length > 0,
+    staged,
+    modified,
+    untracked,
+    ahead,
+    behind,
+    hasUpstream,
+    remote,
+    lastCommit,
+    changes,
+    stats,
+    truncated,
+    refreshIntervalMs: config.refreshIntervalMs,
+    showInputPill: config.showInputPill,
+    defaultDiffView: config.defaultDiffView,
+    graphStyle: config.graphStyle,
+    suggestEnabled: config.suggestEnabled,
+    checkedAt: Date.now()
+  };
+  return { ok: true, value: snapshot };
+}
+async function maxChangeMtime(deps, root, changes, cap = 200) {
+  let max = null;
+  const slice = changes.slice(0, cap);
+  await Promise.all(slice.map(async (c) => {
+    if (c.isDirectory) return;
+    try {
+      const info = await deps.fs.stat(join(root, c.path));
+      if (Number.isFinite(info.mtimeMs)) {
+        max = max === null ? info.mtimeMs : Math.max(max, info.mtimeMs);
+      }
+    } catch {
+    }
+  }));
+  return max;
+}
+export {
+  DEFAULT_CONFIG,
+  mapWorkspaceFailure,
+  maxChangeMtime,
+  normalizeConfig,
+  parsePrimaryRemote,
+  readBool,
+  readDiffView,
+  readGraphStyle,
+  resolveBrowseRoot,
+  resolveWorkspace,
+  runCommand,
+  snapshotForSession
+};