@xbzbing/dsh-git-panel 1.3.0 → 1.4.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, 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

package/lib/host/index.d.ts

@@ -10,11 +10,11 @@ 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 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, } from './types.ts';
 export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace } 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 { 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 +29,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

@@ -250,6 +250,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");
@@ -318,6 +337,7 @@ var DEFAULT_CONFIG = {
   refreshIntervalMs: 3e4,
   showInputPill: true,
   defaultDiffView: "unified",
+  graphStyle: "parallel",
   suggestEnabled: true,
   suggestMaxBytes: 64 * 1024,
   suggestMaxOutputTokens: 200,
@@ -336,6 +356,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 +371,16 @@ 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;
+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 };
@@ -499,16 +525,19 @@ async function snapshotForSession(deps, config, sessionId) {
   }
   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 +547,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,
@@ -538,6 +568,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,14 +630,86 @@ function planAction(action, unborn) {
       return { argv: [["git", "checkout", "--end-of-options", action.name]] };
     case "fetch":
       return { argv: [["git", "fetch", "--all", "--prune"]] };
+    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 (/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) {
@@ -624,7 +727,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 +741,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,6 +853,8 @@ 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":
@@ -1096,6 +1211,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)) : [];
@@ -1557,6 +1677,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 +1688,7 @@ export {
   DEFAULT_CONFIG,
   GitPanelService,
   checkLatestVersion,
+  classifyActionFailure,
   compareVersions,
   createGitRunner,
   index_default as default,
@@ -1573,7 +1698,9 @@ export {
   parseGraphLog,
   parseNameStatus,
   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/types.d.ts

@@ -5,6 +5,10 @@
  */
 /** Diff layout: `unified` = single inline column, `split` = side-by-side. */
 export type DiffViewMode = 'unified' | 'split';
+/** Commit-graph line style: `compact` = converge a shared ancestor into one
+ * lane (git log --graph); `parallel` = keep each merge's first parent in its
+ * own lane, converging only at the ancestor (VSCode / GUI tools). */
+export type GraphStyle = 'compact' | 'parallel';
 /** Wire request: the browser sends only session identity, never a path. */
 export interface GitSnapshotRequest {
     readonly sessionId: string;
@@ -62,6 +66,8 @@ export interface GitSnapshot {
     readonly showInputPill: boolean;
     /** Default diff layout the views open with (user preference). */
     readonly defaultDiffView: DiffViewMode;
+    /** Commit-graph line style (user preference). */
+    readonly graphStyle: GraphStyle;
     /** Whether the commit box shows the AI-suggest button (user preference). */
     readonly suggestEnabled: boolean;
     /** Epoch millis of the snapshot. */
@@ -122,8 +128,41 @@ export type GitAction = {
     readonly name: string;
 } | {
     readonly kind: 'fetch';
+} | {
+    readonly kind: 'tag-create';
+    readonly name: string;
+    readonly commit: string;
+    readonly message?: string;
+} | {
+    readonly kind: 'tag-delete';
+    readonly name: string;
+} | {
+    readonly kind: 'stash-push';
+    readonly message?: string;
+} | {
+    readonly kind: 'stash-apply';
+    readonly index: number;
+    readonly sha: string;
+} | {
+    readonly kind: 'stash-pop';
+    readonly index: number;
+    readonly sha: string;
+} | {
+    readonly kind: 'stash-drop';
+    readonly index: number;
+    readonly sha: string;
+} | {
+    readonly kind: 'revert';
+    readonly commit: string;
+} | {
+    readonly kind: 'reset';
+    readonly commit: string;
+    readonly mode: ResetMode;
 };
-export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
+/** `git reset` modes, from least to most destructive. Single source so the
+ * client dialog and the command builder cannot drift. */
+export type ResetMode = 'soft' | 'mixed' | 'hard';
+export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
 export type GitActionResult = {
     readonly ok: true;
     readonly snapshot: GitSnapshot;
@@ -197,6 +236,8 @@ export type GitQuery = {
     readonly kind: 'branches';
 } | {
     readonly kind: 'tags';
+} | {
+    readonly kind: 'stash-list';
 } | {
     readonly kind: 'authors';
 } | {
@@ -224,6 +265,19 @@ export interface GitBranch {
     readonly ahead?: number;
     readonly behind?: number;
 }
+/** One entry in the stash stack (`git stash list`). */
+export interface StashEntry {
+    /** Stack position (0 = most recent). */
+    readonly index: number;
+    /** The stash commit SHA — a stable id the index position is not (see run). */
+    readonly sha: string;
+    /** The stash message (custom `-m` text, or the auto "WIP on …" subject). */
+    readonly message: string;
+    /** Branch the stash was taken on; null when it could not be parsed. */
+    readonly branch: string | null;
+    /** Human relative time (e.g. "2 hours ago"). */
+    readonly relTime: string;
+}
 /** Working-tree statistics for the changes page header. */
 export interface WorktreeStats {
     /** Distinct changed-file paths (staged ∪ modified ∪ untracked). */
@@ -239,6 +293,13 @@ export interface WorktreeStats {
     readonly lastChangeAt: number | null;
     /** HEAD commit time ISO; null when unborn. */
     readonly headCommittedAt: string | null;
+    /**
+     * True when the per-file fan-outs were skipped because the change set was too
+     * large (issue #16): `insertions` then omits untracked lines and
+     * `lastChangeAt` is null. Counts (fileCount/staged/modified/untracked) and
+     * tracked insertions/deletions stay exact.
+     */
+    readonly partial: boolean;
 }
 export type GitQueryResult = {
     readonly kind: 'history';
@@ -286,6 +347,9 @@ export type GitQueryResult = {
 } | {
     readonly kind: 'tags';
     readonly tags: readonly GitBranch[];
+} | {
+    readonly kind: 'stash-list';
+    readonly entries: readonly StashEntry[];
 } | {
     readonly kind: 'authors';
     readonly authors: readonly string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbzbing/dsh-git-panel",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "DeepSeek Harness (dsh) plugin: an IDE-style Git panel in the Web GUI — branch/history overview, uncommitted changes with commit & amend, diff stats, and a zsh-style branch marker in the input bar.",
   "type": "module",
   "license": "MIT",