@travisennis/acai 0.0.10 → 0.0.11

package/dist/tools/edit-file.js

@@ -118,25 +118,180 @@ function validateEdits(edits) {
         throw new Error("Invalid oldText in edit. The value of oldText must be at least one character");
     }
 }
-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");
+/**
+ * Normalize text for fuzzy matching by:
+ * - Unicode NFKC normalization (canonical compatibility decomposition)
+ * - Converting smart quotes to straight quotes
+ * - Unifying various dash characters to hyphen
+ * - Normalizing whitespace characters to regular space
+ * - Removing trailing whitespace from each line
+ */
+function normalizeForFuzzyMatch(text) {
+    return text
+        .normalize("NFKC")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'") // curly single quotes → '
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"') // curly double quotes → "
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-") // dashes → -
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "); // spaces → space
+}
+/**
+ * Find text in content, trying exact match first, then fuzzy match.
+ * When fuzzy match is used, positions are in the normalized content.
+ * IMPORTANT: When fuzzy matching is needed, the caller must work entirely
+ * in normalized space to avoid position mapping issues.
+ */
+function fuzzyFindText(content, searchText) {
+    // Try exact match first
+    const exactIndex = content.indexOf(searchText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            index: exactIndex,
+            matchLength: searchText.length,
+            usedFuzzyMatch: false,
+        };
+    }
+    // Fall back to fuzzy matching
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzySearch = normalizeForFuzzyMatch(searchText);
+    const fuzzyIndex = fuzzyContent.indexOf(fuzzySearch);
+    if (fuzzyIndex === -1) {
+        return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
+    }
+    return {
+        found: true,
+        index: fuzzyIndex,
+        matchLength: fuzzySearch.length,
+        usedFuzzyMatch: true,
+    };
+}
+/**
+ * Count how many times searchText appears in content (exact or fuzzy).
+ * Used to ensure uniqueness.
+ */
+function countMatches(content, searchText) {
+    // Count exact matches first
+    const exactEscaped = searchText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const exactRegex = new RegExp(exactEscaped, "g");
+    const exactMatches = content.match(exactRegex);
+    const exactCount = exactMatches ? exactMatches.length : 0;
+    if (exactCount > 0) {
+        return exactCount;
+    }
+    // Count fuzzy matches
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzySearch = normalizeForFuzzyMatch(searchText);
+    const fuzzyEscaped = fuzzySearch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const fuzzyRegex = new RegExp(fuzzyEscaped, "g");
+    const fuzzyMatches = fuzzyContent.match(fuzzyRegex);
+    return fuzzyMatches ? fuzzyMatches.length : 0;
+}
+/**
+ * Preflight validation: Find all edit positions, validate uniqueness and no overlaps.
+ * If any edit requires fuzzy matching, normalize the entire content and work in
+ * normalized space. This avoids position mapping issues.
+ */
+function preflightEdits(edits, content) {
+    const normalizedEdits = edits.map((edit) => ({
+        oldText: normalizeLineEndings(edit.oldText),
+        newText: normalizeLineEndings(edit.newText),
+    }));
+    // Check if any edit requires fuzzy matching
+    const needsFuzzyMatching = normalizedEdits.some((edit) => content.indexOf(edit.oldText) === -1);
+    // Use normalized content if fuzzy matching is needed
+    const baseContent = needsFuzzyMatching
+        ? normalizeForFuzzyMatch(content)
+        : content;
+    const matchedEdits = [];
+    // First pass: Find all match positions
+    for (let i = 0; i < normalizedEdits.length; i++) {
+        const edit = normalizedEdits[i];
+        // Check uniqueness
+        const matchCount = countMatches(baseContent, edit.oldText);
+        if (matchCount === 0) {
+            return {
+                success: false,
+                matchedEdits: [],
+                errorMessage: `Edit ${i + 1}: Could not find the exact text. ` +
+                    "The oldText must match exactly including all whitespace and newlines.",
+                usedFuzzyMatch: needsFuzzyMatching,
+                baseContent,
+            };
         }
-        const result = await applyNormalizedEdit(edit, modifiedContent);
-        if (result.success) {
-            modifiedContent = result.content;
+        if (matchCount > 1) {
+            const fuzzyContext = needsFuzzyMatching
+                ? " (including fuzzy matches)"
+                : "";
+            return {
+                success: false,
+                matchedEdits: [],
+                errorMessage: `Edit ${i + 1}: oldText matches ${matchCount} locations${fuzzyContext} but should match only 1. ` +
+                    "Please provide a more specific oldText that includes more surrounding context.",
+                usedFuzzyMatch: needsFuzzyMatching,
+                baseContent,
+            };
         }
-        else if (result.errorMessage) {
-            throw new Error(result.errorMessage);
+        // Find the match position
+        const matchResult = fuzzyFindText(baseContent, edit.oldText);
+        if (!matchResult.found) {
+            return {
+                success: false,
+                matchedEdits: [],
+                errorMessage: `Edit ${i + 1}: Could not find the text (unexpected error).`,
+                usedFuzzyMatch: needsFuzzyMatching,
+                baseContent,
+            };
         }
-        else {
-            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.");
+        matchedEdits.push({
+            ...edit,
+            index: matchResult.index,
+            matchLength: matchResult.matchLength,
+            editIndex: i,
+        });
+    }
+    // Sort by position (ascending) for overlap detection
+    matchedEdits.sort((a, b) => a.index - b.index);
+    // Check for overlapping edits
+    for (let i = 0; i < matchedEdits.length - 1; i++) {
+        const current = matchedEdits[i];
+        const next = matchedEdits[i + 1];
+        // Check if current edit overlaps with next edit
+        if (current.index + current.matchLength > next.index) {
+            return {
+                success: false,
+                matchedEdits: [],
+                errorMessage: `Edits ${current.editIndex + 1} and ${next.editIndex + 1} overlap in the file. ` +
+                    "Each edit must target a distinct region. Please combine overlapping edits into a single edit.",
+                usedFuzzyMatch: needsFuzzyMatching,
+                baseContent,
+            };
         }
     }
-    return modifiedContent;
+    return {
+        success: true,
+        matchedEdits,
+        usedFuzzyMatch: needsFuzzyMatching,
+        baseContent,
+    };
+}
+/**
+ * Apply edits in reverse position order (highest index first).
+ * This prevents position shifting - earlier edits don't affect later ones.
+ * All positions are relative to baseContent (normalized if fuzzy matching).
+ */
+function applyEditsReverseOrder(content, matchedEdits) {
+    let result = content;
+    // Process in reverse order (highest index first)
+    for (let i = matchedEdits.length - 1; i >= 0; i--) {
+        const edit = matchedEdits[i];
+        const before = result.slice(0, edit.index);
+        const after = result.slice(edit.index + edit.matchLength);
+        result = before + edit.newText + after;
+    }
+    return result;
 }
 function formatDiff(diff, _filePath) {
     let numBackticks = 3;
@@ -158,11 +313,27 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
     const originalLineEnding = detectLineEnding(bomStrippedContent);
     const content = normalizeLineEndings(bomStrippedContent);
     validateEdits(edits);
-    const modifiedContent = await applyEditsSequentially(edits, content, abortSignal, filePath);
+    // PREFLIGHT: Find all positions, validate no overlaps
+    const preflight = preflightEdits(edits, content);
+    if (!preflight.success) {
+        throw new Error(`Edit validation failed: ${preflight.errorMessage}`);
+    }
+    // All edits validated - apply in reverse order
+    // Note: baseContent is normalized if fuzzy matching was needed
+    const modifiedContent = applyEditsReverseOrder(preflight.baseContent, preflight.matchedEdits);
+    // Verify something actually changed
+    if (modifiedContent === preflight.baseContent) {
+        throw new Error("No changes were made - all edits resulted in identical content");
+    }
     const finalContentWithLineEndings = restoreLineEndings(modifiedContent, originalLineEnding);
     const finalContent = originalBom + finalContentWithLineEndings;
-    const diff = createUnifiedDiff(content, finalContent, filePath);
+    // Use baseContent for diff (normalized if fuzzy matching)
+    const diff = createUnifiedDiff(preflight.baseContent, modifiedContent, filePath);
     const formattedDiff = formatDiff(diff, filePath);
+    // Add fuzzy match indicator if applicable
+    const result = preflight.usedFuzzyMatch
+        ? `${formattedDiff}\n\n(Note: Used fuzzy matching - file content has been normalized)`
+        : formattedDiff;
     if (!dryRun) {
         if (abortSignal?.aborted) {
             throw new Error("File edit operation aborted before writing");
@@ -172,67 +343,5 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
             signal: abortSignal,
         });
     }
-    return formattedDiff;
-}
-/**
- * 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
- */
-function countMatches(content, search) {
-    if (search === "") {
-        return { count: 0 };
-    }
-    // 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) {
-    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;
-    const modifiedContent = content.replace(regex, () => {
-        matchCount++;
-        return replace;
-    });
-    return { matchCount, content: modifiedContent };
+    return result;
 }

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;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"}
+{"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;AA6EvD,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;CAuCrB,CAAC"}

package/dist/tools/glob.js

@@ -38,6 +38,24 @@ function formatResult(sortedFiles) {
         ? sortedFiles.join("\n")
         : "No files found matching the specified patterns.";
 }
+function normalizePatternArray(patterns) {
+    return Array.isArray(patterns) ? patterns : [patterns];
+}
+function buildGlobOptions(effectivePath, gitignore, recursive, expandDirectories, ignoreFiles, cwd) {
+    return {
+        cwd: cwd || effectivePath,
+        ...(gitignore !== null && { gitignore }),
+        ...(recursive !== null && { recursive }),
+        ...(expandDirectories !== null && { expandDirectories }),
+        ...(ignoreFiles !== null && { ignoreFiles }),
+    };
+}
+function limitResults(sortedFiles, effectiveMaxResults) {
+    if (effectiveMaxResults > 0 && sortedFiles.length > effectiveMaxResults) {
+        return sortedFiles.slice(0, effectiveMaxResults);
+    }
+    return sortedFiles;
+}
 export const GlobTool = {
     name: "Glob",
 };
@@ -125,27 +143,16 @@ export const createGlobTool = () => {
                 throw new Error("Glob search aborted");
             }
             const effectivePath = typeof path === "string" && path.trim() !== "" ? path : process.cwd();
-            const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+            const patternArray = normalizePatternArray(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 }),
-            };
-            const matchingFiles = await glob(patternArray, {
-                ...globOptions,
-                cwd: effectivePath,
-            });
+            const globOptions = buildGlobOptions(effectivePath, gitignore, recursive, expandDirectories, ignoreFiles, cwd);
+            const matchingFiles = await glob(patternArray, globOptions);
             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;
+            const result = limitResults(sortedFiles, effectiveMaxResults);
             return formatResult(result);
         },
     };

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

@@ -1 +1 @@
-{"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"}
+{"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;AAuMD,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,CAoDpD;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"}

package/dist/tools/grep.js

@@ -133,39 +133,47 @@ function skipCharacterClass(pattern, startIndex) {
     }
     return i;
 }
+/**
+ * Checks if a character is valid inside braces (digits 0-9 or comma).
+ */
+function isValidBraceChar(c) {
+    return (c >= "0" && c <= "9") || c === ",";
+}
+/**
+ * Checks if empty braces have a preceding atom.
+ * Empty braces with no preceding atom are treated as literal.
+ */
+function hasPrecedingAtom(pattern, startIndex) {
+    if (startIndex === 0)
+        return false;
+    const prev = pattern[startIndex - 1];
+    return /\S/.test(prev);
+}
 /**
  * Parses and validates the content inside braces {..}.
  * Returns true if the brace content is invalid.
  */
 function isInvalidBraceContent(pattern, startIndex) {
-    let j = startIndex + 1;
+    const j = startIndex + 1;
+    // Find closing brace and check for invalid characters
     let hasDigits = false;
-    let hasComma = false;
-    // Parse content inside braces
-    while (j < pattern.length && pattern[j] !== "}") {
-        const c = pattern[j];
-        if (c >= "0" && c <= "9") {
-            hasDigits = true;
-        }
-        else if (c === "," && !hasComma) {
-            hasComma = true;
-        }
-        else {
-            // Invalid character inside braces
+    let k = j;
+    while (k < pattern.length && pattern[k] !== "}") {
+        if (!isValidBraceChar(pattern[k])) {
             return true;
         }
-        j++;
+        if (pattern[k] >= "0" && pattern[k] <= "9") {
+            hasDigits = true;
+        }
+        k++;
     }
     // No closing brace found
-    if (j >= pattern.length) {
+    if (k >= pattern.length) {
         return true;
     }
-    // Empty braces {} with no preceding atom are treated as literal
-    if (!hasDigits) {
-        const prev = startIndex > 0 ? pattern[startIndex - 1] : undefined;
-        if (prev !== undefined && /\S/.test(prev)) {
-            return true;
-        }
+    // Empty braces {} with preceding atom are invalid
+    if (!hasDigits && hasPrecedingAtom(pattern, startIndex)) {
+        return true;
     }
     return false;
 }
@@ -184,24 +192,31 @@ function hasInvalidRepetition(pattern) {
             i = skipCharacterClass(pattern, i);
             continue;
         }
+        // Unmatched closing brace is invalid
         if (ch === "}") {
-            // Unmatched closing brace is invalid
             return true;
         }
+        // Handle opening brace
         if (ch === "{") {
             if (isInvalidBraceContent(pattern, i)) {
                 return true;
             }
-            // Find closing brace to move past it
-            let j = i + 1;
-            while (j < pattern.length && pattern[j] !== "}") {
-                j++;
-            }
-            i = j;
+            i = findClosingBrace(pattern, i);
         }
     }
     return false;
 }
+/**
+ * Finds the index of the closing brace matching an opening brace.
+ * Returns the index of the closing brace, or the last index of pattern if not found.
+ */
+function findClosingBrace(pattern, startIndex) {
+    let j = startIndex + 1;
+    while (j < pattern.length && pattern[j] !== "}") {
+        j++;
+    }
+    return j;
+}
 /**
  * Count bracket/paren/brace pairs in a regex pattern, excluding character classes.
  */
@@ -489,7 +504,6 @@ export function truncateMatches(matches, maxResults) {
                 matchesKept++;
             }
             else {
-                break;
             }
         }
         else if (match.isContext) {

package/dist/tools/index.d.ts

@@ -11,6 +11,20 @@ export type CompleteToolNames = keyof CompleteToolSet;
 export declare function initTools({ workspace, }: {
     workspace: WorkspaceContext;
 }): Promise<{
+    readonly ApplyPatch: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                patchText: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        display({ patchText }: {
+            patchText: string;
+        }): string;
+        execute({ patchText }: {
+            patchText: string;
+        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
+    };
     readonly Edit: {
         toolDef: {
             description: string;
@@ -112,7 +126,6 @@ export declare function initTools({ workspace, }: {
                 }>>>;
                 startLine: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
                 lineCount: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                maxBytes: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ path: providedPath, startLine, lineCount }: {
@@ -120,14 +133,12 @@ export declare function initTools({ workspace, }: {
             encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
-            maxBytes: number | null;
         }): string;
-        execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }: {
+        execute({ path: providedPath, encoding, startLine, lineCount, }: {
             path: string;
             encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
-            maxBytes: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
     readonly Glob: {
@@ -203,50 +214,6 @@ export declare function initTools({ workspace, }: {
             maxResults: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
-    readonly CodeSearch: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                query: import("zod").ZodString;
-                path: import("zod").ZodDefault<import("zod").ZodString>;
-                regexPattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                filePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                excludePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                excludeDir: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                contextLines: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                filesOnly: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                showContent: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                codeOnly: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-            }, import("zod/v4/core").$strip>;
-        };
-        display({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: {
-            query: string;
-            path: string;
-            regexPattern: string | null;
-            filePattern: string | null;
-            excludePattern: string | null;
-            excludeDir: string | null;
-            maxResults: number | null;
-            contextLines: number | null;
-            filesOnly: boolean | null;
-            showContent: boolean | null;
-            codeOnly: boolean | null;
-        }): string;
-        execute({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: {
-            query: string;
-            path: string;
-            regexPattern: string | null;
-            filePattern: string | null;
-            excludePattern: string | null;
-            excludeDir: string | null;
-            maxResults: number | null;
-            contextLines: number | null;
-            filesOnly: boolean | null;
-            showContent: boolean | null;
-            codeOnly: boolean | null;
-        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
-    };
     readonly DirectoryTree: {
         toolDef: {
             description: string;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAoBpD,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAEtD,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAoBpD,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAEtD,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EA"}

package/dist/tools/index.js

@@ -1,7 +1,7 @@
 import { config } from "../config/index.js";
 import { AgentTool, createAgentTools } from "./agent.js";
+import { ApplyPatchTool, createApplyPatchTool } from "./apply-patch.js";
 import { BashTool, createBashTool } from "./bash.js";
-import { CodeSearchTool, createCodeSearchTool } from "./code-search.js";
 import { createDirectoryTreeTool, DirectoryTreeTool, } from "./directory-tree.js";
 import { loadDynamicTools } from "./dynamic-tool-loader.js";
 import { createEditFileTool, EditFileTool } from "./edit-file.js";
@@ -21,7 +21,6 @@ export async function initTools({ workspace, }) {
     const directoryTreeTool = await createDirectoryTreeTool({ workspace });
     const globTool = createGlobTool();
     const grepTool = createGrepTool();
-    const codeSearchTool = createCodeSearchTool();
     const thinkTool = createThinkTool();
     const lsTool = await createLsTool({ workspace });
     const projectConfig = await config.getConfig();
@@ -30,16 +29,17 @@ export async function initTools({ workspace, }) {
     const agentTool = await createAgentTools({ workspace });
     const webSearchTool = await createWebSearchTool();
     const webFetchTool = await createWebFetchTool();
+    const applyPatchTool = await createApplyPatchTool({ workspace });
     const dynamicTools = await loadDynamicTools({
         baseDir: workspace.primaryDir,
         existingToolNames: [
+            ApplyPatchTool.name,
             EditFileTool.name,
             BashTool.name,
             SaveFileTool.name,
             ReadFileTool.name,
             GlobTool.name,
             GrepTool.name,
-            CodeSearchTool.name,
             DirectoryTreeTool.name,
             ThinkTool.name,
             LsTool.name,
@@ -51,13 +51,13 @@ export async function initTools({ workspace, }) {
     });
     // Build tools object for AI SDK
     const tools = {
+        [ApplyPatchTool.name]: applyPatchTool,
         [EditFileTool.name]: editFileTool,
         [BashTool.name]: bashTool,
         [SaveFileTool.name]: saveFileTool,
         [ReadFileTool.name]: readFileTool,
         [GlobTool.name]: globTool,
         [GrepTool.name]: grepTool,
-        [CodeSearchTool.name]: codeSearchTool,
         [DirectoryTreeTool.name]: directoryTreeTool,
         [ThinkTool.name]: thinkTool,
         [LsTool.name]: lsTool,

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

@@ -1 +1 @@
-{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../source/tools/ls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,MAAM;;CAElB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAQf,CAAC;AAEH,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAIjD,eAAO,MAAM,YAAY,GAAU,SAAS;IAC1C,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;2CAS0C,aAAa;2CAOnB,aAAa,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6DrB,CAAC"}
+{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../source/tools/ls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,MAAM;;CAElB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAQf,CAAC;AAEH,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAIjD,eAAO,MAAM,YAAY,GAAU,SAAS;IAC1C,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;2CAU0C,aAAa;2CAOnB,aAAa,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6DrB,CAAC"}

package/dist/tools/ls.js

@@ -24,7 +24,7 @@ export const createLsTool = async (options) => {
     const allowedDirectory = allowedDirs ?? [primaryDir];
     return {
         toolDef: {
-            description: "List files in a directory.",
+            description: "List files in a single directory. Fast and simple - use this when you need a quick flat list of files in one directory. For recursive tree views, use DirectoryTree instead.",
             inputSchema,
         },
         display({ path: providedPath, limit }) {