viberag 0.1.0

package/dist/rag/__tests__/rag.test.js

@@ -0,0 +1,311 @@
+/**
+ * E2E tests for the RAG system.
+ *
+ * Tests system behavior, not library correctness:
+ * - Merkle tree correctly detects file changes
+ * - Search returns expected files for known queries
+ * - Incremental indexing only reprocesses what changed
+ * - Manifest persistence enables recovery
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Indexer } from '../indexer/indexer.js';
+import { SearchEngine } from '../search/index.js';
+import { copyFixtureToTemp, addFile, modifyFile, deleteFile, waitForFs, } from './helpers.js';
+describe('RAG E2E', () => {
+    let ctx;
+    beforeEach(async () => {
+        ctx = await copyFixtureToTemp('codebase');
+    });
+    afterEach(async () => {
+        await ctx.cleanup();
+    });
+    it('indexes codebase and finds files by semantic search', async () => {
+        // Index fixture
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // Search for math operations → should find math.py
+        const search = new SearchEngine(ctx.projectRoot);
+        const mathResults = await search.search('add two numbers calculate sum');
+        expect(mathResults.results.some(r => r.filepath.includes('math.py'))).toBe(true);
+        // Search for HTTP/API → should find http_client.ts
+        const httpResults = await search.search('fetch data API request');
+        expect(httpResults.results.some(r => r.filepath.includes('http_client.ts'))).toBe(true);
+        // Search for string/date → should find utils.js
+        const utilsResults = await search.search('format string parse date');
+        expect(utilsResults.results.some(r => r.filepath.includes('utils.js'))).toBe(true);
+        search.close();
+    }, 60000);
+    it('detects new/modified/deleted files correctly', async () => {
+        // Initial index
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // Add new file
+        await addFile(ctx.projectRoot, 'new_module.py', 'def new_function():\n    return "new"\n');
+        // Modify existing file
+        await modifyFile(ctx.projectRoot, 'math.py', '# Modified file\ndef add(a, b):\n    return a + b\n');
+        // Delete a file
+        await deleteFile(ctx.projectRoot, 'utils.js');
+        await waitForFs();
+        // Reindex
+        const indexer2 = new Indexer(ctx.projectRoot);
+        const stats = await indexer2.index();
+        indexer2.close();
+        expect(stats.filesNew).toBe(1);
+        expect(stats.filesModified).toBe(1);
+        expect(stats.filesDeleted).toBe(1);
+    }, 60000);
+    it('skips unchanged files on reindex', async () => {
+        // Initial index
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // Reindex with no changes
+        const indexer2 = new Indexer(ctx.projectRoot);
+        const stats = await indexer2.index();
+        indexer2.close();
+        expect(stats.filesNew).toBe(0);
+        expect(stats.filesModified).toBe(0);
+        expect(stats.filesDeleted).toBe(0);
+        expect(stats.chunksAdded).toBe(0);
+    }, 60000);
+    it('recovers state from manifest after restart', async () => {
+        // Index
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // "Restart" - create new indexer instance
+        const indexer2 = new Indexer(ctx.projectRoot);
+        const stats = await indexer2.index();
+        indexer2.close();
+        // Should detect no changes (recovered from manifest)
+        expect(stats.filesNew).toBe(0);
+        expect(stats.filesModified).toBe(0);
+        expect(stats.filesDeleted).toBe(0);
+    }, 60000);
+    it('reindexes all files with force=true', async () => {
+        // Initial index
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // Force reindex
+        const indexer2 = new Indexer(ctx.projectRoot);
+        const stats = await indexer2.index({ force: true });
+        indexer2.close();
+        // All files treated as new (5 files in fixture)
+        expect(stats.filesNew).toBeGreaterThanOrEqual(4); // fixture file count (empty.py may not produce chunks)
+        expect(stats.chunksAdded).toBeGreaterThan(0);
+        // Embeddings should be cached from first run
+        expect(stats.embeddingsCached).toBeGreaterThan(0);
+    }, 60000);
+    it('removes deleted files from search results', async () => {
+        // Initial index
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // Verify math.py is searchable
+        const search = new SearchEngine(ctx.projectRoot);
+        let results = await search.search('add two numbers');
+        expect(results.results.some(r => r.filepath.includes('math.py'))).toBe(true);
+        search.close();
+        // Delete math.py
+        await deleteFile(ctx.projectRoot, 'math.py');
+        await waitForFs();
+        // Reindex
+        const indexer2 = new Indexer(ctx.projectRoot);
+        await indexer2.index();
+        indexer2.close();
+        // Should no longer appear in results
+        const search2 = new SearchEngine(ctx.projectRoot);
+        results = await search2.search('add two numbers');
+        expect(results.results.some(r => r.filepath.includes('math.py'))).toBe(false);
+        search2.close();
+    }, 60000);
+});
+describe('Search modes', () => {
+    let ctx;
+    beforeEach(async () => {
+        ctx = await copyFixtureToTemp('codebase');
+        // Index the fixture
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+    });
+    afterEach(async () => {
+        await ctx.cleanup();
+    });
+    it('vector search finds semantically similar content', async () => {
+        const search = new SearchEngine(ctx.projectRoot);
+        // "calculate sum" should find math.py via semantic similarity
+        const results = await search.searchVector('calculate sum', 5);
+        expect(results.results.some(r => r.filepath.includes('math.py'))).toBe(true);
+        search.close();
+    }, 60000);
+    it('FTS search finds exact keyword matches', async () => {
+        const search = new SearchEngine(ctx.projectRoot);
+        // "fetchData" exact match in http_client.ts
+        const results = await search.searchFts('fetchData', 5);
+        expect(results.results.some(r => r.filepath.includes('http_client.ts'))).toBe(true);
+        search.close();
+    }, 60000);
+    it('hybrid search returns results with both scores', async () => {
+        const search = new SearchEngine(ctx.projectRoot);
+        const results = await search.search('API request fetch');
+        expect(results.results.some(r => r.filepath.includes('http_client.ts'))).toBe(true);
+        // Results should have both vector and FTS scores
+        if (results.results.length > 0) {
+            expect(results.results[0]).toHaveProperty('vectorScore');
+            expect(results.results[0]).toHaveProperty('ftsScore');
+        }
+        search.close();
+    }, 60000);
+});
+describe('Edge cases', () => {
+    let ctx;
+    beforeEach(async () => {
+        ctx = await copyFixtureToTemp('codebase');
+    });
+    afterEach(async () => {
+        await ctx.cleanup();
+    });
+    it('handles empty files gracefully', async () => {
+        // empty.py is already in fixture (0 bytes)
+        const indexer = new Indexer(ctx.projectRoot);
+        const stats = await indexer.index();
+        indexer.close();
+        // Should not crash, empty file counted but produces no chunks
+        expect(stats.filesScanned).toBeGreaterThan(0);
+    }, 60000);
+    it('indexes files with unicode content', async () => {
+        // unicode_content.js has Korean, emoji, Chinese
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        const search = new SearchEngine(ctx.projectRoot);
+        const results = await search.search('Korean greeting emoji');
+        expect(results.results.some(r => r.filepath.includes('unicode_content'))).toBe(true);
+        search.close();
+    }, 60000);
+    it('handles files with syntax errors gracefully', async () => {
+        // Add malformed file
+        await addFile(ctx.projectRoot, 'broken.ts', 'function { broken syntax');
+        await waitForFs();
+        const indexer = new Indexer(ctx.projectRoot);
+        const stats = await indexer.index();
+        indexer.close();
+        // Should still index (as module chunk), not crash
+        expect(stats.chunksAdded).toBeGreaterThan(0);
+    }, 60000);
+});
+describe('Error handling', () => {
+    let ctx;
+    beforeEach(async () => {
+        ctx = await copyFixtureToTemp('codebase');
+    });
+    afterEach(async () => {
+        await ctx.cleanup();
+    });
+    it('continues indexing when one file fails to parse', async () => {
+        // Add broken file alongside good files
+        await addFile(ctx.projectRoot, 'broken.ts', 'const x = {{{');
+        await addFile(ctx.projectRoot, 'good.ts', 'export function works() { return 1; }');
+        await waitForFs();
+        const indexer = new Indexer(ctx.projectRoot);
+        const stats = await indexer.index();
+        indexer.close();
+        // Both files processed
+        expect(stats.chunksAdded).toBeGreaterThan(0);
+        // Good file should be searchable
+        const search = new SearchEngine(ctx.projectRoot);
+        const results = await search.search('works function export');
+        expect(results.results.some(r => r.filepath.includes('good.ts'))).toBe(true);
+        search.close();
+    }, 60000);
+    it('skips binary files without error', async () => {
+        // Add binary content (PNG header bytes)
+        const binaryContent = Buffer.from([
+            0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+        ]).toString('binary');
+        await addFile(ctx.projectRoot, 'image.png', binaryContent);
+        await waitForFs();
+        const indexer = new Indexer(ctx.projectRoot);
+        // Should not crash
+        const stats = await indexer.index();
+        indexer.close();
+        // Index should complete successfully
+        expect(stats.filesScanned).toBeGreaterThan(0);
+    }, 60000);
+});
+describe('Subdirectory indexing', () => {
+    let ctx;
+    beforeEach(async () => {
+        ctx = await copyFixtureToTemp('codebase');
+    });
+    afterEach(async () => {
+        await ctx.cleanup();
+    });
+    it('indexes files in nested subdirectories', async () => {
+        const indexer = new Indexer(ctx.projectRoot);
+        const stats = await indexer.index();
+        indexer.close();
+        // Should have indexed all nested files (5 original + 10 nested = 15)
+        // Note: empty.py may not produce chunks
+        expect(stats.filesScanned).toBeGreaterThanOrEqual(10);
+        // Should find deeply nested file via search
+        const search = new SearchEngine(ctx.projectRoot);
+        const results = await search.search('flatten deeply nested array');
+        expect(results.results.some(r => r.filepath.includes('deep/nested'))).toBe(true);
+        search.close();
+    }, 60000);
+    it('detects changes in deeply nested files', async () => {
+        // Initial index
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // Modify file 3 levels deep
+        await modifyFile(ctx.projectRoot, 'src/components/forms/LoginForm.tsx', '// modified login form\nexport function LoginForm() { return null; }');
+        await waitForFs();
+        // Reindex
+        const indexer2 = new Indexer(ctx.projectRoot);
+        const stats = await indexer2.index();
+        indexer2.close();
+        expect(stats.filesModified).toBe(1);
+    }, 60000);
+    it('removes chunks when nested file deleted', async () => {
+        // Initial index
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        // Verify file is searchable
+        const search1 = new SearchEngine(ctx.projectRoot);
+        let results = await search1.search('LoginForm authentication login');
+        expect(results.results.some(r => r.filepath.includes('LoginForm'))).toBe(true);
+        search1.close();
+        // Delete nested file
+        await deleteFile(ctx.projectRoot, 'src/components/forms/LoginForm.tsx');
+        await waitForFs();
+        // Reindex
+        const indexer2 = new Indexer(ctx.projectRoot);
+        const stats = await indexer2.index();
+        indexer2.close();
+        expect(stats.filesDeleted).toBe(1);
+        // Should no longer be searchable
+        const search2 = new SearchEngine(ctx.projectRoot);
+        results = await search2.search('LoginForm authentication login');
+        expect(results.results.some(r => r.filepath.includes('LoginForm'))).toBe(false);
+        search2.close();
+    }, 60000);
+    it('indexes sibling files in same directory', async () => {
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        const search = new SearchEngine(ctx.projectRoot);
+        // Should find both api.ts and auth.ts in services/
+        const apiResults = await search.search('API request fetch endpoint');
+        expect(apiResults.results.some(r => r.filepath.includes('services/api.ts'))).toBe(true);
+        const authResults = await search.search('authentication token login');
+        expect(authResults.results.some(r => r.filepath.includes('services/auth.ts'))).toBe(true);
+        search.close();
+    }, 60000);
+});

package/dist/rag/__tests__/search-exhaustive.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests for exhaustive search mode.
+ *
+ * Tests the exhaustive mode for refactoring tasks:
+ * - Returns totalMatches count
+ * - Returns more results than default limit
+ * - Works with filters
+ */
+export {};

package/dist/rag/__tests__/search-exhaustive.test.js

@@ -0,0 +1,87 @@
+/**
+ * Tests for exhaustive search mode.
+ *
+ * Tests the exhaustive mode for refactoring tasks:
+ * - Returns totalMatches count
+ * - Returns more results than default limit
+ * - Works with filters
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { Indexer } from '../indexer/indexer.js';
+import { SearchEngine } from '../search/index.js';
+import { copyFixtureToTemp } from './helpers.js';
+describe('Exhaustive Mode', () => {
+    let ctx;
+    let search;
+    beforeAll(async () => {
+        // Setup once - index the codebase
+        ctx = await copyFixtureToTemp('codebase');
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        search = new SearchEngine(ctx.projectRoot);
+    }, 120000);
+    afterAll(async () => {
+        search.close();
+        await ctx.cleanup();
+    });
+    it('returns totalMatches count when exhaustive is true', async () => {
+        const results = await search.search('function', { exhaustive: true });
+        expect(results.totalMatches).toBeDefined();
+        expect(typeof results.totalMatches).toBe('number');
+        expect(results.totalMatches).toBeGreaterThan(0);
+        // totalMatches should equal results length in exhaustive mode
+        expect(results.totalMatches).toBe(results.results.length);
+    }, 60000);
+    it('does not return totalMatches when exhaustive is false', async () => {
+        const results = await search.search('function', { exhaustive: false });
+        expect(results.totalMatches).toBeUndefined();
+    }, 60000);
+    it('returns more results than default limit', async () => {
+        // Default limit is 10
+        const normalResults = await search.search('function', { limit: 5 });
+        const exhaustiveResults = await search.search('function', {
+            exhaustive: true,
+        });
+        // Exhaustive should return at least as many results
+        expect(exhaustiveResults.results.length).toBeGreaterThanOrEqual(normalResults.results.length);
+    }, 60000);
+    it('works with semantic mode', async () => {
+        const results = await search.search('data processing', {
+            mode: 'semantic',
+            exhaustive: true,
+        });
+        expect(results.totalMatches).toBeDefined();
+        expect(results.searchType).toBe('semantic');
+    }, 60000);
+    it('works with exact mode', async () => {
+        const results = await search.search('function', {
+            mode: 'exact',
+            exhaustive: true,
+        });
+        expect(results.totalMatches).toBeDefined();
+        expect(results.searchType).toBe('exact');
+    }, 60000);
+    it('works with filters', async () => {
+        const results = await search.search('function', {
+            exhaustive: true,
+            filters: { extension: ['.ts'] },
+        });
+        expect(results.totalMatches).toBeDefined();
+        // All results should be TypeScript
+        expect(results.results.every(r => r.filepath.endsWith('.ts'))).toBe(true);
+    }, 60000);
+    it('respects minScore threshold', async () => {
+        const allResults = await search.search('function', { exhaustive: true });
+        const filteredResults = await search.search('function', {
+            exhaustive: true,
+            minScore: 0.5,
+        });
+        // Filtered should have equal or fewer results
+        expect(filteredResults.results.length).toBeLessThanOrEqual(allResults.results.length);
+        // All filtered results should have score >= 0.5
+        filteredResults.results.forEach(r => {
+            expect(r.score).toBeGreaterThanOrEqual(0.5);
+        });
+    }, 60000);
+});

package/dist/rag/__tests__/search-filters.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for search filters.
+ *
+ * Tests the transparent, AI-controlled filter system:
+ * - Path filters: pathPrefix, pathContains, pathNotContains
+ * - Type filters: type, extension
+ * - Metadata filters: isExported, decoratorContains, hasDocstring
+ * - Filter combinations
+ */
+export {};

package/dist/rag/__tests__/search-filters.test.js

@@ -0,0 +1,250 @@
+/**
+ * Tests for search filters.
+ *
+ * Tests the transparent, AI-controlled filter system:
+ * - Path filters: pathPrefix, pathContains, pathNotContains
+ * - Type filters: type, extension
+ * - Metadata filters: isExported, decoratorContains, hasDocstring
+ * - Filter combinations
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { Indexer } from '../indexer/indexer.js';
+import { SearchEngine } from '../search/index.js';
+import { copyFixtureToTemp } from './helpers.js';
+describe('Search Filters', () => {
+    let ctx;
+    let search;
+    beforeAll(async () => {
+        // Setup once - index the codebase
+        ctx = await copyFixtureToTemp('codebase');
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        search = new SearchEngine(ctx.projectRoot);
+    }, 120000);
+    afterAll(async () => {
+        search.close();
+        await ctx.cleanup();
+    });
+    describe('path filters', () => {
+        it('filters by pathPrefix', async () => {
+            const results = await search.search('function', {
+                filters: { pathPrefix: 'src/' },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // All results should be in src/ directory
+            expect(results.results.every(r => r.filepath.startsWith('src/'))).toBe(true);
+        }, 60000);
+        it('filters by pathPrefix to specific subdirectory', async () => {
+            const results = await search.search('function', {
+                filters: { pathPrefix: 'src/api/' },
+            });
+            // All results should be in src/api/
+            results.results.forEach(r => {
+                expect(r.filepath.startsWith('src/api/')).toBe(true);
+            });
+        }, 60000);
+        it('filters by pathContains', async () => {
+            const results = await search.search('function', {
+                filters: { pathContains: ['services'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // All results should have 'services' in path
+            expect(results.results.every(r => r.filepath.includes('services'))).toBe(true);
+        }, 60000);
+        it('filters by pathContains with multiple strings (AND)', async () => {
+            const results = await search.search('function', {
+                filters: { pathContains: ['src', 'utils'] },
+            });
+            // All results must contain BOTH strings
+            results.results.forEach(r => {
+                expect(r.filepath.includes('src')).toBe(true);
+                expect(r.filepath.includes('utils')).toBe(true);
+            });
+        }, 60000);
+        it('excludes paths with pathNotContains', async () => {
+            const results = await search.search('function', {
+                filters: { pathNotContains: ['__tests__'] },
+            });
+            // No results should be in __tests__ directory
+            expect(results.results.every(r => !r.filepath.includes('__tests__'))).toBe(true);
+        }, 60000);
+        it('excludes multiple patterns with pathNotContains', async () => {
+            const results = await search.search('function', {
+                filters: { pathNotContains: ['__tests__', '.test.', '.spec.'] },
+            });
+            // No results should match any exclusion pattern
+            results.results.forEach(r => {
+                expect(r.filepath.includes('__tests__')).toBe(false);
+                expect(r.filepath.includes('.test.')).toBe(false);
+                expect(r.filepath.includes('.spec.')).toBe(false);
+            });
+        }, 60000);
+    });
+    describe('type filters', () => {
+        it('filters by function type', async () => {
+            const results = await search.search('data', {
+                filters: { type: ['function'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // All results should be functions
+            expect(results.results.every(r => r.type === 'function')).toBe(true);
+        }, 60000);
+        it('filters by class type', async () => {
+            const results = await search.search('service', {
+                filters: { type: ['class'] },
+            });
+            // All results should be classes
+            results.results.forEach(r => {
+                expect(r.type).toBe('class');
+            });
+        }, 60000);
+        it('filters by method type', async () => {
+            const results = await search.search('get', {
+                filters: { type: ['method'] },
+            });
+            // All results should be methods
+            results.results.forEach(r => {
+                expect(r.type).toBe('method');
+            });
+        }, 60000);
+        it('filters by multiple types (OR)', async () => {
+            const results = await search.search('user', {
+                filters: { type: ['function', 'class'] },
+            });
+            // All results should be either function or class
+            results.results.forEach(r => {
+                expect(['function', 'class']).toContain(r.type);
+            });
+        }, 60000);
+    });
+    describe('extension filters', () => {
+        it('filters by .py extension', async () => {
+            const results = await search.search('function', {
+                filters: { extension: ['.py'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // All results should be Python files
+            expect(results.results.every(r => r.filepath.endsWith('.py'))).toBe(true);
+        }, 60000);
+        it('filters by .ts extension', async () => {
+            const results = await search.search('function', {
+                filters: { extension: ['.ts'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // All results should be TypeScript files
+            expect(results.results.every(r => r.filepath.endsWith('.ts'))).toBe(true);
+        }, 60000);
+        it('filters by multiple extensions (OR)', async () => {
+            const results = await search.search('function', {
+                filters: { extension: ['.ts', '.tsx'] },
+            });
+            // All results should be .ts or .tsx files
+            results.results.forEach(r => {
+                expect(r.filepath.endsWith('.ts') || r.filepath.endsWith('.tsx')).toBe(true);
+            });
+        }, 60000);
+        it('filters by .js extension', async () => {
+            const results = await search.search('format', {
+                filters: { extension: ['.js'] },
+            });
+            // All results should be JavaScript files
+            results.results.forEach(r => {
+                expect(r.filepath.endsWith('.js')).toBe(true);
+            });
+        }, 60000);
+    });
+    describe('metadata filters', () => {
+        it('filters by isExported true', async () => {
+            const results = await search.search('function', {
+                filters: { isExported: true },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // All results should be exported
+            expect(results.results.every(r => r.isExported === true)).toBe(true);
+        }, 60000);
+        it('filters by isExported false', async () => {
+            const results = await search.search('helper internal', {
+                filters: { isExported: false },
+            });
+            // All results should NOT be exported
+            results.results.forEach(r => {
+                expect(r.isExported).toBe(false);
+            });
+        }, 60000);
+        it('filters by decoratorContains', async () => {
+            const results = await search.search('function', {
+                filters: { decoratorContains: 'log' },
+            });
+            // Should find decorated Python functions
+            // Results may be empty if no decorated functions match, that's ok
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('decorators.py'))).toBe(true);
+            }
+        }, 60000);
+        it('filters by hasDocstring true', async () => {
+            const results = await search.search('function', {
+                filters: { hasDocstring: true },
+            });
+            // Results should be documented code
+            // Most fixture files have JSDoc/docstrings
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('filter combinations', () => {
+        it('combines pathPrefix + type', async () => {
+            const results = await search.search('data', {
+                filters: {
+                    pathPrefix: 'src/',
+                    type: ['function'],
+                },
+            });
+            // All results should be functions in src/
+            results.results.forEach(r => {
+                expect(r.filepath.startsWith('src/')).toBe(true);
+                expect(r.type).toBe('function');
+            });
+        }, 60000);
+        it('combines pathNotContains + isExported', async () => {
+            const results = await search.search('user', {
+                filters: {
+                    pathNotContains: ['__tests__'],
+                    isExported: true,
+                },
+            });
+            // All results should be exported and NOT in tests
+            results.results.forEach(r => {
+                expect(r.filepath.includes('__tests__')).toBe(false);
+                expect(r.isExported).toBe(true);
+            });
+        }, 60000);
+        it('combines extension + type', async () => {
+            const results = await search.search('process', {
+                filters: {
+                    extension: ['.ts'],
+                    type: ['function'],
+                },
+            });
+            // All results should be TypeScript functions
+            results.results.forEach(r => {
+                expect(r.filepath.endsWith('.ts')).toBe(true);
+                expect(r.type).toBe('function');
+            });
+        }, 60000);
+        it('combines pathPrefix + pathNotContains + type', async () => {
+            const results = await search.search('function', {
+                filters: {
+                    pathPrefix: 'src/',
+                    pathNotContains: ['__tests__'],
+                    type: ['function', 'method'],
+                },
+            });
+            // Complex filter combination
+            results.results.forEach(r => {
+                expect(r.filepath.startsWith('src/')).toBe(true);
+                expect(r.filepath.includes('__tests__')).toBe(false);
+                expect(['function', 'method']).toContain(r.type);
+            });
+        }, 60000);
+    });
+});

package/dist/rag/__tests__/search-modes.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for search modes: definition and similar.
+ *
+ * Tests the new search modes added in Phase 2:
+ * - definition: Direct metadata lookup by symbol name
+ * - similar: Vector search with code snippet as query
+ */
+export {};