@xbzbing/dsh-git-panel 1.5.3 → 1.5.4

package/lib/host/suggest.js

@@ -0,0 +1,217 @@
+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 = "";
+  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 } : {}
+    }
+  };
+}
+export {
+  runSuggest
+};

package/lib/host/types.js

@@ -0,0 +1,22 @@
+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 {
+  IMAGE_MIME,
+  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.5.4",
   "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,7 +36,7 @@
     "icon.svg",
     "cordis.patch.yml",
     "README.md",
-    "README_EN.md",
+    "README.en.md",
     "LICENSE"
   ],
   "scripts": {
@@ -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": [