@xynogen/pix-pretty 1.1.0 → 1.3.0

package/src/tools/ls.ts

@@ -0,0 +1,111 @@
+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",
+
+		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;
+		},
+	});
+}

package/src/tools/multi-grep.ts

@@ -0,0 +1,328 @@
+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 {
+	GrepResultDetails,
+	MultiGrepParams,
+	MultiGrepRenderState,
+	PiPrettyApi,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+} from "../types.js";
+import {
+	appendNotices,
+	buildLiteralAlternationPattern,
+	countRipgrepMatches,
+	getConstraintBackedPath,
+	getErrorMessage,
+	getTextContent,
+	isTextContent,
+	makeTextResult,
+	normalizeLineEndings,
+	shouldIgnoreCaseForPatterns,
+	termW,
+	trimToUndefined,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+export function registerMultiGrepTool(
+	pi: PiPrettyApi,
+	createGrepTool: ToolFactory<GrepToolInput> | null,
+	ctx: ToolContext,
+): void {
+	const {
+		cwd,
+		sp,
+		TextComponent,
+		fffState,
+		cursorStore,
+		multiGrepRipgrepFallback,
+	} = ctx;
+	const multiGrepFallback = createGrepTool ? createGrepTool(cwd) : null;
+
+	pi.registerTool({
+		name: "multi_grep",
+		label: "multi_grep",
+		description: [
+			"Search file contents for lines matching ANY of multiple patterns (OR logic).",
+			"Uses SIMD-accelerated Aho-Corasick multi-pattern matching when FFF is available.",
+			"Falls back to ripgrep while preserving literal OR semantics and file constraints when needed.",
+			"Patterns are literal text — never escape special characters.",
+			"Use path to scope a directory/file and constraints for file filtering ('*.rs', 'src/', '!test/').",
+		].join(" "),
+		promptSnippet:
+			"Multi-pattern OR search across file contents (FFF-accelerated with grep fallback)",
+		promptGuidelines: [
+			"Use multi_grep when you need to find multiple identifiers at once (OR logic).",
+			"Include all naming conventions: snake_case, PascalCase, camelCase variants.",
+			"Patterns are literal text. Never escape special characters.",
+			"Use path to scope a directory or file when you need fresh on-disk results.",
+			"Use the constraints parameter for additional file filtering, not inside patterns.",
+		],
+
+		parameters: {
+			type: "object",
+			properties: {
+				patterns: {
+					type: "array",
+					items: { type: "string" },
+					description:
+						"Patterns to search for (OR logic — matches lines containing ANY pattern).",
+				},
+				path: {
+					type: "string",
+					description:
+						"Directory or file path to search (default: current directory)",
+				},
+				constraints: {
+					type: "string",
+					description:
+						"File constraints, e.g. '*.{ts,tsx} !test/' to filter files.",
+				},
+				context: {
+					type: "number",
+					description:
+						"Number of context lines before and after each match (default: 0)",
+				},
+				limit: {
+					type: "number",
+					description: "Maximum number of matches to return (default: 100)",
+				},
+			},
+			required: ["patterns"],
+		},
+
+		async execute(
+			tid: string,
+			params: MultiGrepParams,
+			sig: AbortSignal | undefined,
+			upd: unknown,
+			toolCtx: ExtensionContext,
+		) {
+			if (sig?.aborted) return makeTextResult("Aborted", {});
+
+			if (!params.patterns || params.patterns.length === 0) {
+				return makeTextResult(
+					"Error: patterns array must have at least 1 element",
+					{ error: "empty patterns" },
+				);
+			}
+
+			const effectiveLimit = Math.max(1, params.limit ?? 100);
+			const pattern = buildLiteralAlternationPattern(params.patterns);
+			const requestedPath = trimToUndefined(params.path);
+			const requestedConstraints = trimToUndefined(params.constraints);
+			const effectivePath =
+				requestedPath ?? getConstraintBackedPath(requestedConstraints);
+			const hasNativeConstraints = Boolean(
+				requestedPath || requestedConstraints,
+			);
+
+			// FFF path (no constraints — constrained searches use ripgrep)
+			if (
+				fffState.finder &&
+				!fffState.finder.isDestroyed &&
+				!hasNativeConstraints
+			) {
+				try {
+					const grepResult = fffState.finder.multiGrep({
+						patterns: params.patterns,
+						maxMatchesPerFile: Math.min(effectiveLimit, 50),
+						smartCase: true,
+						cursor: null,
+						beforeContext: params.context ?? 0,
+						afterContext: params.context ?? 0,
+					});
+
+					if (!grepResult.ok) {
+						return makeTextResult(`multi_grep error: ${grepResult.error}`, {
+							error: grepResult.error,
+						});
+					}
+
+					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.nextCursor) {
+						const cursorId = cursorStore.store(grep.nextCursor);
+						notices.push(`More results: cursor="${cursorId}"`);
+					}
+
+					const textContent = appendNotices(
+						fffFormatGrepText(grep.items, effectiveLimit),
+						notices,
+					);
+					return makeTextResult<GrepResultDetails>(textContent, {
+						_type: "grepResult",
+						text: textContent,
+						pattern,
+						matchCount: Math.min(grep.items.length, effectiveLimit),
+					});
+				} catch {
+					/* fall through to SDK */
+				}
+			}
+
+			// Ripgrep path (constrained, or FFF unavailable)
+			if (requestedConstraints || !multiGrepFallback) {
+				try {
+					const pathBackedConstraint = Boolean(
+						requestedConstraints &&
+							!requestedPath &&
+							requestedConstraints === effectivePath,
+					);
+					const constraintsForRipgrep = pathBackedConstraint
+						? undefined
+						: requestedConstraints;
+					const notices: string[] = [];
+
+					if (!fffState.finder || fffState.finder.isDestroyed)
+						notices.push("FFF unavailable, used ripgrep fallback");
+					else if (hasNativeConstraints)
+						notices.push("Used ripgrep fallback for constrained search");
+					else notices.push("Used ripgrep fallback");
+
+					const rgResult = await multiGrepRipgrepFallback({
+						cwd,
+						patterns: params.patterns,
+						path: effectivePath,
+						constraints: constraintsForRipgrep,
+						ignoreCase: shouldIgnoreCaseForPatterns(params.patterns),
+						context: params.context,
+						limit: effectiveLimit,
+						signal: sig,
+					});
+					const textContent =
+						normalizeLineEndings(rgResult.text) || "No matches found";
+					if (rgResult.limitReached)
+						notices.push(`${effectiveLimit} limit reached`);
+					const finalText = appendNotices(textContent, notices);
+
+					return makeTextResult<GrepResultDetails>(finalText, {
+						_type: "grepResult",
+						text: finalText,
+						pattern,
+						matchCount: rgResult.matchCount,
+					});
+				} catch (error: unknown) {
+					const message = getErrorMessage(error);
+					return makeTextResult(`multi_grep error: ${message}`, {
+						error: message,
+					});
+				}
+			}
+
+			// SDK grep fallback
+			try {
+				const notices: string[] = [];
+				if (!fffState.finder || fffState.finder.isDestroyed)
+					notices.push("FFF unavailable, used SDK grep fallback");
+
+				const result = await multiGrepFallback.execute(
+					tid,
+					{
+						pattern,
+						path: effectivePath,
+						ignoreCase: shouldIgnoreCaseForPatterns(params.patterns),
+						context: params.context,
+						limit: params.limit,
+					},
+					sig,
+					upd as never,
+					toolCtx,
+				);
+				const textContent =
+					normalizeLineEndings(getTextContent(result)) || "No matches found";
+				const finalText = appendNotices(textContent, notices);
+
+				return makeTextResult<GrepResultDetails>(finalText, {
+					_type: "grepResult",
+					text: finalText,
+					pattern,
+					matchCount: textContent ? countRipgrepMatches(textContent) : 0,
+				});
+			} catch (error: unknown) {
+				const message = getErrorMessage(error);
+				return makeTextResult(`multi_grep error: ${message}`, {
+					error: message,
+				});
+			}
+		},
+
+		renderCall(
+			args: MultiGrepParams,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const patterns = args.patterns ?? [];
+			const path = args.path
+				? ` ${theme.fg("muted", `in ${sp(args.path)}`)}`
+				: "";
+			const constraints = args.constraints;
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			let content =
+				theme.fg("toolTitle", theme.bold("multi_grep")) +
+				" " +
+				theme.fg("accent", patterns.map((p) => `"${p}"`).join(", "));
+			content += path;
+			if (constraints) content += theme.fg("muted", ` (${constraints})`);
+			text.setText(content);
+			return text;
+		},
+
+		renderResult(
+			result: ToolResultLike<GrepResultDetails | { error?: string }>,
+			_opt: ToolRenderResultOptions,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike<MultiGrepRenderState>,
+		) {
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+
+			if (renderCtx.isError) {
+				text.setText(
+					`\n${theme.fg("error", getTextContent(result) || "Error")}`,
+				);
+				return text;
+			}
+
+			const d = result.details;
+			if (d && "_type" in d && d._type === "grepResult" && d.text) {
+				const key = `mgrep:${d.pattern}:${d.matchCount}:${termW()}`;
+				if (renderCtx.state._mgk !== key) {
+					renderCtx.state._mgk = key;
+					const info = `${FG_DIM}${d.matchCount} matches${RST}`;
+					renderCtx.state._mgt = `  ${info}`;
+
+					renderGrepResults(d.text, d.pattern)
+						.then((rendered: string) => {
+							if (renderCtx.state._mgk !== key) return;
+							renderCtx.state._mgt = `  ${info}\n${rendered}`;
+							renderCtx.invalidate();
+						})
+						.catch(() => {});
+				}
+				text.setText(
+					renderCtx.state._mgt ?? `  ${FG_DIM}${d.matchCount} matches${RST}`,
+				);
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "searched";
+			text.setText(`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`);
+			return text;
+		},
+	});
+}

package/src/tools/read.ts

@@ -0,0 +1,177 @@
+import type {
+	AgentToolUpdateCallback,
+	ExtensionContext,
+	ReadToolInput,
+} from "@earendil-works/pi-coding-agent";
+
+import { FG_DIM, RST } from "../ansi.js";
+import { MAX_PREVIEW_LINES } from "../config.js";
+import { fileIcon } from "../icons.js";
+import { renderFileContent } from "../renderers.js";
+import type {
+	PiPrettyApi,
+	ReadParams,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+} from "../types.js";
+import {
+	fillToolBackground,
+	getTextContent,
+	humanSize,
+	isImageContent,
+	isTextContent,
+	normalizeLineEndings,
+	renderToolError,
+	setResultDetails,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+export function registerReadTool(
+	pi: PiPrettyApi,
+	createReadTool: ToolFactory<ReadToolInput>,
+	ctx: ToolContext,
+): void {
+	const { cwd, sp, TextComponent } = ctx;
+	const origRead = createReadTool(cwd);
+
+	pi.registerTool({
+		...origRead,
+		name: "read",
+
+		async execute(
+			tid: string,
+			params: ReadParams,
+			sig: AbortSignal | undefined,
+			upd: AgentToolUpdateCallback<unknown> | undefined,
+			toolCtx: ExtensionContext,
+		) {
+			const result = (await origRead.execute(
+				tid,
+				params,
+				sig,
+				upd,
+				toolCtx,
+			)) as ToolResultLike;
+
+			const fp = params.path ?? "";
+			const offset = params.offset ?? 1;
+
+			const imageBlock = result.content?.find(isImageContent);
+			if (imageBlock) {
+				setResultDetails(result, {
+					_type: "readImage",
+					filePath: fp,
+					data: imageBlock.data,
+					mimeType: imageBlock.mimeType ?? "image/png",
+				});
+				return result;
+			}
+
+			const textContent = getTextContent(result);
+			if (textContent && fp) {
+				const normalizedContent = normalizeLineEndings(textContent);
+				const lineCount = normalizedContent.split("\n").length;
+				setResultDetails(result, {
+					_type: "readFile",
+					filePath: fp,
+					content: normalizedContent,
+					offset,
+					lineCount,
+				});
+			}
+
+			return result;
+		},
+
+		renderCall(
+			args: ReadParams,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const fp = args.path ?? "";
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			const offset = args.offset
+				? ` ${theme.fg("muted", `from line ${args.offset}`)}`
+				: "";
+			const limit = args.limit
+				? ` ${theme.fg("muted", `(${args.limit} lines)`)}`
+				: "";
+			text.setText(
+				fillToolBackground(
+					`${theme.fg("toolTitle", theme.bold("read"))} ${theme.fg("accent", sp(fp))}${offset}${limit}`,
+				),
+			);
+			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 === "readImage") {
+				const byteSize = Math.ceil(((d.data as string).length * 3) / 4);
+				text.setText(
+					fillToolBackground(
+						`  ${fileIcon(d.filePath as string)}${FG_DIM}${d.mimeType ?? "image"} · ${humanSize(byteSize)}${RST}`,
+					),
+				);
+				return text;
+			}
+
+			if (d?._type === "readFile" && d.content) {
+				const key = `read:${d.filePath}:${d.offset}:${d.lineCount}:${process.stdout.columns ?? 80}`;
+				if (renderCtx.state._rk !== key) {
+					renderCtx.state._rk = key;
+					const info = `${FG_DIM}${d.lineCount} lines${RST}`;
+					renderCtx.state._rt = fillToolBackground(`  ${info}`);
+
+					const maxShow = renderCtx.expanded
+						? (d.lineCount as number)
+						: MAX_PREVIEW_LINES;
+					renderFileContent(
+						d.content as string,
+						d.filePath as string,
+						d.offset as number,
+						maxShow,
+					)
+						.then((rendered: string) => {
+							if (renderCtx.state._rk !== key) return;
+							renderCtx.state._rt = fillToolBackground(
+								`  ${info}\n${rendered}`,
+							);
+							renderCtx.invalidate();
+						})
+						.catch(() => {});
+				}
+				text.setText(
+					renderCtx.state._rt ??
+						fillToolBackground(`  ${FG_DIM}${d.lineCount} lines${RST}`),
+				);
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "read";
+			text.setText(
+				fillToolBackground(
+					`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`,
+				),
+			);
+			return text;
+		},
+	});
+}