🤖 refactor: remove line_offset from insert tool

Generated with

Author: ammar-agent

src/services/tools/file_edit_insert.test.ts

@@ -96,18 +96,18 @@ describe("file_edit_insert tool", () => {
     }
   });
 
-  it("creates new file when create flag and line_offset provided", async () => {
-    const newFile = path.join(testDir, "new.txt");
+  it("fails when no guards are provided", async () => {
     const tool = createTestTool(testDir);
     const args: FileEditInsertToolArgs = {
-      file_path: path.relative(testDir, newFile),
-      content: "Hello world!\n",
-      line_offset: 0,
-      create: true,
+      file_path: path.relative(testDir, testFilePath),
+      content: "noop",
     };
 
     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");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Provide either a before or after guard");
+    }
   });
+
 });

src/services/tools/file_edit_insert.ts

@@ -1,13 +1,10 @@
 import { tool } from "ai";
-import { RuntimeError } from "@/runtime/Runtime";
 import type { FileEditInsertToolArgs, FileEditInsertToolResult } from "@/types/tools";
 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 { executeFileEditOperation } from "./file_edit_operation";
-import { fileExists } from "@/utils/runtime/fileExists";
-import { writeFileString } from "@/utils/runtime/helpers";
 
 const READ_AND_RETRY_NOTE = `${EDIT_FAILED_NOTE_PREFIX} ${NOTE_READ_FILE_RETRY}`;
 
@@ -26,7 +23,6 @@ interface InsertOperationFailure {
 interface InsertContentOptions {
   before?: string;
   after?: string;
-  lineOffset?: number;
 }
 
 interface GuardResolutionSuccess {
@@ -49,7 +45,7 @@ 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, line_offset, create, before, after }: FileEditInsertToolArgs,
+      { file_path, content, before, after }: FileEditInsertToolArgs,
       { abortSignal }
     ): Promise<FileEditInsertToolResult> => {
       try {
@@ -64,39 +60,6 @@ export const createFileEditInsertTool: ToolFactory = (config: ToolConfiguration)
           };
         }
 
-        if (line_offset !== undefined && line_offset < 0) {
-          return {
-            success: false,
-            error: `line_offset must be non-negative (got ${line_offset})`,
-            note: `${EDIT_FAILED_NOTE_PREFIX} The line_offset must be >= 0.`,
-          };
-        }
-
-        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, "", abortSignal);
-          } catch (err) {
-            if (err instanceof RuntimeError) {
-              return {
-                success: false,
-                error: err.message,
-              };
-            }
-            throw err;
-          }
-        }
-
         return executeFileEditOperation({
           config,
           filePath: file_path,
@@ -105,7 +68,6 @@ export const createFileEditInsertTool: ToolFactory = (config: ToolConfiguration)
             insertContent(originalContent, content, {
               before,
               after,
-              lineOffset: line_offset,
             }),
         });
       } catch (error) {
@@ -131,21 +93,17 @@ function insertContent(
   contentToInsert: string,
   options: InsertContentOptions
 ): InsertOperationSuccess | InsertOperationFailure {
-  const { before, after, lineOffset } = options;
+  const { before, after } = options;
 
   if (before !== undefined && after !== undefined) {
     return guardFailure("Provide only one of before or after (not both).");
   }
 
-  if (before !== undefined || after !== undefined) {
-    return insertWithGuards(originalContent, contentToInsert, { before, after });
+  if (before === undefined && after === undefined) {
+    return guardFailure("Provide either a before or after guard to anchor the insertion point.");
   }
 
-  if (lineOffset === undefined) {
-    return guardFailure("line_offset must be provided when before/after guards are omitted.");
-  }
-
-  return insertWithLineOffset(originalContent, contentToInsert, lineOffset);
+  return insertWithGuards(originalContent, contentToInsert, { before, after });
 }
 
 function insertWithGuards(
@@ -212,76 +170,3 @@ function resolveGuardAnchor(
 
   return guardFailure("Unable to determine insertion point from guards.");
 }
-
-function insertWithLineOffset(
-  originalContent: string,
-  contentToInsert: string,
-  lineOffset: number
-): InsertOperationSuccess | InsertOperationFailure {
-  const lineCount = countLines(originalContent);
-  if (lineOffset > lineCount) {
-    return {
-      success: false,
-      error: `line_offset ${lineOffset} is beyond file length (${lineCount} lines)`,
-      note: `${EDIT_FAILED_NOTE_PREFIX} The file has ${lineCount} lines. ${NOTE_READ_FILE_RETRY}`,
-    };
-  }
-
-  const insertionIndex = getIndexForLineOffset(originalContent, lineOffset);
-  if (insertionIndex === null) {
-    return guardFailure(`Unable to compute insertion point for line_offset ${lineOffset}.`);
-  }
-
-  const newContent =
-    originalContent.slice(0, insertionIndex) +
-    contentToInsert +
-    originalContent.slice(insertionIndex);
-
-  return {
-    success: true,
-    newContent,
-    metadata: {},
-  };
-}
-
-function getIndexForLineOffset(content: string, lineOffset: number): number | null {
-  if (lineOffset === 0) {
-    return 0;
-  }
-
-  let linesAdvanced = 0;
-  let cursor = 0;
-
-  while (linesAdvanced < lineOffset) {
-    const nextNewline = content.indexOf("\n", cursor);
-    if (nextNewline === -1) {
-      if (linesAdvanced + 1 === lineOffset) {
-        return content.length;
-      }
-      return null;
-    }
-
-    linesAdvanced += 1;
-    cursor = nextNewline + 1;
-
-    if (linesAdvanced === lineOffset) {
-      return cursor;
-    }
-  }
-
-  return null;
-}
-
-function countLines(content: string): number {
-  if (content.length === 0) {
-    return 1;
-  }
-
-  let count = 1;
-  for (const char of content) {
-    if (char === "\n") {
-      count += 1;
-    }
-  }
-  return count;
-}

src/types/tools.ts

@@ -74,12 +74,6 @@ export interface FileEditErrorResult {
 export interface FileEditInsertToolArgs {
   file_path: string;
   content: string;
-  /**
-   * Optional line offset fallback when guards are not provided.
-   * 1-indexed: 0 inserts at the top, 1 after line 1, etc.
-   */
-  line_offset?: number;
-  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

@@ -110,26 +110,13 @@ export const TOOL_DEFINITIONS = {
   },
   file_edit_insert: {
     description:
-      "Insert content into a file using either a line offset or substring guards. " +
-      "Provide at least one of before/after/line_offset so the operation is anchored. " +
-      "When using guards, supply exactly one of before or after (not both). " +
+      "Insert content into a file using substring guards. " +
+      "Provide exactly one of before or after to anchor the operation. " +
       `Optional before/after substrings must uniquely match surrounding content. ${TOOL_EDIT_WARNING}`,
     schema: z
       .object({
         file_path: z.string().describe("The absolute path to the file to edit"),
         content: z.string().describe("The content to insert"),
-        line_offset: z
-          .number()
-          .int()
-          .min(0)
-          .optional()
-          .describe(
-            "Optional 1-indexed line position (0 = insert at top, 1 inserts after line 1, etc.)"
-          ),
-        create: z
-          .boolean()
-          .optional()
-          .describe("If true, create the file if it doesn't exist (default: false)"),
         before: z
           .string()
           .min(1)
@@ -141,15 +128,10 @@ export const TOOL_DEFINITIONS = {
           .optional()
           .describe("Optional substring that must appear immediately after the insertion point"),
       })
-      .refine(
-        (data) =>
-          data.line_offset !== undefined || data.before !== undefined || data.after !== undefined,
-        {
-          message:
-            "Provide at least one of line_offset, before, or after to anchor the insertion point.",
-          path: ["line_offset"],
-        }
-      )
+      .refine((data) => data.before !== undefined || data.after !== undefined, {
+        message: "Provide either before or after to anchor the insertion point.",
+        path: ["before"],
+      })
       .refine((data) => !(data.before !== undefined && data.after !== undefined), {
         message: "Provide only one of before or after (not both).",
         path: ["before"],