@travisennis/acai 0.0.3 → 0.0.5

package/dist/tools/file-editing-utils.js

@@ -0,0 +1,135 @@
+const LineTrimmedReplacer = function* (content, find) {
+    const originalLines = content.split("\n");
+    const searchLines = find.split("\n");
+    if (searchLines[searchLines.length - 1] === "") {
+        searchLines.pop();
+    }
+    for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+        let matches = true;
+        for (let j = 0; j < searchLines.length; j++) {
+            const originalTrimmed = originalLines[i + j].trim();
+            const searchTrimmed = searchLines[j].trim();
+            if (originalTrimmed !== searchTrimmed) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            let matchStartIndex = 0;
+            for (let k = 0; k < i; k++) {
+                matchStartIndex += originalLines[k].length + 1;
+            }
+            let matchEndIndex = matchStartIndex;
+            for (let k = 0; k < searchLines.length; k++) {
+                matchEndIndex += originalLines[i + k].length;
+                if (k < searchLines.length - 1) {
+                    matchEndIndex += 1; // Add newline character except for the last line
+                }
+            }
+            yield content.substring(matchStartIndex, matchEndIndex);
+        }
+    }
+};
+const WhitespaceNormalizedReplacer = function* (content, find) {
+    const normalizeWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+    const normalizedFind = normalizeWhitespace(find);
+    // Handle single line matches
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (typeof line === "undefined") {
+            continue;
+        }
+        if (normalizeWhitespace(line) === normalizedFind) {
+            yield line;
+        }
+        else {
+            // Only check for substring matches if the full line doesn't match
+            const normalizedLine = normalizeWhitespace(line);
+            if (normalizedLine.includes(normalizedFind)) {
+                // Find the actual substring in the original line that matches
+                const words = find.trim().split(/\s+/);
+                if (words.length > 0) {
+                    const pattern = words
+                        .map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+                        .join("\\s+");
+                    try {
+                        const regex = new RegExp(pattern);
+                        const match = line.match(regex);
+                        if (match) {
+                            yield match[0];
+                        }
+                    }
+                    catch (_e) {
+                        // Invalid regex pattern, skip
+                    }
+                }
+            }
+        }
+    }
+    // Handle multi-line matches
+    const findLines = find.split("\n");
+    if (findLines.length > 1) {
+        for (let i = 0; i <= lines.length - findLines.length; i++) {
+            const block = lines.slice(i, i + findLines.length);
+            if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
+                yield block.join("\n");
+            }
+        }
+    }
+};
+const IndentationFlexibleReplacer = function* (content, find) {
+    const removeIndentation = (text) => {
+        const lines = text.split("\n");
+        const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+        if (nonEmptyLines.length === 0)
+            return text;
+        const minIndent = Math.min(...nonEmptyLines.map((line) => {
+            const match = line.match(/^(\s*)/);
+            return match ? match[1].length : 0;
+        }));
+        return lines
+            .map((line) => (line.trim().length === 0 ? line : line.slice(minIndent)))
+            .join("\n");
+    };
+    const normalizedFind = removeIndentation(find);
+    const contentLines = content.split("\n");
+    const findLines = find.split("\n");
+    for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+        const block = contentLines.slice(i, i + findLines.length).join("\n");
+        if (removeIndentation(block) === normalizedFind) {
+            yield block;
+        }
+    }
+};
+export function replace(content, oldString, newString, replaceAll = false) {
+    if (oldString === newString) {
+        throw new Error("oldString and newString must be different");
+    }
+    let notFound = true;
+    for (const replacer of [
+        LineTrimmedReplacer,
+        WhitespaceNormalizedReplacer,
+        IndentationFlexibleReplacer,
+    ]) {
+        for (const search of replacer(content, oldString)) {
+            const index = content.indexOf(search);
+            if (index === -1)
+                continue;
+            notFound = false;
+            if (replaceAll) {
+                return content.replaceAll(search, newString);
+            }
+            const lastIndex = content.lastIndexOf(search);
+            if (index !== lastIndex)
+                continue;
+            return (content.substring(0, index) +
+                newString +
+                content.substring(index + search.length));
+        }
+    }
+    if (notFound) {
+        throw new Error("oldString not found in content");
+    }
+    throw new Error("oldString found multiple times and requires more code context to uniquely identify the intended match");
+}

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

@@ -1,22 +1,7 @@
-import type { TokenCounter } from "../token-utils.ts";
-export declare function normalizePath(p: string): string;
 export declare function joinWorkingDir(userPath: string, workingDir: string): string;
-export declare function expandHome(filepath: string): string;
-export declare function validatePath(requestedPath: string, allowedDirectory: string): Promise<string>;
-export interface FileEdit {
-    oldText: string;
-    newText: string;
-}
-export declare function applyFileEdits(filePath: string, edits: FileEdit[], dryRun?: boolean): Promise<string>;
-/**
- * Generates a string representation of a directory tree starting from the given path.
- * @param dirPath - The path of the directory to generate the tree for.
- * @returns A Promise that resolves to a string representation of the directory tree.
- */
-export declare function directoryTree(dirPath: string): Promise<string>;
-export declare function readFileAndCountTokens(filePath: string, workingDir: string, allowedDirectory: string, tokenCounter: TokenCounter, maxTokens: number): Promise<{
-    path: string;
-    content: string | null;
-    tokenCount: number;
-    error: string | null;
-}>;
+export declare function isPathWithinBaseDir(requestedPath: string, baseDir: string): boolean;
+export declare function validatePath(requestedPath: string, allowedDirectory: string, options?: {
+    requireExistence?: boolean;
+    abortSignal?: AbortSignal;
+}): Promise<string>;
+//# sourceMappingURL=filesystem-utils.d.ts.map

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

@@ -0,0 +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"}

package/dist/tools/filesystem-utils.js

@@ -1,10 +1,9 @@
+import { realpathSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { createTwoFilesPatch } from "diff";
-import ignore from "ignore";
 // Normalize all paths consistently
-export function normalizePath(p) {
+function normalizePath(p) {
     return path.normalize(p);
 }
 // Handle path joining with working directory
@@ -14,178 +13,127 @@ export function joinWorkingDir(userPath, workingDir) {
     }
     return path.normalize(path.join(workingDir, userPath));
 }
-export function expandHome(filepath) {
+function expandHome(filepath) {
     if (filepath.startsWith("~/") || filepath === "~") {
         return path.join(os.homedir(), filepath.slice(1));
     }
     return filepath;
 }
+// Ensure path is within base directory (handles '.', relative paths, and symlinks)
+export function isPathWithinBaseDir(requestedPath, baseDir) {
+    const baseAbs = path.resolve(baseDir);
+    let baseReal = baseAbs;
+    try {
+        baseReal = realpathSync(baseAbs);
+    }
+    catch {
+        // If baseDir doesn't exist, fall back to resolved path
+    }
+    const abs = path.isAbsolute(requestedPath)
+        ? path.resolve(requestedPath)
+        : path.resolve(baseReal, requestedPath);
+    let target = abs;
+    try {
+        target = realpathSync(abs);
+    }
+    catch {
+        // If target doesn't fully exist, validate against intended path
+    }
+    const rel = path.relative(baseReal, target);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
 // Security utilities
-export async function validatePath(requestedPath, allowedDirectory) {
+export async function validatePath(requestedPath, allowedDirectory, options = {}) {
+    const { requireExistence = true, abortSignal } = options;
+    if (abortSignal?.aborted) {
+        throw new Error("Path validation aborted");
+    }
     const expandedPath = expandHome(requestedPath);
     const absolute = path.isAbsolute(expandedPath)
         ? path.resolve(expandedPath)
         : path.resolve(process.cwd(), expandedPath);
     const normalizedRequested = normalizePath(absolute);
-    // Check if path is within allowed directories
-    const isAllowed = normalizedRequested.startsWith(allowedDirectory);
-    if (!isAllowed) {
+    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);
+        }
+    }
+    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
+    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));
+    };
+    // Check intended path is within allowed directory
+    if (!isWithinAllowed(normalizedRequested)) {
         throw new Error(`Access denied - path outside allowed directories: ${absolute} not in ${allowedDirectory}`);
     }
-    // Handle symlinks by checking their real path
+    let validatedPath;
+    // Try to resolve real path for existing targets to handle symlinks safely
     try {
         const realPath = await fs.realpath(absolute);
         const normalizedReal = normalizePath(realPath);
-        const isRealPathAllowed = normalizedReal.startsWith(allowedDirectory);
-        if (!isRealPathAllowed) {
+        if (!isWithinAllowed(normalizedReal)) {
             throw new Error("Access denied - symlink target outside allowed directories");
         }
-        return realPath;
+        validatedPath = realPath;
     }
     catch (_error) {
-        // For new files that don't exist yet, verify parent directory
-        const parentDir = path.dirname(absolute);
-        try {
-            const realParentPath = await fs.realpath(parentDir);
-            const normalizedParent = normalizePath(realParentPath);
-            const isParentAllowed = normalizedParent.startsWith(allowedDirectory);
-            if (!isParentAllowed) {
-                throw new Error("Access denied - parent directory outside allowed directories");
+        // For new files or paths where some directories don't exist yet:
+        // Walk up to the nearest existing ancestor directory and validate it.
+        let current = path.dirname(absolute);
+        let foundValidAncestor = false;
+        while (true) {
+            try {
+                const stat = await fs.stat(current);
+                if (!stat.isDirectory()) {
+                    throw new Error(`Nearest existing ancestor is not a directory: ${current}`);
+                }
+                const realAncestor = await fs.realpath(current);
+                const normalizedAncestor = normalizePath(realAncestor);
+                if (!isWithinAllowed(normalizedAncestor)) {
+                    throw new Error("Access denied - ancestor directory resolves outside allowed directories");
+                }
+                // Ancestor is within allowed; allow creation below it.
+                foundValidAncestor = true;
+                break;
+            }
+            catch (_err) {
+                // If we reached the filesystem root, break to fallback check
+                const parent = path.dirname(current);
+                if (parent === current) {
+                    break;
+                }
+                current = parent;
             }
-            return absolute;
-        }
-        catch {
-            throw new Error(`Parent directory does not exist: ${parentDir}`);
-        }
-    }
-}
-// file editing and diffing utilities
-function normalizeLineEndings(text) {
-    return text.replace(/\r\n/g, "\n");
-}
-function createUnifiedDiff(originalContent, newContent, filepath = "file") {
-    // Ensure consistent line endings for diff
-    const normalizedOriginal = normalizeLineEndings(originalContent);
-    const normalizedNew = normalizeLineEndings(newContent);
-    return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
-}
-export async function applyFileEdits(filePath, edits, dryRun = false) {
-    // Read file content literally
-    const originalContent = await fs.readFile(filePath, "utf-8");
-    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
-    let modifiedContent = originalContent;
-    for (const edit of edits) {
-        const { oldText, newText } = edit; // Use literal oldText and newText
-        const normalizedContent = normalizeLineEndings(modifiedContent);
-        const normalizedOldText = normalizeLineEndings(oldText);
-        if (normalizedContent.includes(normalizedOldText)) {
-            modifiedContent = normalizedContent.replace(normalizedOldText, newText);
         }
-        else {
-            // If literal match is not found, throw an error.
-            // The previous complex fallback logic is removed to ensure literal matching.
-            throw new Error(`Could not find literal match for edit:\n${edit.oldText}`);
+        if (!foundValidAncestor) {
+            // Rely on intended path check
         }
+        validatedPath = absolute;
     }
-    // Create unified diff (createUnifiedDiff normalizes line endings internally for diffing)
-    const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
-    // Format diff with appropriate number of backticks
-    let numBackticks = 3;
-    while (diff.includes("`".repeat(numBackticks))) {
-        numBackticks++;
-    }
-    const formattedDiff = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
-    if (!dryRun) {
-        // Write the modified content (which has literal newlines from newText, and preserves original newlines not part of oldText/newText)
-        await fs.writeFile(filePath, modifiedContent, "utf-8");
-    }
-    return formattedDiff;
-}
-/**
- * Generates the indentation string for a given level in the directory tree.
- * @param level - The current level in the directory tree.
- * @param isLast - Indicates if the current item is the last in its parent directory.
- * @returns The indentation string for the current level.
- */
-function getIndent(level, isLast) {
-    const indent = "│   ".repeat(level - 1);
-    return level === 0 ? "" : `${indent}${isLast ? "└── " : "├── "}`;
-}
-/**
- * Recursively generates a string representation of a directory tree.
- * @param dirPath - The path of the directory to generate the tree for.
- * @param level - The current level in the directory tree (default: 1).
- * @returns A Promise that resolves to a string representation of the directory tree.
- * @throws Will log an error if there's an issue reading the directory.
- */
-async function generateDirectoryTree(dirPath, ig, level = 1) {
-    const name = path.basename(dirPath);
-    let output = `${getIndent(level, false)}${name}\n`;
-    const items = await fs.readdir(dirPath);
-    const filteredItems = ig.filter(items);
-    for (let i = 0; i < filteredItems.length; i++) {
-        const item = filteredItems[i] ?? "";
-        const itemPath = path.join(dirPath, item);
-        const isLast = i === items.length - 1;
-        const stats = await fs.stat(itemPath);
-        if (stats.isDirectory()) {
-            output += await generateDirectoryTree(itemPath, ig, level + 1);
+    // Now, if requireExistence, check if the path exists
+    if (requireExistence) {
+        if (abortSignal?.aborted) {
+            throw new Error("Path validation aborted during existence check");
         }
-        else {
-            output += `${getIndent(level + 1, isLast)}${item}\n`;
-        }
-    }
-    return output;
-}
-/**
- * Generates a string representation of a directory tree starting from the given path.
- * @param dirPath - The path of the directory to generate the tree for.
- * @returns A Promise that resolves to a string representation of the directory tree.
- */
-export async function directoryTree(dirPath) {
-    let ig;
-    try {
-        const ignoreFile = await fs.readFile(path.join(process.cwd(), ".gitignore"));
-        ig = ignore().add(ignoreFile.toString()).add(".git");
-    }
-    catch (_error) {
-        // If .gitignore doesn't exist, create basic ignore with just .git
-        ig = ignore().add(".git");
-    }
-    return (await generateDirectoryTree(dirPath, ig)).trim();
-}
-export async function readFileAndCountTokens(filePath, workingDir, allowedDirectory, tokenCounter, maxTokens) {
-    try {
-        const validPath = await validatePath(joinWorkingDir(filePath, workingDir), allowedDirectory);
-        const content = await fs.readFile(validPath, "utf-8");
-        let tokenCount = 0;
         try {
-            tokenCount = tokenCounter.count(content);
+            await fs.stat(validatedPath);
         }
-        catch (tokenError) {
-            console.error("Error calculating token count:", tokenError);
-            // Handle token calculation error if needed
+        catch (err) {
+            const error = err;
+            if (error.code === "ENOENT") {
+                throw new Error(`The specified path does not exist: ${requestedPath} (${validatedPath})`);
+            }
+            throw error;
         }
-        const maxTokenMessage = `File content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Use readFile with startLine/lineCount or grepFiles for targeted access.`;
-        const finalContent = tokenCount > maxTokens ? maxTokenMessage : content;
-        const actualTokenCount = tokenCount > maxTokens ? 0 : tokenCount; // Don't count tokens for skipped files
-        return {
-            path: filePath,
-            content: finalContent,
-            tokenCount: actualTokenCount,
-            error: null,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            path: filePath,
-            content: null,
-            tokenCount: 0,
-            error: errorMessage,
-        };
     }
+    return validatedPath;
 }

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

@@ -18,3 +18,4 @@ export declare function hasUncommittedChanges(): Promise<boolean>;
  * Get the current git branch name
  */
 export declare function getCurrentBranch(): Promise<string | null>;
+//# sourceMappingURL=git-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git-utils.d.ts","sourceRoot":"","sources":["../../source/tools/git-utils.ts"],"names":[],"mappings":"AAIA,wBAAsB,WAAW;;;;GAyDhC;AAED,wBAAsB,YAAY;;;;;GAmCjC;AAED,eAAO,MAAM,cAAc,QAAqB,OAAO,CAAC,OAAO,CAS7D,CAAC;AAEH;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAgB9D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsB/D"}

package/dist/tools/grep.d.ts

@@ -1,13 +1,15 @@
+import type { TokenCounter } from "../tokens/counter.ts";
 import type { SendData } from "./types.ts";
 export declare const GrepTool: {
     name: "grepFiles";
 };
-export declare const createGrepTool: (options?: {
+export declare const createGrepTool: (options: {
     sendData?: SendData | undefined;
+    tokenCounter: TokenCounter;
 }) => {
     grepFiles: import("ai").Tool<{
-        path: string;
         pattern: string;
+        path: string;
         recursive: boolean | null;
         ignoreCase: boolean | null;
         filePattern: string | null;
@@ -33,5 +35,5 @@ interface GrepOptions {
  * @returns The result of the grep command
  */
 export declare function buildGrepCommand(pattern: string, path: string, options?: GrepOptions): string;
-export declare function grepFiles(pattern: string, path: string, options?: GrepOptions): string;
 export {};
+//# sourceMappingURL=grep.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../source/tools/grep.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,SAAS;IACtC,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;;;CA0KA,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;CAC1B;AAoDD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CAmDR"}

package/dist/tools/grep.js

@@ -1,50 +1,60 @@
 import { execSync } from "node:child_process";
 import { inspect } from "node:util";
 import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
+import { config } from "../config.js";
+import style from "../terminal/style.js";
+import { manageOutput } from "../tokens/manage-output.js";
 export const GrepTool = {
     name: "grepFiles",
 };
-export const createGrepTool = (options = {}) => {
-    const { sendData } = options;
+export const createGrepTool = (options) => {
+    const { sendData, tokenCounter } = options;
     return {
         [GrepTool.name]: tool({
-            description: "Search files for patterns using ripgrep",
+            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.`,
             inputSchema: z.object({
-                pattern: z.string().describe("The regex pattern to search for"),
+                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
+                recursive: z.coerce
                     .boolean()
                     .nullable()
-                    .describe("Pass null to use the default (true, search recursively)."),
-                ignoreCase: z
+                    .describe("Search recursively. (default: true))"),
+                ignoreCase: z.coerce
                     .boolean()
                     .nullable()
-                    .describe("Pass null to use the default (false, case-sensitive search)."),
+                    .describe("Use case-sensitive search. (default: false)"),
                 filePattern: z
                     .string()
                     .nullable()
-                    .describe("Pass null if no file pattern filter is needed."),
-                contextLines: z
+                    .describe("Glob pattern to filter files (e.g., '*.ts', '**/*.test.js'). (Default: no filtering)"),
+                contextLines: z.coerce
                     .number()
                     .nullable()
-                    .describe("Pass null if no context lines are needed."),
-                searchIgnored: z
+                    .describe("The number of context lines needed in search results. (Default: 0)"),
+                searchIgnored: z.coerce
                     .boolean()
                     .nullable()
-                    .describe("Pass null to use the default (false, don't search ignored files)."),
-                literal: z
+                    .describe("Search ignored files. (Default: false)"),
+                literal: z.coerce
                     .boolean()
                     .nullable()
-                    .describe("Pass true to search as a fixed string (no regex). Pass null to auto-detect."),
+                    .describe("Pass true for fixed-string search (-F), false for regex, (Default: auto-detects unbalanced patterns like mismatched parentheses/brackets.)"),
             }),
-            execute: ({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, }, { toolCallId }) => {
+            execute: async ({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("Grep search aborted");
+                }
                 try {
+                    // grok doesn't follow my instructions
+                    const safeFilePattern = filePattern === "null" ? null : filePattern;
                     sendData?.({
                         event: "tool-init",
                         id: toolCallId,
-                        data: `Searching codebase for "${chalk.cyan(inspect(pattern))}" in ${chalk.cyan(path)}`,
+                        data: `Searching codebase for ${style.cyan(inspect(pattern))}${safeFilePattern ? ` with file pattern ${style.cyan(safeFilePattern)}` : ""} in ${style.cyan(path)}`,
                     });
                     // Normalize literal option: if null => auto-detect using heuristic
                     let effectiveLiteral = null;
@@ -75,17 +85,32 @@ export const createGrepTool = (options = {}) => {
                             effectiveLiteral = false;
                         }
                     }
-                    const result = grepFiles(pattern, path, {
+                    const rawResult = grepFiles(pattern, path, {
                         recursive,
                         ignoreCase,
-                        filePattern,
+                        filePattern: safeFilePattern,
                         contextLines,
                         searchIgnored,
                         literal: effectiveLiteral,
                     });
-                    const matchCount = result === "No matches found."
-                        ? 0
-                        : result
+                    const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
+                    const managed = manageOutput(rawResult, {
+                        tokenCounter,
+                        threshold: maxTokens,
+                    });
+                    if (managed.truncated) {
+                        sendData?.({
+                            event: "tool-update",
+                            id: toolCallId,
+                            data: { primary: managed.warning },
+                        });
+                    }
+                    // Extract and filter matches from the content
+                    const extractMatches = (content) => {
+                        if (content === "No matches found.") {
+                            return [];
+                        }
+                        return content
                             .trim()
                             .split("\n")
                             .filter((line) => {
@@ -93,13 +118,28 @@ export const createGrepTool = (options = {}) => {
                                 return false;
                             }
                             return /^(.+?):(\d+):(.*)$/.test(line);
-                        }).length;
+                        });
+                    };
+                    const matches = extractMatches(managed.content);
+                    const matchCount = matches.length;
+                    // Show the last 10 matches as a preview
+                    if (matchCount > 0) {
+                        const previewMatches = matches.slice(-10); // Get last 10 matches
+                        sendData?.({
+                            event: "tool-update",
+                            id: toolCallId,
+                            data: {
+                                primary: `Last ${previewMatches.length} matches:`,
+                                secondary: previewMatches,
+                            },
+                        });
+                    }
                     sendData?.({
                         event: "tool-completion",
                         id: toolCallId,
-                        data: `Found ${chalk.cyan(matchCount)} matches.`,
+                        data: `Found ${style.cyan(matchCount)} matches. (${managed.tokenCount} tokens)`,
                     });
-                    return Promise.resolve(result);
+                    return Promise.resolve(managed.content);
                 }
                 catch (error) {
                     sendData?.({
@@ -209,7 +249,7 @@ export function buildGrepCommand(pattern, path, options = {}) {
     command += ` ${path}`;
     return command;
 }
-export function grepFiles(pattern, path, options = {}) {
+function grepFiles(pattern, path, options = {}) {
     try {
         const command = buildGrepCommand(pattern, path, options);
         const result = execSync(command, { encoding: "utf-8" });