@travisennis/acai 0.0.8 → 0.0.10

package/dist/tools/edit-file.js

@@ -1,46 +1,73 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { access, constants, readFile, writeFile } from "node:fs/promises";
 import { createTwoFilesPatch } from "diff";
 import { z } from "zod";
-import { config } from "../config.js";
+import { config } from "../config/index.js";
 import { clearProjectStatusCache } from "../repl/project-status.js";
 import style from "../terminal/style.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
 import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
 export const EditFileTool = {
     name: "Edit",
 };
+const MAX_EDITS_PER_CALL = 10;
 const inputSchema = z.object({
     path: z.string().describe("The path of the file to edit."),
-    edits: z.array(z.object({
+    edits: z
+        .preprocess((val) => {
+        // Handle case where model passes a JSON string instead of an array
+        if (typeof val === "string") {
+            const trimmed = val.trim();
+            // Try parsing as JSON if it looks like an array
+            if (trimmed.startsWith("[")) {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (Array.isArray(parsed)) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    // Not valid JSON, treat as a plain string
+                }
+            }
+        }
+        return val;
+    }, 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."),
+            .describe("Text to search for - must match exactly. The oldText must uniquely identify the location - include enough surrounding context (e.g., 3+ lines or function/class names) to ensure only ONE match exists in the file. " +
+            "Special characters require JSON escaping: backticks (`\\``...\\``), quotes, backslashes. " +
+            "For multi-line content, include exact newlines and indentation.")
+            .min(1, "oldText must be at least 1 character"),
         newText: z.string().describe("Text to replace with"),
-    })),
+    })))
+        .describe("The edits to make to the file."),
 });
-export const createEditFileTool = async ({ workingDir, allowedDirs, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
+export const createEditFileTool = async (options) => {
+    const { primaryDir, allowedDirs } = options.workspace;
+    const allowedDirectory = allowedDirs ?? [primaryDir];
+    // Cache config at tool creation time instead of on every execute
+    const projectConfig = await config.getConfig();
     return {
         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.",
+            description: "Edit text in files using literal search-and-replace.",
             inputSchema,
         },
         display({ path, edits }) {
-            return `\n> ${style.cyan(path)} (${edits.length} edit${edits.length === 1 ? "" : "s"})`;
+            const displayPath = toDisplayPath(path);
+            return `${style.cyan(displayPath)} (${edits.length} edit${edits.length === 1 ? "" : "s"})`;
         },
         async execute({ path, edits }, { abortSignal }) {
             if (abortSignal?.aborted) {
                 throw new Error("File editing aborted");
             }
-            const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
-            const projectConfig = await config.getConfig();
-            validateFileNotReadOnly(validPath, projectConfig, workingDir);
+            // Check for excessive edits and return helpful message to the model
+            if (edits.length > MAX_EDITS_PER_CALL) {
+                throw new Error(`Too many edits (${edits.length}). Maximum ${MAX_EDITS_PER_CALL} edits per call. ` +
+                    "Please split your changes into multiple tool calls. " +
+                    "For example, if you need to make 20 edits, make 2 calls with 10 edits each.");
+            }
+            const validPath = await validatePath(joinWorkingDir(path, primaryDir), allowedDirectory, { abortSignal });
+            validateFileNotReadOnly(validPath, projectConfig, primaryDir);
             const result = await applyFileEdits(validPath, edits, false, abortSignal);
             clearProjectStatusCache();
             return result;
@@ -48,55 +75,99 @@ export const createEditFileTool = async ({ workingDir, allowedDirs, }) => {
     };
 };
 // file editing and diffing utilities
+/** Detect the line ending used in the content */
+function detectLineEnding(content) {
+    const crlfIdx = content.indexOf("\r\n");
+    const lfIdx = content.indexOf("\n");
+    // If no line endings at all, default to LF
+    if (crlfIdx === -1 && lfIdx === -1)
+        return "\n";
+    // If CRLF exists (and either no LF or CRLF comes first), return CRLF
+    if (crlfIdx !== -1 && (lfIdx === -1 || crlfIdx < lfIdx)) {
+        return "\r\n";
+    }
+    return "\n";
+}
+/** Normalize line endings to LF for internal processing */
 function normalizeLineEndings(text) {
-    return text.replace(/\r\n/g, "\n");
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
-function createUnifiedDiff(originalContent, newContent, filepath = "file") {
-    // Ensure consistent line endings for diff
-    const normalizedOriginal = normalizeLineEndings(originalContent);
-    const normalizedNew = normalizeLineEndings(newContent);
+/** Restore original line endings after processing */
+function restoreLineEndings(text, ending) {
+    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+/** Strip UTF-8 BOM if present - users won't include invisible BOM in oldText */
+function stripBom(content) {
+    return content.startsWith("\uFEFF")
+        ? { bom: "\uFEFF", text: content.slice(1) }
+        : { bom: "", text: content };
+}
+function createUnifiedDiff(normalizedOriginal, normalizedNew, filepath = "file") {
     return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
 }
-export async function applyFileEdits(filePath, edits, dryRun = false, abortSignal) {
-    if (abortSignal?.aborted) {
-        throw new Error("File edit operation aborted");
+async function validateFileReadable(filePath) {
+    try {
+        await access(filePath, constants.R_OK);
     }
-    // Read file content literally with signal
-    const originalContent = await readFile(filePath, {
-        encoding: "utf-8",
-        signal: abortSignal,
-    });
-    if (edits.find((edit) => edit.oldText.length === 0)) {
+    catch {
+        throw new Error(`File not found or not readable: ${filePath}`);
+    }
+}
+function validateEdits(edits) {
+    if (edits.some((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 literal matches (allow multiple matches)
-    let modifiedContent = originalContent;
+}
+async function applyEditsSequentially(edits, content, abortSignal, filePath) {
+    let modifiedContent = content;
     for (const edit of edits) {
         if (abortSignal?.aborted) {
             throw new Error("File edit operation aborted during processing");
         }
-        const result = await applyEditWithLlmFix(edit, modifiedContent);
+        const result = await applyNormalizedEdit(edit, modifiedContent);
         if (result.success) {
             modifiedContent = result.content;
         }
+        else if (result.errorMessage) {
+            throw new Error(result.errorMessage);
+        }
         else {
-            throw new Error("oldText not found in content");
+            throw new Error(`Could not find the exact text in ${filePath}. The oldText must match exactly including all whitespace and newlines. ` +
+                "Tip: Check for invisible characters, extra/missing whitespace, or line ending differences.");
         }
     }
-    // Create unified diff (createUnifiedDiff normalizes line endings internally for diffing)
-    const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
-    // Format diff with appropriate number of backticks
+    return modifiedContent;
+}
+function formatDiff(diff, _filePath) {
     let numBackticks = 3;
     while (diff.includes("`".repeat(numBackticks))) {
         numBackticks++;
     }
-    const formattedDiff = `${"`".repeat(numBackticks)} diff\n${diff}\n${"`".repeat(numBackticks)}`;
+    return `${"`".repeat(numBackticks)} diff\n${diff}\n${"`".repeat(numBackticks)}`;
+}
+export async function applyFileEdits(filePath, edits, dryRun = false, abortSignal) {
+    if (abortSignal?.aborted) {
+        throw new Error("File edit operation aborted");
+    }
+    await validateFileReadable(filePath);
+    const rawContent = await readFile(filePath, {
+        encoding: "utf-8",
+        signal: abortSignal,
+    });
+    const { bom: originalBom, text: bomStrippedContent } = stripBom(rawContent);
+    const originalLineEnding = detectLineEnding(bomStrippedContent);
+    const content = normalizeLineEndings(bomStrippedContent);
+    validateEdits(edits);
+    const modifiedContent = await applyEditsSequentially(edits, content, abortSignal, filePath);
+    const finalContentWithLineEndings = restoreLineEndings(modifiedContent, originalLineEnding);
+    const finalContent = originalBom + finalContentWithLineEndings;
+    const diff = createUnifiedDiff(content, finalContent, filePath);
+    const formattedDiff = formatDiff(diff, filePath);
     if (!dryRun) {
         if (abortSignal?.aborted) {
             throw new Error("File edit operation aborted before writing");
         }
-        // Write the modified content with signal
-        await writeFile(filePath, modifiedContent, {
+        await writeFile(filePath, finalContent, {
             encoding: "utf-8",
             signal: abortSignal,
         });
@@ -104,37 +175,64 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
     return formattedDiff;
 }
 /**
- * Applies a single edit
+ * Applies a single edit with normalized line endings
+ * Returns an error if oldText matches more than one location in the file
+ */
+async function applyNormalizedEdit(edit, content) {
+    // Normalize line endings to match the normalized content
+    const normalizedOldText = normalizeLineEndings(edit.oldText);
+    const normalizedNewText = normalizeLineEndings(edit.newText);
+    // First, check how many matches exist (without replacing)
+    const matchCountResult = countMatches(content, normalizedOldText);
+    const matchCount = matchCountResult.count;
+    // If more than one match, require unique oldText
+    if (matchCount > 1) {
+        return {
+            success: false,
+            content,
+            matchCount,
+            errorMessage: `oldText matches ${matchCount} locations in the file but should match only 1. ` +
+                "Please provide a more specific oldText that includes more surrounding context (e.g., 3+ lines, " +
+                "function/class names, or unique surrounding code) to uniquely identify the location you want to edit.",
+        };
+    }
+    // If no matches, return failure
+    if (matchCount === 0) {
+        return { success: false, content };
+    }
+    // Exactly one match - apply the edit
+    const originalResult = applyLiteralEdit(content, normalizedOldText, normalizedNewText);
+    return { success: true, content: originalResult.content };
+}
+/**
+ * Count the number of literal matches in content without replacing
  */
-async function applyEditWithLlmFix(edit, content) {
-    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 };
+function countMatches(content, search) {
+    if (search === "") {
+        return { count: 0 };
     }
-    return { success: false, content };
+    // Escape special regex characters for literal matching
+    const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(escapedSearch, "g");
+    // Count matches without modifying content
+    const matches = content.match(regex);
+    return { count: matches ? matches.length : 0 };
 }
 /**
  * Applies a literal search and replace operation
  */
 function applyLiteralEdit(content, search, replace) {
-    let modifiedContent = content;
+    if (search === "") {
+        return { matchCount: 0, content };
+    }
+    // Escape special regex characters for literal matching
+    const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(escapedSearch, "g");
+    // Use replace with callback to count matches while replacing all occurrences
     let matchCount = 0;
-    let currentIndex = 0;
-    while (currentIndex < modifiedContent.length) {
-        const matchIndex = modifiedContent.indexOf(search, currentIndex);
-        if (matchIndex === -1) {
-            break;
-        }
+    const modifiedContent = content.replace(regex, () => {
         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 replace;
+    });
     return { matchCount, content: modifiedContent };
 }

package/dist/tools/glob.d.ts

@@ -4,12 +4,12 @@ export declare const GlobTool: {
     name: "Glob";
 };
 export declare const inputSchema: z.ZodObject<{
-    patterns: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    path: z.ZodString;
+    patterns: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    path: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodString>;
     gitignore: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
     recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
     expandDirectories: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    ignoreFiles: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    ignoreFiles: z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
     cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
     maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
@@ -18,12 +18,12 @@ export declare const createGlobTool: () => {
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
-            patterns: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-            path: z.ZodString;
+            patterns: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            path: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodString>;
             gitignore: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
             recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
             expandDirectories: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            ignoreFiles: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            ignoreFiles: z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
             cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
             maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$strip>;

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

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAIvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;iBA4BtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;gCAMK,eAAe;wGAkBtC,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CA4ErB,CAAC"}
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA8CvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;iBA0EtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;gCAMK,eAAe;wGAmBtC,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CA6CrB,CAAC"}

package/dist/tools/glob.js

@@ -2,17 +2,71 @@ import * as fs from "node:fs";
 import * as nodePath from "node:path";
 import { z } from "zod";
 import style from "../terminal/style.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
 import { glob } from "../utils/glob.js";
 import { convertNullString } from "../utils/zod.js";
 const DEFAULT_MAX_RESULTS = 100;
+const MAX_STAT_FILES = 1000;
+async function getFileWithStats(filePath, effectivePath) {
+    const fullPath = nodePath.join(effectivePath, filePath);
+    try {
+        const stats = await fs.promises.stat(fullPath);
+        return {
+            path: filePath,
+            mtime: stats.mtime.getTime(),
+        };
+    }
+    catch {
+        return {
+            path: filePath,
+            mtime: 0,
+        };
+    }
+}
+function sortFilesByMtime(files) {
+    return files
+        .sort((a, b) => {
+        if (b.mtime !== a.mtime) {
+            return b.mtime - a.mtime;
+        }
+        return a.path.localeCompare(b.path);
+    })
+        .map((file) => file.path);
+}
+function formatResult(sortedFiles) {
+    return sortedFiles.length > 0
+        ? sortedFiles.join("\n")
+        : "No files found matching the specified patterns.";
+}
 export const GlobTool = {
     name: "Glob",
 };
 export const inputSchema = z.object({
     patterns: z
-        .union([z.string(), z.array(z.string())])
+        .preprocess((val) => {
+        if (val === null || val === undefined) {
+            return "**/*";
+        }
+        if (typeof val === "string") {
+            const trimmed = val.trim();
+            if (trimmed.startsWith("[")) {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (Array.isArray(parsed)) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    // Not valid JSON, treat as a plain glob string
+                }
+            }
+        }
+        return val;
+    }, 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"),
+    path: z
+        .preprocess((val) => (val === null || val === undefined ? process.cwd() : val), z.string())
+        .describe("Base directory to search in"),
     gitignore: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Respect ignore patterns in .gitignore files. (default: true)"),
@@ -23,9 +77,28 @@ export const inputSchema = z.object({
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Automatically expand directories to files. (default: true)"),
     ignoreFiles: z
-        .union([z.string(), z.array(z.string())])
-        .nullable()
-        .describe("Glob patterns to look for ignore files. (default: undefined)"),
+        .preprocess((val) => {
+        const converted = convertNullString(val);
+        if (converted === null) {
+            return null;
+        }
+        if (typeof converted === "string") {
+            const trimmed = converted.trim();
+            if (trimmed.startsWith("[")) {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (Array.isArray(parsed)) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    // Not valid JSON, treat as a plain string
+                }
+            }
+        }
+        return converted;
+    }, z.union([z.string(), z.array(z.string())]).nullable())
+        .describe("Glob patterns to look for ignore files (e.g., '.gitignore'). Pass null to use default behavior."),
     cwd: z
         .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
         .describe("Current working directory override. (default: process.cwd())"),
@@ -36,7 +109,7 @@ export const inputSchema = z.object({
 export const createGlobTool = () => {
     return {
         toolDef: {
-            description: `Search for files using glob patterns (e.g., *.ts, **/*.test.ts, src/**/*.js). Uses the fast-glob library with support for .gitignore, recursive searching, directory expansion, and automatic result limiting to prevent overwhelming output. Default limit is ${DEFAULT_MAX_RESULTS} files. Use maxResults parameter to override this limit.`,
+            description: "Find files by name pattern (e.g., *.ts).",
             inputSchema,
         },
         display({ patterns, path }) {
@@ -44,69 +117,36 @@ export const createGlobTool = () => {
             const patternStr = patternArray.length === 1
                 ? patternArray[0]
                 : JSON.stringify(patternArray);
-            return `\n> ${style.cyan(patternStr)} in ${style.cyan(path)}`;
+            const displayPath = toDisplayPath(path);
+            return `${style.cyan(patternStr)} in ${style.cyan(displayPath)}`;
         },
         async execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }, { abortSignal }) {
             if (abortSignal?.aborted) {
                 throw new Error("Glob search aborted");
             }
+            const effectivePath = typeof path === "string" && path.trim() !== "" ? path : process.cwd();
             const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+            const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
             const globOptions = {
                 cwd: cwd || process.cwd(),
+                ...(gitignore !== null && { gitignore }),
+                ...(recursive !== null && { recursive }),
+                ...(expandDirectories !== null && { expandDirectories }),
+                ...(ignoreFiles !== null && { ignoreFiles }),
             };
-            if (gitignore !== null) {
-                globOptions["gitignore"] = gitignore;
-            }
-            if (recursive !== null) {
-                globOptions["recursive"] = recursive;
-            }
-            if (expandDirectories !== null) {
-                globOptions["expandDirectories"] = expandDirectories;
-            }
-            if (ignoreFiles !== null) {
-                globOptions["ignoreFiles"] = ignoreFiles;
-            }
             const matchingFiles = await glob(patternArray, {
                 ...globOptions,
-                cwd: path,
+                cwd: effectivePath,
             });
-            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,
-                    };
-                }
-                catch {
-                    return {
-                        path: filePath,
-                        mtime: new Date(0),
-                        isRecent: false,
-                    };
-                }
-            }));
-            const sortedFiles = filesWithStats
-                .sort((a, b) => {
-                if (a.isRecent && !b.isRecent)
-                    return -1;
-                if (!a.isRecent && b.isRecent)
-                    return 1;
-                if (a.isRecent && b.isRecent) {
-                    return b.mtime.getTime() - a.mtime.getTime();
-                }
-                return a.path.localeCompare(b.path);
-            })
-                .map((file) => file.path);
-            const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
-            const limitedFiles = effectiveMaxResults && effectiveMaxResults > 0
+            const filesToStat = matchingFiles.length > MAX_STAT_FILES
+                ? matchingFiles.slice(0, MAX_STAT_FILES)
+                : matchingFiles;
+            const filesWithStats = await Promise.all(filesToStat.map((filePath) => getFileWithStats(filePath, effectivePath)));
+            const sortedFiles = sortFilesByMtime(filesWithStats);
+            const result = effectiveMaxResults > 0 && sortedFiles.length > effectiveMaxResults
                 ? sortedFiles.slice(0, effectiveMaxResults)
                 : sortedFiles;
-            return limitedFiles.length > 0
-                ? limitedFiles.join("\n")
-                : "No files found matching the specified patterns.";
+            return formatResult(result);
         },
     };
 };

package/dist/tools/grep.d.ts

@@ -41,23 +41,31 @@ interface GrepOptions {
     searchIgnored?: boolean | null;
     literal?: boolean | null;
     maxResults?: number | null;
+    likelyUnbalanced?: boolean;
 }
 export declare function likelyUnbalancedRegex(pattern: string): boolean;
 /**
- * Search files for patterns using ripgrep
+ * Build grep command args array directly
  *
  * @param pattern - The regex pattern to search for
  * @param path - The path to search in
  * @param options - Additional options for the grep command
- * @returns The result of the grep command
+ * @returns The args array for the grep command
  */
-export declare function buildGrepCommand(pattern: string, path: string, options?: GrepOptions): string;
+export declare function buildGrepArgs(pattern: string, path: string, options?: GrepOptions): string[];
 export interface ParsedMatch {
     file?: string;
     line: number;
     content: string;
     isMatch: boolean;
     isContext?: boolean;
+    lineNumber?: number;
+    absolutePath?: string;
+    submatches?: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
 }
 interface GrepResult {
     rawOutput: string;
@@ -69,9 +77,9 @@ interface GrepResult {
     isTruncated?: boolean;
 }
 /**
- * Parse ripgrep output and extract structured match information
+ * Parse ripgrep JSON output and extract structured match information
  */
-export declare function parseRipgrepOutput(content: string): ParsedMatch[];
+export declare function parseRipgrepJsonOutput(content: string): ParsedMatch[];
 /**
  * Count actual matches (excluding context lines)
  */
@@ -81,17 +89,12 @@ export declare function countActualMatches(parsed: ParsedMatch[]): number;
  */
 export declare function countContextLines(parsed: ParsedMatch[]): number;
 /**
- * Truncate matches to a maximum number of results
+ * Truncate matches to a maximum number of results, preserving context lines for kept matches
  */
 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 declare function grepFilesStructured(pattern: string, path: string, options?: GrepOptions, abortSignal?: AbortSignal | null): Promise<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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;iBAoCf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kFAapB,eAAe;sHAmCb,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CA6DrB,CAAC;AAEF,UAAU,WAAW;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAQD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiI9D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CA+DR;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CA4EjE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAE/D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC;IAAE,SAAS,EAAE,WAAW,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CA6BpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAWxD;AAED,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CAGR;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,UAAU,CAwDZ"}
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../source/tools/grep.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;iBAoCf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kFAapB,eAAe;sHAoCb,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAkErB,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;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAqLD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA8B9D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,EAAE,CAgEV;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;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;CACJ;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,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CAqDrE;AA8BD;;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;AAyBD;;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,CAqDpD;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,EACzB,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,GAC/B,OAAO,CAAC,UAAU,CAAC,CAgGrB"}