@travisennis/acai 0.0.5 → 0.0.6

package/dist/tools/edit-file.js

@@ -1,122 +1,71 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { tool } from "ai";
 import { createTwoFilesPatch } from "diff";
 import { z } from "zod";
+import { logger } from "../logger.js";
 import style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { fixLlmEditWithInstruction } from "./llm-edit-fixer.js";
 export const EditFileTool = {
     name: "editFile",
 };
-export const createEditFileTool = async ({ workingDir, terminal, sendData, toolExecutor, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    path: z.string().describe("The path of the file to edit."),
+    edits: z.array(z.object({
+        oldText: z
+            .string()
+            .describe("Text to search for - must match exactly and enough context must be provided to uniquely match the target text. " +
+            "Special characters require JSON escaping: backticks (\\`...\\`), quotes, backslashes. " +
+            "For multi-line content, include exact newlines and indentation."),
+        newText: z.string().describe("Text to replace with"),
+    })),
+});
+export const createEditFileTool = async ({ workingDir, allowedDirs, modelManager, tokenTracker, enableLlmFix = true, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [EditFileTool.name]: tool({
+        toolDef: {
             description: "Make line-based edits to a text file. Each edit replaces exact line sequences " +
                 "with new content. Exact literal matching is used: no whitespace, indentation, escape, or newline normalization is applied when locating matches. " +
                 "Provide enough context so the match is unique; otherwise the operation errors. Returns a git-style diff showing the changes made. " +
                 "Only works within allowed directories. " +
                 "Note: Special characters in oldText must be properly escaped for JSON (e.g., backticks as \\`...\\`). " +
                 "Multi-line strings require exact character-by-character matching including whitespace.",
-            inputSchema: z.object({
-                path: z.string().describe("The path of the file to edit."),
-                edits: z.array(z.object({
-                    oldText: z
-                        .string()
-                        .describe("Text to search for - must match exactly and enough context must be provided to uniquely match the target text. " +
-                        "Special characters require JSON escaping: backticks (\\`...\\`), quotes, backslashes. " +
-                        "For multi-line content, include exact newlines and indentation."),
-                    newText: z.string().describe("Text to replace with"),
-                })),
-            }),
-            execute: async ({ path, edits }, { toolCallId, abortSignal }) => {
-                // Check if execution has been aborted
+            inputSchema,
+        },
+        async *execute({ path, edits }, { toolCallId, abortSignal }) {
+            try {
                 if (abortSignal?.aborted) {
                     throw new Error("File editing aborted");
                 }
-                sendData?.({
+                yield {
+                    name: EditFileTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Editing file: ${style.cyan(path)}`,
+                    data: `${style.cyan(path)}`,
+                };
+                const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
+                const result = await applyFileEdits(validPath, edits, false, abortSignal, {
+                    modelManager,
+                    tokenTracker,
+                    enableLlmFix,
                 });
-                try {
-                    const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
-                    if (terminal) {
-                        terminal.writeln(`\n${style.blue.bold("●")} Proposing file changes: ${style.cyan(path)}`);
-                        terminal.lineBreak();
-                        const result = await applyFileEdits(validPath, edits, true, abortSignal);
-                        terminal.writeln(`The agent is proposing the following ${style.cyan(edits.length)} edits:`);
-                        terminal.hr();
-                        terminal.display(result);
-                        terminal.hr();
-                        let userResponse;
-                        if (toolExecutor) {
-                            const ctx = {
-                                toolName: EditFileTool.name,
-                                toolCallId,
-                                message: "What would you like to do with these changes?",
-                                choices: {
-                                    accept: "Accept these changes",
-                                    acceptAll: "Accept all future edits (including these)",
-                                    reject: "Reject these changes",
-                                },
-                            };
-                            try {
-                                userResponse = await toolExecutor.ask(ctx, { abortSignal });
-                            }
-                            catch (e) {
-                                if (e.name === "AbortError") {
-                                    throw new Error("File editing aborted during user input");
-                                }
-                                throw e;
-                            }
-                        }
-                        const { result: userChoice, reason } = userResponse ?? {
-                            result: "accept",
-                        };
-                        terminal.lineBreak();
-                        if (userChoice === "accept-all") {
-                            terminal.writeln(style.yellow("✓ Auto-accept mode enabled for all edits"));
-                            terminal.lineBreak();
-                        }
-                        if (userChoice === "accept" || userChoice === "accept-all") {
-                            const finalEdits = await applyFileEdits(validPath, edits, false, abortSignal);
-                            // Send completion message indicating success
-                            sendData?.({
-                                id: toolCallId,
-                                event: "tool-completion",
-                                data: "Edits accepted and applied successfully.",
-                            });
-                            return finalEdits;
-                        }
-                        terminal.lineBreak();
-                        // Send completion message indicating rejection
-                        const rejectionReason = reason || "No reason provided";
-                        sendData?.({
-                            id: toolCallId,
-                            event: "tool-completion",
-                            data: `Edits rejected by user. Reason: ${rejectionReason}`,
-                        });
-                        return `The user rejected these changes. Reason: ${rejectionReason}`;
-                    }
-                    const finalEdits = await applyFileEdits(validPath, edits, false, abortSignal);
-                    // Send completion message indicating success
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: "Edits accepted and applied successfully.",
-                    });
-                    return finalEdits;
-                }
-                catch (error) {
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: `Failed to edit file: ${error.message}`,
-                    });
-                    return `Failed to edit file: ${error.message}`;
-                }
-            },
-        }),
+                yield {
+                    name: EditFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: `Applied ${edits.length} edits`,
+                };
+                yield result;
+            }
+            catch (error) {
+                yield {
+                    name: EditFileTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield `Failed to edit file: ${error.message}`;
+            }
+        },
     };
 };
 // file editing and diffing utilities
@@ -129,7 +78,7 @@ function createUnifiedDiff(originalContent, newContent, filepath = "file") {
     const normalizedNew = normalizeLineEndings(newContent);
     return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
 }
-export async function applyFileEdits(filePath, edits, dryRun = false, abortSignal) {
+export async function applyFileEdits(filePath, edits, dryRun = false, abortSignal, options) {
     if (abortSignal?.aborted) {
         throw new Error("File edit operation aborted");
     }
@@ -141,26 +90,19 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
     if (edits.find((edit) => edit.oldText.length === 0)) {
         throw new Error("Invalid oldText in edit. The value of oldText must be at least one character");
     }
-    // Apply edits sequentially using strict literal, unique matches
+    // Apply edits sequentially using literal matches (allow multiple matches)
     let modifiedContent = originalContent;
     for (const edit of edits) {
         if (abortSignal?.aborted) {
             throw new Error("File edit operation aborted during processing");
         }
-        const { oldText, newText } = edit; // Use literal oldText and newText
-        // Strict literal match: find exactly one occurrence without any normalization
-        const firstIndex = modifiedContent.indexOf(oldText);
-        if (firstIndex === -1) {
-            throw new Error("oldText not found in content");
+        const result = await applyEditWithLlmFix(edit, modifiedContent, abortSignal, options);
+        if (result.success) {
+            modifiedContent = result.content;
         }
-        const secondIndex = modifiedContent.indexOf(oldText, firstIndex + oldText.length);
-        if (secondIndex !== -1) {
-            throw new Error("oldText found multiple times and requires more code context to uniquely identify the intended match");
+        else {
+            throw new Error("oldText not found in content");
         }
-        modifiedContent =
-            modifiedContent.slice(0, firstIndex) +
-                newText +
-                modifiedContent.slice(firstIndex + oldText.length);
     }
     // Create unified diff (createUnifiedDiff normalizes line endings internally for diffing)
     const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
@@ -182,3 +124,61 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
     }
     return formattedDiff;
 }
+/**
+ * Applies a single edit with LLM fix fallback
+ */
+async function applyEditWithLlmFix(edit, content, abortSignal, options) {
+    const { oldText, newText } = edit;
+    // Try the original edit first
+    const originalResult = applyLiteralEdit(content, oldText, newText);
+    if (originalResult.matchCount > 0) {
+        return { success: true, content: originalResult.content };
+    }
+    // If LLM fix is enabled and dependencies are available, try to fix the edit
+    if (options?.enableLlmFix !== false &&
+        options?.modelManager &&
+        options?.tokenTracker) {
+        try {
+            const fixedEdit = await fixLlmEditWithInstruction(options.instruction, oldText, newText, "oldText not found in content", content, options.modelManager ?? undefined, abortSignal);
+            if (fixedEdit && !fixedEdit.noChangesRequired) {
+                // Retry the edit with the corrected search string
+                const correctedResult = applyLiteralEdit(content, fixedEdit.search, fixedEdit.replace);
+                if (correctedResult.matchCount > 0) {
+                    return { success: true, content: correctedResult.content };
+                }
+            }
+            else if (fixedEdit?.noChangesRequired) {
+                // No changes required, skip this edit
+                return { success: true, content };
+            }
+        }
+        catch (llmError) {
+            // If LLM fix fails, fall back to original error
+            logger.warn(llmError, "LLM edit fix failed:");
+        }
+    }
+    return { success: false, content };
+}
+/**
+ * Applies a literal search and replace operation
+ */
+function applyLiteralEdit(content, search, replace) {
+    let modifiedContent = content;
+    let matchCount = 0;
+    let currentIndex = 0;
+    while (currentIndex < modifiedContent.length) {
+        const matchIndex = modifiedContent.indexOf(search, currentIndex);
+        if (matchIndex === -1) {
+            break;
+        }
+        matchCount++;
+        // Apply the replacement
+        modifiedContent =
+            modifiedContent.slice(0, matchIndex) +
+                replace +
+                modifiedContent.slice(matchIndex + search.length);
+        // Move current index past the replacement
+        currentIndex = matchIndex + replace.length;
+    }
+    return { matchCount, content: modifiedContent };
+}

package/dist/tools/filesystem-utils.d.ts

@@ -1,6 +1,7 @@
 export declare function joinWorkingDir(userPath: string, workingDir: string): string;
 export declare function isPathWithinBaseDir(requestedPath: string, baseDir: string): boolean;
-export declare function validatePath(requestedPath: string, allowedDirectory: string, options?: {
+export declare function isPathWithinAllowedDirs(requestedPath: string, allowedDirs: string[]): boolean;
+export declare function validatePath(requestedPath: string, allowedDirectory: string | string[], options?: {
     requireExistence?: boolean;
     abortSignal?: AbortSignal;
 }): Promise<string>;

package/dist/tools/filesystem-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesystem-utils.d.ts","sourceRoot":"","sources":["../../source/tools/filesystem-utils.ts"],"names":[],"mappings":"AAWA,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK3E;AAUD,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GACd,OAAO,CAsBT;AAGD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,GACtE,OAAO,CAAC,MAAM,CAAC,CA0GjB"}
+{"version":3,"file":"filesystem-utils.d.ts","sourceRoot":"","sources":["../../source/tools/filesystem-utils.ts"],"names":[],"mappings":"AAWA,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK3E;AAUD,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GACd,OAAO,CAsBT;AAGD,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAIT;AAGD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,EACnC,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,GACtE,OAAO,CAAC,MAAM,CAAC,CAwHjB"}

package/dist/tools/filesystem-utils.js

@@ -42,6 +42,10 @@ export function isPathWithinBaseDir(requestedPath, baseDir) {
     const rel = path.relative(baseReal, target);
     return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
 }
+// Check if path is within any of the allowed directories
+export function isPathWithinAllowedDirs(requestedPath, allowedDirs) {
+    return allowedDirs.some((allowedDir) => isPathWithinBaseDir(requestedPath, allowedDir));
+}
 // Security utilities
 export async function validatePath(requestedPath, allowedDirectory, options = {}) {
     const { requireExistence = true, abortSignal } = options;
@@ -53,27 +57,37 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
         ? path.resolve(expandedPath)
         : path.resolve(process.cwd(), expandedPath);
     const normalizedRequested = normalizePath(absolute);
-    let normalizedAllowed = normalizePath(path.resolve(allowedDirectory));
-    // Try to resolve real path for allowedDirectory when it exists to handle symlinked roots
-    try {
-        const stats = await fs.stat(normalizedAllowed);
-        if (stats.isDirectory()) {
-            const allowedReal = await fs.realpath(normalizedAllowed);
-            normalizedAllowed = normalizePath(allowedReal);
+    // Handle both single directory and array of directories
+    const allowedDirectories = Array.isArray(allowedDirectory)
+        ? allowedDirectory
+        : [allowedDirectory];
+    // Resolve and normalize all allowed directories
+    const normalizedAllowedDirs = await Promise.all(allowedDirectories.map(async (dir) => {
+        let normalizedDir = normalizePath(path.resolve(dir));
+        // Try to resolve real path for allowedDirectory when it exists to handle symlinked roots
+        try {
+            const stats = await fs.stat(normalizedDir);
+            if (stats.isDirectory()) {
+                const allowedReal = await fs.realpath(normalizedDir);
+                normalizedDir = normalizePath(allowedReal);
+            }
         }
-    }
-    catch (_err) {
-        // If allowedDirectory doesn't exist, keep normalizedAllowed as-is
-    }
-    // Helper to check if a path is within the allowed directory using path.relative
+        catch (_err) {
+            // If allowedDirectory doesn't exist, keep normalizedDir as-is
+        }
+        return normalizedDir;
+    }));
+    // Helper to check if a path is within any allowed directory using path.relative
     const isWithinAllowed = (targetPath) => {
-        const rel = path.relative(normalizedAllowed, targetPath);
-        // Allow the allowed directory itself (rel === "") and any descendant paths
-        return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+        return normalizedAllowedDirs.some((normalizedAllowed) => {
+            const rel = path.relative(normalizedAllowed, targetPath);
+            // Allow the allowed directory itself (rel === "") and any descendant paths
+            return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+        });
     };
-    // Check intended path is within allowed directory
+    // Check intended path is within any allowed directory
     if (!isWithinAllowed(normalizedRequested)) {
-        throw new Error(`Access denied - path outside allowed directories: ${absolute} not in ${allowedDirectory}`);
+        throw new Error(`Access denied - path outside allowed directories: ${absolute} not in any of ${allowedDirectories.join(", ")}`);
     }
     let validatedPath;
     // Try to resolve real path for existing targets to handle symlinks safely

package/dist/tools/glob.d.ts

@@ -0,0 +1,36 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { ToolResult } from "./types.ts";
+export declare const GlobTool: {
+    name: "globFiles";
+};
+export declare const inputSchema: z.ZodObject<{
+    patterns: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    path: z.ZodString;
+    gitignore: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+    recursive: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+    expandDirectories: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+    ignoreFiles: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    cwd: z.ZodNullable<z.ZodCoercedString<unknown>>;
+}, z.core.$strip>;
+type GlobInputSchema = z.infer<typeof inputSchema>;
+export declare const createGlobTool: (options: {
+    tokenCounter: TokenCounter;
+}) => {
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            patterns: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+            path: z.ZodString;
+            gitignore: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+            recursive: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+            expandDirectories: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+            ignoreFiles: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            cwd: z.ZodNullable<z.ZodCoercedString<unknown>>;
+        }, z.core.$strip>;
+    };
+    execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, }: GlobInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+};
+export {};
+//# sourceMappingURL=glob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;iBA2BtB,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;;;;;;;;;;;;;4FAkB7D,eAAe,+BACW,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;CA2HhC,CAAC"}

package/dist/tools/glob.js

@@ -0,0 +1,143 @@
+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 } from "../tokens/threshold.js";
+import { glob } from "../utils/glob.js";
+export const GlobTool = {
+    name: "globFiles",
+};
+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()
+        .describe("Respect ignore patterns in .gitignore files. (default: true)"),
+    recursive: z.coerce
+        .boolean()
+        .nullable()
+        .describe("Search recursively. (default: true)"),
+    expandDirectories: 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()
+        .describe("Current working directory override. (default: process.cwd())"),
+});
+export const createGlobTool = (options) => {
+    const { tokenCounter } = options;
+    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.",
+            inputSchema,
+        },
+        async *execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, }, { toolCallId, abortSignal }) {
+            // Check if execution has been aborted
+            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 result = await manageTokenLimit(resultContent, tokenCounter, "Glob", "Use more specific glob patterns or recursive=false to reduce matches");
+                let completionMessage = `Found ${style.cyan(sortedFiles.length)} files.`;
+                if (result.truncated) {
+                    completionMessage += ` ${result.content}`;
+                }
+                completionMessage += ` (${result.tokenCount} tokens)`;
+                yield {
+                    name: GlobTool.name,
+                    event: "tool-completion",
+                    id: toolCallId,
+                    data: completionMessage,
+                };
+                yield result.content;
+            }
+            catch (error) {
+                yield {
+                    name: GlobTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield error.message;
+            }
+        },
+    };
+};

package/dist/tools/grep.d.ts

@@ -1,22 +1,40 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
 import type { TokenCounter } from "../tokens/counter.ts";
-import type { SendData } from "./types.ts";
+import type { ToolResult } from "./types.ts";
 export declare const GrepTool: {
     name: "grepFiles";
 };
+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>>;
+}, z.core.$strip>;
+type GrepInputSchema = z.infer<typeof inputSchema>;
 export declare const createGrepTool: (options: {
-    sendData?: SendData | undefined;
     tokenCounter: TokenCounter;
 }) => {
-    grepFiles: import("ai").Tool<{
-        pattern: string;
-        path: string;
-        recursive: boolean | null;
-        ignoreCase: boolean | null;
-        filePattern: string | null;
-        contextLines: number | null;
-        searchIgnored: boolean | null;
-        literal: boolean | null;
-    }, string>;
+    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>>;
+        }, z.core.$strip>;
+    };
+    execute({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, maxResults, }: GrepInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 };
 interface GrepOptions {
     recursive?: boolean | null;
@@ -25,7 +43,9 @@ interface GrepOptions {
     contextLines?: number | null;
     searchIgnored?: boolean | null;
     literal?: boolean | null;
+    maxResults?: number | null;
 }
+export declare function likelyUnbalancedRegex(pattern: string): boolean;
 /**
  * Search files for patterns using ripgrep
  *
@@ -35,5 +55,46 @@ interface GrepOptions {
  * @returns The result of the grep command
  */
 export declare function buildGrepCommand(pattern: string, path: string, options?: GrepOptions): string;
+export interface ParsedMatch {
+    file?: string;
+    line: number;
+    content: string;
+    isMatch: boolean;
+    isContext?: boolean;
+}
+interface GrepResult {
+    rawOutput: string;
+    parsedMatches: ParsedMatch[];
+    matchCount: number;
+    displayedCount?: number;
+    contextCount: number;
+    hasMatches: boolean;
+    isTruncated?: boolean;
+}
+/**
+ * Parse ripgrep output and extract structured match information
+ */
+export declare function parseRipgrepOutput(content: string): ParsedMatch[];
+/**
+ * Count actual matches (excluding context lines)
+ */
+export declare function countActualMatches(parsed: ParsedMatch[]): number;
+/**
+ * Count context lines
+ */
+export declare function countContextLines(parsed: ParsedMatch[]): number;
+/**
+ * Truncate matches to a maximum number of results
+ */
+export declare function truncateMatches(matches: ParsedMatch[], maxResults: number | null | undefined): {
+    truncated: ParsedMatch[];
+    isTruncated: boolean;
+};
+/**
+ * Extract matches from content (backwards compatibility wrapper)
+ */
+export declare function extractMatches(content: string): string[];
+export declare function grepFiles(pattern: string, path: string, options?: GrepOptions): string;
+export declare function grepFilesStructured(pattern: string, path: string, options?: GrepOptions): GrepResult;
 export {};
 //# sourceMappingURL=grep.d.ts.map