@xbzbing/dsh-git-panel 1.6.1 → 1.7.0

package/lib/host/actions.js

@@ -36,10 +36,10 @@ function planAction(action, unborn) {
     }
     case "branch-checkout": {
       if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe branch name: ${action.name}` };
-      let checkout = ["git", "checkout", "--end-of-options", action.name];
+      let checkout = ["git", "checkout", action.name];
       if (action.createFrom !== void 0) {
         if (!isSafeBranchName(action.createFrom)) return { error: "invalid-name", message: `unsafe tracking ref: ${action.createFrom}` };
-        checkout = ["git", "checkout", "-b", action.name, "--track", "--end-of-options", action.createFrom];
+        checkout = ["git", "checkout", "-b", action.name, "--track", action.createFrom];
       }
       const msg = action.stashMessage?.trim() ?? "";
       return { argv: msg === "" ? [checkout] : [["git", "stash", "push", "-u", "-m", msg], checkout] };
@@ -85,7 +85,7 @@ function planAction(action, unborn) {
       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]] };
+      return { argv: [["git", "reset", `--${action.mode}`, action.commit]] };
     }
   }
 }
@@ -211,6 +211,26 @@ async function runAction(deps, config, request) {
   }
   return { ok: true, snapshot: snapshot.value, output: lastOutput.trim() };
 }
+async function looksLikeRepository(deps, target) {
+  try {
+    await deps.fs.stat(join(target, ".git"));
+    return true;
+  } catch {
+  }
+  const head = await pathKind(deps, join(target, "HEAD"));
+  const refs = await pathKind(deps, join(target, "refs"));
+  const objects = await pathKind(deps, join(target, "objects"));
+  if (!head.present || head.directory === true) return false;
+  const directoryLike = (kind) => kind.present && kind.directory !== false;
+  return directoryLike(refs) && directoryLike(objects);
+}
+async function pathKind(deps, path) {
+  try {
+    return { present: true, directory: (await deps.fs.stat(path)).isDirectory() };
+  } catch {
+    return { present: await deps.fs.symlinkTarget(path) !== null, directory: null };
+  }
+}
 async function discardUntracked(deps, config, root, sessionId, paths) {
   const snap = await snapshotForSession(deps, config, sessionId);
   if (!snap.ok) return null;
@@ -218,12 +238,20 @@ async function discardUntracked(deps, config, root, sessionId, paths) {
   const untracked = paths.filter((p) => untrackedSet.has(p));
   if (untracked.length === 0) return null;
   const tracked = paths.filter((p) => !untrackedSet.has(p));
+  const directoryEntries = new Set(snap.value.changes.filter((c) => c.isDirectory === true).map((c) => c.path));
+  for (const path of untracked) {
+    if (!directoryEntries.has(path)) continue;
+    if (!await looksLikeRepository(deps, join(root, path))) continue;
+    return { ok: false, result: { ok: false, error: { code: "nested-repo", message: `repository directory: ${path}` } } };
+  }
   let rootReal;
   try {
     rootReal = await deps.fs.realpath(root);
   } catch {
     return { ok: false, result: { ok: false, error: { code: "git-error", message: "repository root unavailable" } } };
   }
+  const failures = [];
+  let removedCount = 0;
   for (const path of untracked) {
     if (!isSafePath(path)) return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `unsafe path: ${path}` } } };
     const target = join(root, path);
@@ -236,8 +264,24 @@ async function discardUntracked(deps, config, root, sessionId, paths) {
     if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep)) {
       return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `path escapes repository: ${path}` } } };
     }
-    await deps.fs.remove(target).catch(() => {
-    });
+    if (await looksLikeRepository(deps, target)) {
+      const code = removedCount === 0 ? "nested-repo" : "nested-repo-partial";
+      const detail = removedCount === 0 ? "" : `; ${removedCount} path(s) already removed`;
+      return { ok: false, result: { ok: false, error: { code, message: `repository directory: ${path}${detail}` } } };
+    }
+    try {
+      await deps.fs.remove(target);
+      removedCount += 1;
+    } catch (e) {
+      failures.push(`${path}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  if (failures.length > 0) {
+    const skipped = tracked.length > 0 ? `; ${tracked.length} tracked path(s) not restored` : "";
+    return {
+      ok: false,
+      result: { ok: false, error: { code: "git-error", message: `could not discard ${failures.length} path(s): ${failures.join("; ")}${skipped}` } }
+    };
   }
   return { ok: true, remainingTracked: tracked };
 }

package/lib/host/core.d.ts

@@ -1,6 +1,6 @@
 import type { GitRunner } from './git.js';
 import type { AgentDefaultModelFace, LlmFace } from './llm-face.js';
-import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult } from './types.js';
+import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult, SuggestLanguage } from './types.js';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
     /** Per-command stdout cap; also the per-side image-diff payload cap. */
@@ -15,6 +15,8 @@ export interface GitPanelConfig {
     readonly graphStyle: GraphStyle;
     /** Whether the "AI suggest" button shows in the commit box. */
     readonly suggestEnabled: boolean;
+    /** Language the generated message is written in; `auto` follows repo history. */
+    readonly suggestLanguage: SuggestLanguage;
     /** Max diff bytes sent to the model; beyond this the diff is truncated. Range 16–512 KiB. */
     readonly suggestMaxBytes: number;
     /** Model output token budget (reasoning tokens count against it on thinking models). Range 256–16384. */
@@ -31,6 +33,12 @@ export declare function normalizeConfig(raw: unknown): GitPanelConfig;
 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 the commit-message language field, unwrapping a schemastery volatile
+ * ref. An unknown string (a hand-edited profile, or a value from a newer
+ * version) falls back to the default rather than reaching the prompt.
+ */
+export declare function readSuggestLanguage(value: unknown, fallback: SuggestLanguage): SuggestLanguage;
 /**
  * Read a boolean config field, unwrapping a schemastery volatile reference
  * (`{ get() }`) so a live-editable toggle reflects the latest value. Absent or
@@ -42,9 +50,11 @@ export interface SnapshotDeps {
     readonly run: GitRunner;
     readonly fs: {
         realpath(path: string): Promise<string>;
+        /** `isDirectory` reports the *resolved* type (symlinks are followed). */
         stat(path: string): Promise<{
             mtimeMs: number;
             size: number;
+            isDirectory(): boolean;
         }>;
         /** Raw bytes (no encoding) — image sides for the image-diff query. */
         readFile(path: string): Promise<Buffer>;
@@ -59,7 +69,7 @@ export interface SnapshotDeps {
             name: string;
             isDirectory: boolean;
         }>>;
-        /** Best-effort unlink (force) — temp-blob cleanup. */
+        /** Recursive remove (force) — untracked discards pass whole directories; temp-blob cleanup passes files. */
         remove(path: string): Promise<void>;
     };
     readonly sessions: {

package/lib/host/core.js

@@ -1,8 +1,9 @@
 import { dirname, join } from "node:path";
 import { commitFromFields, parseStatus, sumNumstat } from "./parser.js";
 import { parseRemote } from "./remote.js";
+import { snapshotFingerprint } from "./snapshot-fingerprint.js";
 import { isSafePath } from "./validate.js";
-import { SUGGEST_LIMITS } from "./types.js";
+import { SUGGEST_LANGUAGE_DEFAULT, SUGGEST_LANGUAGES, SUGGEST_LIMITS } from "./types.js";
 const DEFAULT_CONFIG = {
   timeoutMs: 8e3,
   maxBytes: 4 * 1024 * 1024,
@@ -12,6 +13,7 @@ const DEFAULT_CONFIG = {
   defaultDiffView: "unified",
   graphStyle: "parallel",
   suggestEnabled: true,
+  suggestLanguage: SUGGEST_LANGUAGE_DEFAULT,
   suggestMaxBytes: SUGGEST_LIMITS.maxBytes.default,
   suggestMaxOutputTokens: SUGGEST_LIMITS.maxOutputTokens.default,
   suggestTimeoutMs: SUGGEST_LIMITS.timeoutMs.default
@@ -35,6 +37,7 @@ function normalizeConfig(raw) {
     defaultDiffView: readDiffView(c.defaultDiffView, DEFAULT_CONFIG.defaultDiffView),
     graphStyle: readGraphStyle(c.graphStyle, DEFAULT_CONFIG.graphStyle),
     suggestEnabled: readBool(c.suggestEnabled, DEFAULT_CONFIG.suggestEnabled),
+    suggestLanguage: readSuggestLanguage(c.suggestLanguage, DEFAULT_CONFIG.suggestLanguage),
     suggestMaxBytes: clampLimit(c.suggestMaxBytes, SUGGEST_LIMITS.maxBytes),
     suggestMaxOutputTokens: clampLimit(c.suggestMaxOutputTokens, SUGGEST_LIMITS.maxOutputTokens),
     suggestTimeoutMs: clampLimit(c.suggestTimeoutMs, SUGGEST_LIMITS.timeoutMs),
@@ -52,6 +55,10 @@ function readGraphStyle(value, fallback) {
   const raw = unwrapVolatile(value);
   return raw === "parallel" || raw === "compact" ? raw : fallback;
 }
+function readSuggestLanguage(value, fallback) {
+  const raw = unwrapVolatile(value);
+  return typeof raw === "string" && SUGGEST_LANGUAGES.includes(raw) ? raw : fallback;
+}
 function readBool(value, fallback) {
   const raw = unwrapVolatile(value);
   return typeof raw === "boolean" ? raw : fallback;
@@ -74,6 +81,7 @@ function parsePrimaryRemote(stdout) {
   return parseRemote(name, fetchUrls.get(name));
 }
 const STATS_FANOUT_LIMIT = 200;
+const UNTRACKED_NUMSTAT_LIMIT = 32;
 async function resolveBrowseRoot(deps, sessionId) {
   const ws = await resolveWorkspace(deps, sessionId);
   if (ws.ok) return { ok: true, root: ws.root, isGitRepo: true };
@@ -180,7 +188,7 @@ async function snapshotForSession(deps, config, sessionId) {
   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", "status", "--porcelain=v1", "-z", "--untracked-files=all"], 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),
@@ -198,7 +206,20 @@ async function snapshotForSession(deps, config, sessionId) {
     allChanges = parseStatus(statusRes.run.stdout);
     statusLossy = statusRes.run.stdoutLossy;
   }
+  let untrackedCollapsed = false;
+  const untrackedEntries = allChanges.filter((c) => c.status === "untracked");
+  const collapseCandidate = untrackedEntries.some((c) => c.path.includes("/"));
+  if (statusLossy || untrackedEntries.length > config.maxChanges && collapseCandidate) {
+    const collapsed = await runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--untracked-files=normal"], root, "status-collapsed", deps.signal);
+    if ("run" in collapsed && !collapsed.run.timedOut && collapsed.run.exitCode === 0) {
+      const list = parseStatus(collapsed.run.stdout);
+      untrackedCollapsed = list.some((c) => c.status === "untracked" && c.isDirectory);
+      allChanges = list;
+      statusLossy = collapsed.run.stdoutLossy;
+    }
+  }
   const truncated = allChanges.length > config.maxChanges || statusLossy;
+  const truncatedReason = statusLossy ? "lossy" : allChanges.length > config.maxChanges ? "cap" : void 0;
   const changes = allChanges.length > config.maxChanges ? allChanges.slice(0, config.maxChanges) : allChanges;
   let staged = 0;
   let modified = 0;
@@ -224,9 +245,10 @@ 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;
+  const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
+  const untrackedCountable = untrackedPaths.length <= UNTRACKED_NUMSTAT_LIMIT;
   let untrackedInsertions = 0;
-  if (statsDetailed) {
-    const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
+  if (untrackedCountable) {
     const safeUntracked = untrackedPaths.filter(isSafePath);
     if (safeUntracked.length > 0) {
       const perFile = await Promise.all(
@@ -246,7 +268,9 @@ async function snapshotForSession(deps, config, sessionId) {
     deletions: wt.deletions + stg.deletions,
     lastChangeAt,
     headCommittedAt: lastCommit?.dateIso ?? null,
-    partial: !statsDetailed
+    // Collapsed untracked directories have no per-file line counts and count as
+    // one entry each, so the stats are an explicit lower bound there too.
+    partial: !statsDetailed || !untrackedCountable || untrackedCollapsed
   };
   const snapshot = {
     root,
@@ -265,6 +289,8 @@ async function snapshotForSession(deps, config, sessionId) {
     changes,
     stats,
     truncated,
+    ...truncatedReason !== void 0 ? { truncatedReason } : {},
+    ...untrackedCollapsed ? { untrackedCollapsed: true } : {},
     refreshIntervalMs: config.refreshIntervalMs,
     showInputPill: config.showInputPill,
     defaultDiffView: config.defaultDiffView,
@@ -272,7 +298,7 @@ async function snapshotForSession(deps, config, sessionId) {
     suggestEnabled: config.suggestEnabled,
     checkedAt: Date.now()
   };
-  return { ok: true, value: snapshot };
+  return { ok: true, value: { ...snapshot, stateFingerprint: snapshotFingerprint(snapshot) } };
 }
 async function maxChangeMtime(deps, root, changes, cap = 200) {
   let max = null;
@@ -298,6 +324,7 @@ export {
   readBool,
   readDiffView,
   readGraphStyle,
+  readSuggestLanguage,
   resolveBrowseRoot,
   resolveWorkspace,
   runCommand,

package/lib/host/fs-deps.d.ts

@@ -0,0 +1,2 @@
+import type { SnapshotDeps } from './core.js';
+export declare function createFsDeps(): SnapshotDeps['fs'];

package/lib/host/fs-deps.js

@@ -0,0 +1,25 @@
+import { lstat, readdir, readFile, readlink, realpath, rm, stat } from "node:fs/promises";
+function createFsDeps() {
+  return {
+    realpath,
+    stat: async (p) => stat(p),
+    readFile,
+    symlinkTarget: async (p) => {
+      try {
+        return (await lstat(p)).isSymbolicLink() ? await readlink(p) : null;
+      } catch {
+        return null;
+      }
+    },
+    readdir: async (p) => (await readdir(p, { withFileTypes: true })).map((e) => ({ name: e.name, isDirectory: e.isDirectory() })),
+    // Untracked entries include whole directories (porcelain collapses `?? dir/`
+    // into one entry) and a plain `rm` fails EISDIR on them; the caller
+    // realpath-contains every target inside the repo root before removing.
+    remove: async (p) => {
+      await rm(p, { recursive: true, force: true });
+    }
+  };
+}
+export {
+  createFsDeps
+};

package/lib/host/history-topology.d.ts

@@ -0,0 +1,25 @@
+import type { GitRunner } from './git.js';
+import type { GitGraphNode } from './types.js';
+/** Hard cap on the auxiliary walk: deep enough for a filtered page, bounded
+ * against a pathological DAG. */
+export declare const HISTORY_TOPOLOGY_LIMIT = 10000;
+/** Hard cap on the walk's stdout. The node cap alone does not bound a line: an
+ * octopus merge can list thousands of parents on one commit. Over budget the
+ * result is conservatively `[]` (an incomplete graph), never a partial parse. */
+export declare const HISTORY_TOPOLOGY_MAX_BYTES: number;
+/**
+ * Parse `git rev-list --parents` output: one `<hash> [<parent>…]` per line.
+ * Returns null whenever the capture cannot be trusted as a complete ancestry —
+ * a missing trailing newline (git always terminates each line, so a cut read can
+ * land exactly on a 40-char hash and otherwise read as a parentless root), any
+ * malformed line, or output past the node/byte budget. `[]` is a genuinely empty
+ * walk, never a degraded one.
+ */
+export declare function parseGraphNodes(stdout: string): GitGraphNode[] | null;
+/**
+ * Walk the page's raw ancestry. Seeds must already be full hashes; anything
+ * else is dropped rather than passed as argv. Resolves `[]` on every failure
+ * path (spawn throw, cancel, timeout, non-zero exit, lossy output, malformed
+ * output) so a filtered history page is never lost to this auxiliary command.
+ */
+export declare function walkHistoryTopology(runner: GitRunner, root: string, seeds: readonly string[], signal?: AbortSignal): Promise<GitGraphNode[]>;

package/lib/host/history-topology.js

@@ -0,0 +1,55 @@
+import { runCommand } from "./core.js";
+const HISTORY_TOPOLOGY_LIMIT = 1e4;
+const HISTORY_TOPOLOGY_MAX_BYTES = 2 * 1024 * 1024;
+const FULL_HASH = /^(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})$/;
+function parseGraphNodes(stdout) {
+  if (stdout === "") return [];
+  if (Buffer.byteLength(stdout, "utf8") > HISTORY_TOPOLOGY_MAX_BYTES) return null;
+  if (!stdout.endsWith("\n")) return null;
+  const lines = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (line !== "") lines.push(line);
+  }
+  if (lines.length > HISTORY_TOPOLOGY_LIMIT) return null;
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const fields = line.split(" ");
+    const hash = fields[0];
+    if (hash === void 0 || !FULL_HASH.test(hash)) return null;
+    const parents = [];
+    for (const parent of fields.slice(1)) {
+      if (!FULL_HASH.test(parent)) return null;
+      parents.push(parent);
+    }
+    if (seen.has(hash)) continue;
+    seen.add(hash);
+    nodes.push({ hash, parents });
+  }
+  return nodes;
+}
+async function walkHistoryTopology(runner, root, seeds, signal) {
+  const safeSeeds = seeds.filter((seed) => FULL_HASH.test(seed));
+  if (safeSeeds.length === 0) return [];
+  const argv = [
+    "git",
+    "rev-list",
+    "--parents",
+    `--max-count=${HISTORY_TOPOLOGY_LIMIT}`,
+    "--end-of-options",
+    ...safeSeeds
+  ];
+  const res = await runCommand(runner, argv, root, "history-topology", signal);
+  if (!("run" in res)) return [];
+  const { run } = res;
+  if (run.cancelled || run.timedOut || run.exitCode !== 0 || run.stdoutLossy) return [];
+  if (Buffer.byteLength(run.stdout, "utf8") > HISTORY_TOPOLOGY_MAX_BYTES) return [];
+  return parseGraphNodes(run.stdout) ?? [];
+}
+export {
+  HISTORY_TOPOLOGY_LIMIT,
+  HISTORY_TOPOLOGY_MAX_BYTES,
+  parseGraphNodes,
+  walkHistoryTopology
+};

package/lib/host/index.d.ts

@@ -10,14 +10,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, GitSuggestRequest, GitSuggestResult, GitVersionInfo, GitVersionRequest } from './types.js';
-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.js';
-export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace, parsePrimaryRemote } from './core.js';
+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, SuggestLanguage, ResolvedLanguage, } from './types.js';
+export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace, parsePrimaryRemote, readSuggestLanguage } from './core.js';
 export { createGitRunner } from './git.js';
 export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from './parser.js';
 export { parseRemote, classifyHost } from './remote.js';
 export { isSafePath, planAction, runAction, classifyActionFailure } from './actions.js';
 export { runQuery } from './queries.js';
-export { runSuggest } from './suggest.js';
+export { runSuggest, resolveSuggestLanguage, parseStyleHistory, isCjkText, compactLongLines, LONG_LINE_MAX_CHARS } from './suggest.js';
 export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository } from './version.js';
 export declare class GitPanelService extends TypertRemoteService {
     static inject: string[];
@@ -32,6 +32,7 @@ export declare class GitPanelService extends TypertRemoteService {
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
         graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
+        suggestLanguage: Schema<"auto" | "zh" | "en", "auto" | "zh" | "en", "volatile-defined">;
         suggestMaxBytes: Schema<number, number, "volatile-defined">;
         suggestMaxOutputTokens: Schema<number, number, "volatile-defined">;
         suggestTimeoutMs: Schema<number, number, "volatile-defined">;
@@ -40,6 +41,7 @@ export declare class GitPanelService extends TypertRemoteService {
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
         graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
+        suggestLanguage: Schema<"auto" | "zh" | "en", "auto" | "zh" | "en", "volatile-defined">;
         suggestMaxBytes: Schema<number, number, "volatile-defined">;
         suggestMaxOutputTokens: Schema<number, number, "volatile-defined">;
         suggestTimeoutMs: Schema<number, number, "volatile-defined">;

package/lib/host/index.js

@@ -49,20 +49,20 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _version_dec, _suggest_dec, _query_dec, _run_dec, _snapshot_dec, _a, _init;
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import Schema from "@deepseek-ai/schemastery";
-import { lstat, readFile, readdir, readlink, realpath, rm, stat } from "node:fs/promises";
 import { createGitRunner } from "./git.js";
+import { createFsDeps } from "./fs-deps.js";
 import { normalizeConfig, snapshotForSession, DEFAULT_CONFIG } from "./core.js";
 import { runAction } from "./actions.js";
 import { runQuery } from "./queries.js";
 import { runSuggest } from "./suggest.js";
 import { checkLatestVersion, readVersionInfo } from "./version.js";
-import { normalizeConfig as normalizeConfig2, DEFAULT_CONFIG as DEFAULT_CONFIG2, snapshotForSession as snapshotForSession2, resolveWorkspace, parsePrimaryRemote } from "./core.js";
+import { normalizeConfig as normalizeConfig2, DEFAULT_CONFIG as DEFAULT_CONFIG2, snapshotForSession as snapshotForSession2, resolveWorkspace, parsePrimaryRemote, readSuggestLanguage } from "./core.js";
 import { createGitRunner as createGitRunner2 } from "./git.js";
 import { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from "./parser.js";
 import { parseRemote, classifyHost } from "./remote.js";
 import { isSafePath, planAction, runAction as runAction2, classifyActionFailure } from "./actions.js";
 import { runQuery as runQuery2 } from "./queries.js";
-import { runSuggest as runSuggest2 } from "./suggest.js";
+import { runSuggest as runSuggest2, resolveSuggestLanguage, parseStyleHistory, isCjkText, compactLongLines, LONG_LINE_MAX_CHARS } from "./suggest.js";
 import { readVersionInfo as readVersionInfo2, checkLatestVersion as checkLatestVersion2, compareVersions, parseRepository } from "./version.js";
 class GitPanelService 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) {
@@ -79,22 +79,7 @@ class GitPanelService extends (_a = TypertRemoteService, _snapshot_dec = [Remote
     const rootCache = /* @__PURE__ */ new Map();
     const rootNegCache = /* @__PURE__ */ new Map();
     const get = (key) => ctx.get(key);
-    const fs = {
-      realpath,
-      stat: async (p) => stat(p),
-      readFile,
-      symlinkTarget: async (p) => {
-        try {
-          return (await lstat(p)).isSymbolicLink() ? await readlink(p) : null;
-        } catch {
-          return null;
-        }
-      },
-      readdir: async (p) => (await readdir(p, { withFileTypes: true })).map((e) => ({ name: e.name, isDirectory: e.isDirectory() })),
-      remove: async (p) => {
-        await rm(p, { force: true });
-      }
-    };
+    const fs = createFsDeps();
     const subprocess = get("subprocess");
     const run = subprocess === void 0 ? { run: async () => {
       throw new Error("subprocess service unavailable");
@@ -180,6 +165,11 @@ __publicField(GitPanelService, "Config", Schema.object({
     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"),
+  suggestLanguage: Schema.union([
+    Schema.const("auto").description("\u81EA\u52A8\u8DDF\u968F\u4ED3\u5E93\u5386\u53F2\u63D0\u4EA4\u7684\u8BED\u8A00"),
+    Schema.const("zh").description("\u4E2D\u6587"),
+    Schema.const("en").description("English")
+  ]).default(DEFAULT_CONFIG.suggestLanguage).volatile().description("AI \u751F\u6210\u63D0\u4EA4\u4FE1\u606F\u7684\u8BED\u8A00"),
   // Defaults come from DEFAULT_CONFIG (which itself reads SUGGEST_LIMITS) —
   // a literal here could silently drift from what normalizeConfig enforces.
   suggestMaxBytes: Schema.number().default(DEFAULT_CONFIG.suggestMaxBytes).volatile().description("AI \u751F\u6210\u8F93\u5165\u9884\u7B97\uFF08diff \u5B57\u8282\u4E0A\u9650\uFF0C16\u2013512 KiB\uFF09"),
@@ -190,12 +180,15 @@ var index_default = GitPanelService;
 export {
   DEFAULT_CONFIG2 as DEFAULT_CONFIG,
   GitPanelService,
+  LONG_LINE_MAX_CHARS,
   checkLatestVersion2 as checkLatestVersion,
   classifyActionFailure,
   classifyHost,
+  compactLongLines,
   compareVersions,
   createGitRunner2 as createGitRunner,
   index_default as default,
+  isCjkText,
   isSafePath,
   normalizeConfig2 as normalizeConfig,
   parseBranches,
@@ -206,9 +199,12 @@ export {
   parseRepository,
   parseStashList,
   parseStatus,
+  parseStyleHistory,
   parseTags,
   planAction,
+  readSuggestLanguage,
   readVersionInfo2 as readVersionInfo,
+  resolveSuggestLanguage,
   resolveWorkspace,
   runAction2 as runAction,
   runQuery2 as runQuery,

package/lib/host/queries.js

@@ -1,13 +1,12 @@
 import { join, sep } from "node:path";
 import { mapWorkspaceFailure, resolveBrowseRoot, resolveWorkspace, runCommand, snapshotForSession } from "./core.js";
 import { isSafePath, isSafeRev } from "./validate.js";
+import { walkHistoryTopology } from "./history-topology.js";
 import { commitFromFields, parseBranches, parseGraphLog, parseNameStatus, parseStashList, parseTags, sumNumstat } from "./parser.js";
-import { imageMimeFor, DIFF_CONTEXT_DEFAULT, DIFF_CONTEXT_MAX, DIFF_COUNT_READ_MAX } from "./types.js";
+import { imageMimeFor, isHistoryHashSearch, isHistoryFiltered, DIFF_CONTEXT_DEFAULT, DIFF_CONTEXT_MAX, DIFF_COUNT_READ_MAX, FILE_COPY_MAX_BYTES } from "./types.js";
 const GRAPH_FORMAT = "--format=%H%x1f%h%x1f%P%x1f%an%x1f%aI%x1f%D%x1f%s%x1e";
+const FIRST_PARENT_DIFF = "--diff-merges=first-parent";
 const VISIBLE_REFS = ["--branches", "--remotes", "--tags", "HEAD"];
-function isHexLike(text) {
-  return /^[0-9a-fA-F]{7,40}$/.test(text.trim());
-}
 async function runQuery(deps, config, request) {
   const q = request.query;
   if (q.kind === "dir-list" || q.kind === "file-content") {
@@ -61,13 +60,19 @@ async function queryHistory(deps, root, q) {
   const skip = Number.isFinite(q.skip) ? Math.max(0, Math.trunc(q.skip)) : 0;
   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 hexJump = isHistoryHashSearch(search);
+  const filtered = isHistoryFiltered(q);
+  const author = q.author ?? "";
+  const since = q.since ?? "";
+  const searchFilter = search !== "";
+  const authorFilter = author !== "";
+  const sinceFilter = since !== "";
   const countArgs = ["git", "rev-list", "--count"];
   if (!hexJump) {
     const filters = [];
-    if (search !== "") filters.push("-i", "-E", `--grep=${search}`);
-    if (q.author !== void 0 && q.author !== "") filters.push(`--author=${q.author}`);
-    if (q.since !== void 0 && q.since !== "") filters.push(`--since=${q.since}`);
+    if (searchFilter) filters.push("-i", "-E", `--grep=${search}`);
+    if (authorFilter) filters.push(`--author=${author}`);
+    if (sinceFilter) filters.push(`--since=${since}`);
     if (q.ref !== void 0 && q.ref !== "") {
       if (!isSafeRev(q.ref)) return { ok: false, error: { code: "invalid-name", message: `unsafe ref: ${q.ref}` } };
       filters.push("--end-of-options", q.ref);
@@ -89,7 +94,7 @@ async function queryHistory(deps, root, q) {
   if (res.run.exitCode !== 0) {
     const stderr = res.run.stderr.trim();
     if (hexJump || /unknown revision|bad revision|does not have any commits|ambiguous argument/i.test(stderr)) {
-      return { ok: true, value: { kind: "history", commits: [], total: 0 } };
+      return { ok: true, value: { kind: "history", commits: [], total: 0, ...filtered ? { topology: [] } : {} } };
     }
     return { ok: false, error: { code: "git-error", message: stderr || `git exited ${res.run.exitCode}` } };
   }
@@ -99,7 +104,8 @@ async function queryHistory(deps, root, q) {
     const n = Number(countRes.run.stdout.trim());
     if (Number.isFinite(n)) total = n;
   }
-  return { ok: true, value: { kind: "history", commits, total } };
+  const topology = filtered ? commits.length === 0 ? [] : await walkHistoryTopology(deps.run, root, commits.map((c) => c.hash), deps.signal) : void 0;
+  return { ok: true, value: { kind: "history", commits, total, ...topology !== void 0 ? { topology } : {} } };
 }
 async function queryDiff(deps, root, q) {
   if (!isSafePath(q.path)) return { ok: false, error: { code: "invalid-path", message: q.path } };
@@ -110,7 +116,7 @@ async function queryDiff(deps, root, q) {
     args = ["git", "diff", unified, "--cached", "--", q.path];
   } else if (q.base === "commit") {
     if (!isSafeRev(q.commit)) return { ok: false, error: { code: "invalid-name", message: `unsafe commit: ${q.commit}` } };
-    args = ["git", "show", unified, "--end-of-options", q.commit, "--", q.path];
+    args = ["git", "show", unified, FIRST_PARENT_DIFF, "--end-of-options", q.commit, "--", q.path];
   } else {
     args = ["git", "diff", unified, "--", q.path];
   }
@@ -353,7 +359,6 @@ async function queryFileContent(deps, config, root, q) {
   const file = join(root, q.path);
   const inside = await isInsideRoot(deps, root, file, true);
   if (!inside) return { ok: false, error: { code: "invalid-path", message: q.path } };
-  const cap = config.maxBytes;
   let info;
   try {
     info = await deps.fs.stat(file);
@@ -361,6 +366,7 @@ async function queryFileContent(deps, config, root, q) {
     return { ok: false, error: { code: "git-error", message: error instanceof Error ? error.message : "stat failed" } };
   }
   const mime = imageMimeFor(q.path);
+  const cap = mime !== null ? config.maxBytes : Math.max(config.maxBytes, FILE_COPY_MAX_BYTES);
   const statFields = { size: info.size, mtimeMs: Math.round(info.mtimeMs) };
   const tooLarge = { ok: true, value: { kind: "file-content", path: q.path, variant: mime !== null ? "image" : "text", tooLarge: true, ...statFields } };
   if (info.size > cap) return tooLarge;
@@ -402,8 +408,8 @@ async function queryShow(deps, root, ref) {
   const metaFormat = "--format=%H%x1f%h%x1f%s%x1f%an%x1f%aI%x1f%b";
   const [metaRes, statRes, numstatRes] = await Promise.all([
     runCommand(deps.run, ["git", "show", "-s", metaFormat, "--end-of-options", ref], root, "show-meta", deps.signal),
-    runCommand(deps.run, ["git", "show", "--name-status", "-z", "--format=", "--end-of-options", ref], root, "show-stat", deps.signal),
-    runCommand(deps.run, ["git", "show", "--numstat", "--format=", "--end-of-options", ref], root, "show-numstat", deps.signal)
+    runCommand(deps.run, ["git", "show", FIRST_PARENT_DIFF, "--name-status", "-z", "--format=", "--end-of-options", ref], root, "show-stat", deps.signal),
+    runCommand(deps.run, ["git", "show", FIRST_PARENT_DIFF, "--numstat", "--format=", "--end-of-options", ref], root, "show-numstat", deps.signal)
   ]);
   if (!("run" in metaRes)) return { ok: false, error: { code: "git-unavailable" } };
   if (metaRes.run.cancelled) return { ok: false, error: { code: "cancelled" } };

package/lib/host/snapshot-fingerprint.d.ts

@@ -0,0 +1,3 @@
+import type { GitSnapshot } from './types.js';
+/** Hash the final wire state; sampling time and the digest itself are not state. */
+export declare function snapshotFingerprint(snapshot: GitSnapshot): string;

package/lib/host/snapshot-fingerprint.js

@@ -0,0 +1,12 @@
+import { createHash } from "node:crypto";
+function snapshotFingerprint(snapshot) {
+  const { checkedAt: _checkedAt, stateFingerprint: _stateFingerprint, ...state } = snapshot;
+  const encoded = JSON.stringify(state, (_key, value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+  });
+  return createHash("sha256").update(encoded).digest("hex");
+}
+export {
+  snapshotFingerprint
+};