@xynogen/pix-pretty 1.1.0 → 1.3.0

package/src/tools/edit.ts

@@ -0,0 +1,291 @@
+import { existsSync, readFileSync } from "node:fs";
+import type {
+	AgentToolUpdateCallback,
+	EditToolInput,
+	ExtensionContext,
+	ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+
+import { MAX_RENDER_LINES } from "../config.js";
+import { parseDiff } from "../diff.js";
+import {
+	diffThemeCacheKey,
+	renderSplit,
+	resolveDiffColors,
+	summarize,
+} from "../diff-render.js";
+import { lang } from "../lang.js";
+import type {
+	EditOperation,
+	EditParams,
+	EditRenderState,
+	PiPrettyApi,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+} from "../types.js";
+import {
+	fillToolBackground,
+	getTextContent,
+	isTextContent,
+	renderToolError,
+	setResultDetails,
+	termW,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+export function getEditOperations(input: EditParams): EditOperation[] {
+	if (Array.isArray(input?.edits)) {
+		return input.edits
+			.map((e) => ({
+				oldText:
+					typeof e?.oldText === "string"
+						? e.oldText
+						: typeof e?.old_text === "string"
+							? e.old_text
+							: "",
+				newText:
+					typeof e?.newText === "string"
+						? e.newText
+						: typeof e?.new_text === "string"
+							? e.new_text
+							: "",
+			}))
+			.filter((e) => e.oldText && e.oldText !== e.newText);
+	}
+	const oldText =
+		typeof input?.oldText === "string"
+			? input.oldText
+			: typeof input?.old_text === "string"
+				? input.old_text
+				: "";
+	const newText =
+		typeof input?.newText === "string"
+			? input.newText
+			: typeof input?.new_text === "string"
+				? input.new_text
+				: "";
+	return oldText && oldText !== newText ? [{ oldText, newText }] : [];
+}
+
+export function summarizeEditOperations(operations: EditOperation[]) {
+	const diffs = operations.map((e) => parseDiff(e.oldText, e.newText));
+	const totalAdded = diffs.reduce((sum, d) => sum + d.added, 0);
+	const totalRemoved = diffs.reduce((sum, d) => sum + d.removed, 0);
+	return {
+		diffs,
+		totalAdded,
+		totalRemoved,
+		summary: summarize(totalAdded, totalRemoved),
+	};
+}
+
+// ── Tool ───────────────────────────────────────────────────────────────
+
+export function registerEditTool(
+	pi: PiPrettyApi,
+	createEditTool: ToolFactory<EditToolInput>,
+	ctx: ToolContext,
+	trackInvalidator: (id: string, inv: () => void) => void,
+): void {
+	const { cwd, sp, TextComponent } = ctx;
+	const origEdit = createEditTool(cwd);
+
+	pi.registerTool({
+		...origEdit,
+		name: "edit",
+
+		async execute(
+			tid: string,
+			params: EditParams,
+			sig: AbortSignal | undefined,
+			upd: AgentToolUpdateCallback<unknown> | undefined,
+			toolCtx: ExtensionContext,
+		) {
+			const fp = params.path ?? params.file_path ?? "";
+			const operations = getEditOperations(params);
+			const fileLang = lang(fp);
+
+			const result = (await origEdit.execute(
+				tid,
+				params as unknown as Parameters<typeof origEdit.execute>[1],
+				sig,
+				upd,
+				toolCtx,
+			)) as ToolResultLike;
+
+			if (operations.length === 0) return result;
+
+			const { diffs, summary } = summarizeEditOperations(operations);
+
+			if (operations.length === 1) {
+				let editLine = 0;
+				try {
+					if (fp && existsSync(fp)) {
+						const f = readFileSync(fp, "utf-8");
+						const idx = f.indexOf(operations[0].newText);
+						if (idx >= 0) editLine = f.slice(0, idx).split("\n").length;
+					}
+				} catch {
+					editLine = 0;
+				}
+				setResultDetails(result, {
+					_type: "editInfo",
+					summary,
+					editLine,
+					oldContent: operations[0].oldText,
+					newContent: operations[0].newText,
+					language: fileLang,
+					filePath: fp,
+				});
+				return result;
+			}
+
+			setResultDetails(result, {
+				_type: "multiEditInfo",
+				summary,
+				editCount: operations.length,
+				diffLineCount: diffs.reduce((sum, d) => sum + d.lines.length, 0),
+				ops: operations.map((op) => ({
+					oldContent: op.oldText,
+					newContent: op.newText,
+					language: fileLang,
+					filePath: fp,
+				})),
+			});
+			return result;
+		},
+
+		renderCall(
+			args: EditParams,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike<EditRenderState>,
+		) {
+			const fp = args?.path ?? args?.file_path ?? "";
+			const operations = getEditOperations(args);
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			const hdr = `${theme.fg("toolTitle", theme.bold("edit"))} ${theme.fg("accent", sp(fp))}`;
+
+			if (operations.length === 0) {
+				text.setText(fillToolBackground(hdr));
+				return text;
+			}
+
+			const { summary } = summarizeEditOperations(operations);
+			const suffix =
+				operations.length === 1
+					? summary
+					: `${operations.length} edits ${summary}`;
+			text.setText(fillToolBackground(`${hdr}  ${theme.fg("muted", suffix)}`));
+			return text;
+		},
+
+		renderResult(
+			result: ToolResultLike,
+			_opt: ToolRenderResultOptions,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike<EditRenderState>,
+		) {
+			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;
+
+			// Single edit — full split diff
+			if (d?._type === "editInfo") {
+				const key = `ed:${diffThemeCacheKey(theme)}:${termW()}:${d.summary}:${(d.oldContent as string).length}:${(d.newContent as string).length}:${d.language ?? ""}`;
+				if (renderCtx.toolCallId)
+					trackInvalidator(renderCtx.toolCallId, renderCtx.invalidate);
+				if (renderCtx.state._edk !== key) {
+					renderCtx.state._edk = key;
+					const loc =
+						(d.editLine as number) > 0
+							? ` ${theme.fg("muted", `at line ${d.editLine}`)}`
+							: "";
+					renderCtx.state._edt = `  ${d.summary}${loc}\n${theme.fg("muted", "  rendering diff…")}`;
+					const dc = resolveDiffColors(theme);
+					const diff = parseDiff(
+						d.oldContent as string,
+						d.newContent as string,
+					);
+					renderSplit(
+						diff,
+						d.language as string | undefined,
+						MAX_RENDER_LINES,
+						dc,
+					)
+						.then((rendered) => {
+							if (renderCtx.state._edk !== key) return;
+							const loc2 =
+								(d.editLine as number) > 0
+									? ` ${theme.fg("muted", `at line ${d.editLine}`)}`
+									: "";
+							renderCtx.state._edt = `  ${d.summary}${loc2}\n${rendered}`;
+							renderCtx.invalidate();
+						})
+						.catch(() => {
+							if (renderCtx.state._edk !== key) return;
+							renderCtx.state._edt = `  ${d.summary}`;
+							renderCtx.invalidate();
+						});
+				}
+				text.setText(renderCtx.state._edt ?? `  ${d.summary}`);
+				return text;
+			}
+
+			// Multi-edit — stacked diffs
+			if (d?._type === "multiEditInfo") {
+				const key = `med:${diffThemeCacheKey(theme)}:${termW()}:${d.summary}:${d.editCount}:${d.diffLineCount}`;
+				if (renderCtx.toolCallId)
+					trackInvalidator(renderCtx.toolCallId, renderCtx.invalidate);
+				if (renderCtx.state._edk !== key) {
+					renderCtx.state._edk = key;
+					renderCtx.state._edt = `  ${d.editCount} edits ${d.summary}\n${theme.fg("muted", "  rendering diff…")}`;
+					const dc = resolveDiffColors(theme);
+					Promise.all(
+						(
+							d.ops as Array<{
+								oldContent: string;
+								newContent: string;
+								language?: string;
+							}>
+						).map((op) => {
+							const diff = parseDiff(op.oldContent, op.newContent);
+							return renderSplit(diff, op.language, MAX_RENDER_LINES, dc);
+						}),
+					)
+						.then((rendered) => {
+							if (renderCtx.state._edk !== key) return;
+							const body = rendered.join(`\n${theme.fg("muted", "  ···")}\n`);
+							renderCtx.state._edt = `  ${d.editCount} edits ${d.summary}\n${body}`;
+							renderCtx.invalidate();
+						})
+						.catch(() => {
+							if (renderCtx.state._edk !== key) return;
+							renderCtx.state._edt = `  ${d.editCount} edits ${d.summary}`;
+							renderCtx.invalidate();
+						});
+				}
+				text.setText(
+					renderCtx.state._edt ?? `  ${d.editCount} edits ${d.summary}`,
+				);
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "edited";
+			text.setText(
+				fillToolBackground(
+					`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`,
+				),
+			);
+			return text;
+		},
+	});
+}

package/src/tools/find.ts

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