@travisennis/acai 0.0.7 → 0.0.8

package/dist/tools/glob.js

@@ -1,154 +1,112 @@
 import * as fs from "node:fs";
 import * as nodePath from "node:path";
-import { inspect } from "node:util";
 import { z } from "zod";
 import style from "../terminal/style.js";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
 import { glob } from "../utils/glob.js";
+import { convertNullString } from "../utils/zod.js";
+const DEFAULT_MAX_RESULTS = 100;
 export const GlobTool = {
-    name: "globFiles",
+    name: "Glob",
 };
 export const inputSchema = z.object({
     patterns: z
         .union([z.string(), z.array(z.string())])
         .describe("Glob patterns to search for (e.g., '*.ts', '**/*.test.ts', 'src/**/*.js')"),
     path: z.string().describe("Base directory to search in"),
-    gitignore: z.coerce
-        .boolean()
-        .nullable()
+    gitignore: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Respect ignore patterns in .gitignore files. (default: true)"),
-    recursive: z.coerce
-        .boolean()
-        .nullable()
+    recursive: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Search recursively. (default: true)"),
-    expandDirectories: z.coerce
-        .boolean()
-        .nullable()
+    expandDirectories: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Automatically expand directories to files. (default: true)"),
     ignoreFiles: z
         .union([z.string(), z.array(z.string())])
         .nullable()
         .describe("Glob patterns to look for ignore files. (default: undefined)"),
-    cwd: z.coerce
-        .string()
-        .nullable()
+    cwd: z
+        .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
         .describe("Current working directory override. (default: process.cwd())"),
+    maxResults: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Maximum number of files to return. Set to 0 for no limit. (Default: 100)"),
 });
-export const createGlobTool = (options) => {
-    const { tokenCounter } = options;
+export const createGlobTool = () => {
     return {
         toolDef: {
-            description: "Search for files using glob patterns (e.g., `*.ts`, `**/*.test.ts`, `src/**/*.js`). Uses the fast-glob library with support for gitignore, recursive searching, and directory expansion.",
+            description: `Search for files using glob patterns (e.g., *.ts, **/*.test.ts, src/**/*.js). Uses the fast-glob library with support for .gitignore, recursive searching, directory expansion, and automatic result limiting to prevent overwhelming output. Default limit is ${DEFAULT_MAX_RESULTS} files. Use maxResults parameter to override this limit.`,
             inputSchema,
         },
-        async *execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, }, { toolCallId, abortSignal }) {
-            // Check if execution has been aborted
+        display({ patterns, path }) {
+            const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+            const patternStr = patternArray.length === 1
+                ? patternArray[0]
+                : JSON.stringify(patternArray);
+            return `\n> ${style.cyan(patternStr)} in ${style.cyan(path)}`;
+        },
+        async execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }, { abortSignal }) {
             if (abortSignal?.aborted) {
                 throw new Error("Glob search aborted");
             }
-            try {
-                const patternArray = Array.isArray(patterns) ? patterns : [patterns];
-                yield {
-                    name: GlobTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `${style.cyan(inspect(patternArray))} in ${style.cyan(path)}`,
-                };
-                // Build glob options
-                const globOptions = {
-                    cwd: cwd || process.cwd(),
-                };
-                if (gitignore !== null) {
-                    globOptions["gitignore"] = gitignore;
-                }
-                if (recursive !== null) {
-                    globOptions["recursive"] = recursive;
-                }
-                if (expandDirectories !== null) {
-                    globOptions["expandDirectories"] = expandDirectories;
-                }
-                if (ignoreFiles !== null) {
-                    globOptions["ignoreFiles"] = ignoreFiles;
-                }
-                // Execute glob search
-                const matchingFiles = await glob(patternArray, {
-                    ...globOptions,
-                    cwd: path,
-                });
-                // Get file stats and sort by recency then alphabetically
-                const filesWithStats = await Promise.all(matchingFiles.map(async (filePath) => {
-                    const fullPath = nodePath.join(path, filePath);
-                    try {
-                        const stats = await fs.promises.stat(fullPath);
-                        return {
-                            path: filePath,
-                            mtime: stats.mtime,
-                            isRecent: Date.now() - stats.mtime.getTime() < 7 * 24 * 60 * 60 * 1000, // 7 days
-                        };
-                    }
-                    catch {
-                        // If stat fails, treat as old file
-                        return {
-                            path: filePath,
-                            mtime: new Date(0),
-                            isRecent: false,
-                        };
-                    }
-                }));
-                // Sort files: recent files first (newest to oldest), then older files alphabetically
-                const sortedFiles = filesWithStats
-                    .sort((a, b) => {
-                    // Recent files come first
-                    if (a.isRecent && !b.isRecent)
-                        return -1;
-                    if (!a.isRecent && b.isRecent)
-                        return 1;
-                    // Both recent: sort by modification time (newest first)
-                    if (a.isRecent && b.isRecent) {
-                        return b.mtime.getTime() - a.mtime.getTime();
-                    }
-                    // Both old: sort alphabetically by path
-                    return a.path.localeCompare(b.path);
-                })
-                    .map((file) => file.path);
-                // Format results
-                const resultContent = sortedFiles.length > 0
-                    ? sortedFiles.join("\n")
-                    : "No files found matching the specified patterns.";
+            const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+            const globOptions = {
+                cwd: cwd || process.cwd(),
+            };
+            if (gitignore !== null) {
+                globOptions["gitignore"] = gitignore;
+            }
+            if (recursive !== null) {
+                globOptions["recursive"] = recursive;
+            }
+            if (expandDirectories !== null) {
+                globOptions["expandDirectories"] = expandDirectories;
+            }
+            if (ignoreFiles !== null) {
+                globOptions["ignoreFiles"] = ignoreFiles;
+            }
+            const matchingFiles = await glob(patternArray, {
+                ...globOptions,
+                cwd: path,
+            });
+            const filesWithStats = await Promise.all(matchingFiles.map(async (filePath) => {
+                const fullPath = nodePath.join(path, filePath);
                 try {
-                    const result = await manageTokenLimit(resultContent, tokenCounter, "Glob", "Use more specific glob patterns or recursive=false to reduce matches");
-                    const completionMessage = `Found ${style.cyan(sortedFiles.length)} files (${result.tokenCount} tokens)`;
-                    yield {
-                        name: GlobTool.name,
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: completionMessage,
+                    const stats = await fs.promises.stat(fullPath);
+                    return {
+                        path: filePath,
+                        mtime: stats.mtime,
+                        isRecent: Date.now() - stats.mtime.getTime() < 7 * 24 * 60 * 60 * 1000,
                     };
-                    yield result.content;
                 }
-                catch (error) {
-                    if (error instanceof TokenLimitExceededError) {
-                        yield {
-                            name: GlobTool.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: error.message,
-                        };
-                        yield error.message;
-                        return;
-                    }
-                    throw error;
+                catch {
+                    return {
+                        path: filePath,
+                        mtime: new Date(0),
+                        isRecent: false,
+                    };
                 }
-            }
-            catch (error) {
-                yield {
-                    name: GlobTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: error.message,
-                };
-                yield error.message;
-            }
+            }));
+            const sortedFiles = filesWithStats
+                .sort((a, b) => {
+                if (a.isRecent && !b.isRecent)
+                    return -1;
+                if (!a.isRecent && b.isRecent)
+                    return 1;
+                if (a.isRecent && b.isRecent) {
+                    return b.mtime.getTime() - a.mtime.getTime();
+                }
+                return a.path.localeCompare(b.path);
+            })
+                .map((file) => file.path);
+            const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
+            const limitedFiles = effectiveMaxResults && effectiveMaxResults > 0
+                ? sortedFiles.slice(0, effectiveMaxResults)
+                : sortedFiles;
+            return limitedFiles.length > 0
+                ? limitedFiles.join("\n")
+                : "No files found matching the specified patterns.";
         },
     };
 };

package/dist/tools/grep.d.ts

@@ -1,40 +1,37 @@
-import type { ToolCallOptions } from "ai";
 import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
+import type { ToolExecutionOptions } from "./types.ts";
 export declare const GrepTool: {
-    name: "grepFiles";
+    name: "Grep";
 };
 declare const inputSchema: z.ZodObject<{
     pattern: z.ZodString;
     path: z.ZodString;
-    recursive: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-    ignoreCase: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-    filePattern: z.ZodNullable<z.ZodCoercedString<unknown>>;
-    contextLines: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
-    searchIgnored: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-    literal: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-    maxResults: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+    recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+    ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+    filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
+    contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+    literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
 type GrepInputSchema = z.infer<typeof inputSchema>;
-export declare const createGrepTool: (options: {
-    tokenCounter: TokenCounter;
-}) => {
+export declare const createGrepTool: () => {
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
             pattern: z.ZodString;
             path: z.ZodString;
-            recursive: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-            ignoreCase: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-            filePattern: z.ZodNullable<z.ZodCoercedString<unknown>>;
-            contextLines: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
-            searchIgnored: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-            literal: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-            maxResults: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+            recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+            ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+            filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
+            contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+            literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
+            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$strip>;
     };
-    execute({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, maxResults, }: GrepInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }: GrepInputSchema): string;
+    execute({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, maxResults, }: GrepInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 };
 interface GrepOptions {
     recursive?: boolean | null;

package/dist/tools/grep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../source/tools/grep.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;iBA2Cf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAI,SAAS;IAAE,YAAY,EAAE,YAAY,CAAA;CAAE;;;;;;;;;;;;;;;sHAmB7D,eAAe,+BACW,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;CAuJhC,CAAC;AAEF,UAAU,WAAW;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAQD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiI9D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CAmDR;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CA4EjE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAE/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC;IAAE,SAAS,EAAE,WAAW,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CA6BpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAWxD;AAED,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CAGR;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,UAAU,CAqDZ"}
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../source/tools/grep.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;iBAoCf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kFAapB,eAAe;sHAmCb,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CA6DrB,CAAC;AAEF,UAAU,WAAW;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAQD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiI9D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CA+DR;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CA4EjE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAE/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC;IAAE,SAAS,EAAE,WAAW,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CA6BpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAWxD;AAED,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CAGR;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,UAAU,CAwDZ"}

package/dist/tools/grep.js

@@ -1,84 +1,72 @@
 import { execSync } from "node:child_process";
 import { inspect } from "node:util";
 import { z } from "zod";
-import { config } from "../config.js";
 import style from "../terminal/style.js";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
+import { convertNullString } from "../utils/zod.js";
+// default limit
+const DEFAULT_MAX_RESULTS = 100;
 export const GrepTool = {
-    name: "grepFiles",
+    name: "Grep",
 };
 const inputSchema = z.object({
     pattern: z
         .string()
         .describe("The search pattern (regex by default, or fixed-string if literal=true or auto-detected as unbalanced)"),
     path: z.string().describe("The path to search in"),
-    recursive: z.coerce
-        .boolean()
-        .nullable()
+    recursive: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Search recursively. (default: true))"),
-    ignoreCase: z.coerce
-        .boolean()
-        .nullable()
+    ignoreCase: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Use case-sensitive search. (default: false)"),
-    filePattern: z.coerce
-        .string()
-        .nullable()
+    filePattern: z
+        .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
         .describe("Glob pattern to filter files (e.g., '*.ts', '**/*.test.js'). (Default: no filtering)"),
-    contextLines: z.coerce
-        .number()
-        .nullable()
+    contextLines: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
         .describe("The number of context lines needed in search results. (Default: 0)"),
-    searchIgnored: z.coerce
-        .boolean()
-        .nullable()
+    searchIgnored: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Search ignored files. (Default: false)"),
-    literal: z.coerce
-        .boolean()
-        .nullable()
+    literal: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Pass true for fixed-string search (-F), false for regex, (Default: auto-detects unbalanced patterns like mismatched parentheses/brackets.)"),
-    maxResults: z.coerce
-        .number()
-        .nullable()
-        .describe("Maximum number of matches to return. Set to 0 for no limit. (Default: configured value)"),
+    maxResults: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Maximum number of matches to return. Set to 0 for no limit. (Default: 100)"),
 });
-export const createGrepTool = (options) => {
-    const { tokenCounter } = options;
+export const createGrepTool = () => {
     return {
         toolDef: {
-            description: `Search files for patterns using ripgrep (rg). Uses glob patterns for file filtering (e.g., "*.ts", "**/*.test.ts"). Auto-detects unbalanced regex patterns and falls back to fixed-string search for safety. Results are limited to prevent overwhelming output; configure via maxResults parameter.`,
+            description: `Search files for patterns using ripgrep (rg). Uses glob patterns for file filtering (e.g., "*.ts", "**/*.test.ts"). Auto-detects unbalanced regex patterns and falls back to fixed-string search for safety. Results are automatically limited to prevent overwhelming output using a hybrid approach: ripgrep's --max-count flag limits matches per file for efficiency, and post-processing ensures reasonable result counts. Default limit is ${DEFAULT_MAX_RESULTS} matches. Use maxResults parameter to override this limit.`,
             inputSchema,
         },
-        async *execute({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, maxResults, }, { toolCallId, abortSignal }) {
-            // Check if execution has been aborted
+        display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }) {
+            // grok doesn't follow my instructions
+            const safeFilePattern = filePattern === "null" || filePattern === "undefined"
+                ? null
+                : filePattern;
+            // Enhanced tool-init with detailed search parameters
+            let initMessage = `${style.cyan(inspect(pattern))} in ${style.cyan(path)}`;
+            if (safeFilePattern) {
+                initMessage += ` ${style.dim(`(filter: ${safeFilePattern})`)}`;
+            }
+            if (recursive === false) {
+                initMessage += ` ${style.dim("(non-recursive)")}`;
+            }
+            if (ignoreCase) {
+                initMessage += ` ${style.dim("(case-insensitive)")}`;
+            }
+            if (contextLines && contextLines > 0) {
+                initMessage += ` ${style.dim(`(with ${contextLines} context line${contextLines === 1 ? "" : "s"})`)}`;
+            }
+            return initMessage;
+        },
+        async execute({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, maxResults, }, { abortSignal }) {
             if (abortSignal?.aborted) {
                 throw new Error("Grep search aborted");
             }
             try {
-                // grok doesn't follow my instructions
-                const safeFilePattern = filePattern === "null" || filePattern === "undefined"
-                    ? null
-                    : filePattern;
-                // Enhanced tool-init with detailed search parameters
-                let initMessage = `${style.cyan(inspect(pattern))} in ${style.cyan(path)}`;
-                if (safeFilePattern) {
-                    initMessage += ` ${style.dim(`(filter: ${safeFilePattern})`)}`;
-                }
-                if (recursive === false) {
-                    initMessage += ` ${style.dim("(non-recursive)")}`;
-                }
-                if (ignoreCase) {
-                    initMessage += ` ${style.dim("(case-insensitive)")}`;
-                }
-                if (contextLines && contextLines > 0) {
-                    initMessage += ` ${style.dim(`(with ${contextLines} context line${contextLines === 1 ? "" : "s"})`)}`;
-                }
-                yield {
-                    name: GrepTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: initMessage,
-                };
-                // Normalize literal option: if null => auto-detect using heuristic
                 let effectiveLiteral = null;
                 if (literal === true) {
                     effectiveLiteral = true;
@@ -87,7 +75,6 @@ export const createGrepTool = (options) => {
                     effectiveLiteral = false;
                 }
                 else {
-                    // auto-detect
                     try {
                         if (likelyUnbalancedRegex(pattern)) {
                             effectiveLiteral = true;
@@ -100,9 +87,10 @@ export const createGrepTool = (options) => {
                         effectiveLiteral = false;
                     }
                 }
-                const projectConfig = await config.getConfig();
-                const configMaxResults = projectConfig.tools.maxResults;
-                const effectiveMaxResults = maxResults ?? configMaxResults;
+                const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
+                const safeFilePattern = filePattern === "null" || filePattern === "undefined"
+                    ? null
+                    : filePattern;
                 const grepResult = grepFilesStructured(pattern, path, {
                     recursive,
                     ignoreCase,
@@ -112,51 +100,11 @@ export const createGrepTool = (options) => {
                     literal: effectiveLiteral,
                     maxResults: effectiveMaxResults,
                 });
-                try {
-                    const result = await manageTokenLimit(grepResult.rawOutput, tokenCounter, "Grep", "Use maxResults parameter, more specific patterns, or contextLines=0 to reduce output");
-                    const matchCount = grepResult.matchCount;
-                    // Build completion message with preview information
-                    let completionMessage = `Found ${style.cyan(matchCount)} match${matchCount === 1 ? "" : "es"}`;
-                    if (matchCount === 0) {
-                        completionMessage = "Search completed - no matches found";
-                    }
-                    // Calculate unique files with matches
-                    const filesWithMatches = new Set(grepResult.parsedMatches
-                        .filter((match) => match.isMatch && !match.isContext && match.file)
-                        .map((match) => match.file)).size;
-                    if (filesWithMatches > 0) {
-                        completionMessage += ` across ${style.cyan(filesWithMatches)} file${filesWithMatches === 1 ? "" : "s"}`;
-                    }
-                    if (grepResult.contextCount > 0) {
-                        completionMessage += ` with ${style.cyan(grepResult.contextCount)} context line${grepResult.contextCount === 1 ? "" : "s"}`;
-                    }
-                    completionMessage += ` (${result.tokenCount} tokens)`;
-                    yield {
-                        name: GrepTool.name,
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: completionMessage,
-                    };
-                    yield result.content;
-                }
-                catch (error) {
-                    if (error instanceof TokenLimitExceededError) {
-                        yield {
-                            name: GrepTool.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: error.message,
-                        };
-                        yield error.message;
-                        return;
-                    }
-                    throw error;
-                }
+                return grepResult.rawOutput;
             }
             catch (error) {
                 const errorMessage = error.message;
                 let userFriendlyError = `Error searching for "${pattern}" in ${path}: ${errorMessage}`;
-                // Provide more helpful error messages for common cases
                 if (errorMessage.includes("No such file or directory")) {
                     userFriendlyError = `Path not found: "${path}"`;
                     if (filePattern) {
@@ -170,13 +118,7 @@ export const createGrepTool = (options) => {
                 else if (errorMessage.includes("Regex parse error")) {
                     userFriendlyError = `Invalid search pattern "${pattern}" - try using literal=true for fixed-string search`;
                 }
-                yield {
-                    name: GrepTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: userFriendlyError,
-                };
-                yield errorMessage;
+                throw new Error(userFriendlyError);
             }
         },
     };
@@ -347,6 +289,15 @@ export function buildGrepCommand(pattern, path, options = {}) {
     if (effectiveLiteral) {
         command += " -F";
     }
+    // Use ripgrep's --max-count flag to limit matches per file for efficiency
+    // This helps prevent any single file from dominating results
+    if (options.maxResults !== null &&
+        options.maxResults !== undefined &&
+        options.maxResults > 0) {
+        // Use a reasonable per-file limit (max 100 per file) to balance efficiency and completeness
+        const perFileLimit = Math.min(options.maxResults, 100);
+        command += ` --max-count=${perFileLimit}`;
+    }
     command += ` ${JSON.stringify(pattern)}`;
     command += ` ${JSON.stringify(path)}`;
     return command;
@@ -490,7 +441,9 @@ export function grepFilesStructured(pattern, path, options = {}) {
         });
         const parsedMatches = parseRipgrepOutput(rawOutput);
         const matchCount = countActualMatches(parsedMatches);
-        const { truncated, isTruncated } = truncateMatches(parsedMatches, options.maxResults);
+        // Use the maxResults from options (which will be set by the execute function)
+        const maxResults = options.maxResults;
+        const { truncated, isTruncated } = truncateMatches(parsedMatches, maxResults);
         const displayedCount = countActualMatches(truncated);
         const displayedContextCount = countContextLines(truncated);
         return {