@quandev104/pi-style 0.1.1

package/extension-src/pi-style/features/tools/boxed/bash.ts

@@ -0,0 +1,347 @@
+// Boxed bash tool renderer
+// (renderCall/renderResult only).
+
+import { highlightCode } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../../../shared/ansi.js";
+import type { BoxTheme } from "../../../shared/box.js";
+import {
+	boxedToolWidthKey,
+	formatBoxedFooter,
+	formatToolOutputLine,
+	getTextOutput,
+	renderBoxedToolCall,
+	renderBoxedToolResult,
+	replaceTabs,
+} from "../../../shared/box.js";
+import { safeTruncateToWidth, truncateAtCodePointBoundary } from "../../../shared/render-budget.js";
+import { getStateElapsedMs, getToolsRenderConfig } from "./session-config.js";
+import { type BoxedToolContext, type BoxedToolDefinition, noteExecutionStart } from "./shared.js";
+
+const MAX_BASH_PREVIEW_LINES = 5;
+const MAX_LINE_CHARS = 2000;
+const ESC = "\x1b";
+const BASH_TOOL_NOTICE_PATTERN = /^\[Showing (?:last|lines)\b.*\. Full output: .+\]$/;
+const BG_ANSI_PATTERN = new RegExp(`${ESC}\\[4[0-9;]*m`, "g");
+const SHELL_VAR_PATTERN = /\$\{?[A-Za-z_][A-Za-z0-9_]*\}?/;
+const SHELL_OP_PATTERN = /^(?:&&|\|\||>>|>&|\|&|[|&;()<>])$/;
+
+function highlightBashFallback(line: string): string {
+	try {
+		const highlighted = highlightCode(line, "bash")[0] ?? line;
+		// Strip background colors to avoid clashing with badge/parens styling
+		return highlighted.replace(BG_ANSI_PATTERN, "");
+	} catch {
+		return line;
+	}
+}
+
+function normalizeShellWord(word: string): string {
+	return word.replace(/^(['"])(.*)\1$/, "$2");
+}
+
+function colorShellWord(theme: BoxTheme, word: string, commandExpected: boolean): string {
+	const normalized = normalizeShellWord(word);
+	if (/^[A-Za-z_][A-Za-z0-9_]*=.*/.test(normalized)) return theme.fg("syntaxVariable", word);
+	if (normalized.startsWith("-")) return theme.fg("syntaxKeyword", word);
+	if (normalized.includes("/") || /^\.{1,2}(?:\/|$)/.test(normalized)) return theme.fg("syntaxVariable", word);
+	if (SHELL_VAR_PATTERN.test(normalized)) return theme.fg("syntaxVariable", word);
+	return commandExpected ? theme.fg("syntaxFunction", word) : theme.fg("syntaxString", word);
+}
+
+function tokenizeShellLinePreservingText(line: string): string[] | undefined {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: string | null = null;
+
+	for (let i = 0; i < line.length; i++) {
+		const char = line[i] ?? "";
+		const next = line[i + 1] ?? "";
+
+		if (quote) {
+			current += char;
+			if (char === "\\" && next) current += line[++i] ?? "";
+			else if (char === quote) quote = null;
+			continue;
+		}
+
+		if (char === "'" || char === '"') {
+			quote = char;
+			current += char;
+			continue;
+		}
+
+		if (/\s/.test(char)) {
+			if (current) tokens.push(current);
+			current = "";
+			tokens.push(char);
+			continue;
+		}
+
+		if (char === "#" && !current) {
+			if (current) tokens.push(current);
+			tokens.push(line.slice(i));
+			return tokens;
+		}
+
+		const two = `${char}${next}`;
+		if (SHELL_OP_PATTERN.test(two) || SHELL_OP_PATTERN.test(char)) {
+			if (current) tokens.push(current);
+			current = "";
+			if (SHELL_OP_PATTERN.test(two)) {
+				tokens.push(two);
+				i++;
+			} else {
+				tokens.push(char);
+			}
+			continue;
+		}
+
+		current += char;
+	}
+
+	if (quote) return undefined;
+	if (current) tokens.push(current);
+	return tokens;
+}
+
+function highlightBashLine(line: string, theme: BoxTheme): string {
+	const tokens = tokenizeShellLinePreservingText(line);
+	if (!tokens) return highlightBashFallback(line);
+	let commandExpected = true;
+	return tokens
+		.map((token) => {
+			if (/^\s+$/.test(token)) return token;
+			if (token.startsWith("#")) return theme.fg("syntaxComment", token);
+			if (SHELL_OP_PATTERN.test(token)) {
+				commandExpected = token === "|" || token === "||" || token === "&&" || token === ";" || token === "&";
+				return theme.fg("syntaxOperator", token);
+			}
+			const styled = colorShellWord(theme, token, commandExpected);
+			if (!/^[A-Za-z_][A-Za-z0-9_]*=.*/.test(normalizeShellWord(token))) commandExpected = false;
+			return styled;
+		})
+		.join("");
+}
+
+function clampLineLength(line: string, max: number = MAX_LINE_CHARS): string {
+	if (line.length <= max) return line;
+	return `${truncateAtCodePointBoundary(line, max)}… (truncated)`;
+}
+
+function countNewlines(text: string, from: number, to: number): number {
+	let count = 0;
+	for (let i = from; i < to; i++) {
+		if (text.charCodeAt(i) === 10) count++;
+	}
+	return count;
+}
+
+function stripBashToolNoticeLines(text: string): string {
+	const filteredLines = text
+		.replace(/\r/g, "")
+		.split("\n")
+		.filter((line) => !BASH_TOOL_NOTICE_PATTERN.test(line.trim()));
+	return filteredLines
+		.join("\n")
+		.replace(/\n{3,}/g, "\n\n")
+		.trimEnd();
+}
+
+function bashWidthKey(rawCommand: string, timeout: unknown): string {
+	return boxedToolWidthKey("Bash", `${rawCommand}|${timeout ?? ""}`);
+}
+
+function renderBoxedBashCall(
+	theme: BoxTheme,
+	commandLines: string[],
+	context: BoxedToolContext,
+	widthKey: string,
+): Component {
+	const maxCommandLines = 5;
+	const shownCount = Math.min(commandLines.length, maxCommandLines + 1);
+	const detailLines: string[] = [];
+	for (let i = 0; i < shownCount; i++) {
+		const prefix = i === 0 ? theme.fg("dim", "$ ") : theme.fg("dim", "> ");
+		detailLines.push(`${prefix}${highlightBashLine(commandLines[i] ?? "", theme)}`);
+	}
+	if (commandLines.length > maxCommandLines + 1) {
+		detailLines.push(theme.fg("muted", `... ${commandLines.length - maxCommandLines - 1} more lines`));
+	}
+	return renderBoxedToolCall(theme, "Bash", detailLines, {
+		widthKey,
+		isError: Boolean(context.isError),
+		isPartial: Boolean(context.isPartial),
+		isPending: Boolean(context.isPartial),
+	});
+}
+
+function formatTimeout(context: BoxedToolContext): string {
+	const timeout = context?.args?.timeout ?? 300;
+	return `${timeout}s`;
+}
+
+function renderBoxedBashResult(
+	theme: BoxTheme,
+	inner: Component,
+	result: unknown,
+	context: BoxedToolContext,
+): Component {
+	const rawCommand = String(context?.args?.command ?? "...");
+	const referenceLines = rawCommand.split("\n").map((line, index) => `${index === 0 ? "$ " : "> "}${line}`);
+	return renderBoxedToolResult(theme, inner, {
+		widthKey: bashWidthKey(rawCommand, context?.args?.timeout),
+		referenceLines,
+		footerLines: [formatBoxedFooter(theme, result as never, [`⏹ ${formatTimeout(context)}`], getElapsed(context))],
+		isError: context.isError,
+		isPartial: Boolean(context.isPartial),
+	});
+}
+
+function getElapsed(context: BoxedToolContext): number | undefined {
+	return getStateElapsedMs(context.state);
+}
+
+function createBashResultPreview(
+	theme: BoxTheme,
+	text: string,
+	options: { expanded: boolean },
+	color: "toolOutput" | "error",
+	extraLinesBefore: number = 0,
+): Component {
+	let cacheKey = "";
+	let cacheLines: string[] | null = null;
+
+	return {
+		invalidate() {
+			cacheKey = "";
+			cacheLines = null;
+		},
+		render(width: number): string[] {
+			const bodyWidth = Math.max(1, width);
+			const cfg = getToolsRenderConfig();
+			const expanded = Boolean(options.expanded);
+			const cacheId = `${bodyWidth}|${expanded ? 1 : 0}|${cfg.maxExpandedLines}|${cfg.dimOutput ? 1 : 0}`;
+			if (cacheLines && cacheKey === cacheId) return cacheLines;
+
+			if (!expanded) {
+				// Collapsed: only process the tail of the output
+				const needed = MAX_BASH_PREVIEW_LINES;
+				let totalNewlines = 0;
+				let scanFrom = 0; // default: take full text if fewer than needed newlines
+				for (let i = text.length - 1; i >= 0; i--) {
+					if (text.charCodeAt(i) === 10) {
+						totalNewlines++;
+						if (totalNewlines === needed) {
+							scanFrom = i + 1;
+							break;
+						}
+					}
+				}
+
+				if (text.length === 0) {
+					cacheKey = cacheId;
+					cacheLines = [];
+					return cacheLines;
+				}
+
+				const tail = replaceTabs(text.slice(scanFrom)).replace(/\r/g, "");
+				const shownLines = tail ? tail.split("\n").map((l) => clampLineLength(l)) : [];
+
+				if (shownLines.length === 0) {
+					cacheKey = cacheId;
+					cacheLines = [];
+					return cacheLines;
+				}
+
+				const truncatedShown = shownLines.map((line) => {
+					const truncated = safeTruncateToWidth(line, bodyWidth, "…");
+					if (color === "error") return formatToolOutputLine(theme, truncated, "error");
+					return cfg.dimOutput
+						? formatToolOutputLine(theme, truncated)
+						: formatToolOutputLine(theme, truncated, "text");
+				});
+
+				// Count remaining lines (lines before scanFrom)
+				const remaining = extraLinesBefore + (scanFrom > 0 ? countNewlines(text, 0, scanFrom) : 0);
+
+				if (remaining <= 0) {
+					cacheKey = cacheId;
+					cacheLines = truncatedShown;
+					return cacheLines;
+				}
+
+				const hint = safeTruncateToWidth(`... ${remaining} more lines, press Ctrl+o to expand`, bodyWidth, "…");
+				cacheKey = cacheId;
+				cacheLines = [...truncatedShown, "", theme.fg("muted", hint)];
+				return cacheLines;
+			}
+
+			// Expanded: process all lines
+			const normalized = replaceTabs(text);
+			const logicalLines = normalized.split("\n").map((l) => clampLineLength(l));
+			const hasOutput = !(logicalLines.length === 1 && logicalLines[0] === "");
+
+			if (!hasOutput) {
+				cacheKey = cacheId;
+				cacheLines = [];
+				return cacheLines;
+			}
+
+			const truncatedLines = logicalLines.map((line) => safeTruncateToWidth(line, bodyWidth, "…"));
+			const expandedLines = truncatedLines.length === 1 && truncatedLines[0] === "" ? [] : truncatedLines;
+			const applyColor = (l: string) =>
+				color === "error"
+					? formatToolOutputLine(theme, l, "error")
+					: cfg.dimOutput
+						? formatToolOutputLine(theme, l)
+						: formatToolOutputLine(theme, l, "text");
+			if (cfg.maxExpandedLines > 0 && expandedLines.length > cfg.maxExpandedLines) {
+				const truncated = expandedLines.slice(-cfg.maxExpandedLines).map(applyColor);
+				const remaining = expandedLines.length - cfg.maxExpandedLines;
+				truncated.unshift(theme.fg("dim", `… ${remaining} earlier lines`));
+				cacheKey = cacheId;
+				cacheLines = truncated;
+				return cacheLines;
+			}
+
+			cacheKey = cacheId;
+			cacheLines = expandedLines.map(applyColor);
+			return cacheLines;
+		},
+	};
+}
+
+export const bashTool: BoxedToolDefinition = {
+	call(args, theme, context) {
+		noteExecutionStart(context);
+		const rawCommand = String(args?.command ?? "...");
+		return renderBoxedBashCall(theme, rawCommand.split("\n"), context, bashWidthKey(rawCommand, args?.timeout));
+	},
+	result(result, options, theme, context) {
+		const raw = getTextOutput(result);
+		const outputColor = context.isError ? "error" : "toolOutput";
+
+		if (!options.expanded) {
+			const scanLines = MAX_BASH_PREVIEW_LINES + 10;
+			let nlCount = 0;
+			let tailStart = 0;
+			for (let i = raw.length - 1; i >= 0; i--) {
+				if (raw.charCodeAt(i) === 10) {
+					nlCount++;
+					if (nlCount >= scanLines) {
+						tailStart = i + 1;
+						break;
+					}
+				}
+			}
+			const tail = stripBashToolNoticeLines(stripAnsi(raw.slice(tailStart)));
+			const totalLinesBefore = tailStart > 0 ? countNewlines(raw, 0, tailStart) : 0;
+			const inner = createBashResultPreview(theme, tail, options, outputColor, totalLinesBefore);
+			return renderBoxedBashResult(theme, inner, result, context);
+		}
+		const output = stripBashToolNoticeLines(stripAnsi(raw));
+		const inner = createBashResultPreview(theme, output, options, outputColor, 0);
+		return renderBoxedBashResult(theme, inner, result, context);
+	},
+};

package/extension-src/pi-style/features/tools/boxed/edit.ts

@@ -0,0 +1,113 @@
+// Boxed edit tool renderer
+// (renderCall/renderResult only; no edit-core re-registration).
+
+import { getLanguageFromPath } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../../../shared/ansi.js";
+import { getTextOutput, renderBoxedToolCall, renderBoxedToolResult } from "../../../shared/box.js";
+import {
+	buildSplitRows,
+	countDiffStats,
+	extractEditedPath,
+	firstText,
+	renderDiffMeter,
+	SplitDiffComponent,
+} from "../../../shared/split-diff.js";
+import {
+	type BoxedToolContext,
+	type BoxedToolDefinition,
+	displayPath,
+	noteExecutionStart,
+	resultFooterLines,
+} from "./shared.js";
+
+const MAX_HIGHLIGHT_DIFF_CHARS = 12000;
+const MAX_HIGHLIGHT_DIFF_ROWS = 120;
+
+type EditResultDetails = { diff?: string; path?: string } | undefined;
+
+export const editTool: BoxedToolDefinition = {
+	call(args, theme, context) {
+		noteExecutionStart(context);
+		const detail = displayPath(String(args?.path ?? args?.file_path ?? ""), context);
+		return renderBoxedToolCall(theme, "Edit", [`${theme.fg("dim", "Path: ")}${detail}`], {
+			isError: Boolean(context.isError),
+			isPartial: Boolean(context.isPartial),
+			isPending: Boolean(context.isPartial),
+		});
+	},
+	result(result, options, theme, context) {
+		// Handle partial/streaming state
+		if (options.isPartial) {
+			return renderBoxedToolResult(theme, () => [`${theme.fg("dim", "↳")} ${theme.fg("muted", "Applying edit...")}`], {
+				isPartial: true,
+			});
+		}
+
+		// Handle errors
+		if (context.isError) {
+			const output = getTextOutput(result);
+			return renderBoxedToolResult(theme, () => [theme.fg("error", stripAnsi(output).trim() || "Error")], {
+				footerLines: resultFooterLines(theme, result, context),
+				isError: true,
+			});
+		}
+
+		// Extract diff from result details
+		const details = result.details as EditResultDetails;
+		const diff = details?.diff as string | undefined;
+
+		if (!diff) {
+			const output = stripAnsi(getTextOutput(result)).trim();
+			const fallback = `↳ ${output || "Edit applied"}`;
+			return renderBoxedToolResult(theme, () => [theme.fg("dim", fallback)], {
+				footerLines: resultFooterLines(theme, result, context),
+			});
+		}
+
+		// Resolve language for syntax highlighting
+		const message = firstText(result.content as Array<{ type: string; text?: string }>);
+		const argPath = String(context?.args?.path ?? context?.args?.file_path ?? "");
+		const sourcePath = details?.path ?? (argPath || extractEditedPath(message));
+		const language = sourcePath ? getLanguageFromPath(sourcePath) : undefined;
+
+		// Build split-diff rows
+		const rows = buildSplitRows(diff);
+		const expanded = options.expanded;
+		const shouldHighlight =
+			Boolean(language) && diff.length <= MAX_HIGHLIGHT_DIFF_CHARS && rows.length <= MAX_HIGHLIGHT_DIFF_ROWS;
+
+		// Build summary header with diff stats and meter
+		const { additions, removals } = countDiffStats(diff);
+		const meter = renderDiffMeter(theme, additions, removals);
+		const summary =
+			`${theme.fg("dim", "↳")} ${theme.fg("muted", "diff")}` +
+			` ${theme.fg("toolDiffAdded", `+${additions}`)}` +
+			` ${theme.fg("toolDiffRemoved", `-${removals}`)}` +
+			` ${theme.fg("muted", "split")}` +
+			(meter ? ` ${meter}` : "");
+
+		// Render split-diff with syntax colors for small outputs.
+		const maxRows = expanded ? 160 : 36;
+		const split = new SplitDiffComponent(theme, rows, maxRows, shouldHighlight ? language : undefined);
+
+		return renderBoxedToolResult(
+			theme,
+			{
+				render(width: number): string[] {
+					const safeWidth = Math.max(20, width);
+					const headerLines = new Text(summary, 0, 0).render(safeWidth);
+					return [...headerLines, ...split.render(safeWidth)];
+				},
+				invalidate(): void {
+					split.invalidate();
+				},
+			},
+			{
+				footerLines: resultFooterLines(theme, result, context),
+			},
+		);
+	},
+};
+
+export type { BoxedToolContext };

package/extension-src/pi-style/features/tools/boxed/fallback.ts

@@ -0,0 +1,67 @@
+// Boxed fallback for tools without a dedicated renderer.
+// (component side only; no ToolExecutionComponent prototype patching).
+
+import type { Component } from "@earendil-works/pi-tui";
+import type { BoxTheme, MetricResultLike } from "../../../shared/box.js";
+import {
+	formatBoxedFooter,
+	formatToolName,
+	formatToolParamLines,
+	getTextOutput,
+	renderBoxedToolCall,
+	renderBoxedToolResult,
+	renderLines,
+} from "../../../shared/box.js";
+import { getStateElapsedMs, getToolsRenderConfig } from "./session-config.js";
+import { type BoxedToolContext, noteExecutionStart } from "./shared.js";
+
+const MAX_FALLBACK_PREVIEW_LINES = 10;
+
+export function renderFallbackCall(
+	toolName: unknown,
+	args: Record<string, unknown>,
+	theme: BoxTheme,
+	context: BoxedToolContext,
+): Component {
+	noteExecutionStart(context);
+	return renderBoxedToolCall(theme, formatToolName(String(toolName ?? "Tool")), formatToolParamLines(args, theme), {
+		isError: Boolean(context.isError),
+		isPartial: Boolean(context.isPartial),
+		isPending: Boolean(context.isPartial),
+	});
+}
+
+export function renderFallbackResult(
+	_toolName: unknown,
+	result: MetricResultLike,
+	options: { expanded: boolean; isPartial: boolean },
+	theme: BoxTheme,
+	context: BoxedToolContext,
+): Component {
+	const isError = Boolean(context.isError);
+	const expanded = Boolean(options.expanded);
+	const maxLines = expanded ? getToolsRenderConfig().maxExpandedLines : MAX_FALLBACK_PREVIEW_LINES;
+	const output = getTextOutput(result);
+	const elapsedMs = getStateElapsedMs(context.state);
+
+	return renderBoxedToolResult(
+		theme,
+		(contentWidth) => {
+			const body = renderLines(theme, output, options, {
+				maxLines,
+				color: isError ? "error" : "toolOutput",
+				width: contentWidth,
+			});
+			return body ? body.split("\n") : [];
+		},
+		{
+			footerLines: [formatBoxedFooter(theme, result, [], elapsedMs)],
+			renderLineBudget: maxLines,
+			isError,
+			isPartial: Boolean(options.isPartial),
+		},
+	);
+}
+
+// Re-exported for callers that need the tool-name label normalization.
+export { formatToolName };

package/extension-src/pi-style/features/tools/boxed/find.ts

@@ -0,0 +1,65 @@
+// Boxed find tool renderer.
+
+import { stripAnsi } from "../../../shared/ansi.js";
+import {
+	boxedToolWidthKey,
+	countLines,
+	getTextOutput,
+	renderBoxedToolResult,
+	shortenPath,
+	stripTrailingNotice,
+} from "../../../shared/box.js";
+import {
+	type BoxedToolDefinition,
+	clearFooterState,
+	compactCall,
+	compactFooterWithState,
+	noteExecutionStart,
+	resultFooterLines,
+	truncationOutputLines,
+} from "./shared.js";
+
+function queryDetail(pattern: string, rawPath: string): string {
+	const displayPath = String(rawPath ?? ".");
+	const path = displayPath === "." || displayPath === "" ? "current directory" : shortenPath(displayPath);
+	return pattern ? `${pattern} in ${path}` : path;
+}
+
+export const findTool: BoxedToolDefinition = {
+	call(args, theme, context) {
+		noteExecutionStart(context);
+		const detail = queryDetail(String(args?.pattern ?? ""), String(args?.path ?? "."));
+		return compactCall(theme, "Find", `${theme.fg("dim", "Query: ")}${detail}`, {
+			detailKey: detail,
+			context,
+		});
+	},
+	result(result, options, theme, context) {
+		clearFooterState(context);
+		const output = stripAnsi(getTextOutput(result)).trimEnd();
+		const detail = queryDetail(String(context?.args?.pattern ?? ""), String(context?.args?.path ?? "."));
+		const widthKey = boxedToolWidthKey("Find", detail);
+
+		if (context.isError) {
+			return renderBoxedToolResult(theme, () => [theme.fg("error", output || "Error")], {
+				widthKey,
+				footerLines: resultFooterLines(theme, result, context),
+				isError: true,
+			});
+		}
+
+		if (!options.expanded) return compactFooterWithState(theme, result, context);
+
+		let fileCount = 0;
+		if (output && output !== "No files found matching pattern") {
+			const stripped = stripTrailingNotice(output);
+			fileCount = truncationOutputLines(result) ?? countLines(stripped);
+		}
+
+		const summary = `↳ Found ${fileCount} ${fileCount === 1 ? "file" : "files"}.`;
+		return renderBoxedToolResult(theme, () => [theme.fg("dim", summary)], {
+			widthKey,
+			footerLines: resultFooterLines(theme, result, context),
+		});
+	},
+};

package/extension-src/pi-style/features/tools/boxed/grep.ts

@@ -0,0 +1,108 @@
+// Boxed grep/search tool renderer.
+
+import { stripAnsi } from "../../../shared/ansi.js";
+import {
+	boxedToolWidthKey,
+	countLines,
+	getTextOutput,
+	renderBoxedToolResult,
+	renderLines,
+	shortenPath,
+	stripTrailingNotice,
+} from "../../../shared/box.js";
+import { getToolsRenderConfig } from "./session-config.js";
+import {
+	type BoxedToolDefinition,
+	clearFooterState,
+	compactCall,
+	compactFooterWithState,
+	matchLimitReached,
+	noteExecutionStart,
+	resultFooterLines,
+} from "./shared.js";
+
+const MAX_GREP_PREVIEW_LINES = 10;
+
+function queryDetail(pattern: string, rawPath: string): string {
+	const displayPath = String(rawPath ?? ".");
+	const path = displayPath === "." || displayPath === "" ? "current directory" : shortenPath(displayPath);
+	return pattern ? `/${pattern}/ in ${path}` : path;
+}
+
+export const grepTool: BoxedToolDefinition = {
+	call(args, theme, context) {
+		noteExecutionStart(context);
+		const detail = queryDetail(String(args?.pattern ?? ""), String(args?.path ?? "."));
+		return compactCall(theme, "Search", `${theme.fg("dim", "Query: ")}${detail}`, {
+			detailKey: detail,
+			context,
+		});
+	},
+	result(result, options, theme, context) {
+		clearFooterState(context);
+		const output = stripAnsi(getTextOutput(result)).trimEnd();
+		const stripped = stripTrailingNotice(output);
+		const detail = queryDetail(String(context?.args?.pattern ?? ""), String(context?.args?.path ?? "."));
+		const widthKey = boxedToolWidthKey("Search", detail);
+		const cfg = getToolsRenderConfig();
+
+		if (context.isError) {
+			return renderBoxedToolResult(
+				theme,
+				(width) => {
+					const body = renderLines(theme, stripped || output || "Error", options, {
+						maxLines: MAX_GREP_PREVIEW_LINES,
+						color: "error",
+						width,
+					});
+					return body ? body.split("\n") : [];
+				},
+				{
+					widthKey,
+					footerLines: resultFooterLines(theme, result, context),
+					isError: true,
+				},
+			);
+		}
+
+		if (!options.expanded) return compactFooterWithState(theme, result, context);
+
+		let matchCount = 0;
+		if (stripped && stripped !== "No matches found") {
+			const lines = stripped.split("\n");
+			matchCount = lines.filter((line) => /:\d+:/.test(line)).length;
+
+			if (matchCount === 0) {
+				matchCount = countLines(stripped);
+			}
+
+			if (matchLimitReached(result) !== undefined) {
+				matchCount = Math.max(matchCount, matchLimitReached(result) as number);
+			}
+		}
+
+		const summary = theme.fg("dim", `↳ Found ${matchCount} ${matchCount === 1 ? "match" : "matches"}.`);
+		if (!stripped || stripped === "No matches found") {
+			return renderBoxedToolResult(theme, () => [summary], {
+				widthKey,
+				footerLines: resultFooterLines(theme, result, context),
+			});
+		}
+
+		return renderBoxedToolResult(
+			theme,
+			(width) => {
+				const body = renderLines(theme, stripped, options, {
+					maxLines: options.expanded ? cfg.maxExpandedLines : MAX_GREP_PREVIEW_LINES,
+					color: "toolOutput",
+					width,
+				});
+				return [summary, ...(body ? body.split("\n") : [])];
+			},
+			{
+				widthKey,
+				footerLines: resultFooterLines(theme, result, context),
+			},
+		);
+	},
+};