@xbzbing/dsh-git-panel 1.2.0 → 1.4.0

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");
@@ -317,18 +336,32 @@ var DEFAULT_CONFIG = {
   maxChanges: 1e3,
   refreshIntervalMs: 3e4,
   showInputPill: true,
-  defaultDiffView: "unified"
+  defaultDiffView: "unified",
+  graphStyle: "parallel",
+  suggestEnabled: true,
+  suggestMaxBytes: 64 * 1024,
+  suggestMaxOutputTokens: 200,
+  suggestTimeoutMs: 15e3
 };
 function normalizeConfig(raw) {
   const c = raw ?? {};
   const num = (v, d) => typeof v === "number" && Number.isFinite(v) && v >= 1 ? Math.floor(v) : d;
+  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)
+    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),
+    suggestTimeoutMs: num(c.suggestTimeoutMs, DEFAULT_CONFIG.suggestTimeoutMs),
+    ...route
   };
 }
 function unwrapVolatile(value) {
@@ -338,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 };
@@ -487,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,
@@ -506,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,
@@ -526,6 +568,8 @@ async function snapshotForSession(deps, config, sessionId) {
     refreshIntervalMs: config.refreshIntervalMs,
     showInputPill: config.showInputPill,
     defaultDiffView: config.defaultDiffView,
+    graphStyle: config.graphStyle,
+    suggestEnabled: config.suggestEnabled,
     checkedAt: Date.now()
   };
   return { ok: true, value: snapshot };
@@ -586,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) {
@@ -611,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);
@@ -621,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);
@@ -693,6 +819,7 @@ function imageMimeFor(path) {
 
 // src/host/queries.ts
 var GRAPH_FORMAT = "--format=%H%x1f%h%x1f%P%x1f%an%x1f%aI%x1f%D%x1f%s%x1e";
+var VISIBLE_REFS = ["--branches", "--remotes", "--tags", "HEAD"];
 function isHexLike(text) {
   return /^[0-9a-fA-F]{7,40}$/.test(text.trim());
 }
@@ -726,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":
@@ -741,7 +870,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", GRAPH_FORMAT, `--max-count=${limit}`, `--skip=${skip}`];
+  const args = ["git", "log", "--topo-order", GRAPH_FORMAT, `--max-count=${limit}`, `--skip=${skip}`];
   const search = q.search?.trim() ?? "";
   const hexJump = search !== "" && isHexLike(search);
   const countArgs = ["git", "rev-list", "--count"];
@@ -754,7 +883,7 @@ async function queryHistory(deps, root, q) {
       if (!isSafeRev(q.ref)) return { ok: false, error: { code: "invalid-name", message: `unsafe ref: ${q.ref}` } };
       filters.push("--end-of-options", q.ref);
     } else {
-      filters.push("--all");
+      filters.push(...VISIBLE_REFS);
     }
     args.push(...filters);
     countArgs.push(...filters);
@@ -1082,8 +1211,13 @@ 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", "--all", "--format=%an", "--max-count=2000"], root, "authors", deps.signal);
+  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)) : [];
   return { ok: true, value: { kind: "authors", authors } };
 }
@@ -1098,6 +1232,219 @@ async function queryWorktreeStats(deps, config, sessionId) {
   return { ok: true, value: { kind: "worktree-stats", stats: snapshot.value.stats } };
 }
 
+// src/host/suggest.ts
+var SYSTEM_PROMPT = [
+  "You are an expert at writing concise, accurate git commit messages.",
+  "Given a repository\u2019s uncommitted changes, write ONE commit message for them.",
+  "The message must start with a short imperative subject line (72 chars max), optionally followed by a blank line and a brief body explaining what changed and why.",
+  "Return only the message text: no quotes, code fences, prefixes, bullet lists, or explanations.",
+  "Match the language and style of the recent commit message when one is provided; otherwise write in English.",
+  "Focus on the most important change; do not mechanically list every file."
+].join("\n");
+var UNTRACKED_FILE_CAP = 16;
+function resolveRoute(config, agentDefaultModel) {
+  if (config.suggestProvider !== void 0 && config.suggestModel !== void 0) {
+    return { provider: config.suggestProvider, model: config.suggestModel };
+  }
+  return agentDefaultModel?.currentSelection();
+}
+function withDeadline(timeoutMs, parent) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  const onAbort = () => {
+    controller.abort();
+  };
+  if (parent !== void 0) {
+    if (parent.aborted) {
+      controller.abort();
+    } else parent.addEventListener("abort", onAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    expired: () => timedOut,
+    dispose: () => {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+function truncateUtf8(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  let lo = 0;
+  let hi = text.length;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) lo = mid;
+    else hi = mid - 1;
+  }
+  return text.slice(0, lo);
+}
+function frameChanges(files, diff, recentCommitMessage) {
+  return JSON.stringify({
+    files,
+    diff,
+    recentCommitMessage: recentCommitMessage === "" ? null : recentCommitMessage
+  });
+}
+function normalizeMessage(raw) {
+  let m = raw.trim();
+  if (m.startsWith("```")) {
+    const firstNl = m.indexOf("\n");
+    if (firstNl !== -1) {
+      m = m.slice(firstNl + 1);
+      m = m.endsWith("```") ? m.slice(0, -3) : m;
+      m = m.trim();
+    }
+  }
+  return m.replace(/\n---+\s*$/, "").trim();
+}
+function finishError(reason) {
+  if (reason === void 0 || reason.kind === "stop") return void 0;
+  if (reason.kind === "max-tokens") return { ok: false, error: { code: "llm-output", message: "model output hit the token limit" } };
+  if (reason.kind === "tool-calls") return { ok: false, error: { code: "llm-output", message: "model requested a tool instead of writing a message" } };
+  const failure = "failure" in reason ? reason.failure : void 0;
+  return { ok: false, error: { code: "llm-error", message: failure?.message ?? `model stream finished abnormally (${reason.kind})` } };
+}
+async function collectDiff(deps, root, hasHead, pathArgs) {
+  const cmds = hasHead ? [["git", "diff", "HEAD", ...pathArgs]] : [["git", "diff", "--cached", ...pathArgs], ["git", "diff", ...pathArgs]];
+  const runs = await Promise.all(cmds.map((argv) => runCommand(deps.run, argv, root, "suggest-diff", deps.signal)));
+  let diff = "";
+  for (const res of runs) {
+    if ("failure" in res) return { ok: false, error: { code: "git-unavailable", message: "diff failed" } };
+    if (res.run.cancelled) return { ok: false, error: { code: "cancelled" } };
+    if (res.run.timedOut) return { ok: false, error: { code: "timeout" } };
+    if (res.run.exitCode !== 0) {
+      return { ok: false, error: { code: "git-error", message: res.run.stderr.trim() || "git diff failed" } };
+    }
+    diff += res.run.stdout;
+  }
+  return diff;
+}
+async function appendUntracked(deps, root, files, diff, budget) {
+  let text = diff;
+  let truncated = false;
+  const candidates = files.filter((c) => c.status === "untracked" && !c.isDirectory && isSafePath(c.path));
+  for (const c of candidates.slice(0, UNTRACKED_FILE_CAP)) {
+    const remaining = budget - Buffer.byteLength(text, "utf8");
+    if (remaining <= 0) {
+      truncated = true;
+      break;
+    }
+    const res = await runCommand(deps.run, ["git", "diff", "--no-index", "--", "/dev/null", c.path], root, "suggest-untracked", deps.signal);
+    if ("failure" in res || res.run.cancelled || res.run.timedOut) continue;
+    const chunk = res.run.stdout;
+    if (chunk === "") continue;
+    if (Buffer.byteLength(chunk, "utf8") > remaining) {
+      text += truncateUtf8(chunk, remaining) + "\n... [diff truncated]";
+      truncated = true;
+      break;
+    }
+    text += chunk;
+  }
+  return { diff: text, truncated };
+}
+async function runSuggest(deps, config, request) {
+  if (!config.suggestEnabled) {
+    return { ok: false, error: { code: "suggest-disabled", message: "AI suggest is turned off in the plugin config" } };
+  }
+  const workspace = await resolveWorkspace(deps, request.sessionId);
+  if (!workspace.ok) return { ok: false, error: mapWorkspaceFailure(workspace.failure) };
+  const root = workspace.root;
+  const paths = request.paths ?? [];
+  for (const path of paths) {
+    if (!isSafePath(path)) return { ok: false, error: { code: "invalid-path", message: path } };
+  }
+  const pathArgs = paths.length > 0 ? ["--", ...paths] : [];
+  const pathSet = new Set(paths);
+  const [statusRes, headRes, lastRes] = await Promise.all([
+    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z"], root, "suggest-status", deps.signal),
+    runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "suggest-head", deps.signal),
+    runCommand(deps.run, ["git", "log", "-1", "--format=%B"], root, "suggest-last", deps.signal)
+  ]);
+  if ("failure" in statusRes) return { ok: false, error: { code: "git-unavailable", message: "status failed" } };
+  if (statusRes.run.cancelled) return { ok: false, error: { code: "cancelled" } };
+  if (statusRes.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (statusRes.run.exitCode !== 0) {
+    return { ok: false, error: { code: "git-error", message: statusRes.run.stderr.trim() || "git status failed" } };
+  }
+  const hasHead = "run" in headRes && headRes.run.exitCode === 0;
+  const recentCommitMessage = "run" in lastRes && lastRes.run.exitCode === 0 ? lastRes.run.stdout.replace(/\n+$/, "") : "";
+  const all = statusRes.run.stdoutLossy ? [] : parseStatus(statusRes.run.stdout);
+  const files = pathSet.size > 0 ? all.filter((c) => pathSet.has(c.path)) : all;
+  const collected = await collectDiff(deps, root, hasHead, pathArgs);
+  if (typeof collected !== "string") return collected;
+  if (files.length === 0 && collected.trim() === "") {
+    return { ok: false, error: { code: "empty-diff", message: "no uncommitted changes to summarize" } };
+  }
+  let diff = collected;
+  let truncated = false;
+  if (Buffer.byteLength(diff, "utf8") > config.suggestMaxBytes) {
+    diff = truncateUtf8(diff, config.suggestMaxBytes) + "\n... [diff truncated]";
+    truncated = true;
+  }
+  const untracked = await appendUntracked(deps, root, files, diff, config.suggestMaxBytes);
+  diff = untracked.diff;
+  truncated = truncated || untracked.truncated;
+  const llm = deps.getLlm?.();
+  const route = resolveRoute(config, deps.getAgentDefaultModel?.());
+  if (llm === void 0 || route === void 0) {
+    return { ok: false, error: { code: "llm-unavailable", message: "no model service or route is configured" } };
+  }
+  const frame = frameChanges(
+    files.map((c) => ({ path: c.path, status: c.status })),
+    diff,
+    recentCommitMessage
+  );
+  const deadline = withDeadline(config.suggestTimeoutMs, deps.signal);
+  const options = {
+    provider: route.provider,
+    model: route.model,
+    system: SYSTEM_PROMPT,
+    messages: [{
+      id: "git-panel-suggest",
+      role: "user",
+      content: [{ type: "text", text: frame }],
+      source: { kind: "user" }
+    }],
+    maxTokens: config.suggestMaxOutputTokens,
+    temperature: 0.3,
+    signal: deadline.signal
+  };
+  let output = "";
+  let finish;
+  try {
+    for await (const chunk of llm.stream(options)) {
+      if (chunk.type === "text-delta") output += chunk.text;
+      else if (chunk.type === "finish") finish = chunk.reason;
+    }
+  } catch (error) {
+    if (deps.signal?.aborted === true) return { ok: false, error: { code: "cancelled" } };
+    if (deadline.expired()) return { ok: false, error: { code: "llm-error", message: `model call timed out after ${config.suggestTimeoutMs}ms` } };
+    return { ok: false, error: { code: "llm-error", message: error instanceof Error ? error.message : "model stream failed" } };
+  } finally {
+    deadline.dispose();
+  }
+  if (deps.signal?.aborted === true) return { ok: false, error: { code: "cancelled" } };
+  if (deadline.expired()) return { ok: false, error: { code: "llm-error", message: `model call timed out after ${config.suggestTimeoutMs}ms` } };
+  const terminal = finishError(finish);
+  if (terminal !== void 0) return terminal;
+  const message = normalizeMessage(output);
+  if (message === "") return { ok: false, error: { code: "llm-output", message: "model produced no message text" } };
+  return {
+    ok: true,
+    value: {
+      message,
+      provider: route.provider,
+      model: route.model,
+      ...truncated ? { truncated: true } : {}
+    }
+  };
+}
+
 // src/host/version.ts
 import { readFile as readFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join4 } from "node:path";
@@ -1225,8 +1572,8 @@ async function checkLatestVersion(options = {}) {
 }
 
 // src/host/index.ts
-var _version_dec, _query_dec, _run_dec, _snapshot_dec, _a, _init;
-var GitPanelService = class extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _run_dec = [Remote("run")], _query_dec = [Remote("query")], _version_dec = [Remote("version")], _a) {
+var _version_dec, _suggest_dec, _query_dec, _run_dec, _snapshot_dec, _a, _init;
+var GitPanelService = class extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _run_dec = [Remote("run")], _query_dec = [Remote("query")], _suggest_dec = [Remote("suggest")], _version_dec = [Remote("version")], _a) {
   constructor(ctx, config) {
     super(ctx, "gitPanel");
     __runInitializers(_init, 5, this);
@@ -1272,7 +1619,13 @@ var GitPanelService = class extends (_a = TypertRemoteService, _snapshot_dec = [
         }
       },
       rootCache,
-      rootNegCache
+      rootNegCache,
+      // Optional model services, resolved per request so a provider fiber that
+      // activates late or restarts is picked up — absent in deployments without
+      // a model backend, where the suggest endpoint reports `llm-unavailable`
+      // rather than failing activation (kept out of `static inject` on purpose).
+      getLlm: () => get("llm"),
+      getAgentDefaultModel: () => get("agentDefaultModel")
     };
   }
   async snapshot(request, signal) {
@@ -1284,6 +1637,9 @@ var GitPanelService = class extends (_a = TypertRemoteService, _snapshot_dec = [
   async query(request, signal) {
     return runQuery(this.withSignal(signal), this.liveConfig(), request);
   }
+  async suggest(request, signal) {
+    return runSuggest(this.withSignal(signal), this.liveConfig(), request);
+  }
   async version(request) {
     try {
       return request.check === true ? await checkLatestVersion() : await readVersionInfo();
@@ -1305,6 +1661,7 @@ _init = __decoratorStart(_a);
 __decorateElement(_init, 1, "snapshot", _snapshot_dec, GitPanelService);
 __decorateElement(_init, 1, "run", _run_dec, GitPanelService);
 __decorateElement(_init, 1, "query", _query_dec, GitPanelService);
+__decorateElement(_init, 1, "suggest", _suggest_dec, GitPanelService);
 __decorateElement(_init, 1, "version", _version_dec, GitPanelService);
 __decoratorMetadata(_init, GitPanelService);
 __publicField(GitPanelService, "inject", ["subprocess", "sessions", "sessionPersistence"]);
@@ -1319,13 +1676,19 @@ __publicField(GitPanelService, "Config", Schema.object({
   defaultDiffView: Schema.union([
     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")
+  ]).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;
 export {
   DEFAULT_CONFIG,
   GitPanelService,
   checkLatestVersion,
+  classifyActionFailure,
   compareVersions,
   createGitRunner,
   index_default as default,
@@ -1335,12 +1698,15 @@ export {
   parseGraphLog,
   parseNameStatus,
   parseRepository,
+  parseStashList,
   parseStatus,
+  parseTags,
   planAction,
   readVersionInfo,
   resolveWorkspace,
   runAction,
   runQuery,
+  runSuggest,
   snapshotForSession,
   sumNumstat
 };

package/lib/host/llm-face.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Structural faces of the host `llm` and `agentDefaultModel` services.
+ *
+ * The `llm` face is typed against the real `@deepseek-ai/dsh-llm` contract
+ * via type-only imports — the build externalizes the whole `@deepseek-ai/*`
+ * scope, so this adds no runtime dependency, and any wire-shape drift (e.g.
+ * the finish chunk's `reason` envelope) breaks typecheck instead of silently
+ * passing. Both services are shipped by `@deepseek-ai/dsh-base`; they are
+ * resolved per request (never frozen at construction) and absence degrades
+ * the suggest endpoint to a typed `llm-unavailable` failure instead of
+ * breaking plugin activation (kept out of `static inject` on purpose).
+ */
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+/** Minimal face of the host `llm` service (`ctx.llm`). */
+export interface LlmFace {
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    listProviders?(): readonly {
+        readonly id: string;
+    }[];
+}
+/** Minimal face of the host `agentDefaultModel` service. */
+export interface AgentDefaultModelFace {
+    currentSelection(): {
+        readonly provider: string;
+        readonly model: string;
+    } | undefined;
+}

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/suggest.d.ts

@@ -0,0 +1,4 @@
+import type { GitPanelConfig, SnapshotDeps } from './core.ts';
+import type { GitSuggestRequest, GitSuggestResult } from './types.ts';
+/** Generate a commit message for the session's uncommitted changes. */
+export declare function runSuggest(deps: SnapshotDeps, config: GitPanelConfig, request: GitSuggestRequest): Promise<GitSuggestResult>;