@oh-my-pi/pi-coding-agent 6.9.69 → 8.0.0

package/src/{core/tools → tools}/find.ts

@@ -6,30 +6,29 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { ptree, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Static } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
-import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
-import findDescription from "../../prompts/tools/find.md" with { type: "text" };
-import { ensureTool } from "../../utils/tools-manager";
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import { getLanguageFromPath, type Theme } from "$c/modes/theme/theme";
+import findDescription from "$c/prompts/tools/find.md" with { type: "text" };
+import type { OutputMeta } from "$c/tools/output-meta";
+import { ToolAbortError, ToolError, throwIfAborted } from "$c/tools/tool-errors";
+import { ensureTool } from "$c/utils/tools-manager";
+
 import type { ToolSession } from "./index";
+import { applyListLimit } from "./list-limit";
 import { resolveToCwd } from "./path-utils";
 import { PREVIEW_LIMITS, ToolUIKit } from "./render-utils";
-import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
+import { toolResult } from "./tool-result";
+import { type TruncationResult, truncateHead } from "./truncate";
 
 const findSchema = Type.Object({
-	pattern: Type.String({
-		description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'",
-	}),
-	path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
-	limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
+	pattern: Type.String({ description: "Glob pattern, e.g. '*.ts', '**/*.json'" }),
+	path: Type.Optional(Type.String({ description: "Directory to search (default: cwd)" })),
+	limit: Type.Optional(Type.Number({ description: "Max results (default: 1000)" })),
 	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files (default: true)" })),
-	sortByMtime: Type.Optional(
-		Type.Boolean({ description: "Sort results by modification time, most recent first (default: false)" }),
-	),
 	type: Type.Optional(
 		StringEnum(["file", "dir", "all"], {
-			description:
-				"Filter by type: 'file' for files only, 'dir' for directories only, 'all' for both (default: 'all')",
+			description: "Filter: file, dir, or all (default: all)",
 		}),
 	),
 });
@@ -39,6 +38,7 @@ const DEFAULT_LIMIT = 1000;
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
+	meta?: OutputMeta;
 	// Fields for TUI rendering
 	scopePath?: string;
 	fileCount?: number;
@@ -72,7 +72,7 @@ export interface FdResult {
 /**
  * Run fd command and capture output.
  *
- * @throws Error with message "Operation aborted" if signal is aborted
+ * @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 });
@@ -82,15 +82,27 @@ export async function runFd(fdPath: string, args: string[], signal?: AbortSignal
 		stdout = await child.nothrow().text();
 	} catch (err) {
 		if (err instanceof ptree.Exception && err.aborted) {
-			throw new Error("Operation 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: child.exitCode,
+		exitCode,
 	};
 }
 
@@ -116,7 +128,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<FindToolDetails>> {
-		const { pattern, path: searchDir, limit, hidden, sortByMtime, type } = params;
+		const { pattern, path: searchDir, limit, hidden, type } = params;
 
 		return untilAborted(signal, async () => {
 			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
@@ -127,12 +139,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const effectiveLimit = limit ?? DEFAULT_LIMIT;
 			const effectiveType = type ?? "all";
 			const includeHidden = hidden ?? true;
-			const shouldSortByMtime = sortByMtime ?? false;
 
 			// If custom operations provided with glob, use that instead of fd
 			if (this.customOps?.glob) {
 				if (!(await this.customOps.exists(searchPath))) {
-					throw new Error(`Path not found: ${searchPath}`);
+					throw new ToolError(`Path not found: ${searchPath}`);
 				}
 
 				const results = await this.customOps.glob(pattern, searchPath, {
@@ -141,10 +152,8 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				});
 
 				if (results.length === 0) {
-					return {
-						content: [{ type: "text", text: "No files found matching pattern" }],
-						details: { scopePath, fileCount: 0, files: [], truncated: false },
-					};
+					const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
+					return toolResult(details).text("No files found matching pattern").done();
 				}
 
 				// Relativize paths
@@ -155,45 +164,35 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					return path.relative(searchPath, p);
 				});
 
-				const resultLimitReached = relativized.length >= effectiveLimit;
-				const rawOutput = relativized.join("\n");
+				const listLimit = applyListLimit(relativized, { limit: effectiveLimit });
+				const limited = listLimit.items;
+				const limitMeta = listLimit.meta;
+				const rawOutput = limited.join("\n");
 				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
-				let resultOutput = truncation.content;
 				const details: FindToolDetails = {
 					scopePath,
-					fileCount: relativized.length,
-					files: relativized,
-					truncated: resultLimitReached || truncation.truncated,
+					fileCount: limited.length,
+					files: limited,
+					truncated: Boolean(limitMeta.resultLimit || truncation.truncated),
+					resultLimitReached: limitMeta.resultLimit?.reached,
+					truncation: truncation.truncated ? truncation : undefined,
 				};
-				const notices: string[] = [];
-
-				if (resultLimitReached) {
-					notices.push(
-						`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`,
-					);
-					details.resultLimitReached = effectiveLimit;
-				}
 
+				const resultBuilder = toolResult(details)
+					.text(truncation.content)
+					.limits({ resultLimit: limitMeta.resultLimit?.reached });
 				if (truncation.truncated) {
-					notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-					details.truncation = truncation;
+					resultBuilder.truncation(truncation, { direction: "head" });
 				}
 
-				if (notices.length > 0) {
-					resultOutput += `\n\n[${notices.join(". ")}]`;
-				}
-
-				return {
-					content: [{ type: "text", text: resultOutput }],
-					details,
-				};
+				return resultBuilder.done();
 			}
 
 			// Default: use fd
 			const fdPath = await ensureTool("fd", true);
 			if (!fdPath) {
-				throw new Error("fd is not available and could not be downloaded");
+				throw new ToolError("fd is not available and could not be downloaded");
 			}
 
 			// Build fd arguments
@@ -254,7 +253,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					gitignoreFiles.add(file);
 				}
 			} catch (err) {
-				if (err instanceof Error && err.message === "Operation aborted") {
+				if (err instanceof ToolAbortError) {
 					throw err;
 				}
 				// Ignore other lookup errors
@@ -271,15 +270,14 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const { stdout, stderr, exitCode } = await runFd(fdPath, args, signal);
 			const output = stdout.trim();
 
-			if (exitCode !== 0 && !output) {
-				throw new Error(stderr.trim() || `fd exited with code ${exitCode ?? -1}`);
-			}
-
+			// fd exit codes: 0 = found files, 1 = no matches, other = error
+			// Treat exit code 1 with no output as "no files found"
 			if (!output) {
-				return {
-					content: [{ type: "text", text: "No files found matching pattern" }],
-					details: { scopePath, fileCount: 0, files: [], truncated: false },
-				};
+				if (exitCode !== 0 && exitCode !== 1) {
+					throw new ToolError(stderr.trim() || `fd failed (exit ${exitCode})`);
+				}
+				const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
+				return toolResult(details).text("No files found matching pattern").done();
 			}
 
 			const lines = output.split("\n");
@@ -287,7 +285,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const mtimes: number[] = [];
 
 			for (const rawLine of lines) {
-				signal?.throwIfAborted();
+				throwIfAborted(signal);
 				const line = rawLine.replace(/\r$/, "").trim();
 				if (!line) {
 					continue;
@@ -305,68 +303,52 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					relativePath += "/";
 				}
 
-				// When sorting by mtime, keep files that fail to stat with mtime 0
-				if (shouldSortByMtime) {
-					try {
-						const fullPath = path.join(searchPath, relativePath);
-						const stat = await Bun.file(fullPath).stat();
-						relativized.push(relativePath);
-						mtimes.push(stat.mtimeMs);
-					} catch {
-						relativized.push(relativePath);
-						mtimes.push(0);
-					}
-				} else {
+				// 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);
+				} catch {
 					relativized.push(relativePath);
+					mtimes.push(0);
 				}
 			}
 
-			// Sort by mtime if requested (most recent first)
-			if (shouldSortByMtime && relativized.length > 0) {
+			// Sort by mtime (most recent first)
+			if (relativized.length > 0) {
 				const indexed = relativized.map((path, idx) => ({ path, mtime: mtimes[idx] }));
 				indexed.sort((a, b) => b.mtime - a.mtime);
 				relativized.length = 0;
 				relativized.push(...indexed.map((item) => item.path));
 			}
 
-			// Check if we hit the result limit
-			const resultLimitReached = relativized.length >= effectiveLimit;
+			const listLimit = applyListLimit(relativized, { limit: effectiveLimit });
+			const limited = listLimit.items;
+			const limitMeta = listLimit.meta;
 
 			// Apply byte truncation (no line limit since we already have result limit)
-			const rawOutput = relativized.join("\n");
+			const rawOutput = limited.join("\n");
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
-			let resultOutput = truncation.content;
+			const resultOutput = truncation.content;
 			const details: FindToolDetails = {
 				scopePath,
-				fileCount: relativized.length,
-				files: relativized,
-				truncated: resultLimitReached || truncation.truncated,
+				fileCount: limited.length,
+				files: limited,
+				truncated: Boolean(limitMeta.resultLimit || truncation.truncated),
+				resultLimitReached: limitMeta.resultLimit?.reached,
+				truncation: truncation.truncated ? truncation : undefined,
 			};
 
-			// Build notices
-			const notices: string[] = [];
-
-			if (resultLimitReached) {
-				notices.push(
-					`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`,
-				);
-				details.resultLimitReached = effectiveLimit;
-			}
-
+			const resultBuilder = toolResult(details)
+				.text(resultOutput)
+				.limits({ resultLimit: limitMeta.resultLimit?.reached });
 			if (truncation.truncated) {
-				notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-				details.truncation = truncation;
+				resultBuilder.truncation(truncation, { direction: "head" });
 			}
 
-			if (notices.length > 0) {
-				resultOutput += `\n\n[${notices.join(". ")}]`;
-			}
-
-			return {
-				content: [{ type: "text", text: resultOutput }],
-				details,
-			};
+			return resultBuilder.done();
 		});
 	}
 }
@@ -449,7 +431,11 @@ export const findToolRenderer = {
 		}
 
 		const fileCount = details?.fileCount ?? 0;
-		const truncated = details?.truncated ?? details?.truncation?.truncated ?? false;
+		const truncation = details?.meta?.truncation;
+		const limits = details?.meta?.limits;
+		const truncated = Boolean(
+			details?.truncated || truncation || limits?.resultLimit || limits?.headLimit || limits?.matchLimit,
+		);
 		const files = details?.files ?? [];
 
 		if (fileCount === 0) {
@@ -466,11 +452,14 @@ export const findToolRenderer = {
 		let text = `  ${icon} ${uiTheme.fg("dim", summaryText)}${ui.truncationSuffix(truncated)}${scopeLabel}${expandHint}`;
 
 		const truncationReasons: string[] = [];
-		if (details?.resultLimitReached) {
-			truncationReasons.push(`limit ${details.resultLimitReached} results`);
+		if (limits?.resultLimit) {
+			truncationReasons.push(`limit ${limits.resultLimit.reached} results`);
+		}
+		if (truncation) {
+			truncationReasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
 		}
-		if (details?.truncation?.truncated) {
-			truncationReasons.push("size limit");
+		if (truncation?.artifactId) {
+			truncationReasons.push(`full output: artifact://${truncation.artifactId}`);
 		}
 
 		const hasTruncation = truncationReasons.length > 0;