@kr78/pi-coding-agent 17.2.10

package/src/tools/render-utils.ts

@@ -0,0 +1,926 @@
+/**
+ * Shared utilities and constants for tool renderers.
+ *
+ * Provides consistent formatting, truncation, and display patterns across all
+ * tool renderers to ensure a unified TUI experience.
+ */
+
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
+import type { Ellipsis } from "@oh-my-pi/pi-natives";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { getKeybindings, replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
+import { pluralize } from "@oh-my-pi/pi-utils";
+import { formatKeyHints, type KeyId } from "../config/keybindings";
+import { isSettingsInitialized, settings } from "../config/settings";
+import { getDefault } from "../config/settings-schema";
+import type { Theme } from "../modes/theme/theme";
+import { Hasher } from "../tui/utils";
+import { formatDimensionNote, type ResizedImage } from "../utils/image-resize";
+
+export { Ellipsis } from "@oh-my-pi/pi-natives";
+export { replaceTabs, truncateToWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
+
+// =============================================================================
+// Standardized Display Constants
+// =============================================================================
+
+/** Resolve inline image dimension caps from settings and viewport. */
+export function resolveImageOptions(): { maxWidthCells: number; maxHeightCells?: number } {
+	const activeSettings = isSettingsInitialized() ? settings : undefined;
+	const maxWidthCells = activeSettings?.get("tui.maxInlineImageColumns") ?? getDefault("tui.maxInlineImageColumns");
+	const rowSetting = Math.max(
+		0,
+		activeSettings?.get("tui.maxInlineImageRows") ?? getDefault("tui.maxInlineImageRows"),
+	);
+	const viewportRows = process.stdout.rows;
+	const viewportFraction = viewportRows ? Math.floor(viewportRows * 0.6) : 0;
+	let maxHeightCells: number | undefined;
+	if (rowSetting === 0) {
+		// No explicit cap — use viewport fraction as safety bound
+		maxHeightCells = viewportFraction || undefined;
+	} else if (viewportFraction > 0) {
+		maxHeightCells = Math.min(rowSetting, viewportFraction);
+	} else {
+		// Viewport size unknown (transitional state) — honor explicit setting
+		maxHeightCells = rowSetting;
+	}
+	return { maxWidthCells, maxHeightCells };
+}
+
+/** Preview limits for collapsed/expanded views */
+export const PREVIEW_LIMITS = {
+	/** Lines shown in collapsed view */
+	COLLAPSED_LINES: 3,
+	/** Lines shown in expanded view */
+	EXPANDED_LINES: 12,
+	/** Items (files, results) shown in collapsed view */
+	COLLAPSED_ITEMS: 8,
+	/** Output preview lines in collapsed view */
+	OUTPUT_COLLAPSED: 3,
+	/** Output preview lines in expanded view */
+	OUTPUT_EXPANDED: 10,
+	/** Computer script lines shown in collapsed view */
+	COMPUTER_CODE_COLLAPSED: 10,
+	/** Max hunks shown when collapsed (edit tool) */
+	DIFF_COLLAPSED_HUNKS: 8,
+	/** Max diff lines shown when collapsed (edit tool) */
+	DIFF_COLLAPSED_LINES: 40,
+} as const;
+
+/** Default number of terminal output rows shown before expansion. */
+export const DEFAULT_TERMINAL_PREVIEW_LINES = 10;
+
+/** Truncation lengths for different content types */
+export const TRUNCATE_LENGTHS = {
+	/** Short titles, labels */
+	TITLE: 60,
+	/** Medium-length content (messages, previews) */
+	CONTENT: 80,
+	/** Longer content (code, explanations) */
+	LONG: 100,
+	/** Full line content */
+	LINE: 110,
+	/** Very short (task previews, badges) */
+	SHORT: 40,
+	/** Idle recap status line (~40-word LLM reply) */
+	RECAP: 280,
+} as const;
+
+/** Keybinding action that toggles tool-output expansion. */
+const EXPAND_ACTION = "app.tools.expand";
+/** Fallback key when no binding is resolvable (e.g. outside an interactive session). */
+const DEFAULT_EXPAND_KEY: KeyId = "ctrl+o";
+
+/** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
+export function expandKeyHint(): string {
+	const keys = getKeybindings().getKeys(EXPAND_ACTION);
+	return formatKeyHints(keys.length > 0 ? keys : [DEFAULT_EXPAND_KEY]);
+}
+
+// =============================================================================
+// Text Truncation Utilities
+// =============================================================================
+
+/**
+ * Get first N lines of text as preview, with each line truncated.
+ */
+export function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[] {
+	const lines = text.split("\n").filter(l => l.trim());
+	return lines.slice(0, maxLines).map(l => truncateToWidth(l.trim(), maxLineLen, ellipsis));
+}
+
+/**
+ * Collapse a possibly multi-line string into a single line, then truncate it to
+ * `maxWidth` display cells. {@link truncateToWidth} alone caps width but
+ * newlines are zero-width, so multi-line content (markdown briefs, tool args,
+ * provider errors) would otherwise spill a single status row across several
+ * visual lines. Whitespace runs collapse to one space, so tabs are handled too.
+ */
+export function previewLine(text: string, maxWidth: number, ellipsis?: Ellipsis): string {
+	return truncateToWidth(text.replace(/\s+/g, " ").trim(), maxWidth, ellipsis);
+}
+
+// =============================================================================
+// URL Utilities
+// =============================================================================
+
+/**
+ * Extract domain from URL, stripping www. prefix.
+ */
+export function getDomain(url: string): string {
+	try {
+		const u = new URL(url);
+		return u.hostname.replace(/^www\./, "");
+	} catch {
+		return url;
+	}
+}
+
+// =============================================================================
+// Formatting Utilities
+// =============================================================================
+
+export { formatAge, formatBytes, formatCount, formatDuration, pluralize } from "@oh-my-pi/pi-utils";
+
+// =============================================================================
+// Theme Helper Utilities
+// =============================================================================
+
+/**
+ * Get the appropriate status icon with color for a given state.
+ * Standardizes status icon usage across all renderers.
+ */
+export function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFrame?: number): string {
+	switch (status) {
+		case "success":
+			return theme.styledSymbol("status.success", "success");
+		case "done":
+			return theme.styledSymbol("status.done", "success");
+		case "error":
+			return theme.styledSymbol("status.error", "error");
+		case "warning":
+			return theme.styledSymbol("status.warning", "warning");
+		case "info":
+			return theme.styledSymbol("status.info", "accent");
+		case "pending":
+			return theme.styledSymbol("status.pending", "muted");
+		case "running":
+			if (spinnerFrame !== undefined) {
+				const frames = theme.spinnerFrames;
+				return frames[spinnerFrame % frames.length];
+			}
+			return theme.styledSymbol("status.running", "accent");
+		case "aborted":
+			return theme.styledSymbol("status.aborted", "error");
+	}
+}
+
+/**
+ * Format the expand hint with proper theming.
+ * Returns empty string if already expanded or there is nothing more to show.
+ */
+export function formatExpandHint(theme: Theme, expanded?: boolean, hasMore?: boolean): string {
+	if (expanded) return "";
+	if (hasMore === false) return "";
+	return theme.fg("dim", wrapBrackets(`${expandKeyHint()}: Expand`, theme));
+}
+
+/**
+ * Format a badge like [done] or [failed] with brackets and color.
+ */
+export function formatBadge(label: string, color: ToolUIColor, theme: Theme): string {
+	const left = theme.format.bracketLeft;
+	const right = theme.format.bracketRight;
+	return theme.fg(color, `${left}${label}${right}`);
+}
+
+/**
+ * Build a "more items" suffix line for truncated lists.
+ * Uses consistent wording pattern.
+ */
+export function formatMoreItems(remaining: number, itemType: string): string {
+	const safeRemaining = Number.isFinite(remaining) ? remaining : 0;
+	return `… ${safeRemaining} more ${pluralize(itemType, safeRemaining)}`;
+}
+
+/**
+ * Collapsed command/code previews render a tail window sized from the live
+ * viewport: terminal rows minus a reserve for the rest of the block (frame,
+ * Output section, stats line) and the editor/status area below the
+ * transcript. This keeps a volatile streaming block from growing past the
+ * viewport and stranding its top, while letting tall terminals show more.
+ */
+const PREVIEW_WINDOW_RESERVED_ROWS = 20;
+/** Floor so tiny or unknown viewports still show a useful window. */
+const PREVIEW_WINDOW_MIN_LINES = 6;
+/** Assumed viewport when rows are unknown (non-TTY, tests). */
+const PREVIEW_WINDOW_FALLBACK_ROWS = 30;
+
+/** Tail-window height for collapsed command/code previews. */
+export function previewWindowRows(): number {
+	const rows = process.stdout.rows || PREVIEW_WINDOW_FALLBACK_ROWS;
+	return Math.max(PREVIEW_WINDOW_MIN_LINES, rows - PREVIEW_WINDOW_RESERVED_ROWS);
+}
+
+/**
+ * Cap a pre-rendered command preview to a viewport-sized tail window: the end
+ * of the command stays visible (it is the live edge while args stream) behind
+ * an "… N earlier lines" marker on top. The same window applies while
+ * streaming and after completion so the block never jumps; only `expanded`
+ * (ctrl+o) uncaps it.
+ *
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the marker line so
+ * nested previews stay aligned. `expandHint: false` drops the "ctrl+o: Expand"
+ * suffix for callers that cap even inside the expanded view (task recent
+ * output), where the hint would point the wrong way.
+ */
+export function capPreviewLines(
+	lines: string[],
+	theme: Theme,
+	options: { max?: number; expanded?: boolean; prefix?: string; expandHint?: boolean } = {},
+): string[] {
+	if (options.expanded) return lines;
+	const max = options.max ?? previewWindowRows();
+	if (lines.length <= max) return lines;
+	const visible = max <= 1 ? [] : lines.slice(lines.length - (max - 1));
+	const hidden = lines.length - visible.length;
+	const hint = options.expandHint === false ? "" : formatExpandHint(theme, false, true);
+	const marker = `… ${hidden} earlier ${pluralize("line", hidden)}${hint ? ` ${hint}` : ""}`;
+	return [`${options.prefix ?? ""}${theme.fg("dim", marker)}`, ...visible];
+}
+
+export function formatMeta(meta: string[], theme: Theme): string {
+	return meta.length > 0 ? ` ${theme.fg("muted", meta.join(theme.sep.dot))}` : "";
+}
+
+function sanitizeErrorText(message: string | undefined): string {
+	const clean = (message ?? "").replace(/^Error:\s*/, "").trim();
+	return clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
+}
+
+export function formatErrorMessage(message: string | undefined, theme: Theme): string {
+	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${sanitizeErrorText(message)}`)}`;
+}
+
+/**
+ * Error message rendered as a subordinate detail line beneath a status header
+ * that already carries the error icon (e.g. `✘ Write: <path>`). The header's
+ * icon already signals failure, so this omits the redundant error symbol and
+ * "Error:" prefix that `formatErrorMessage` adds for standalone single-line
+ * errors, indenting two columns to sit under the header title instead.
+ */
+export function formatErrorDetail(message: string | undefined, theme: Theme): string {
+	return `  ${theme.fg("error", sanitizeErrorText(message))}`;
+}
+
+export function formatEmptyMessage(message: string, theme: Theme): string {
+	return `${theme.styledSymbol("status.warning", "warning")} ${theme.fg("muted", message)}`;
+}
+
+// =============================================================================
+// Code Frame Formatting
+// =============================================================================
+
+export type CodeFrameMarker = "" | " " | "*" | "+" | "-" | ">";
+
+export function formatCodeFrameLine(
+	marker: CodeFrameMarker,
+	lineNumber: string | number,
+	content: string,
+	lineNumberWidth: number,
+): string {
+	const markerText = marker.trim();
+	const lineNumberText = String(lineNumber).trim();
+	const gutterText = markerText && lineNumberText ? `${markerText}${lineNumberText}` : lineNumberText || markerText;
+	return `${gutterText.padStart(lineNumberWidth + 1, " ")}│${content}`;
+}
+
+// =============================================================================
+// Tool UI Helpers
+// =============================================================================
+
+export type ToolUIStatus = "success" | "done" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
+export type ToolUIColor = "success" | "error" | "warning" | "accent" | "muted";
+
+export interface ToolUITitleOptions {
+	bold?: boolean;
+}
+
+export function formatTitle(label: string, theme: Theme, options?: ToolUITitleOptions): string {
+	const content = options?.bold === false ? label : theme.bold(label);
+	return theme.fg("toolTitle", content);
+}
+
+// =============================================================================
+// Diagnostic Formatting
+// =============================================================================
+
+interface ParsedDiagnostic {
+	filePath: string;
+	line: number;
+	col: number;
+	severity: "error" | "warning" | "info" | "hint";
+	source?: string;
+	message: string;
+	code?: string;
+}
+
+function sanitizeDiagnosticDisplayText(text: string): string {
+	return replaceTabs(text);
+}
+
+function getSeverityRank(severity: ParsedDiagnostic["severity"]): number {
+	switch (severity) {
+		case "error":
+			return 0;
+		case "warning":
+			return 1;
+		case "info":
+			return 2;
+		case "hint":
+			return 3;
+	}
+}
+
+function parseDiagnosticMessage(msg: string): ParsedDiagnostic | null {
+	const match = msg.match(/^(.+?):(\d+):(\d+)\s+\[(\w+)\]\s+(?:\[([^\]]+)\]\s+)?(.+?)(?:\s+\(([^)]+)\))?$/);
+	if (!match) return null;
+	return {
+		filePath: sanitizeDiagnosticDisplayText(match[1]),
+		line: parseInt(match[2], 10),
+		col: parseInt(match[3], 10),
+		severity: match[4] as ParsedDiagnostic["severity"],
+		source: match[5] ? sanitizeDiagnosticDisplayText(match[5]) : undefined,
+		message: sanitizeDiagnosticDisplayText(match[6]),
+		code: match[7] ? sanitizeDiagnosticDisplayText(match[7]) : undefined,
+	};
+}
+
+export function formatDiagnostics(
+	diag: { errored: boolean; summary: string; messages: string[] },
+	expanded: boolean,
+	theme: Theme,
+	getLangIcon: (filePath: string) => string,
+	options?: { title?: string },
+): string {
+	if (diag.messages.length === 0) return "";
+
+	const byFile = new Map<string, ParsedDiagnostic[]>();
+	const unparsed: string[] = [];
+
+	for (const msg of diag.messages) {
+		const parsed = parseDiagnosticMessage(msg);
+		if (parsed) {
+			const existing = byFile.get(parsed.filePath) ?? [];
+			existing.push(parsed);
+			byFile.set(parsed.filePath, existing);
+		} else {
+			unparsed.push(sanitizeDiagnosticDisplayText(msg));
+		}
+	}
+
+	for (const diagnostics of byFile.values()) {
+		diagnostics.sort((a, b) => {
+			const severityCompare = getSeverityRank(a.severity) - getSeverityRank(b.severity);
+			if (severityCompare !== 0) return severityCompare;
+			if (a.line !== b.line) return a.line - b.line;
+			if (a.col !== b.col) return a.col - b.col;
+			return a.message.localeCompare(b.message);
+		});
+	}
+
+	const headerIcon = diag.errored
+		? theme.styledSymbol("status.error", "error")
+		: theme.styledSymbol("status.warning", "warning");
+	const summary = sanitizeDiagnosticDisplayText(diag.summary);
+	const summaryTag = summary ? ` ${theme.fg("dim", `(${summary})`)}` : "";
+	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", options?.title ?? "Diagnostics")}${summaryTag}`;
+
+	const maxDiags = expanded ? diag.messages.length : 5;
+	let diagsShown = 0;
+
+	const files = Array.from(byFile.entries());
+
+	// Count total diagnostics for "... X more" calculation
+	const totalParsedDiags = files.reduce((sum, [, diags]) => sum + diags.length, 0);
+	const totalDiags = totalParsedDiags + unparsed.length;
+
+	// Helper to check if this is the very last item in the tree
+	const isTreeEnd = (fileIdx: number, diagIdx: number | null, unparsedIdx: number | null): boolean => {
+		const willShowMore = totalDiags > diagsShown + 1;
+		if (willShowMore) return false;
+
+		if (unparsedIdx !== null) {
+			return unparsedIdx === unparsed.length - 1;
+		}
+		if (diagIdx !== null) {
+			const isLastDiagInFile = diagIdx === files[fileIdx][1].length - 1;
+			const isLastFile = fileIdx === files.length - 1;
+			return isLastDiagInFile && isLastFile && unparsed.length === 0;
+		}
+		// File node - never the tree end if it has diagnostics
+		return false;
+	};
+
+	for (let fi = 0; fi < files.length && diagsShown < maxDiags; fi++) {
+		const [filePath, diagnostics] = files[fi];
+		// File is "last" only if no more files AND no unparsed AND we'll show all diags AND no "... X more"
+		const remainingDiagsInFile = diagnostics.length;
+		const remainingDiagsAfter = files.slice(fi + 1).reduce((sum, [, d]) => sum + d.length, 0) + unparsed.length;
+		const willShowAllRemaining = diagsShown + remainingDiagsInFile + remainingDiagsAfter <= maxDiags;
+		const isLastFileNode = fi === files.length - 1 && unparsed.length === 0 && willShowAllRemaining;
+		const fileBranch = isLastFileNode ? theme.tree.last : theme.tree.branch;
+
+		const fileIcon = theme.fg("muted", getLangIcon(filePath));
+		output += `\n ${theme.fg("dim", fileBranch)} ${fileIcon} ${theme.fg("accent", filePath)}`;
+
+		for (let di = 0; di < diagnostics.length && diagsShown < maxDiags; di++) {
+			const d = diagnostics[di];
+			const isLastDiagInFile = di === diagnostics.length - 1;
+			// This is the last visible diag in file if it's actually last OR we're about to hit the limit
+			const atDisplayLimit = diagsShown + 1 >= maxDiags;
+			const isLastVisibleInFile = isLastDiagInFile || atDisplayLimit;
+			// Check if this is the last visible item in the entire tree
+			const isVeryLast = isTreeEnd(fi, di, null);
+			const diagBranch = isLastFileNode
+				? isLastVisibleInFile || isVeryLast
+					? `  ${theme.tree.last}`
+					: `  ${theme.tree.branch}`
+				: isLastVisibleInFile || isVeryLast
+					? `${theme.tree.vertical} ${theme.tree.last}`
+					: `${theme.tree.vertical} ${theme.tree.branch}`;
+
+			const sevIcon =
+				d.severity === "error"
+					? theme.styledSymbol("status.error", "error")
+					: d.severity === "warning"
+						? theme.styledSymbol("status.warning", "warning")
+						: theme.styledSymbol("status.info", "muted");
+			const location = theme.fg("dim", `:${d.line}:${d.col}`);
+			const codeTag = d.code ? theme.fg("dim", ` (${d.code})`) : "";
+			const msgColor = d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "toolOutput";
+
+			output += `\n ${theme.fg("dim", diagBranch)} ${sevIcon}${location} ${theme.fg(msgColor, d.message)}${codeTag}`;
+			diagsShown++;
+		}
+	}
+
+	for (let ui = 0; ui < unparsed.length && diagsShown < maxDiags; ui++) {
+		const msg = unparsed[ui];
+		const isVeryLast = isTreeEnd(-1, null, ui);
+		const branch = isVeryLast ? theme.tree.last : theme.tree.branch;
+		const color = msg.includes("[error]") ? "error" : msg.includes("[warning]") ? "warning" : "dim";
+		output += `\n ${theme.fg("dim", branch)} ${theme.fg(color, msg)}`;
+		diagsShown++;
+	}
+
+	if (totalDiags > diagsShown) {
+		const remaining = totalDiags - diagsShown;
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+			"muted",
+			`… ${remaining} more`,
+		)} ${formatExpandHint(theme)}`;
+	}
+
+	return output;
+}
+
+// =============================================================================
+// Diff Utilities
+// =============================================================================
+
+export interface DiffStats {
+	added: number;
+	removed: number;
+	hunks: number;
+	lines: number;
+}
+
+export function getDiffStats(diffText: string): DiffStats {
+	const lines = diffText ? diffText.split("\n") : [];
+	let added = 0;
+	let removed = 0;
+	let hunks = 0;
+	let inHunk = false;
+
+	for (const line of lines) {
+		const isAdded = line.startsWith("+");
+		const isRemoved = line.startsWith("-");
+		const isChange = isAdded || isRemoved;
+
+		if (isAdded) added++;
+		if (isRemoved) removed++;
+
+		if (isChange && !inHunk) {
+			hunks++;
+			inHunk = true;
+		} else if (!isChange) {
+			inHunk = false;
+		}
+	}
+
+	return { added, removed, hunks, lines: lines.length };
+}
+
+export function formatDiffStats(added: number, removed: number, hunks: number, theme: Theme): string {
+	const parts: string[] = [];
+	if (added > 0) parts.push(theme.fg("toolDiffAdded", `+${added}`));
+	if (removed > 0) parts.push(theme.fg("toolDiffRemoved", `-${removed}`));
+	if (hunks > 0) parts.push(theme.fg("dim", `${hunks} hunk${hunks !== 1 ? "s" : ""}`));
+	return parts.join(theme.fg("dim", " / "));
+}
+
+interface DiffSegment {
+	lines: string[];
+	isChange: boolean;
+	isEllipsis: boolean;
+}
+
+function parseDiffSegments(lines: string[]): DiffSegment[] {
+	const segments: DiffSegment[] = [];
+	let current: DiffSegment | null = null;
+
+	for (const line of lines) {
+		const isChange = line.startsWith("+") || line.startsWith("-");
+		const isEllipsis = line.trimStart().startsWith("...") || line.trim().length === 0;
+
+		if (isEllipsis) {
+			if (current) segments.push(current);
+			segments.push({ lines: [line], isChange: false, isEllipsis: true });
+			current = null;
+		} else if (!current || current.isChange !== isChange) {
+			if (current) segments.push(current);
+			current = { lines: [line], isChange, isEllipsis: false };
+		} else {
+			current.lines.push(line);
+		}
+	}
+
+	if (current) segments.push(current);
+	return segments;
+}
+
+export function truncateDiffByHunk(
+	diffText: string,
+	maxHunks: number,
+	maxLines: number,
+	options?: { fromTail?: boolean },
+): { text: string; hiddenHunks: number; hiddenLines: number } {
+	if (options?.fromTail) {
+		// Streaming previews want to track the tail of the diff as new hunks
+		// arrive. Reversing the line buffer reuses the head-mode logic without
+		// duplicating the segment-budget bookkeeping: hunk runs survive
+		// reversal (a continuous `+`/`-` block stays contiguous) and so do the
+		// per-line `+`/`-` markers, so getDiffStats yields identical counts.
+		const reversed = (diffText ?? "").split("\n").reverse().join("\n");
+		const result = truncateDiffByHunk(reversed, maxHunks, maxLines);
+		return {
+			text: result.text.split("\n").reverse().join("\n"),
+			hiddenHunks: result.hiddenHunks,
+			hiddenLines: result.hiddenLines,
+		};
+	}
+	const lines = diffText ? diffText.split("\n") : [];
+	const totalStats = getDiffStats(diffText);
+
+	if (lines.length <= maxLines && totalStats.hunks <= maxHunks) {
+		return { text: diffText, hiddenHunks: 0, hiddenLines: 0 };
+	}
+
+	const segments = parseDiffSegments(lines);
+
+	const changeSegments = segments.filter(s => s.isChange);
+	const changeLineCount = changeSegments.reduce((sum, s) => sum + s.lines.length, 0);
+
+	if (changeLineCount > maxLines) {
+		const kept: string[] = [];
+		let keptHunks = 0;
+
+		for (const seg of segments) {
+			if (seg.isChange) {
+				keptHunks++;
+				if (keptHunks > maxHunks) break;
+			}
+			kept.push(...seg.lines);
+			if (kept.length >= maxLines) break;
+		}
+
+		const keptStats = getDiffStats(kept.join("\n"));
+		return {
+			text: kept.join("\n"),
+			hiddenHunks: Math.max(0, totalStats.hunks - keptStats.hunks),
+			hiddenLines: Math.max(0, lines.length - kept.length),
+		};
+	}
+
+	const contextBudget = maxLines - changeLineCount;
+	const contextSegments = segments.filter(s => !s.isChange && !s.isEllipsis);
+	const totalContextLines = contextSegments.reduce((sum, s) => sum + s.lines.length, 0);
+
+	const kept: string[] = [];
+	let keptHunks = 0;
+
+	if (totalContextLines <= contextBudget) {
+		for (const seg of segments) {
+			if (seg.isChange) {
+				keptHunks++;
+				if (keptHunks > maxHunks) break;
+			}
+			kept.push(...seg.lines);
+		}
+	} else {
+		const contextRatio = contextSegments.length > 0 ? contextBudget / totalContextLines : 0;
+
+		for (let i = 0; i < segments.length; i++) {
+			const seg = segments[i];
+
+			if (seg.isChange) {
+				keptHunks++;
+				if (keptHunks > maxHunks) break;
+				kept.push(...seg.lines);
+			} else if (seg.isEllipsis) {
+				kept.push(...seg.lines);
+			} else {
+				const allowedLines = Math.max(1, Math.floor(seg.lines.length * contextRatio));
+				const isBeforeChange = segments[i + 1]?.isChange;
+				const isAfterChange = segments[i - 1]?.isChange;
+
+				if (isBeforeChange && isAfterChange) {
+					const half = Math.ceil(allowedLines / 2);
+					if (seg.lines.length > allowedLines) {
+						kept.push(...seg.lines.slice(0, half));
+						kept.push("");
+						kept.push(...seg.lines.slice(-half));
+					} else {
+						kept.push(...seg.lines);
+					}
+				} else if (isBeforeChange) {
+					kept.push(...seg.lines.slice(-allowedLines));
+				} else if (isAfterChange) {
+					kept.push(...seg.lines.slice(0, allowedLines));
+				} else {
+					kept.push(...seg.lines.slice(0, Math.min(allowedLines, 2)));
+				}
+			}
+		}
+	}
+
+	const keptStats = getDiffStats(kept.join("\n"));
+	return {
+		text: kept.join("\n"),
+		hiddenHunks: Math.max(0, totalStats.hunks - keptStats.hunks),
+		hiddenLines: Math.max(0, lines.length - kept.length),
+	};
+}
+
+// =============================================================================
+// Path Utilities
+// =============================================================================
+
+export function shortenPath(filePath: unknown, homeDir?: string): string {
+	if (typeof filePath !== "string") {
+		return "";
+	}
+	const home = homeDir ?? os.homedir();
+	if (home && filePath.startsWith(home)) {
+		const suffix = filePath.slice(home.length);
+		if (suffix === "" || suffix.startsWith(path.posix.sep) || suffix.startsWith(path.win32.sep)) {
+			return `~${suffix.replaceAll(path.win32.sep, path.posix.sep)}`;
+		}
+	}
+	return filePath;
+}
+
+export function formatToolWorkingDirectory(workdir: string | undefined, projectDir: string): string | undefined {
+	if (!workdir) return undefined;
+	const resolvedProjectDir = path.resolve(projectDir);
+	const resolvedWorkdir = path.resolve(projectDir, workdir);
+	if (resolvedWorkdir === resolvedProjectDir) {
+		return undefined;
+	}
+	const relativePath = path.relative(resolvedProjectDir, resolvedWorkdir);
+	const isWithinProject =
+		relativePath.length > 0 && !relativePath.startsWith("..") && !relativePath.startsWith(`..${path.sep}`);
+	const displayWorkdir = isWithinProject ? relativePath : shortenPath(resolvedWorkdir);
+	return replaceTabs(displayWorkdir);
+}
+
+export function formatScreenshot(opts: {
+	saveFullRes: boolean;
+	savedMimeType: string;
+	savedByteLength: number;
+	dest: string;
+	resized: ResizedImage;
+}): string[] {
+	const lines = ["Screenshot captured"];
+	if (opts.saveFullRes) {
+		lines.push(
+			`Saved: ${opts.savedMimeType} (${(opts.savedByteLength / 1024).toFixed(2)} KB) to ${shortenPath(opts.dest)}`,
+		);
+		lines.push(
+			`Model: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB, ${opts.resized.width}x${opts.resized.height})`,
+		);
+	} else {
+		lines.push(`Format: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB)`);
+		lines.push(`Dimensions: ${opts.resized.width}x${opts.resized.height}`);
+	}
+	if (opts.resized.decodeFailed) {
+		lines.push("Resize: image decoder failed; using original image bytes");
+	}
+	const dimensionNote = formatDimensionNote(opts.resized);
+	if (dimensionNote) {
+		lines.push(dimensionNote);
+	}
+	return lines;
+}
+
+export function wrapBrackets(text: string, theme: Theme): string {
+	return `${theme.format.bracketLeft}${text}${theme.format.bracketRight}`;
+}
+
+export const PARSE_ERRORS_LIMIT = 20;
+
+export function dedupeParseErrors(errors: string[] | undefined): string[] {
+	if (!errors || errors.length === 0) return [];
+	const seen = new Set<string>();
+	const deduped: string[] = [];
+	for (const error of errors) {
+		if (seen.has(error)) continue;
+		seen.add(error);
+		deduped.push(error);
+	}
+	return deduped;
+}
+
+export function formatParseErrors(errors: string[], total?: number): string[] {
+	const deduped = dedupeParseErrors(errors);
+	if (deduped.length === 0) return [];
+	const fullCount = total ?? deduped.length;
+	const capped = deduped.slice(0, PARSE_ERRORS_LIMIT);
+	const header = fullCount > capped.length ? `Parse issues (${capped.length} / ${fullCount}):` : "Parse issues:";
+	return [header, ...capped.map(err => `- ${err}`)];
+}
+
+/**
+ * Cap an upstream parse-error list to {@link PARSE_ERRORS_LIMIT} unique entries,
+ * preserving the original deduplicated total. Use this at the source so tool
+ * details never carry thousands of per-file parse errors into traces or
+ * renderers.
+ */
+export function capParseErrors(
+	errors: string[] | undefined,
+	limit: number = PARSE_ERRORS_LIMIT,
+): { errors: string[]; total: number } {
+	const deduped = dedupeParseErrors(errors);
+	return { errors: deduped.slice(0, limit), total: deduped.length };
+}
+
+// =============================================================================
+// Renderer helpers shared by search / find / ast tools
+// =============================================================================
+
+/**
+ * Standard width+expand keyed render cache used by every search-style tool
+ * renderer. `compute` re-runs only when the cache key changes; the returned
+ * Component is the canonical `{ render, invalidate }` pair.
+ */
+export function createCachedComponent(
+	getExpanded: () => boolean,
+	compute: (width: number, expanded: boolean) => string[],
+	options: { paddingX?: number } = {},
+): Component {
+	let cached: { key: bigint; lines: string[] } | undefined;
+	return {
+		render(width: number): readonly string[] {
+			const expanded = getExpanded();
+			const key = new Hasher().bool(expanded).u32(width).digest();
+			if (cached?.key === key) return cached.lines;
+			const paddingX = Math.max(0, options.paddingX ?? 0);
+			const innerWidth = Math.max(1, width - paddingX * 2);
+			const lines = compute(innerWidth, expanded);
+			const pad = paddingX === 0 ? "" : " ".repeat(paddingX);
+			const paddedLines = paddingX === 0 ? lines : lines.map(line => `${pad}${line}${pad}`);
+			cached = { key, lines: paddedLines };
+			return paddedLines;
+		},
+		invalidate() {
+			cached = undefined;
+		},
+	};
+}
+
+/**
+ * Single-slot memo for an expensive rendered string (syntax highlighting, diff
+ * coloring) keyed by the exact inputs that shape the bytes: theme instance,
+ * expanded state, a caller-chosen salt (path/language), and the source content.
+ * Field-wise comparison instead of a concatenated key string: a cache hit costs
+ * one string value-compare (engines short-circuit on length) and a miss never
+ * allocates a key. Comparing the {@link Theme} by reference is sound because
+ * theme switches replace the instance wholesale (`setTheme`/`previewTheme`/
+ * `setSymbolPreset` in modes/theme/theme.ts) — themes are never mutated in
+ * place.
+ */
+export interface RenderedStringCache {
+	theme: Theme | null;
+	expanded: boolean;
+	salt: string;
+	content: string;
+	value: string;
+}
+
+export function createRenderedStringCache(): RenderedStringCache {
+	return { theme: null, expanded: false, salt: "", content: "", value: "" };
+}
+
+/** Drop the memo so the next lookup re-renders (e.g. the render function identity changed). */
+export function invalidateRenderedStringCache(cache: RenderedStringCache): void {
+	cache.theme = null;
+}
+
+export function cachedRenderedString(
+	cache: RenderedStringCache | undefined,
+	theme: Theme,
+	expanded: boolean,
+	salt: string,
+	content: string,
+	render: () => string,
+): string {
+	if (
+		cache !== undefined &&
+		cache.theme === theme &&
+		cache.expanded === expanded &&
+		cache.salt === salt &&
+		cache.content === content
+	) {
+		return cache.value;
+	}
+	const value = render();
+	if (cache !== undefined) {
+		cache.theme = theme;
+		cache.expanded = expanded;
+		cache.salt = salt;
+		cache.content = content;
+		cache.value = value;
+	}
+	return value;
+}
+
+/**
+ * Append the indented bullet list of parse errors (capped at
+ * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the
+ * total exceeds the cap. No-op when `parseErrors` is empty.
+ */
+export function appendParseErrorsBulletList(
+	lines: string[],
+	parseErrors: readonly string[] | undefined,
+	theme: Theme,
+	total?: number,
+): void {
+	if (!parseErrors || parseErrors.length === 0) return;
+	const fullCount = total ?? parseErrors.length;
+	const capped = parseErrors.slice(0, PARSE_ERRORS_LIMIT);
+	for (const err of capped) {
+		lines.push(theme.fg("warning", `  - ${err}`));
+	}
+	if (fullCount > capped.length) {
+		lines.push(theme.fg("dim", `  … ${fullCount - capped.length} more`));
+	}
+}
+
+/**
+ * Human-readable summary string for the parse-issues count, capped by
+ * {@link PARSE_ERRORS_LIMIT}.
+ */
+export function formatParseErrorsCountLabel(parseErrors: readonly string[], total?: number): string {
+	const fullCount = total ?? parseErrors.length;
+	return fullCount > PARSE_ERRORS_LIMIT
+		? `${PARSE_ERRORS_LIMIT} / ${fullCount} parse issues`
+		: `${fullCount} parse issue${fullCount !== 1 ? "s" : ""}`;
+}
+
+// =============================================================================
+// LSP Batching
+// =============================================================================
+
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+export interface LspBatchRequest {
+	id: string;
+	flush: boolean;
+}
+
+export function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some(call => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}