@heyhuynhgiabuu/pi-pretty 0.6.2 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@heyhuynhgiabuu/pi-pretty",
-	"version": "0.6.2",
+	"version": "0.6.3",
 	"description": "Pretty terminal output for pi — syntax-highlighted file reads, colored bash output, tree-view directory listings, and more.",
 	"author": "huynhgiabuu",
 	"license": "MIT",
@@ -47,7 +47,7 @@
 	},
 	"pi": {
 		"extensions": [
-			"./src/index.ts"
+			"./dist/index.js"
 		]
 	}
 }

package/src/index.ts

@@ -246,4 +246,25 @@ export default function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrettyDeps)
 	pi.on("session_shutdown", async () => {
 		fffService?.destroy();
 	});
+
+	// Fallback padding for SDK-rendered tool bodies. The SDK reads
+	// result.content[0].text and slices collapsed output to roughly the first
+	// 10 lines, so insert bottom padding inside that visible slice.
+    	const PADDED_TOOLS = new Set(["read", "grep", "bash"]);
+    	const RESULT_LEFT_PAD = "    ";
+    	const BOTTOM_PADDING_BY_TOOL: Record<string, number> = { read: 2, grep: 2, bash: 0 };
+    	pi.on("tool_result", (event, _ctx) => {
+    		if (!PADDED_TOOLS.has(event.toolName)) return undefined;
+    		const first = event.content[0];
+    		if (!first || first.type !== "text") return undefined;
+    		const lines = first.text.split("\n").map((line) => `${RESULT_LEFT_PAD}${line}`);
+    		if (lines.length === 0) return undefined;
+
+    		const padCount = BOTTOM_PADDING_BY_TOOL[event.toolName] ?? 0;
+    		lines.push(...Array.from({ length: padCount }, () => RESULT_LEFT_PAD));
+
+    		return {
+    			content: [{ type: "text" as const, text: lines.join("\n") }, ...event.content.slice(1)],
+    		};
+    	});
 }

package/src/render.ts

@@ -184,36 +184,21 @@ export function renderToolError(error: string, theme: ThemeLike): string {
 export async function renderFileContent(
 	content: string,
 	filePath: string,
-	offset = 1,
+	offset = 0,
 	maxLines = MAX_PREVIEW_LINES,
 	width?: number,
 ): Promise<string> {
 	const normalizedContent = normalizeLineEndings(content);
 	const lines = normalizedContent.split("\n");
-	const total = lines.length;
 	const show = lines.slice(0, maxLines);
 	const lg = detectLang(filePath);
 	const hl = await hlBlock(show.join("\n"), lg);
 
 	const tw = width ?? termWidth();
-	const startLine = offset;
-	const endLine = startLine + show.length - 1;
-	const nw = Math.max(3, String(endLine).length);
-	const gw = nw + 3;
-	const cw = Math.max(1, tw - gw);
 
 	const out: string[] = [];
-	out.push(rule(tw));
-
-	for (let i = 0; i < hl.length; i++) {
-		const ln = startLine + i;
-		const code = hl[i] ?? show[i] ?? "";
-		const display = truncateToWidth(code, cw, `${FG_DIM}›`);
-		out.push(`${lnum(ln, nw)} ${FG_RULE}│${RST} ${display}${RST}`);
-	}
-
-	if (total > maxLines) {
-		out.push(`${FG_DIM}  … ${total - maxLines} more lines (${total} total)${RST}`);
+	for (const line of hl) {
+		out.push(truncateToWidth(line ?? "", Math.max(1, tw), `${FG_DIM}›`));
 	}
 	return out.join("\n");
 }
@@ -270,44 +255,44 @@ export function renderTree(text: string, _basePath: string): string {
 	return out.join("\n");
 }
 
-// ---------------------------------------------------------------------------
-// Find — grouped file list with icons
-// ---------------------------------------------------------------------------
-
-export function renderFindResults(text: string): string {
-	const lines = text.trim().split("\n").filter(Boolean);
-	if (!lines.length) return `${FG_DIM}(no matches)${RST}`;
-
-	const groups = new Map<string, string[]>();
-	for (const line of lines) {
-		const trimmed = line.trim();
-		const dir = dirname(trimmed) || ".";
-		const file = basename(trimmed);
-		if (!groups.has(dir)) groups.set(dir, []);
-		const bucket = groups.get(dir);
-		if (bucket) bucket.push(file);
-	}
-
-	const out: string[] = [];
-	let count = 0;
-
-	for (const [dir, files] of groups) {
-		if (count > 0) out.push("");
-		out.push(`${dirIcon()}${FG_BLUE}\x1b[1m${dir}/${RST}`);
-		for (let i = 0; i < files.length; i++) {
-			if (count >= MAX_PREVIEW_LINES) {
-				out.push(`  ${FG_DIM}… ${lines.length - count} more files${RST}`);
-				return out.join("\n");
-			}
-			const isLast = i === files.length - 1;
-			const prefix = isLast ? "└── " : "├── ";
-			out.push(`  ${FG_RULE}${prefix}${RST}${files[i]}`);
-			count++;
-		}
-	}
-
-	return out.join("\n");
-}
+    // ---------------------------------------------------------------------------
+    // Find — grouped file list (plain, no tree characters or icons)
+    // ---------------------------------------------------------------------------
+    
+    export function renderFindResults(text: string, theme?: ThemeLike): string {
+    	const lines = text.trim().split("\n").filter(Boolean);
+    	if (!lines.length) return theme ? theme.fg("dim", "(no matches)") : `${FG_DIM}(no matches)${RST}`;
+    
+    	const groups = new Map<string, string[]>();
+    	for (const line of lines) {
+    		const trimmed = line.trim();
+    		const dir = dirname(trimmed) || ".";
+    		const file = basename(trimmed);
+    		if (!groups.has(dir)) groups.set(dir, []);
+    		const bucket = groups.get(dir);
+    		if (bucket) bucket.push(file);
+    	}
+    
+    	const out: string[] = [];
+    	let count = 0;
+    
+    	for (const [dir, files] of groups) {
+    		if (count > 0) out.push("");
+    		const dirColored = theme ? theme.fg("accent", theme.bold(`${dir}/`)) : `${FG_BLUE}\x1b[1m${dir}/${RST}`;
+    		out.push(dirColored);
+    		for (let i = 0; i < files.length; i++) {
+    			if (count >= MAX_PREVIEW_LINES) {
+    				const more = theme ? theme.fg("dim", `… ${lines.length - count} more files`) : `${FG_DIM}… ${lines.length - count} more files${RST}`;
+    				out.push(`  ${more}`);
+    				return out.join("\n");
+    			}
+    		out.push(`  ${files[i]}`);
+    		count++;
+    	}
+    	}
+    
+            	return out.join("\n");
+            }
 
 // ---------------------------------------------------------------------------
 // Grep — highlighted matches with line numbers

package/src/tools/bash.ts

@@ -37,18 +37,15 @@ export function registerBashTool(
 			}
 		}),
 
-			renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
+		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
 			const text = ctx.lastComponent ?? new TC("", 0, 0);
-			const t = typeof args.timeout === "number" ? ` ${theme.fg("muted", `(${args.timeout}s timeout)`)}` : "";
+			const t = typeof args.timeout === "number" ? ` ${theme.fg("muted", `(timeout ${args.timeout}s)`)}` : "";
 			const tw = termWidth() || 80;
 			const rawCmd = String(args.command ?? "");
-			const cmd = (() => {
-				const ml = Math.max(1, tw - 20);
-				return rawCmd.length > ml ? rawCmd.slice(0, ml) + "\u2026" : rawCmd;
-			})();
+			const cmd = rawCmd.length === 0 ? theme.fg("toolOutput", "...") : (rawCmd.length > tw - 20 ? rawCmd.slice(0, Math.max(1, tw - 20)) + "…" : rawCmd);
 			const toolWidth = ctx.expanded ? undefined : tw;
-			text.setText(fillToolBackground(`\n  ${theme.fg("toolTitle", theme.bold("bash"))} ${theme.fg("accent", cmd)}${t}`, ctx.isError ? BG_ERROR : undefined, toolWidth));
+			text.setText(fillToolBackground(`\n  ${theme.fg("toolTitle", theme.bold(`$ ${cmd}`))}${t}`, ctx.isError ? BG_ERROR : undefined, toolWidth));
 			return text;
 		},
 

package/src/tools/find.ts

@@ -1,6 +1,7 @@
 /* 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";
 import { shortPath } from "../helpers.js";
@@ -32,24 +33,35 @@ export function registerFindTool(
 		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 = typeof (params as any).limit === "number" ? (params as any).limit : 200;
+			const limit = (params as any).limit;
+			const glob = (params as any).glob;
 
-			if (fffService?.isAvailable) {
+			const fff = fffService?.isAvailable ? fffService.getFinder() : null;
+			if (fff) {
 				try {
-					const fff = fffService.getFinder();
-					if (!fff) throw new Error("FFF finder not available");
-					const effectiveLimit = Math.max(1, limit);
-					const searchResult = fff.fileSearch(path ? `${path} ${pattern}` : pattern, { pageSize: effectiveLimit });
-					if (searchResult.ok) {
-						const items: FileItem[] = searchResult.value.items.slice(0, effectiveLimit);
-						const notices: string[] = [];
-						if (fffService.partialIndex) notices.push("Warning: partial file index");
-						if (items.length >= effectiveLimit) notices.push(`${effectiveLimit} limit reached`);
-						if (searchResult.value.totalMatched > items.length) notices.push(`${searchResult.value.totalMatched} total matches`);
-						const text = appendNotices(items.map((i) => i.relativePath).join("\n"), notices);
-						return { content: [{ type: "text" as const, text }], details: { _type: "findResult", text, pattern, matchCount: items.length } as FindDetails };
+					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) || "";
 					}
-				} catch { /* fall through */ }
+					cleanPath = cleanPath.replace(/\/$/, "");
+					const cleanPattern = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+					const globPattern = cleanPath
+						? `${cleanPath}/**/${cleanPattern}`
+						: `**/${cleanPattern}`;
+					const searchResult = fff.glob(globPattern, { pageSize: effectiveLimit });
+    					if (searchResult.ok) {
+    						const items: FileItem[] = searchResult.value.items.slice(0, effectiveLimit);
+    						const notices: string[] = [];
+    						if (fffService?.partialIndex) notices.push("Warning: partial file index");
+    						if (items.length >= effectiveLimit) notices.push(`${effectiveLimit} limit reached`);
+    						if (searchResult.value.totalMatched > items.length) notices.push(`${searchResult.value.totalMatched} total matches`);
+    						const paths = items.map((i) => i.relativePath).join("\n");
+    						return { content: [{ type: "text" as const, text: paths }], details: { _type: "findResult", text: paths, pattern, matchCount: items.length, notices } as FindDetails };
+    					}
+				} catch { /* fall through to SDK */ }
 			}
 
 			const result = await sdkTool.execute(tid, params, sig, undefined, ctx) as Result;
@@ -58,11 +70,20 @@ export function registerFindTool(
 			return result;
 		}),
 
-		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
+    		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
 			const text = ctx.lastComponent ?? new TextComp!("", 0, 0);
-			const p = args.path ? ` ${theme.fg("muted", `in ${shortPath(cwd, home, String(args.path))}`)}` : "";
-			text.setText(fillToolBackground(`\n  ${theme.fg("toolTitle", theme.bold("find"))} ${theme.fg("accent", String(args.pattern ?? ""))}${p}`, ctx.isError ? BG_ERROR : undefined));
+			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 inPart = theme.fg("dim", " in ");
+			const pathPart = theme.fg("toolOutput", path);
+			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));
 			return text;
 		},
 
@@ -71,13 +92,21 @@ export function registerFindTool(
 			const text = ctx.lastComponent ?? new TextComp!("", 0, 0);
 			if (ctx.isError) { text.setText(renderToolError(getText(result) || "Error", theme)); return text; }
 			const d = result.details as FindDetails | undefined;
-			if (d?._type === "findResult" && d.text) {
-				const rendered = renderFindResults(d.text).split("\n").map(l => `  ${l}`).join("\n");
-				text.setText(fillToolBackground(`  ${FG_DIM}${d.matchCount} files${RST}${renderToolMetrics(result)}\n${rendered}`));
-				return text;
+			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  `));
+    					return text;
+    				}
+    				const rendered = renderFindResults(d.text, theme).split("\n").map(l => `  ${l}`).join("\n");
+    				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", `${d.matchCount} files`)}${renderToolMetrics(result)}\n${rendered}${noticeStr}\n  `));
+    				return text;
 			}
 			const fc = result.content?.[0];
-			text.setText(fillToolBackground(`  ${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "found")}`));
+			text.setText(fillToolBackground(`  \n  ${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "0 files")}\n  `));
 			return text;
 		},
 	} as unknown as ToolDefinition<any, any, any>);

package/src/tools/grep.ts

@@ -2,12 +2,15 @@
 
 import { type ToolDefinition, type ExtensionAPI, type ExtensionContext, type AgentToolResult } from "@earendil-works/pi-coding-agent";
 import type { SdkToolDef, GrepDetails, FffServiceWithCursor, TextContent, ThemeLike, RenderCtxLike } from "../types.js";
-import { resolveBaseBackground, MAX_PREVIEW_LINES, BG_ERROR, FG_DIM, FG_LNUM, FG_RULE, RST } from "../config.js";
+import { keyHint } from "@earendil-works/pi-coding-agent";
+import { MAX_PREVIEW_LINES, BG_ERROR, resolveBaseBackground } from "../config.js";
 import { shortPath, normalizeLineEndings } from "../helpers.js";
 import { wrapExecuteWithMetrics } from "./metrics.js";
-import { renderToolError, renderToolMetrics, fillToolBackground } from "../render.js";
+import { renderToolError, fillToolBackground } from "../render.js";
 import { fffFormatGrepText } from "../fff-helpers.js";
 
+const invalidArg = "<missing>";
+
 type Result = AgentToolResult<Record<string, unknown>>;
 
 export function registerGrepTool(
@@ -70,9 +73,18 @@ export function registerGrepTool(
 		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
 			const text = ctx.lastComponent ?? new T("", 0, 0);
-			const p = args.path ? ` ${theme.fg("muted", `in ${shortPath(cwd, home, String(args.path))}`)}` : "";
-			const lit = args.literal ? ` ${theme.fg("dim", "[literal]")}` : "";
-			text.setText(fillToolBackground(`\n  ${theme.fg("toolTitle", theme.bold("grep"))} ${theme.fg("accent", String(args.pattern ?? ""))}${p}${lit}`, ctx.isError ? BG_ERROR : undefined));
+			const pattern = args.pattern === null || args.pattern === undefined ? invalidArg : String(args.pattern);
+			const path = args.path === null || args.path === undefined ? invalidArg : shortPath(cwd, home, String(args.path));
+			const glob = args.glob;
+			const limit = args.limit;
+			const literal = args.literal === true;
+			const caseInsensitive = args.caseInsensitive === true || args.ignoreCase === true;
+			let out = `${theme.fg("toolTitle", theme.bold("grep"))} ${theme.fg("accent", `/${pattern || ""}/`)}${theme.fg("toolOutput", ` in ${path}`)}`;
+			if (glob) out += theme.fg("dim", ` (${String(glob)})`);
+			if (limit !== undefined && limit !== null) out += theme.fg("dim", ` limit ${limit}`);
+			if (literal) out += theme.fg("dim", ` (literal)`);
+			if (caseInsensitive) out += theme.fg("dim", ` (case-insensitive)`);
+			text.setText(fillToolBackground(`\n  ${out}`, ctx.isError ? BG_ERROR : undefined));
 			return text;
 		},
 
@@ -85,38 +97,22 @@ export function registerGrepTool(
 				const lines = d.text.split("\n");
 				const maxShow = ctx.expanded ? lines.length : Math.min(lines.length, MAX_PREVIEW_LINES);
 				const show = lines.slice(0, maxShow);
-				const nw = Math.max(3, 5);
-
-				// Build highlight regex from pattern
-				let hlRe: RegExp | null = null;
-				try { hlRe = new RegExp(`(${d.pattern})`, "gi"); } catch {}
-
+				const remaining = lines.length - maxShow;
 				const out: string[] = [];
-				let currentFile = "";
 				for (const line of show) {
-					const fileMatch = line.match(/^(.+?)[:-](\d+)[:-](.*)$/);
-					if (fileMatch) {
-						const [, file, lineNo, content] = fileMatch;
-						if (file !== currentFile) {
-							if (currentFile) out.push("");
-							out.push(`  ${theme.fg("accent", theme.bold(file))}`);
-							currentFile = file;
-						}
-						let display = content;
-						if (hlRe) display = content.replace(hlRe, (m) => `${RST}${theme.fg("warning", theme.bold(m))}${RST}`);
-						const padded = `${FG_LNUM}${String(lineNo).padStart(nw)}${RST} ${FG_RULE}│${RST} ${display}${RST}`;
-						out.push(`  ${padded}`);
-					} else if (line.trim()) {
-						out.push(`  ${FG_DIM}  ${line.trim()}${RST}`);
-					}
+					if (!line) continue;
+					out.push(theme.fg("toolOutput", line));
+				}
+				if (remaining > 0) {
+					out.push(theme.fg("muted", `… (${remaining} more ${remaining === 1 ? "line" : "lines"}, ${keyHint("app.tools.expand", "to expand")})`));
 				}
-				const preview = out.join("\n");
-				const more = lines.length > maxShow ? `\n${FG_DIM}  ... ${lines.length - maxShow} more lines${RST}` : "";
-				text.setText(fillToolBackground(`  ${FG_DIM}${d.matchCount} matches${RST}${renderToolMetrics(result)}\n${preview}${more}`));
+				const body = out.map((l) => `  ${l}`).join("\n") + "\n\n";
+				text.setText(fillToolBackground(body, ctx.isError ? BG_ERROR : undefined));
 				return text;
 			}
 			const fc = result.content?.[0];
-			text.setText(fillToolBackground(`  ${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "no matches")}`));
+			const fallback = fc && "text" in fc ? String(fc.text).slice(0, 120) : "no matches";
+			text.setText(fillToolBackground(`  ${theme.fg("dim", fallback)}`, ctx.isError ? BG_ERROR : undefined));
 			return text;
 		},
 	} as unknown as ToolDefinition<any, any, any>);

package/src/tools/ls.ts

@@ -3,6 +3,7 @@
 import { type ToolDefinition, type ExtensionAPI, type ExtensionContext, type AgentToolResult } from "@earendil-works/pi-coding-agent";
 import type { SdkToolDef, LsDetails, TextContent, ComponentLike, ThemeLike, RenderCtxLike } from "../types.js";
 import { resolveBaseBackground, termWidth, MAX_PREVIEW_LINES, BG_BASE, BG_ERROR, FG_DIM, RST } from "../config.js";
+import { shortPath } from "../helpers.js";
 import { wrapExecuteWithMetrics } from "./metrics.js";
 import { renderTree, renderToolError, renderToolMetrics, fillToolBackground } from "../render.js";
 
@@ -10,11 +11,12 @@ type Result = AgentToolResult<Record<string, unknown>>;
 
 export function registerLsTool(
 	pi: ExtensionAPI,
-	_cwd: string,
+	cwd: string,
 	_fffService: unknown,
 	sdkTool: SdkToolDef,
 	TextComp?: new (t?: string, x?: number, y?: number) => { setText(v: string): void },
 ): void {
+	const home = process.env.HOME ?? "";
 	const TC = TextComp ?? (() => {
 		const { Text } = require("@earendil-works/pi-tui") as { Text: new (t?: string, x?: number, y?: number) => { setText(v: string): void } };
 		return Text;
@@ -36,10 +38,14 @@ export function registerLsTool(
 
 		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
-			
 			const text = ctx.lastComponent ?? new TC("", 0, 0);
-			const p = String(args.path ?? ".");
-			text.setText(fillToolBackground(`\n  ${theme.fg("toolTitle", theme.bold("ls"))} ${theme.fg("accent", p)}`, ctx.isError ? BG_ERROR : undefined));
+			const rawPath = args.path;
+			const path = rawPath === null || rawPath === undefined || String(rawPath).length === 0 ? "" : shortPath(cwd, home, String(rawPath));
+			const limit = args.limit;
+			let out = theme.fg("toolTitle", theme.bold("ls"));
+			if (path) out += ` ${theme.fg("accent", path)}`;
+			if (limit !== undefined && limit !== null) out += theme.fg("toolOutput", ` (limit ${limit})`);
+			text.setText(fillToolBackground(`  \n  ${out}`, ctx.isError ? BG_ERROR : undefined));
 			return text;
 		},
 
@@ -51,7 +57,7 @@ export function registerLsTool(
 			const d = result.details as LsDetails | undefined;
 			if (d?._type === "lsResult" && d.text) {
 				const rendered = renderTree(d.text, d.path).split("\n").map(l => `  ${l}`).join("\n");
-				text.setText(fillToolBackground(`  ${FG_DIM}${d.entryCount} entries${RST}${renderToolMetrics(result)}\n${rendered}`));
+				text.setText(fillToolBackground(`  \n  ${FG_DIM}${d.entryCount} entries${RST}${renderToolMetrics(result)}\n${rendered}\n  `));
 				return text;
 			}
 			const fc = result.content?.[0];

package/src/tools/multi-grep.ts

@@ -136,12 +136,16 @@ export function registerMultiGrepTool(
 
 		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
-			
 			const text = ctx.lastComponent ?? new TC("", 0, 0);
-			const pats = (Array.isArray(args.patterns) ? args.patterns.map(String) : [String(args.patterns ?? "")]);
-			const label = pats.length > 2 ? `${pats[0]}, ${pats[1]}, +${pats.length - 2}` : pats.join(", ");
-			const p = args.path ? ` ${theme.fg("muted", `in ${shortPath(cwd, home, String(args.path))}`)}` : "";
-			text.setText(fillToolBackground(`\n  ${theme.fg("toolTitle", theme.bold("mgrep"))} ${theme.fg("accent", label)}${p}`, ctx.isError ? BG_ERROR : undefined));
+			const patterns: string[] = Array.isArray(args.patterns) ? args.patterns.map((p: unknown) => String(p)) : [];
+			const limit = typeof args.limit === "number" ? args.limit : undefined;
+			const path = args.path === null || args.path === undefined ? "<missing>" : shortPath(cwd, home, String(args.path));
+			const literal = args.literal === true;
+			const patternStr = patterns.length === 0 ? "" : patterns.length === 1 ? patterns[0]! : patterns.length === 2 ? `${patterns[0]}|${patterns[1]}` : `${patterns[0]}|${patterns[1]}|+${patterns.length - 2}`;
+			let out = `${theme.fg("toolTitle", theme.bold("mgrep"))} ${theme.fg("accent", `/${patternStr || ""}/`)}${theme.fg("toolOutput", ` in ${path}`)}`;
+			if (literal) out += theme.fg("dim", ` (literal)`);
+			if (limit !== undefined) out += theme.fg("dim", ` limit ${limit}`);
+			text.setText(fillToolBackground(`\n  ${out}`, ctx.isError ? BG_ERROR : undefined));
 			return text;
 		},
 

package/test/bash-rendering.test.ts

@@ -130,8 +130,8 @@ describe("bash renderCall expansion", () => {
 			invalidate: () => {},
 		});
 
-		expect(collapsed.getText()).toContain("5s timeout");
-		expect(expanded.getText()).toContain("5s timeout");
+		expect(collapsed.getText()).toContain("(timeout 5s)");
+		expect(expanded.getText()).toContain("(timeout 5s)");
 	});
 
 	it("truncates ANSI tool headers that exceed the terminal width", () => {
@@ -184,7 +184,7 @@ describe("bash renderCall expansion", () => {
 			});
 
 			const lines = stripAnsi(rendered.getText()).split("\n");
-			expect(lines[1]).toMatch(/^  bash false/);
+			expect(lines[1]).toMatch(/^  \$ false/);
 		});
 	});
 

package/test/fff-integration.test.ts

@@ -249,13 +249,21 @@ function mkFinder(overrides?: Record<string, any>) {
 	return {
 		isDestroyed: false,
 		waitForScan: vi.fn().mockResolvedValue({ ok: true, value: true }),
-		fileSearch: vi.fn().mockReturnValue({
-			ok: true,
-			value: {
-				items: [{ relativePath: "src/index.ts" }, { relativePath: "src/main.ts" }],
-				totalMatched: 2,
-			},
-		}),
+    		fileSearch: vi.fn().mockReturnValue({
+    			ok: true,
+    			value: {
+    				items: [{ relativePath: "src/index.ts" }, { relativePath: "src/main.ts" }],
+    				totalMatched: 2,
+    			},
+    		}),
+    		glob: vi.fn().mockReturnValue({
+    			ok: true,
+    			value: {
+    				items: [{ relativePath: "src/index.ts" }, { relativePath: "src/main.ts" }],
+    				totalMatched: 2,
+    			},
+    		}),
+    		getBasePath: vi.fn().mockReturnValue({ ok: true, value: "/Users/test/proj" }),
 		grep: vi.fn().mockReturnValue({
 			ok: true,
 			value: {
@@ -489,52 +497,54 @@ describe("piPrettyExtension integration", () => {
 			expect(r.content[0].text).toContain("src/index.ts");
 		});
 
-		it("falls back to SDK on FFF { ok: false }", async () => {
-			await loadWithFFF({
-				fileSearch: vi.fn().mockReturnValue({ ok: false, error: "fail" }),
-			});
-			await tools.get("find")!.execute("t1", { pattern: "*.ts" }, null, null, {});
-			expect(findExec).toHaveBeenCalledOnce();
-		});
-
-		it("falls back to SDK on FFF throw", async () => {
-			await loadWithFFF({
-				fileSearch: vi.fn().mockImplementation(() => { throw new Error("crash"); }),
-			});
-			await tools.get("find")!.execute("t1", { pattern: "*.ts" }, null, null, {});
-			expect(findExec).toHaveBeenCalledOnce();
-		});
-
-		it("respects limit param", async () => {
-			const fileSearch = vi.fn().mockReturnValue({
-				ok: true,
-				value: { items: Array.from({ length: 50 }, (_, i) => ({ relativePath: `f${i}.ts` })), totalMatched: 50 },
-			});
-			await loadWithFFF({ fileSearch });
-			await tools.get("find")!.execute("t1", { pattern: "*.ts", limit: 5 }, null, null, {});
-			expect(fileSearch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ pageSize: 5 }));
-		});
-
-		it("includes path in search query", async () => {
-			const fileSearch = vi.fn().mockReturnValue({ ok: true, value: { items: [], totalMatched: 0 } });
-			await loadWithFFF({ fileSearch });
-			await tools.get("find")!.execute("t1", { pattern: "*.ts", path: "src/" }, null, null, {});
-			expect(fileSearch).toHaveBeenCalledWith("src/ *.ts", expect.any(Object));
-		});
-
-		it("shows partial-index + limit notices", async () => {
+    		it("falls back to SDK on FFF { ok: false }", async () => {
+    			await loadWithFFF({
+    				glob: vi.fn().mockReturnValue({ ok: false, error: "fail" }),
+    			});
+    			await tools.get("find")!.execute("t1", { pattern: "*.ts" }, null, null, {});
+    			expect(findExec).toHaveBeenCalledOnce();
+    		});
+
+    		it("falls back to SDK on FFF throw", async () => {
+    			await loadWithFFF({
+    				glob: vi.fn().mockImplementation(() => { throw new Error("crash"); }),
+    			});
+    			await tools.get("find")!.execute("t1", { pattern: "*.ts" }, null, null, {});
+    			expect(findExec).toHaveBeenCalledOnce();
+    		});
+
+    		it("respects limit param", async () => {
+    			const glob = vi.fn().mockReturnValue({
+    				ok: true,
+    				value: { items: Array.from({ length: 50 }, (_, i) => ({ relativePath: `f${i}.ts` })), totalMatched: 50 },
+    			});
+    			await loadWithFFF({ glob });
+    			await tools.get("find")!.execute("t1", { pattern: "*.ts", limit: 5 }, null, null, {});
+    			expect(glob).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ pageSize: 5 }));
+    		});
+
+    		it("combines path and pattern into glob pattern", async () => {
+    			const glob = vi.fn().mockReturnValue({ ok: true, value: { items: [], totalMatched: 0 } });
+    			await loadWithFFF({ glob });
+    			await tools.get("find")!.execute("t1", { pattern: "*.ts", path: "src" }, null, null, {});
+    			expect(glob).toHaveBeenCalledWith("src/**/*.ts", expect.any(Object));
+    		});
+
+    		it("shows partial-index + limit notices", async () => {
 			await loadWithFFF({
 				waitForScan: vi.fn().mockResolvedValue({ ok: true, value: false }),
-				fileSearch: vi.fn().mockReturnValue({
+				glob: vi.fn().mockReturnValue({
 					ok: true,
 					value: { items: Array.from({ length: 200 }, (_, i) => ({ relativePath: `f${i}` })), totalMatched: 500 },
 				}),
-			});
-			const text = (await tools.get("find")!.execute("t1", { pattern: "*" }, null, null, {})).content[0].text;
-			expect(text).toContain("partial file index");
-			expect(text).toContain("200 limit reached");
-			expect(text).toContain("500 total matches");
+    		});
+    		const result = await tools.get("find")!.execute("t1", { pattern: "*", limit: 200 }, null, null, {});
+			const notices = (result.details as any).notices as string[];
+			expect(notices).toContain("Warning: partial file index");
+			expect(notices).toContain("200 limit reached");
+			expect(notices).toContain("500 total matches");
 		});
+	// ---- grep: FFF path ------------------------------------------------
 	});
 
 	// ---- grep: FFF path ------------------------------------------------