@heyhuynhgiabuu/pi-pretty 0.6.15 → 0.6.17

package/src/notices.ts

@@ -1,3 +1,3 @@
 /** Stable user-facing strings for FFF/grep tool footers (not source-line titles). */
 
-export const NOTICE_PARTIAL_FILE_INDEX = "FFF index incomplete; results may be missing files";
+export const NOTICE_PARTIAL_FILE_INDEX = "FFF index incomplete; results may be missing files";

package/src/render.ts

@@ -5,40 +5,40 @@
  * They are async only when Shiki syntax highlighting is involved.
  */
 
-import type { BundledLanguage } from "shiki";
-import { codeToANSI } from "@shikijs/cli";
 import { basename, dirname } from "node:path";
-
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { codeToANSI } from "@shikijs/cli";
+import type { BundledLanguage } from "shiki";
 import {
-	RST,
-	FG_LNUM,
+	BG_BASE,
+	BG_ERROR,
+	CACHE_LIMIT,
+	detectLang,
+	dirIcon,
+	FG_BLUE,
 	FG_DIM,
-	FG_RULE,
 	FG_GREEN,
+	FG_LNUM,
 	FG_RED,
+	FG_RULE,
 	FG_YELLOW,
-	FG_BLUE,
-	BG_BASE,
-	BG_ERROR,
-	dirIcon,
-	detectLang,
-	termWidth,
-	MAX_PREVIEW_LINES,
 	MAX_HL_CHARS,
-	CACHE_LIMIT,
+	MAX_PREVIEW_LINES,
+	RST,
 	resolveBaseBackground,
+	TOOL_RESULT_INDENT,
+	termWidth,
 } from "./config.js";
 import {
-	normalizeLineEndings,
-	humanSize,
-	formatElapsedMs,
-	formatCharCount,
-	ELAPSED_KEY,
 	CHARS_KEY,
 	compactErrorLines,
+	ELAPSED_KEY,
+	formatCharCount,
+	formatElapsedMs,
+	humanSize,
+	normalizeLineEndings,
 } from "./helpers.js";
-import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
-import type { ThemeLike, RenderCtxLike as RenderContext } from "./types.js";
+import type { RenderCtxLike as RenderContext, ThemeLike } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Lazy imports — avoid top-level require() that blocks module loading
@@ -72,7 +72,7 @@ function resolveTheme(): BundledTheme {
 	}
 }
 
-let THEME: BundledTheme = resolveTheme();
+const THEME: BundledTheme = resolveTheme();
 const _cache = new Map<string, string[]>();
 
 function _touch(k: string, v: string[]): string[] {
@@ -168,9 +168,14 @@ export function fillToolBackground(text: string, bg = BG_BASE, width?: number):
 	return text
 		.split("\n")
 		.map((line) => {
-			const fitted = width ? _truncateToWidth(line, width, "") : line;
+			if (!width) {
+				const stripped = preserveBoxBackground(line);
+				return bg ? bg + stripped : stripped;
+			}
+			const plainLead = line.replace(/\x1b\[[0-9;]*m/g, "");
+			const skipPad = line.startsWith(TOOL_RESULT_INDENT) || plainLead.startsWith(TOOL_RESULT_INDENT);
+			const fitted = _truncateToWidth(line, width, "", !skipPad);
 			const stripped = preserveBoxBackground(fitted);
-			// Apply background to the entire line
 			return bg ? bg + stripped : stripped;
 		})
 		.join("\n");
@@ -198,13 +203,18 @@ export function renderToolMetrics(result: AgentToolResult<Record<string, unknown
 	return `${FG_DIM}· ${[elapsed, chars].filter(Boolean).join(" · ")}${RST}`;
 }
 
+export function renderToolDuration(result: AgentToolResult<Record<string, unknown>>): string {
+	const details = result.details as Record<string, unknown> | undefined;
+	return formatElapsedMs(details?.[ELAPSED_KEY] as number | undefined);
+}
+
 // ---------------------------------------------------------------------------
 // Error renderer
 // ---------------------------------------------------------------------------
 
 export function renderToolError(error: string, theme: ThemeLike): string {
 	const body = compactErrorLines(error)
-		.map((line) => `  ${line ? theme.fg("error", line) : ""}`)
+		.map((line) => `${TOOL_RESULT_INDENT}${line ? theme.fg("error", line) : ""}`)
 		.join("\n");
 	return fillToolBackground(body, BG_ERROR);
 }
@@ -239,23 +249,16 @@ export async function renderFileContent(
 // Bash — colored exit status
 // ---------------------------------------------------------------------------
 
-export function renderBashOutput(text: string, exitCode: number | null): { summary: string; body: string } {
-	const isOk = exitCode === 0;
-	const statusIcon = isOk ? "✓" : "✗";
-	const codeStr =
-		exitCode !== null
-			? `${isOk ? FG_GREEN : FG_RED}${statusIcon} exit ${exitCode}${RST}`
-			: `${FG_YELLOW}⚡ killed${RST}`;
-
+export function renderBashOutput(text: string): string {
 	const lines = text.split("\n");
 	const maxShow = MAX_PREVIEW_LINES;
 	const show = lines.slice(0, maxShow);
 	const remaining = lines.length - maxShow;
 
 	let body = show.join("\n");
-	if (remaining > 0) body += `\n${FG_DIM}  … ${remaining} more lines${RST}`;
+	if (remaining > 0) body += `\n${TOOL_RESULT_INDENT}${FG_DIM}… ${remaining} more lines${RST}`;
 
-	return { summary: codeStr, body };
+	return body;
 }
 
 // ---------------------------------------------------------------------------
@@ -318,10 +321,10 @@ export function renderFindResults(text: string, theme?: ThemeLike): string {
 				const more = theme
 					? theme.fg("dim", `… ${lines.length - count} more files`)
 					: `${FG_DIM}… ${lines.length - count} more files${RST}`;
-				out.push(`  ${more}`);
+				out.push(`${TOOL_RESULT_INDENT}${more}`);
 				return out.join("\n");
 			}
-			out.push(`  ${files[i]}`);
+			out.push(`${TOOL_RESULT_INDENT}${files[i]}`);
 			count++;
 		}
 	}
@@ -364,10 +367,10 @@ export async function renderGrepResults(text: string, pattern: string): Promise<
 			const nw = Math.max(3, lineNo.length);
 			let display = content;
 			if (re) display = content.replace(re, `${RST}${FG_YELLOW}\x1b[1m$1${RST}`);
-			out.push(`  ${lnum(Number(lineNo), nw)} ${FG_RULE}│${RST} ${display}${RST}`);
+			out.push(`${TOOL_RESULT_INDENT}${lnum(Number(lineNo), nw)} ${FG_RULE}│${RST} ${display}${RST}`);
 			count++;
 		} else if (line.trim() === "--") {
-			out.push(`  ${FG_DIM}  ···${RST}`);
+			out.push(`${TOOL_RESULT_INDENT}${FG_DIM}  ···${RST}`);
 		} else if (line.trim()) {
 			out.push(line);
 			count++;
@@ -407,9 +410,15 @@ export function makeRenderResult() {
 			const preview = lines.slice(0, maxShow).join("\n");
 			const more = lines.length > maxShow ? `\n${FG_DIM}... ${lines.length - maxShow} more lines${RST}` : "";
 			const metrics = renderToolMetrics(result);
-			text.setText(fillToolBackground(`  ${preview}${more}${metrics ? `\n  ${metrics}` : ""}`, undefined, renderWidth));
+			text.setText(
+				fillToolBackground(
+					`${TOOL_RESULT_INDENT}${preview}${more}${metrics ? `\n${TOOL_RESULT_INDENT}${metrics}` : ""}`,
+					undefined,
+					renderWidth,
+				),
+			);
 		} else {
-			text.setText(fillToolBackground(`  ${theme.fg("dim", "(no text output)")}`));
+			text.setText(fillToolBackground(`${TOOL_RESULT_INDENT}${theme.fg("dim", "(no text output)")}`));
 		}
 		return text;
 	};

package/src/tools/bash.ts

@@ -1,26 +1,12 @@
 /* pi-pretty: bash tool -- command execution with styled output. */
 
-import {
-	type ToolDefinition,
-	type ExtensionAPI,
-	type ExtensionContext,
-	type AgentToolResult,
-} from "@earendil-works/pi-coding-agent";
-import type { SdkToolDef, BashDetails, TextContent, ComponentLike, ThemeLike, RenderCtxLike } from "../types.js";
-import {
-	resolveBaseBackground,
-	termWidth,
-	MAX_PREVIEW_LINES,
-	BG_BASE,
-	BG_ERROR,
-	FG_DIM,
-	FG_RULE,
-	RST,
-} from "../config.js";
-import { wrapExecuteWithMetrics } from "./metrics.js";
-import { renderBashOutput, renderToolError, renderToolMetrics, fillToolBackground } from "../render.js";
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { BG_BASE, FG_DIM, MAX_PREVIEW_LINES, resolveBaseBackground, TOOL_RESULT_INDENT, termWidth } from "../config.js";
+import { compactErrorLines, inferBashExitCode, stripBashExitStatusLine } from "../helpers.js";
+import { fillToolBackground, renderToolDuration, renderToolError } from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
-import { stripBashExitStatusLine, inferBashExitCode, compactErrorLines } from "../helpers.js";
+import type { BashDetails, ComponentLike, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
+import { wrapExecuteWithMetrics } from "./metrics.js";
 
 type Result = AgentToolResult<Record<string, unknown>>;
 
@@ -38,8 +24,8 @@ export function registerBashTool(
 		label: "Bash",
 		description: sdkTool.description
 			? `${sdkTool.description} For text search: \`rg -n\`.`
-			: "Execute shell commands. For text search: \`rg -n\`.",
-		promptSnippet: "Execute commands via bash. For text search: \`rg -n\`.",
+			: "Execute shell commands. For text search: `rg -n`.",
+		promptSnippet: "Execute commands via bash. For text search: `rg -n`.",
 		promptGuidelines: [
 			"For text search: `rg -n`. If no results, try `rg -u` (respects .gitignore by default).",
 			"In rg: | means alternation, \\| means literal pipe. Opposite of GNU grep. Never use \\| for alternation.",
@@ -71,19 +57,16 @@ export function registerBashTool(
 			const t = typeof args.timeout === "number" ? ` ${theme.fg("muted", `(timeout ${args.timeout}s)`)}` : "";
 			const tw = termWidth() || 80;
 			const rawCmd = String(args.command ?? "");
+			const headerBudget = ctx.expanded ? tw : Math.max(8, tw - 20);
 			const cmd =
 				rawCmd.length === 0
 					? theme.fg("toolOutput", "...")
-					: rawCmd.length > tw - 20
-						? rawCmd.slice(0, Math.max(1, tw - 20)) + "…"
+					: !ctx.expanded && rawCmd.length > headerBudget
+						? `${rawCmd.slice(0, Math.max(1, headerBudget))}…`
 						: rawCmd;
-			const toolWidth = ctx.expanded ? undefined : tw;
+			const commandLabel = theme.fg(ctx.isError ? "error" : "toolTitle", theme.bold(`$ ${cmd}`));
 			text.setText(
-				fillToolBackground(
-					`\n  ${theme.fg("toolTitle", theme.bold(`$ ${cmd}`))}${t}`,
-					ctx.isError ? BG_ERROR : undefined,
-					toolWidth,
-				),
+				fillToolBackground(`\n${TOOL_RESULT_INDENT}${commandLabel}${t}`, undefined, ctx.expanded ? undefined : tw),
 			);
 			return text;
 		},
@@ -109,25 +92,22 @@ export function registerBashTool(
 
 			if (d?._type === "bashResult") {
 				const isErr = ctx.isError || (d.exitCode !== null && d.exitCode !== 0);
-				const bg = isErr ? BG_ERROR : undefined;
 				const cleaned = stripBashExitStatusLine(d.text);
 				const output = isErr ? compactErrorLines(cleaned).join("\n") : cleaned;
-				const { summary } = renderBashOutput(output, d.exitCode);
 				const lineCount = output.split("\n").length;
-				const info =
-					lineCount > 1
-						? `  ${FG_DIM}(${lineCount} lines)${RST} ${renderToolMetrics(result)}`
-						: ` ${renderToolMetrics(result)}`;
-				const header = `  ${summary}${info}`;
+				const info = [`${lineCount} lines`, renderToolDuration(result), !ctx.expanded ? "ctrl+o to expand" : ""]
+					.filter(Boolean)
+					.map((part) => theme.fg("dim", part))
+					.join(theme.fg("dim", " · "));
+				const header = `${TOOL_RESULT_INDENT}${info}`;
 				const rw = termWidth();
 
 				const renderFn = (w: number) => {
-					if (!output.trim()) return fillToolBackground(header, bg, w);
-					const max = ctx.expanded ? lineCount : MAX_PREVIEW_LINES;
-					const show = output.split("\n").slice(0, max);
-					const out = [header, rule(w), ...show.map((l: string) => `  ${l}`)];
-					if (lineCount > max) out.push(`${FG_DIM}  \u2026 ${lineCount - max} more lines${RST}`);
-					return fillToolBackground(out.join("\n"), bg, w);
+					if (!ctx.expanded) return fillToolBackground(`${header}\n`, undefined, w);
+					if (!output.trim()) return fillToolBackground(`${header}\n`, undefined, w);
+					const show = output.split("\n");
+					const out = [header, "", ...show.map((line: string) => `${TOOL_RESULT_INDENT}${line}`)];
+					return fillToolBackground(`${out.join("\n")}\n`, undefined, w);
 				};
 
 				text.setText(renderFn(rw));
@@ -137,7 +117,7 @@ export function registerBashTool(
 					let key: string | undefined;
 					(text as unknown as Record<string, unknown>).render = (w: number) => {
 						const width = Math.max(1, Math.floor(w || termWidth()));
-						const k = `bash:${ctx.expanded ? "1" : "0"}:${width}:${d.exitCode ?? "killed"}:${output.length}:${renderToolMetrics(result)}`;
+						const k = `bash:${ctx.expanded ? "1" : "0"}:${width}:${d.exitCode ?? "killed"}:${output.length}:${renderToolDuration(result)}`;
 						if (key !== k) {
 							text.setText(renderFn(width));
 							key = k;
@@ -154,16 +134,15 @@ export function registerBashTool(
 			}
 			const fc = result.content?.[0];
 			text.setText(
-				fillToolBackground(`  ${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`),
+				fillToolBackground(
+					`${TOOL_RESULT_INDENT}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
+				),
 			);
 			return text;
 		},
 	} as unknown as ToolDefinition<any, any, any>);
 }
 
-function rule(w: number): string {
-	return `${FG_RULE}${"\u2500".repeat(w)}${RST}`;
-}
 function getText(result: Result): string {
 	return (
 		((result.content ?? []) as TextContent[])

package/src/tools/find.ts

@@ -1,35 +1,80 @@
-/* pi-pretty: find tool -- FFF-backed file search with SDK fallback. */
-
-import {
-	type ToolDefinition,
-	type ExtensionAPI,
-	type ExtensionContext,
-	type AgentToolResult,
-} from "@earendil-works/pi-coding-agent";
-import { isAbsolute, relative as toRelative } from "node:path";
-import type {
-	SdkToolDef,
-	FindDetails,
-	FffServiceLike,
-	FileItem,
-	TextContent,
-	ThemeLike,
-	RenderCtxLike,
-	ComponentLike,
-} from "../types.js";
-import { resolveBaseBackground, BG_ERROR, FG_DIM, RST } from "../config.js";
+/* pi-pretty: find tool -- FFF-backed file search with SDK (fd) fallback. */
+
+import { isAbsolute, relative } from "node:path";
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { BG_ERROR, FG_DIM, RST, resolveBaseBackground, TOOL_RESULT_INDENT } from "../config.js";
+import { isLikelyGlobPattern, normalizeFindGlobPattern } from "../find-glob.js";
 import { shortPath } from "../helpers.js";
-import { wrapExecuteWithMetrics } from "./metrics.js";
-import { renderFindResults, renderToolError, renderToolMetrics, fillToolBackground } from "../render.js";
-import { resolveTextCtor } from "../tui-text.js";
 import { NOTICE_PARTIAL_FILE_INDEX } from "../notices.js";
+import { fillToolBackground, renderFindResults, renderToolDuration, renderToolError } from "../render.js";
+import { resolveTextCtor } from "../tui-text.js";
+import type { FffServiceWithCursor, FindDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
+import { wrapExecuteWithMetrics } from "./metrics.js";
 
 type Result = AgentToolResult<Record<string, unknown>>;
 
+function getText(result: Result): string {
+	return (result.content ?? [])
+		.filter((c) => c.type === "text")
+		.map((c) => (c as TextContent).text ?? "")
+		.join("\n");
+}
+
+function buildGlobPattern(pattern: string, path: string | undefined, basePath: string | null): string {
+	const raw = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+	const normalized = normalizeFindGlobPattern(raw);
+	let cleanPath = path ?? "";
+	if (cleanPath && isAbsolute(cleanPath) && basePath) {
+		cleanPath = relative(basePath, cleanPath) || "";
+	}
+	cleanPath = cleanPath.replace(/\/$/, "");
+	if (cleanPath) {
+		if (normalized.startsWith("**/")) {
+			return `${cleanPath}/${normalized}`;
+		}
+		if (normalized.includes("/")) {
+			return `${cleanPath}/${normalized}`;
+		}
+		return `${cleanPath}/**/${normalized}`;
+	}
+	return normalized.startsWith("**/") || normalized.includes("/") ? normalized : `**/${normalized}`;
+}
+
+function appendFindNotices(result: Result, extra: string[]): Result {
+	if (extra.length === 0) return result;
+	const d = result.details;
+	if (!d || d._type !== "findResult") return result;
+	const prev = Array.isArray(d.notices) ? (d.notices as string[]) : [];
+	return { ...result, details: { ...d, notices: [...prev, ...extra] } };
+}
+
+async function sdkFindAsFindResult(
+	sdkTool: SdkToolDef,
+	tid: string,
+	params: Record<string, unknown>,
+	sig: AbortSignal | undefined,
+	ctx: ExtensionContext,
+	pattern: string,
+	extraNotices: string[],
+): Promise<Result> {
+	const result = (await sdkTool.execute(tid, params, sig, undefined, ctx)) as Result;
+	const tc = getText(result);
+	const prev = (result.details as FindDetails | undefined)?.notices ?? [];
+	const notices = [...(Array.isArray(prev) ? prev : []), ...extraNotices];
+	result.details = {
+		_type: "findResult",
+		text: tc,
+		pattern,
+		matchCount: tc ? tc.trim().split("\n").filter(Boolean).length : 0,
+		notices,
+	};
+	return result;
+}
+
 export function registerFindTool(
 	pi: ExtensionAPI,
 	cwd: string,
-	fffService: FffServiceLike | null | undefined,
+	fffService: FffServiceWithCursor | null | undefined,
 	sdkTool: SdkToolDef,
 	TextComp?: new (t?: string, x?: number, y?: number) => { setText(v: string): void },
 ): void {
@@ -44,32 +89,40 @@ export function registerFindTool(
 		renderShell: "self",
 
 		execute: wrapExecuteWithMetrics(async (tid, params, sig, _upd, ctx: ExtensionContext) => {
-			const pattern = String((params as any).pattern ?? "");
-			const path = (params as any).path ? String((params as any).path) : undefined;
-			const limit = (params as any).limit;
-			const glob = (params as any).glob;
-
+			const pattern = String(params.pattern ?? "");
+			const path = params.path ? String(params.path) : undefined;
+			const limit = params.limit;
 			const fff = fffService?.isAvailable ? fffService.getFinder() : null;
+
 			if (fff) {
 				try {
 					const effectiveLimit = Math.max(1, typeof limit === "number" ? limit : 100);
 					const basePathResult = fff.getBasePath();
 					const basePath = basePathResult.ok ? basePathResult.value : null;
-					let cleanPath = path ?? "";
-					if (cleanPath && isAbsolute(cleanPath) && basePath) {
-						cleanPath = toRelative(basePath, cleanPath) || "";
-					}
-					cleanPath = cleanPath.replace(/\/$/, "");
-					const cleanPattern = pattern.startsWith("/") ? pattern.slice(1) : pattern;
-					const globPattern = cleanPath ? `${cleanPath}/**/${cleanPattern}` : `**/${cleanPattern}`;
-					const searchResult = fff.glob(globPattern, { pageSize: effectiveLimit });
+					const globPattern = buildGlobPattern(pattern, path, basePath);
+					const searchResult = fff.glob(globPattern, {
+						pageSize: effectiveLimit,
+					});
+
 					if (searchResult.ok) {
-						const items: FileItem[] = searchResult.value.items.slice(0, effectiveLimit);
+						const items = searchResult.value.items.slice(0, effectiveLimit);
 						const notices: string[] = [];
 						if (fffService?.partialIndex) notices.push(NOTICE_PARTIAL_FILE_INDEX);
 						if (items.length >= effectiveLimit) notices.push(`${effectiveLimit} limit reached`);
-						if (searchResult.value.totalMatched > items.length)
+						if (searchResult.value.totalMatched > items.length) {
 							notices.push(`${searchResult.value.totalMatched} total matches`);
+						}
+
+						if (items.length === 0 && isLikelyGlobPattern(pattern)) {
+							return sdkFindAsFindResult(sdkTool, tid, params, sig, ctx, pattern, [
+								"FFF glob returned no matches; results from SDK find (fd).",
+								...notices,
+							]);
+						}
+
+						if (items.length > 0) notices.push("Search engine: FFF glob.");
+						else if (notices.length === 0) notices.push("Search engine: FFF glob (no matches).");
+
 						const paths = items.map((i) => i.relativePath).join("\n");
 						return {
 							content: [{ type: "text" as const, text: paths }],
@@ -79,7 +132,7 @@ export function registerFindTool(
 								pattern,
 								matchCount: items.length,
 								notices,
-							} as FindDetails,
+							},
 						};
 					}
 				} catch {
@@ -87,82 +140,74 @@ export function registerFindTool(
 				}
 			}
 
-			const result = (await sdkTool.execute(tid, params, sig, undefined, ctx)) as Result;
-			const tc = getText(result);
-			result.details = {
-				_type: "findResult",
-				text: tc,
-				pattern,
-				matchCount: tc ? tc.trim().split("\n").filter(Boolean).length : 0,
-			} as FindDetails;
-			return result;
+			return sdkFindAsFindResult(sdkTool, tid, params, sig, ctx, pattern, [
+				fff ? "FFF find unavailable; results from SDK find (fd)." : "Search engine: SDK find (fd).",
+			]);
 		}),
 
 		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
-			const text = ctx.lastComponent ?? new TC("", 0, 0);
-			const pattern = args.pattern === null || args.pattern === undefined ? "" : String(args.pattern);
-			const path =
-				args.path === null || args.path === undefined ? "<missing>" : shortPath(cwd, home, String(args.path));
-			const limit = args.limit;
-			const glob = args.glob;
-			const findLabel = theme.fg("toolTitle", theme.bold("find"));
-			const patternPart = pattern ? theme.fg("accent", pattern) : "";
+			const a = args as { pattern?: unknown; path?: unknown; limit?: unknown };
+			const text = (ctx as RenderCtxLike).lastComponent ?? new TC("", 0, 0);
+			const pattern = a.pattern == null ? "" : String(a.pattern);
+			const pathArg = a.path == null ? "<missing>" : shortPath(cwd, home, String(a.path));
+			const limit = a.limit;
+			const findLabel = theme.fg(ctx.isError ? "error" : "toolTitle", theme.bold("✱ find"));
+			const patternPart = pattern ? theme.fg("toolTitle", pattern) : "";
 			const inPart = theme.fg("dim", " in ");
-			const pathPart = theme.fg("toolOutput", path);
+			const pathPart = theme.fg("toolOutput", pathArg);
 			const limitPart = limit !== undefined && limit !== null ? theme.fg("dim", ` limit ${limit}`) : "";
 			const out = `${findLabel} ${patternPart}${inPart}${pathPart}${limitPart}`;
-			text.setText(fillToolBackground(`  \n  ${out}`, ctx.isError ? BG_ERROR : undefined));
+			text.setText(fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}`, ctx.isError ? BG_ERROR : undefined));
 			return text;
 		},
 
 		renderResult(result: Result, _opt: unknown, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
-			const text = ctx.lastComponent ?? new TC("", 0, 0);
+			const r = result;
+			const text = (ctx as RenderCtxLike).lastComponent ?? new TC("", 0, 0);
 			if (ctx.isError) {
-				text.setText(renderToolError(getText(result) || "Error", theme));
+				text.setText(renderToolError(getText(r) || "Error", theme));
 				return text;
 			}
-			const d = result.details as FindDetails | undefined;
+			const d = r.details as FindDetails | undefined;
 			if (d?._type === "findResult") {
 				if (!d.text.trim()) {
-					const notices = (d as any).notices as string[] | undefined;
-					const noticeStr = notices?.length ? `\n  ${theme.fg("warning", `[${notices.join(". ")}]`)}` : "";
-					text.setText(fillToolBackground(`  \n  ${theme.fg("dim", "0 files")}${noticeStr}\n  `));
+					const noticeStr = d.notices?.length
+						? `\n${TOOL_RESULT_INDENT}${theme.fg("warning", `[${d.notices.join(". ")}]`)}`
+						: "";
+					text.setText(fillToolBackground(`\n${TOOL_RESULT_INDENT}${theme.fg("dim", "0 files")}${noticeStr}\n`));
+					return text;
+				}
+				if (!ctx.expanded) {
+					const duration = renderToolDuration(r);
+					text.setText(
+						fillToolBackground(
+							`${TOOL_RESULT_INDENT}${FG_DIM}${d.matchCount} files — ctrl+o to expand${RST}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}\n`,
+						),
+					);
 					return text;
 				}
 				const rendered = renderFindResults(d.text, theme)
 					.split("\n")
-					.map((l) => `  ${l}`)
+					.map((l) => `${TOOL_RESULT_INDENT}${l}`)
 					.join("\n");
-				const notices = (d as any).notices as string[] | undefined;
-				const noticeStr = notices?.length ? `\n  ${theme.fg("warning", `[${notices.join(". ")}]`)}` : "";
+				const noticeStr = d.notices?.length
+					? `\n${TOOL_RESULT_INDENT}${theme.fg("warning", `[${d.notices.join(". ")}]`)}`
+					: "";
+				const duration = renderToolDuration(r);
 				text.setText(
 					fillToolBackground(
-						`  \n  ${theme.fg("dim", `${d.matchCount} files`)}${renderToolMetrics(result)}\n${rendered}${noticeStr}\n  `,
+						`\n${TOOL_RESULT_INDENT}${theme.fg("dim", `${d.matchCount} files`)}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}\n${rendered}${noticeStr}\n`,
 					),
 				);
 				return text;
 			}
-			const fc = result.content?.[0];
+			const fc = r.content?.[0] as TextContent | undefined;
 			text.setText(
-				fillToolBackground(
-					`  \n  ${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "0 files")}\n  `,
-				),
+				fillToolBackground(`\n${TOOL_RESULT_INDENT}${theme.fg("dim", fc?.text?.slice(0, 120) ?? "0 files")}\n`),
 			);
 			return text;
 		},
-	} as unknown as ToolDefinition<any, any, any>);
-}
-
-function appendNotices(text: string, notices: string[]): string {
-	return notices.length ? `${text}\n\n[${notices.join(". ")}]` : text;
-}
-function getText(result: Result): string {
-	return (
-		((result.content ?? []) as TextContent[])
-			.filter((c) => c.type === "text")
-			.map((c) => c.text ?? "")
-			.join("\n") ?? ""
-	);
+	} as unknown as ToolDefinition);
 }