@travisennis/acai 0.0.10 → 0.0.12

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

@@ -4,28 +4,28 @@ export declare const GlobTool: {
     name: "Glob";
 };
 export declare const inputSchema: z.ZodObject<{
-    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.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>>>;
+    patterns: z.ZodDefault<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    path: z.ZodDefault<z.ZodPreprocess<z.ZodString>>;
+    gitignore: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    expandDirectories: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    ignoreFiles: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
+    cwd: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+    maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
 }, z.core.$strip>;
 type GlobInputSchema = z.infer<typeof inputSchema>;
 export declare const createGlobTool: () => {
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
-            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.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>>>;
+            patterns: z.ZodDefault<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+            path: z.ZodDefault<z.ZodPreprocess<z.ZodString>>;
+            gitignore: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            expandDirectories: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            ignoreFiles: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
+            cwd: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+            maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ patterns, path }: GlobInputSchema): string;

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;;;;;;;;;iBAkFtB,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",
 };
@@ -63,18 +81,23 @@ export const inputSchema = z.object({
         }
         return val;
     }, z.union([z.string(), z.array(z.string())]))
+        .default("**/*")
         .describe("Glob patterns to search for (e.g., '*.ts', '**/*.test.ts', 'src/**/*.js')"),
     path: z
         .preprocess((val) => (val === null || val === undefined ? process.cwd() : val), z.string())
+        .default(process.cwd())
         .describe("Base directory to search in"),
     gitignore: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Respect ignore patterns in .gitignore files. (default: true)"),
     recursive: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Search recursively. (default: true)"),
     expandDirectories: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Automatically expand directories to files. (default: true)"),
     ignoreFiles: z
         .preprocess((val) => {
@@ -98,12 +121,15 @@ export const inputSchema = z.object({
         }
         return converted;
     }, z.union([z.string(), z.array(z.string())]).nullable())
+        .default(null)
         .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())
+        .default(null)
         .describe("Current working directory override. (default: process.cwd())"),
     maxResults: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe("Maximum number of files to return. Set to 0 for no limit. (Default: 100)"),
 });
 export const createGlobTool = () => {
@@ -125,27 +151,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 ?? null, recursive ?? null, expandDirectories ?? null, ignoreFiles ?? null, cwd ?? null);
+            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

@@ -6,13 +6,13 @@ export declare const GrepTool: {
 declare const inputSchema: z.ZodObject<{
     pattern: z.ZodString;
     path: z.ZodString;
-    recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-    contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    ignoreCase: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    filePattern: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+    contextLines: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    searchIgnored: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    literal: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
 }, z.core.$strip>;
 type GrepInputSchema = z.infer<typeof inputSchema>;
 export declare const createGrepTool: () => {
@@ -21,13 +21,13 @@ export declare const createGrepTool: () => {
         inputSchema: z.ZodObject<{
             pattern: z.ZodString;
             path: z.ZodString;
-            recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-            contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-            searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            ignoreCase: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            filePattern: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+            contextLines: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            searchIgnored: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            literal: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }: GrepInputSchema): string;

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;;;;;;;;;;iBA2Cf,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

@@ -16,24 +16,31 @@ const inputSchema = z.object({
     path: z.string().describe("The path to search in"),
     recursive: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Search recursively. (default: true))"),
     ignoreCase: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Use case-sensitive search. (default: false)"),
     filePattern: z
         .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
+        .default(null)
         .describe("Glob pattern to filter files (e.g., '*.ts', '**/*.test.js'). (Default: no filtering)"),
     contextLines: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe("The number of context lines needed in search results. (Default: 0)"),
     searchIgnored: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Search ignored files. (Default: false)"),
     literal: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Pass true for fixed-string search (-F), false for regex, (Default: auto-detects unbalanced patterns like mismatched parentheses/brackets.)"),
     maxResults: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe("Maximum number of matches to return. Set to 0 for no limit. (Default: 100)"),
 });
 export const createGrepTool = () => {
@@ -133,39 +140,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 +199,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 +511,6 @@ export function truncateMatches(matches, maxResults) {
                 matchesKept++;
             }
             else {
-                break;
             }
         }
         else if (match.isContext) {