@herbertgao/pi-extensions 2026.9.19 → 2026.10.0

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/tool/diff/ansi-utils.ts

@@ -1,5 +1,4 @@
-const ANSI_SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
-const ANSI_SGR_WITH_COLON_PATTERN = /\x1b\[([0-9;:]*)m/g;
+const ANSI_SGR_PATTERN = /\x1b\[([0-9;:]*)m/g;
 const STYLE_RESET_PARAMS = [39, 22, 23, 24, 25, 27, 28, 29, 59] as const;
 
 export { ANSI_SGR_PATTERN, STYLE_RESET_PARAMS };
@@ -89,12 +88,35 @@ export function stripBackgroundSgrParams(params: readonly number[]): number[] {
 	return sanitized;
 }
 
+function isKeptColonSgr(token: string): boolean {
+	const parts = token.split(":");
+	if (parts[0] === "48") return false;
+	if (parts[0] !== "38") return true;
+	const channels =
+		parts[1] === "5" && parts.length === 3
+			? parts.slice(2)
+			: parts[1] === "2" && (parts.length === 5 || parts.length === 6)
+				? parts.slice(-3)
+				: undefined;
+	return !!channels?.every((c) => /^\d+$/.test(c) && Number(c) <= 255);
+}
+
 export function filterSgrSequences(text: string, filter: (params: number[]) => number[]): string {
 	if (!text || !text.includes("\x1b[")) {
 		return text;
 	}
 
 	return text.replace(ANSI_SGR_PATTERN, (_sequence, rawParams: string) => {
+		if (rawParams.includes(":")) {
+			// 冒号形式 (ISO 8613-6)：逐段处理；去掉 48:*，校验 38:*，其余原样保留
+			const kept = rawParams.split(";").flatMap((token) => {
+				if (!token.includes(":")) {
+					return token ? filter(toSgrParams(token)).map(String) : [];
+				}
+				return isKeptColonSgr(token) ? [token] : [];
+			});
+			return kept.length > 0 ? `\x1b[${kept.join(";")}m` : "";
+		}
 		const parsed = toSgrParams(rawParams);
 		if (parsed.length === 0) {
 			return "";
@@ -109,60 +131,6 @@ export function filterSgrSequences(text: string, filter: (params: number[]) => n
 	});
 }
 
-function isValidColonForeground(segment: string): boolean {
-	const params = segment.split(":");
-	const isByte = (value: string | undefined) =>
-		value !== undefined && /^\d+$/.test(value) && Number(value) <= 255;
-	if (params[0] !== "38") return false;
-	if (params[1] === "5") return params.length === 3 && isByte(params[2]);
-	return (
-		params[1] === "2" &&
-		params.length === 6 &&
-		(params[2] === "" || /^\d+$/.test(params[2] ?? "")) &&
-		params.slice(3).every(isByte)
-	);
-}
-
-function sanitizeColonSgr(rawParams: string): string {
-	const segments = rawParams.split(";");
-	const sanitized: string[] = [];
-	for (let index = 0; index < segments.length; index++) {
-		const segment = segments[index] ?? "";
-		if (segment.includes(":")) {
-			const code = Number.parseInt(segment, 10);
-			if (code !== 48 && (code !== 38 || isValidColonForeground(segment))) {
-				sanitized.push(segment);
-			}
-			continue;
-		}
-		const param = Number.parseInt(segment, 10);
-		if (!Number.isFinite(param)) continue;
-		if (param === 0) {
-			sanitized.push(...STYLE_RESET_PARAMS.map(String));
-			continue;
-		}
-		if (param === 49 || (param >= 40 && param <= 47) || (param >= 100 && param <= 107)) {
-			continue;
-		}
-		if (param === 38 || param === 48) {
-			const mode = Number.parseInt(segments[index + 1] ?? "", 10);
-			const advance = mode === 5 ? 2 : mode === 2 ? 4 : 0;
-			if (advance > 0) {
-				if (param === 38) sanitized.push(...segments.slice(index, index + advance + 1));
-				index += advance;
-				continue;
-			}
-		}
-		sanitized.push(segment);
-	}
-	return sanitized.length > 0 ? `\x1b[${sanitized.join(";")}m` : "";
-}
-
 export function sanitizeAnsiForThemedOutput(text: string): string {
-	if (!text || !text.includes("\x1b[")) return text;
-	return text.replace(ANSI_SGR_WITH_COLON_PATTERN, (sequence, rawParams: string) =>
-		rawParams.includes(":")
-			? sanitizeColonSgr(rawParams)
-			: filterSgrSequences(sequence, stripBackgroundSgrParams),
-	);
+	return filterSgrSequences(text, stripBackgroundSgrParams);
 }

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/tool/diff/diff-component.ts

@@ -0,0 +1,125 @@
+import {
+	DEFAULT_TOOL_DISPLAY_CONFIG,
+	type DiffIndicatorMode,
+	type ToolDisplayConfig,
+} from "../../../config/config.ts";
+import { stripTerminalSequencesPreservingLayout } from "../../../utils/ansi-text.ts";
+import { RICH_DIFF_COMPONENT } from "../../../utils/patch-keys.ts";
+import type { DiffPresentationMode } from "./diff-presentation.ts";
+export { RICH_DIFF_COMPONENT };
+
+/** Snapshot or live getter — panel changes must apply on the next paint. */
+export type DisplayConfigInput = ToolDisplayConfig | (() => ToolDisplayConfig);
+
+export interface DiffRenderOptions {
+	expanded: boolean;
+	filePath?: string;
+	previousContent?: string;
+	fileExistedBeforeWrite?: boolean;
+	headerLabel?: string;
+	/** Live hover state for the collapsed hint row (muted → text on hover). */
+	isHovered?: () => boolean;
+	invalidate?: () => void;
+}
+
+export function isRichDiffComponent(value: unknown): boolean {
+	return Boolean(
+		value &&
+			typeof value === "object" &&
+			(value as Record<symbol, unknown>)[RICH_DIFF_COMPONENT] === true,
+	);
+}
+
+export function resolveLiveDisplayConfig(input: DisplayConfigInput): ToolDisplayConfig {
+	return typeof input === "function" ? input() : input;
+}
+
+/**
+ * 比对用归一化：ANSI、缩进前缀和右侧填充不影响判断。
+ * 折叠态 remainder 行里有任意正文，入口必须先由组件声明再比对文本。
+ */
+export function normalizeCollapsedHintLine(line: string | undefined): string | undefined {
+	if (line === undefined) return undefined;
+	return stripTerminalSequencesPreservingLayout(line).replace(/\s+/g, " ").trim();
+}
+
+/** Cache key fragment so indicator/wrap/limits invalidate without host recreate. */
+export function displayConfigCacheKey(config: ToolDisplayConfig): string {
+	return [
+		config.diffViewMode,
+		config.diffIndicatorMode,
+		String(config.diffSplitMinWidth),
+		String(config.editDiffCollapsedLines),
+		String(config.writeDiffCollapsedLines),
+		config.diffWordWrap ? "1" : "0",
+	].join(":");
+}
+
+export function resolveDiffIndicatorMode(
+	config: Partial<Pick<ToolDisplayConfig, "diffIndicatorMode">>,
+): DiffIndicatorMode {
+	return config.diffIndicatorMode ?? DEFAULT_TOOL_DISPLAY_CONFIG.diffIndicatorMode;
+}
+
+export function createDiffRenderCache() {
+	let cachedWidth: number | undefined;
+	let cachedExpanded: boolean | undefined;
+	let cachedMode: DiffPresentationMode | undefined;
+	let cachedConfigKey: string | undefined;
+	let cachedHovered: boolean | undefined;
+	let cachedLines: string[] | undefined;
+	/** 与 cachedLines 同一次渲染的折叠态 remainder 行文本。 */
+	let cachedHintLine: string | undefined;
+
+	return {
+		get(
+			width: number,
+			expanded: boolean,
+			mode: DiffPresentationMode,
+			configKey: string,
+			hovered: boolean,
+		): string[] | undefined {
+			if (
+				cachedLines &&
+				cachedWidth === width &&
+				cachedExpanded === expanded &&
+				cachedMode === mode &&
+				cachedConfigKey === configKey &&
+				cachedHovered === hovered
+			) {
+				return cachedLines;
+			}
+			return undefined;
+		},
+		getHintLine(): string | undefined {
+			return cachedHintLine;
+		},
+		set(
+			width: number,
+			expanded: boolean,
+			mode: DiffPresentationMode,
+			configKey: string,
+			hovered: boolean,
+			lines: string[],
+			hintLine?: string,
+		): string[] {
+			cachedWidth = width;
+			cachedExpanded = expanded;
+			cachedMode = mode;
+			cachedConfigKey = configKey;
+			cachedHovered = hovered;
+			cachedLines = lines;
+			cachedHintLine = hintLine;
+			return lines;
+		},
+		invalidate(): void {
+			cachedWidth = undefined;
+			cachedExpanded = undefined;
+			cachedMode = undefined;
+			cachedConfigKey = undefined;
+			cachedHovered = undefined;
+			cachedLines = undefined;
+			cachedHintLine = undefined;
+		},
+	};
+}

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/tool/diff/diff-edit-render.ts

@@ -0,0 +1,227 @@
+import { Text, type Component } from "@earendil-works/pi-tui";
+import type { EditToolDetails } from "@earendil-works/pi-coding-agent";
+import { sanitizeToolResultText } from "../../../utils/tool-result-sanitize.ts";
+import {
+	getLineNumberWidth,
+	parseDiff,
+	type ParsedDiff,
+	type ParsedDiffEntry,
+} from "./diff-parse.ts";
+import { buildInlineHighlightMap, buildSplitRows } from "./diff-inline.ts";
+import { resolveDiffPalette, type DiffTheme } from "./diff-palette.ts";
+import { createCodeLineHighlighter, resolveLanguageFromPath } from "./diff-highlight.ts";
+import {
+	canRenderSplitLayout,
+	renderCompact,
+	renderSplit,
+	renderUnified,
+	type DiffRenderContext,
+} from "./diff-layout.ts";
+import { renderDiffFrameLine, renderHeaderRows, renderSingleDiffRow } from "./diff-header.ts";
+import {
+	applyLineLimit,
+	clampDiffLinesToWidth,
+	resolveDiffDisplayLimit,
+	resolveDiffProcessBudget,
+	takeEntriesForLineBudget,
+	takeSplitRowsForBudget,
+} from "./diff-limits.ts";
+import {
+	RICH_DIFF_COMPONENT,
+	createDiffRenderCache,
+	displayConfigCacheKey,
+	resolveDiffIndicatorMode,
+	resolveLiveDisplayConfig,
+	normalizeCollapsedHintLine,
+	type DiffRenderOptions,
+	type DisplayConfigInput,
+} from "./diff-component.ts";
+import {
+	buildDiffSummaryText,
+	normalizeDiffRenderWidth,
+	resolveDiffPresentationMode,
+} from "./diff-presentation.ts";
+
+function safeGetDiff(details: unknown): string {
+	if (!details || typeof details !== "object") {
+		return "";
+	}
+	const typed = details as Partial<EditToolDetails>;
+	return typeof typed.diff === "string" ? typed.diff : "";
+}
+
+// Pi appends an omission marker after final context to say the file continues.
+// It does not separate visible diff regions, so keep only omissions before a rendered line.
+function omitTerminalOmissions(entries: ParsedDiffEntry[]): ParsedDiffEntry[] {
+	let lastLineIndex = -1;
+	for (let index = entries.length - 1; index >= 0; index--) {
+		if (entries[index]?.kind === "line") {
+			lastLineIndex = index;
+			break;
+		}
+	}
+
+	return entries.filter((entry, index) => entry.kind !== "omission" || index < lastLineIndex);
+}
+
+/**
+ * edit 变更行统计（compact 单行 `(+A -D)` 用）：复用现有 parser，diff 文件头不计入。
+ * 无 diff 或解析失败时返回 undefined，不把未知状态误报为零变更。
+ */
+export function countEditDiffStats(
+	details: unknown,
+): { added: number; removed: number } | undefined {
+	const diffText = sanitizeToolResultText(safeGetDiff(details));
+	if (!diffText.trim()) return undefined;
+	try {
+		const parsed = parseDiff(diffText);
+		return { added: parsed.stats.added, removed: parsed.stats.removed };
+	} catch {
+		return undefined;
+	}
+}
+
+export function renderEditDiffResult(
+	details: unknown,
+	options: DiffRenderOptions,
+	config: DisplayConfigInput,
+	theme: DiffTheme,
+	fallbackText: string,
+): Component {
+	const diffText = sanitizeToolResultText(safeGetDiff(details));
+	const safeFallbackText = sanitizeToolResultText(fallbackText);
+	if (!diffText.trim()) {
+		if (!safeFallbackText.trim()) {
+			return new Text(theme.fg("muted", "↳ edit completed (no diff payload)"), 0, 0);
+		}
+		return new Text(theme.fg("toolOutput", safeFallbackText), 0, 0);
+	}
+
+	let parsed: ParsedDiff;
+	try {
+		parsed = parseDiff(diffText);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return new Text(theme.fg("warning", `↳ unable to render diff: ${message}`), 0, 0);
+	}
+
+	const renderEntries = omitTerminalOmissions(parsed.entries);
+	if (renderEntries.length === 0) {
+		return new Text(theme.fg("muted", "↳ no diff data"), 0, 0);
+	}
+
+	const splitRows = buildSplitRows(renderEntries);
+	const showHashlineAnchors =
+		options.expanded === true &&
+		renderEntries.some((entry) => entry.kind === "line" && !!entry.hashlineAnchorContent);
+	const lineNumberWidth = getLineNumberWidth(renderEntries, showHashlineAnchors);
+	const palette = resolveDiffPalette(theme);
+	// Rich diffs use ccstyle's self shell. Keep the panel transparent so the
+	// separator cannot leak toolSuccessBg across the entire new column.
+	const containerBgAnsi = undefined;
+	const language = resolveLanguageFromPath(options.filePath);
+	const cache = createDiffRenderCache();
+	const highlightLine = createCodeLineHighlighter(language, theme, renderEntries, () => {
+		cache.invalidate();
+		options.invalidate?.();
+	});
+
+	return {
+		[RICH_DIFF_COMPONENT]: true,
+		/** 鼠标层只在真正的 remainder 行上提供展开入口。 */
+		isCollapsedHintLine(plainLine: string): boolean {
+			const hint = cache.getHintLine();
+			return hint !== undefined && normalizeCollapsedHintLine(plainLine) === hint;
+		},
+		render(width: number): string[] {
+			// Live config: panel can change indicator/wrap/limits after this component is created.
+			const live = resolveLiveDisplayConfig(config);
+			const wordWrap = live.diffWordWrap;
+			const indicatorMode = resolveDiffIndicatorMode(live);
+			const configKey = displayConfigCacheKey(live);
+			const safeWidth = normalizeDiffRenderWidth(width);
+			const mode = resolveDiffPresentationMode(live, safeWidth, canRenderSplitLayout(safeWidth));
+			const hovered = options.isHovered?.() ?? false;
+			const cached = cache.get(safeWidth, options.expanded, mode, configKey, hovered);
+			if (cached) {
+				return cached;
+			}
+
+			if (mode === "summary") {
+				return cache.set(
+					safeWidth,
+					options.expanded,
+					mode,
+					configKey,
+					hovered,
+					clampDiffLinesToWidth(
+						renderSingleDiffRow(
+							buildDiffSummaryText(parsed.stats, safeWidth),
+							"toolOutput",
+							safeWidth,
+							theme,
+						),
+						safeWidth,
+					),
+				);
+			}
+
+			const headerRows = renderHeaderRows(parsed.stats, mode, safeWidth, theme);
+			const displayLimit = resolveDiffDisplayLimit(options.expanded, live.editDiffCollapsedLines);
+			const processBudget = resolveDiffProcessBudget(displayLimit, wordWrap);
+			// Only highlight/render a prefix that can fill the display limit; full-diff
+			// LCS + syntax highlight on thousands of hidden lines is pure waste when collapsed.
+			const entryBudget = takeEntriesForLineBudget(renderEntries, processBudget);
+			const splitBudget = takeSplitRowsForBudget(splitRows, processBudget);
+			const inlineHighlights = buildInlineHighlightMap(splitBudget.rows);
+			const renderCtx: DiffRenderContext = {
+				width: safeWidth,
+				theme,
+				inlineHighlights,
+				palette,
+				highlightLine,
+				containerBgAnsi,
+				wordWrap,
+				indicatorMode,
+				showHashlineAnchors,
+			};
+			const bodyRows =
+				mode === "split"
+					? renderSplit(splitBudget.rows, renderCtx, lineNumberWidth)
+					: mode === "compact"
+						? renderCompact(entryBudget.entries, renderCtx)
+						: renderUnified(entryBudget.entries, renderCtx, lineNumberWidth);
+			const unprocessedLogicalRows =
+				mode === "split"
+					? Math.max(0, splitBudget.totalRows - splitBudget.processedRows)
+					: Math.max(0, entryBudget.totalLineEntries - entryBudget.processedLineEntries);
+			const bodyWithLimit = applyLineLimit(
+				bodyRows,
+				safeWidth,
+				options.expanded,
+				live.editDiffCollapsedLines,
+				parsed.stats.hunks,
+				theme,
+				unprocessedLogicalRows,
+				hovered,
+			);
+			const frame = renderDiffFrameLine(safeWidth, theme);
+			const renderedLines =
+				mode === "unified"
+					? [...headerRows.map((row) => row.text), frame, ...bodyWithLimit.lines, frame]
+					: [...headerRows.map((row) => row.text), ...bodyWithLimit.lines];
+
+			const clampedLines = clampDiffLinesToWidth(renderedLines, safeWidth);
+			return cache.set(
+				safeWidth,
+				options.expanded,
+				mode,
+				configKey,
+				hovered,
+				clampedLines,
+				normalizeCollapsedHintLine(bodyWithLimit.hintLine),
+			);
+		},
+		invalidate: cache.invalidate,
+	} as Component;
+}

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/tool/diff/diff-header.ts

@@ -0,0 +1,136 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { sanitizeAnsiForThemedOutput } from "./ansi-utils.ts";
+import { normalizeCodeWhitespace, wrapToWidth } from "./diff-text.ts";
+import { emphasis, stabilizeBackgroundResets, type DiffTheme } from "./diff-palette.ts";
+import { clampDiffLineToWidth } from "./diff-limits.ts";
+import type { DiffMetaEntry, DiffStats } from "./diff-parse.ts";
+import type { DiffPresentationMode } from "./diff-presentation.ts";
+import type { RenderedRow } from "./diff-layout.ts";
+
+export function formatMetaEntryRows(
+	entry: DiffMetaEntry,
+	width: number,
+	theme: DiffTheme,
+	wordWrap: boolean,
+): RenderedRow[] {
+	const normalized = sanitizeAnsiForThemedOutput(normalizeCodeWhitespace(entry.raw));
+	const lines = wordWrap
+		? wrapToWidth(normalized, width, true)
+		: [truncateToWidth(normalized, width)];
+
+	const mapColor = (line: string): string => {
+		if (entry.kind === "hunk") {
+			return stabilizeBackgroundResets(theme.fg("accent", line));
+		}
+		if (entry.kind === "file") {
+			return stabilizeBackgroundResets(theme.fg("muted", line));
+		}
+		return stabilizeBackgroundResets(theme.fg("toolDiffContext", line));
+	};
+
+	return lines.map((line) => ({
+		text: mapColor(line),
+		hunkIndex: entry.kind === "file" ? null : entry.hunkIndex || null,
+	}));
+}
+
+function renderDiffStatBar(stats: DiffStats, width: number, theme: DiffTheme): string | null {
+	const totalChanges = stats.added + stats.removed;
+	if (totalChanges === 0 || width < 20) {
+		return null;
+	}
+
+	const barSlots = Math.max(8, Math.min(24, Math.floor(width / 12)));
+	let addedSlots = Math.max(
+		0,
+		Math.min(barSlots, Math.round((stats.added / totalChanges) * barSlots)),
+	);
+	if (stats.added > 0 && addedSlots === 0) {
+		addedSlots = 1;
+	}
+	if (stats.removed > 0 && addedSlots >= barSlots) {
+		addedSlots = barSlots - 1;
+	}
+	const removedSlots = Math.max(0, barSlots - addedSlots);
+
+	const addedBar = addedSlots > 0 ? theme.fg("toolDiffAdded", "━".repeat(addedSlots)) : "";
+	const removedBar = removedSlots > 0 ? theme.fg("toolDiffRemoved", "━".repeat(removedSlots)) : "";
+	return stabilizeBackgroundResets(
+		`${theme.fg("dim", "[")}${addedBar}${removedBar}${theme.fg("dim", "]")}`,
+	);
+}
+
+function buildDiffSummaryBasePieces(stats: DiffStats, theme: DiffTheme): string[] {
+	return [
+		theme.fg("toolOutput", `↳ ${emphasis(theme, "diff")}`),
+		theme.fg("toolDiffAdded", `+${stats.added}`),
+		theme.fg("toolDiffRemoved", `-${stats.removed}`),
+	];
+}
+
+export function renderHeaderRows(
+	stats: DiffStats,
+	mode: Exclude<DiffPresentationMode, "summary">,
+	width: number,
+	theme: DiffTheme,
+): RenderedRow[] {
+	if (mode === "compact") {
+		const summary = buildDiffSummaryBasePieces(stats, theme).join(" ");
+		return [{ text: stabilizeBackgroundResets(truncateToWidth(summary, width)), hunkIndex: null }];
+	}
+
+	const summaryPieces = [...buildDiffSummaryBasePieces(stats, theme), theme.fg("muted", mode)];
+
+	const summary = summaryPieces.join(mode === "split" ? " " : theme.fg("muted", " · "));
+	const meter = renderDiffStatBar(stats, width, theme);
+	if (!meter) {
+		return [{ text: stabilizeBackgroundResets(truncateToWidth(summary, width)), hunkIndex: null }];
+	}
+
+	const meterSeparator = " ";
+	const meterWidth = visibleWidth(meterSeparator) + visibleWidth(meter);
+	if (meterWidth >= width) {
+		return [{ text: stabilizeBackgroundResets(truncateToWidth(summary, width)), hunkIndex: null }];
+	}
+
+	const summaryWidth = Math.max(0, width - meterWidth);
+	const fittedSummary = truncateToWidth(summary, summaryWidth);
+	return [
+		{
+			text: stabilizeBackgroundResets(`${fittedSummary}${meterSeparator}${meter}`),
+			hunkIndex: null,
+		},
+	];
+}
+
+export function renderDiffFrameLine(width: number, theme: DiffTheme): string {
+	const frameWidth = Math.max(0, width);
+	if (frameWidth === 0) {
+		return "";
+	}
+	return stabilizeBackgroundResets(theme.fg("dim", "─".repeat(frameWidth)));
+}
+
+export function renderSingleDiffRow(
+	text: string,
+	color: string,
+	width: number,
+	theme: DiffTheme,
+): string[] {
+	if (width <= 0) {
+		return [""];
+	}
+	return [clampDiffLineToWidth(stabilizeBackgroundResets(theme.fg(color, text)), width)];
+}
+
+export function renderWriteHeader(
+	wasOverwrite: boolean,
+	width: number,
+	theme: DiffTheme,
+	headerLabel?: string,
+): string {
+	const actionLabel = headerLabel?.trim() || (wasOverwrite ? "overwritten" : "created");
+	return stabilizeBackgroundResets(
+		truncateToWidth(theme.fg("toolOutput", `↳ ${emphasis(theme, actionLabel)}`), width),
+	);
+}