@xynogen/pix-pretty 1.2.0 → 1.3.1

package/src/tools/find.ts

@@ -0,0 +1,159 @@
+import type {
+	ExtensionContext,
+	FindToolInput,
+	ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+
+import { FG_DIM, RST } from "../ansi.js";
+import { renderFindResults } from "../renderers.js";
+import type {
+	FindParams,
+	FindResultDetails,
+	PiPrettyApi,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+} from "../types.js";
+import {
+	appendNotices,
+	fillToolBackground,
+	getTextContent,
+	isTextContent,
+	makeTextResult,
+	renderToolError,
+	setResultDetails,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+export function registerFindTool(
+	pi: PiPrettyApi,
+	createFindTool: ToolFactory<FindToolInput>,
+	ctx: ToolContext,
+): void {
+	const { cwd, sp, TextComponent, fffState } = ctx;
+	const origFind = createFindTool(cwd);
+
+	pi.registerTool({
+		...origFind,
+		name: "find",
+		renderShell: "self",
+
+		async execute(
+			tid: string,
+			params: FindParams,
+			sig: AbortSignal | undefined,
+			upd: unknown,
+			toolCtx: ExtensionContext,
+		) {
+			// Try FFF first (frecency-ranked, SIMD-accelerated)
+			if (fffState.finder && !fffState.finder.isDestroyed) {
+				try {
+					const effectiveLimit = Math.max(1, params.limit ?? 200);
+					let query = params.pattern;
+					if (params.path) query = `${params.path} ${query}`;
+
+					const searchResult = fffState.finder.fileSearch(query, {
+						pageSize: effectiveLimit,
+					});
+					if (searchResult.ok) {
+						const { items, totalMatched } = searchResult.value;
+						const trimmed = items.slice(0, effectiveLimit);
+						const notices: string[] = [];
+						if (fffState.partialIndex)
+							notices.push("Warning: partial file index");
+						if (trimmed.length >= effectiveLimit)
+							notices.push(`${effectiveLimit} limit reached`);
+						if (totalMatched > trimmed.length)
+							notices.push(`${totalMatched} total matches`);
+
+						const textContent = appendNotices(
+							trimmed.map((item) => item.relativePath).join("\n"),
+							notices,
+						);
+						return makeTextResult<FindResultDetails>(textContent, {
+							_type: "findResult",
+							text: textContent,
+							pattern: params.pattern,
+							matchCount: trimmed.length,
+						});
+					}
+				} catch {
+					/* fall through to SDK */
+				}
+			}
+
+			// SDK fallback
+			const result = await origFind.execute(
+				tid,
+				params,
+				sig,
+				upd as never,
+				toolCtx,
+			);
+			const textContent = getTextContent(result);
+			const matchCount = textContent
+				? textContent.trim().split("\n").filter(Boolean).length
+				: 0;
+
+			setResultDetails<FindResultDetails>(result, {
+				_type: "findResult",
+				text: textContent,
+				pattern: params.pattern,
+				matchCount,
+			});
+
+			return result;
+		},
+
+		renderCall(
+			args: FindParams,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const pattern = args.pattern ?? "";
+			const path = args.path
+				? ` ${theme.fg("muted", `in ${sp(args.path)}`)}`
+				: "";
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			text.setText(
+				fillToolBackground(
+					`${theme.fg("toolTitle", theme.bold("find"))} ${theme.fg("accent", pattern)}${path}`,
+				),
+			);
+			return text;
+		},
+
+		renderResult(
+			result: ToolResultLike<FindResultDetails>,
+			_opt: ToolRenderResultOptions,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+
+			if (renderCtx.isError) {
+				text.setText(renderToolError(getTextContent(result) || "Error", theme));
+				return text;
+			}
+
+			const d = result.details;
+			if (d?._type === "findResult" && d.text) {
+				const rendered = renderFindResults(d.text);
+				const info = `${FG_DIM}${d.matchCount} files${RST}`;
+				text.setText(fillToolBackground(`  ${info}\n${rendered}`));
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "found";
+			text.setText(
+				fillToolBackground(
+					`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`,
+				),
+			);
+			return text;
+		},
+	});
+}

package/src/tools/grep.ts

@@ -0,0 +1,203 @@
+import type {
+	ExtensionContext,
+	GrepToolInput,
+	ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+
+import { FG_DIM, RST } from "../ansi.js";
+import { fffFormatGrepText } from "../fff.js";
+import { renderGrepResults } from "../renderers.js";
+import type {
+	GrepParams,
+	GrepRenderState,
+	GrepResultDetails,
+	PiPrettyApi,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+} from "../types.js";
+import {
+	appendNotices,
+	countRipgrepMatches,
+	fillToolBackground,
+	getTextContent,
+	isTextContent,
+	makeTextResult,
+	normalizeLineEndings,
+	renderToolError,
+	setResultDetails,
+	termW,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+export function registerGrepTool(
+	pi: PiPrettyApi,
+	createGrepTool: ToolFactory<GrepToolInput>,
+	ctx: ToolContext,
+): void {
+	const { cwd, sp, TextComponent, fffState, cursorStore } = ctx;
+	const origGrep = createGrepTool(cwd);
+
+	pi.registerTool({
+		...origGrep,
+		name: "grep",
+		renderShell: "self",
+
+		async execute(
+			tid: string,
+			params: GrepParams,
+			sig: AbortSignal | undefined,
+			upd: unknown,
+			toolCtx: ExtensionContext,
+		) {
+			// Try FFF first (SIMD-accelerated).
+			// Constrained searches (path/glob) fall through to SDK — FFF 0.5.2
+			// can abort the process on constrained searches with Unicode filenames.
+			if (
+				fffState.finder &&
+				!fffState.finder.isDestroyed &&
+				!params.path &&
+				!params.glob
+			) {
+				try {
+					const effectiveLimit = Math.max(1, params.limit ?? 100);
+					const grepResult = fffState.finder.grep(params.pattern, {
+						mode: params.literal ? "plain" : "regex",
+						smartCase: !params.ignoreCase,
+						maxMatchesPerFile: Math.min(effectiveLimit, 50),
+						cursor: null,
+						beforeContext: params.context ?? 0,
+						afterContext: params.context ?? 0,
+					});
+
+					if (grepResult.ok) {
+						const grep = grepResult.value;
+						const notices: string[] = [];
+						if (fffState.partialIndex)
+							notices.push("Warning: partial file index");
+						if (grep.items.length >= effectiveLimit)
+							notices.push(`${effectiveLimit} limit reached`);
+						if (grep.regexFallbackError)
+							notices.push(
+								`Regex failed: ${grep.regexFallbackError}, used literal match`,
+							);
+						if (grep.nextCursor) {
+							const cursorId = cursorStore.store(grep.nextCursor);
+							notices.push(
+								`More results available. Use cursor="${cursorId}" to continue`,
+							);
+						}
+
+						const textContent = appendNotices(
+							fffFormatGrepText(grep.items, effectiveLimit),
+							notices,
+						);
+						return makeTextResult<GrepResultDetails>(textContent, {
+							_type: "grepResult",
+							text: textContent,
+							pattern: params.pattern,
+							matchCount: Math.min(grep.items.length, effectiveLimit),
+						});
+					}
+				} catch {
+					/* fall through to SDK */
+				}
+			}
+
+			// SDK fallback
+			const result = await origGrep.execute(
+				tid,
+				params,
+				sig,
+				upd as never,
+				toolCtx,
+			);
+			const textContent = normalizeLineEndings(getTextContent(result));
+			if (result.content) {
+				for (const content of result.content) {
+					if (isTextContent(content))
+						content.text = normalizeLineEndings(content.text || "");
+				}
+			}
+			const matchCount = textContent ? countRipgrepMatches(textContent) : 0;
+
+			setResultDetails<GrepResultDetails>(result, {
+				_type: "grepResult",
+				text: textContent,
+				pattern: params.pattern,
+				matchCount,
+			});
+
+			return result;
+		},
+
+		renderCall(
+			args: GrepParams,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const pattern = args.pattern ?? "";
+			const path = args.path
+				? ` ${theme.fg("muted", `in ${sp(args.path)}`)}`
+				: "";
+			const glob = args.glob ? ` ${theme.fg("muted", `(${args.glob})`)}` : "";
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			text.setText(
+				fillToolBackground(
+					`${theme.fg("toolTitle", theme.bold("grep"))} ${theme.fg("accent", pattern)}${path}${glob}`,
+				),
+			);
+			return text;
+		},
+
+		renderResult(
+			result: ToolResultLike<GrepResultDetails>,
+			_opt: ToolRenderResultOptions,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike<GrepRenderState>,
+		) {
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+
+			if (renderCtx.isError) {
+				text.setText(renderToolError(getTextContent(result) || "Error", theme));
+				return text;
+			}
+
+			const d = result.details;
+			if (d?._type === "grepResult" && d.text) {
+				const key = `grep:${d.pattern}:${d.matchCount}:${termW()}`;
+				if (renderCtx.state._gk !== key) {
+					renderCtx.state._gk = key;
+					const info = `${FG_DIM}${d.matchCount} matches${RST}`;
+					renderCtx.state._gt = fillToolBackground(`  ${info}`);
+
+					renderGrepResults(d.text, d.pattern)
+						.then((rendered: string) => {
+							if (renderCtx.state._gk !== key) return;
+							renderCtx.state._gt = fillToolBackground(
+								`  ${info}\n${rendered}`,
+							);
+							renderCtx.invalidate();
+						})
+						.catch(() => {});
+				}
+				text.setText(
+					renderCtx.state._gt ??
+						fillToolBackground(`  ${FG_DIM}${d.matchCount} matches${RST}`),
+				);
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "searched";
+			text.setText(
+				fillToolBackground(
+					`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`,
+				),
+			);
+			return text;
+		},
+	});
+}

package/src/tools/ls.ts

@@ -0,0 +1,112 @@
+import type {
+	AgentToolUpdateCallback,
+	ExtensionContext,
+	LsToolInput,
+} from "@earendil-works/pi-coding-agent";
+
+import { FG_DIM, RST } from "../ansi.js";
+import { renderTree } from "../renderers.js";
+import type {
+	LsParams,
+	PiPrettyApi,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+} from "../types.js";
+import {
+	fillToolBackground,
+	getTextContent,
+	isTextContent,
+	renderToolError,
+	setResultDetails,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+export function registerLsTool(
+	pi: PiPrettyApi,
+	createLsTool: ToolFactory<LsToolInput>,
+	ctx: ToolContext,
+): void {
+	const { cwd, sp, TextComponent } = ctx;
+	const origLs = createLsTool(cwd);
+
+	pi.registerTool({
+		...origLs,
+		name: "ls",
+		renderShell: "self",
+
+		async execute(
+			tid: string,
+			params: LsParams,
+			sig: AbortSignal | undefined,
+			upd: AgentToolUpdateCallback<unknown> | undefined,
+			toolCtx: ExtensionContext,
+		) {
+			const result = (await origLs.execute(
+				tid,
+				params,
+				sig,
+				upd,
+				toolCtx,
+			)) as ToolResultLike;
+			const textContent = getTextContent(result);
+			const fp = params.path ?? cwd;
+			const entryCount = textContent
+				? textContent.trim().split("\n").filter(Boolean).length
+				: 0;
+
+			setResultDetails(result, {
+				_type: "lsResult",
+				text: textContent ?? "",
+				path: fp,
+				entryCount,
+			});
+
+			return result;
+		},
+
+		renderCall(args: LsParams, theme: ThemeLike, renderCtx: RenderContextLike) {
+			const fp = args.path ?? ".";
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			text.setText(
+				fillToolBackground(
+					`${theme.fg("toolTitle", theme.bold("ls"))} ${theme.fg("accent", sp(fp))}`,
+				),
+			);
+			return text;
+		},
+
+		renderResult(
+			result: ToolResultLike,
+			_opt: unknown,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+
+			if (renderCtx.isError) {
+				text.setText(renderToolError(getTextContent(result) || "Error", theme));
+				return text;
+			}
+
+			const d = result.details as Record<string, unknown> | undefined;
+			if (d?._type === "lsResult" && d.text) {
+				const tree = renderTree(d.text as string, d.path as string);
+				const info = `${FG_DIM}${d.entryCount} entries${RST}`;
+				text.setText(fillToolBackground(`  ${info}\n${tree}`));
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "listed";
+			text.setText(
+				fillToolBackground(
+					`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`,
+				),
+			);
+			return text;
+		},
+	});
+}