@rexvane/piweb 0.3.20 → 0.3.22

package/src/lib/chat/stream-settings.ts

@@ -0,0 +1,192 @@
+/**
+ * 流式文字输出偏好：显示样式 / 推进速度 / 打字光标。
+ *
+ * 存 localStorage（piweb.streamStyle / piweb.streamSpeed / piweb.streamCaret），
+ * 模块级订阅：设置面板一改，正在流的那条回答在下一帧就换样式，不必重开会话；
+ * 跨标签页由 storage 事件同步。
+ *
+ * 推进量是纯函数 nextRevealEnd(target, shownLength, settings)：给定目标文本、已显示长度和偏好，
+ * 算出这一帧该显示到哪。不变量是「显示内容始终是目标前缀、单调增长、最终追平」——
+ * 见 tests/stream-settings.test.ts。
+ */
+
+export type StreamStyle = "smooth" | "instant" | "typewriter" | "fade";
+
+export interface StreamSettings {
+	/** 文字出现的方式 */
+	style: StreamStyle;
+	/** 推进速度档位 1..5（3 = 标准） */
+	speed: number;
+	/** 打字光标：流式期间在文字末尾闪烁 */
+	caret: boolean;
+}
+
+/** 设置面板里的展示顺序（即时排在最后：它是「不要平滑」的退路） */
+export const STREAM_STYLES: readonly StreamStyle[] = ["smooth", "typewriter", "fade", "instant"];
+export const STREAM_SPEED_MIN = 1;
+export const STREAM_SPEED_MAX = 5;
+export const DEFAULT_STREAM_SETTINGS: StreamSettings = { style: "smooth", speed: 3, caret: false };
+
+const KEY = {
+	style: "piweb.streamStyle",
+	speed: "piweb.streamSpeed",
+	caret: "piweb.streamCaret",
+} as const;
+
+/** 每帧间隔（约 60fps 起步）：档位越高越密 */
+const STEP_MS = [24, 20, 16, 12, 8];
+/** 平滑 / 渐显：每帧推进「积压 / 该值」，值越大追赶越缓、手感越匀（突发不再狂奔） */
+const SMOOTH_DIVISOR = [14, 10, 7, 5, 3];
+/** 平滑 / 渐显：每帧至少推进的字符数，保证收尾时也能走完 */
+const SMOOTH_MIN_CHARS = [1, 1, 1, 2, 3];
+/** 平滑 / 渐显：每帧至多推进的字符数——大块突发被摊到更多帧里缓缓出现，不会一口吞掉 */
+const SMOOTH_MAX_CHARS = [140, 110, 90, 70, 50];
+/** 打字机：每帧固定敲出的字符数 */
+const TYPEWRITER_CHARS = [1, 2, 3, 5, 8];
+/** 打字机也要有底线：积压超过约 1.5 秒的量就跟着加速，不出现「回答完了字还在爬」 */
+const TYPEWRITER_CATCHUP_DIVISOR = 90;
+
+export function isStreamStyle(value: string | null | undefined): value is StreamStyle {
+	return value === "smooth" || value === "instant" || value === "typewriter" || value === "fade";
+}
+
+export function clampStreamSpeed(value: number): number {
+	if (!Number.isFinite(value)) return DEFAULT_STREAM_SETTINGS.speed;
+	return Math.max(STREAM_SPEED_MIN, Math.min(STREAM_SPEED_MAX, Math.round(value)));
+}
+
+/** 这一档速度下每帧的间隔（毫秒） */
+export function streamStepMs(speed: number): number {
+	return STEP_MS[clampStreamSpeed(speed) - 1];
+}
+
+function readStored(): StreamSettings {
+	try {
+		const style = localStorage.getItem(KEY.style);
+		const speed = Number.parseInt(localStorage.getItem(KEY.speed) ?? "", 10);
+		const caret = localStorage.getItem(KEY.caret);
+		return {
+			style: isStreamStyle(style) ? style : DEFAULT_STREAM_SETTINGS.style,
+			speed: Number.isFinite(speed) ? clampStreamSpeed(speed) : DEFAULT_STREAM_SETTINGS.speed,
+			caret: caret === null ? DEFAULT_STREAM_SETTINGS.caret : caret === "1" || caret === "true",
+		};
+	} catch {
+		// 隐私模式 / localStorage 不可用：这一份内存偏好照样生效
+		return DEFAULT_STREAM_SETTINGS;
+	}
+}
+
+export function loadStreamSettings(): StreamSettings {
+	if (typeof window === "undefined") return DEFAULT_STREAM_SETTINGS;
+	return readStored();
+}
+
+function persist(settings: StreamSettings): void {
+	if (typeof window === "undefined") return;
+	try {
+		localStorage.setItem(KEY.style, settings.style);
+		localStorage.setItem(KEY.speed, String(settings.speed));
+		localStorage.setItem(KEY.caret, settings.caret ? "1" : "0");
+	} catch {
+		/* 配额满 / 被禁用：内存里已经生效 */
+	}
+}
+
+let cached: StreamSettings | null = null;
+const listeners = new Set<() => void>();
+let storageBound = false;
+
+/** useSyncExternalStore 的 getSnapshot：同一份引用，只有真改了才换（否则会无限重渲染） */
+export function getStreamSettings(): StreamSettings {
+	if (!cached) cached = loadStreamSettings();
+	return cached;
+}
+
+/** 服务端 / 水合首帧没有 localStorage，给默认值 */
+export function getServerStreamSettings(): StreamSettings {
+	return DEFAULT_STREAM_SETTINGS;
+}
+
+function bindStorage(): void {
+	if (storageBound || typeof window === "undefined") return;
+	storageBound = true;
+	window.addEventListener("storage", (event) => {
+		if (event.key !== null && event.key !== KEY.style && event.key !== KEY.speed && event.key !== KEY.caret) return;
+		cached = loadStreamSettings();
+		for (const listener of listeners) listener();
+	});
+}
+
+export function subscribeStreamSettings(listener: () => void): () => void {
+	listeners.add(listener);
+	bindStorage();
+	return () => {
+		listeners.delete(listener);
+	};
+}
+
+/** 改一项并持久化，返回合并后的完整偏好；正在流的回答下帧就用新值 */
+export function setStreamSettings(patch: Partial<StreamSettings>): StreamSettings {
+	const current = getStreamSettings();
+	const next: StreamSettings = {
+		style: isStreamStyle(patch.style) ? patch.style : current.style,
+		speed: patch.speed === undefined ? current.speed : clampStreamSpeed(patch.speed),
+		caret: patch.caret === undefined ? current.caret : patch.caret === true,
+	};
+	cached = next;
+	persist(next);
+	for (const listener of listeners) listener();
+	return next;
+}
+
+/**
+ * 不在 UTF-16 代理对中间切：切在中间会渲染成一个替换字符（半个 emoji）。
+ * 端点越界时按文本长度收口。
+ */
+export function safeSliceEnd(text: string, end: number): number {
+	if (end <= 0) return 0;
+	if (end >= text.length) return text.length;
+	const high = text.charCodeAt(end - 1);
+	const low = text.charCodeAt(end);
+	if (high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) return Math.min(end + 1, text.length);
+	return end;
+}
+
+/**
+ * 渐显：只在整词处停 —— 从 end 往回找到最近的分隔符，切在它后面；
+ * 这一段里没有分隔符（正在敲的词）就照常长，否则会停在原地走不完。
+ */
+function snapToWordEnd(target: string, from: number, end: number): number {
+	if (end >= target.length) return target.length;
+	for (let i = end - 1; i >= from; i -= 1) {
+		if (/\s/.test(target[i])) return i + 1;
+	}
+	return end;
+}
+
+/**
+ * 这一帧显示到哪个下标（返回值 = 目标文本前缀长度）。
+ * - instant：不排队，直接追平；
+ * - smooth：自适应 —— 积压越多推得越快，但每帧有上限：大块突发被摊到多帧缓缓出现；
+ * - typewriter：固定节奏逐字，但积压过大时跟着加速（上限约 1.5 秒的落后量）；
+ * - fade：在 smooth 的基础上按整词推进。
+ */
+export function nextRevealEnd(target: string, shownLength: number, settings: StreamSettings): number {
+	const total = target.length;
+	if (settings.style === "instant") return total;
+	const backlog = total - shownLength;
+	if (backlog <= 0) return total;
+	const level = clampStreamSpeed(settings.speed) - 1;
+	let end: number;
+	if (settings.style === "typewriter") {
+		end = shownLength + Math.max(TYPEWRITER_CHARS[level], Math.ceil(backlog / TYPEWRITER_CATCHUP_DIVISOR));
+	} else {
+		end = shownLength + Math.min(
+			SMOOTH_MAX_CHARS[level],
+			Math.max(SMOOTH_MIN_CHARS[level], Math.ceil(backlog / SMOOTH_DIVISOR[level])),
+		);
+	}
+	if (end > total) end = total;
+	if (settings.style === "fade") end = snapToWordEnd(target, shownLength, end);
+	return safeSliceEnd(target, end);
+}

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,6 +33,101 @@ 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;

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("@@ ") };
 }