@xbzbing/dsh-git-panel 1.3.0 → 1.5.0

package/lib/host/actions.d.ts

@@ -11,5 +11,24 @@ type PlanResult = CommandPlan | {
 };
 /** Build the git command sequence for an action. */
 export declare function planAction(action: GitAction, unborn: boolean): PlanResult;
+/**
+ * Classify a non-zero git exit into a wire error code + message. Order is
+ * semantic and must not be reshuffled:
+ *  - conflict first — a stash apply/pop conflict prints both "CONFLICT …" and
+ *    "no changes added to commit", so it must win over the nothing-to-commit
+ *    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).
+ *  - 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
+ *    refuses before touching the work tree, so it is a plain refusal).
+ *  - git-error fallback (surface the repo's own stderr).
+ */
+export declare function classifyActionFailure(stdout: string, stderr: string, exitCode: number): {
+    code: GitErrorCode;
+    message: string;
+};
 /** Execute a management action, returning the fresh snapshot on success. */
 export declare function runAction(deps: SnapshotDeps, config: GitPanelConfig, request: GitActionRequest): Promise<GitActionResult>;

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, GitChange, GitErrorCode, GitSnapshotResult } from './types.ts';
+import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult } from './types.ts';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
     /** Per-command stdout cap; also the per-side image-diff payload cap. */
@@ -11,6 +11,8 @@ export interface GitPanelConfig {
     readonly showInputPill: boolean;
     /** Default diff layout the views open with (user can switch per-diff). */
     readonly defaultDiffView: DiffViewMode;
+    /** Commit-graph line style (parallel = VSCode-like, compact = git log). */
+    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. */
@@ -25,6 +27,8 @@ export declare const DEFAULT_CONFIG: GitPanelConfig;
 export declare function normalizeConfig(raw: unknown): GitPanelConfig;
 /** Read the default-diff-view field, unwrapping a schemastery volatile ref. */
 export declare function readDiffView(value: unknown, fallback: DiffViewMode): DiffViewMode;
+/** Read the commit-graph style field, unwrapping a schemastery volatile ref. */
+export declare function readGraphStyle(value: unknown, fallback: GraphStyle): GraphStyle;
 /**
  * Read a boolean config field, unwrapping a schemastery volatile reference
  * (`{ get() }`) so a live-editable toggle reflects the latest value. Absent or
@@ -81,6 +85,12 @@ export interface SnapshotDeps {
     readonly getLlm?: () => LlmFace | undefined;
     readonly getAgentDefaultModel?: () => AgentDefaultModelFace | undefined;
 }
+/**
+ * Pick the primary remote from `git remote -v` output and parse its fetch URL.
+ * Prefers `origin`; otherwise the first remote listed. Lines look like
+ * `origin\thttps://…\t(fetch)` — only `(fetch)` rows are considered.
+ */
+export declare function parsePrimaryRemote(stdout: string): GitRemote | null;
 export type WorkspaceResolution = {
     readonly ok: true;
     readonly root: string;

package/lib/host/git.d.ts

@@ -18,6 +18,8 @@ interface SpawnSpec {
     };
     readonly graceMs: number;
     readonly signal?: AbortSignal;
+    /** Explicit child env entries merged onto the service's scrubbed base. */
+    readonly env?: Readonly<Record<string, string | undefined>>;
 }
 interface OutputRead {
     readonly text: string;

package/lib/host/index.d.ts

@@ -10,11 +10,12 @@ import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import type { GitActionRequest, GitActionResult, GitQueryRequest, GitQueryResponse, GitSnapshotRequest, GitSnapshotResult, GitSuggestRequest, GitSuggestResult, GitVersionInfo, GitVersionRequest } from './types.ts';
-export type { GitSnapshot, GitSnapshotResult, GitSnapshotRequest, GitFailure, GitCommit, GraphCommit, GitRef, GitChange, GitChangeStatus, GitAction, GitActionRequest, GitActionResult, GitErrorCode, GitQuery, GitQueryRequest, GitQueryResponse, GitQueryResult, GitBranch, GitFileStat, WorktreeStats, GitVersionRequest, GitVersionInfo, DiffViewMode, DirEntry, GitSuggestRequest, GitSuggestResult, } from './types.ts';
-export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace } from './core.ts';
+export type { GitSnapshot, GitSnapshotResult, GitSnapshotRequest, GitFailure, GitCommit, GraphCommit, GitRef, GitChange, GitChangeStatus, GitAction, GitActionRequest, GitActionResult, GitErrorCode, GitQuery, GitQueryRequest, GitQueryResponse, GitQueryResult, GitBranch, GitFileStat, WorktreeStats, StashEntry, GitVersionRequest, GitVersionInfo, DiffViewMode, GraphStyle, DirEntry, ResetMode, GitSuggestRequest, GitSuggestResult, GitRemote, RemoteHostKind, } from './types.ts';
+export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace, parsePrimaryRemote } from './core.ts';
 export { createGitRunner } from './git.ts';
-export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, sumNumstat } from './parser.ts';
-export { isSafePath, planAction, runAction } from './actions.ts';
+export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from './parser.ts';
+export { parseRemote, classifyHost } from './remote.ts';
+export { isSafePath, planAction, runAction, classifyActionFailure } from './actions.ts';
 export { runQuery } from './queries.ts';
 export { runSuggest } from './suggest.ts';
 export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository } from './version.ts';
@@ -29,10 +30,12 @@ export declare class GitPanelService extends TypertRemoteService {
     static Config: Schema<Schemastery.ObjectS<NoInfer<{
         showInputPill: Schema<boolean, boolean, "volatile-defined">;
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
+        graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
     }>>, Schemastery.ObjectT<NoInfer<{
         showInputPill: Schema<boolean, boolean, "volatile-defined">;
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
+        graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
     }>>, "plain">;
     private readonly deps;

package/lib/host/index.js

@@ -65,6 +65,11 @@ function createGitRunner(subprocess, timeoutMs, maxBytes) {
         const handle = subprocess.spawn({
           argv,
           cwd: opts.cwd,
+          // Never let a network command (fetch/pull) block on an interactive
+          // credential or host-key prompt: with stdin ignored git would hang
+          // until the timeout. GIT_TERMINAL_PROMPT=0 makes it fail fast instead,
+          // and is harmless for the non-network commands that share this runner.
+          env: { GIT_TERMINAL_PROMPT: "0" },
           stdio: {
             stdin: opts.stdinData === void 0 ? "ignore" : { data: opts.stdinData },
             stdout: { collect: { maxBytes, spill: { maxBytes: spillMaxBytes } } },
@@ -214,7 +219,15 @@ function parseRefs(decoration) {
       continue;
     }
     if (token.startsWith("tag: ")) {
-      refs.push({ kind: "tag", name: token.slice("tag: ".length).trim(), head: false });
+      refs.push({ kind: "tag", name: token.slice("tag: ".length).trim().replace(/^refs\/tags\//, ""), head: false });
+    } else if (token.startsWith("refs/tags/")) {
+      refs.push({ kind: "tag", name: token.slice("refs/tags/".length), head: false });
+    } else if (token.startsWith("refs/remotes/")) {
+      refs.push({ kind: "remote", name: token.slice("refs/remotes/".length), head });
+    } else if (token.startsWith("refs/heads/")) {
+      refs.push({ kind: "branch", name: token.slice("refs/heads/".length), head });
+    } else if (head) {
+      refs.push({ kind: "branch", name: token, head });
     } else if (token.startsWith("origin/") || token.includes("/")) {
       refs.push({ kind: "remote", name: token, head });
     } else {
@@ -250,6 +263,25 @@ function parseTags(stdout) {
   }
   return out;
 }
+function parseStashList(stdout) {
+  const out = [];
+  for (const record of stdout.split("\0")) {
+    if (record.trim() === "") continue;
+    const [selector = "", sha = "", subject = "", relTime = ""] = record.split("");
+    const idxMatch = /stash@\{(\d+)\}/.exec(selector);
+    if (idxMatch === null) continue;
+    const index = Number(idxMatch[1]);
+    let branch = null;
+    let message = subject;
+    const m = /^(?:WIP on|On) (.+?): (.*)$/s.exec(subject);
+    if (m !== null) {
+      branch = m[1] === "(no branch)" ? null : m[1] ?? null;
+      message = m[2] ?? "";
+    }
+    out.push({ index, sha: sha.trim(), message: message.trim(), branch, relTime: relTime.trim() });
+  }
+  return out;
+}
 function parseNameStatus(stdout) {
   const out = [];
   const tokens = stdout.split("\0");
@@ -291,6 +323,52 @@ function sumNumstat(stdout) {
   return { insertions, deletions };
 }
 
+// src/host/remote.ts
+function classifyHost(host) {
+  const h = host.toLowerCase();
+  if (h === "github.com" || h.endsWith(".github.com")) return "github";
+  if (h === "gitlab.com" || h.endsWith(".gitlab.com")) return "gitlab";
+  if (h === "gitee.com" || h.endsWith(".gitee.com")) return "gitee";
+  if (h === "bitbucket.org" || h.endsWith(".bitbucket.org")) return "bitbucket";
+  return "other";
+}
+function normalizePath(path) {
+  return path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+}
+function splitHostPath(raw) {
+  const url = raw.trim();
+  if (url === "") return null;
+  const scp = url.match(/^(?:[^@/]+@)?([^/:]+):(.+)$/);
+  if (scp !== null && !/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
+    const host = scp[1];
+    const path = normalizePath(scp[2]);
+    return host !== "" && path !== "" ? { host, path } : null;
+  }
+  const scheme = url.match(/^[a-z][a-z0-9+.-]*:\/\/([^/]+)\/(.+)$/i);
+  if (scheme !== null) {
+    let authority = scheme[1];
+    const at = authority.lastIndexOf("@");
+    if (at >= 0) authority = authority.slice(at + 1);
+    const host = authority.replace(/:\d+$/, "");
+    const path = normalizePath(scheme[2]);
+    return host !== "" && path !== "" ? { host, path } : null;
+  }
+  return null;
+}
+function parseRemote(name, url) {
+  const parsed = splitHostPath(url);
+  if (parsed === null) {
+    return { name, url, webUrl: null, host: null, hostKind: "other" };
+  }
+  return {
+    name,
+    url,
+    webUrl: `https://${parsed.host}/${parsed.path}`,
+    host: parsed.host,
+    hostKind: classifyHost(parsed.host)
+  };
+}
+
 // src/host/validate.ts
 import { isAbsolute, normalize } from "node:path";
 function isSafePath(path) {
@@ -318,6 +396,7 @@ var DEFAULT_CONFIG = {
   refreshIntervalMs: 3e4,
   showInputPill: true,
   defaultDiffView: "unified",
+  graphStyle: "parallel",
   suggestEnabled: true,
   suggestMaxBytes: 64 * 1024,
   suggestMaxOutputTokens: 200,
@@ -336,6 +415,7 @@ function normalizeConfig(raw) {
     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: num(c.suggestMaxBytes, DEFAULT_CONFIG.suggestMaxBytes),
     suggestMaxOutputTokens: num(c.suggestMaxOutputTokens, DEFAULT_CONFIG.suggestMaxOutputTokens),
@@ -350,11 +430,32 @@ 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;
 }
 var 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));
+}
+var 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 };
@@ -458,14 +559,17 @@ async function snapshotForSession(deps, config, sessionId) {
     return failure;
   }
   const root = workspace.root;
-  const [branchRes, headRes, statusRes, aheadBehindRes, lastCommitRes, worktreeNumRes, stagedNumRes] = await Promise.all([
+  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)
+    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;
@@ -488,27 +592,32 @@ async function snapshotForSession(deps, config, sessionId) {
   }
   let ahead = 0;
   let behind = 0;
-  if ("run" in aheadBehindRes && aheadBehindRes.run.exitCode === 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;
-  const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
-  const safeUntracked = untrackedPaths.filter(isSafePath).slice(0, 200);
-  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 = await maxChangeMtime(deps, root, allChanges);
+  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,
@@ -518,7 +627,8 @@ async function snapshotForSession(deps, config, sessionId) {
     insertions: wt.insertions + stg.insertions + untrackedInsertions,
     deletions: wt.deletions + stg.deletions,
     lastChangeAt,
-    headCommittedAt: lastCommit?.dateIso ?? null
+    headCommittedAt: lastCommit?.dateIso ?? null,
+    partial: !statsDetailed
   };
   const snapshot = {
     root,
@@ -531,6 +641,8 @@ async function snapshotForSession(deps, config, sessionId) {
     untracked,
     ahead,
     behind,
+    hasUpstream,
+    remote,
     lastCommit,
     changes,
     stats,
@@ -538,6 +650,7 @@ async function snapshotForSession(deps, config, sessionId) {
     refreshIntervalMs: config.refreshIntervalMs,
     showInputPill: config.showInputPill,
     defaultDiffView: config.defaultDiffView,
+    graphStyle: config.graphStyle,
     suggestEnabled: config.suggestEnabled,
     checkedAt: Date.now()
   };
@@ -599,7 +712,73 @@ function planAction(action, unborn) {
       return { argv: [["git", "checkout", "--end-of-options", action.name]] };
     case "fetch":
       return { argv: [["git", "fetch", "--all", "--prune"]] };
+    case "pull-ff":
+      return { argv: [["git", "pull", "--ff-only"]] };
+    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 classifyActionFailure(stdout, stderr, exitCode) {
+  const combined = stderr + stdout;
+  const err = 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/i.test(combined)) {
+    return { code: "not-found", message: err || "not found" };
+  }
+  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);
@@ -607,6 +786,17 @@ async function runAction(deps, config, request) {
   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) {
@@ -624,7 +814,11 @@ async function runAction(deps, config, request) {
   let lastOutput = "";
   for (let step = 0; step < plan.argv.length; step += 1) {
     const argv = plan.argv[step];
-    const outcome = await runCommand(deps.run, argv, root, "action", deps.signal);
+    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(" ")})` : "";
     if ("failure" in outcome) {
       const message = outcome.failure instanceof Error ? outcome.failure.message : String(outcome.failure);
@@ -634,14 +828,20 @@ async function runAction(deps, config, request) {
     if (outcome.run.timedOut) return { ok: false, error: { code: "timeout" } };
     lastOutput = outcome.run.stdout || outcome.run.stderr;
     if (outcome.run.exitCode !== 0) {
-      const stderr = outcome.run.stderr;
-      if (/nothing to commit|no changes added/i.test(stderr + lastOutput)) {
-        return { ok: false, error: { code: "git-error", message: (stderr.trim() || "nothing to commit") + where } };
-      }
-      if (/would be overwritten by checkout|local changes/i.test(stderr)) {
-        return { ok: false, error: { code: "local-changes-block", message: stderr.trim() + where } };
+      const failure = classifyActionFailure(outcome.run.stdout, outcome.run.stderr, outcome.run.exitCode ?? -1);
+      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: "git-error", message: (stderr.trim() || `git exited ${outcome.run.exitCode}`) + where } };
+      return { ok: false, error: { code: failure.code, message: failure.message + where } };
+    }
+    if (request.action.kind === "stash-push" && /No local changes to save/i.test(outcome.run.stdout + outcome.run.stderr)) {
+      return { ok: false, error: { code: "git-error", message: (outcome.run.stdout.trim() || "No local changes to save") + where } };
     }
   }
   const snapshot = await snapshotForSession(deps, config, request.sessionId);
@@ -740,12 +940,16 @@ async function runQuery(deps, config, request) {
         return await queryBranches(deps, root);
       case "tags":
         return await queryTags(deps, root);
+      case "stash-list":
+        return await queryStashList(deps, root);
       case "authors":
         return await queryAuthors(deps, root);
       case "last-commit-message":
         return await queryLastCommitMessage(deps, root);
       case "worktree-stats":
         return await queryWorktreeStats(deps, config, request.sessionId);
+      case "pull-preview":
+        return await queryPullPreview(deps, root);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -755,7 +959,7 @@ async function runQuery(deps, config, request) {
 async function queryHistory(deps, root, q) {
   const limit = Number.isFinite(q.limit) ? Math.min(500, Math.max(1, Math.trunc(q.limit))) : 100;
   const skip = Number.isFinite(q.skip) ? Math.max(0, Math.trunc(q.skip)) : 0;
-  const args = ["git", "log", "--topo-order", GRAPH_FORMAT, `--max-count=${limit}`, `--skip=${skip}`];
+  const args = ["git", "log", "--topo-order", "--decorate=full", GRAPH_FORMAT, `--max-count=${limit}`, `--skip=${skip}`];
   const search = q.search?.trim() ?? "";
   const hexJump = search !== "" && isHexLike(search);
   const countArgs = ["git", "rev-list", "--count"];
@@ -1096,6 +1300,11 @@ async function queryTags(deps, root) {
   const tags = "run" in res && res.run.exitCode === 0 ? parseTags(res.run.stdout) : [];
   return { ok: true, value: { kind: "tags", tags } };
 }
+async function queryStashList(deps, root) {
+  const res = await runCommand(deps.run, ["git", "stash", "list", "-z", "--format=%gd%x1f%H%x1f%gs%x1f%cr"], root, "stash-list", deps.signal);
+  const entries = "run" in res && res.run.exitCode === 0 ? parseStashList(res.run.stdout) : [];
+  return { ok: true, value: { kind: "stash-list", entries } };
+}
 async function queryAuthors(deps, root) {
   const res = await runCommand(deps.run, ["git", "log", ...VISIBLE_REFS, "--format=%an", "--max-count=2000"], root, "authors", deps.signal);
   const authors = "run" in res && res.run.exitCode === 0 ? [...new Set(res.run.stdout.split("\n").map((s) => s.trim()).filter((s) => s !== ""))].sort((a, b) => a.localeCompare(b)) : [];
@@ -1106,6 +1315,23 @@ async function queryLastCommitMessage(deps, root) {
   const message = "run" in res && res.run.exitCode === 0 ? res.run.stdout.replace(/\n+$/, "") : "";
   return { ok: true, value: { kind: "last-commit-message", message } };
 }
+async function queryPullPreview(deps, root) {
+  const empty = { kind: "pull-preview", hasUpstream: false, commits: 0, files: 0, insertions: 0, deletions: 0 };
+  const commitsRes = await runCommand(deps.run, ["git", "rev-list", "--count", "--end-of-options", "HEAD..@{upstream}"], root, "pull-preview-count", deps.signal);
+  if (!("run" in commitsRes) || commitsRes.run.exitCode !== 0) return { ok: true, value: empty };
+  const commits = Number(commitsRes.run.stdout.trim()) || 0;
+  const diffRes = await runCommand(deps.run, ["git", "diff", "--numstat", "--end-of-options", "HEAD", "@{upstream}"], root, "pull-preview-diff", deps.signal);
+  let files = 0;
+  let insertions = 0;
+  let deletions = 0;
+  if ("run" in diffRes && diffRes.run.exitCode === 0) {
+    files = diffRes.run.stdout.split("\n").filter((l) => l.trim() !== "").length;
+    const sum = sumNumstat(diffRes.run.stdout);
+    insertions = sum.insertions;
+    deletions = sum.deletions;
+  }
+  return { ok: true, value: { kind: "pull-preview", hasUpstream: true, commits, files, insertions, deletions } };
+}
 async function queryWorktreeStats(deps, config, sessionId) {
   const snapshot = await snapshotForSession(deps, config, sessionId);
   if (!snapshot.ok) return { ok: false, error: { code: "git-error", message: "snapshot failed" } };
@@ -1557,6 +1783,10 @@ __publicField(GitPanelService, "Config", Schema.object({
     Schema.const("unified").description("\u7EDF\u4E00\u89C6\u56FE\uFF08\u5355\u680F\u884C\u5185\u5BF9\u6BD4\uFF09"),
     Schema.const("split").description("\u5E76\u6392\u89C6\u56FE\uFF08\u5DE6\u53F3\u5206\u680F\u5BF9\u6BD4\uFF09")
   ]).default("unified").volatile().description("\u5DEE\u5F02\u5BF9\u6BD4\u9ED8\u8BA4\u89C6\u56FE"),
+  graphStyle: Schema.union([
+    Schema.const("parallel").description("\u5E73\u884C\u7EBF\uFF08VSCode \u98CE\u683C\uFF0C\u5206\u652F\u5404\u5360\u4E00\u5217\uFF09"),
+    Schema.const("compact").description("\u7D27\u51D1\uFF08git log \u98CE\u683C\uFF0C\u5171\u4EAB\u7956\u5148\u5408\u5E76\u4E3A\u4E00\u5217\uFF09")
+  ]).default("parallel").volatile().description("\u63D0\u4EA4\u5386\u53F2\u56FE\u7EBF\u6761\u6837\u5F0F"),
   suggestEnabled: Schema.boolean().default(true).volatile().description("\u63D0\u4EA4\u6846\u663E\u793A AI \u751F\u6210\u6309\u94AE")
 }));
 var index_default = GitPanelService;
@@ -1564,6 +1794,8 @@ export {
   DEFAULT_CONFIG,
   GitPanelService,
   checkLatestVersion,
+  classifyActionFailure,
+  classifyHost,
   compareVersions,
   createGitRunner,
   index_default as default,
@@ -1572,8 +1804,12 @@ export {
   parseBranches,
   parseGraphLog,
   parseNameStatus,
+  parsePrimaryRemote,
+  parseRemote,
   parseRepository,
+  parseStashList,
   parseStatus,
+  parseTags,
   planAction,
   readVersionInfo,
   resolveWorkspace,

package/lib/host/parser.d.ts

@@ -2,7 +2,7 @@
  * git output parsers: porcelain status, log, branch, numstat, name-status.
  * Pure functions over raw stdout, no I/O.
  */
-import type { GitBranch, GitChange, GitCommit, GitFileStat, GraphCommit, GitRef } from './types.ts';
+import type { GitBranch, GitChange, GitCommit, GitFileStat, GraphCommit, GitRef, StashEntry } from './types.ts';
 /**
  * Build a GitCommit from a `%H\x1f%h\x1f%s\x1f%an\x1f%aI`-ordered field array
  * (the body, when present, is the caller's `parts.slice(5)`). Null when the
@@ -27,6 +27,14 @@ export declare function parseRefs(decoration: string): GitRef[];
 export declare function parseBranches(stdout: string): GitBranch[];
 /** Parse `git for-each-ref` tag lines: `name\0shortHash` per line. */
 export declare function parseTags(stdout: string): GitBranch[];
+/**
+ * Parse `git stash list -z --format=%gd%x1f%H%x1f%gs%x1f%cr` into stash entries.
+ * Each NUL-separated record is: selector (`stash@{N}`), the stash commit SHA, the
+ * reflog subject, and a relative time. The subject is either auto ("WIP on
+ * <branch>: <sha> <subj>") or custom ("On <branch>: <message>"); the branch is
+ * the text between "on " and the first ": ", and the message is after it.
+ */
+export declare function parseStashList(stdout: string): StashEntry[];
 /**
  * Parse `git show --name-status -z` into stats with an explicit state machine:
  * read a status token, then consume exactly the paths it owns (2 for R/C, 1

package/lib/host/remote.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parse a git remote URL into a browsable https page URL + host classification.
+ *
+ * Git remotes come in several shapes — scp-like ssh (`git@host:owner/repo.git`),
+ * ssh:// , https:// , git:// — all of which must collapse to a single
+ * `https://<host>/<path>` page link and a known-host kind for the status-bar
+ * icon. Credentials in the URL (`https://user:token@host/…`) are stripped so a
+ * token can never leak into an href the browser renders.
+ */
+import type { GitRemote, RemoteHostKind } from './types.ts';
+/** Map a hostname to a known-host kind (self-hosted / unknown → 'other'). */
+export declare function classifyHost(host: string): RemoteHostKind;
+/** Build a {@link GitRemote} from a remote name + its configured URL. */
+export declare function parseRemote(name: string, url: string): GitRemote;