Composer V2: Replace replaceInFile with editFile as the primary targeted-edit tool

src/LLMProviders/chainRunner/CopilotPlusChainRunner.ts

@@ -17,7 +17,7 @@ import { logInfo, logWarn } from "@/logger";
 import { checkIsPlusUser } from "@/plusUtils";
 import { getSettings } from "@/settings/model";
 import { getSystemPromptWithMemory } from "@/system-prompts/systemPromptBuilder";
-import { writeToFileTool } from "@/tools/ComposerTools";
+import { writeFileTool } from "@/tools/ComposerTools";
 import { ToolManager } from "@/tools/toolManager";
 import { ToolResultFormatter } from "@/tools/ToolResultFormatter";
 import { ToolRegistry } from "@/tools/ToolRegistry";
@@ -697,7 +697,7 @@ Include your extracted terms as: [SALIENT_TERMS: term1, term2, term3]`;
       contextEnvelope: userMessage.contextEnvelope,
     });
 
-    const actionStreamer = new ActionBlockStreamer(ToolManager, writeToFileTool);
+    const actionStreamer = new ActionBlockStreamer(ToolManager, writeFileTool);
 
     // Wrap the stream call with warning suppression
     const chatStream = await withSuppressedTokenWarnings(() =>

src/LLMProviders/chainRunner/utils/ActionBlockStreamer.test.ts

@@ -10,17 +10,17 @@ const MockedToolManager = ToolManager as jest.Mocked<typeof ToolManager>;
 const MockedToolResultFormatter = ToolResultFormatter as jest.Mocked<typeof ToolResultFormatter>;
 
 describe("ActionBlockStreamer", () => {
-  let writeToFileTool: any;
+  let writeFileTool: any;
   let streamer: ActionBlockStreamer;
 
   beforeEach(() => {
-    writeToFileTool = { name: "writeToFile" };
+    writeFileTool = { name: "writeFile" };
     MockedToolManager.callTool.mockClear();
 
     // Mock ToolResultFormatter to return the raw result without "File change result: " prefix
     MockedToolResultFormatter.format = jest.fn((_toolName, result) => result);
 
-    streamer = new ActionBlockStreamer(MockedToolManager, writeToFileTool);
+    streamer = new ActionBlockStreamer(MockedToolManager, writeFileTool);
   });
 
   // Helper function to process chunks and collect results
@@ -35,7 +35,7 @@ describe("ActionBlockStreamer", () => {
     return outputContents;
   }
 
-  it("should pass through chunks without writeToFile tags unchanged", async () => {
+  it("should pass through chunks without writeFile tags unchanged", async () => {
     const chunks = [{ content: "Hello " }, { content: "world, this is " }, { content: "a test." }];
     const output = await processChunks(chunks);
 
@@ -46,112 +46,112 @@ describe("ActionBlockStreamer", () => {
     expect(MockedToolManager.callTool).not.toHaveBeenCalled();
   });
 
-  it("should handle a complete writeToFile block in a single chunk", async () => {
+  it("should handle a complete writeFile block in a single chunk", async () => {
     MockedToolManager.callTool.mockResolvedValue("File written successfully.");
     const chunks = [
       {
         content:
-          "Some text before <writeToFile><path>file.txt</path><content>content</content></writeToFile> and some text after.",
+          "Some text before <writeFile><path>file.txt</path><content>content</content></writeFile> and some text after.",
       },
     ];
     const output = await processChunks(chunks);
 
     // Should yield original chunk plus tool result
     expect(output).toEqual([
-      "Some text before <writeToFile><path>file.txt</path><content>content</content></writeToFile> and some text after.",
+      "Some text before <writeFile><path>file.txt</path><content>content</content></writeFile> and some text after.",
       "\nFile written successfully.\n",
     ]);
 
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "file.txt",
       content: "content",
     });
   });
 
-  it("should handle a complete xml-wrapped writeToFile block", async () => {
+  it("should handle a complete xml-wrapped writeFile block", async () => {
     MockedToolManager.callTool.mockResolvedValue("XML file written.");
     const chunks = [
       {
         content:
-          "```xml\n<writeToFile><path>file.xml</path><content>xml content</content></writeToFile>\n```",
+          "```xml\n<writeFile><path>file.xml</path><content>xml content</content></writeFile>\n```",
       },
     ];
     const output = await processChunks(chunks);
 
     expect(output).toEqual([
-      "```xml\n<writeToFile><path>file.xml</path><content>xml content</content></writeToFile>\n```",
+      "```xml\n<writeFile><path>file.xml</path><content>xml content</content></writeFile>\n```",
       "\nXML file written.\n",
     ]);
 
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "file.xml",
       content: "xml content",
     });
   });
 
-  it("should handle a writeToFile block split across multiple chunks", async () => {
+  it("should handle a writeFile block split across multiple chunks", async () => {
     MockedToolManager.callTool.mockResolvedValue("Split file written.");
     const chunks = [
-      { content: "Here is a file <writeToFile><path>split.txt</path>" },
+      { content: "Here is a file <writeFile><path>split.txt</path>" },
       { content: "<content>split content</content>" },
-      { content: "</writeToFile> That was it." },
+      { content: "</writeFile> That was it." },
     ];
     const output = await processChunks(chunks);
 
     // All chunks should be yielded as-is, plus tool result when complete block is detected
     expect(output).toEqual([
-      "Here is a file <writeToFile><path>split.txt</path>",
+      "Here is a file <writeFile><path>split.txt</path>",
       "<content>split content</content>",
-      "</writeToFile> That was it.",
+      "</writeFile> That was it.",
       "\nSplit file written.\n",
     ]);
 
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "split.txt",
       content: "split content",
     });
   });
 
-  it("should handle multiple writeToFile blocks in the stream", async () => {
+  it("should handle multiple writeFile blocks in the stream", async () => {
     MockedToolManager.callTool
       .mockResolvedValueOnce("File 1 written.")
       .mockResolvedValueOnce("File 2 written.");
     const chunks = [
       {
         content:
-          "<writeToFile><path>f1.txt</path><content>c1</content></writeToFile>Some text<writeToFile><path>f2.txt</path><content>c2</content></writeToFile>",
+          "<writeFile><path>f1.txt</path><content>c1</content></writeFile>Some text<writeFile><path>f2.txt</path><content>c2</content></writeFile>",
       },
     ];
     const output = await processChunks(chunks);
 
     // Should yield original chunk plus both tool results
     expect(output).toEqual([
-      "<writeToFile><path>f1.txt</path><content>c1</content></writeToFile>Some text<writeToFile><path>f2.txt</path><content>c2</content></writeToFile>",
+      "<writeFile><path>f1.txt</path><content>c1</content></writeFile>Some text<writeFile><path>f2.txt</path><content>c2</content></writeFile>",
       "\nFile 1 written.\n",
       "\nFile 2 written.\n",
     ]);
 
     expect(MockedToolManager.callTool).toHaveBeenCalledTimes(2);
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "f1.txt",
       content: "c1",
     });
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "f2.txt",
       content: "c2",
     });
   });
 
   it("should handle unclosed tags without calling tools", async () => {
     const chunks = [
-      { content: "Starting... <writeToFile><path>unclosed.txt</path>" },
+      { content: "Starting... <writeFile><path>unclosed.txt</path>" },
       { content: "<content>this will not be closed" },
     ];
     const output = await processChunks(chunks);
 
     // Should yield all chunks as-is
     expect(output).toEqual([
-      "Starting... <writeToFile><path>unclosed.txt</path>",
+      "Starting... <writeFile><path>unclosed.txt</path>",
       "<content>this will not be closed",
     ]);
 
@@ -163,17 +163,17 @@ describe("ActionBlockStreamer", () => {
     MockedToolManager.callTool.mockRejectedValue(new Error("Tool error"));
     const chunks = [
       {
-        content: "<writeToFile><path>error.txt</path><content>content</content></writeToFile>",
+        content: "<writeFile><path>error.txt</path><content>content</content></writeFile>",
       },
     ];
     const output = await processChunks(chunks);
 
     expect(output).toEqual([
-      "<writeToFile><path>error.txt</path><content>content</content></writeToFile>",
+      "<writeFile><path>error.txt</path><content>content</content></writeFile>",
       "\nError: Tool error\n",
     ]);
 
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "error.txt",
       content: "content",
     });
@@ -197,12 +197,12 @@ describe("ActionBlockStreamer", () => {
     const chunks = [
       {
         content:
-          "<writeToFile><path>  spaced.txt  </path><content>  content with spaces  </content></writeToFile>",
+          "<writeFile><path>  spaced.txt  </path><content>  content with spaces  </content></writeFile>",
       },
     ];
     await processChunks(chunks);
 
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "spaced.txt",
       content: "content with spaces",
     });
@@ -212,19 +212,19 @@ describe("ActionBlockStreamer", () => {
     MockedToolManager.callTool.mockResolvedValue("Malformed handled.");
     const chunks = [
       {
-        content: "<writeToFile><path>missing-content.txt</path></writeToFile>",
+        content: "<writeFile><path>missing-content.txt</path></writeFile>",
       },
     ];
     const output = await processChunks(chunks);
 
     // Should yield chunk as-is plus tool result
     expect(output).toEqual([
-      "<writeToFile><path>missing-content.txt</path></writeToFile>",
+      "<writeFile><path>missing-content.txt</path></writeFile>",
       "\nMalformed handled.\n",
     ]);
 
     // Tool should be called with undefined content
-    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeToFileTool, {
+    expect(MockedToolManager.callTool).toHaveBeenCalledWith(writeFileTool, {
       path: "missing-content.txt",
       content: undefined,
     });

src/LLMProviders/chainRunner/utils/ActionBlockStreamer.ts

@@ -2,24 +2,24 @@ import { ToolManager } from "@/tools/toolManager";
 import { ToolResultFormatter } from "@/tools/ToolResultFormatter";
 
 /**
- * ActionBlockStreamer processes streaming chunks to detect and handle writeToFile blocks.
+ * ActionBlockStreamer processes streaming chunks to detect and handle writeFile blocks.
  *
  * 1. Accumulates chunks in a buffer
- * 2. Detects complete writeToFile blocks
- * 3. Calls the writeToFile tool when a complete block is found
+ * 2. Detects complete writeFile blocks
+ * 3. Calls the writeFile tool when a complete block is found
  * 4. Returns chunks as-is otherwise
  */
 export class ActionBlockStreamer {
   private buffer = "";
 
   constructor(
     private toolManager: typeof ToolManager,
-    private writeToFileTool: any
+    private writeFileTool: any
   ) {}
 
   private findCompleteBlock(str: string) {
     // Regex for both formats
-    const regex = /<writeToFile>[\s\S]*?<\/writeToFile>/;
+    const regex = /<writeFile>[\s\S]*?<\/writeFile>/;
     const match = str.match(regex);
 
     if (!match || match.index === undefined) {
@@ -71,13 +71,13 @@ export class ActionBlockStreamer {
 
       // Call the tool
       try {
-        const result = await this.toolManager.callTool(this.writeToFileTool, {
+        const result = await this.toolManager.callTool(this.writeFileTool, {
           path: filePath,
           content: fileContent,
         });
 
         // Format tool result using ToolResultFormatter for consistency with agent mode
-        const formattedResult = ToolResultFormatter.format("writeToFile", result);
+        const formattedResult = ToolResultFormatter.format("writeFile", result);
         yield { ...chunk, content: `\n${formattedResult}\n` };
       } catch (err: any) {
         yield { ...chunk, content: `\nError: ${err?.message || err}\n` };

src/LLMProviders/chainRunner/utils/AgentReasoningState.ts

@@ -252,8 +252,8 @@ export function summarizeToolResult(
       return "Indexed vault";
     case "updateMemory":
       return "Updated memory";
-    case "writeToFile":
-    case "replaceInFile": {
+    case "writeFile":
+    case "editFile": {
       // Parse the result to check if accepted/rejected
       const filePath = args?.path as string | undefined;
       const fileName = filePath ? filePath.split("/").pop() || filePath : "file";
@@ -269,7 +269,7 @@ export function summarizeToolResult(
       // TODO(@wenzhengjiang): Handle no-op cases (e.g., "File is too small", "Search text not found")
       // Requires ComposerTools to return structured results instead of plain strings.
       // See docs/TODO-composer-tool-redesign.md
-      return toolName === "writeToFile" ? `Wrote to "${fileName}"` : `Edited "${fileName}"`;
+      return toolName === "writeFile" ? `Wrote to "${fileName}"` : `Edited "${fileName}"`;
     }
     default:
       return "Done";
@@ -422,15 +422,15 @@ export function summarizeToolCall(
       return "Indexing vault";
     case "updateMemory":
       return "Saving to memory";
-    case "writeToFile": {
+    case "writeFile": {
       const filePath = args?.path as string | undefined;
       if (filePath) {
         const fileName = filePath.split("/").pop() || filePath;
         return `Writing to "${fileName}"`;
       }
       return "Writing to file";
     }
-    case "replaceInFile": {
+    case "editFile": {
       const filePath = args?.path as string | undefined;
       if (filePath) {
         const fileName = filePath.split("/").pop() || filePath;

src/LLMProviders/chainRunner/utils/modelAdapter.test.ts

@@ -21,13 +21,13 @@ describe("ModelAdapter", () => {
       const toolMetadata: ToolMetadata[] = [
         createToolMetadata("localSearch", "LocalSearch specific instructions"),
         createToolMetadata("webSearch", "WebSearch specific instructions"),
-        createToolMetadata("writeToFile", "WriteToFile specific instructions"),
+        createToolMetadata("writeFile", "WriteToFile specific instructions"),
       ];
 
       const enhancedPrompt = adapter.enhanceSystemPrompt(
         basePrompt,
         toolDescriptions,
-        ["localSearch", "webSearch", "writeToFile"],
+        ["localSearch", "webSearch", "writeFile"],
         toolMetadata
       );
 
@@ -44,7 +44,7 @@ describe("ModelAdapter", () => {
       const toolMetadata: ToolMetadata[] = [
         createToolMetadata("localSearch", "LocalSearch specific instructions"),
         createToolMetadata("webSearch", "WebSearch specific instructions"),
-        createToolMetadata("writeToFile", "WriteToFile specific instructions"),
+        createToolMetadata("writeFile", "WriteToFile specific instructions"),
       ];
 
       // Only pass localSearch as enabled
@@ -129,15 +129,15 @@ describe("ModelAdapter", () => {
       const enhancedPrompt = adapter.enhanceSystemPrompt(
         basePrompt,
         toolDescriptions,
-        ["replaceInFile", "writeToFile"],
+        ["editFile", "writeFile"],
         []
       );
 
       // Check for composer-specific GPT instructions (simplified without XML examples)
       expect(enhancedPrompt).toContain("FILE EDITING WITH COMPOSER TOOLS");
-      expect(enhancedPrompt).toContain("replaceInFile");
-      expect(enhancedPrompt).toContain("writeToFile");
-      expect(enhancedPrompt).toContain("SEARCH/REPLACE format");
+      expect(enhancedPrompt).toContain("editFile");
+      expect(enhancedPrompt).toContain("writeFile");
+      expect(enhancedPrompt).toContain("oldText");
     });
 
     it("should rebuild enhanceSystemPrompt output from section metadata", () => {
@@ -164,8 +164,8 @@ describe("ModelAdapter", () => {
       const enhanced = adapter.enhanceUserMessage(editMessage, true);
 
       expect(enhanced).toContain("GPT REMINDER");
-      expect(enhanced).toContain("replaceInFile");
-      expect(enhanced).toContain("SEARCH/REPLACE blocks");
+      expect(enhanced).toContain("editFile");
+      expect(enhanced).toContain("oldText/newText parameters");
     });
   });
 });