🤖 fix: allow file_edit_insert to create files

Generated with

Author: ammar-agent

src/services/tools/file_edit_insert.test.ts

@@ -96,6 +96,20 @@ describe("file_edit_insert tool", () => {
     }
   });
 
+  it("creates new file when create flag is provided", async () => {
+    const newFile = path.join(testDir, "new.txt");
+    const tool = createTestTool(testDir);
+    const args: FileEditInsertToolArgs = {
+      file_path: path.relative(testDir, newFile),
+      content: "Hello world!\n",
+      create: true,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as FileEditInsertToolResult;
+    expect(result.success).toBe(true);
+    expect(await fs.readFile(newFile, "utf-8")).toBe("Hello world!\n");
+  });
+
   it("fails when no guards are provided", async () => {
     const tool = createTestTool(testDir);
     const args: FileEditInsertToolArgs = {

src/services/tools/file_edit_insert.ts

@@ -3,8 +3,11 @@ import type { FileEditInsertToolArgs, FileEditInsertToolResult } from "@/types/t
 import { EDIT_FAILED_NOTE_PREFIX, NOTE_READ_FILE_RETRY } from "@/types/tools";
 import type { ToolConfiguration, ToolFactory } from "@/utils/tools/tools";
 import { TOOL_DEFINITIONS } from "@/utils/tools/toolDefinitions";
-import { validateAndCorrectPath, validatePathInCwd } from "./fileCommon";
+import { generateDiff, validateAndCorrectPath, validatePathInCwd } from "./fileCommon";
 import { executeFileEditOperation } from "./file_edit_operation";
+import { fileExists } from "@/utils/runtime/fileExists";
+import { writeFileString } from "@/utils/runtime/helpers";
+import { RuntimeError } from "@/runtime/Runtime";
 
 const READ_AND_RETRY_NOTE = `${EDIT_FAILED_NOTE_PREFIX} ${NOTE_READ_FILE_RETRY}`;
 
@@ -45,11 +48,15 @@ export const createFileEditInsertTool: ToolFactory = (config: ToolConfiguration)
     description: TOOL_DEFINITIONS.file_edit_insert.description,
     inputSchema: TOOL_DEFINITIONS.file_edit_insert.schema,
     execute: async (
-      { file_path, content, before, after }: FileEditInsertToolArgs,
+      { file_path, content, before, after, create }: FileEditInsertToolArgs,
       { abortSignal }
     ): Promise<FileEditInsertToolResult> => {
       try {
-        const { correctedPath } = validateAndCorrectPath(file_path, config.cwd, config.runtime);
+        const { correctedPath, warning: pathWarning } = validateAndCorrectPath(
+          file_path,
+          config.cwd,
+          config.runtime
+        );
         file_path = correctedPath;
 
         const pathValidation = validatePathInCwd(file_path, config.cwd, config.runtime);
@@ -60,6 +67,38 @@ export const createFileEditInsertTool: ToolFactory = (config: ToolConfiguration)
           };
         }
 
+        const resolvedPath = config.runtime.normalizePath(file_path, config.cwd);
+        const exists = await fileExists(config.runtime, resolvedPath, abortSignal);
+
+        if (!exists) {
+          if (!create) {
+            return {
+              success: false,
+              error: `File not found: ${file_path}. Set create: true to create it.`,
+              note: `${EDIT_FAILED_NOTE_PREFIX} File does not exist. Set create: true to create it, or check the file path.`,
+            };
+          }
+
+          try {
+            await writeFileString(config.runtime, resolvedPath, content, abortSignal);
+          } catch (err) {
+            if (err instanceof RuntimeError) {
+              return {
+                success: false,
+                error: err.message,
+              };
+            }
+            throw err;
+          }
+
+          const diff = generateDiff(resolvedPath, "", content);
+          return {
+            success: true,
+            diff,
+            ...(pathWarning && { warning: pathWarning }),
+          };
+        }
+
         return executeFileEditOperation({
           config,
           filePath: file_path,

src/types/tools.ts

@@ -74,6 +74,8 @@ export interface FileEditErrorResult {
 export interface FileEditInsertToolArgs {
   file_path: string;
   content: string;
+  /** When true, create the file if it doesn't exist */
+  create?: boolean;
   /** Optional substring that must appear immediately before the insertion point */
   before?: string;
   /** Optional substring that must appear immediately after the insertion point */

src/utils/tools/toolDefinitions.ts

@@ -115,12 +115,14 @@ export const TOOL_DEFINITIONS = {
   file_edit_insert: {
     description:
       "Insert content into a file using substring guards. " +
-      "Provide exactly one of before or after to anchor the operation. " +
+      "Provide exactly one of before or after to anchor the operation when editing an existing file. " +
+      "Set create: true to write a brand new file without guards. " +
       `Optional before/after substrings must uniquely match surrounding content. ${TOOL_EDIT_WARNING}`,
     schema: z
       .object({
         file_path: FILE_EDIT_FILE_PATH,
         content: z.string().describe("The content to insert"),
+        create: z.boolean().optional().describe("If true, create the file if it does not exist"),
         before: z
           .string()
           .min(1)
@@ -132,10 +134,14 @@ export const TOOL_DEFINITIONS = {
           .optional()
           .describe("Optional substring that must appear immediately after the insertion point"),
       })
-      .refine((data) => data.before !== undefined || data.after !== undefined, {
-        message: "Provide either before or after to anchor the insertion point.",
-        path: ["before"],
-      })
+      .refine(
+        (data) => data.create === true || data.before !== undefined || data.after !== undefined,
+        {
+          message:
+            "Provide before or after when editing existing files, or set create: true to write a new file.",
+          path: ["before"],
+        }
+      )
       .refine((data) => !(data.before !== undefined && data.after !== undefined), {
         message: "Provide only one of before or after (not both).",
         path: ["before"],