Function createEditTool

packages/computer/src/tools/fs/edit.ts:93–159

(options: EditToolOptions)

}

export function createEditTool(options: EditToolOptions): Tool<z.infer<typeof inputSchema>> {
  const { store } = options;
  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;

  return tool({
    description:
      "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes touch the same block, merge them into one edit.",
    inputSchema,
    execute: async (rawInput: z.infer<typeof inputSchema>) => {
      const { path, edits } = prepareArguments(rawInput);

      if (!Array.isArray(edits) || edits.length === 0) {
        return { error: "edits must contain at least one replacement." };
      }

      return withFileLock(path, async () => {
        try {
          const stat = await store.stat(path);
          if (!stat) return { error: `File not found: ${path}` };
          if (stat.size > maxBytes) {
            return {
              error: `File too large to edit: ${stat.size} bytes exceeds the ${maxBytes}-byte cap. Use the write tool to rewrite the file from scratch.`,
            };
          }

          const bytes = await store.readAll(path);
          if (!bytes) return { error: `File not found: ${path}` };

          const rawContent = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true }).decode(
            bytes,
          );
          const { bom, text } = stripBom(rawContent);
          const ending = detectLineEnding(text);
          const normalized = normalizeToLF(text);

          let baseContent: string;
          let newContent: string;
          try {
            ({ baseContent, newContent } = applyEditsToNormalizedContent(normalized, edits, path));
          } catch (err) {
            return { error: err instanceof Error ? err.message : String(err) };
          }

          const finalContent = bom + restoreLineEndings(newContent, ending);
          // Round-trip the file's mode so editing an executable script (or any
          // file with a non-default mode) doesn't silently drop bits. `stat.mode`
          // is undefined for stores that don't track modes; pass `undefined` in
          // that case so the store applies its own default.
          await store.write(path, new TextEncoder().encode(finalContent), { mode: stat.mode });

          const diffResult = generateDiffString(baseContent, newContent);
          const patch = generateUnifiedPatch(path, baseContent, newContent);

          return {
            path,
            editsApplied: edits.length,
            diff: diffResult.diff,
            patch,