@travisennis/acai 0.0.9 → 0.0.11

package/dist/tools/dynamic-tool-loader.d.ts

@@ -16,7 +16,7 @@ declare const toolMetadataSchema: z.ZodObject<{
     }, z.core.$strip>>;
     needsApproval: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
-export type ToolMetadata = z.infer<typeof toolMetadataSchema>;
+type ToolMetadata = z.infer<typeof toolMetadataSchema>;
 export declare function parseToolMetadata(output: string): ToolMetadata;
 interface DynamicToolObject {
     toolDef: {
@@ -24,13 +24,10 @@ interface DynamicToolObject {
         inputSchema: any;
     };
     execute: (input: Record<string, unknown>, options: ToolExecutionOptions) => Promise<string>;
-    ask?: (input: Record<string, unknown>, options: ToolExecutionOptions) => Promise<{
-        approve: boolean;
-        reason?: string;
-    }>;
 }
-export declare function loadDynamicTools({ baseDir }: {
+export declare function loadDynamicTools({ baseDir, existingToolNames, }: {
     baseDir: string;
+    existingToolNames?: string[];
 }): Promise<Record<string, DynamicToolObject>>;
 export {};
 //# sourceMappingURL=dynamic-tool-loader.d.ts.map

package/dist/tools/dynamic-tool-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D;AA2LD,UAAU,iBAAiB;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QAEpB,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,GAAG,CAAC,EAAE,CACJ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAwCD,wBAAsB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,8CAgEtE"}
+{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,KAAK,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEvD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D;AA2LD,UAAU,iBAAiB;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QAEpB,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB;AAwCD,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,iBAAsB,GACvB,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,8CA2FA"}

package/dist/tools/dynamic-tool-loader.js

@@ -3,8 +3,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { z } from "zod";
-import { config } from "../config.js";
-import { logger } from "../logger.js";
+import { config } from "../config/index.js";
+import { logger } from "../utils/logger.js";
 // Tool Metadata Schema and Parser
 const toolMetadataSchema = z.object({
     name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_-]*$/),
@@ -183,7 +183,7 @@ async function spawnChildProcess(scriptPath, params, abortSignal) {
 }
 function createDynamicTool(scriptPath, metadata) {
     const inputSchema = generateZodSchema(metadata.parameters);
-    const toolName = `dynamic-${metadata.name}`;
+    const toolName = metadata.name;
     return {
         [toolName]: {
             toolDef: {
@@ -208,7 +208,7 @@ function createDynamicTool(scriptPath, metadata) {
         },
     };
 }
-export async function loadDynamicTools({ baseDir }) {
+export async function loadDynamicTools({ baseDir, existingToolNames = [], }) {
     const projectConfig = await config.getConfig();
     const dynamicConfig = projectConfig.tools.dynamicTools;
     if (!dynamicConfig.enabled) {
@@ -260,8 +260,24 @@ export async function loadDynamicTools({ baseDir }) {
         }
     }
     const tools = {};
+    const conflictingTools = [];
     for (const [_, { path, metadata }] of toolMap) {
+        const toolName = metadata.name;
+        // Check for conflicts with existing tools
+        if (existingToolNames.includes(toolName)) {
+            conflictingTools.push(toolName);
+            logger.warn(`Dynamic tool '${toolName}' conflicts with existing tool. Skipping.`);
+            continue;
+        }
+        // Check for duplicate dynamic tool names
+        if (tools[toolName]) {
+            logger.warn(`Duplicate dynamic tool name '${toolName}' found. Skipping duplicate.`);
+            continue;
+        }
         Object.assign(tools, createDynamicTool(path, metadata));
     }
+    if (conflictingTools.length > 0) {
+        logger.warn(`Warning: ${conflictingTools.length} dynamic tool(s) skipped due to name conflicts: ${conflictingTools.join(", ")}`);
+    }
     return tools;
 }

package/dist/tools/edit-file.d.ts

@@ -1,28 +1,28 @@
 import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const EditFileTool: {
     name: "Edit";
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
-    edits: z.ZodArray<z.ZodObject<{
+    edits: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
         oldText: z.ZodString;
         newText: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 type EditFileInputSchema = z.infer<typeof inputSchema>;
-export declare const createEditFileTool: ({ workingDir, allowedDirs, }: {
-    workingDir: string;
-    allowedDirs?: string[];
+export declare const createEditFileTool: (options: {
+    workspace: WorkspaceContext;
 }) => Promise<{
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
             path: z.ZodString;
-            edits: z.ZodArray<z.ZodObject<{
+            edits: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
                 oldText: z.ZodString;
                 newText: z.ZodString;
-            }, z.core.$strip>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
     };
     display({ path, edits }: EditFileInputSchema): string;

package/dist/tools/edit-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;iBAcf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,8BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;6BAa4B,mBAAmB;6BAIzB,mBAAmB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAqBrB,CAAC;AAyBF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAsDjB"}
+{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAIF,QAAA,MAAM,WAAW;;;;;;iBAqCf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;6BAY4B,mBAAmB;6BAKzB,mBAAmB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6BrB,CAAC;AAiDF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAgQD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAqEjB"}

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,93 +75,273 @@ 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");
+}
+/** Restore original line endings after processing */
+function restoreLineEndings(text, ending) {
+    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
 }
-function createUnifiedDiff(originalContent, newContent, filepath = "file") {
-    // Ensure consistent line endings for diff
-    const normalizedOriginal = normalizeLineEndings(originalContent);
-    const normalizedNew = normalizeLineEndings(newContent);
+/** 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;
-    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 applyEditWithLlmFix(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 {
-            throw new Error("oldText not found in content");
+        // 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,
+            };
+        }
+        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,
+            };
         }
     }
-    // Create unified diff (createUnifiedDiff normalizes line endings internally for diffing)
-    const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
-    // Format diff with appropriate number of backticks
+    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;
     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);
+    // 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;
+    // 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");
         }
-        // Write the modified content with signal
-        await writeFile(filePath, modifiedContent, {
+        await writeFile(filePath, finalContent, {
             encoding: "utf-8",
             signal: abortSignal,
         });
     }
-    return formattedDiff;
-}
-/**
- * Applies a single edit
- */
-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 };
-    }
-    return { success: false, content };
-}
-/**
- * Applies a literal search and replace operation
- */
-function applyLiteralEdit(content, search, replace) {
-    let modifiedContent = content;
-    let matchCount = 0;
-    let currentIndex = 0;
-    while (currentIndex < modifiedContent.length) {
-        const matchIndex = modifiedContent.indexOf(search, currentIndex);
-        if (matchIndex === -1) {
-            break;
-        }
-        matchCount++;
-        // Apply the replacement
-        modifiedContent =
-            modifiedContent.slice(0, matchIndex) +
-                replace +
-                modifiedContent.slice(matchIndex + search.length);
-        // Move current index past the replacement
-        currentIndex = matchIndex + replace.length;
-    }
-    return { matchCount, content: modifiedContent };
+    return result;
 }

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;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"}