@qduc/term2 0.7.3 → 0.9.0

package/dist/tools/file/search-replace.test.js

@@ -0,0 +1,1282 @@
+import { it, expect } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { createSearchReplaceToolDefinition } from './search-replace.js';
+import { createMockSettingsService } from '../../services/settings/settings-service.mock.js';
+function parsePlainResult(result) {
+    const lines = result.split('\n').filter(Boolean);
+    if (lines.length === 0) {
+        return { success: false, error: 'No output', output: [{ success: false, error: 'No output' }] };
+    }
+    const output = lines.map((line) => {
+        if (line.startsWith('Error: ')) {
+            return { success: false, error: line.slice(7) };
+        }
+        return { success: true, message: line };
+    });
+    return { ...output[0], output };
+}
+// Helper to create a temp dir and change cwd to it
+async function withTempDir(run) {
+    const originalCwd = process.cwd;
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'term2-search-replace-'));
+    // Mock process.cwd
+    process.cwd = () => tempDir;
+    try {
+        await run(tempDir);
+    }
+    finally {
+        process.cwd = originalCwd;
+        await fs.rm(tempDir, { recursive: true, force: true });
+    }
+}
+const mockLoggingService = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+    security: () => { },
+    setCorrelationId: () => { },
+    getCorrelationId: () => undefined,
+    clearCorrelationId: () => { },
+};
+function createTool(settingsService = createMockSettingsService(), editHealing) {
+    return createSearchReplaceToolDefinition({
+        loggingService: mockLoggingService,
+        settingsService,
+        ...(editHealing ? { editHealing } : {}),
+    });
+}
+it.sequential('needsApproval auto-approves creation when search_content is empty and file is missing', async () => {
+    await withTempDir(async () => {
+        const tool = createTool(createMockSettingsService());
+        const filePath = 'new-file.txt';
+        const result = await tool.needsApproval({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '',
+                    replace_content: 'initial content',
+                },
+            ],
+        });
+        expect(result).toBe(false);
+    });
+});
+it.sequential('needsApproval auto-approves a unique exact match', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService());
+        const filePath = 'sample.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello world');
+        const result = await tool.needsApproval({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hi',
+                },
+            ],
+        });
+        expect(result).toBe(false);
+    });
+});
+it.sequential('needsApproval auto-approves when multiple exact matches are found', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService());
+        const filePath = 'sample.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello world hello');
+        const result = await tool.needsApproval({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hi',
+                },
+            ],
+        });
+        expect(result).toBe(false);
+    });
+});
+it.sequential('execute replaces only a unique exact match', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'target before unique after');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'target',
+                    replace_content: 'done',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('done before unique after');
+    });
+});
+it.sequential('execute fails with a match_all hint when multiple exact matches are found', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'foo foo foo');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'foo',
+                    replace_content: 'bar',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error).toMatch(/Found 3 exact matches/);
+        expect(parsed.output[0].error).toMatch(/Set match_all to true to replace all matches/);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('foo foo foo');
+    });
+});
+it.sequential('execute replaces all exact matches when match_all is true', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'foo foo foo');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'foo',
+                    replace_content: 'bar',
+                    match_all: true,
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        expect(parsed.output[0].message).toMatch(/3 exact matches/);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('bar bar bar');
+    });
+});
+it.sequential('execute performs relaxed match replacement when exact match is not found', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, '    line one\n\tline two\nremainder');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line one\nline two',
+                    replace_content: 'new block\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('new block\nremainder');
+    });
+});
+it.sequential('execute fails when multiple relaxed matches are found', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, '  foo  \n\tbar\n---\n  foo  \n\tbar\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'foo\nbar',
+                    replace_content: 'replacement',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('relaxed matches') || parsed.output[0].error.includes('Found 2 relaxed matches')).toBe(true);
+        const unchanged = await fs.readFile(absPath, 'utf8');
+        expect(unchanged).toBe('  foo  \n\tbar\n---\n  foo  \n\tbar\n');
+    });
+});
+it.sequential('execute replaces all relaxed matches when match_all is true', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, '  foo  \n\tbar\n---\n  foo  \n\tbar\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'foo\nbar',
+                    replace_content: 'replacement\n',
+                    match_all: true,
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        expect(parsed.output[0].message).toMatch(/2 relaxed matches/);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('replacement\n---\nreplacement\n');
+    });
+});
+it.sequential('execute creates a new file when search_content is empty and file is missing', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'missing.txt';
+        const absPath = path.join(dir, filePath);
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '',
+                    replace_content: 'new content',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const createdContent = await fs.readFile(absPath, 'utf8');
+        expect(createdContent).toBe('new content');
+    });
+});
+it.sequential('execute preserves parallel edits to different regions of the same file', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'parallel.txt';
+        const absPath = path.join(dir, filePath);
+        const tokens = Array.from({ length: 20 }, (_, index) => `token_${String(index).padStart(2, '0')}`);
+        await fs.writeFile(absPath, tokens.join('\n'));
+        const results = await Promise.all(tokens.map((token, index) => tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: token,
+                    replace_content: `done_${index}`,
+                },
+            ],
+        })));
+        for (const result of results) {
+            const parsed = parsePlainResult(result);
+            expect(parsed.output[0].success).toBe(true);
+        }
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated.split('\n')).toEqual(tokens.map((_, index) => `done_${index}`));
+    });
+});
+it.sequential('execute applies batched replacements to one file with a single result per edit', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'batch.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'alpha\nbeta\ngamma\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'alpha',
+                    replace_content: 'ALPHA',
+                },
+                {
+                    search_content: 'gamma',
+                    replace_content: 'GAMMA',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output.every((item) => item.success)).toBe(true);
+        expect(parsed.output.length).toBe(2);
+        expect(parsed.output.every((item) => item.message?.includes(filePath))).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('ALPHA\nbeta\nGAMMA\n');
+    });
+});
+it.sequential('execute keeps successful batched replacements when another replacement fails', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'batch-failure.txt';
+        const absPath = path.join(dir, filePath);
+        const originalContent = 'alpha\nbeta\ngamma\n';
+        await fs.writeFile(absPath, originalContent);
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'alpha',
+                    replace_content: 'ALPHA',
+                },
+                {
+                    search_content: 'missing',
+                    replace_content: 'MISSING',
+                },
+                {
+                    search_content: 'gamma',
+                    replace_content: 'GAMMA',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        expect(parsed.output[1].success).toBe(false);
+        expect(parsed.output[2].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('ALPHA\nbeta\nGAMMA\n');
+    });
+});
+it.sequential('execute reports failure when search string is not found', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        const originalContent = 'hello world';
+        await fs.writeFile(absPath, originalContent);
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'nonexistent',
+                    replace_content: 'replacement',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        const unchanged = await fs.readFile(absPath, 'utf8');
+        expect(unchanged).toBe(originalContent);
+    });
+});
+it.sequential('execute heals search content when no match is found', async () => {
+    await withTempDir(async (dir) => {
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'const foo = 1;\n');
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': true }), async (params) => ({
+            params: {
+                ...params,
+                search_content: 'const foo = 1;\n',
+            },
+            wasModified: true,
+            confidence: 0.9,
+        }));
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'const foo = 2;\n',
+                    replace_content: 'const foo = 3;\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        expect(parsed.output[0].message.includes('auto healing')).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('const foo = 3;\n');
+    });
+});
+it.sequential('execute includes auto-healing failure reason when healing does not find a match', async () => {
+    await withTempDir(async (dir) => {
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'const foo = 1;\n');
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': true }), async (params) => ({
+            params,
+            wasModified: false,
+            confidence: 0,
+            failureReason: 'model returned NO_MATCH',
+        }));
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'const foo = 2;\n',
+                    replace_content: 'const foo = 3;\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('model returned NO_MATCH')).toBe(true);
+    });
+});
+it.sequential('execute treats special regex characters literally', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'code.js';
+        const absPath = path.join(dir, filePath);
+        const originalContent = 'function it() { return [1, 2, 3]; }';
+        await fs.writeFile(absPath, originalContent);
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '[1, 2, 3]',
+                    replace_content: '[4, 5, 6]',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('function it() { return [4, 5, 6]; }');
+    });
+});
+it.sequential('execute deletes content when replacement is empty string', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'sample.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'before DELETE_ME after');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'DELETE_ME ',
+                    replace_content: '',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('before after');
+    });
+});
+it.sequential('execute performs exact multi-line match without whitespace normalization', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'exact.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'line one\nline two\nline three');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line one\nline two',
+                    replace_content: 'new content',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('new content\nline three');
+    });
+});
+it.sequential('execute handles leading/trailing whitespace differences in relaxed mode', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'whitespace.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, '  foo  \nbar');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'foo\nbar',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('replaced');
+    });
+});
+it.sequential('execute performs normalized whitespace match across line breaks', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'normalized.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'const foo = 1;\nconst bar = 2;\nconst baz = 3;\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'const foo = 1; const bar = 2;',
+                    replace_content: 'const foo = 1;\nconst bar = 42;',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('const foo = 1;\nconst bar = 42;\nconst baz = 3;\n');
+    });
+});
+it.sequential('execute matches escaped newline sequences in search content', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'escaped.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello\nworld\nafter');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello\\nworld',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('replaced\nafter');
+    });
+});
+it.sequential('execute trims whitespace around the whole search string as a fallback', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'boundary-whitespace.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'before\nconst value = 1;\nafter');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '\n  const value = 1;  \n',
+                    replace_content: 'const value = 2;',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('before\nconst value = 2;\nafter');
+    });
+});
+it.sequential('execute recovers a unique multiline block with matching anchors and a minor middle difference', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'anchor-context.ts';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, [
+            'function calculate() {',
+            '  const subtotal = getSubtotal();',
+            '  const tax = subtotal * 0.2;',
+            '  return subtotal + tax;',
+            '}',
+        ].join('\n'));
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: [
+                        'function calculate() {',
+                        '  const subtotal = getSubtotal();',
+                        '  const tax = subtotal * 0.18;',
+                        '  return subtotal + tax;',
+                        '}',
+                    ].join('\n'),
+                    replace_content: 'function calculate() {\n  return getSubtotal() * 1.2;\n}',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('function calculate() {\n  return getSubtotal() * 1.2;\n}');
+    });
+});
+it.sequential('needsApproval requires approval for anchor recovery outside the workspace', async () => {
+    await withTempDir(async () => {
+        const outsideDir = await fs.mkdtemp(path.join(os.tmpdir(), 'term2-search-replace-outside-'));
+        const filePath = path.join(outsideDir, 'anchor-context.ts');
+        try {
+            await fs.writeFile(filePath, [
+                'function calculate() {',
+                '  const subtotal = getSubtotal();',
+                '  const tax = subtotal * 0.2;',
+                '  return subtotal + tax;',
+                '}',
+            ].join('\n'));
+            const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+            const result = await tool.needsApproval({
+                path: filePath,
+                replacements: [
+                    {
+                        search_content: [
+                            'function calculate() {',
+                            '  const subtotal = getSubtotal();',
+                            '  const tax = subtotal * 0.18;',
+                            '  return subtotal + tax;',
+                            '}',
+                        ].join('\n'),
+                        replace_content: 'function calculate() {\n  return getSubtotal() * 1.2;\n}',
+                    },
+                ],
+            });
+            expect(result).toBe(true);
+        }
+        finally {
+            await fs.rm(outsideDir, { recursive: true, force: true });
+        }
+    });
+});
+it.sequential('execute rejects anchor recovery when the selected span is much larger than the search string', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'oversized-anchor.ts';
+        const absPath = path.join(dir, filePath);
+        const originalContent = [
+            'function calculate() {',
+            ...Array.from({ length: 40 }, (_, index) => `  const value${index} = ${index};`),
+            '  return total;',
+            '}',
+        ].join('\n');
+        await fs.writeFile(absPath, originalContent);
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: ['function calculate() {', '  const subtotal = 1;', '  return total;', '}'].join('\n'),
+                    replace_content: 'function calculate() {\n  return 0;\n}',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        const unchanged = await fs.readFile(absPath, 'utf8');
+        expect(unchanged).toBe(originalContent);
+    });
+});
+it.sequential('execute rejects multiple normalized matches', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'normalized-multi.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'const foo = 1;\n   const bar = 2;\n---\nconst foo = 1;\tconst bar = 2;\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'const foo = 1; const bar = 2;',
+                    replace_content: 'const foo = 9; const bar = 9;',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('normalized matches')).toBe(true);
+        const unchanged = await fs.readFile(absPath, 'utf8');
+        expect(unchanged).toBe('const foo = 1;\n   const bar = 2;\n---\nconst foo = 1;\tconst bar = 2;\n');
+    });
+});
+it.sequential('execute does not match substrings in relaxed mode', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'substring.txt';
+        const absPath = path.join(dir, filePath);
+        const originalContent = '  formatted text  ';
+        await fs.writeFile(absPath, originalContent);
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '    format    ',
+                    replace_content: 'replacement',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        const unchanged = await fs.readFile(absPath, 'utf8');
+        expect(unchanged).toBe(originalContent);
+    });
+});
+it.sequential('execute normalizes CRLF search content to match LF file', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'lf-file.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'line one\nline two\nline three');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line one\r\nline two',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('replaced\nline three');
+    });
+});
+it.sequential('execute normalizes LF search content to match CRLF file', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'crlf-file.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'line one\r\nline two\r\nline three');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line one\nline two',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('replaced\r\nline three');
+    });
+});
+it.sequential('execute preserves CRLF in replacement content when file uses CRLF', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'crlf-file.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello\r\nworld');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'new\nline',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('new\r\nline\r\nworld');
+    });
+});
+it.sequential('execute strips leading filepath comment from search content', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'sample.ts';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'const x = 1;\nconst y = 2;');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '// sample.ts\nconst x = 1;',
+                    replace_content: 'const x = 42;',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('const x = 42;\nconst y = 2;');
+    });
+});
+it.sequential('execute strips leading hash filepath comment from search content', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'script.py';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'x = 1\ny = 2');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '# script.py\nx = 1',
+                    replace_content: 'x = 42',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('x = 42\ny = 2');
+    });
+});
+it.sequential('execute does not strip non-filepath leading comments', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'code.ts';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, '// TODO: fix this\nconst x = 1;');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: '// TODO: fix this\nconst x = 1;',
+                    replace_content: 'const x = 42;',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('const x = 42;');
+    });
+});
+it.sequential('execute rejects search content with "Lines X-Y omitted" marker', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'line 1\nline 2\nline 3');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line 1\nLines 2-50 omitted\nline 3',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('omitted')).toBe(true);
+    });
+});
+it.sequential('execute rejects search content with ellipsis marker {…}', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'function foo() { /* code */ }');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'function foo() {…}',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('ellipsis')).toBe(true);
+    });
+});
+it.sequential('execute rejects search content with /*...*/ marker', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'function foo() { return 1; }');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'function foo() { /*...*/ }',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('/*...*/')).toBe(true);
+    });
+});
+it.sequential('execute rejects search content with // ... marker', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'const a = 1;\nconst b = 2;\nconst c = 3;');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'const a = 1;\n// ...\nconst c = 3;',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('// ...')).toBe(true);
+    });
+});
+it.sequential('execute rejects search content when search and replace content are identical', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello world');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hello',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error).toMatch(/identical/i);
+    });
+});
+it.sequential('needsApproval auto-approves when search and replace content are identical', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello world');
+        const result = await tool.needsApproval({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hello',
+                },
+            ],
+        });
+        expect(result).toBe(false);
+    });
+});
+it.sequential('execute performs gap match: head <...> tail replaces entire region', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'function foo() {\n  const x = 1;\n  const y = 2;\n  const z = 3;\n  return x + y + z;\n}\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'function foo() {\n  const x = 1;\n<...>\n  return x + y + z;\n}',
+                    replace_content: 'function foo() {\n  return 6;\n}\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        expect(parsed.output[0].message.includes('gap')).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('function foo() {\n  return 6;\n}\n');
+    });
+});
+it.sequential('execute performs gap match with single-line head and tail', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'start\nmiddle1\nmiddle2\nend\nafter');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'start\n<...>\nend',
+                    replace_content: 'replaced\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('replaced\nafter');
+    });
+});
+it.sequential('execute performs gap match with adjacent head and tail (no actual gap content)', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'line1\nline2\nline3');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line1\n<...>\nline2',
+                    replace_content: 'replaced\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('replaced\nline3');
+    });
+});
+it.sequential('execute performs gap match with multiple <...> markers', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'function a() {\n  body1;\n}\nfunction b() {\n  body2;\n}\nfunction c() {\n  body3;\n}\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'function a() {\n<...>\nfunction b() {\n<...>\nfunction c() {\n  body3;\n}',
+                    replace_content: 'function abc() {\n  combined;\n}\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('function abc() {\n  combined;\n}\n');
+    });
+});
+it.sequential('execute gap match fails when head is not found', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'line1\nline2\nline3');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'nonexistent\n<...>\nline3',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+    });
+});
+it.sequential('execute gap match fails when tail is not found after head', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'line1\nline2\nline3');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line1\n<...>\nnonexistent',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+    });
+});
+it.sequential('execute does not invoke healing for a failed gap pattern and reports a head-anchor diagnostic', async () => {
+    await withTempDir(async (dir) => {
+        let healingCalls = 0;
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': true }), async (params) => {
+            healingCalls++;
+            return { params, wasModified: false, confidence: 0 };
+        });
+        const filePath = 'content.txt';
+        await fs.writeFile(path.join(dir, filePath), 'line1\nline2\nline3');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'nonexistent\n<...>\nline3',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(healingCalls).toBe(0);
+        expect(parsed.output[0].error).toMatch(/head anchor/i);
+        expect(parsed.output[0].error).toMatch(/not auto-healed/i);
+    });
+});
+it.sequential('execute gap diagnostic identifies the anchor that failed after the head matched', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': true }), async (params) => ({
+            params,
+            wasModified: false,
+            confidence: 0,
+        }));
+        const filePath = 'content.txt';
+        await fs.writeFile(path.join(dir, filePath), 'line1\nline2\nline3');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line1\n<...>\nnonexistent',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error).toMatch(/not found after/i);
+    });
+});
+it.sequential('execute gap match rejects multiple matches', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'start\nmiddle1\nend\nstart\nmiddle2\nend\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'start\n<...>\nend',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(false);
+        expect(parsed.output[0].error.includes('gap')).toBe(true);
+    });
+});
+it.sequential('execute gap match works with relaxed whitespace matching in segments', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, '  function foo() {\n  const x = 1;\n  const y = 2;\n  return x;\n  }\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'function foo() {\n<...>\nreturn x;\n}',
+                    replace_content: 'function foo() {\n  return 42;\n}\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('function foo() {\n  return 42;\n}\n');
+    });
+});
+it.sequential('needsApproval handles gap match', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService());
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'start\nmiddle\nend\n');
+        const result = await tool.needsApproval({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'start\n<...>\nend',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        expect(result).toBe(false);
+    });
+});
+it.sequential('execute falls back to literal match when gap matching fails with standalone <...>', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'literal-standalone-gap-fallback.txt';
+        const absPath = path.join(dir, filePath);
+        // File has <...> on its own line as literal text, without matching head anchors
+        await fs.writeFile(absPath, 'prefix\n<...>\nsuffix\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: `<...>\nsuffix`,
+                    replace_content: 'replacement',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('prefix\nreplacement\n');
+    });
+});
+it.sequential('execute matches literal <...> when not on a standalone line', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'literal-inline.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, "export const GAP_MARKER = '<...>';\n");
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: "export const GAP_MARKER = '<...>';",
+                    replace_content: 'export const GAP_MARKER = "___";',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('export const GAP_MARKER = "___";\n');
+    });
+});
+it.sequential('execute performs gap match when input has literal \\n sequences', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'unescape-gap.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'class MyClass {\n  myMethod() {\n    return 42;\n  }\n}\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'class MyClass {\\n<...>\\n  myMethod() {\\n    return 42;\\n  }\\n}',
+                    replace_content: 'class MyClass {\n  myMethod() { return 100; }\n}\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('class MyClass {\n  myMethod() { return 100; }\n}\n');
+    });
+});
+it.sequential('execute gap match preserves blank lines inside anchors', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'blank-lines-anchor.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'const a = 1;\n\nconst b = 2;\n// gap here\nconst c = 3;\n\nconst d = 4;\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'const a = 1;\n\nconst b = 2;\n<...>\nconst c = 3;\n\nconst d = 4;',
+                    replace_content: 'const replaced = true;\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('const replaced = true;\n');
+    });
+});
+it.sequential('execute gap match works with normalized whitespace within lines', async () => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        const filePath = 'whitespace-norm-gap.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'if (condition)  {\n  doSomething();\n  doOtherThing();\n  return  true;\n}\n');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'if (condition) {\n<...>\nreturn true;\n}',
+                    replace_content: 'if (condition) {\n  return false;\n}\n',
+                },
+            ],
+        });
+        const parsed = parsePlainResult(result);
+        expect(parsed.output[0].success).toBe(true);
+        const updated = await fs.readFile(absPath, 'utf8');
+        expect(updated).toBe('if (condition) {\n  return false;\n}\n');
+    });
+});
+//# sourceMappingURL=search-replace.test.js.map