@xynogen/pix-find 0.2.3 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-find",
-	"version": "0.2.3",
+	"version": "0.3.0",
 	"description": "Pi tool — glob file search",
 	"type": "module",
 	"main": "src/index.ts",
@@ -13,6 +13,7 @@
 	},
 	"files": [
 		"src",
+		"!src/**/*.test.*",
 		"README.md",
 		"LICENSE"
 	],

package/src/find.ts

@@ -4,6 +4,17 @@ import type {
 	ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
 import { resolveBaseBackground } from "@xynogen/pix-pretty/ansi";
+import {
+	BATCH_MAX_BYTES,
+	type BatchSection,
+	capSections,
+	formatBatchIndex,
+	formatCallTargets,
+	joinSectionBodies,
+	resolveBatchStrings,
+	sliceBatchTargets,
+	withOptionalStringArray,
+} from "@xynogen/pix-pretty/batch";
 import type { ToolContext } from "@xynogen/pix-pretty/context";
 import type {
 	FindParams,
@@ -32,6 +43,11 @@ import { type CollapseState, tickCollapse } from "@xynogen/pix-runtime/collapse"
 
 export const DEFAULT_FIND_LIMIT = 200;
 
+const FILE_NOUNS = ["file", "files"] as const;
+
+/** FindParams plus the optional batch `patterns` array (added to the schema at runtime). */
+type FindBatchParams = FindParams & { patterns?: string[] };
+
 export function applyFindDefaults(params: FindParams): FindParams {
 	return params.limit === undefined ? { ...params, limit: DEFAULT_FIND_LIMIT } : params;
 }
@@ -67,88 +83,165 @@ export function registerFindTool(
 		...origFind,
 		name: "find",
 		description:
-			"Find files by glob pattern. Defaults to 200 paths; use limit to request more. Respects .gitignore and remains capped by Pi's 50KB hard limit.",
+			"Find files by glob pattern. Defaults to 200 paths; use limit to request more. Respects .gitignore and remains capped by Pi's 50KB hard limit. Pass `patterns` to search several known globs in one call.",
+		parameters: withOptionalStringArray(
+			origFind.parameters,
+			"patterns",
+			"Known glob patterns to search in one call (each capped, one combined result). Use instead of `pattern` for multiple known globs.",
+			["pattern"],
+		),
 		renderShell: "self",
 
 		async execute(
 			tid: string,
-			params: FindParams,
+			params: FindBatchParams,
 			sig: AbortSignal | undefined,
 			upd: unknown,
 			toolCtx: ExtensionContext,
 		) {
-			const effectiveParams = applyFindDefaults(params);
+			// Search one glob (FFF-accelerated, SDK fallback) → structured find result.
+			const runOne = async (
+				pattern: string,
+				callId: string,
+			): Promise<ToolResultLike<FindResultDetails>> => {
+				const { patterns: _patterns, ...rest } = params;
+				const effectiveParams = applyFindDefaults({ ...rest, pattern });
 
-			// Try FFF first (frecency-ranked, SIMD-accelerated)
-			if (fffState.finder && !fffState.finder.isDestroyed) {
-				try {
-					const effectiveLimit = Math.max(1, effectiveParams.limit ?? DEFAULT_FIND_LIMIT);
-					let query = effectiveParams.pattern;
-					if (effectiveParams.path) query = `${effectiveParams.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: effectiveParams.pattern,
-							path: effectiveParams.path,
-							matchCount: trimmed.length,
+				// Try FFF first (frecency-ranked, SIMD-accelerated)
+				if (fffState.finder && !fffState.finder.isDestroyed) {
+					try {
+						const effectiveLimit = Math.max(1, effectiveParams.limit ?? DEFAULT_FIND_LIMIT);
+						let query = effectiveParams.pattern;
+						if (effectiveParams.path) query = `${effectiveParams.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: effectiveParams.pattern,
+								path: effectiveParams.path,
+								matchCount: trimmed.length,
+							});
+						}
+					} catch {
+						/* fall through to SDK */
 					}
-				} catch {
-					/* fall through to SDK */
 				}
-			}
 
-			// SDK fallback
-			try {
-				const result = await origFind.execute(tid, effectiveParams, sig, upd as never, toolCtx);
+				// SDK fallback
+				const result = await origFind.execute(callId, effectiveParams, 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,
+					pattern,
+					path: effectiveParams.path,
+					matchCount: textContent ? textContent.trim().split("\n").filter(Boolean).length : 0,
+				});
+				return result as ToolResultLike<FindResultDetails>;
+			};
+
+			const { targets, omitted } = sliceBatchTargets(
+				resolveBatchStrings(params.pattern, params.patterns),
+			);
+			if (targets.length === 0) {
+				return makeTextResult<FindResultDetails>("pattern or patterns required", {
+					_type: "findResult",
+					text: "pattern or patterns required",
+					pattern: "",
 					path: params.path,
-					matchCount,
+					matchCount: 0,
 				});
+			}
 
-				return result;
-			} catch (error) {
-				const text = error instanceof Error ? error.message : String(error);
-				if (sig?.aborted || /aborted/i.test(text)) throw error;
-				return {
-					content: [{ type: "text" as const, text }],
-					details: {
-						_type: "findResult" as const,
-						text,
-						pattern: params.pattern,
-						path: params.path,
-						matchCount: 0,
-					},
-					isError: true,
-				};
+			// Single glob → preserve the original single-search result shape.
+			if (targets.length === 1 && omitted === 0) {
+				try {
+					return await runOne(targets[0] ?? "", tid);
+				} catch (error) {
+					const text = error instanceof Error ? error.message : String(error);
+					if (sig?.aborted || /aborted/i.test(text)) throw error;
+					return {
+						content: [{ type: "text" as const, text }],
+						details: {
+							_type: "findResult" as const,
+							text,
+							pattern: params.pattern ?? "",
+							path: params.path,
+							matchCount: 0,
+						},
+						isError: true,
+					};
+				}
 			}
+
+			// Batch: search every glob in parallel, cap the combined output.
+			const settled = await Promise.all(
+				targets.map(async (pattern, i) => {
+					try {
+						return { pattern, result: await runOne(pattern, `${tid}:${i}`) };
+					} catch (error) {
+						if (sig?.aborted) throw error;
+						return { pattern, error: error instanceof Error ? error.message : String(error) };
+					}
+				}),
+			);
+			const sections: BatchSection[] = settled.map((entry) => {
+				if ("error" in entry && entry.error) {
+					return { id: entry.pattern, body: "", units: 0, nouns: FILE_NOUNS, error: entry.error };
+				}
+				const details = (entry as { result: ToolResultLike<FindResultDetails> }).result.details;
+				const body =
+					details?._type === "findResult"
+						? details.text
+						: getTextContent((entry as { result: ToolResultLike }).result);
+				const units =
+					details?._type === "findResult"
+						? details.matchCount
+						: body.trim().split("\n").filter(Boolean).length;
+				return { id: entry.pattern, body, units, nouns: FILE_NOUNS };
+			});
+			const { text } = capSections(
+				sections,
+				BATCH_MAX_BYTES,
+				params.limit ?? DEFAULT_FIND_LIMIT,
+				omitted,
+			);
+			const matchCount = sections.reduce((sum, s) => sum + (s.error ? 0 : s.units), 0);
+			const full = [formatBatchIndex(sections, omitted), joinSectionBodies(sections)]
+				.filter(Boolean)
+				.join("\n\n");
+			return makeTextResult<FindResultDetails>(text, {
+				_type: "findResult",
+				text: full,
+				pattern: targets.join(", "),
+				patterns: targets,
+				path: params.path,
+				matchCount,
+			});
 		},
 
-		renderCall(args: FindParams, theme: ThemeLike, renderCtx: RenderContextLike) {
+		renderCall(args: FindBatchParams, theme: ThemeLike, renderCtx: RenderContextLike) {
 			resolveBaseBackground(theme);
-			const pattern = args.pattern ?? "";
+			const batchPatterns = resolveBatchStrings(args.pattern, args.patterns);
+			const pattern =
+				batchPatterns.length > 1
+					? formatCallTargets(batchPatterns, 3, "patterns")
+					: (args.pattern ?? "");
 			const path = args.path ? ` ${theme.fg("muted", `in ${sp(args.path)}`)}` : "";
 			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
 			if (
@@ -215,7 +308,8 @@ export function registerFindTool(
 				renderDimPreview(output, theme, {
 					frame: !isPartial,
 					paint: (s: string) => theme.fg(renderCtx.isError ? "error" : "success", s),
-					highlight: d?._type === "findResult" ? globHighlight(d.pattern) : undefined,
+					highlight:
+						d?._type === "findResult" && !d.patterns ? globHighlight(d.pattern) : undefined,
 				}),
 			);
 			return text;

package/src/find.test.ts

@@ -1,255 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { CursorStore, FffState } from "@xynogen/pix-pretty/fff";
-import type {
-	PiPrettyApi,
-	RenderContextLike,
-	TextComponentCtor,
-	ThemeLike,
-} from "@xynogen/pix-pretty/types";
-import { applyFindDefaults, DEFAULT_FIND_LIMIT, globHighlight, registerFindTool } from "./find";
-
-describe("globHighlight", () => {
-	it("keeps literal runs from a glob as case-insensitive alternatives", () => {
-		const re = globHighlight("**/*.test.ts");
-		expect(re).toBeInstanceOf(RegExp);
-		expect((re as RegExp).flags).toBe("gi");
-		expect("foo.test.ts".match(re as RegExp)).not.toBeNull();
-	});
-
-	it("highlights the extension of a simple glob", () => {
-		expect("app.ts".match(globHighlight("*.ts") as RegExp)?.[0]).toBe(".ts");
-	});
-
-	it("returns undefined when the glob has no meaningful literal run", () => {
-		expect(globHighlight("*")).toBeUndefined();
-	});
-});
-
-class MockTextComponent {
-	private text = "";
-	setText(v: string) {
-		this.text = v;
-	}
-	getText() {
-		return this.text;
-	}
-	render(_width?: number) {
-		return this.text.split("\n");
-	}
-	invalidate() {}
-}
-
-describe("applyFindDefaults", () => {
-	it("applies a conservative default without overriding an explicit limit", () => {
-		expect(applyFindDefaults({ pattern: "**/*.ts" })).toEqual({
-			pattern: "**/*.ts",
-			limit: DEFAULT_FIND_LIMIT,
-		});
-		expect(applyFindDefaults({ pattern: "**/*.ts", limit: 8 })).toEqual({
-			pattern: "**/*.ts",
-			limit: 8,
-		});
-	});
-});
-
-describe("registerFindTool", () => {
-	it("registers a tool named 'find'", () => {
-		const tools: string[] = [];
-		const mockPi: PiPrettyApi = {
-			registerTool(t: unknown) {
-				tools.push((t as { name: string }).name);
-			},
-			registerCommand() {},
-			on() {},
-		};
-
-		registerFindTool(
-			mockPi,
-			() => ({ execute: async () => ({ content: [], details: undefined }) }),
-			{
-				cwd: process.cwd(),
-				sp: (p: string) => p,
-				TextComponent: MockTextComponent as unknown as TextComponentCtor,
-				fffState: {
-					module: null,
-					finder: null,
-					partialIndex: false,
-					dbDir: null,
-				} satisfies FffState,
-				cursorStore: {
-					store: () => "",
-					get: () => undefined,
-				} as unknown as CursorStore,
-			},
-		);
-		expect(tools).toEqual(["find"]);
-	});
-
-	it("restores result paths when an elapsed card is expanded", () => {
-		const registered: { renderResult?: (...args: unknown[]) => MockTextComponent } = {};
-		const mockPi: PiPrettyApi = {
-			registerTool(tool: unknown) {
-				Object.assign(registered, tool);
-			},
-			registerCommand() {},
-			on() {},
-		};
-		registerFindTool(
-			mockPi,
-			() => ({ execute: async () => ({ content: [], details: undefined }) }),
-			{
-				cwd: process.cwd(),
-				sp: (p: string) => p,
-				TextComponent: MockTextComponent as unknown as TextComponentCtor,
-				fffState: { module: null, finder: null, partialIndex: false, dbDir: null },
-				cursorStore: { store: () => "", get: () => undefined } as unknown as CursorStore,
-			},
-		);
-		const theme: ThemeLike = {
-			fg: (_key: string, value: string) => value,
-			bold: (value: string) => value,
-		};
-		const result = registered.renderResult?.(
-			{
-				content: [{ type: "text", text: "src/one.ts\nsrc/two.ts" }],
-				details: {
-					_type: "findResult",
-					text: "src/one.ts\nsrc/two.ts",
-					pattern: "**/*.ts",
-					matchCount: 2,
-				},
-			},
-			undefined,
-			theme,
-			{
-				expanded: true,
-				isError: false,
-				invalidate: () => {},
-				state: { collapsed: true },
-			} as unknown as RenderContextLike,
-		);
-
-		const strip = (s: string) => s.replace(/\u001b\[[0-9;]*m/g, "");
-		const shown = strip(result?.getText() ?? "");
-		expect(shown).toContain("src/one.ts");
-		expect(shown).toContain("src/two.ts");
-		// No floating count header in the framed view — the collapsed row carries it.
-		expect(shown).not.toContain("2 files");
-	});
-
-	it("frames single-file output like multi-file (no inline row)", () => {
-		const registered: { renderResult?: (...args: unknown[]) => MockTextComponent } = {};
-		const mockPi: PiPrettyApi = {
-			registerTool(tool: unknown) {
-				Object.assign(registered, tool);
-			},
-			registerCommand() {},
-			on() {},
-		};
-		registerFindTool(
-			mockPi,
-			() => ({ execute: async () => ({ content: [], details: undefined }) }),
-			{
-				cwd: process.cwd(),
-				sp: (p: string) => p,
-				TextComponent: MockTextComponent as unknown as TextComponentCtor,
-				fffState: {
-					module: null,
-					finder: null,
-					partialIndex: false,
-					dbDir: null,
-				} satisfies FffState,
-				cursorStore: { store: () => "", get: () => undefined } as unknown as CursorStore,
-			},
-		);
-		const theme: ThemeLike = { fg: (_k: string, v: string) => v, bold: (v: string) => v };
-		const strip = (s: string) => s.replace(/\u001b\[[0-9;]*m/g, "");
-		const result = {
-			content: [{ type: "text", text: "src/a.ts" }],
-			details: { _type: "findResult", text: "src/a.ts", pattern: "*.ts", matchCount: 1 } as never,
-		};
-		const out =
-			registered
-				.renderResult?.(result, { isPartial: false }, theme, {
-					expanded: false,
-					isError: false,
-					invalidate: () => {},
-					state: {},
-				} as unknown as RenderContextLike)
-				?.getText() ?? "";
-		// Single result is framed just like multi — one shape, no inline row.
-		expect(out).toContain("─");
-		expect(strip(out)).toContain("src/a.ts");
-		expect(strip(out)).not.toContain("file");
-		const multi = {
-			content: [{ type: "text", text: "a.ts\nb.ts\nc.ts" }],
-			details: {
-				_type: "findResult",
-				text: "a.ts\nb.ts\nc.ts",
-				pattern: "*.ts",
-				matchCount: 3,
-			} as never,
-		};
-		const multiOut =
-			registered
-				.renderResult?.(multi, { isPartial: false }, theme, {
-					expanded: false,
-					isError: false,
-					invalidate: () => {},
-					state: {},
-				} as unknown as RenderContextLike)
-				?.getText() ?? "";
-		expect(multiOut).toContain("─");
-	});
-
-	it("collapses structured errors and restores the exact diagnostic on expansion", () => {
-		const registered: { renderResult?: (...args: unknown[]) => MockTextComponent } = {};
-		const mockPi: PiPrettyApi = {
-			registerTool(tool: unknown) {
-				Object.assign(registered, tool);
-			},
-			registerCommand() {},
-			on() {},
-		};
-		registerFindTool(
-			mockPi,
-			() => ({ execute: async () => ({ content: [], details: undefined }) }),
-			{
-				cwd: process.cwd(),
-				sp: (p: string) => p,
-				TextComponent: MockTextComponent as unknown as TextComponentCtor,
-				fffState: { module: null, finder: null, partialIndex: false, dbDir: null },
-				cursorStore: { store: () => "", get: () => undefined } as unknown as CursorStore,
-			},
-		);
-		const theme: ThemeLike = {
-			fg: (_key: string, value: string) => value,
-			bold: (value: string) => value,
-		};
-		const diagnostic = "Invalid glob pattern: [";
-		const result = {
-			content: [{ type: "text", text: diagnostic }],
-			details: {
-				_type: "findResult",
-				text: diagnostic,
-				pattern: "[",
-				path: "src",
-				matchCount: 0,
-			},
-		};
-		const render = (state: Record<string, unknown>, expanded = false) => {
-			const component = registered.renderResult?.(result, { isPartial: false }, theme, {
-				expanded,
-				isError: true,
-				invalidate: () => {},
-				state,
-			} as unknown as RenderContextLike);
-			return component?.render(120).join("\n") ?? "";
-		};
-
-		expect(render({ timer: 1 })).toContain(diagnostic);
-		expect(render({ timer: 1 })).toContain("─");
-		expect(render({ collapsed: true })).toContain("✗  find [ in src · failed");
-		expect(render({ collapsed: true }, true)).toContain(diagnostic);
-	});
-});