@travisennis/acai 0.0.5 → 0.0.7

package/dist/tools/edit-file.js

@@ -1,122 +1,84 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { tool } from "ai";
 import { createTwoFilesPatch } from "diff";
 import { z } from "zod";
+import { config } from "../config.js";
+import { logger } from "../logger.js";
+import { clearProjectStatusCache } from "../repl/project-status-line.js";
 import style from "../terminal/style.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.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 });
+                // Check if file is read-only
+                const projectConfig = await config.getConfig();
+                validateFileNotReadOnly(validPath, projectConfig, workingDir);
+                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-update",
+                    data: result.trim(),
+                };
+                yield {
+                    name: EditFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: `Applied ${edits.length} edits to ${style.cyan(path)}`,
+                };
+                // Clear project status cache since file operations change git status
+                clearProjectStatusCache();
+                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 +91,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 +103,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);
@@ -169,7 +124,7 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
     while (diff.includes("`".repeat(numBackticks))) {
         numBackticks++;
     }
-    const formattedDiff = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
+    const formattedDiff = `${"`".repeat(numBackticks)} diff\n${diff}\n${"`".repeat(numBackticks)}`;
     if (!dryRun) {
         if (abortSignal?.aborted) {
             throw new Error("File edit operation aborted before writing");
@@ -182,3 +137,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/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;AAMzD,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;CAmIhC,CAAC"}

package/dist/tools/glob.js

@@ -0,0 +1,154 @@
+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";
+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.";
+                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,
+                    };
+                    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 (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

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

@@ -1 +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"}
+{"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"}