@travisennis/acai 0.0.5 → 0.0.6

package/dist/tools/index.js

@@ -1,206 +1,313 @@
-import { createAgentTools } from "./agent.js";
-import { createBashTool } from "./bash.js";
-import { createCodeInterpreterTool } from "./code-interpreter.js";
-import { createDeleteFileTool } from "./delete-file.js";
-// import { createDirectoryTreeTool } from "./directory-tree.ts";
+import { tool } from "ai";
+import { AdvancedEditFileTool, createAdvancedEditFileTool, } from "./advanced-edit-file.js";
+import { AgentTool, createAgentTools } from "./agent.js";
+import { BashTool, createBashTool } from "./bash.js";
+import { CodeInterpreterTool, createCodeInterpreterTool, } from "./code-interpreter.js";
+import { createDeleteFileTool, DeleteFileTool } from "./delete-file.js";
+import { createDirectoryTreeTool, DirectoryTreeTool, } from "./directory-tree.js";
 import { loadDynamicTools } from "./dynamic-tool-loader.js";
-import { createEditFileTool } from "./edit-file.js";
-import { createGrepTool } from "./grep.js";
-import { createMoveFileTool } from "./move-file.js";
-import { createReadFileTool } from "./read-file.js";
-import { createReadMultipleFilesTool } from "./read-multiple-files.js";
-import { createSaveFileTool } from "./save-file.js";
-import { createThinkTool } from "./think.js";
-import { createWebFetchTool } from "./web-fetch.js";
-import { createWebSearchTool } from "./web-search.js";
-const sendDataHandler = (events) => {
-    const msgStore = events;
-    return (msg) => {
-        if (msgStore.has(msg.id)) {
-            msgStore.get(msg.id)?.push(msg);
-        }
-        else {
-            msgStore.set(msg.id, [msg]);
-        }
-    };
-};
-export async function initTools({ terminal, tokenCounter, events, toolExecutor, }) {
-    const sendDataFn = sendDataHandler(events);
+import { createEditFileTool, EditFileTool } from "./edit-file.js";
+import { createGlobTool, GlobTool } from "./glob.js";
+import { createGrepTool, GrepTool } from "./grep.js";
+import { createMoveFileTool, MoveFileTool } from "./move-file.js";
+import { createReadFileTool, ReadFileTool } from "./read-file.js";
+import { createReadMultipleFilesTool, ReadMultipleFilesTool, } from "./read-multiple-files.js";
+import { createSaveFileTool, SaveFileTool } from "./save-file.js";
+import { createThinkTool, ThinkTool } from "./think.js";
+import { createWebFetchTool, WebFetchTool } from "./web-fetch.js";
+import { createWebSearchTool, WebSearchTool } from "./web-search.js";
+export async function initTools({ tokenCounter, workspace, modelManager, tokenTracker, }) {
     const readFileTool = await createReadFileTool({
-        workingDir: process.cwd(),
-        sendData: sendDataFn,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
         tokenCounter,
     });
     const readMultipleFilesTool = await createReadMultipleFilesTool({
-        workingDir: process.cwd(),
-        sendData: sendDataFn,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
         tokenCounter,
     });
     const editFileTool = await createEditFileTool({
-        workingDir: process.cwd(),
-        terminal,
-        sendData: sendDataFn,
-        toolExecutor,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
+        modelManager,
+        tokenTracker,
+    });
+    const advancedEditFileTool = await createAdvancedEditFileTool({
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
     });
     const saveFileTool = await createSaveFileTool({
-        workingDir: process.cwd(),
-        sendData: sendDataFn,
-        terminal,
-        toolExecutor,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
     });
     const moveFileTool = await createMoveFileTool({
-        workingDir: process.cwd(),
-        sendData: sendDataFn,
-    });
-    // const directoryTreeTool = await createDirectoryTreeTool({
-    //   workingDir: process.cwd(),
-    //   sendData: sendDataFn,
-    //   tokenCounter,
-    // });
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
+    });
+    const directoryTreeTool = await createDirectoryTreeTool({
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
+        tokenCounter,
+    });
     const deleteFileTool = await createDeleteFileTool({
-        workingDir: process.cwd(),
-        sendData: sendDataFn,
-        terminal,
-        toolExecutor,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
+    });
+    const codeInterpreterTool = await createCodeInterpreterTool({
+        tokenCounter,
     });
-    const codeInterpreterTool = createCodeInterpreterTool({
-        sendData: sendDataFn,
+    const globTool = createGlobTool({
+        tokenCounter,
     });
     const grepTool = createGrepTool({
-        sendData: sendDataFn,
         tokenCounter,
     });
-    const thinkTool = createThinkTool({
-        sendData: sendDataFn,
-    });
+    const thinkTool = createThinkTool();
     const webFetchTool = createWebFetchTool({
-        sendData: sendDataFn,
         tokenCounter,
     });
     const webSearchTool = createWebSearchTool({
-        sendData: sendDataFn,
         tokenCounter,
     });
     const bashTool = await createBashTool({
-        baseDir: process.cwd(),
-        sendData: sendDataFn,
+        baseDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
         tokenCounter,
-        terminal,
-        toolExecutor,
     });
     const dynamicTools = await loadDynamicTools({
-        baseDir: process.cwd(),
-        sendData: sendDataFn,
+        baseDir: workspace.primaryDir,
     });
+    // Build tools object for AI SDK
     const tools = {
-        ...readFileTool,
-        ...readMultipleFilesTool,
-        ...editFileTool,
-        ...saveFileTool,
-        ...moveFileTool,
-        // ...directoryTreeTool,
-        ...deleteFileTool,
-        ...codeInterpreterTool,
-        ...grepTool,
-        ...thinkTool,
-        ...webFetchTool,
-        ...bashTool,
-        ...webSearchTool,
-        ...dynamicTools,
+        [EditFileTool.name]: tool(editFileTool.toolDef),
+        [AdvancedEditFileTool.name]: tool(advancedEditFileTool.toolDef),
+        [BashTool.name]: tool(bashTool.toolDef),
+        [SaveFileTool.name]: tool(saveFileTool.toolDef),
+        [DeleteFileTool.name]: tool(deleteFileTool.toolDef),
+        [MoveFileTool.name]: tool(moveFileTool.toolDef),
+        [ReadFileTool.name]: tool(readFileTool.toolDef),
+        [ReadMultipleFilesTool.name]: tool(readMultipleFilesTool.toolDef),
+        [GlobTool.name]: tool(globTool.toolDef),
+        [GrepTool.name]: tool(grepTool.toolDef),
+        [DirectoryTreeTool.name]: tool(directoryTreeTool.toolDef),
+        [CodeInterpreterTool.name]: tool(codeInterpreterTool.toolDef),
+        [ThinkTool.name]: tool(thinkTool.toolDef),
+        [WebFetchTool.name]: tool(webFetchTool.toolDef),
+        [WebSearchTool.name]: tool(webSearchTool.toolDef),
+        // Add dynamic tools - they already have toolDef structure
+        ...Object.fromEntries(Object.entries(dynamicTools).map(([name, toolObj]) => [
+            name,
+            tool(toolObj.toolDef),
+        ])),
+    };
+    // Build executors map for manual loop
+    const executors = new Map();
+    // Add bash tool
+    executors.set(BashTool.name, bashTool.execute);
+    // Add editFile tool
+    executors.set(EditFileTool.name, editFileTool.execute);
+    // Add advancedEditFile tool
+    executors.set(AdvancedEditFileTool.name, advancedEditFileTool.execute);
+    // Add saveFile tool
+    executors.set(SaveFileTool.name, saveFileTool.execute);
+    // Add deleteFile tool
+    executors.set(DeleteFileTool.name, deleteFileTool.execute);
+    // Add moveFile tool
+    executors.set(MoveFileTool.name, moveFileTool.execute);
+    // Add readFile tool
+    executors.set(ReadFileTool.name, readFileTool.execute);
+    // Add readMultipleFiles tool
+    executors.set(ReadMultipleFilesTool.name, readMultipleFilesTool.execute);
+    // Add glob tool
+    executors.set(GlobTool.name, globTool.execute);
+    // Add grep tool
+    executors.set(GrepTool.name, grepTool.execute);
+    // Add directoryTree tool
+    executors.set(DirectoryTreeTool.name, directoryTreeTool.execute);
+    // Add webFetch tool
+    executors.set(WebFetchTool.name, webFetchTool.execute);
+    // Add webSearch tool
+    executors.set(WebSearchTool.name, webSearchTool.execute);
+    // Add think tool
+    executors.set(ThinkTool.name, thinkTool.execute);
+    // Add codeInterpreter tool
+    executors.set(CodeInterpreterTool.name, codeInterpreterTool.execute);
+    // Add dynamic tools to executors
+    for (const [name, toolObj] of Object.entries(dynamicTools)) {
+        executors.set(name, toolObj.execute);
+    }
+    return {
+        toolDefs: tools,
+        executors,
     };
-    return tools;
 }
-export async function initCliTools({ tokenCounter, }) {
+export async function initCliTools({ tokenCounter, workspace, modelManager, tokenTracker, }) {
     const readFileTool = await createReadFileTool({
-        workingDir: process.cwd(),
-        sendData: undefined,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
         tokenCounter,
     });
     const readMultipleFilesTool = await createReadMultipleFilesTool({
-        workingDir: process.cwd(),
-        sendData: undefined,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
         tokenCounter,
     });
     const editFileTool = await createEditFileTool({
-        workingDir: process.cwd(),
-        terminal: undefined,
-        sendData: undefined,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
+        modelManager,
+        tokenTracker,
+    });
+    const advancedEditFileTool = await createAdvancedEditFileTool({
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
     });
     const saveFileTool = await createSaveFileTool({
-        workingDir: process.cwd(),
-        sendData: undefined,
-        terminal: undefined,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
     });
     const moveFileTool = await createMoveFileTool({
-        workingDir: process.cwd(),
-        sendData: undefined,
-    });
-    // const directoryTreeTool = await createDirectoryTreeTool({
-    //   workingDir: process.cwd(),
-    //   sendData: undefined,
-    //   tokenCounter,
-    // });
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
+    });
+    const directoryTreeTool = await createDirectoryTreeTool({
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
+        tokenCounter,
+    });
     const deleteFileTool = await createDeleteFileTool({
-        workingDir: process.cwd(),
-        sendData: undefined,
-        terminal: undefined,
+        workingDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
     });
-    const codeInterpreterTool = createCodeInterpreterTool({
-        sendData: undefined,
+    const codeInterpreterTool = await createCodeInterpreterTool({
+        tokenCounter,
     });
-    const grepTool = createGrepTool({
-        sendData: undefined,
+    const globTool = createGlobTool({
         tokenCounter,
     });
-    const thinkTool = createThinkTool({
-        sendData: undefined,
+    const grepTool = createGrepTool({
+        tokenCounter,
     });
+    const thinkTool = createThinkTool();
     const webFetchTool = createWebFetchTool({
-        sendData: undefined,
         tokenCounter,
     });
     const webSearchTool = createWebSearchTool({
-        sendData: undefined,
         tokenCounter,
     });
     const bashTool = await createBashTool({
-        baseDir: process.cwd(),
-        sendData: undefined,
+        baseDir: workspace.primaryDir,
+        allowedDirs: workspace.allowedDirs,
         tokenCounter,
-        terminal: undefined,
     });
     const dynamicTools = await loadDynamicTools({
-        baseDir: process.cwd(),
-        sendData: undefined,
+        baseDir: workspace.primaryDir,
+    });
+    const tools = {
+        [EditFileTool.name]: tool({
+            ...editFileTool.toolDef,
+            execute: editFileTool.execute,
+        }),
+        [AdvancedEditFileTool.name]: tool({
+            ...advancedEditFileTool.toolDef,
+            execute: advancedEditFileTool.execute,
+        }),
+        [BashTool.name]: tool({
+            ...bashTool.toolDef,
+            execute: bashTool.execute,
+        }),
+        [SaveFileTool.name]: tool({
+            ...saveFileTool.toolDef,
+            execute: saveFileTool.execute,
+        }),
+        [DeleteFileTool.name]: tool({
+            ...deleteFileTool.toolDef,
+            execute: deleteFileTool.execute,
+        }),
+        [MoveFileTool.name]: tool({
+            ...moveFileTool.toolDef,
+            execute: moveFileTool.execute,
+        }),
+        [ReadFileTool.name]: tool({
+            ...readFileTool.toolDef,
+            execute: readFileTool.execute,
+        }),
+        [ReadMultipleFilesTool.name]: tool({
+            ...readMultipleFilesTool.toolDef,
+            execute: readMultipleFilesTool.execute,
+        }),
+        [GlobTool.name]: tool({
+            ...globTool.toolDef,
+            execute: globTool.execute,
+        }),
+        [GrepTool.name]: tool({
+            ...grepTool.toolDef,
+            execute: grepTool.execute,
+        }),
+        [DirectoryTreeTool.name]: tool({
+            ...directoryTreeTool.toolDef,
+            execute: directoryTreeTool.execute,
+        }),
+        [CodeInterpreterTool.name]: tool({
+            ...codeInterpreterTool.toolDef,
+            execute: codeInterpreterTool.execute,
+        }),
+        [ThinkTool.name]: tool({
+            ...thinkTool.toolDef,
+            execute: thinkTool.execute,
+        }),
+        [WebFetchTool.name]: tool({
+            ...webFetchTool.toolDef,
+            execute: webFetchTool.execute,
+        }),
+        [WebSearchTool.name]: tool({
+            ...webSearchTool.toolDef,
+            execute: webSearchTool.execute,
+        }),
+        // Add dynamic tools with execute functions
+        ...Object.fromEntries(Object.entries(dynamicTools).map(([name, toolObj]) => [
+            name,
+            tool({
+                ...toolObj.toolDef,
+                execute: toolObj.execute,
+            }),
+        ])),
+    };
+    return {
+        toolDefs: tools,
+    };
+}
+export async function initAgents({ modelManager, tokenTracker, tokenCounter, workspace, }) {
+    const agentTools = createAgentTools({
+        modelManager,
+        tokenTracker,
+        tokenCounter,
+        workspace,
     });
     const tools = {
-        ...readFileTool,
-        ...readMultipleFilesTool,
-        ...editFileTool,
-        ...saveFileTool,
-        ...moveFileTool,
-        // ...directoryTreeTool,
-        ...deleteFileTool,
-        ...codeInterpreterTool,
-        ...grepTool,
-        ...thinkTool,
-        ...webFetchTool,
-        ...bashTool,
-        ...webSearchTool,
-        ...dynamicTools,
+        [AgentTool.name]: tool(agentTools.toolDef),
+    };
+    // Build executors map for manual loop
+    const executors = new Map();
+    executors.set(AgentTool.name, agentTools.execute);
+    return {
+        toolDefs: tools,
+        executors,
     };
-    return tools;
 }
-export async function initAgents({ modelManager, tokenTracker, tokenCounter, events, }) {
-    const sendDataFn = sendDataHandler(events);
+export async function initCliAgents({ modelManager, tokenTracker, tokenCounter, workspace, }) {
     const agentTools = createAgentTools({
         modelManager,
         tokenTracker,
         tokenCounter,
-        sendData: sendDataFn,
+        workspace,
     });
     const tools = {
-        ...agentTools,
+        [AgentTool.name]: tool({
+            ...agentTools.toolDef,
+            execute: agentTools.execute,
+        }),
     };
-    return tools;
+    return { toolDefs: tools };
 }

package/dist/tools/llm-edit-fixer.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { ModelManager } from "../models/manager.ts";
+declare const SearchReplaceEditSchema: z.ZodObject<{
+    search: z.ZodString;
+    replace: z.ZodString;
+    noChangesRequired: z.ZodBoolean;
+    explanation: z.ZodString;
+}, z.core.$strip>;
+type SearchReplaceEdit = z.infer<typeof SearchReplaceEditSchema>;
+/**
+ * Attempts to fix a failed edit by using an LLM to generate a new search and replace pair.
+ *
+ * @param instruction The instruction for what needs to be done. If not provided, will auto-generate from oldString/newString
+ * @param oldString The original string to be replaced
+ * @param newString The original replacement string
+ * @param error The error that occurred during the initial edit
+ * @param currentContent The current content of the file
+ * @param modelManager The model manager for accessing LLM models
+ * @param tokenTracker The token tracker for usage monitoring
+ * @param abortSignal An abort signal to cancel the operation
+ * @returns A corrected search and replace pair, or null if fixing failed
+ */
+export declare function fixLlmEditWithInstruction(instruction: string | undefined, oldString: string, newString: string, error: string, currentContent: string, modelManager: ModelManager | undefined, abortSignal?: AbortSignal): Promise<SearchReplaceEdit | null>;
+export {};
+//# sourceMappingURL=llm-edit-fixer.d.ts.map

package/dist/tools/llm-edit-fixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-edit-fixer.d.ts","sourceRoot":"","sources":["../../source/tools/llm-edit-fixer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAyDzD,QAAA,MAAM,uBAAuB;;;;;iBAK3B,CAAC;AAEH,KAAK,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAuEjE;;;;;;;;;;;;GAYG;AACH,wBAAsB,yBAAyB,CAC7C,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAyCnC"}

package/dist/tools/llm-edit-fixer.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+import { logger } from "../logger.js";
+const GENERATE_JSON_TIMEOUT_MS = 40000; // 40 seconds
+const EDIT_SYS_PROMPT = `
+You are an expert code-editing assistant specializing in debugging and correcting failed search-and-replace operations.
+
+# Primary Goal
+Your task is to analyze a failed edit attempt and provide a corrected \`search\` string that will match the text in the file precisely. The correction should be as minimal as possible, staying very close to the original, failed \`search\` string. Do NOT invent a completely new edit based on the instruction; your job is to fix the provided parameters.
+
+It is important that you do no try to figure out if the instruction is correct. DO NOT GIVE ADVICE. Your only goal here is to do your best to perform the search and replace task! 
+
+# Input Context
+You will be given:
+1. The high-level instruction for the original edit.
+2. The exact \`search\` and \`replace\` strings that failed.
+3. The error message that was produced.
+4. The full content of the latest version of the source file.
+
+# Rules for Correction
+1.  **Minimal Correction:** Your new \`search\` string must be a close variation of the original. Focus on fixing issues like whitespace, indentation, line endings, or small contextual differences.
+2.  **Explain the Fix:** Your \`explanation\` MUST state exactly why the original \`search\` failed and how your new \`search\` string resolves that specific failure. (e.g., "The original search failed due to incorrect indentation; the new search corrects the indentation to match the source file.").
+3.  **Preserve the \`replace\` String:** Do NOT modify the \`replace\` string unless the instruction explicitly requires it and it was the source of the error. Do not escape any characters in \`replace\`. Your primary focus is fixing the \`search\` string.
+4.  **No Changes Case:** CRUCIAL: if the change is already present in the file,  set \`noChangesRequired\` to True and explain why in the \`explanation\`. It is crucial that you only do this if the changes outline in \`replace\` are already in the file and suits the instruction.
+5.  **Exactness:** The final \`search\` field must be the EXACT literal text from the file. Do not escape characters.
+`;
+const EDIT_USER_PROMPT = `
+# Goal of the Original Edit
+<instruction>
+{instruction}
+</instruction>
+
+# Failed Attempt Details
+- **Original \`search\` parameter (failed):**
+<search>
+{old_string}
+</search>
+- **Original \`replace\` parameter:**
+<replace>
+{new_string}
+</replace>
+- **Error Encountered:**
+<error>
+{error}
+</error>
+
+# Full File Content
+<file_content>
+{current_content}
+</file_content>
+
+# Your Task
+Based on the error and the file content, provide a corrected \`search\` string that will succeed. Remember to keep your correction minimal and explain the precise reason for the failure in your \`explanation\`.
+`;
+// Zod schema for the LLM response
+const SearchReplaceEditSchema = z.object({
+    search: z.string(),
+    replace: z.string(),
+    noChangesRequired: z.boolean(),
+    explanation: z.string(),
+});
+/**
+ * Auto-generates an instruction based on edit parameters when none is provided
+ */
+function autoGenerateInstruction(oldString, newString) {
+    // Create a natural language description of the edit intent
+    const oldPreview = oldString.length > 50 ? `${oldString.slice(0, 47)}...` : oldString;
+    const newPreview = newString.length > 50 ? `${newString.slice(0, 47)}...` : newString;
+    return `Replace "${oldPreview}" with "${newPreview}"`;
+}
+/**
+ * Generates JSON with timeout and proper error handling
+ */
+async function generateJsonWithTimeout(modelManager, params, timeoutMs) {
+    try {
+        const controller = new AbortController();
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        // Combine abort signals
+        const combinedSignal = AbortSignal.any([
+            params.abortSignal ?? new AbortController().signal,
+            timeoutSignal,
+            controller.signal,
+        ]);
+        if (!modelManager) {
+            throw new Error("Edit-fix model not available");
+        }
+        const { text } = await modelManager.getText("edit-fix", params.system, params.prompt, combinedSignal);
+        // Parse the JSON response
+        try {
+            const parsed = JSON.parse(text);
+            return parsed;
+        }
+        catch (error) {
+            logger.error(error, "Failed to parse LLM response as JSON.");
+            logger.info(`Response preview: ${text.slice(0, 500)}`);
+            return null;
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.warn(`LLM edit fix operation timed out. Timeout: ${timeoutMs}ms`);
+            return null;
+        }
+        logger.error(`LLM edit fix operation failed. Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+        return null;
+    }
+}
+/**
+ * Attempts to fix a failed edit by using an LLM to generate a new search and replace pair.
+ *
+ * @param instruction The instruction for what needs to be done. If not provided, will auto-generate from oldString/newString
+ * @param oldString The original string to be replaced
+ * @param newString The original replacement string
+ * @param error The error that occurred during the initial edit
+ * @param currentContent The current content of the file
+ * @param modelManager The model manager for accessing LLM models
+ * @param tokenTracker The token tracker for usage monitoring
+ * @param abortSignal An abort signal to cancel the operation
+ * @returns A corrected search and replace pair, or null if fixing failed
+ */
+export async function fixLlmEditWithInstruction(instruction, oldString, newString, error, currentContent, modelManager, abortSignal) {
+    // If no modelManager is available, return null (LLM fix not available)
+    if (!modelManager) {
+        return null;
+    }
+    const finalInstruction = instruction || autoGenerateInstruction(oldString, newString);
+    // Generate the user prompt with substitutions
+    const userPrompt = EDIT_USER_PROMPT.replace("{instruction}", finalInstruction)
+        .replace("{old_string}", oldString)
+        .replace("{new_string}", newString)
+        .replace("{error}", error)
+        .replace("{current_content}", currentContent);
+    const result = await generateJsonWithTimeout(modelManager, {
+        system: EDIT_SYS_PROMPT,
+        prompt: userPrompt,
+        abortSignal,
+    }, GENERATE_JSON_TIMEOUT_MS);
+    // Validate the result with Zod schema
+    if (result) {
+        try {
+            const validatedResult = SearchReplaceEditSchema.parse(result);
+            logger.info("LLM edit fix successful.");
+            return validatedResult;
+        }
+        catch (validationError) {
+            logger.error(`LLM edit fix response validation failed. Error: ${validationError instanceof Error ? validationError.message : "Unknown validation error"}`);
+            console.info("Response:", result);
+        }
+    }
+    return null;
+}

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

@@ -1,14 +1,26 @@
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ToolResult } from "./types.ts";
 export declare const MoveFileTool: {
     name: "moveFile";
 };
-export declare const createMoveFileTool: ({ workingDir, sendData, }: {
+declare const inputSchema: z.ZodObject<{
+    source: z.ZodString;
+    destination: z.ZodString;
+}, z.core.$strip>;
+type MoveFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createMoveFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
 }) => Promise<{
-    moveFile: import("ai").Tool<{
-        source: string;
-        destination: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            source: z.ZodString;
+            destination: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ source, destination }: MoveFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
 //# sourceMappingURL=move-file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"move-file.d.ts","sourceRoot":"","sources":["../../source/tools/move-file.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,2BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;;;;;EAsDA,CAAC"}
+{"version":3,"file":"move-file.d.ts","sourceRoot":"","sources":["../../source/tools/move-file.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAGf,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;;;;;;;;qCAY8B,mBAAmB,+BACf,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAkDhC,CAAC"}