Method execute

src/tools/filesystem/edit.ts:21–134

(args: z.infer<typeof ArgsSchema>, ctx: ToolContext)

  argsSchema = ArgsSchema;

  async execute(args: z.infer<typeof ArgsSchema>, ctx: ToolContext): Promise<ToolResult> {
    const abs = path.isAbsolute(args.path) ? args.path : path.resolve(ctx.cwd, args.path);
    const rel = path.relative(ctx.cwd, abs);

    let content: string;
    try {
      content = await fs.readFile(abs, 'utf-8');
    } catch (e: any) {
      if (e.code === 'ENOENT') {
        const { notFoundWithSuggestions } = await import('./suggest-paths.js');
        const msg = await notFoundWithSuggestions(
          ctx.cwd, args.path,
          `[FILE_NOT_FOUND] ${args.path} doesn't exist. Use write_file to create it, or check the path with ls.`,
        );
        return { content: msg, isError: true };
      }
      return { content: `[ERROR] Cannot read ${args.path}: ${e.message}`, isError: true };
    }

    if (args.old_string === args.new_string) {
      return { content: `[ERROR] old_string and new_string are identical — nothing to do.`, isError: true };
    }

    const { findMatch, reindentReplacement } = await import('./fuzzy-match.js');

    let updated: string;
    let occurrences: number;
    let tierNote = '';

    // replace_all keeps exact semantics (it's an explicit "every occurrence" op);
    // fuzzy only applies to the single-match path where drift is the usual cause
    // of failure.
    if (args.replace_all) {
      occurrences = content.split(args.old_string).length - 1;
      if (occurrences === 0) {
        return {
          content: `[STRING_NOT_FOUND] old_string was not found in ${rel} (replace_all). ` +
            `For a single fuzzy-tolerant edit, omit replace_all.`,
          isError: true,
        };
      }
      updated = content.split(args.old_string).join(args.new_string);
    } else {
      const match = findMatch(content, args.old_string, { allowFuzzy: true });
      if (!match) {
        // Helpful approximate-line hints, same as before.
        const lines = content.split('\n');
        const firstLine = args.old_string.split('\n')[0]?.trim();
        const hints: string[] = [];
        if (firstLine && firstLine.length > 3) {
          for (let i = 0; i < lines.length; i++) {
            if (lines[i]?.trim().startsWith(firstLine.slice(0, Math.min(40, firstLine.length)))) {
              hints.push(`  Line ${i + 1}: ${lines[i]?.trim().slice(0, 80)}`);
              if (hints.length >= 3) break;
            }
          }
        }
        return {