@oh-my-pi/pi-coding-agent 8.4.2 → 8.4.5

package/src/tools/find.ts

@@ -1,9 +1,9 @@
-import path from "node:path";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { ptree, untilAborted } from "@oh-my-pi/pi-utils";
+import { isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Static } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -13,28 +13,24 @@ import findDescription from "../prompts/tools/find.md" with { type: "text" };
 import { renderFileList, renderStatusLine, renderTreeList } from "../tui";
 import { ensureTool } from "../utils/tools-manager";
 import type { ToolSession } from ".";
+import { runRg } from "./grep";
 import { applyListLimit } from "./list-limit";
 import type { OutputMeta } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
-import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
+import { ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { type TruncationResult, truncateHead } from "./truncate";
 
 const findSchema = Type.Object({
 	pattern: Type.String({ description: "Glob pattern, e.g. '*.ts', '**/*.json'" }),
 	path: Type.Optional(Type.String({ description: "Directory to search (default: cwd)" })),
+	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files and directories (default: true)" })),
 	limit: Type.Optional(Type.Number({ description: "Max results (default: 1000)" })),
-	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files (default: true)" })),
-	type: Type.Optional(
-		StringEnum(["file", "dir", "all"], {
-			description: "Filter: file, dir, or all (default: all)",
-		}),
-	),
 });
 
 const DEFAULT_LIMIT = 1000;
-const FD_TIMEOUT_MS = 5000;
+const RG_TIMEOUT_MS = 5000;
 
 export interface FindToolDetails {
 	truncation?: TruncationResult;
@@ -60,53 +56,10 @@ export interface FindOperations {
 }
 
 export interface FindToolOptions {
-	/** Custom operations for find. Default: local filesystem + fd */
+	/** Custom operations for find. Default: local filesystem + rg */
 	operations?: FindOperations;
 }
 
-export interface FdResult {
-	stdout: string;
-	stderr: string;
-	exitCode: number | null;
-}
-
-/**
- * Run fd command and capture output.
- *
- * @throws ToolAbortError if signal is aborted
- */
-export async function runFd(fdPath: string, args: string[], signal?: AbortSignal): Promise<FdResult> {
-	const child = ptree.cspawn([fdPath, ...args], { signal });
-
-	let stdout: string;
-	try {
-		stdout = await child.nothrow().text();
-	} catch (err) {
-		if (err instanceof ptree.Exception && err.aborted) {
-			throw new ToolAbortError();
-		}
-		throw err;
-	}
-
-	let exitError: unknown;
-	try {
-		await child.exited;
-	} catch (err) {
-		exitError = err;
-		if (err instanceof ptree.Exception && err.aborted) {
-			throw new ToolAbortError();
-		}
-	}
-
-	const exitCode = child.exitCode ?? (exitError instanceof ptree.Exception ? exitError.exitCode : null);
-
-	return {
-		stdout,
-		stderr: child.peekStderr(),
-		exitCode,
-	};
-}
-
 export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 	public readonly name = "find";
 	public readonly label = "Find";
@@ -129,7 +82,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<FindToolDetails>> {
-		const { pattern, path: searchDir, limit, hidden, type } = params;
+		const { pattern, path: searchDir, limit, hidden } = params;
 
 		return untilAborted(signal, async () => {
 			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
@@ -142,9 +95,19 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				const relative = path.relative(this.session.cwd, searchPath).replace(/\\/g, "/");
 				return relative.length === 0 ? "." : relative;
 			})();
-			const effectiveLimit = limit ?? DEFAULT_LIMIT;
-			const effectiveType = type ?? "all";
+			const normalizedPattern = pattern.trim();
+			if (!normalizedPattern) {
+				throw new ToolError("Pattern must not be empty");
+			}
+
+			const rawLimit = limit ?? DEFAULT_LIMIT;
+			const effectiveLimit = Number.isFinite(rawLimit) ? Math.floor(rawLimit) : Number.NaN;
+			if (!Number.isFinite(effectiveLimit) || effectiveLimit <= 0) {
+				throw new ToolError("Limit must be a positive number");
+			}
 			const includeHidden = hidden ?? true;
+			const globPattern = normalizedPattern.replace(/\\/g, "/");
+			const globMatcher = new Bun.Glob(globPattern);
 
 			// If custom operations provided with glob, use that instead of fd
 			if (this.customOps?.glob) {
@@ -152,7 +115,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					throw new ToolError(`Path not found: ${searchPath}`);
 				}
 
-				const results = await this.customOps.glob(pattern, searchPath, {
+				const results = await this.customOps.glob(normalizedPattern, searchPath, {
 					ignore: ["**/node_modules/**", "**/.git/**"],
 					limit: effectiveLimit,
 				});
@@ -195,99 +158,51 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				return resultBuilder.done();
 			}
 
-			// Default: use fd
-			const fdPath = await ensureTool("fd", {
-				silent: true,
-				notify: message => context?.ui?.notify(message, "info"),
-			});
-			if (!fdPath) {
-				throw new ToolError("fd is not available and could not be downloaded");
-			}
-
-			// Build fd arguments
-			// When pattern contains path separators (e.g. "reports/**"), use --full-path
-			// so fd matches against the full path, not just the filename.
-			// Also prepend **/ to anchor the pattern at any depth in the search path.
-			// Note: "**/foo.rs" is a glob construct (filename at any depth), not a path.
-			// Only patterns with real path components like "foo/bar" or "foo/**/bar" need --full-path.
-			const patternWithoutLeadingStarStar = pattern.replace(/^\*\*\//, "");
-			const hasPathSeparator =
-				patternWithoutLeadingStarStar.includes("/") || patternWithoutLeadingStarStar.includes("\\");
-			const effectivePattern = hasPathSeparator && !pattern.startsWith("**/") ? `**/${pattern}` : pattern;
-			const args: string[] = [
-				"--glob", // Use glob pattern
-				...(hasPathSeparator ? ["--full-path"] : []),
-				"--color=never", // No ANSI colors
-				"--max-results",
-				String(effectiveLimit),
-			];
-
-			if (includeHidden) {
-				args.push("--hidden");
-			}
-
-			// Add type filter
-			if (effectiveType === "file") {
-				args.push("--type", "f");
-			} else if (effectiveType === "dir") {
-				args.push("--type", "d");
-			}
-
-			// Include .gitignore files (root + nested) so fd respects them even outside git repos
-			const gitignoreFiles = new Set<string>();
-			const rootGitignore = path.join(searchPath, ".gitignore");
-			if (await Bun.file(rootGitignore).exists()) {
-				gitignoreFiles.add(rootGitignore);
-			}
-
+			let searchStat: Awaited<ReturnType<typeof fs.stat>>;
 			try {
-				const gitignoreArgs = [
-					"--hidden",
-					"--no-ignore",
-					"--type",
-					"f",
-					"--glob",
-					".gitignore",
-					"--exclude",
-					".git",
-					"--exclude",
-					"node_modules",
-					"--absolute-path",
-					searchPath,
-				];
-				const timeoutSignal = AbortSignal.timeout(FD_TIMEOUT_MS);
-				const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-				const { stdout: gitignoreStdout } = await runFd(fdPath, gitignoreArgs, combinedSignal);
-				for (const rawLine of gitignoreStdout.split("\n")) {
-					const file = rawLine.trim();
-					if (!file) continue;
-					gitignoreFiles.add(file);
-				}
+				searchStat = await fs.stat(searchPath);
 			} catch (err) {
-				if (err instanceof ToolAbortError) {
-					throw err;
+				if (isEnoent(err)) {
+					throw new ToolError(`Path not found: ${searchPath}`);
 				}
-				// Ignore other lookup errors
+				throw err;
+			}
+			if (!searchStat.isDirectory()) {
+				throw new ToolError(`Path is not a directory: ${searchPath}`);
 			}
 
-			for (const gitignorePath of gitignoreFiles) {
-				args.push("--ignore-file", gitignorePath);
+			// Default: use rg
+			const rgPath = await ensureTool("rg", {
+				silent: true,
+				notify: message => context?.ui?.notify(message, "info"),
+			});
+			if (!rgPath) {
+				throw new ToolError("rg is not available and could not be downloaded");
 			}
 
-			// Pattern and path
-			args.push(effectivePattern, searchPath);
+			const args = [
+				"--files",
+				...(includeHidden ? ["--hidden"] : []),
+				"--no-require-git",
+				"--color=never",
+				"--glob",
+				"!**/.git/**",
+				"--glob",
+				"!**/node_modules/**",
+				searchPath,
+			];
 
-			// Run fd with timeout
-			const mainTimeoutSignal = AbortSignal.timeout(FD_TIMEOUT_MS);
+			// Run rg with timeout
+			const mainTimeoutSignal = AbortSignal.timeout(RG_TIMEOUT_MS);
 			const mainCombinedSignal = signal ? AbortSignal.any([signal, mainTimeoutSignal]) : mainTimeoutSignal;
-			const { stdout, stderr, exitCode } = await runFd(fdPath, args, mainCombinedSignal);
+			const { stdout, stderr, exitCode } = await runRg(rgPath, args, mainCombinedSignal);
 			const output = stdout.trim();
 
-			// fd exit codes: 0 = found files, 1 = no matches, other = error
+			// rg exit codes: 0 = found files, 1 = no matches, other = error
 			// Treat exit code 1 with no output as "no files found"
 			if (!output) {
 				if (exitCode !== 0 && exitCode !== 1) {
-					throw new ToolError(stderr.trim() || `fd failed (exit ${exitCode})`);
+					throw new ToolError(stderr.trim() || `rg failed (exit ${exitCode})`);
 				}
 				const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
 				return toolResult(details).text("No files found matching pattern").done();
@@ -311,21 +226,34 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				} else {
 					relativePath = path.relative(searchPath, line);
 				}
-
-				if (hadTrailingSlash && !relativePath.endsWith("/")) {
-					relativePath += "/";
+				const matchPath = relativePath.replace(/\\/g, "/");
+				if (!globMatcher.match(matchPath)) {
+					continue;
 				}
 
+				let mtimeMs = 0;
+				let isDirectory = false;
 				// Get mtime for sorting (files that fail to stat get mtime 0)
 				try {
 					const fullPath = path.join(searchPath, relativePath);
-					const stat = await Bun.file(fullPath).stat();
-					relativized.push(relativePath);
-					mtimes.push(stat.mtimeMs);
+					const stat = await fs.stat(fullPath);
+					mtimeMs = stat.mtimeMs;
+					isDirectory = stat.isDirectory();
 				} catch {
-					relativized.push(relativePath);
-					mtimes.push(0);
+					mtimeMs = 0;
+				}
+
+				if ((isDirectory || hadTrailingSlash) && !relativePath.endsWith("/")) {
+					relativePath += "/";
 				}
+
+				relativized.push(relativePath);
+				mtimes.push(mtimeMs);
+			}
+
+			if (relativized.length === 0) {
+				const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
+				return toolResult(details).text("No files found matching pattern").done();
 			}
 
 			// Sort by mtime (most recent first)
@@ -373,8 +301,6 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 interface FindRenderArgs {
 	pattern: string;
 	path?: string;
-	type?: string;
-	hidden?: boolean;
 	sortByMtime?: boolean;
 	limit?: number;
 }
@@ -386,8 +312,6 @@ export const findToolRenderer = {
 	renderCall(args: FindRenderArgs, uiTheme: Theme): Component {
 		const meta: string[] = [];
 		if (args.path) meta.push(`in ${args.path}`);
-		if (args.type && args.type !== "all") meta.push(`type:${args.type}`);
-		if (args.hidden) meta.push("hidden");
 		if (args.sortByMtime) meta.push("sort:mtime");
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);