@xbzbing/dsh-git-panel 1.5.3 → 1.6.0

package/lib/host/suggest.js

@@ -0,0 +1,220 @@
+import { mapWorkspaceFailure, resolveWorkspace, runCommand } from "./core.js";
+import { isSafePath } from "./validate.js";
+import { parseStatus } from "./parser.js";
+const 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");
+const 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 = "";
+  let lossy = false;
+  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" } };
+    }
+    if (res.run.stdoutLossy) lossy = true;
+    diff += res.run.stdout;
+  }
+  return { diff, lossy };
+}
+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;
+    const lossy = res.run.stdoutLossy;
+    if (lossy || 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 (!("diff" in collected)) return collected;
+  if (files.length === 0 && collected.diff.trim() === "") {
+    return { ok: false, error: { code: "empty-diff", message: "no uncommitted changes to summarize" } };
+  }
+  let diff = collected.diff;
+  let truncated = collected.lossy;
+  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 } : {}
+    }
+  };
+}
+export {
+  runSuggest
+};

package/lib/host/types.d.ts

@@ -9,6 +9,26 @@ export type DiffViewMode = 'unified' | 'split';
  * lane (git log --graph); `parallel` = keep each merge's first parent in its
  * own lane, converging only at the ancestor (VSCode / GUI tools). */
 export type GraphStyle = 'compact' | 'parallel';
+/**
+ * Diff context (-U) values shared by both halves. `DEFAULT` matches git's own
+ * default and is what the host applies when a request omits `context`.
+ * `MAX` is the host's clamp ceiling. `EXPAND` is what the "expand all" button
+ * asks for: deliberately bounded, because a -U window wide enough to cover a
+ * huge file makes the host emit that whole file as one hunk — megabytes of
+ * text, and past the runner's stdout cap a silently truncated diff. Whatever
+ * the window does not reach stays a collapsed gap the view reveals on demand.
+ */
+export declare const DIFF_CONTEXT_DEFAULT = 3;
+export declare const DIFF_CONTEXT_MAX = 100000;
+export declare const DIFF_EXPAND_CONTEXT = 2000;
+/**
+ * Ceiling for the working-file read taken only to count the diff's new-side
+ * lines. That count decides whether hidden context follows the last hunk, so it
+ * is read on every diff query — including the changes tab's poll while a diff is
+ * open — while `file-lines` (the on-demand expansion) stays uncapped. Above this
+ * size the count reports 0 (unknown) and no trailing control is offered.
+ */
+export declare const DIFF_COUNT_READ_MAX: number;
 /** Wire request: the browser sends only session identity, never a path. */
 export interface GitSnapshotRequest {
     readonly sessionId: string;
@@ -145,6 +165,8 @@ export type GitAction = {
 } | {
     readonly kind: 'branch-checkout';
     readonly name: string;
+    readonly createFrom?: string;
+    readonly stashMessage?: string;
 } | {
     readonly kind: 'fetch';
 } | {
@@ -188,7 +210,7 @@ export type GitAction = {
 /** `git reset` modes, from least to most destructive. Single source so the
  * client dialog and the command builder cannot drift. */
 export type ResetMode = 'soft' | 'mixed' | 'hard';
-export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'not-ff' | 'push-rejected' | 'auth-failed' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
+export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'not-ff' | 'push-rejected' | 'auth-failed' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'branch-in-use' | 'stash-switch-failed' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
 export type GitActionResult = {
     readonly ok: true;
     readonly snapshot: GitSnapshot;
@@ -335,10 +357,32 @@ export type GitQueryResult = {
     readonly kind: 'history';
     readonly commits: readonly GraphCommit[];
     readonly total: number;
-} | {
+}
+/**
+ * Unified diff text plus the new-side line count. The count is the fact the
+ * view needs to decide whether hidden context can follow the LAST hunk: git
+ * caps trailing context at -U, so a full trailing run is ambiguous from the
+ * text alone (it may be mid-file, or the file may end exactly there), while
+ * `newLines` makes it provable.
+ *
+ * 0 means "no trailing control is possible, or the count is not trustworthy":
+ * the side does not exist (a deleted file), the read failed or was truncated,
+ * the diff has no hunk at all, or the working file is above
+ * DIFF_COUNT_READ_MAX. The view treats all of those the same way — no
+ * trailing gap rather than a speculative one.
+ *
+ * `truncated` marks the one case where the text itself is incomplete: the
+ * runner dropped output at its collect/spill ceiling, so `text` is a prefix
+ * that still parses like a real diff. It is flagged rather than refused —
+ * the partial hunks stay readable — but the view must say so, because line
+ * numbers and +/- counts past the cut are simply wrong.
+ */
+ | {
     readonly kind: 'diff';
     readonly path: string;
     readonly text: string;
+    readonly newLines: number;
+    readonly truncated?: true;
 } | {
     readonly kind: 'file-lines';
     readonly path: string;
@@ -444,6 +488,31 @@ export interface GitQueryRequest {
     readonly sessionId: string;
     readonly query: GitQuery;
 }
+/**
+ * Suggest-limit ranges and defaults, in host storage units (bytes / tokens /
+ * ms) — the single source shared by both plugin halves (the client bundle
+ * imports this value, like imageMimeFor below): the host's DEFAULT_CONFIG and
+ * normalizeConfig clamp every read into [min, max], and the detail-page form
+ * derives its display units from it (the /1024 and /1000 divisions are exact
+ * and guarded by test).
+ */
+export declare const SUGGEST_LIMITS: {
+    readonly maxBytes: {
+        readonly min: number;
+        readonly max: number;
+        readonly default: number;
+    };
+    readonly maxOutputTokens: {
+        readonly min: 256;
+        readonly max: 16384;
+        readonly default: 4096;
+    };
+    readonly timeoutMs: {
+        readonly min: 5000;
+        readonly max: 120000;
+        readonly default: 15000;
+    };
+};
 /**
  * Wire request for the suggest endpoint: ask the configured model to write a
  * commit message from the repository's uncommitted changes. `paths` restricts
@@ -462,7 +531,8 @@ export type GitSuggestResult = {
         /** Actual provider/model route used (display only). */
         readonly provider?: string;
         readonly model?: string;
-        /** The diff exceeded the model input cap and was truncated. */
+        /** The diff reached the model truncated: over the input cap, or cut
+         * by the per-command runner stdout cap before it. */
         readonly truncated?: boolean;
     };
 } | {

package/lib/host/types.js

@@ -0,0 +1,36 @@
+const DIFF_CONTEXT_DEFAULT = 3;
+const DIFF_CONTEXT_MAX = 1e5;
+const DIFF_EXPAND_CONTEXT = 2e3;
+const DIFF_COUNT_READ_MAX = 8 * 1024 * 1024;
+const SUGGEST_LIMITS = {
+  maxBytes: { min: 16 * 1024, max: 512 * 1024, default: 128 * 1024 },
+  maxOutputTokens: { min: 256, max: 16384, default: 4096 },
+  timeoutMs: { min: 5e3, max: 12e4, default: 15e3 }
+};
+const IMAGE_MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  tif: "image/tiff",
+  tiff: "image/tiff"
+};
+function imageMimeFor(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot < 0) return null;
+  return IMAGE_MIME[path.slice(dot + 1).toLowerCase()] ?? null;
+}
+export {
+  DIFF_CONTEXT_DEFAULT,
+  DIFF_CONTEXT_MAX,
+  DIFF_COUNT_READ_MAX,
+  DIFF_EXPAND_CONTEXT,
+  IMAGE_MIME,
+  SUGGEST_LIMITS,
+  imageMimeFor
+};

package/lib/host/validate.js

@@ -0,0 +1,26 @@
+import { isAbsolute, normalize } from "node:path";
+function isSafePath(path) {
+  if (path === "" || isAbsolute(path)) return false;
+  const norm = normalize(path);
+  if (norm === ".." || norm.startsWith("../") || norm.startsWith("..\\")) return false;
+  return true;
+}
+const REV_META = /[\x00-\x20\x7f~^:?*[\\]/;
+function isSafeRev(input) {
+  if (input === "" || input.startsWith("-")) return false;
+  if (REV_META.test(input)) return false;
+  if (input.includes("..") || input.includes("@{")) return false;
+  return true;
+}
+function isSafeBranchName(name) {
+  return isSafeRev(name) && !name.startsWith("/");
+}
+function isSafeRemoteName(name) {
+  return /^[A-Za-z0-9._][A-Za-z0-9._/-]*$/.test(name) && name.length <= 128;
+}
+export {
+  isSafeBranchName,
+  isSafePath,
+  isSafeRemoteName,
+  isSafeRev
+};

package/lib/host/version.js

@@ -0,0 +1,130 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function manifestPath() {
+  return join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+}
+function stringField(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function parseRepository(repository) {
+  const raw = typeof repository === "string" ? repository : typeof repository === "object" && repository !== null ? stringField(repository.url) : void 0;
+  if (raw === void 0) return void 0;
+  const fromHost = raw.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?(?:$|[/#?])/i);
+  if (fromHost !== null) return { owner: fromHost[1], repo: fromHost[2] };
+  const shorthand = raw.match(/^(?:github:)?([\w.-]+)\/([\w.-]+?)(?:\.git)?$/i);
+  if (shorthand !== null) return { owner: shorthand[1], repo: shorthand[2] };
+  return void 0;
+}
+function compareVersions(a, b) {
+  const split = (value) => {
+    const trimmed = value.trim().replace(/^v/i, "");
+    const [core, ...rest] = trimmed.split("-");
+    const preRaw = rest.join("-");
+    return {
+      core: core.split(".").map((part) => Number.parseInt(part, 10)).filter((part) => Number.isFinite(part)),
+      pre: preRaw === "" ? [] : preRaw.split(".")
+    };
+  };
+  const left = split(a);
+  const right = split(b);
+  const length = Math.max(left.core.length, right.core.length);
+  for (let index = 0; index < length; index += 1) {
+    const l = left.core[index] ?? 0;
+    const r = right.core[index] ?? 0;
+    if (l > r) return 1;
+    if (l < r) return -1;
+  }
+  if (left.pre.length === 0 && right.pre.length === 0) return 0;
+  if (left.pre.length === 0) return 1;
+  if (right.pre.length === 0) return -1;
+  const preLen = Math.max(left.pre.length, right.pre.length);
+  for (let i = 0; i < preLen; i += 1) {
+    const lp = left.pre[i];
+    const rp = right.pre[i];
+    if (lp === void 0) return -1;
+    if (rp === void 0) return 1;
+    const ln = Number.parseInt(lp, 10);
+    const rn = Number.parseInt(rp, 10);
+    const lNum = Number.isFinite(ln) && String(ln) === lp;
+    const rNum = Number.isFinite(rn) && String(rn) === rp;
+    if (lNum && rNum) {
+      if (ln !== rn) return ln > rn ? 1 : -1;
+    } else if (lp !== rp) return lp > rp ? 1 : -1;
+  }
+  return 0;
+}
+let manifestCache;
+async function readManifest(path) {
+  const raw = await readFile(path, "utf8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null) throw new Error("package.json is not an object");
+  return parsed;
+}
+async function loadManifest(path) {
+  if (path !== void 0) return readManifest(path);
+  if (manifestCache === void 0) manifestCache = await readManifest(manifestPath());
+  return manifestCache;
+}
+async function readVersionInfo(options = {}) {
+  const manifest = await loadManifest(options.manifestPath);
+  const current = stringField(manifest.version) ?? "0.0.0";
+  const repo = parseRepository(manifest.repository);
+  const repositoryUrl = repo === void 0 ? void 0 : `https://github.com/${repo.owner}/${repo.repo}`;
+  return {
+    current,
+    ...repositoryUrl ? { repositoryUrl } : {},
+    updateAvailable: false,
+    checkedRemote: false
+  };
+}
+function safeReleaseUrl(url) {
+  if (url === void 0) return void 0;
+  return /^https:\/\/github\.com\//i.test(url) ? url : void 0;
+}
+const REMOTE_CACHE_MS = 10 * 60 * 1e3;
+let remoteCache;
+async function checkLatestVersion(options = {}) {
+  if (options.manifestPath === void 0 && options.fetchFn === void 0 && remoteCache !== void 0 && Date.now() - remoteCache.at < REMOTE_CACHE_MS) {
+    return remoteCache.info;
+  }
+  const base = await readVersionInfo({ manifestPath: options.manifestPath });
+  const repo = parseRepository((await loadManifest(options.manifestPath)).repository);
+  if (repo === void 0) {
+    return { ...base, checkedRemote: false, error: "repository is not configured" };
+  }
+  const fetchFn = options.fetchFn ?? fetch;
+  try {
+    const response = await fetchFn(`https://api.github.com/repos/${repo.owner}/${repo.repo}/releases/latest`, {
+      headers: { accept: "application/vnd.github+json", "user-agent": "dsh-git-panel" },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      return { ...base, checkedRemote: true, error: `GitHub responded with ${response.status}` };
+    }
+    const body = await response.json();
+    const tag = typeof body === "object" && body !== null ? stringField(body.tag_name) : void 0;
+    const htmlUrl = typeof body === "object" && body !== null ? stringField(body.html_url) : void 0;
+    if (tag === void 0) {
+      return { ...base, checkedRemote: true, error: "GitHub response did not include a release tag" };
+    }
+    const latest = tag.replace(/^v/i, "");
+    const info = {
+      ...base,
+      checkedRemote: true,
+      latest,
+      updateAvailable: compareVersions(latest, base.current) > 0,
+      releaseUrl: safeReleaseUrl(htmlUrl) ?? (base.repositoryUrl !== void 0 ? `${base.repositoryUrl}/releases/latest` : void 0)
+    };
+    if (options.manifestPath === void 0 && options.fetchFn === void 0) remoteCache = { at: Date.now(), info };
+    return info;
+  } catch (error) {
+    return { ...base, checkedRemote: true, error: error instanceof Error ? error.message : "Unable to reach GitHub" };
+  }
+}
+export {
+  checkLatestVersion,
+  compareVersions,
+  parseRepository,
+  readVersionInfo
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbzbing/dsh-git-panel",
-  "version": "1.5.3",
+  "version": "1.6.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",
@@ -25,7 +25,8 @@
     "./client": {
       "default": "./lib/client.js"
     },
-    "./locale/*.json": "./locale/*.json",
+    "./locale/zh.json": "./locale/zh.json",
+    "./locale/en.json": "./locale/en.json",
     "./package.json": "./package.json"
   },
   "files": [
@@ -35,14 +36,14 @@
     "icon.svg",
     "cordis.patch.yml",
     "README.md",
-    "README_EN.md",
+    "README.en.md",
     "LICENSE"
   ],
   "scripts": {
     "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 && node test/e2e/run3.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 && node test/e2e/run4.mjs && node test/e2e/run5.mjs",
     "test": "npm run test:unit && npm run test:e2e",
     "check": "npm run typecheck && npm run test && git diff --exit-code -- lib/"
   },
@@ -58,6 +59,12 @@
         "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-ui-primitives"
       ]
+    },
+    "compatibility": {
+      "dsh": ">=0.1.7-rc.2",
+      "dshReleases": {
+        "0.2.1-alpha.2": "compatible"
+      }
     }
   },
   "keywords": [