@xbzbing/dsh-git-panel 1.2.0 → 1.3.0

package/lib/host/core.d.ts

@@ -1,4 +1,5 @@
 import type { GitRunner } from './git.ts';
+import type { AgentDefaultModelFace, LlmFace } from './llm-face.ts';
 import type { DiffViewMode, GitChange, GitErrorCode, GitSnapshotResult } from './types.ts';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
@@ -10,6 +11,15 @@ export interface GitPanelConfig {
     readonly showInputPill: boolean;
     /** Default diff layout the views open with (user can switch per-diff). */
     readonly defaultDiffView: DiffViewMode;
+    /** 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. */
+    readonly suggestMaxBytes: number;
+    readonly suggestMaxOutputTokens: number;
+    readonly suggestTimeoutMs: number;
+    /** Optional provider/model route override; absent → the agent default. */
+    readonly suggestProvider?: string;
+    readonly suggestModel?: string;
 }
 export declare const DEFAULT_CONFIG: GitPanelConfig;
 export declare function normalizeConfig(raw: unknown): GitPanelConfig;
@@ -61,6 +71,15 @@ export interface SnapshotDeps {
      * cwd is picked up soon after.
      */
     readonly rootNegCache?: Map<string, number>;
+    /**
+     * Optional per-request resolvers for the host `llm` and `agentDefaultModel`
+     * services (see llm-face.ts). Resolved on every suggest call — never frozen
+     * at construction — so a provider fiber that activates late or restarts is
+     * picked up. Absent in deployments without a model backend; the suggest
+     * endpoint then reports `llm-unavailable` instead of failing activation.
+     */
+    readonly getLlm?: () => LlmFace | undefined;
+    readonly getAgentDefaultModel?: () => AgentDefaultModelFace | undefined;
 }
 export type WorkspaceResolution = {
     readonly ok: true;

package/lib/host/index.d.ts

@@ -9,13 +9,14 @@
 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, 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, } from './types.ts';
+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 { createGitRunner } from './git.ts';
 export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, sumNumstat } from './parser.ts';
 export { isSafePath, planAction, runAction } from './actions.ts';
 export { runQuery } from './queries.ts';
+export { runSuggest } from './suggest.ts';
 export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository } from './version.ts';
 export declare class GitPanelService extends TypertRemoteService {
     static inject: string[];
@@ -28,9 +29,11 @@ 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">;
+        suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
     }>>, Schemastery.ObjectT<NoInfer<{
         showInputPill: Schema<boolean, boolean, "volatile-defined">;
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
+        suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
     }>>, "plain">;
     private readonly deps;
     private config;
@@ -40,6 +43,7 @@ export declare class GitPanelService extends TypertRemoteService {
     snapshot(request: GitSnapshotRequest, signal?: AbortSignal): Promise<GitSnapshotResult>;
     run(request: GitActionRequest, signal?: AbortSignal): Promise<GitActionResult>;
     query(request: GitQueryRequest, signal?: AbortSignal): Promise<GitQueryResponse>;
+    suggest(request: GitSuggestRequest, signal?: AbortSignal): Promise<GitSuggestResult>;
     version(request: GitVersionRequest): Promise<GitVersionInfo>;
     /** Re-read config so a live-edited volatile field (showInputPill) is current. */
     private liveConfig;

package/lib/host/index.js

@@ -317,18 +317,30 @@ var DEFAULT_CONFIG = {
   maxChanges: 1e3,
   refreshIntervalMs: 3e4,
   showInputPill: true,
-  defaultDiffView: "unified"
+  defaultDiffView: "unified",
+  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),
+    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) {
@@ -526,6 +538,7 @@ async function snapshotForSession(deps, config, sessionId) {
     refreshIntervalMs: config.refreshIntervalMs,
     showInputPill: config.showInputPill,
     defaultDiffView: config.defaultDiffView,
+    suggestEnabled: config.suggestEnabled,
     checkedAt: Date.now()
   };
   return { ok: true, value: snapshot };
@@ -693,6 +706,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());
 }
@@ -741,7 +755,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 +768,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);
@@ -1083,7 +1097,7 @@ async function queryTags(deps, root) {
   return { ok: true, value: { kind: "tags", tags } };
 }
 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 +1112,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 +1452,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 +1499,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 +1517,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 +1541,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,7 +1556,8 @@ __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"),
+  suggestEnabled: Schema.boolean().default(true).volatile().description("\u63D0\u4EA4\u6846\u663E\u793A AI \u751F\u6210\u6309\u94AE")
 }));
 var index_default = GitPanelService;
 export {
@@ -1341,6 +1579,7 @@ export {
   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/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>;

package/lib/host/types.d.ts

@@ -62,6 +62,8 @@ export interface GitSnapshot {
     readonly showInputPill: boolean;
     /** Default diff layout the views open with (user preference). */
     readonly defaultDiffView: DiffViewMode;
+    /** Whether the commit box shows the AI-suggest button (user preference). */
+    readonly suggestEnabled: boolean;
     /** Epoch millis of the snapshot. */
     readonly checkedAt: number;
 }
@@ -121,7 +123,7 @@ export type GitAction = {
 } | {
     readonly kind: 'fetch';
 };
-export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block';
+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';
 export type GitActionResult = {
     readonly ok: true;
     readonly snapshot: GitSnapshot;
@@ -325,6 +327,34 @@ export interface GitQueryRequest {
     readonly sessionId: string;
     readonly query: GitQuery;
 }
+/**
+ * Wire request for the suggest endpoint: ask the configured model to write a
+ * commit message from the repository's uncommitted changes. `paths` restricts
+ * the diff to the user's selection (bare repo-relative paths); absent means
+ * all uncommitted changes.
+ */
+export interface GitSuggestRequest {
+    readonly sessionId: string;
+    readonly paths?: readonly string[];
+}
+export type GitSuggestResult = {
+    readonly ok: true;
+    readonly value: {
+        /** The generated message, ready for the user to edit and commit. */
+        readonly message: string;
+        /** Actual provider/model route used (display only). */
+        readonly provider?: string;
+        readonly model?: string;
+        /** The diff exceeded the model input cap and was truncated. */
+        readonly truncated?: boolean;
+    };
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: GitErrorCode;
+        readonly message?: string;
+    };
+};
 /**
  * Extensions the image-diff query serves, mapped to MIME types. Part of the
  * query's contract, so both halves gate on this one list and cannot drift.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbzbing/dsh-git-panel",
-  "version": "1.2.0",
+  "version": "1.3.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",
@@ -42,7 +42,7 @@
     "build": "node build.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:unit": "node build.mjs && node --test --test-force-exit test/unit/*.test.mjs",
-    "test:e2e": "node build.mjs && node test/e2e/setup.mjs && node test/e2e/run.mjs && node test/e2e/run2.mjs",
+    "test:e2e": "node build.mjs && node test/e2e/setup.mjs && node test/e2e/run.mjs && node test/e2e/run2.mjs && node test/e2e/run3.mjs",
     "test": "npm run test:unit && npm run test:e2e",
     "check": "npm run typecheck && npm run test && git diff --exit-code -- lib/"
   },