@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/tools/find.ts

@@ -4,8 +4,8 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import * as natives from "@prometheus-ai/natives";
 import type { Component } from "@prometheus-ai/tui";
 import { Text } from "@prometheus-ai/tui";
-import { isEnoent, prompt, untilAborted } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { formatGroupedPaths, isEnoent, prompt, untilAborted } from "@prometheus-ai/utils";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";
@@ -53,37 +53,6 @@ const DEFAULT_GLOB_TIMEOUT_MS = 5000;
 const MIN_GLOB_TIMEOUT_MS = 500;
 const MAX_GLOB_TIMEOUT_MS = 60_000;
 
-/**
- * Group find matches by their directory so the model doesn't pay repeated
- * tokens for shared path prefixes. Preserves the input order: groups appear in
- * the order their first member was emitted (mtime-desc for native glob), and
- * within a group entries keep their relative order.
- */
-export function formatFindGroupedOutput(paths: readonly string[]): string {
-	if (paths.length === 0) return "";
-	const groups = new Map<string, string[]>();
-	for (const entry of paths) {
-		const hasTrailingSlash = entry.endsWith("/");
-		const trimmed = hasTrailingSlash ? entry.slice(0, -1) : entry;
-		const slash = trimmed.lastIndexOf("/");
-		const dir = slash === -1 ? "" : trimmed.slice(0, slash);
-		const base = slash === -1 ? trimmed : trimmed.slice(slash + 1);
-		const label = hasTrailingSlash ? `${base}/` : base;
-		const list = groups.get(dir);
-		if (list) list.push(label);
-		else groups.set(dir, [label]);
-	}
-	const sections: string[] = [];
-	for (const [dir, entries] of groups) {
-		if (dir === "") {
-			sections.push(entries.join("\n"));
-		} else {
-			sections.push(`# ${dir}/\n${entries.join("\n")}`);
-		}
-	}
-	return sections.join("\n\n");
-}
-
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
@@ -123,6 +92,12 @@ export interface FindToolOptions {
 	operations?: FindOperations;
 }
 
+interface FindTarget {
+	searchPath: string;
+	globPattern: string;
+	hasGlob: boolean;
+}
+
 export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 	readonly name = "find";
 	readonly approval = "read" as const;
@@ -199,15 +174,31 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 
 			const multiPattern = await resolveExplicitFindPatterns(effectivePatterns, this.session.cwd);
-			const parsedPattern = multiPattern ? null : parseFindPattern(effectivePatterns[0] ?? ".");
-			const hasGlob = multiPattern ? true : (parsedPattern?.hasGlob ?? false);
-			const globPattern = multiPattern?.globPattern ?? parsedPattern?.globPattern ?? "**/*";
-			const searchPath = resolveToCwd(multiPattern?.basePath ?? parsedPattern?.basePath ?? ".", this.session.cwd);
-			const scopePath = multiPattern?.scopePath ?? formatScopePath(searchPath);
-
-			if (searchPath === "/") {
-				throw new ToolError("Searching from root directory '/' is not allowed");
+			const isSingle = !multiPattern;
+			const targets: FindTarget[] = multiPattern
+				? multiPattern.targets.map(target => ({
+						searchPath: resolveToCwd(target.basePath, this.session.cwd),
+						globPattern: target.globPattern,
+						hasGlob: target.hasGlob,
+					}))
+				: [
+						(() => {
+							const parsed = parseFindPattern(effectivePatterns[0] ?? ".");
+							return {
+								searchPath: resolveToCwd(parsed.basePath, this.session.cwd),
+								globPattern: parsed.globPattern,
+								hasGlob: parsed.hasGlob,
+							};
+						})(),
+					];
+			const scopePath = multiPattern?.scopePath ?? formatScopePath(targets[0].searchPath);
+
+			for (const target of targets) {
+				if (target.searchPath === "/") {
+					throw new ToolError("Searching from root directory '/' is not allowed");
+				}
 			}
+
 			const requestedLimit = limit ?? DEFAULT_LIMIT;
 			if (!Number.isFinite(requestedLimit) || requestedLimit <= 0) {
 				throw new ToolError("Limit must be a positive number");
@@ -219,9 +210,9 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const timeoutMs = Math.min(MAX_GLOB_TIMEOUT_MS, Math.max(MIN_GLOB_TIMEOUT_MS, requestedTimeoutMs));
 			const timeoutSignal = AbortSignal.timeout(timeoutMs);
 			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-			const formatMatchPath = (matchPath: string, fileType?: natives.FileType): string => {
+			const formatMatchPath = (matchPath: string, base: string, fileType?: natives.FileType): string => {
 				const hadTrailingSlash = matchPath.endsWith("/") || matchPath.endsWith("\\");
-				const absolutePath = path.isAbsolute(matchPath) ? matchPath : path.resolve(searchPath, matchPath);
+				const absolutePath = path.isAbsolute(matchPath) ? matchPath : path.resolve(base, matchPath);
 				return formatPathRelativeToCwd(absolutePath, this.session.cwd, {
 					trailingSlash: fileType === natives.FileType.Dir || hadTrailingSlash,
 				});
@@ -248,13 +239,15 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					const parts = ["No files found matching pattern"];
 					if (notice) parts.push(notice);
 					if (missingPathsNote) parts.push(missingPathsNote);
-					return toolResult(details).text(parts.join("\n")).done();
+					// Zero results is useless regardless of notices: the follow-up
+					// call has already corrected course by the time compaction runs.
+					return toolResult(details).text(parts.join("\n")).useless().done();
 				}
 
 				const listLimit = applyListLimit(files, { limit: effectiveLimit });
 				const limited = listLimit.items;
 				const limitMeta = listLimit.meta;
-				const baseOutput = formatFindGroupedOutput(limited);
+				const baseOutput = formatGroupedPaths(limited);
 				const trailingNotes: string[] = [];
 				if (notice) trailingNotes.push(notice);
 				if (missingPathsNote) trailingNotes.push(missingPathsNote);
@@ -282,45 +275,41 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				return resultBuilder.done();
 			};
 
+			// Walk each user path as its own root and run the globs concurrently.
+			// Collapsing multiple paths to a shared base would force the walker to
+			// traverse and stat every unrelated sibling under that ancestor; per-path
+			// roots keep each scan bounded to exactly what the user asked for.
 			if (this.#customOps?.glob) {
-				if (!(await this.#customOps.exists(searchPath))) {
-					throw new ToolError(`Path not found: ${scopePath}`);
-				}
-
-				if (!hasGlob && this.#customOps.stat) {
-					const stat = await this.#customOps.stat(searchPath);
-					if (stat.isFile()) {
-						return buildResult([scopePath]);
+				const customOps = this.#customOps;
+				const perTarget = await Promise.all(
+					targets.map(async target => {
+						if (!(await customOps.exists(target.searchPath))) {
+							if (isSingle) throw new ToolError(`Path not found: ${scopePath}`);
+							return [] as string[];
+						}
+						if (!target.hasGlob && customOps.stat) {
+							const stat = await customOps.stat(target.searchPath);
+							if (stat.isFile()) return [formatScopePath(target.searchPath)];
+						}
+						const results = await customOps.glob(target.globPattern, target.searchPath, {
+							ignore: ["**/node_modules/**", "**/.git/**"],
+							limit: effectiveLimit,
+						});
+						return results.map(matchPath => formatMatchPath(matchPath, target.searchPath));
+					}),
+				);
+				const seen = new Set<string>();
+				const merged: string[] = [];
+				for (const group of perTarget) {
+					for (const entry of group) {
+						if (seen.has(entry)) continue;
+						seen.add(entry);
+						merged.push(entry);
 					}
 				}
-
-				const results = await this.#customOps.glob(globPattern, searchPath, {
-					ignore: ["**/node_modules/**", "**/.git/**"],
-					limit: effectiveLimit,
-				});
-				const relativized = results.map(p => formatMatchPath(p));
-
-				return buildResult(relativized);
-			}
-
-			let searchStat: fs.Stats;
-			try {
-				searchStat = await fs.promises.stat(searchPath);
-			} catch (err) {
-				if (isEnoent(err)) {
-					throw new ToolError(`Path not found: ${scopePath}`);
-				}
-				throw err;
+				return buildResult(merged);
 			}
 
-			if (!hasGlob && searchStat.isFile()) {
-				return buildResult([scopePath]);
-			}
-			if (!searchStat.isDirectory()) {
-				throw new ToolError(`Path is not a directory: ${searchPath}`);
-			}
-
-			let matches: natives.GlobMatch[];
 			const onUpdateMatches: string[] = [];
 			const onUpdateMtimes: number[] = [];
 			const updateIntervalMs = 200;
@@ -341,80 +330,111 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					details,
 				});
 			};
-			const onMatch = (err: Error | null, match: natives.GlobMatch | null) => {
-				if (err || combinedSignal.aborted || !match?.path) return;
-				const relativePath = formatMatchPath(match.path, match.fileType);
-				onUpdateMatches.push(relativePath);
-				onUpdateMtimes.push(match.mtime ?? 0);
-				emitUpdate();
-			};
-
-			const doGlob = async (useGitignore: boolean) =>
-				untilAborted(combinedSignal, () =>
-					natives.glob(
-						{
-							pattern: globPattern,
-							path: searchPath,
-							hidden: includeHidden,
-							maxResults: effectiveLimit,
-							sortByMtime: true,
-							gitignore: useGitignore,
-							signal: combinedSignal,
-						},
-						onMatch,
-					),
-				);
+			const streamed = new Set<string>();
+			const makeOnMatch =
+				(base: string) =>
+				(err: Error | null, match: natives.GlobMatch | null): void => {
+					if (err || combinedSignal.aborted || !match?.path) return;
+					const relativePath = formatMatchPath(match.path, base, match.fileType);
+					if (streamed.has(relativePath)) return;
+					streamed.add(relativePath);
+					onUpdateMatches.push(relativePath);
+					onUpdateMtimes.push(match.mtime ?? 0);
+					emitUpdate();
+				};
 
 			let timedOut = false;
-			try {
-				const result = await doGlob(useGitignore);
-				// Native glob returns a bounded mtime-ranked set; keep the JS sort for
-				// deterministic ordering across cached and uncached native paths.
-				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
-				matches = result.matches;
-			} catch (error) {
-				if (error instanceof Error && error.name === "AbortError") {
-					if (timeoutSignal.aborted && !signal?.aborted) {
-						timedOut = true;
-						matches = [];
-					} else {
+			const runTarget = async (target: FindTarget): Promise<Array<{ path: string; mtime: number }>> => {
+				throwIfAborted(signal);
+				let stat: fs.Stats;
+				try {
+					stat = await fs.promises.stat(target.searchPath);
+				} catch (err) {
+					if (isEnoent(err)) {
+						if (isSingle) throw new ToolError(`Path not found: ${scopePath}`);
+						return [];
+					}
+					throw err;
+				}
+				if (!target.hasGlob && stat.isFile()) {
+					return [{ path: formatScopePath(target.searchPath), mtime: stat.mtimeMs }];
+				}
+				if (!stat.isDirectory()) {
+					if (isSingle) throw new ToolError(`Path is not a directory: ${target.searchPath}`);
+					return [];
+				}
+				try {
+					const result = await untilAborted(combinedSignal, () =>
+						natives.glob(
+							{
+								pattern: target.globPattern,
+								path: target.searchPath,
+								hidden: includeHidden,
+								maxResults: effectiveLimit,
+								sortByMtime: true,
+								gitignore: useGitignore,
+								// parseFindPattern explicitly prepends "**/" when the user's
+								// pattern begins with a glob (so `*.ts` becomes `**/*.ts`).
+								// Anything that arrives here without "**/" was scoped to a
+								// single directory by the user (e.g. `dir/*`); disable the
+								// native auto-recursion so `dir/*` does not silently match
+								// `dir/sub/nested.ts`.
+								recursive: false,
+								signal: combinedSignal,
+							},
+							makeOnMatch(target.searchPath),
+						),
+					);
+					throwIfAborted(signal);
+					const out: Array<{ path: string; mtime: number }> = [];
+					for (const match of result.matches) {
+						if (!match.path) continue;
+						out.push({
+							path: formatMatchPath(match.path, target.searchPath, match.fileType),
+							mtime: match.mtime ?? 0,
+						});
+					}
+					return out;
+				} catch (error) {
+					if (error instanceof Error && error.name === "AbortError") {
+						if (timeoutSignal.aborted && !signal?.aborted) {
+							timedOut = true;
+							return [];
+						}
 						throw new ToolAbortError();
 					}
-				} else {
 					throw error;
 				}
-			}
+			};
+
+			const perTarget = await Promise.all(targets.map(runTarget));
 
 			if (timedOut) {
 				// Drain the partial matches accumulated during streaming and return them
 				// instead of throwing — empty results after a multi-second wait force the
 				// caller to retry blind, which is the worst possible outcome.
-				const seen = new Set<string>();
-				const partial: Array<{ p: string; m: number }> = [];
-				for (let i = 0; i < onUpdateMatches.length; i++) {
-					const entry = onUpdateMatches[i];
-					if (seen.has(entry)) continue;
-					seen.add(entry);
-					partial.push({ p: entry, m: onUpdateMtimes[i] ?? 0 });
-				}
+				const partial = onUpdateMatches.map((entry, index) => ({ p: entry, m: onUpdateMtimes[index] ?? 0 }));
 				partial.sort((a, b) => b.m - a.m);
-				const sortedPaths = partial.map(e => e.p);
+				const sortedPaths = partial.map(entry => entry.p);
 				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
 				const notice = `find timed out after ${seconds}s; returning ${sortedPaths.length} partial matches — increase timeout or narrow pattern`;
 				return buildResult(sortedPaths, { notice, forceTruncated: true });
 			}
 
-			const relativized: string[] = [];
-			for (const match of matches) {
-				throwIfAborted(signal);
-				if (!match.path) {
-					continue;
+			// Merge per-target results: native glob already ranks each target's own
+			// matches by mtime and caps them at the limit, so a global mtime re-sort
+			// plus dedup yields the correct top-N across all roots.
+			const seen = new Set<string>();
+			const merged: Array<{ path: string; mtime: number }> = [];
+			for (const group of perTarget) {
+				for (const entry of group) {
+					if (seen.has(entry.path)) continue;
+					seen.add(entry.path);
+					merged.push(entry);
 				}
-
-				relativized.push(formatMatchPath(match.path, match.fileType));
 			}
-
-			return buildResult(relativized);
+			merged.sort((a, b) => b.mtime - a.mtime);
+			return buildResult(merged.map(entry => entry.path));
 		});
 	}
 }
@@ -434,6 +454,10 @@ function formatFindRenderPaths(paths: FindRenderArgs["paths"]): string | undefin
 
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 
+function findStatusIcon(uiTheme: Theme): string {
+	return uiTheme.fg("toolTitle", uiTheme.symbol("icon.search"));
+}
+
 export const findToolRenderer = {
 	inline: true,
 	renderCall(args: FindRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
@@ -441,10 +465,16 @@ export const findToolRenderer = {
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 
 		const text = renderStatusLine(
-			{ icon: "pending", title: "Find", description: formatFindRenderPaths(args.paths) || "*", meta },
+			{
+				icon: "pending",
+				title: "Find",
+				titleColor: "toolTitle",
+				description: formatFindRenderPaths(args.paths) || "*",
+				meta,
+			},
 			uiTheme,
 		);
-		return new Text(text, 0, 0);
+		return new Text(text, 1, 0);
 	},
 
 	renderResult(
@@ -457,7 +487,7 @@ export const findToolRenderer = {
 
 		if (result.isError || details?.error) {
 			const errorText = details?.error || result.content?.find(c => c.type === "text")?.text || "Unknown error";
-			return new Text(formatErrorMessage(errorText, uiTheme), 0, 0);
+			return new Text(formatErrorMessage(errorText, uiTheme), 1, 0);
 		}
 
 		const hasDetailedData = details?.fileCount !== undefined;
@@ -470,14 +500,15 @@ export const findToolRenderer = {
 				textContent.includes("No files found") ||
 				textContent.trim() === ""
 			) {
-				return new Text(formatEmptyMessage("No files found", uiTheme), 0, 0);
+				return new Text(formatEmptyMessage("No files found", uiTheme), 1, 0);
 			}
 
 			const lines = textContent.split("\n").filter(l => l.trim());
 			const header = renderStatusLine(
 				{
-					icon: "success",
+					iconOverride: findStatusIcon(uiTheme),
 					title: "Find",
+					titleColor: "toolTitle",
 					description: formatFindRenderPaths(args?.paths),
 					meta: [formatCount("file", lines.length)],
 				},
@@ -498,6 +529,7 @@ export const findToolRenderer = {
 					);
 					return [header, ...listLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
 				},
+				{ paddingX: 1 },
 			);
 		}
 
@@ -513,20 +545,27 @@ export const findToolRenderer = {
 
 		if (fileCount === 0) {
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Find", description: formatFindRenderPaths(args?.paths), meta: ["0 files"] },
+				{
+					icon: "warning",
+					title: "Find",
+					titleColor: "toolTitle",
+					description: formatFindRenderPaths(args?.paths),
+					meta: ["0 files"],
+				},
 				uiTheme,
 			);
 			const lines = [header, formatEmptyMessage("No files found", uiTheme)];
 			if (missingNote) lines.push(missingNote);
-			return new Text(lines.join("\n"), 0, 0);
+			return new Text(lines.join("\n"), 1, 0);
 		}
 		const meta: string[] = [formatCount("file", fileCount)];
 		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const header = renderStatusLine(
 			{
-				icon: truncated ? "warning" : "success",
+				...(truncated ? { icon: "warning" as const } : { iconOverride: findStatusIcon(uiTheme) }),
 				title: "Find",
+				titleColor: "toolTitle",
 				description: formatFindRenderPaths(args?.paths),
 				meta,
 			},
@@ -565,6 +604,7 @@ export const findToolRenderer = {
 				);
 				return [header, ...fileLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
 			},
+			{ paddingX: 1 },
 		);
 	},
 	mergeCallAndResult: true,