@machina.ai/cell-cli-core 1.38.1-rc2 → 1.40.1-rc2

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

@@ -3,145 +3,58 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi, } from 'vitest';
-import { canUseRipgrep, RipGrepTool, ensureRgPath, } from './ripGrep.js';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { canUseRipgrep, RipGrepTool, ensureRgPath, getRipgrepPath, } from './ripGrep.js';
 import path from 'node:path';
 import { isSubpath } from '../utils/paths.js';
 import fs from 'node:fs/promises';
 import os from 'node:os';
-import { Storage } from '../config/storage.js';
 import { GEMINI_IGNORE_FILE_NAME } from '../config/constants.js';
 import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
 import { spawn } from 'node:child_process';
 import { PassThrough, Readable } from 'node:stream';
 import EventEmitter from 'node:events';
-import { downloadRipGrep } from '@joshua.litt/get-ripgrep';
 import { createMockMessageBus } from '../test-utils/mock-message-bus.js';
-// Mock dependencies for canUseRipgrep
-vi.mock('@joshua.litt/get-ripgrep', () => ({
-    downloadRipGrep: vi.fn(),
-}));
+import { fileExists } from '../utils/fileUtils.js';
+vi.mock('../utils/fileUtils.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        fileExists: vi.fn(),
+    };
+});
 // 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', () => {
-    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 });
+    beforeEach(() => {
+        vi.mocked(fileExists).mockReset();
     });
     it('should return true if ripgrep already exists', async () => {
-        const existingPath = path.join(binDir, getRipgrepBinaryName());
-        await fs.writeFile(existingPath, '');
+        vi.mocked(fileExists).mockResolvedValue(true);
         const result = await canUseRipgrep();
         expect(result).toBe(true);
-        expect(downloadRipGrepMock).not.toHaveBeenCalled();
     });
-    it('should download ripgrep and return true if it does not exist initially', async () => {
-        const expectedPath = path.join(binDir, getRipgrepBinaryName());
-        downloadRipGrepMock.mockImplementation(async () => {
-            await fs.writeFile(expectedPath, '');
-        });
-        const result = await canUseRipgrep();
-        expect(result).toBe(true);
-        expect(downloadRipGrep).toHaveBeenCalledWith(binDir);
-        await expect(fs.access(expectedPath)).resolves.toBeUndefined();
-    });
-    it('should return false if download fails and file does not exist', async () => {
+    it('should return false if file does not exist', async () => {
+        vi.mocked(fileExists).mockResolvedValue(false);
         const result = await canUseRipgrep();
         expect(result).toBe(false);
-        expect(downloadRipGrep).toHaveBeenCalledWith(binDir);
-    });
-    it('should propagate errors from downloadRipGrep', async () => {
-        const error = new Error('Download failed');
-        downloadRipGrepMock.mockRejectedValue(error);
-        await expect(canUseRipgrep()).rejects.toThrow(error);
-        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', () => {
-    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 });
+    beforeEach(() => {
+        vi.mocked(fileExists).mockReset();
     });
     it('should return rg path if ripgrep already exists', async () => {
-        const existingPath = path.join(binDir, getRipgrepBinaryName());
-        await fs.writeFile(existingPath, '');
+        vi.mocked(fileExists).mockResolvedValue(true);
         const rgPath = await ensureRgPath();
-        expect(rgPath).toBe(existingPath);
-        expect(downloadRipGrep).not.toHaveBeenCalled();
-    });
-    it('should return rg path if ripgrep is downloaded successfully', async () => {
-        const expectedPath = path.join(binDir, getRipgrepBinaryName());
-        downloadRipGrepMock.mockImplementation(async () => {
-            await fs.writeFile(expectedPath, '');
-        });
-        const rgPath = await ensureRgPath();
-        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 () => {
-        await expect(ensureRgPath()).rejects.toThrow('Cannot use ripgrep.');
-        expect(downloadRipGrep).toHaveBeenCalledTimes(1);
+        expect(rgPath).toBe(await getRipgrepPath());
     });
-    it('should propagate errors from downloadRipGrep', async () => {
-        const error = new Error('Download failed');
-        downloadRipGrepMock.mockRejectedValue(error);
-        await expect(ensureRgPath()).rejects.toThrow(error);
-        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();
+    it('should throw an error if ripgrep cannot be used', async () => {
+        vi.mocked(fileExists).mockResolvedValue(false);
+        await expect(ensureRgPath()).rejects.toThrow(/Cannot find bundled ripgrep binary/);
     });
 });
 // Helper function to create mock spawn implementations
@@ -179,9 +92,6 @@ function createMockSpawn(options = {}) {
 }
 describe('RipGrepTool', () => {
     let tempRootDir;
-    let tempBinRoot;
-    let binDir;
-    let ripgrepBinaryPath;
     let grepTool;
     const abortSignal = new AbortController().signal;
     let mockConfig = {
@@ -196,18 +106,10 @@ describe('RipGrepTool', () => {
         }),
     };
     beforeEach(async () => {
-        downloadRipGrepMock.mockReset();
-        downloadRipGrepMock.mockResolvedValue(undefined);
         mockSpawn.mockReset();
         mockSpawn.mockImplementation(createMockSpawn());
-        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-'));
+        vi.mocked(fileExists).mockResolvedValue(true);
         mockConfig = {
             getTargetDir: () => tempRootDir,
             getWorkspaceContext: () => createMockWorkspaceContext(tempRootDir),
@@ -247,9 +149,7 @@ 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.each([
@@ -332,7 +232,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'world' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             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');
@@ -365,7 +265,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'world' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('File: ..env');
             expect(result.llmContent).toContain('L1: world in ..env');
             expect(result.llmContent).not.toContain('secret.txt');
@@ -385,7 +285,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'world', dir_path: 'sub' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Found 1 match for pattern "world" in path "sub"');
             expect(result.llmContent).toContain('File: fileC.txt'); // Path relative to 'sub'
             expect(result.llmContent).toContain('L1: another world in sub dir');
@@ -409,7 +309,7 @@ describe('RipGrepTool', () => {
                 include_pattern: '*.js',
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             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"; }');
@@ -435,7 +335,7 @@ describe('RipGrepTool', () => {
                 include_pattern: '*.js',
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Found 1 match for pattern "hello" in path "sub" (filter: "*.js")');
             expect(result.llmContent).toContain('File: another.js');
             expect(result.llmContent).toContain('L1: const greeting = "hello";');
@@ -448,7 +348,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'nonexistentpattern' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('No matches found for pattern "nonexistentpattern" in path ".".');
             expect(result.returnDisplay.summary).toBe('No matches found');
         });
@@ -466,7 +366,7 @@ describe('RipGrepTool', () => {
                 pattern: 'foo',
                 dir_path: tempRootDir,
             });
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Process exited with code 2');
             expect(result.returnDisplay).toContain('Error: Process exited with code 2');
         });
@@ -525,7 +425,7 @@ describe('RipGrepTool', () => {
                 pattern: 'test',
                 dir_path: tempRootDir,
             });
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.returnDisplay.summary).toContain('(limited)');
         }, 10000);
         it('should filter out files based on FileDiscoveryService even if ripgrep returns them', async () => {
@@ -557,7 +457,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'should' };
             const invocation = toolWithIgnore.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             // Verify ignored file is filtered out
             expect(result.llmContent).toContain('allowed.txt');
             expect(result.llmContent).toContain('should be kept');
@@ -580,7 +480,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'foo.*bar' }; // Matches 'const foo = "bar";'
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             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";');
@@ -610,7 +510,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'HELLO' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             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');
@@ -622,14 +522,13 @@ describe('RipGrepTool', () => {
             expect(() => grepTool.build(params)).toThrow(/params must have required property 'pattern'/);
         });
         it('should throw an error if ripgrep is not available', async () => {
-            await fs.rm(ripgrepBinaryPath, { force: true });
-            downloadRipGrepMock.mockResolvedValue(undefined);
+            vi.mocked(fileExists).mockResolvedValue(false);
             const params = { pattern: 'world' };
             const invocation = grepTool.build(params);
-            expect(await invocation.execute(abortSignal)).toStrictEqual({
-                llmContent: 'Error during grep search operation: Cannot use ripgrep.',
-                returnDisplay: 'Error: Cannot use ripgrep.',
-            });
+            const result = await invocation.execute({ abortSignal });
+            expect(result.llmContent).toContain('Cannot find bundled ripgrep binary');
+            // restore the mock for subsequent tests
+            vi.mocked(fileExists).mockResolvedValue(true);
         });
     });
     describe('multi-directory workspace', () => {
@@ -703,7 +602,7 @@ describe('RipGrepTool', () => {
             const multiDirGrepTool = new RipGrepTool(multiDirConfig, createMockMessageBus());
             const params = { pattern: 'world' };
             const invocation = multiDirGrepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             // 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
@@ -772,7 +671,7 @@ describe('RipGrepTool', () => {
             // Search only in the 'sub' directory of the first workspace
             const params = { pattern: 'world', dir_path: 'sub' };
             const invocation = multiDirGrepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             // Should only find matches in the specified sub directory
             expect(result.llmContent).toContain('Found 1 match for pattern "world" in path "sub"');
             expect(result.llmContent).toContain('File: fileC.txt');
@@ -789,7 +688,9 @@ describe('RipGrepTool', () => {
             const params = { pattern: 'world' };
             const invocation = grepTool.build(params);
             controller.abort();
-            const result = await invocation.execute(controller.signal);
+            const result = await invocation.execute({
+                abortSignal: controller.signal,
+            });
             expect(result).toBeDefined();
         });
         it('should abort streaming search when signal is triggered', async () => {
@@ -803,7 +704,9 @@ describe('RipGrepTool', () => {
             const invocation = grepTool.build(params);
             // Abort immediately before starting the search
             controller.abort();
-            const result = await invocation.execute(controller.signal);
+            const result = await invocation.execute({
+                abortSignal: controller.signal,
+            });
             expect(result.returnDisplay.summary).toContain('No matches found');
         });
     });
@@ -835,7 +738,7 @@ describe('RipGrepTool', () => {
             mockSpawn.mockImplementation(createMockSpawn({ exitCode: 1 }));
             const params = await setup();
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('No matches found');
         });
         it('should handle special characters in file names', async () => {
@@ -854,7 +757,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'world' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain(specialFileName);
             expect(result.llmContent).toContain('hello world with special chars');
         });
@@ -875,7 +778,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'deep' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('deep.txt');
             expect(result.llmContent).toContain('content in deep directory');
         });
@@ -899,7 +802,7 @@ describe('RipGrepTool', () => {
                 context: 0,
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('function getName()');
             expect(result.llmContent).not.toContain('const getValue');
         });
@@ -937,7 +840,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'hello' };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Hello World');
             expect(result.llmContent).toContain('hello world');
             expect(result.llmContent).toContain('HELLO WORLD');
@@ -960,7 +863,7 @@ describe('RipGrepTool', () => {
                 context: 0,
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Price: $19.99');
             expect(result.llmContent).not.toContain('Email: test@example.com');
         });
@@ -997,7 +900,7 @@ describe('RipGrepTool', () => {
                 include_pattern: '*.{ts,tsx}',
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('test.ts');
             expect(result.llmContent).toContain('test.tsx');
             expect(result.llmContent).not.toContain('test.js');
@@ -1023,7 +926,7 @@ describe('RipGrepTool', () => {
                 include_pattern: 'src/**',
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('main.ts');
             expect(result.llmContent).not.toContain('other.ts');
         });
@@ -1044,7 +947,7 @@ describe('RipGrepTool', () => {
             }));
             let params = { pattern: 'HELLO', context: 0 };
             let invocation = grepTool.build(params);
-            let result = await invocation.execute(abortSignal);
+            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');
@@ -1062,7 +965,7 @@ describe('RipGrepTool', () => {
             }));
             params = { pattern: 'HELLO', case_sensitive: true, context: 0 };
             invocation = grepTool.build(params);
-            result = await invocation.execute(abortSignal);
+            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');
@@ -1083,7 +986,7 @@ describe('RipGrepTool', () => {
                 pattern: 'hello.world',
                 fixed_strings: true,
             });
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             const spawnArgs = mockSpawn.mock.calls[0][1];
             expect(spawnArgs).toContain('--fixed-strings');
             expect(spawnArgs).toContain('--regexp');
@@ -1114,7 +1017,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'secret', no_ignore: true };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            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"');
@@ -1166,7 +1069,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'secret' };
             const invocation = gitIgnoreDisabledTool.build(params);
-            await invocation.execute(abortSignal);
+            await invocation.execute({ abortSignal });
             expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.arrayContaining(['--no-ignore-vcs', '--no-ignore-exclude']), expect.anything());
         });
         it('should add .geminiignore when enabled and patterns exist', async () => {
@@ -1216,7 +1119,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'secret' };
             const invocation = geminiIgnoreTool.build(params);
-            await invocation.execute(abortSignal);
+            await invocation.execute({ abortSignal });
             expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.arrayContaining(['--ignore-file', geminiIgnorePath]), expect.anything());
         });
         it('should skip .geminiignore when disabled', async () => {
@@ -1266,7 +1169,7 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'secret' };
             const invocation = geminiIgnoreTool.build(params);
-            await invocation.execute(abortSignal);
+            await invocation.execute({ abortSignal });
             expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.not.arrayContaining(['--ignore-file', geminiIgnorePath]), expect.anything());
         });
         it('should handle context parameters', async () => {
@@ -1316,7 +1219,7 @@ describe('RipGrepTool', () => {
                 before: 1,
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(mockSpawn).toHaveBeenLastCalledWith(expect.anything(), expect.arrayContaining([
                 '--context',
                 '1',
@@ -1430,7 +1333,7 @@ describe('RipGrepTool', () => {
                 max_matches_per_file: 1,
             };
             const invocation = grepTool.build(params);
-            await invocation.execute(abortSignal);
+            await invocation.execute({ abortSignal });
             const spawnArgs = mockSpawn.mock.calls[0][1];
             expect(spawnArgs).toContain('--max-count');
             expect(spawnArgs).toContain('1');
@@ -1473,7 +1376,7 @@ describe('RipGrepTool', () => {
                 context: 0,
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Found 2 matches');
             expect(result.llmContent).toContain('results limited to 2 matches for performance');
             expect(result.llmContent).toContain('L1: match 1');
@@ -1508,7 +1411,7 @@ describe('RipGrepTool', () => {
                 names_only: true,
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Found 2 files with matches');
             expect(result.llmContent).toContain('fileA.txt');
             expect(result.llmContent).toContain('fileB.txt');
@@ -1543,7 +1446,7 @@ describe('RipGrepTool', () => {
                 context: 0,
             };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             expect(result.llmContent).toContain('Found 1 match');
             expect(result.llmContent).toContain('fileA.txt');
             expect(result.llmContent).not.toContain('fileB.txt');
@@ -1564,14 +1467,57 @@ describe('RipGrepTool', () => {
             }));
             const params = { pattern: 'Target match', context: 0 };
             const invocation = grepTool.build(params);
-            const result = await invocation.execute(abortSignal);
+            const result = await invocation.execute({ abortSignal });
             // MAX_LINE_LENGTH_TEXT_FILE is 2000. It should be truncated.
             expect(result.llmContent).toContain('... [truncated]');
             expect(result.llmContent).not.toContain(longString);
         });
     });
 });
-afterAll(() => {
-    storageSpy.mockRestore();
+describe('getRipgrepPath', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('OS/Architecture Resolution', () => {
+        it.each([
+            { platform: 'darwin', arch: 'arm64', expectedBin: 'rg-darwin-arm64' },
+            { platform: 'darwin', arch: 'x64', expectedBin: 'rg-darwin-x64' },
+            { platform: 'linux', arch: 'arm64', expectedBin: 'rg-linux-arm64' },
+            { platform: 'linux', arch: 'x64', expectedBin: 'rg-linux-x64' },
+            { platform: 'win32', arch: 'x64', expectedBin: 'rg-win32-x64.exe' },
+        ])('should map $platform $arch to $expectedBin', async ({ platform, arch, expectedBin }) => {
+            vi.spyOn(os, 'platform').mockReturnValue(platform);
+            vi.spyOn(os, 'arch').mockReturnValue(arch);
+            vi.mocked(fileExists).mockImplementation(async (checkPath) => checkPath.endsWith(expectedBin));
+            const resolvedPath = await getRipgrepPath();
+            expect(resolvedPath).not.toBeNull();
+            expect(resolvedPath?.endsWith(expectedBin)).toBe(true);
+        });
+    });
+    describe('Path Fallback Logic', () => {
+        beforeEach(() => {
+            vi.spyOn(os, 'platform').mockReturnValue('linux');
+            vi.spyOn(os, 'arch').mockReturnValue('x64');
+        });
+        it('should resolve the SEA (flattened) path first', async () => {
+            vi.mocked(fileExists).mockImplementation(async (checkPath) => checkPath.includes(path.normalize('tools/vendor/ripgrep')));
+            const resolvedPath = await getRipgrepPath();
+            expect(resolvedPath).not.toBeNull();
+            expect(resolvedPath).toContain(path.normalize('tools/vendor/ripgrep'));
+        });
+        it('should fall back to the Dev path if SEA path is missing', async () => {
+            vi.mocked(fileExists).mockImplementation(async (checkPath) => checkPath.includes(path.normalize('core/vendor/ripgrep')) &&
+                !checkPath.includes(path.join(path.sep, 'tools', path.sep)));
+            const resolvedPath = await getRipgrepPath();
+            expect(resolvedPath).not.toBeNull();
+            expect(resolvedPath).toContain(path.normalize('core/vendor/ripgrep'));
+            expect(resolvedPath).not.toContain(path.join(path.sep, 'tools', path.sep));
+        });
+        it('should return null if binary is missing from both paths', async () => {
+            vi.mocked(fileExists).mockResolvedValue(false);
+            const resolvedPath = await getRipgrepPath();
+            expect(resolvedPath).toBeNull();
+        });
+    });
 });
 //# sourceMappingURL=ripGrep.test.js.map