@office-ai/aioncli-core 0.8.1 → 0.18.5

package/dist/src/tools/ripGrep.test.js

@@ -3,109 +3,140 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { describe, it, expect, beforeEach, afterEach, vi, } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi, } from 'vitest';
 import { canUseRipgrep, RipGrepTool, ensureRgPath } from './ripGrep.js';
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import os, { EOL } from 'node:os';
+import os from 'node:os';
+import { Storage } from '../config/storage.js';
 import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
 import { spawn } from 'node:child_process';
 import { downloadRipGrep } from '@joshua.litt/get-ripgrep';
-import { fileExists } from '../utils/fileUtils.js';
 // Mock dependencies for canUseRipgrep
 vi.mock('@joshua.litt/get-ripgrep', () => ({
     downloadRipGrep: vi.fn(),
 }));
-vi.mock('../utils/fileUtils.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        fileExists: vi.fn(),
-    };
-});
-vi.mock('../config/storage.js', () => ({
-    Storage: {
-        getGlobalBinDir: vi.fn().mockReturnValue('/mock/bin/dir'),
-    },
-}));
 // Mock child_process for ripgrep calls
 vi.mock('child_process', () => ({
     spawn: vi.fn(),
 }));
 const mockSpawn = vi.mocked(spawn);
+const downloadRipGrepMock = vi.mocked(downloadRipGrep);
+const originalGetGlobalBinDir = Storage.getGlobalBinDir.bind(Storage);
+const storageSpy = vi.spyOn(Storage, 'getGlobalBinDir');
+function getRipgrepBinaryName() {
+    return process.platform === 'win32' ? 'rg.exe' : 'rg';
+}
 describe('canUseRipgrep', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
+    let tempRootDir;
+    let binDir;
+    beforeEach(async () => {
+        downloadRipGrepMock.mockReset();
+        downloadRipGrepMock.mockResolvedValue(undefined);
+        tempRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'ripgrep-bin-'));
+        binDir = path.join(tempRootDir, 'bin');
+        await fs.mkdir(binDir, { recursive: true });
+        storageSpy.mockImplementation(() => binDir);
+    });
+    afterEach(async () => {
+        storageSpy.mockImplementation(() => originalGetGlobalBinDir());
+        await fs.rm(tempRootDir, { recursive: true, force: true });
     });
     it('should return true if ripgrep already exists', async () => {
-        fileExists.mockResolvedValue(true);
+        const existingPath = path.join(binDir, getRipgrepBinaryName());
+        await fs.writeFile(existingPath, '');
         const result = await canUseRipgrep();
         expect(result).toBe(true);
-        expect(fileExists).toHaveBeenCalledWith(path.join('/mock/bin/dir', 'rg'));
-        expect(downloadRipGrep).not.toHaveBeenCalled();
+        expect(downloadRipGrepMock).not.toHaveBeenCalled();
     });
     it('should download ripgrep and return true if it does not exist initially', async () => {
-        fileExists
-            .mockResolvedValueOnce(false)
-            .mockResolvedValueOnce(true);
-        downloadRipGrep.mockResolvedValue(undefined);
+        const expectedPath = path.join(binDir, getRipgrepBinaryName());
+        downloadRipGrepMock.mockImplementation(async () => {
+            await fs.writeFile(expectedPath, '');
+        });
         const result = await canUseRipgrep();
         expect(result).toBe(true);
-        expect(fileExists).toHaveBeenCalledTimes(2);
-        expect(downloadRipGrep).toHaveBeenCalledWith('/mock/bin/dir');
+        expect(downloadRipGrep).toHaveBeenCalledWith(binDir);
+        await expect(fs.access(expectedPath)).resolves.toBeUndefined();
     });
     it('should return false if download fails and file does not exist', async () => {
-        fileExists.mockResolvedValue(false);
-        downloadRipGrep.mockResolvedValue(undefined);
         const result = await canUseRipgrep();
         expect(result).toBe(false);
-        expect(fileExists).toHaveBeenCalledTimes(2);
-        expect(downloadRipGrep).toHaveBeenCalledWith('/mock/bin/dir');
+        expect(downloadRipGrep).toHaveBeenCalledWith(binDir);
     });
     it('should propagate errors from downloadRipGrep', async () => {
         const error = new Error('Download failed');
-        fileExists.mockResolvedValue(false);
-        downloadRipGrep.mockRejectedValue(error);
+        downloadRipGrepMock.mockRejectedValue(error);
         await expect(canUseRipgrep()).rejects.toThrow(error);
-        expect(fileExists).toHaveBeenCalledTimes(1);
-        expect(downloadRipGrep).toHaveBeenCalledWith('/mock/bin/dir');
+        expect(downloadRipGrep).toHaveBeenCalledWith(binDir);
+    });
+    it('should only download once when called concurrently', async () => {
+        const expectedPath = path.join(binDir, getRipgrepBinaryName());
+        downloadRipGrepMock.mockImplementation(() => new Promise((resolve, reject) => {
+            setTimeout(() => {
+                fs.writeFile(expectedPath, '')
+                    .then(() => resolve())
+                    .catch(reject);
+            }, 0);
+        }));
+        const firstCall = ensureRgPath();
+        const secondCall = ensureRgPath();
+        const [pathOne, pathTwo] = await Promise.all([firstCall, secondCall]);
+        expect(pathOne).toBe(expectedPath);
+        expect(pathTwo).toBe(expectedPath);
+        expect(downloadRipGrepMock).toHaveBeenCalledTimes(1);
+        await expect(fs.access(expectedPath)).resolves.toBeUndefined();
     });
 });
 describe('ensureRgPath', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
+    let tempRootDir;
+    let binDir;
+    beforeEach(async () => {
+        downloadRipGrepMock.mockReset();
+        downloadRipGrepMock.mockResolvedValue(undefined);
+        tempRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'ripgrep-bin-'));
+        binDir = path.join(tempRootDir, 'bin');
+        await fs.mkdir(binDir, { recursive: true });
+        storageSpy.mockImplementation(() => binDir);
+    });
+    afterEach(async () => {
+        storageSpy.mockImplementation(() => originalGetGlobalBinDir());
+        await fs.rm(tempRootDir, { recursive: true, force: true });
     });
     it('should return rg path if ripgrep already exists', async () => {
-        fileExists.mockResolvedValue(true);
+        const existingPath = path.join(binDir, getRipgrepBinaryName());
+        await fs.writeFile(existingPath, '');
         const rgPath = await ensureRgPath();
-        expect(rgPath).toBe(path.join('/mock/bin/dir', 'rg'));
-        expect(fileExists).toHaveBeenCalledOnce();
+        expect(rgPath).toBe(existingPath);
         expect(downloadRipGrep).not.toHaveBeenCalled();
     });
     it('should return rg path if ripgrep is downloaded successfully', async () => {
-        fileExists
-            .mockResolvedValueOnce(false)
-            .mockResolvedValueOnce(true);
-        downloadRipGrep.mockResolvedValue(undefined);
+        const expectedPath = path.join(binDir, getRipgrepBinaryName());
+        downloadRipGrepMock.mockImplementation(async () => {
+            await fs.writeFile(expectedPath, '');
+        });
         const rgPath = await ensureRgPath();
-        expect(rgPath).toBe(path.join('/mock/bin/dir', 'rg'));
-        expect(downloadRipGrep).toHaveBeenCalledOnce();
-        expect(fileExists).toHaveBeenCalledTimes(2);
+        expect(rgPath).toBe(expectedPath);
+        expect(downloadRipGrep).toHaveBeenCalledTimes(1);
+        await expect(fs.access(expectedPath)).resolves.toBeUndefined();
     });
     it('should throw an error if ripgrep cannot be used after download attempt', async () => {
-        fileExists.mockResolvedValue(false);
-        downloadRipGrep.mockResolvedValue(undefined);
         await expect(ensureRgPath()).rejects.toThrow('Cannot use ripgrep.');
-        expect(downloadRipGrep).toHaveBeenCalledOnce();
-        expect(fileExists).toHaveBeenCalledTimes(2);
+        expect(downloadRipGrep).toHaveBeenCalledTimes(1);
     });
     it('should propagate errors from downloadRipGrep', async () => {
         const error = new Error('Download failed');
-        fileExists.mockResolvedValue(false);
-        downloadRipGrep.mockRejectedValue(error);
+        downloadRipGrepMock.mockRejectedValue(error);
         await expect(ensureRgPath()).rejects.toThrow(error);
-        expect(fileExists).toHaveBeenCalledTimes(1);
-        expect(downloadRipGrep).toHaveBeenCalledWith('/mock/bin/dir');
+        expect(downloadRipGrep).toHaveBeenCalledWith(binDir);
+    });
+    it.runIf(process.platform === 'win32')('should detect ripgrep when only rg.exe exists on Windows', async () => {
+        const expectedRgExePath = path.join(binDir, 'rg.exe');
+        await fs.writeFile(expectedRgExePath, '');
+        const rgPath = await ensureRgPath();
+        expect(rgPath).toBe(expectedRgExePath);
+        expect(downloadRipGrep).not.toHaveBeenCalled();
+        await expect(fs.access(expectedRgExePath)).resolves.toBeUndefined();
     });
 });
 // Helper function to create mock spawn implementations
@@ -141,6 +172,9 @@ function createMockSpawn(options = {}) {
 }
 describe('RipGrepTool', () => {
     let tempRootDir;
+    let tempBinRoot;
+    let binDir;
+    let ripgrepBinaryPath;
     let grepTool;
     const abortSignal = new AbortController().signal;
     const mockConfig = {
@@ -149,10 +183,16 @@ describe('RipGrepTool', () => {
         getDebugMode: () => false,
     };
     beforeEach(async () => {
-        vi.clearAllMocks();
-        downloadRipGrep.mockResolvedValue(undefined);
-        fileExists.mockResolvedValue(true);
-        mockSpawn.mockClear();
+        downloadRipGrepMock.mockReset();
+        downloadRipGrepMock.mockResolvedValue(undefined);
+        mockSpawn.mockReset();
+        tempBinRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'ripgrep-bin-'));
+        binDir = path.join(tempBinRoot, 'bin');
+        await fs.mkdir(binDir, { recursive: true });
+        const binaryName = process.platform === 'win32' ? 'rg.exe' : 'rg';
+        ripgrepBinaryPath = path.join(binDir, binaryName);
+        await fs.writeFile(ripgrepBinaryPath, '');
+        storageSpy.mockImplementation(() => binDir);
         tempRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'grep-tool-root-'));
         grepTool = new RipGrepTool(mockConfig);
         // Create some test files and directories
@@ -163,58 +203,93 @@ describe('RipGrepTool', () => {
         await fs.writeFile(path.join(tempRootDir, 'sub', 'fileD.md'), '# Markdown file\nThis is a test.');
     });
     afterEach(async () => {
+        storageSpy.mockImplementation(() => originalGetGlobalBinDir());
         await fs.rm(tempRootDir, { recursive: true, force: true });
+        await fs.rm(tempBinRoot, { recursive: true, force: true });
     });
     describe('validateToolParams', () => {
-        it('should return null for valid params (pattern only)', () => {
-            const params = { pattern: 'hello' };
-            expect(grepTool.validateToolParams(params)).toBeNull();
-        });
-        it('should return null for valid params (pattern and path)', () => {
-            const params = { pattern: 'hello', path: '.' };
-            expect(grepTool.validateToolParams(params)).toBeNull();
-        });
-        it('should return null for valid params (pattern, path, and include)', () => {
-            const params = {
-                pattern: 'hello',
-                path: '.',
-                include: '*.txt',
-            };
-            expect(grepTool.validateToolParams(params)).toBeNull();
+        it.each([
+            {
+                name: 'pattern only',
+                params: { pattern: 'hello' },
+                expected: null,
+            },
+            {
+                name: 'pattern and path',
+                params: { pattern: 'hello', dir_path: '.' },
+                expected: null,
+            },
+            {
+                name: 'pattern, path, and include',
+                params: { pattern: 'hello', dir_path: '.', include: '*.txt' },
+                expected: null,
+            },
+            {
+                name: 'invalid regex pattern',
+                params: { pattern: '[[' },
+                expected: null,
+            },
+        ])('should return null for valid params ($name)', ({ params, expected }) => {
+            expect(grepTool.validateToolParams(params)).toBe(expected);
         });
         it('should return error if pattern is missing', () => {
-            const params = { path: '.' };
+            const params = { dir_path: '.' };
             expect(grepTool.validateToolParams(params)).toBe(`params must have required property 'pattern'`);
         });
-        it('should return null for what would be an invalid regex pattern', () => {
-            const params = { pattern: '[[' };
-            expect(grepTool.validateToolParams(params)).toBeNull();
-        });
         it('should return error if path does not exist', () => {
             const params = {
                 pattern: 'hello',
-                path: 'nonexistent',
+                dir_path: 'nonexistent',
             };
             // Check for the core error message, as the full path might vary
-            expect(grepTool.validateToolParams(params)).toContain('Failed to access path stats for');
+            expect(grepTool.validateToolParams(params)).toContain('Path does not exist');
             expect(grepTool.validateToolParams(params)).toContain('nonexistent');
         });
-        it('should return error if path is a file, not a directory', async () => {
+        it('should allow path to be a file', async () => {
             const filePath = path.join(tempRootDir, 'fileA.txt');
-            const params = { pattern: 'hello', path: filePath };
-            expect(grepTool.validateToolParams(params)).toContain(`Path is not a directory: ${filePath}`);
+            const params = {
+                pattern: 'hello',
+                dir_path: filePath,
+            };
+            expect(grepTool.validateToolParams(params)).toBeNull();
         });
     });
     describe('execute', () => {
         it('should find matches for a simple pattern in all files', async () => {
             mockSpawn.mockImplementationOnce(createMockSpawn({
-                outputData: `fileA.txt:1:hello world${EOL}fileA.txt:2:second line with world${EOL}sub/fileC.txt:1:another world in sub dir${EOL}`,
+                outputData: JSON.stringify({
+                    type: 'match',
+                    data: {
+                        path: { text: 'fileA.txt' },
+                        line_number: 1,
+                        lines: { text: 'hello world\n' },
+                    },
+                }) +
+                    '\n' +
+                    JSON.stringify({
+                        type: 'match',
+                        data: {
+                            path: { text: 'fileA.txt' },
+                            line_number: 2,
+                            lines: { text: 'second line with world\n' },
+                        },
+                    }) +
+                    '\n' +
+                    JSON.stringify({
+                        type: 'match',
+                        data: {
+                            path: { text: 'sub/fileC.txt' },
+                            line_number: 1,
+                            lines: { text: 'another world in sub dir\n' },
+                        },
+                    }) +
+                    '\n',
                 exitCode: 0,
             }));
             const params = { pattern: 'world' };
             const invocation = grepTool.build(params);
             const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).toContain('Found 3 matches for pattern "world" in the workspace directory');
+            expect(result.llmContent).toContain('Found 3 matches for pattern "world" in path "."');
             expect(result.llmContent).toContain('File: fileA.txt');
             expect(result.llmContent).toContain('L1: hello world');
             expect(result.llmContent).toContain('L2: second line with world');
@@ -225,10 +300,17 @@ describe('RipGrepTool', () => {
         it('should find matches in a specific path', async () => {
             // Setup specific mock for this test - searching in 'sub' should only return matches from that directory
             mockSpawn.mockImplementationOnce(createMockSpawn({
-                outputData: `fileC.txt:1:another world in sub dir${EOL}`,
+                outputData: JSON.stringify({
+                    type: 'match',
+                    data: {
+                        path: { text: 'fileC.txt' },
+                        line_number: 1,
+                        lines: { text: 'another world in sub dir\n' },
+                    },
+                }) + '\n',
                 exitCode: 0,
             }));
-            const params = { pattern: 'world', path: 'sub' };
+            const params = { pattern: 'world', dir_path: 'sub' };
             const invocation = grepTool.build(params);
             const result = await invocation.execute(abortSignal);
             expect(result.llmContent).toContain('Found 1 match for pattern "world" in path "sub"');
@@ -239,13 +321,20 @@ describe('RipGrepTool', () => {
         it('should find matches with an include glob', async () => {
             // Setup specific mock for this test
             mockSpawn.mockImplementationOnce(createMockSpawn({
-                outputData: `fileB.js:2:function baz() { return "hello"; }${EOL}`,
+                outputData: JSON.stringify({
+                    type: 'match',
+                    data: {
+                        path: { text: 'fileB.js' },
+                        line_number: 2,
+                        lines: { text: 'function baz() { return "hello"; }\n' },
+                    },
+                }) + '\n',
                 exitCode: 0,
             }));
             const params = { pattern: 'hello', include: '*.js' };
             const invocation = grepTool.build(params);
             const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).toContain('Found 1 match for pattern "hello" in the workspace directory (filter: "*.js"):');
+            expect(result.llmContent).toContain('Found 1 match for pattern "hello" in path "." (filter: "*.js"):');
             expect(result.llmContent).toContain('File: fileB.js');
             expect(result.llmContent).toContain('L2: function baz() { return "hello"; }');
             expect(result.returnDisplay).toBe('Found 1 match');
@@ -272,7 +361,14 @@ describe('RipGrepTool', () => {
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
                         // Only return match from the .js file in sub directory
-                        onData(Buffer.from(`another.js:1:const greeting = "hello";${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'another.js' },
+                                line_number: 1,
+                                lines: { text: 'const greeting = "hello";\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -282,7 +378,7 @@ describe('RipGrepTool', () => {
             });
             const params = {
                 pattern: 'hello',
-                path: 'sub',
+                dir_path: 'sub',
                 include: '*.js',
             };
             const invocation = grepTool.build(params);
@@ -300,7 +396,7 @@ describe('RipGrepTool', () => {
             const params = { pattern: 'nonexistentpattern' };
             const invocation = grepTool.build(params);
             const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).toContain('No matches found for pattern "nonexistentpattern" in the workspace directory.');
+            expect(result.llmContent).toContain('No matches found for pattern "nonexistentpattern" in path ".".');
             expect(result.returnDisplay).toBe('No matches found');
         });
         it('should return an error from ripgrep for invalid regex pattern', async () => {
@@ -334,7 +430,14 @@ describe('RipGrepTool', () => {
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
                         // Return match for the regex pattern
-                        onData(Buffer.from(`fileB.js:1:const foo = "bar";${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'fileB.js' },
+                                line_number: 1,
+                                lines: { text: 'const foo = "bar";\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -345,7 +448,7 @@ describe('RipGrepTool', () => {
             const params = { pattern: 'foo.*bar' }; // Matches 'const foo = "bar";'
             const invocation = grepTool.build(params);
             const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).toContain('Found 1 match for pattern "foo.*bar" in the workspace directory:');
+            expect(result.llmContent).toContain('Found 1 match for pattern "foo.*bar" in path ".":');
             expect(result.llmContent).toContain('File: fileB.js');
             expect(result.llmContent).toContain('L1: const foo = "bar";');
         });
@@ -370,7 +473,24 @@ describe('RipGrepTool', () => {
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
                         // Return case-insensitive matches for 'HELLO'
-                        onData(Buffer.from(`fileA.txt:1:hello world${EOL}fileB.js:2:function baz() { return "hello"; }${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'fileA.txt' },
+                                line_number: 1,
+                                lines: { text: 'hello world\n' },
+                            },
+                        }) +
+                            '\n' +
+                            JSON.stringify({
+                                type: 'match',
+                                data: {
+                                    path: { text: 'fileB.js' },
+                                    line_number: 2,
+                                    lines: { text: 'function baz() { return "hello"; }\n' },
+                                },
+                            }) +
+                            '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -381,20 +501,19 @@ describe('RipGrepTool', () => {
             const params = { pattern: 'HELLO' };
             const invocation = grepTool.build(params);
             const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).toContain('Found 2 matches for pattern "HELLO" in the workspace directory:');
+            expect(result.llmContent).toContain('Found 2 matches for pattern "HELLO" in path ".":');
             expect(result.llmContent).toContain('File: fileA.txt');
             expect(result.llmContent).toContain('L1: hello world');
             expect(result.llmContent).toContain('File: fileB.js');
             expect(result.llmContent).toContain('L2: function baz() { return "hello"; }');
         });
         it('should throw an error if params are invalid', async () => {
-            const params = { path: '.' }; // Invalid: pattern missing
+            const params = { dir_path: '.' }; // Invalid: pattern missing
             expect(() => grepTool.build(params)).toThrow(/params must have required property 'pattern'/);
         });
         it('should throw an error if ripgrep is not available', async () => {
-            // Make ensureRgPath throw
-            fileExists.mockResolvedValue(false);
-            downloadRipGrep.mockResolvedValue(undefined);
+            await fs.rm(ripgrepBinaryPath, { force: true });
+            downloadRipGrepMock.mockResolvedValue(undefined);
             const params = { pattern: 'world' };
             const invocation = grepTool.build(params);
             expect(await invocation.execute(abortSignal)).toStrictEqual({
@@ -404,7 +523,7 @@ describe('RipGrepTool', () => {
         });
     });
     describe('multi-directory workspace', () => {
-        it('should search across all workspace directories when no path is specified', async () => {
+        it('should search only CWD when no path is specified (default behavior)', async () => {
             // Create additional directory with test files
             const secondDir = await fs.mkdtemp(path.join(os.tmpdir(), 'grep-tool-second-'));
             await fs.writeFile(path.join(secondDir, 'other.txt'), 'hello from second directory\nworld in second');
@@ -440,19 +559,55 @@ describe('RipGrepTool', () => {
                     if (callCount === 1) {
                         // First directory (tempRootDir)
                         outputData =
-                            [
-                                'fileA.txt:1:hello world',
-                                'fileA.txt:2:second line with world',
-                                'sub/fileC.txt:1:another world in sub dir',
-                            ].join(EOL) + EOL;
+                            JSON.stringify({
+                                type: 'match',
+                                data: {
+                                    path: { text: 'fileA.txt' },
+                                    line_number: 1,
+                                    lines: { text: 'hello world\n' },
+                                },
+                            }) +
+                                '\n' +
+                                JSON.stringify({
+                                    type: 'match',
+                                    data: {
+                                        path: { text: 'fileA.txt' },
+                                        line_number: 2,
+                                        lines: { text: 'second line with world\n' },
+                                    },
+                                }) +
+                                '\n' +
+                                JSON.stringify({
+                                    type: 'match',
+                                    data: {
+                                        path: { text: 'sub/fileC.txt' },
+                                        line_number: 1,
+                                        lines: { text: 'another world in sub dir\n' },
+                                    },
+                                }) +
+                                '\n';
                     }
                     else if (callCount === 2) {
                         // Second directory (secondDir)
                         outputData =
-                            [
-                                'other.txt:2:world in second',
-                                'another.js:1:function world() { return "test"; }',
-                            ].join(EOL) + EOL;
+                            JSON.stringify({
+                                type: 'match',
+                                data: {
+                                    path: { text: 'other.txt' },
+                                    line_number: 2,
+                                    lines: { text: 'world in second\n' },
+                                },
+                            }) +
+                                '\n' +
+                                JSON.stringify({
+                                    type: 'match',
+                                    data: {
+                                        path: { text: 'another.js' },
+                                        line_number: 1,
+                                        lines: { text: 'function world() { return "test"; }\n' },
+                                    },
+                                }) +
+                                '\n';
                     }
                     if (stdoutDataHandler && outputData) {
                         stdoutDataHandler(Buffer.from(outputData));
@@ -467,19 +622,19 @@ describe('RipGrepTool', () => {
             const params = { pattern: 'world' };
             const invocation = multiDirGrepTool.build(params);
             const result = await invocation.execute(abortSignal);
-            // Should find matches in both directories
-            expect(result.llmContent).toContain('Found 5 matches for pattern "world"');
+            // Should find matches in CWD only (default behavior now)
+            expect(result.llmContent).toContain('Found 3 matches for pattern "world" in path "."');
             // Matches from first directory
             expect(result.llmContent).toContain('fileA.txt');
             expect(result.llmContent).toContain('L1: hello world');
             expect(result.llmContent).toContain('L2: second line with world');
             expect(result.llmContent).toContain('fileC.txt');
             expect(result.llmContent).toContain('L1: another world in sub dir');
-            // Matches from both directories
-            expect(result.llmContent).toContain('other.txt');
-            expect(result.llmContent).toContain('L2: world in second');
-            expect(result.llmContent).toContain('another.js');
-            expect(result.llmContent).toContain('L1: function world()');
+            // Should NOT find matches from second directory
+            expect(result.llmContent).not.toContain('other.txt');
+            expect(result.llmContent).not.toContain('world in second');
+            expect(result.llmContent).not.toContain('another.js');
+            expect(result.llmContent).not.toContain('function world()');
             // Clean up
             await fs.rm(secondDir, { recursive: true, force: true });
             mockSpawn.mockClear();
@@ -514,7 +669,14 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`fileC.txt:1:another world in sub dir${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'fileC.txt' },
+                                line_number: 1,
+                                lines: { text: 'another world in sub dir\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -524,7 +686,7 @@ describe('RipGrepTool', () => {
             });
             const multiDirGrepTool = new RipGrepTool(multiDirConfig);
             // Search only in the 'sub' directory of the first workspace
-            const params = { pattern: 'world', path: 'sub' };
+            const params = { pattern: 'world', dir_path: 'sub' };
             const invocation = multiDirGrepTool.build(params);
             const result = await invocation.execute(abortSignal);
             // Should only find matches in the specified sub directory
@@ -584,67 +746,31 @@ describe('RipGrepTool', () => {
     });
     describe('error handling and edge cases', () => {
         it('should handle workspace boundary violations', () => {
-            const params = { pattern: 'test', path: '../outside' };
+            const params = {
+                pattern: 'test',
+                dir_path: '../outside',
+            };
             expect(() => grepTool.build(params)).toThrow(/Path validation failed/);
         });
-        it('should handle empty directories gracefully', async () => {
-            const emptyDir = path.join(tempRootDir, 'empty');
-            await fs.mkdir(emptyDir);
-            // Setup specific mock for this test - searching in empty directory should return no matches
-            mockSpawn.mockImplementationOnce(() => {
-                const mockProcess = {
-                    stdout: {
-                        on: vi.fn(),
-                        removeListener: vi.fn(),
-                    },
-                    stderr: {
-                        on: vi.fn(),
-                        removeListener: vi.fn(),
-                    },
-                    on: vi.fn(),
-                    removeListener: vi.fn(),
-                    kill: vi.fn(),
-                };
-                setTimeout(() => {
-                    const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
-                    if (onClose) {
-                        onClose(1);
-                    }
-                }, 0);
-                return mockProcess;
-            });
-            const params = { pattern: 'test', path: 'empty' };
-            const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).toContain('No matches found');
-            expect(result.returnDisplay).toBe('No matches found');
-        });
-        it('should handle empty files correctly', async () => {
-            await fs.writeFile(path.join(tempRootDir, 'empty.txt'), '');
-            // Setup specific mock for this test - searching for anything in empty files should return no matches
-            mockSpawn.mockImplementationOnce(() => {
-                const mockProcess = {
-                    stdout: {
-                        on: vi.fn(),
-                        removeListener: vi.fn(),
-                    },
-                    stderr: {
-                        on: vi.fn(),
-                        removeListener: vi.fn(),
-                    },
-                    on: vi.fn(),
-                    removeListener: vi.fn(),
-                    kill: vi.fn(),
-                };
-                setTimeout(() => {
-                    const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
-                    if (onClose) {
-                        onClose(1);
-                    }
-                }, 0);
-                return mockProcess;
-            });
-            const params = { pattern: 'anything' };
+        it.each([
+            {
+                name: 'empty directories',
+                setup: async () => {
+                    const emptyDir = path.join(tempRootDir, 'empty');
+                    await fs.mkdir(emptyDir);
+                    return { pattern: 'test', dir_path: 'empty' };
+                },
+            },
+            {
+                name: 'empty files',
+                setup: async () => {
+                    await fs.writeFile(path.join(tempRootDir, 'empty.txt'), '');
+                    return { pattern: 'anything' };
+                },
+            },
+        ])('should handle $name gracefully', async ({ setup }) => {
+            mockSpawn.mockImplementationOnce(createMockSpawn({ exitCode: 1 }));
+            const params = await setup();
             const invocation = grepTool.build(params);
             const result = await invocation.execute(abortSignal);
             expect(result.llmContent).toContain('No matches found');
@@ -671,7 +797,14 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`${specialFileName}:1:hello world with special chars${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: specialFileName },
+                                line_number: 1,
+                                lines: { text: 'hello world with special chars\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -708,7 +841,14 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`a/b/c/d/e/deep.txt:1:content in deep directory${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'a/b/c/d/e/deep.txt' },
+                                line_number: 1,
+                                lines: { text: 'content in deep directory\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -745,7 +885,14 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`code.js:1:function getName() { return "test"; }${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'code.js' },
+                                line_number: 1,
+                                lines: { text: 'function getName() { return "test"; }\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -780,7 +927,33 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`case.txt:1:Hello World${EOL}case.txt:2:hello world${EOL}case.txt:3:HELLO WORLD${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'case.txt' },
+                                line_number: 1,
+                                lines: { text: 'Hello World\n' },
+                            },
+                        }) +
+                            '\n' +
+                            JSON.stringify({
+                                type: 'match',
+                                data: {
+                                    path: { text: 'case.txt' },
+                                    line_number: 2,
+                                    lines: { text: 'hello world\n' },
+                                },
+                            }) +
+                            '\n' +
+                            JSON.stringify({
+                                type: 'match',
+                                data: {
+                                    path: { text: 'case.txt' },
+                                    line_number: 3,
+                                    lines: { text: 'HELLO WORLD\n' },
+                                },
+                            }) +
+                            '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -816,7 +989,14 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`special.txt:1:Price: $19.99${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'special.txt' },
+                                line_number: 1,
+                                lines: { text: 'Price: $19.99\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -856,7 +1036,24 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`test.ts:1:typescript content${EOL}test.tsx:1:tsx content${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'test.ts' },
+                                line_number: 1,
+                                lines: { text: 'typescript content\n' },
+                            },
+                        }) +
+                            '\n' +
+                            JSON.stringify({
+                                type: 'match',
+                                data: {
+                                    path: { text: 'test.tsx' },
+                                    line_number: 1,
+                                    lines: { text: 'tsx content\n' },
+                                },
+                            }) +
+                            '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -898,7 +1095,14 @@ describe('RipGrepTool', () => {
                     const onData = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
                     const onClose = mockProcess.on.mock.calls.find((call) => call[0] === 'close')?.[1];
                     if (onData) {
-                        onData(Buffer.from(`src/main.ts:1:source code${EOL}`));
+                        onData(Buffer.from(JSON.stringify({
+                            type: 'match',
+                            data: {
+                                path: { text: 'src/main.ts' },
+                                line_number: 1,
+                                lines: { text: 'source code\n' },
+                            },
+                        }) + '\n'));
                     }
                     if (onClose) {
                         onClose(0);
@@ -916,34 +1120,161 @@ describe('RipGrepTool', () => {
             expect(result.llmContent).not.toContain('other.ts');
         });
     });
-    describe('getDescription', () => {
-        it('should generate correct description with pattern only', () => {
-            const params = { pattern: 'testPattern' };
+    describe('advanced search options', () => {
+        it('should handle case_sensitive parameter', async () => {
+            // Case-insensitive search (default)
+            mockSpawn.mockImplementationOnce(createMockSpawn({
+                outputData: JSON.stringify({
+                    type: 'match',
+                    data: {
+                        path: { text: 'fileA.txt' },
+                        line_number: 1,
+                        lines: { text: 'hello world\n' },
+                    },
+                }) + '\n',
+                exitCode: 0,
+            }));
+            let params = { pattern: 'HELLO' };
+            let invocation = grepTool.build(params);
+            let result = await invocation.execute(abortSignal);
+            expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.arrayContaining(['--ignore-case']), expect.anything());
+            expect(result.llmContent).toContain('Found 1 match for pattern "HELLO"');
+            expect(result.llmContent).toContain('L1: hello world');
+            // Case-sensitive search
+            mockSpawn.mockImplementationOnce(createMockSpawn({
+                outputData: JSON.stringify({
+                    type: 'match',
+                    data: {
+                        path: { text: 'fileA.txt' },
+                        line_number: 1,
+                        lines: { text: 'HELLO world\n' },
+                    },
+                }) + '\n',
+                exitCode: 0,
+            }));
+            params = { pattern: 'HELLO', case_sensitive: true };
+            invocation = grepTool.build(params);
+            result = await invocation.execute(abortSignal);
+            expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.not.arrayContaining(['--ignore-case']), expect.anything());
+            expect(result.llmContent).toContain('Found 1 match for pattern "HELLO"');
+            expect(result.llmContent).toContain('L1: HELLO world');
+        });
+        it.each([
+            {
+                name: 'fixed_strings parameter',
+                params: { pattern: 'hello.world', fixed_strings: true },
+                mockOutput: {
+                    path: { text: 'fileA.txt' },
+                    line_number: 1,
+                    lines: { text: 'hello.world\n' },
+                },
+                expectedArgs: ['--fixed-strings'],
+                expectedPattern: 'hello.world',
+            },
+        ])('should handle $name', async ({ params, mockOutput, expectedArgs, expectedPattern }) => {
+            mockSpawn.mockImplementationOnce(createMockSpawn({
+                outputData: JSON.stringify({ type: 'match', data: mockOutput }) + '\n',
+                exitCode: 0,
+            }));
+            const invocation = grepTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.arrayContaining(expectedArgs), expect.anything());
+            expect(result.llmContent).toContain(`Found 1 match for pattern "${expectedPattern}"`);
+        });
+        it('should handle no_ignore parameter', async () => {
+            mockSpawn.mockImplementationOnce(createMockSpawn({
+                outputData: JSON.stringify({
+                    type: 'match',
+                    data: {
+                        path: { text: 'ignored.log' },
+                        line_number: 1,
+                        lines: { text: 'secret log entry\n' },
+                    },
+                }) + '\n',
+                exitCode: 0,
+            }));
+            const params = { pattern: 'secret', no_ignore: true };
             const invocation = grepTool.build(params);
-            expect(invocation.getDescription()).toBe("'testPattern'");
+            const result = await invocation.execute(abortSignal);
+            expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.arrayContaining(['--no-ignore']), expect.anything());
+            expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.not.arrayContaining(['--glob', '!node_modules']), expect.anything());
+            expect(result.llmContent).toContain('Found 1 match for pattern "secret"');
+            expect(result.llmContent).toContain('File: ignored.log');
+            expect(result.llmContent).toContain('L1: secret log entry');
         });
-        it('should generate correct description with pattern and include', () => {
+        it('should handle context parameters', async () => {
+            mockSpawn.mockImplementationOnce(createMockSpawn({
+                outputData: JSON.stringify({
+                    type: 'match',
+                    data: {
+                        path: { text: 'fileA.txt' },
+                        line_number: 2,
+                        lines: { text: 'second line with world\n' },
+                        lines_before: [{ text: 'hello world\n' }],
+                        lines_after: [
+                            { text: 'third line\n' },
+                            { text: 'fourth line\n' },
+                        ],
+                    },
+                }) + '\n',
+                exitCode: 0,
+            }));
             const params = {
-                pattern: 'testPattern',
-                include: '*.ts',
+                pattern: 'world',
+                context: 1,
+                after: 2,
+                before: 1,
             };
             const invocation = grepTool.build(params);
-            expect(invocation.getDescription()).toBe("'testPattern' in *.ts");
+            const result = await invocation.execute(abortSignal);
+            expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.arrayContaining([
+                '--context',
+                '1',
+                '--after-context',
+                '2',
+                '--before-context',
+                '1',
+            ]), expect.anything());
+            expect(result.llmContent).toContain('Found 1 match for pattern "world"');
+            expect(result.llmContent).toContain('File: fileA.txt');
+            expect(result.llmContent).toContain('L2: second line with world');
+            // Note: Ripgrep JSON output for context lines doesn't include line numbers for context lines directly
+            // The current parsing only extracts the matched line, so we only assert on that.
+        });
+    });
+    describe('getDescription', () => {
+        it.each([
+            {
+                name: 'pattern only',
+                params: { pattern: 'testPattern' },
+                expected: "'testPattern' within ./",
+            },
+            {
+                name: 'pattern and include',
+                params: { pattern: 'testPattern', include: '*.ts' },
+                expected: "'testPattern' in *.ts within ./",
+            },
+            {
+                name: 'root path in description',
+                params: { pattern: 'testPattern', dir_path: '.' },
+                expected: "'testPattern' within ./",
+            },
+        ])('should generate correct description with $name', ({ params, expected }) => {
+            const invocation = grepTool.build(params);
+            expect(invocation.getDescription()).toBe(expected);
         });
         it('should generate correct description with pattern and path', async () => {
             const dirPath = path.join(tempRootDir, 'src', 'app');
             await fs.mkdir(dirPath, { recursive: true });
             const params = {
                 pattern: 'testPattern',
-                path: path.join('src', 'app'),
+                dir_path: path.join('src', 'app'),
             };
             const invocation = grepTool.build(params);
-            // The path will be relative to the tempRootDir, so we check for containment.
             expect(invocation.getDescription()).toContain("'testPattern' within");
             expect(invocation.getDescription()).toContain(path.join('src', 'app'));
         });
-        it('should indicate searching across all workspace directories when no path specified', () => {
-            // Create a mock config with multiple directories
+        it('should use ./ when no path is specified (defaults to CWD)', () => {
             const multiDirConfig = {
                 getTargetDir: () => tempRootDir,
                 getWorkspaceContext: () => createMockWorkspaceContext(tempRootDir, ['/another/dir']),
@@ -952,7 +1283,7 @@ describe('RipGrepTool', () => {
             const multiDirGrepTool = new RipGrepTool(multiDirConfig);
             const params = { pattern: 'testPattern' };
             const invocation = multiDirGrepTool.build(params);
-            expect(invocation.getDescription()).toBe("'testPattern' across all workspace directories");
+            expect(invocation.getDescription()).toBe("'testPattern' within ./");
         });
         it('should generate correct description with pattern, include, and path', async () => {
             const dirPath = path.join(tempRootDir, 'src', 'app');
@@ -960,17 +1291,15 @@ describe('RipGrepTool', () => {
             const params = {
                 pattern: 'testPattern',
                 include: '*.ts',
-                path: path.join('src', 'app'),
+                dir_path: path.join('src', 'app'),
             };
             const invocation = grepTool.build(params);
             expect(invocation.getDescription()).toContain("'testPattern' in *.ts within");
             expect(invocation.getDescription()).toContain(path.join('src', 'app'));
         });
-        it('should use ./ for root path in description', () => {
-            const params = { pattern: 'testPattern', path: '.' };
-            const invocation = grepTool.build(params);
-            expect(invocation.getDescription()).toBe("'testPattern' within ./");
-        });
     });
 });
+afterAll(() => {
+    storageSpy.mockRestore();
+});
 //# sourceMappingURL=ripGrep.test.js.map