@rexvane/piweb 0.3.21 → 0.3.23

package/src/lib/files-service.ts

@@ -2,13 +2,17 @@
  * files-service：会话工作区的文件浏览（详情栏「文件」面板）。
  * 安全边界：目标路径必须落在工作区根内（realpath 双重校验，防符号链接逃逸）。
  */
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { promisify } from "node:util";
 import { BoundaryError, isPathInside, resolveWorkspacePath } from "./path-security";
 import { getAgentDir } from "./pi";
+import { resolveGitBin } from "./growth-service";
 import { utf8Prefix } from "./text-sanitize";
 
+const exec = promisify(execFile);
+
 export interface FileEntry {
 	name: string;
 	kind: "dir" | "file";
@@ -29,11 +33,166 @@ const MAX_READ_BYTES = 256 * 1024;
 /** 单次目录响应上限；后续条目通过 offset 分页获取。 */
 const MAX_ENTRIES = 2000;
 
+/**
+ * @ 引用的候选索引上限。一次拉给浏览器做本地模糊匹配，所以是一份完整清单：
+ * 每敲一个字符不再发请求（实测本仓库 700 余条 ≈ 30 KB）。
+ * 超大仓库截断到上限并在界面标出，不静默少候选。
+ */
+const INDEX_LIMIT = 20_000;
+/** 非 git 工作区的退路：只跳过这些明显不该当候选的重目录，其余照常列举 */
+const INDEX_SKIP_DIRS = new Set([".git", "node_modules", ".next", ".next-dev", ".venv", "venv", "__pycache__", "dist", "build", "out", "target", ".turbo", ".cache"]);
+const INDEX_MAX_DEPTH = 12;
+
+export interface WorkspaceIndex {
+	/** 工作区根下的相对路径（"/" 分隔）。只给文件：文件夹由前端从文件路径推导 */
+	files: string[];
+	/** git = `git ls-files`（尊重 .gitignore）；disk = 不是仓库时的目录遍历退路 */
+	source: "git" | "disk";
+	/** 候选被上限截断：匹配结果可能不全，界面要说明 */
+	truncated: boolean;
+}
+
+/** `git ls-files -z` 输出 → 相对路径数组（去重） */
+export function parseLsFiles(raw: string): string[] {
+	const seen = new Set<string>();
+	for (const entry of raw.split("\0")) {
+		if (!entry) continue;
+		const rel = entry.replace(/\\/g, "/");
+		if (rel.startsWith("/") || rel.split("/").includes("..")) continue;
+		seen.add(rel);
+	}
+	return [...seen];
+}
+
+/** 不是仓库（或机器上没有 git）时的退路：广度优先遍历，只收文件 */
+async function walkWorkspaceFiles(root: string): Promise<{ files: string[]; truncated: boolean }> {
+	const files: string[] = [];
+	let queue: Array<{ rel: string; depth: number }> = [{ rel: "", depth: 0 }];
+	while (queue.length) {
+		const next: typeof queue = [];
+		for (const dir of queue) {
+			const entries = await fs.readdir(path.join(root, dir.rel), { withFileTypes: true }).catch(() => []);
+			for (const entry of entries) {
+				const rel = dir.rel ? `${dir.rel}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) {
+					if (dir.depth + 1 <= INDEX_MAX_DEPTH && !INDEX_SKIP_DIRS.has(entry.name)) next.push({ rel, depth: dir.depth + 1 });
+				} else if (entry.isFile()) {
+					files.push(rel);
+					if (files.length > INDEX_LIMIT) return { files: files.slice(0, INDEX_LIMIT), truncated: true };
+				}
+			}
+		}
+		queue = next;
+	}
+	return { files, truncated: false };
+}
+
+/**
+ * git 失败时只有「不是仓库」「没装 git」两种该退回遍历——界面会把 disk 来源解释成这两种情况。
+ * 其它失败（safe.directory 拒绝、索引损坏、超时）照实报错：退回遍历会把 .gitignore 掉的文件混进候选，还给出错误的解释。
+ */
+function gitIndexFailure(error: unknown): "fallback" | Error {
+	const e = error as NodeJS.ErrnoException & { stderr?: string; killed?: boolean };
+	if (e.code === "ENOENT") return "fallback";
+	const stderr = String(e.stderr ?? "");
+	if (/not a git repository/i.test(stderr)) return "fallback";
+	if (e.killed) return new Error("git ls-files timed out");
+	const fatal = stderr.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	return new Error(`git ls-files failed: ${fatal.find((line) => line.startsWith("fatal:")) ?? fatal[0] ?? e.message}`);
+}
+
+/**
+ * @ 引用的候选清单：git 可见的文件（含未被忽略的未跟踪文件）。
+ * `git ls-files` 的路径相对当前目录，所以 cwd 就是工作区根，输出天然是工作区相对路径。
+ */
+export async function listWorkspaceIndex(cwdValue: unknown): Promise<WorkspaceIndex> {
+	const root = await resolveWorkspacePath(cwdValue);
+	const git = await resolveGitBin();
+	try {
+		const { stdout } = await exec(git, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+			cwd: root,
+			timeout: 15_000,
+			maxBuffer: 64 * 1024 * 1024,
+			windowsHide: true,
+			// LC_ALL=C：报错固定为英文，「不是仓库」才认得出来（中文界面的 git 会翻译这句）；-z 输出的路径不受影响
+			env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" },
+		});
+		const files = parseLsFiles(stdout).sort((a, b) => a.localeCompare(b));
+		return { files: files.slice(0, INDEX_LIMIT), source: "git", truncated: files.length > INDEX_LIMIT };
+	} catch (error) {
+		const failure = gitIndexFailure(error);
+		if (failure !== "fallback") throw failure;
+		const walked = await walkWorkspaceFiles(root);
+		return { files: walked.files.sort((a, b) => a.localeCompare(b)), source: "disk", truncated: walked.truncated };
+	}
+}
+
+
 function toRel(root: string, target: string): string {
 	const rel = path.relative(root, target).replace(/\\/g, "/");
 	return rel === "" ? "." : rel;
 }
 
+/** `git check-ignore -z` 输出 → 相对路径数组 */
+export function parseCheckIgnore(raw: string): string[] {
+	return raw.split("\u0000").filter(Boolean).map((entry) => entry.split("\\").join("/"));
+}
+
+/**
+ * 问 git 这个目录里哪些条目被 .gitignore 忽略（且未被跟踪）。
+ * 用 check-ignore --stdin 一次问完整个目录：0 = 有被忽略的，1 = 一条都没有，128 = 不是仓库。
+ * 条目多时命令行会超长，所以走 stdin 不走参数（单页最多 2000 条）。
+ */
+function checkIgnore(root: string, git: string, rels: string[]): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(git, ["check-ignore", "-z", "--stdin"], {
+			cwd: root,
+			windowsHide: true,
+			env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" },
+		});
+		let out = "";
+		let err = "";
+		let inputError: Error | undefined;
+		// Pipe errors are asynchronous: try/catch around end() cannot handle EPIPE.
+		child.stdin.on("error", (error) => { inputError = error; });
+		const timer = setTimeout(() => { child.kill(); reject(new Error("git check-ignore timed out")); }, 10_000);
+		child.stdout.on("data", (chunk: Buffer) => { out += chunk.toString("utf8"); });
+		child.stderr.on("data", (chunk: Buffer) => { err += chunk.toString("utf8"); });
+		child.on("error", (error) => { clearTimeout(timer); reject(error); });
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (inputError) reject(inputError);
+			else if (code === 0) resolve(out);
+			else if (code === 1) resolve("");
+			else reject(new Error(err.trim() || `git check-ignore exited with ${code}`));
+		});
+		try {
+			child.stdin.end(`${rels.join("\u0000")}\u0000`);
+		} catch (error) {
+			inputError = error instanceof Error ? error : new Error(String(error));
+		}
+	});
+}
+
+/**
+ * 这个目录里该从列表里去掉的名字:被 .gitignore 忽略的(node_modules/、.next、.claude 这类的构建产物与私有目录)。
+ * 判据用 git 自己的规则，和快照树、@ 引用清单同一口径；不是仓库 / 没装 git / git 出错一律不过滤
+ * （宁可多显示，也不能把用户的项目文件藏起来）。
+ */
+async function ignoredNames(root: string, dirRel: string, names: string[]): Promise<Set<string>> {
+	if (!names.length) return new Set();
+	try {
+		const git = await resolveGitBin();
+		const rels = names.map((name) => (dirRel ? `${dirRel}/${name}` : name));
+		const raw = await checkIgnore(root, git, rels);
+		// 输出是相对仓库根的路径：减掉当前目录前缀就回到名字集合
+		const prefix = dirRel ? `${dirRel}/` : "";
+		return new Set(parseCheckIgnore(raw).map((entry) => (prefix && entry.startsWith(prefix) ? entry.slice(prefix.length) : entry)));
+	} catch {
+		return new Set();
+	}
+}
+
 export async function listWorkspaceDir(cwdValue: unknown, relPath: unknown, offsetValue: unknown = 0): Promise<DirListing> {
 	const root = await resolveWorkspacePath(cwdValue);
 	const offset = offsetValue === null || offsetValue === "" ? 0 : Number(offsetValue);
@@ -75,8 +234,12 @@ export async function listWorkspaceDir(cwdValue: unknown, relPath: unknown, offs
 		if (a.kind !== b.kind) return a.kind === "dir" ? -1 : 1;
 		return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
 	});
-	const nextOffset = offset + MAX_ENTRIES < entries.length ? offset + MAX_ENTRIES : null;
-	const page = entries.slice(offset, offset + MAX_ENTRIES);
+	// .gitignore 忽略的条目(node_modules/、.next/ 这些)不进列表:和快照树、@ 引用清单同一口径
+	const relForIgnore = path.relative(root, real).replace(/\\/g, "/");
+	const ignored = await ignoredNames(root, relForIgnore, entries.map((entry) => entry.name));
+	const visible = ignored.size ? entries.filter((entry) => !ignored.has(entry.name)) : entries;
+	const nextOffset = offset + MAX_ENTRIES < visible.length ? offset + MAX_ENTRIES : null;
+	const page = visible.slice(offset, offset + MAX_ENTRIES);
 	for (let i = 0; i < page.length; i += 64) {
 		await Promise.all(page.slice(i, i + 64).map(async (entry) => {
 			if (entry.kind !== "file" || entry.size !== undefined) return;

package/src/lib/format.ts

@@ -0,0 +1,56 @@
+/**
+ * 全站数字显示格式。
+ *
+ * 精度口径（用户要求「精确到小数点后两位」）：
+ * - 比率（缓存命中 / 上下文占用）、速率（tok/s）、秒级时长：一律两位小数；
+ * - token 量：≥1000 用 K、≥100 万用 M，都两位小数；<1000 原样整数（计数没有小数含义）；
+ * - 轮次 / 步数 / 文件数等计数：整数；
+ * - 分钟级时长保持 `19m30s`（`19m30.42s` 更难读）、金额保持四位（`$0.0123` 是惯例）。
+ *
+ * 以前 ChatWindow / ContextMeter / TrajectoryView 各有一份 fmtTok，同一个数字在三处
+ * 显示不同（262400 → `262K` / `262.4K` / `262.4K`；53000000 → `53M` / `53000.0K` / `53.0M`），
+ * 统一到这里。
+ */
+
+/** token 量：K / M 两位小数，<1000 整数 */
+export function fmtTokens(value: number): string {
+	if (!Number.isFinite(value)) return "—";
+	if (Math.abs(value) < 1_000) return String(Math.round(value));
+	// 先按 K 缩放；四舍五入到两位小数后已到 1000.00K 就升级成 M，避免出现「1000.00K」
+	const k = value / 1_000;
+	if (Math.abs(Number(k.toFixed(2))) < 1_000) return `${k.toFixed(2)}K`;
+	return `${(value / 1_000_000).toFixed(2)}M`;
+}
+
+/** 计数（轮次 / 步数 / 文件数）：整数 */
+export function fmtCount(value: number): string {
+	return Number.isFinite(value) ? String(Math.round(value)) : "—";
+}
+
+/** 百分比：入参是 0–100 的数值，输出两位小数 */
+export function fmtPercent(percent: number): string {
+	return `${(Number.isFinite(percent) ? percent : 0).toFixed(2)}%`;
+}
+
+/** 速率：tok/s，两位小数 */
+export function fmtThroughput(tokensPerSecond: number): string {
+	return (Number.isFinite(tokensPerSecond) ? tokensPerSecond : 0).toFixed(2);
+}
+
+/**
+ * 时长：不足 60 秒两位小数（`5.32s`），到分钟级用 `19m30s`（秒级再补小数只会更难读）。
+ */
+export function fmtDuration(ms: number): string {
+	const seconds = Math.max(0, Number.isFinite(ms) ? ms : 0) / 1_000;
+	if (seconds < 60) return `${seconds.toFixed(2)}s`;
+	const whole = Math.round(seconds);
+	return `${Math.floor(whole / 60)}m${whole % 60}s`;
+}
+
+/** 文件大小：B 整数，KB / MB 两位小数 */
+export function fmtBytes(bytes: number): string {
+	if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+	if (bytes < 1_024) return `${Math.round(bytes)} B`;
+	if (bytes < 1_024 * 1_024) return `${(bytes / 1_024).toFixed(2)} KB`;
+	return `${(bytes / 1_024 / 1_024).toFixed(2)} MB`;
+}

package/src/lib/git-service.ts

@@ -7,7 +7,7 @@ import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
-import { resolveGitBin } from "./growth-service";
+import { parseNumstat, resolveGitBin } from "./growth-service";
 import { BoundaryError, isPathInside, resolveWorkspacePath } from "./path-security";
 
 const exec = promisify(execFile);
@@ -76,7 +76,8 @@ function kindOf(x: string, y: string): GitFileEntry["kind"] {
 	return "modified";
 }
 
-async function repoRoot(cwd: string): Promise<{ available: boolean; root: string | null }> {
+/** 解析仓库根（GitHub 身份解析也要用，所以导出） */
+export async function repoRoot(cwd: string): Promise<{ available: boolean; root: string | null }> {
 	try {
 		const out = (await runGit(cwd, ["rev-parse", "--show-toplevel"])).trim();
 		return { available: true, root: out ? path.resolve(out) : null };
@@ -187,11 +188,34 @@ export interface GitDiffResult {
 	patch: string;
 	truncated: boolean;
 	binary: boolean;
+	/** 完整 diff 的 Git numstat，独立于用于展示的 patch 截断。二进制不计行数。 */
+	stats: { add: number; del: number };
 }
 
-function truncate(patch: string): GitDiffResult {
-	if (Buffer.byteLength(patch) <= MAX_DIFF_BYTES) return { patch, truncated: false, binary: false };
-	return { patch: Buffer.from(patch).subarray(0, MAX_DIFF_BYTES).toString("utf8"), truncated: true, binary: false };
+async function fullDiffStats(root: string, args: string[], noIndex = false): Promise<{ stats: GitDiffResult["stats"]; binary: boolean }> {
+	let raw: string;
+	try {
+		raw = await runGit(root, args);
+	} catch (error) {
+		// --no-index 的退出码 1 表示有差异，stdout 仍是有效的 numstat。
+		const result = error as { code?: number; stdout?: string };
+		if (!noIndex || result.code !== 1 || typeof result.stdout !== "string" || !result.stdout) throw error;
+		raw = result.stdout;
+	}
+	let add = 0;
+	let del = 0;
+	let binary = false;
+	for (const entry of parseNumstat(raw).values()) {
+		add += entry.add;
+		del += entry.del;
+		binary ||= entry.binary;
+	}
+	return { stats: { add, del }, binary };
+}
+
+function truncate(patch: string, stats: GitDiffResult["stats"]): GitDiffResult {
+	if (Buffer.byteLength(patch) <= MAX_DIFF_BYTES) return { patch, truncated: false, binary: false, stats };
+	return { patch: Buffer.from(patch).subarray(0, MAX_DIFF_BYTES).toString("utf8"), truncated: true, binary: false, stats };
 }
 
 function assertRepoRelative(root: string, relPath: unknown): string {
@@ -215,6 +239,8 @@ export async function gitDiff(cwdValue: unknown, relPath: unknown, mode: unknown
 		if (!isPathInside(realRoot, realFile)) throw new BoundaryError("path escapes the repository");
 		const stat = await fs.stat(realFile).catch(() => null);
 		if (!stat?.isFile()) throw new BoundaryError("file not found");
+		const { stats, binary } = await fullDiffStats(root, ["diff", "--no-index", "--no-ext-diff", "--no-textconv", "--numstat", "-z", "--", "/dev/null", realFile], true);
+		if (binary) return { patch: "", truncated: false, binary: true, stats };
 		const buffer = Buffer.alloc(Math.min(stat.size, MAX_DIFF_BYTES + 1));
 		const handle = await fs.open(realFile, "r");
 		let bytesRead = 0;
@@ -228,8 +254,7 @@ export async function gitDiff(cwdValue: unknown, relPath: unknown, mode: unknown
 			await handle.close();
 		}
 		const head = buffer.subarray(0, bytesRead);
-		if (head.includes(0)) return { patch: "", truncated: false, binary: true };
-		const text = head.subarray(0, MAX_DIFF_BYTES).toString("utf8").replace(/\r/g, "");
+		const text = head.subarray(0, MAX_DIFF_BYTES).toString("utf8").replace(/\r\n/g, "\n");
 		const lines = text.split("\n");
 		if (lines[lines.length - 1] === "") lines.pop();
 		const body = lines.map((l) => `+${l}`).join("\n");
@@ -237,12 +262,16 @@ export async function gitDiff(cwdValue: unknown, relPath: unknown, mode: unknown
 			patch: `--- /dev/null\n+++ b/${rel}\n@@ -0,0 +1,${lines.length} @@\n${body}\n`,
 			truncated: stat.size > MAX_DIFF_BYTES,
 			binary: false,
+			stats,
 		};
 	}
-	const args = mode === "staged" ? ["diff", "--cached", "--no-color", "--", rel] : ["diff", "--no-color", "--", rel];
-	const out = await runGit(root, args, 8 * 1024 * 1024);
-	if (/^Binary files .* differ$/m.test(out)) return { patch: "", truncated: false, binary: true };
-	return truncate(out);
+	const scope = mode === "staged" ? ["--cached"] : [];
+	const [out, counts] = await Promise.all([
+		runGit(root, ["diff", ...scope, "--no-color", "--no-ext-diff", "--no-textconv", "--", rel], 8 * 1024 * 1024),
+		fullDiffStats(root, ["diff", ...scope, "--no-ext-diff", "--no-textconv", "--numstat", "-z", "--", rel]),
+	]);
+	if (counts.binary) return { patch: "", truncated: false, binary: true, stats: counts.stats };
+	return truncate(out, counts.stats);
 }
 
 /** 单次提交的内容（含各文件 patch） */
@@ -252,6 +281,9 @@ export async function gitShow(cwdValue: unknown, hash: unknown): Promise<GitDiff
 	if (!available || !root) throw new BoundaryError("not a git repository");
 	if (typeof hash !== "string" || !/^[0-9a-f]{4,40}$/i.test(hash)) throw new BoundaryError("invalid commit hash");
 	const title = (await runGit(root, ["log", "-1", "--pretty=%h %s%n%an · %cr", hash])).trim();
-	const out = await runGit(root, ["show", "--no-color", "--format=", "--patch", hash], 8 * 1024 * 1024);
-	return { title, ...truncate(out) };
+	const [out, counts] = await Promise.all([
+		runGit(root, ["show", "--no-color", "--no-ext-diff", "--no-textconv", "--format=", "--patch", hash], 8 * 1024 * 1024),
+		fullDiffStats(root, ["show", "--no-ext-diff", "--no-textconv", "--format=", "--numstat", "-z", hash]),
+	]);
+	return { title, ...truncate(out, counts.stats), binary: counts.binary && !out.includes("@@ ") };
 }

package/src/lib/github-identity.ts

@@ -0,0 +1,245 @@
+/**
+ * GitHub 身份：Git 面板头部显示「头像 + 账号」。
+ *
+ * 只读，不碰任何写操作，也不把 token 交给浏览器。三档降级：
+ *
+ * 1. `gh api user` —— 本机 gh 已登录时拿到的是**当前登录账号**（最准）；
+ * 2. 仓库 `origin` remote 的 owner —— 没装 gh / 没登录也能用，头像是免登录的
+ *    `github.com/<owner>.png`；但拿到的可能是「仓库归属者」而不是登录账号；
+ * 3. `git config user.name` —— 纯本地身份，没有头像，只作文字兜底。
+ *
+ * 两条网络路径实测：`gh api user` 约 1.1s、头像约 2.2s，所以结果缓存 12 小时
+ * （内存 + 落盘，PiWeb 重启后仍然即时）。头像取到后转成 data URL 随身份一起返回，
+ * 前端不用再发第二次请求，断网也能显示。
+ *
+ * 任何一步失败都只降级，不抛错：Git 面板不该因为 GitHub 不通而少东西。
+ */
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { resolveGitBin } from "./growth-service";
+import { getAgentDir } from "./pi";
+
+const exec = promisify(execFile);
+
+export interface GithubIdentity {
+	login: string;
+	/** gh 里的显示名（如「心安」），没有就省略 */
+	name?: string;
+	/** data URL；取不到头像时省略，UI 退回首字母 */
+	avatar?: string;
+	/** 账号主页，点击可跳转 */
+	url?: string;
+	/** `owner/repo`（来自 origin remote），没配 remote 就没有 */
+	repo?: string;
+}
+
+const TTL_MS = 12 * 60 * 60 * 1_000;
+const GH_TIMEOUT_MS = 8_000;
+const AVATAR_TIMEOUT_MS = 8_000;
+const AVATAR_SIZE = 64;
+const AVATAR_MAX_BYTES = 256 * 1_024;
+const CACHE_FILENAME = "piweb-github-identity.json";
+// 身份字段一变就提版本：旧的缓存条目直接作废重取，避免返回已经删掉的字段
+const CACHE_VERSION = 2;
+
+interface CacheFile {
+	version: number;
+	entries: Record<string, { at: number; value: GithubIdentity | null }>;
+}
+
+const memory = new Map<string, { at: number; value: GithubIdentity | null }>();
+const inflight = new Map<string, Promise<GithubIdentity | null>>();
+let diskLoaded = false;
+let diskWrite: Promise<void> | null = null;
+
+function cachePath(): string {
+	return path.join(getAgentDir(), CACHE_FILENAME);
+}
+
+/** 离线模式（SDK 也认这个变量）：不发任何网络请求，只走本地能算出来的那一档 */
+function offline(): boolean {
+	const value = process.env.PI_OFFLINE;
+	if (!value || value === "0") return false;
+	return value.toLowerCase() !== "false";
+}
+
+async function loadDisk(): Promise<void> {
+	if (diskLoaded) return;
+	diskLoaded = true;
+	try {
+		const raw = JSON.parse(await fs.readFile(cachePath(), "utf8")) as CacheFile;
+		if (raw?.version !== CACHE_VERSION || !raw.entries || typeof raw.entries !== "object") return;
+		const now = Date.now();
+		for (const [key, entry] of Object.entries(raw.entries)) {
+			if (!entry || typeof entry.at !== "number" || now - entry.at >= TTL_MS) continue;
+			if (!memory.has(key)) memory.set(key, entry);
+		}
+	} catch {
+		/* 没有缓存 / 读不了都当第一次 */
+	}
+}
+
+function persist(): void {
+	if (diskWrite) return;
+	diskWrite = (async () => {
+		try {
+			const entries: CacheFile["entries"] = {};
+			for (const [key, entry] of memory) entries[key] = entry;
+			await fs.writeFile(cachePath(), JSON.stringify({ version: CACHE_VERSION, entries }), "utf8");
+		} catch {
+			/* 写不了就只在内存里缓存 */
+		} finally {
+			diskWrite = null;
+		}
+	})();
+}
+
+/** 解析 gh 可执行文件（PATH 找不到时退回常见安装位置）；结果缓存 */
+let ghBin: string | null | undefined;
+async function resolveGhBin(): Promise<string | null> {
+	if (ghBin !== undefined) return ghBin;
+	const candidates = process.platform === "win32"
+		? ["gh", path.join(process.env.ProgramFiles ?? "C:\\Program Files", "GitHub CLI", "gh.exe"), path.join(process.env.LOCALAPPDATA ?? "", "Programs", "GitHub CLI", "gh.exe")]
+		: ["gh", "/opt/homebrew/bin/gh", "/usr/local/bin/gh", "/usr/bin/gh"];
+	for (const candidate of candidates) {
+		if (!candidate) continue;
+		const ok = await exec(candidate, ["--version"], { timeout: 5_000, windowsHide: true }).then(() => true, () => false);
+		if (ok) {
+			ghBin = candidate;
+			return ghBin;
+		}
+	}
+	ghBin = null;
+	return ghBin;
+}
+
+async function git(cwd: string, args: string[]): Promise<string> {
+	const out = await exec(await resolveGitBin(), args, {
+		cwd,
+		timeout: 15_000,
+		maxBuffer: 1024 * 1_024,
+		windowsHide: true,
+		env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" },
+	});
+	return out.stdout;
+}
+
+/** 从 remote URL 里取 owner 与仓库名：支持 https / ssh / git:// 三种写法 */
+export function parseGithubRemote(remote: string | undefined | null): { owner: string; repo?: string } | null {
+	if (!remote) return null;
+	const trimmed = remote.trim().replace(/\.git$/, "");
+	const m = trimmed.match(/github\.com[:/]+([^/]+)(?:\/([^/]+))?/i);
+	if (!m?.[1]) return null;
+	return { owner: m[1], repo: m[2] ? `${m[1]}/${m[2]}` : undefined };
+}
+
+async function ghAccount(cwd: string): Promise<{ login: string; name?: string; url?: string } | null> {
+	if (offline()) return null;
+	const bin = await resolveGhBin();
+	if (!bin) return null;
+	try {
+		const { stdout } = await exec(bin, ["api", "user"], {
+			cwd,
+			timeout: GH_TIMEOUT_MS,
+			maxBuffer: 1024 * 1_024,
+			windowsHide: true,
+			env: { ...process.env, GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1" },
+		});
+		const parsed = JSON.parse(stdout) as { login?: unknown; name?: unknown; html_url?: unknown };
+		if (typeof parsed.login !== "string" || !parsed.login) return null;
+		return {
+			login: parsed.login,
+			name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : undefined,
+			url: typeof parsed.html_url === "string" ? parsed.html_url : undefined,
+		};
+	} catch {
+		// 没网 / 没登录 / token 失效：交给下一档
+		return null;
+	}
+}
+
+async function avatarDataUrl(owner: string): Promise<string | undefined> {
+	if (offline()) return undefined;
+	try {
+		const res = await fetch(`https://github.com/${encodeURIComponent(owner)}.png?size=${AVATAR_SIZE}`, {
+			signal: AbortSignal.timeout(AVATAR_TIMEOUT_MS),
+			headers: { Accept: "image/*" },
+		});
+		if (!res.ok) return undefined;
+		const type = res.headers.get("content-type") ?? "image/png";
+		if (!type.startsWith("image/")) return undefined;
+		const buffer = Buffer.from(await res.arrayBuffer());
+		if (!buffer.length || buffer.length > AVATAR_MAX_BYTES) return undefined;
+		return `data:${type};base64,${buffer.toString("base64")}`;
+	} catch {
+		return undefined;
+	}
+}
+
+async function compute(root: string): Promise<GithubIdentity | null> {
+	let remote: { owner: string; repo?: string } | null = null;
+	try {
+		remote = parseGithubRemote(await git(root, ["remote", "get-url", "origin"]));
+	} catch {
+		/* 没有 origin 就往下走 */
+	}
+	const account = await ghAccount(root);
+	if (account) {
+		return {
+			login: account.login,
+			name: account.name,
+			url: account.url ?? `https://github.com/${account.login}`,
+			avatar: await avatarDataUrl(account.login),
+			repo: remote?.repo,
+		};
+	}
+	if (remote) {
+		return { login: remote.owner, url: `https://github.com/${remote.owner}`, avatar: await avatarDataUrl(remote.owner), repo: remote.repo };
+	}
+	try {
+		const name = (await git(root, ["config", "user.name"])).trim();
+		if (name) return { login: name };
+	} catch {
+		/* 什么都没配 */
+	}
+	return null;
+}
+
+function start(root: string): Promise<GithubIdentity | null> {
+	const existing = inflight.get(root);
+	if (existing) return existing;
+	const task = compute(root)
+		.then((value) => {
+			memory.set(root, { at: Date.now(), value });
+			persist();
+			return value;
+		})
+		.catch(() => null)
+		.finally(() => inflight.delete(root)) as Promise<GithubIdentity | null>;
+	inflight.set(root, task);
+	return task;
+}
+
+/**
+ * 取仓库的 GitHub 身份。命中缓存立刻返回；否则**后台**刷新并返回已过期的旧值（或 null），
+ * 不会让调用方等网络。要拿首次结果用 `awaitGithubIdentity`。
+ */
+export function githubIdentity(root: string | null): GithubIdentity | null {
+	if (!root) return null;
+	void loadDisk();
+	const hit = memory.get(root);
+	if (hit && Date.now() - hit.at < TTL_MS) return hit.value;
+	void start(root);
+	return hit?.value ?? null;
+}
+
+/** 等首次解析完成（面板刚打开、缓存还冷时用；调用方自己控制超时） */
+export async function awaitGithubIdentity(root: string | null): Promise<GithubIdentity | null> {
+	if (!root) return null;
+	await loadDisk();
+	const hit = memory.get(root);
+	if (hit && Date.now() - hit.at < TTL_MS) return hit.value;
+	return start(root);
+}

package/src/lib/growth-service.ts

@@ -433,8 +433,12 @@ export function parseNumstat(raw: string): Map<string, { add: number; del: numbe
 	for (let i = 0; i < tokens.length; i += 1) {
 		const t = tokens[i];
 		if (!t) continue;
-		const [a, d, rest] = t.split("\t");
-		if (a === undefined || d === undefined) continue;
+		const first = t.indexOf("\t");
+		const second = t.indexOf("\t", first + 1);
+		if (first < 0 || second < 0) continue;
+		const a = t.slice(0, first);
+		const d = t.slice(first + 1, second);
+		const rest = t.slice(second + 1);
 		const binary = a === "-" || d === "-";
 		const entry = { add: binary ? 0 : Number(a) || 0, del: binary ? 0 : Number(d) || 0, binary };
 		if (rest === undefined || rest === "") {

package/src/lib/hero-model-memory.ts

@@ -0,0 +1,28 @@
+/**
+ * 新会话页记住的模型：按工作区存在这个浏览器的 localStorage 里（key 为 piweb.heroModel.<工作区>）。
+ * 只认工作区自己记住的那一条；没有就是没选过，不回落到别的工作区，也不替用户预选。
+ */
+
+export interface HeroModelChoice {
+	provider: string;
+	id: string;
+}
+
+const KEY_PREFIX = "piweb.heroModel.";
+
+/** 读某个工作区记住的模型；没有、或内容损坏，都当作没选过 */
+export function readRememberedHeroModel(storage: Pick<Storage, "getItem">, cwd: string): HeroModelChoice | null {
+	const raw = storage.getItem(`${KEY_PREFIX}${cwd}`);
+	if (!raw) return null;
+	try {
+		const value = JSON.parse(raw) as Partial<HeroModelChoice> | null;
+		return value && typeof value.provider === "string" && typeof value.id === "string" ? { provider: value.provider, id: value.id } : null;
+	} catch {
+		return null;
+	}
+}
+
+/** 记住某个工作区选的模型，只写这个工作区名下 */
+export function writeRememberedHeroModel(storage: Pick<Storage, "setItem">, cwd: string, choice: HeroModelChoice): void {
+	storage.setItem(`${KEY_PREFIX}${cwd}`, JSON.stringify({ provider: choice.provider, id: choice.id }));
+}