@oh-my-pi/pi-coding-agent 7.0.0 → 8.0.1

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

@@ -6,53 +6,39 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { ptree, readLines } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import { $ } from "bun";
-import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
-import grepDescription from "../../prompts/tools/grep.md" with { type: "text" };
-import { ensureTool } from "../../utils/tools-manager";
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
-import { untilAborted } from "../utils";
+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 grepDescription from "$c/prompts/tools/grep.md" with { type: "text" };
+import type { OutputMeta } from "$c/tools/output-meta";
+import { ToolAbortError, ToolError } from "$c/tools/tool-errors";
+import { ensureTool } from "$c/utils/tools-manager";
+import { untilAborted } from "$c/utils/utils";
 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,
-	DEFAULT_MAX_COLUMN,
-	formatSize,
-	type TruncationResult,
-	truncateHead,
-	truncateLine,
-} from "./truncate";
+import { toolResult } from "./tool-result";
+import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead, truncateLine } from "./truncate";
 
 const grepSchema = Type.Object({
-	pattern: Type.String({ description: "Search pattern (regex or literal string)" }),
-	path: Type.Optional(Type.String({ description: "Directory or file to search (default: current directory)" })),
-	glob: Type.Optional(Type.String({ description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'" })),
-	type: Type.Optional(Type.String({ description: "File type filter (e.g., 'ts', 'rust', 'py')" })),
-	ignoreCase: Type.Optional(
-		Type.Boolean({ description: "Force case-insensitive search (default: false, uses smart-case otherwise)" }),
-	),
-	caseSensitive: Type.Optional(
-		Type.Boolean({ description: "Force case-sensitive search (default: false, disables smart-case)" }),
-	),
-	literal: Type.Optional(
-		Type.Boolean({ description: "Treat pattern as literal string instead of regex (default: false)" }),
-	),
-	multiline: Type.Optional(
-		Type.Boolean({ description: "Enable multiline matching for cross-line patterns (default: false)" }),
-	),
-	context: Type.Optional(
-		Type.Number({ description: "Number of lines to show before and after each match (default: 0)" }),
-	),
-	limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" })),
-	outputMode: Type.Optional(
+	pattern: Type.String({ description: "Search pattern (regex)" }),
+	path: Type.Optional(Type.String({ description: "Directory or file to search (default: cwd)" })),
+	glob: Type.Optional(Type.String({ description: "Glob filter, e.g. '*.ts', '**/*.spec.ts'" })),
+	type: Type.Optional(Type.String({ description: "File type filter, e.g. 'ts', 'py', 'rust'" })),
+	ignore_case: Type.Optional(Type.Boolean({ description: "Force case-insensitive (default: smart-case)" })),
+	case_sensitive: Type.Optional(Type.Boolean({ description: "Force case-sensitive (default: smart-case)" })),
+	literal: Type.Optional(Type.Boolean({ description: "Treat pattern as literal, not regex (default: false)" })),
+	multiline: Type.Optional(Type.Boolean({ description: "Match across line boundaries (default: false)" })),
+	context: Type.Optional(Type.Number({ description: "Lines of context before/after match (default: 0)" })),
+	limit: Type.Optional(Type.Number({ description: "Max matches to return (default: 100)" })),
+	output_mode: Type.Optional(
 		StringEnum(["content", "files_with_matches", "count"], {
-			description:
-				"Output mode: 'content' shows matching lines, 'files_with_matches' shows only file paths, 'count' shows match counts per file (default: 'content')",
+			description: "Output format (default: content)",
 		}),
 	),
-	headLimit: Type.Optional(Type.Number({ description: "Limit output to first N results (default: unlimited)" })),
-	offset: Type.Optional(Type.Number({ description: "Skip first N results before applying headLimit (default: 0)" })),
+	head_limit: Type.Optional(Type.Number({ description: "Truncate output to first N results" })),
+	offset: Type.Optional(Type.Number({ description: "Skip first N results (default: 0)" })),
 });
 
 const DEFAULT_LIMIT = 100;
@@ -62,6 +48,7 @@ export interface GrepToolDetails {
 	matchLimitReached?: number;
 	headLimitReached?: number;
 	linesTruncated?: boolean;
+	meta?: OutputMeta;
 	// Fields for TUI rendering
 	scopePath?: string;
 	matchCount?: number;
@@ -99,14 +86,14 @@ interface GrepParams {
 	path?: string;
 	glob?: string;
 	type?: string;
-	ignoreCase?: boolean;
-	caseSensitive?: boolean;
+	ignore_case?: boolean;
+	case_sensitive?: boolean;
 	literal?: boolean;
 	multiline?: boolean;
 	context?: number;
 	limit?: number;
-	outputMode?: "content" | "files_with_matches" | "count";
-	headLimit?: number;
+	output_mode?: "content" | "files_with_matches" | "count";
+	head_limit?: number;
 	offset?: number;
 }
 
@@ -165,14 +152,14 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			path: searchDir,
 			glob,
 			type,
-			ignoreCase,
-			caseSensitive,
+			ignore_case,
+			case_sensitive,
 			literal,
 			multiline,
 			context,
 			limit,
-			outputMode,
-			headLimit,
+			output_mode,
+			head_limit,
 			offset,
 		} = params;
 
@@ -189,7 +176,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 			const rgPath = await this.rgPath;
 			if (!rgPath) {
-				throw new Error("ripgrep (rg) is not available and could not be downloaded");
+				throw new ToolError("ripgrep (rg) is not available and could not be downloaded");
 			}
 
 			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
@@ -202,13 +189,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			try {
 				isDirectory = await this.ops.isDirectory(searchPath);
 			} catch {
-				throw new Error(`Path not found: ${searchPath}`);
+				throw new ToolError(`Path not found: ${searchPath}`);
 			}
 			const contextValue = context && context > 0 ? context : 0;
 			const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
-			const effectiveOutputMode = outputMode ?? "content";
+			const effectiveOutputMode = output_mode ?? "content";
 			const effectiveOffset = offset && offset > 0 ? offset : 0;
-			const hasHeadLimit = headLimit !== undefined && headLimit > 0;
 
 			const formatPath = (filePath: string): string => {
 				if (isDirectory) {
@@ -248,9 +234,9 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				args.push("--json", "--line-number", "--color=never", "--hidden");
 			}
 
-			if (caseSensitive) {
+			if (case_sensitive) {
 				args.push("--case-sensitive");
-			} else if (ignoreCase) {
+			} else if (ignore_case) {
 				args.push("--ignore-case");
 			} else {
 				args.push("--smart-case");
@@ -310,7 +296,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				const exitCode = child.exitCode ?? 0;
 				if (exitCode !== 0 && exitCode !== 1) {
 					const errorMsg = child.peekStderr().trim() || `ripgrep exited with code ${exitCode}`;
-					throw new Error(errorMsg);
+					throw new ToolError(errorMsg);
 				}
 
 				const lines = stdout
@@ -319,27 +305,25 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					.filter((line) => line.length > 0);
 
 				if (lines.length === 0) {
-					return {
-						content: [{ type: "text", text: "No matches found" }],
-						details: {
-							scopePath,
-							matchCount: 0,
-							fileCount: 0,
-							files: [],
-							mode: effectiveOutputMode,
-							truncated: false,
-						},
+					const details: GrepToolDetails = {
+						scopePath,
+						matchCount: 0,
+						fileCount: 0,
+						files: [],
+						mode: effectiveOutputMode,
+						truncated: false,
 					};
+					return toolResult(details).text("No matches found").done();
 				}
 
-				// Apply offset and headLimit
-				let processedLines = lines;
-				if (effectiveOffset > 0) {
-					processedLines = processedLines.slice(effectiveOffset);
-				}
-				if (hasHeadLimit) {
-					processedLines = processedLines.slice(0, headLimit);
-				}
+				const offsetLines = effectiveOffset > 0 ? lines.slice(effectiveOffset) : lines;
+				const listLimit = applyListLimit(offsetLines, {
+					limit: effectiveLimit,
+					headLimit: head_limit,
+					limitType: "result",
+				});
+				const processedLines = listLimit.items;
+				const limitMeta = listLimit.meta;
 
 				let simpleMatchCount = 0;
 				let fileCount = 0;
@@ -382,7 +366,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					fileCount = simpleFiles.size;
 				}
 
-				const truncatedByHeadLimit = hasHeadLimit && processedLines.length < lines.length;
+				const truncatedByLimit = Boolean(limitMeta.resultLimit || limitMeta.headLimit);
 
 				// For count mode, format as "path:count"
 				if (effectiveOutputMode === "count") {
@@ -393,39 +377,47 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						return `${relative}:${count}`;
 					});
 					const output = formatted.join("\n");
-					return {
-						content: [{ type: "text", text: output }],
-						details: {
-							scopePath,
-							matchCount: simpleMatchCount,
-							fileCount,
-							files: simpleFileList,
-							fileMatches: simpleFileList.map((path) => ({
-								path,
-								count: simpleFileMatchCounts.get(path) ?? 0,
-							})),
-							mode: effectiveOutputMode,
-							truncated: truncatedByHeadLimit,
-							headLimitReached: truncatedByHeadLimit ? headLimit : undefined,
-						},
+					const details: GrepToolDetails = {
+						scopePath,
+						matchCount: simpleMatchCount,
+						fileCount,
+						files: simpleFileList,
+						fileMatches: simpleFileList.map((path) => ({
+							path,
+							count: simpleFileMatchCounts.get(path) ?? 0,
+						})),
+						mode: effectiveOutputMode,
+						truncated: truncatedByLimit,
+						headLimitReached: limitMeta.headLimit?.reached,
 					};
+					return toolResult(details)
+						.text(output)
+						.limits({
+							resultLimit: limitMeta.resultLimit?.reached,
+							headLimit: limitMeta.headLimit?.reached,
+						})
+						.done();
 				}
 
 				// For files_with_matches, format paths
 				const formatted = processedLines.map((line) => formatPath(line));
 				const output = formatted.join("\n");
-				return {
-					content: [{ type: "text", text: output }],
-					details: {
-						scopePath,
-						matchCount: simpleMatchCount,
-						fileCount,
-						files: simpleFileList,
-						mode: effectiveOutputMode,
-						truncated: truncatedByHeadLimit,
-						headLimitReached: truncatedByHeadLimit ? headLimit : undefined,
-					},
+				const details: GrepToolDetails = {
+					scopePath,
+					matchCount: simpleMatchCount,
+					fileCount,
+					files: simpleFileList,
+					mode: effectiveOutputMode,
+					truncated: truncatedByLimit,
+					headLimitReached: limitMeta.headLimit?.reached,
 				};
+				return toolResult(details)
+					.text(output)
+					.limits({
+						resultLimit: limitMeta.resultLimit?.reached,
+						headLimit: limitMeta.headLimit?.reached,
+					})
+					.done();
 			}
 
 			// Content mode - existing JSON processing
@@ -499,7 +491,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				}
 			} catch (err) {
 				if (err instanceof ptree.Exception && err.aborted) {
-					throw new Error("Operation aborted");
+					throw new ToolAbortError();
 				}
 				// Stream may close early if we killed due to limit - that's ok
 				if (!killedDueToLimit) {
@@ -513,12 +505,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			} catch (err) {
 				if (err instanceof ptree.Exception) {
 					if (err.aborted) {
-						throw new Error("Operation aborted");
+						throw new ToolAbortError();
 					}
 					// Non-zero exit is ok if we killed due to limit or exit code 1 (no matches)
 					if (!killedDueToLimit && err.exitCode !== 1) {
 						const errorMsg = child.peekStderr().trim() || `ripgrep exited with code ${err.exitCode}`;
-						throw new Error(errorMsg);
+						throw new ToolError(errorMsg);
 					}
 				} else {
 					throw err;
@@ -526,34 +518,29 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			}
 
 			if (matchCount === 0) {
-				return {
-					content: [{ type: "text", text: "No matches found" }],
-					details: {
-						scopePath,
-						matchCount: 0,
-						fileCount: 0,
-						files: [],
-						mode: effectiveOutputMode,
-						truncated: false,
-					},
+				const details: GrepToolDetails = {
+					scopePath,
+					matchCount: 0,
+					fileCount: 0,
+					files: [],
+					mode: effectiveOutputMode,
+					truncated: false,
 				};
+				return toolResult(details).text("No matches found").done();
 			}
 
-			// Apply offset and headLimit to output lines
-			let processedLines = outputLines;
-			if (effectiveOffset > 0) {
-				processedLines = processedLines.slice(effectiveOffset);
-			}
-			if (hasHeadLimit) {
-				processedLines = processedLines.slice(0, headLimit);
-			}
+			// Apply offset and head_limit to output lines
+			let processedLines = effectiveOffset > 0 ? outputLines.slice(effectiveOffset) : outputLines;
+			const listLimit = applyListLimit(processedLines, { headLimit: head_limit });
+			processedLines = listLimit.items;
+			const limitMeta = listLimit.meta;
 
 			// Apply byte truncation (no line limit since we already have match limit)
 			const rawOutput = processedLines.join("\n");
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
-			let output = truncation.content;
-			const truncatedByHeadLimit = hasHeadLimit && processedLines.length < outputLines.length;
+			const output = truncation.content;
+			const truncated = Boolean(matchLimitReached || truncation.truncated || limitMeta.headLimit || linesTruncated);
 			const details: GrepToolDetails = {
 				scopePath,
 				matchCount,
@@ -564,38 +551,27 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					count: fileMatchCounts.get(path) ?? 0,
 				})),
 				mode: effectiveOutputMode,
-				truncated: matchLimitReached || truncation.truncated || truncatedByHeadLimit,
-				headLimitReached: truncatedByHeadLimit ? headLimit : undefined,
+				truncated,
+				headLimitReached: limitMeta.headLimit?.reached,
 			};
 
-			// Build notices
-			const notices: string[] = [];
-
-			if (matchLimitReached) {
-				notices.push(
-					`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`,
-				);
-				details.matchLimitReached = effectiveLimit;
-			}
-
+			// Keep TUI compatibility fields
+			if (matchLimitReached) details.matchLimitReached = effectiveLimit;
+			if (truncation.truncated) details.truncation = truncation;
+			if (linesTruncated) details.linesTruncated = true;
+
+			const resultBuilder = toolResult(details)
+				.text(output)
+				.limits({
+					matchLimit: matchLimitReached ? effectiveLimit : undefined,
+					headLimit: limitMeta.headLimit?.reached,
+					columnMax: linesTruncated ? DEFAULT_MAX_COLUMN : undefined,
+				});
 			if (truncation.truncated) {
-				notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-				details.truncation = truncation;
-			}
-
-			if (linesTruncated) {
-				notices.push(`Some lines truncated to ${DEFAULT_MAX_COLUMN} chars. Use read tool to see full lines`);
-				details.linesTruncated = true;
+				resultBuilder.truncation(truncation, { direction: "head" });
 			}
 
-			if (notices.length > 0) {
-				output += `\n\n[${notices.join(". ")}]`;
-			}
-
-			return {
-				content: [{ type: "text", text: output }],
-				details,
-			};
+			return resultBuilder.done();
 		});
 	}
 }
@@ -609,13 +585,13 @@ interface GrepRenderArgs {
 	path?: string;
 	glob?: string;
 	type?: string;
-	ignoreCase?: boolean;
-	caseSensitive?: boolean;
+	ignore_case?: boolean;
+	case_sensitive?: boolean;
 	literal?: boolean;
 	multiline?: boolean;
 	context?: number;
 	limit?: number;
-	outputMode?: string;
+	output_mode?: string;
 }
 
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
@@ -632,10 +608,10 @@ export const grepToolRenderer = {
 		if (args.path) meta.push(`in ${args.path}`);
 		if (args.glob) meta.push(`glob:${args.glob}`);
 		if (args.type) meta.push(`type:${args.type}`);
-		if (args.outputMode && args.outputMode !== "files_with_matches") meta.push(`mode:${args.outputMode}`);
-		if (args.caseSensitive) {
+		if (args.output_mode && args.output_mode !== "files_with_matches") meta.push(`mode:${args.output_mode}`);
+		if (args.case_sensitive) {
 			meta.push("case:sensitive");
-		} else if (args.ignoreCase) {
+		} else if (args.ignore_case) {
 			meta.push("case:insensitive");
 		}
 		if (args.literal) meta.push("literal");
@@ -696,7 +672,16 @@ export const grepToolRenderer = {
 		const matchCount = details?.matchCount ?? 0;
 		const fileCount = details?.fileCount ?? 0;
 		const mode = details?.mode ?? "files_with_matches";
-		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?.matchLimit ||
+				limits?.resultLimit ||
+				limits?.headLimit ||
+				limits?.columnTruncated,
+		);
 		const files = details?.files ?? [];
 
 		if (matchCount === 0) {
@@ -721,17 +706,23 @@ export const grepToolRenderer = {
 		let text = `  ${icon} ${uiTheme.fg("dim", summaryText)}${ui.truncationSuffix(truncated)}${scopeLabel}${expandHint}`;
 
 		const truncationReasons: string[] = [];
-		if (details?.matchLimitReached) {
-			truncationReasons.push(`limit ${details.matchLimitReached} matches`);
+		if (limits?.matchLimit) {
+			truncationReasons.push(`limit ${limits.matchLimit.reached} matches`);
+		}
+		if (limits?.resultLimit) {
+			truncationReasons.push(`limit ${limits.resultLimit.reached} results`);
+		}
+		if (limits?.headLimit) {
+			truncationReasons.push(`head limit ${limits.headLimit.reached}`);
 		}
-		if (details?.headLimitReached) {
-			truncationReasons.push(`head limit ${details.headLimitReached}`);
+		if (truncation) {
+			truncationReasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
 		}
-		if (details?.truncation?.truncated) {
-			truncationReasons.push("size limit");
+		if (limits?.columnTruncated) {
+			truncationReasons.push(`line length ${limits.columnTruncated.maxColumn}`);
 		}
-		if (details?.linesTruncated) {
-			truncationReasons.push("line length");
+		if (truncation?.artifactId) {
+			truncationReasons.push(`full output: artifact://${truncation.artifactId}`);
 		}
 
 		const hasTruncation = truncationReasons.length > 0;