@google/gemini-cli-core 0.30.0-preview.6 → 0.31.0-preview.0

package/dist/src/tools/diff-utils.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as Diff from 'diff';
+/**
+ * Generates a snippet of the diff between two strings, including a few lines of context around the changes.
+ */
+export function getDiffContextSnippet(originalContent, newContent, contextLines = 5) {
+    if (!originalContent) {
+        return newContent;
+    }
+    const changes = Diff.diffLines(originalContent, newContent);
+    const newLines = newContent.split(/\r?\n/);
+    const ranges = [];
+    let newLineIdx = 0;
+    for (const change of changes) {
+        if (change.added) {
+            ranges.push({ start: newLineIdx, end: newLineIdx + (change.count ?? 0) });
+            newLineIdx += change.count ?? 0;
+        }
+        else if (change.removed) {
+            ranges.push({ start: newLineIdx, end: newLineIdx });
+        }
+        else {
+            newLineIdx += change.count ?? 0;
+        }
+    }
+    if (ranges.length === 0) {
+        return newContent;
+    }
+    const expandedRanges = ranges.map((r) => ({
+        start: Math.max(0, r.start - contextLines),
+        end: Math.min(newLines.length, r.end + contextLines),
+    }));
+    expandedRanges.sort((a, b) => a.start - b.start);
+    const mergedRanges = [];
+    if (expandedRanges.length > 0) {
+        let current = expandedRanges[0];
+        for (let i = 1; i < expandedRanges.length; i++) {
+            const next = expandedRanges[i];
+            if (next.start <= current.end) {
+                current.end = Math.max(current.end, next.end);
+            }
+            else {
+                mergedRanges.push(current);
+                current = next;
+            }
+        }
+        mergedRanges.push(current);
+    }
+    const outputParts = [];
+    let lastEnd = 0;
+    for (const range of mergedRanges) {
+        if (range.start > lastEnd)
+            outputParts.push('...');
+        outputParts.push(newLines.slice(range.start, range.end).join('\n'));
+        lastEnd = range.end;
+    }
+    if (lastEnd < newLines.length) {
+        outputParts.push('...');
+    }
+    return outputParts.join('\n');
+}
+//# sourceMappingURL=diff-utils.js.map

package/dist/src/tools/diff-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-utils.js","sourceRoot":"","sources":["../../../src/tools/diff-utils.ts"],"names":[],"mappings":"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"}

package/dist/src/tools/diff-utils.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/tools/diff-utils.test.js

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, expect, it } from 'vitest';
+import { getDiffContextSnippet } from './diff-utils.js';
+describe('getDiffContextSnippet', () => {
+    it('should return the whole new content if originalContent is empty', () => {
+        const original = '';
+        const modified = 'line1\nline2\nline3';
+        expect(getDiffContextSnippet(original, modified)).toBe(modified);
+    });
+    it('should return the whole content if there are no changes', () => {
+        const content = 'line1\nline2\nline3';
+        expect(getDiffContextSnippet(content, content)).toBe(content);
+    });
+    it('should show added lines with context', () => {
+        const original = '1\n2\n3\n4\n5\n6\n7\n8\n9\n10';
+        const modified = '1\n2\n3\n4\n5\nadded\n6\n7\n8\n9\n10';
+        // Default context is 5 lines.
+        expect(getDiffContextSnippet(original, modified)).toBe(modified);
+    });
+    it('should use ellipses for changes far apart', () => {
+        const original = Array.from({ length: 20 }, (_, i) => `${i + 1}`).join('\n');
+        const modified = original
+            .replace('2\n', '2\nadded1\n')
+            .replace('19', '19\nadded2');
+        const snippet = getDiffContextSnippet(original, modified, 2);
+        expect(snippet).toContain('1\n2\nadded1\n3\n4');
+        expect(snippet).toContain('...');
+        expect(snippet).toContain('18\n19\nadded2\n20');
+    });
+    it('should respect custom contextLines', () => {
+        const original = '1\n2\n3\n4\n5\n6\n7\n8\n9\n10';
+        const modified = '1\n2\n3\n4\n5\nadded\n6\n7\n8\n9\n10';
+        const snippet = getDiffContextSnippet(original, modified, 1);
+        expect(snippet).toBe('...\n5\nadded\n6\n...');
+    });
+    it('should handle multiple changes close together by merging ranges', () => {
+        const original = '1\n2\n3\n4\n5\n6\n7\n8\n9\n10';
+        const modified = '1\nadded1\n2\nadded2\n3\n4\n5\n6\n7\n8\n9\n10';
+        const snippet = getDiffContextSnippet(original, modified, 1);
+        expect(snippet).toBe('1\nadded1\n2\nadded2\n3\n...');
+    });
+    it('should handle removals', () => {
+        const original = '1\n2\n3\n4\n5\n6\n7\n8\n9\n10';
+        const modified = '1\n2\n3\n4\n6\n7\n8\n9\n10';
+        const snippet = getDiffContextSnippet(original, modified, 1);
+        expect(snippet).toBe('...\n4\n6\n...');
+    });
+});
+//# sourceMappingURL=diff-utils.test.js.map

package/dist/src/tools/diff-utils.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-utils.test.js","sourceRoot":"","sources":["../../../src/tools/diff-utils.test.ts"],"names":[],"mappings":"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"}

package/dist/src/tools/edit.d.ts

@@ -18,10 +18,15 @@ interface ReplacementResult {
     occurrences: number;
     finalOldString: string;
     finalNewString: string;
+    strategy?: 'exact' | 'flexible' | 'regex' | 'fuzzy';
+    matchRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
 }
 export declare function applyReplacement(currentContent: string | null, oldString: string, newString: string, isNewFile: boolean): string;
 export declare function calculateReplacement(config: Config, context: ReplacementContext): Promise<ReplacementResult>;
-export declare function getErrorReplaceResult(params: EditToolParams, occurrences: number, expectedReplacements: number, finalOldString: string, finalNewString: string): {
+export declare function getErrorReplaceResult(params: EditToolParams, occurrences: number, finalOldString: string, finalNewString: string): {
     display: string;
     raw: string;
     type: ToolErrorType;
@@ -43,10 +48,10 @@ export interface EditToolParams {
      */
     new_string: string;
     /**
-     * Number of replacements expected. Defaults to 1 if not specified.
-     * Use when you want to replace multiple occurrences.
+     * If true, the tool will replace all occurrences of `old_string` with `new_string`.
+     * If false (default), the tool will only succeed if exactly one occurrence is found.
      */
-    expected_replacements?: number;
+    allow_multiple?: boolean;
     /**
      * The instruction for what needs to be done.
      */

package/dist/src/tools/edit.js

@@ -8,26 +8,30 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import * as crypto from 'node:crypto';
 import * as Diff from 'diff';
-import { BaseDeclarativeTool, BaseToolInvocation, Kind, ToolConfirmationOutcome, } from './tools.js';
+import { BaseDeclarativeTool, BaseToolInvocation, Kind, } from './tools.js';
 import { ToolErrorType } from './tool-error.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import { isNodeError } from '../utils/errors.js';
 import { ApprovalMode } from '../policy/types.js';
 import { CoreToolCallStatus } from '../scheduler/types.js';
 import { DEFAULT_DIFF_OPTIONS, getDiffStat } from './diffOptions.js';
+import { getDiffContextSnippet } from './diff-utils.js';
 import {} from './modifiable-tool.js';
 import { IdeClient } from '../ide/ide-client.js';
 import { FixLLMEditWithInstruction } from '../utils/llm-edit-fixer.js';
 import { safeLiteralReplace, detectLineEnding } from '../utils/textUtils.js';
-import { EditStrategyEvent } from '../telemetry/types.js';
-import { logEditStrategy } from '../telemetry/loggers.js';
-import { EditCorrectionEvent } from '../telemetry/types.js';
-import { logEditCorrectionEvent } from '../telemetry/loggers.js';
+import { EditStrategyEvent, EditCorrectionEvent } from '../telemetry/types.js';
+import { logEditStrategy, logEditCorrectionEvent, } from '../telemetry/loggers.js';
 import { correctPath } from '../utils/pathCorrector.js';
 import { EDIT_TOOL_NAME, READ_FILE_TOOL_NAME, EDIT_DISPLAY_NAME, } from './tool-names.js';
 import { debugLogger } from '../utils/debugLogger.js';
+import levenshtein from 'fast-levenshtein';
 import { EDIT_DEFINITION } from './definitions/coreTools.js';
 import { resolveToolDeclaration } from './definitions/resolver.js';
+import { detectOmissionPlaceholders } from './omissionPlaceholderDetector.js';
+const ENABLE_FUZZY_MATCH_RECOVERY = true;
+const FUZZY_MATCH_THRESHOLD = 0.1; // Allow up to 10% weighted difference
+const WHITESPACE_PENALTY_FACTOR = 0.1; // Whitespace differences cost 10% of a character difference
 export function applyReplacement(currentContent, oldString, newString, isNewFile) {
     if (isNewFile) {
         return newString;
@@ -76,6 +80,14 @@ async function calculateExactReplacement(context) {
     const normalizedSearch = old_string.replace(/\r\n/g, '\n');
     const normalizedReplace = new_string.replace(/\r\n/g, '\n');
     const exactOccurrences = normalizedCode.split(normalizedSearch).length - 1;
+    if (!params.allow_multiple && exactOccurrences > 1) {
+        return {
+            newContent: currentContent,
+            occurrences: exactOccurrences,
+            finalOldString: normalizedSearch,
+            finalNewString: normalizedReplace,
+        };
+    }
     if (exactOccurrences > 0) {
         let modifiedCode = safeLiteralReplace(normalizedCode, normalizedSearch, normalizedReplace);
         modifiedCode = restoreTrailingNewline(currentContent, modifiedCode);
@@ -110,7 +122,7 @@ async function calculateFlexibleReplacement(context) {
             const firstLineInMatch = window[0];
             const indentationMatch = firstLineInMatch.match(/^([ \t]*)/);
             const indentation = indentationMatch ? indentationMatch[1] : '';
-            const newBlockWithIndent = replaceLines.map((line) => `${indentation}${line}`);
+            const newBlockWithIndent = applyIndentation(replaceLines, indentation);
             sourceLines.splice(i, searchLinesStripped.length, newBlockWithIndent.join('\n'));
             i += replaceLines.length;
         }
@@ -154,22 +166,20 @@ async function calculateRegexReplacement(context) {
     // The final pattern captures leading whitespace (indentation) and then matches the token pattern.
     // 'm' flag enables multi-line mode, so '^' matches the start of any line.
     const finalPattern = `^([ \t]*)${pattern}`;
-    const flexibleRegex = new RegExp(finalPattern, 'm');
-    const match = flexibleRegex.exec(currentContent);
-    if (!match) {
+    // Always use a global regex to count all potential occurrences for accurate validation.
+    const globalRegex = new RegExp(finalPattern, 'gm');
+    const matches = currentContent.match(globalRegex);
+    if (!matches) {
         return null;
     }
-    const indentation = match[1] || '';
+    const occurrences = matches.length;
     const newLines = normalizedReplace.split('\n');
-    const newBlockWithIndent = newLines
-        .map((line) => `${indentation}${line}`)
-        .join('\n');
-    // Use replace with the regex to substitute the matched content.
-    // Since the regex doesn't have the 'g' flag, it will only replace the first occurrence.
-    const modifiedCode = currentContent.replace(flexibleRegex, newBlockWithIndent);
+    // Use the appropriate regex for replacement based on allow_multiple.
+    const replaceRegex = new RegExp(finalPattern, params.allow_multiple ? 'gm' : 'm');
+    const modifiedCode = currentContent.replace(replaceRegex, (_match, indentation) => applyIndentation(newLines, indentation || '').join('\n'));
     return {
         newContent: restoreTrailingNewline(currentContent, modifiedCode),
-        occurrences: 1, // This method is designed to find and replace only the first occurrence.
+        occurrences,
         finalOldString: normalizedSearch,
         finalNewString: normalizedReplace,
     };
@@ -205,6 +215,11 @@ export async function calculateReplacement(config, context) {
         logEditStrategy(config, event);
         return regexResult;
     }
+    let fuzzyResult;
+    if (ENABLE_FUZZY_MATCH_RECOVERY &&
+        (fuzzyResult = await calculateFuzzyReplacement(config, context))) {
+        return fuzzyResult;
+    }
     return {
         newContent: currentContent,
         occurrences: 0,
@@ -212,7 +227,7 @@ export async function calculateReplacement(config, context) {
         finalNewString: normalizedReplace,
     };
 }
-export function getErrorReplaceResult(params, occurrences, expectedReplacements, finalOldString, finalNewString) {
+export function getErrorReplaceResult(params, occurrences, finalOldString, finalNewString) {
     let error = undefined;
     if (occurrences === 0) {
         error = {
@@ -221,11 +236,10 @@ export function getErrorReplaceResult(params, occurrences, expectedReplacements,
             type: ToolErrorType.EDIT_NO_OCCURRENCE_FOUND,
         };
     }
-    else if (occurrences !== expectedReplacements) {
-        const occurrenceTerm = expectedReplacements === 1 ? 'occurrence' : 'occurrences';
+    else if (!params.allow_multiple && occurrences !== 1) {
         error = {
-            display: `Failed to edit, expected ${expectedReplacements} ${occurrenceTerm} but found ${occurrences}.`,
-            raw: `Failed to edit, Expected ${expectedReplacements} ${occurrenceTerm} but found ${occurrences} for old_string in file: ${params.file_path}`,
+            display: `Failed to edit, expected 1 occurrence but found ${occurrences}.`,
+            raw: `Failed to edit, Expected 1 occurrence but found ${occurrences} for old_string in file: ${params.file_path}. If you intended to replace multiple occurrences, set 'allow_multiple' to true.`,
             type: ToolErrorType.EDIT_EXPECTED_OCCURRENCE_MISMATCH,
         };
     }
@@ -298,7 +312,7 @@ class EditToolInvocation extends BaseToolInvocation {
             currentContent: contentForLlmEditFixer,
             abortSignal,
         });
-        const secondError = getErrorReplaceResult(params, secondAttemptResult.occurrences, params.expected_replacements ?? 1, secondAttemptResult.finalOldString, secondAttemptResult.finalNewString);
+        const secondError = getErrorReplaceResult(params, secondAttemptResult.occurrences, secondAttemptResult.finalOldString, secondAttemptResult.finalNewString);
         if (secondError) {
             // The fix failed, log failure and return the original error
             const event = new EditCorrectionEvent('failure');
@@ -321,6 +335,8 @@ class EditToolInvocation extends BaseToolInvocation {
             isNewFile: false,
             error: undefined,
             originalLineEnding,
+            strategy: secondAttemptResult.strategy,
+            matchRanges: secondAttemptResult.matchRanges,
         };
     }
     /**
@@ -330,7 +346,6 @@ class EditToolInvocation extends BaseToolInvocation {
      * @throws File system errors if reading the file fails unexpectedly (e.g., permissions)
      */
     async calculateEdit(params, abortSignal) {
-        const expectedReplacements = params.expected_replacements ?? 1;
         let currentContent = null;
         let fileExists = false;
         let originalLineEnding = '\n'; // Default for new files
@@ -407,7 +422,7 @@ class EditToolInvocation extends BaseToolInvocation {
             currentContent,
             abortSignal,
         });
-        const initialError = getErrorReplaceResult(params, replacementResult.occurrences, expectedReplacements, replacementResult.finalOldString, replacementResult.finalNewString);
+        const initialError = getErrorReplaceResult(params, replacementResult.occurrences, replacementResult.finalOldString, replacementResult.finalNewString);
         if (!initialError) {
             return {
                 currentContent,
@@ -416,6 +431,8 @@ class EditToolInvocation extends BaseToolInvocation {
                 isNewFile: false,
                 error: undefined,
                 originalLineEnding,
+                strategy: replacementResult.strategy,
+                matchRanges: replacementResult.matchRanges,
             };
         }
         if (this.config.getDisableLLMCorrection()) {
@@ -469,15 +486,9 @@ class EditToolInvocation extends BaseToolInvocation {
             fileDiff,
             originalContent: editData.currentContent,
             newContent: editData.newContent,
-            onConfirm: async (outcome) => {
-                if (outcome === ToolConfirmationOutcome.ProceedAlways) {
-                    // No need to publish a policy update as the default policy for
-                    // AUTO_EDIT already reflects always approving edit.
-                    this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
-                }
-                else {
-                    await this.publishPolicyUpdate(outcome);
-                }
+            onConfirm: async (_outcome) => {
+                // Mode transitions (e.g. AUTO_EDIT) and policy updates are now
+                // handled centrally by the scheduler.
                 if (ideConfirmation) {
                     const result = await ideConfirmation;
                     if (result.status === 'accepted' && result.content) {
@@ -590,6 +601,15 @@ class EditToolInvocation extends BaseToolInvocation {
                     ? `Created new file: ${this.params.file_path} with provided content.`
                     : `Successfully modified file: ${this.params.file_path} (${editData.occurrences} replacements).`,
             ];
+            // Return a diff of the file before and after the write so that the agent
+            // can avoid the need to spend a turn doing a verification read.
+            const snippet = getDiffContextSnippet(editData.currentContent ?? '', finalContent, 5);
+            llmSuccessMessageParts.push(`Here is the updated code:
+${snippet}`);
+            const fuzzyFeedback = getFuzzyMatchFeedback(editData);
+            if (fuzzyFeedback) {
+                llmSuccessMessageParts.push(fuzzyFeedback);
+            }
             if (this.params.modified_by_user) {
                 llmSuccessMessageParts.push(`User modified the \`new_string\` content to be: ${this.params.new_string}.`);
             }
@@ -653,6 +673,15 @@ export class EditTool extends BaseDeclarativeTool {
             filePath = result.correctedPath;
         }
         params.file_path = filePath;
+        const newPlaceholders = detectOmissionPlaceholders(params.new_string);
+        if (newPlaceholders.length > 0) {
+            const oldPlaceholders = new Set(detectOmissionPlaceholders(params.old_string));
+            for (const placeholder of newPlaceholders) {
+                if (!oldPlaceholders.has(placeholder)) {
+                    return "`new_string` contains an omission placeholder (for example 'rest of methods ...'). Provide exact literal replacement text.";
+                }
+            }
+        }
         return this.config.validatePathAccess(params.file_path);
     }
     createInvocation(params, messageBus) {
@@ -702,4 +731,144 @@ export class EditTool extends BaseDeclarativeTool {
         };
     }
 }
+function stripWhitespace(str) {
+    return str.replace(/\s/g, '');
+}
+/**
+ * Applies the target indentation to the lines, while preserving relative indentation.
+ * It identifies the common indentation of the provided lines and replaces it with the target indentation.
+ */
+function applyIndentation(lines, targetIndentation) {
+    if (lines.length === 0)
+        return [];
+    // Use the first line as the reference for indentation, even if it's empty/whitespace.
+    // This is because flexible/fuzzy matching identifies the indentation of the START of the match.
+    const referenceLine = lines[0];
+    const refIndentMatch = referenceLine.match(/^([ \t]*)/);
+    const refIndent = refIndentMatch ? refIndentMatch[1] : '';
+    return lines.map((line) => {
+        if (line.trim() === '') {
+            return '';
+        }
+        if (line.startsWith(refIndent)) {
+            return targetIndentation + line.slice(refIndent.length);
+        }
+        return targetIndentation + line.trimStart();
+    });
+}
+function getFuzzyMatchFeedback(editData) {
+    if (editData.strategy === 'fuzzy' &&
+        editData.matchRanges &&
+        editData.matchRanges.length > 0) {
+        const ranges = editData.matchRanges
+            .map((r) => (r.start === r.end ? `${r.start}` : `${r.start}-${r.end}`))
+            .join(', ');
+        return `Applied fuzzy match at line${editData.matchRanges.length > 1 ? 's' : ''} ${ranges}.`;
+    }
+    return null;
+}
+async function calculateFuzzyReplacement(config, context) {
+    const { currentContent, params } = context;
+    const { old_string, new_string } = params;
+    // Pre-check: Don't fuzzy match very short strings to avoid false positives
+    if (old_string.length < 10) {
+        return null;
+    }
+    const normalizedCode = currentContent.replace(/\r\n/g, '\n');
+    const normalizedSearch = old_string.replace(/\r\n/g, '\n');
+    const normalizedReplace = new_string.replace(/\r\n/g, '\n');
+    const sourceLines = normalizedCode.match(/.*(?:\n|$)/g)?.slice(0, -1) ?? [];
+    const searchLines = normalizedSearch
+        .match(/.*(?:\n|$)/g)
+        ?.slice(0, -1)
+        .map((l) => l.trimEnd()); // Trim end of search lines to be more robust
+    // Limit the scope of the fuzzy match to reduce impact on responsivesness.
+    // Each comparison takes roughly O(L^2) time.
+    // We perform sourceLines.length comparisons (sliding window).
+    // Total complexity proxy: sourceLines.length * old_string.length^2
+    // Limit to 4e8 for < 1 second.
+    if (sourceLines.length * Math.pow(old_string.length, 2) > 400_000_000) {
+        return null;
+    }
+    if (!searchLines || searchLines.length === 0) {
+        return null;
+    }
+    const N = searchLines.length;
+    const candidates = [];
+    const searchBlock = searchLines.join('\n');
+    // Sliding window
+    for (let i = 0; i <= sourceLines.length - N; i++) {
+        const windowLines = sourceLines.slice(i, i + N);
+        const windowText = windowLines.map((l) => l.trimEnd()).join('\n'); // Normalized join for comparison
+        // Length Heuristic Optimization
+        const lengthDiff = Math.abs(windowText.length - searchBlock.length);
+        if (lengthDiff / searchBlock.length >
+            FUZZY_MATCH_THRESHOLD / WHITESPACE_PENALTY_FACTOR) {
+            continue;
+        }
+        // Tiered Scoring
+        const d_raw = levenshtein.get(windowText, searchBlock);
+        const d_norm = levenshtein.get(stripWhitespace(windowText), stripWhitespace(searchBlock));
+        const weightedDist = d_norm + (d_raw - d_norm) * WHITESPACE_PENALTY_FACTOR;
+        const score = weightedDist / searchBlock.length;
+        if (score <= FUZZY_MATCH_THRESHOLD) {
+            candidates.push({ index: i, score });
+        }
+    }
+    if (candidates.length === 0) {
+        return null;
+    }
+    // Select best non-overlapping matches
+    // Sort by score ascending. If scores equal, prefer earlier index (stable sort).
+    candidates.sort((a, b) => a.score - b.score || a.index - b.index);
+    const selectedMatches = [];
+    for (const candidate of candidates) {
+        // Check for overlap with already selected matches
+        // Two windows overlap if their start indices are within N lines of each other
+        // (Assuming window size N. Actually overlap is |i - j| < N)
+        const overlaps = selectedMatches.some((m) => Math.abs(m.index - candidate.index) < N);
+        if (!overlaps) {
+            selectedMatches.push(candidate);
+        }
+    }
+    // If we found matches, apply them
+    if (selectedMatches.length > 0) {
+        const event = new EditStrategyEvent('fuzzy');
+        logEditStrategy(config, event);
+        // Calculate match ranges before sorting for replacement
+        // Indices in selectedMatches are 0-based line indices
+        const matchRanges = selectedMatches
+            .map((m) => ({ start: m.index + 1, end: m.index + N }))
+            .sort((a, b) => a.start - b.start);
+        // Sort matches by index descending to apply replacements from bottom to top
+        // so that indices remain valid
+        selectedMatches.sort((a, b) => b.index - a.index);
+        const newLines = normalizedReplace.split('\n');
+        for (const match of selectedMatches) {
+            // If we want to preserve the indentation of the first line of the match:
+            const firstLineMatch = sourceLines[match.index];
+            const indentationMatch = firstLineMatch.match(/^([ \t]*)/);
+            const indentation = indentationMatch ? indentationMatch[1] : '';
+            const indentedReplaceLines = applyIndentation(newLines, indentation);
+            let replacementText = indentedReplaceLines.join('\n');
+            // If the last line of the match had a newline, preserve it in the replacement
+            // to avoid merging with the next line or losing a blank line separator.
+            if (sourceLines[match.index + N - 1].endsWith('\n')) {
+                replacementText += '\n';
+            }
+            sourceLines.splice(match.index, N, replacementText);
+        }
+        let modifiedCode = sourceLines.join('');
+        modifiedCode = restoreTrailingNewline(currentContent, modifiedCode);
+        return {
+            newContent: modifiedCode,
+            occurrences: selectedMatches.length,
+            finalOldString: normalizedSearch,
+            finalNewString: normalizedReplace,
+            strategy: 'fuzzy',
+            matchRanges,
+        };
+    }
+    return null;
+}
 //# sourceMappingURL=edit.js.map