@herbertgao/pi-extensions 2026.9.19 → 2026.10.0

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

@@ -0,0 +1,151 @@
+import { getLanguageFromPath, highlightCode } from "@earendil-works/pi-coding-agent";
+import { sanitizeAnsiForThemedOutput } from "./ansi-utils.ts";
+import { sanitizeToolResultText } from "../../../utils/tool-result-sanitize.ts";
+import { MAX_HL_CHARS, shikiHighlightCache } from "./shiki-highlight.ts";
+import { normalizeCodeWhitespace } from "./diff-text.ts";
+import {
+	applyInlineSpanHighlight,
+	getLineBackground,
+	resolveShikiTheme,
+	type DiffPalette,
+	type DiffTheme,
+} from "./diff-palette.ts";
+import type { DiffLineEntry, ParsedDiffEntry } from "./diff-parse.ts";
+import type { DiffSpan } from "./diff-inline.ts";
+
+export type CodeLineHighlighter = (line: string, entry: DiffLineEntry) => string;
+
+function cleanCodeLine(line: string): string {
+	return sanitizeToolResultText(line).replace(/\n/g, "");
+}
+
+export function shouldHighlightCodeBlock(code: string): boolean {
+	return code.length <= MAX_HL_CHARS;
+}
+
+export function resolveLanguageFromPath(rawPath: string | undefined): string | undefined {
+	if (!rawPath || !rawPath.trim()) {
+		return undefined;
+	}
+	const normalizedPath = rawPath.replace(/^@/, "").trim();
+	if (!normalizedPath) {
+		return undefined;
+	}
+	try {
+		return getLanguageFromPath(normalizedPath);
+	} catch {
+		return undefined;
+	}
+}
+
+export function createCodeLineHighlighter(
+	language: string | undefined,
+	theme: DiffTheme,
+	entries: readonly ParsedDiffEntry[],
+	invalidate?: () => void,
+): CodeLineHighlighter {
+	const codeEntries = entries.filter((entry): entry is DiffLineEntry => entry.kind === "line");
+	const cleanLines = codeEntries.map((entry) =>
+		cleanCodeLine(normalizeCodeWhitespace(entry.content)),
+	);
+	const code = cleanLines.join("\n");
+	const shouldHighlight = !!language && shouldHighlightCodeBlock(code);
+	const fallbackLines = shouldHighlight
+		? (() => {
+				try {
+					return highlightCode(code, language).map(sanitizeAnsiForThemedOutput);
+				} catch {
+					return cleanLines.map(sanitizeAnsiForThemedOutput);
+				}
+			})()
+		: cleanLines.map(sanitizeAnsiForThemedOutput);
+	const fallbackByEntry = new WeakMap(
+		codeEntries.map((entry, index) => [entry, fallbackLines[index] ?? cleanLines[index] ?? ""]),
+	);
+	if (!shouldHighlight) return (_line, entry) => fallbackByEntry.get(entry) ?? "";
+
+	const shikiTheme = resolveShikiTheme(theme);
+	let highlightedByEntry: WeakMap<DiffLineEntry, string> | undefined;
+	const resolveHighlighted = () => {
+		if (highlightedByEntry) return;
+		const highlighted = shikiHighlightCache.get(
+			code,
+			language,
+			shikiTheme,
+			fallbackLines,
+			invalidate,
+		);
+		if (highlighted) {
+			highlightedByEntry = new WeakMap(
+				codeEntries.map((entry, index) => [
+					entry,
+					sanitizeAnsiForThemedOutput(highlighted[index] ?? fallbackByEntry.get(entry) ?? ""),
+				]),
+			);
+		}
+	};
+	resolveHighlighted();
+	return (_line, entry) => {
+		resolveHighlighted();
+		return highlightedByEntry?.get(entry) ?? fallbackByEntry.get(entry) ?? "";
+	};
+}
+
+/**
+ * 通用代码块着色（codemode 的 `code` 字段等）：先用 pi 的同步 highlightCode 打底，
+ * 首帧就有颜色；再用 shiki 异步升级（与 diff 共用缓存与主题解析），落地后回调
+ * invalidate 重画。返回行数组，按源行一一对应；语言不识或未就绪时给打底结果。
+ */
+export function createCodeBlockHighlighter(
+	code: string,
+	language: string | undefined,
+	theme: DiffTheme,
+	invalidate?: () => void,
+): () => string[] {
+	const cleanCode = sanitizeToolResultText(code).replace(/\r/g, "");
+	const cleanLines = cleanCode.split("\n").map(cleanCodeLine);
+	if (!language || !shouldHighlightCodeBlock(cleanCode)) {
+		return () => cleanLines.map(sanitizeAnsiForThemedOutput);
+	}
+	let fallback: string[];
+	try {
+		fallback = highlightCode(cleanCode, language).map(sanitizeAnsiForThemedOutput);
+	} catch {
+		fallback = cleanLines.map(sanitizeAnsiForThemedOutput);
+	}
+	const shikiTheme = resolveShikiTheme(theme);
+	let highlighted: string[] | undefined;
+	const resolve = () => {
+		if (highlighted) return;
+		const result = shikiHighlightCache.get(cleanCode, language, shikiTheme, fallback, invalidate);
+		if (result) highlighted = result.map(sanitizeAnsiForThemedOutput);
+	};
+	resolve();
+	return () => {
+		resolve();
+		return highlighted ?? fallback;
+	};
+}
+
+export function highlightDiffLine(
+	codeText: string,
+	entry: DiffLineEntry,
+	inlineHighlights: WeakMap<DiffLineEntry, DiffSpan[]>,
+	palette: DiffPalette,
+	highlightLine: CodeLineHighlighter,
+	containerBgAnsi: string | undefined,
+): { highlighted: string; rowBg: string | undefined } {
+	const syntaxHighlighted = highlightLine(codeText, entry);
+	const rowBg = getLineBackground(entry.lineKind, palette, false);
+	const emphasisBg = getLineBackground(entry.lineKind, palette, true);
+	const inlineSpans = inlineHighlights.get(entry) ?? [];
+	const highlighted = applyInlineSpanHighlight(
+		codeText,
+		syntaxHighlighted,
+		inlineSpans,
+		emphasisBg,
+		rowBg,
+		containerBgAnsi,
+	);
+	return { highlighted, rowBg };
+}

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

@@ -0,0 +1,324 @@
+import { normalizeCodeWhitespace } from "./diff-text.ts";
+import type {
+	DiffLineEntry,
+	DiffMetaEntry,
+	DiffOmissionEntry,
+	ParsedDiffEntry,
+} from "./diff-parse.ts";
+
+export interface DiffSpan {
+	start: number;
+	end: number;
+}
+
+export interface SplitDiffRow {
+	left?: DiffLineEntry;
+	right?: DiffLineEntry;
+	omission?: DiffOmissionEntry;
+	meta?: DiffMetaEntry;
+	hunkIndex: number | null;
+}
+
+const MAX_INLINE_DIFF_LINE_LENGTH = 700;
+
+function tokenizeInlineDiff(input: string): Array<{ value: string; start: number; end: number }> {
+	if (!input) {
+		return [];
+	}
+
+	const tokens: Array<{ value: string; start: number; end: number }> = [];
+	const pattern = /(\s+|[A-Za-z0-9_]+|[^A-Za-z0-9_\s])/g;
+	let match: RegExpExecArray | null;
+
+	while ((match = pattern.exec(input)) !== null) {
+		const value = match[0] ?? "";
+		if (!value) {
+			continue;
+		}
+		tokens.push({
+			value,
+			start: match.index,
+			end: match.index + value.length,
+		});
+	}
+
+	if (tokens.length === 0 && input.length > 0) {
+		tokens.push({ value: input, start: 0, end: input.length });
+	}
+
+	return tokens;
+}
+
+export function mergeSpans(spans: DiffSpan[]): DiffSpan[] {
+	if (spans.length <= 1) {
+		return spans;
+	}
+
+	const sorted = [...spans].sort((a, b) => a.start - b.start);
+	const merged: DiffSpan[] = [sorted[0]];
+
+	for (let index = 1; index < sorted.length; index++) {
+		const current = sorted[index];
+		const previous = merged[merged.length - 1];
+		if (!current || !previous) {
+			continue;
+		}
+
+		if (current.start <= previous.end) {
+			previous.end = Math.max(previous.end, current.end);
+			continue;
+		}
+
+		merged.push({ ...current });
+	}
+
+	return merged;
+}
+
+function tokensToDiffSpans(
+	text: string,
+	tokens: Array<{ value: string; start: number; end: number }>,
+	changedIndexes: Set<number>,
+): DiffSpan[] {
+	if (tokens.length === 0 || changedIndexes.size === 0) {
+		return [];
+	}
+
+	const spans: DiffSpan[] = [];
+	let start: number | null = null;
+	let end = -1;
+
+	for (let index = 0; index < tokens.length; index++) {
+		if (!changedIndexes.has(index)) {
+			if (start !== null && end > start) {
+				spans.push({ start, end });
+				start = null;
+				end = -1;
+			}
+			continue;
+		}
+
+		const token = tokens[index];
+		if (!token) {
+			continue;
+		}
+
+		if (start === null) {
+			start = token.start;
+			end = token.end;
+		} else {
+			end = token.end;
+		}
+	}
+
+	if (start !== null && end > start) {
+		spans.push({ start, end });
+	}
+
+	const trimmed: DiffSpan[] = [];
+	for (const span of spans) {
+		let spanStart = span.start;
+		let spanEnd = span.end;
+
+		while (spanStart < spanEnd && /\s/.test(text[spanStart] ?? "")) {
+			spanStart++;
+		}
+		while (spanEnd > spanStart && /\s/.test(text[spanEnd - 1] ?? "")) {
+			spanEnd--;
+		}
+		if (spanEnd > spanStart) {
+			trimmed.push({ start: spanStart, end: spanEnd });
+		}
+	}
+
+	return mergeSpans(trimmed);
+}
+
+function computeInlineDiffSpans(
+	leftLine: string,
+	rightLine: string,
+): { left: DiffSpan[]; right: DiffSpan[] } {
+	if (leftLine === rightLine) {
+		return { left: [], right: [] };
+	}
+	if (
+		leftLine.length > MAX_INLINE_DIFF_LINE_LENGTH ||
+		rightLine.length > MAX_INLINE_DIFF_LINE_LENGTH
+	) {
+		return { left: [], right: [] };
+	}
+
+	const leftTokens = tokenizeInlineDiff(leftLine);
+	const rightTokens = tokenizeInlineDiff(rightLine);
+	const leftCount = leftTokens.length;
+	const rightCount = rightTokens.length;
+
+	if (leftCount === 0 || rightCount === 0) {
+		return {
+			left: leftLine.trim().length > 0 ? [{ start: 0, end: leftLine.length }] : [],
+			right: rightLine.trim().length > 0 ? [{ start: 0, end: rightLine.length }] : [],
+		};
+	}
+
+	const table: number[][] = Array.from({ length: leftCount + 1 }, () =>
+		Array<number>(rightCount + 1).fill(0),
+	);
+
+	for (let leftIndex = 1; leftIndex <= leftCount; leftIndex++) {
+		const leftToken = leftTokens[leftIndex - 1];
+		for (let rightIndex = 1; rightIndex <= rightCount; rightIndex++) {
+			const rightToken = rightTokens[rightIndex - 1];
+			if (leftToken?.value === rightToken?.value) {
+				table[leftIndex][rightIndex] = (table[leftIndex - 1]?.[rightIndex - 1] ?? 0) + 1;
+			} else {
+				const top = table[leftIndex - 1]?.[rightIndex] ?? 0;
+				const side = table[leftIndex]?.[rightIndex - 1] ?? 0;
+				table[leftIndex][rightIndex] = Math.max(top, side);
+			}
+		}
+	}
+
+	const changedLeft = new Set<number>();
+	const changedRight = new Set<number>();
+	let leftCursor = leftCount;
+	let rightCursor = rightCount;
+
+	while (leftCursor > 0 && rightCursor > 0) {
+		const leftToken = leftTokens[leftCursor - 1];
+		const rightToken = rightTokens[rightCursor - 1];
+		if (leftToken?.value === rightToken?.value) {
+			leftCursor--;
+			rightCursor--;
+			continue;
+		}
+
+		const top = table[leftCursor - 1]?.[rightCursor] ?? 0;
+		const side = table[leftCursor]?.[rightCursor - 1] ?? 0;
+		if (top >= side) {
+			changedLeft.add(leftCursor - 1);
+			leftCursor--;
+		} else {
+			changedRight.add(rightCursor - 1);
+			rightCursor--;
+		}
+	}
+
+	while (leftCursor > 0) {
+		changedLeft.add(leftCursor - 1);
+		leftCursor--;
+	}
+	while (rightCursor > 0) {
+		changedRight.add(rightCursor - 1);
+		rightCursor--;
+	}
+
+	return {
+		left: tokensToDiffSpans(leftLine, leftTokens, changedLeft),
+		right: tokensToDiffSpans(rightLine, rightTokens, changedRight),
+	};
+}
+
+function collectConsecutiveLineEntries(
+	entries: ParsedDiffEntry[],
+	startIndex: number,
+	lineKind: DiffLineEntry["lineKind"],
+): { collected: DiffLineEntry[]; nextIndex: number } {
+	const collected: DiffLineEntry[] = [];
+	let index = startIndex;
+	while (index < entries.length) {
+		const candidate = entries[index];
+		if (!candidate || candidate.kind !== "line" || candidate.lineKind !== lineKind) {
+			break;
+		}
+		collected.push(candidate);
+		index++;
+	}
+	return { collected, nextIndex: index };
+}
+
+export function buildSplitRows(entries: ParsedDiffEntry[]): SplitDiffRow[] {
+	const rows: SplitDiffRow[] = [];
+	let index = 0;
+
+	while (index < entries.length) {
+		const entry = entries[index];
+		if (!entry) {
+			break;
+		}
+
+		if (entry.kind === "omission") {
+			rows.push({ omission: entry, hunkIndex: entry.hunkIndex || null });
+			index++;
+			continue;
+		}
+
+		if (entry.kind !== "line") {
+			rows.push({ meta: entry, hunkIndex: entry.hunkIndex || null });
+			index++;
+			continue;
+		}
+
+		if (entry.lineKind === "remove") {
+			const removedResult = collectConsecutiveLineEntries(entries, index, "remove");
+			const removed = removedResult.collected;
+			const addedResult = collectConsecutiveLineEntries(entries, removedResult.nextIndex, "add");
+			const added = addedResult.collected;
+			index = addedResult.nextIndex;
+
+			const pairCount = Math.max(removed.length, added.length);
+			for (let pairIndex = 0; pairIndex < pairCount; pairIndex++) {
+				const left = removed[pairIndex];
+				const right = added[pairIndex];
+				rows.push({
+					left,
+					right,
+					hunkIndex: left?.hunkIndex ?? right?.hunkIndex ?? null,
+				});
+			}
+			continue;
+		}
+
+		if (entry.lineKind === "add") {
+			rows.push({ right: entry, hunkIndex: entry.hunkIndex || null });
+			index++;
+			continue;
+		}
+
+		rows.push({ left: entry, right: entry, hunkIndex: entry.hunkIndex || null });
+		index++;
+	}
+
+	return rows;
+}
+
+export function getCellLineNumber(line: DiffLineEntry, side: "left" | "right"): number | null {
+	if (side === "left") {
+		return line.oldLineNumber ?? (line.lineKind === "context" ? line.newLineNumber : null);
+	}
+	return line.newLineNumber ?? (line.lineKind === "context" ? line.oldLineNumber : null);
+}
+
+export function buildInlineHighlightMap(rows: SplitDiffRow[]): WeakMap<DiffLineEntry, DiffSpan[]> {
+	const highlights = new WeakMap<DiffLineEntry, DiffSpan[]>();
+
+	for (const row of rows) {
+		if (!row.left || !row.right) {
+			continue;
+		}
+		if (row.left.lineKind !== "remove" || row.right.lineKind !== "add") {
+			continue;
+		}
+
+		const leftText = normalizeCodeWhitespace(row.left.content);
+		const rightText = normalizeCodeWhitespace(row.right.content);
+		const inline = computeInlineDiffSpans(leftText, rightText);
+		if (inline.left.length > 0) {
+			highlights.set(row.left, inline.left);
+		}
+		if (inline.right.length > 0) {
+			highlights.set(row.right, inline.right);
+		}
+	}
+
+	return highlights;
+}