viberag 0.1.0

package/dist/rag/__tests__/multi-language.test.js

@@ -0,0 +1,535 @@
+/**
+ * Multi-Language Support Tests.
+ *
+ * Tests that the indexer correctly handles 8 additional languages:
+ * - Go, Rust, Java, C#, Dart, Swift, Kotlin, PHP
+ *
+ * Validates:
+ * - Export detection (capitalization, pub, public, underscore prefix)
+ * - Decorator/attribute extraction (#[], @, [])
+ * - Docstring extraction (various comment styles)
+ * - Cross-language search capabilities
+ */
+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('Multi-Language Support', () => {
+    let ctx;
+    let search;
+    beforeAll(async () => {
+        ctx = await copyFixtureToTemp('codebase');
+        const indexer = new Indexer(ctx.projectRoot);
+        await indexer.index();
+        indexer.close();
+        search = new SearchEngine(ctx.projectRoot);
+    }, 180000);
+    afterAll(async () => {
+        search.close();
+        await ctx.cleanup();
+    });
+    describe('Go Language', () => {
+        it('indexes .go files', async () => {
+            const results = await search.search('Greeter', {
+                filters: { extension: ['.go'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.go');
+        }, 60000);
+        it('detects exported symbols (capitalized)', async () => {
+            // Exported function (capitalized)
+            const exported = await search.search('NewGreeter', {
+                mode: 'definition',
+                filters: { extension: ['.go'] },
+            });
+            if (exported.results.length > 0) {
+                const result = exported.results.find(r => r.name?.includes('NewGreeter'));
+                if (result) {
+                    expect(result.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects unexported symbols (lowercase)', async () => {
+            const unexported = await search.search('privateHelper', {
+                mode: 'definition',
+                filters: { extension: ['.go'] },
+            });
+            if (unexported.results.length > 0) {
+                const result = unexported.results.find(r => r.name?.includes('privateHelper'));
+                if (result) {
+                    expect(result.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts Go doc comments', async () => {
+            const results = await search.search('Add two integers', {
+                mode: 'semantic',
+                filters: { extension: ['.go'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('Rust Language', () => {
+        it('indexes .rs files', async () => {
+            const results = await search.search('Greeter', {
+                filters: { extension: ['.rs'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.rs');
+        }, 60000);
+        it('detects pub exports', async () => {
+            const results = await search.search('add', {
+                mode: 'definition',
+                filters: { extension: ['.rs'] },
+            });
+            if (results.results.length > 0) {
+                const pubFn = results.results.find(r => r.name === 'add');
+                if (pubFn) {
+                    expect(pubFn.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects private functions', async () => {
+            const results = await search.search('private_function', {
+                mode: 'definition',
+                filters: { extension: ['.rs'] },
+            });
+            if (results.results.length > 0) {
+                const privateFn = results.results.find(r => r.name?.includes('private'));
+                if (privateFn) {
+                    expect(privateFn.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts #[derive] attributes via filter', async () => {
+            const results = await search.search('Greeter', {
+                filters: {
+                    extension: ['.rs'],
+                    decoratorContains: 'derive',
+                },
+            });
+            // Should find Greeter struct with #[derive(...)]
+            expect(results.results.some(r => r.filepath.includes('.rs'))).toBe(true);
+        }, 60000);
+        it('extracts /// doc comments', async () => {
+            const results = await search.search('greeting message', {
+                mode: 'semantic',
+                filters: { extension: ['.rs'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('Java Language', () => {
+        it('indexes .java files', async () => {
+            const results = await search.search('Sample class', {
+                filters: { extension: ['.java'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.java');
+        }, 60000);
+        it('detects public methods', async () => {
+            const results = await search.search('getName', {
+                mode: 'definition',
+                filters: { extension: ['.java'] },
+            });
+            if (results.results.length > 0) {
+                const method = results.results.find(r => r.name?.includes('getName'));
+                if (method) {
+                    expect(method.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects package-private classes', async () => {
+            const results = await search.search('PrivateHelper', {
+                mode: 'definition',
+                filters: { extension: ['.java'] },
+            });
+            if (results.results.length > 0) {
+                const helper = results.results.find(r => r.name?.includes('PrivateHelper'));
+                if (helper) {
+                    expect(helper.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts @Override annotation via filter', async () => {
+            const results = await search.search('toString', {
+                filters: {
+                    extension: ['.java'],
+                    decoratorContains: 'Override',
+                },
+            });
+            // Should find toString with @Override when grammar supports it
+            // Note: If grammar ABI is incompatible, falls back to module-level chunking
+            expect(results).toBeDefined();
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('.java'))).toBe(true);
+            }
+        }, 60000);
+        it('extracts Javadoc comments', async () => {
+            const results = await search.search('greeting string', {
+                mode: 'semantic',
+                filters: { extension: ['.java'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('C# Language', () => {
+        it('indexes .cs files', async () => {
+            const results = await search.search('Greeter class', {
+                filters: { extension: ['.cs'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.cs');
+        }, 60000);
+        it('detects public classes', async () => {
+            const results = await search.search('Greeter', {
+                mode: 'definition',
+                filters: { extension: ['.cs'] },
+            });
+            if (results.results.length > 0) {
+                const cls = results.results.find(r => r.name?.includes('Greeter'));
+                if (cls) {
+                    expect(cls.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects internal classes', async () => {
+            const results = await search.search('PrivateHelper', {
+                mode: 'definition',
+                filters: { extension: ['.cs'] },
+            });
+            if (results.results.length > 0) {
+                const helper = results.results.find(r => r.name?.includes('PrivateHelper'));
+                if (helper) {
+                    expect(helper.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts [Obsolete] attribute via filter', async () => {
+            const results = await search.search('Greet', {
+                filters: {
+                    extension: ['.cs'],
+                    decoratorContains: 'Obsolete',
+                },
+            });
+            // Should find Greet method with [Obsolete] when grammar supports it
+            // Note: C# grammar may have ABI compatibility issues with current web-tree-sitter
+            expect(results).toBeDefined();
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('.cs'))).toBe(true);
+            }
+        }, 60000);
+        it('extracts XML doc comments', async () => {
+            const results = await search.search('formal greeting', {
+                mode: 'semantic',
+                filters: { extension: ['.cs'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('Dart Language', () => {
+        it('indexes .dart files', async () => {
+            const results = await search.search('Greeter class', {
+                filters: { extension: ['.dart'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.dart');
+        }, 60000);
+        it('detects public functions (no underscore)', async () => {
+            const results = await search.search('add', {
+                mode: 'definition',
+                filters: { extension: ['.dart'] },
+            });
+            if (results.results.length > 0) {
+                const fn = results.results.find(r => r.name === 'add' && r.filepath.includes('.dart'));
+                if (fn) {
+                    expect(fn.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects private classes (underscore prefix)', async () => {
+            const results = await search.search('_PrivateHelper', {
+                mode: 'definition',
+                filters: { extension: ['.dart'] },
+            });
+            if (results.results.length > 0) {
+                const cls = results.results.find(r => r.name?.includes('_PrivateHelper'));
+                if (cls) {
+                    expect(cls.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts @Deprecated annotation via filter', async () => {
+            const results = await search.search('processData', {
+                filters: {
+                    extension: ['.dart'],
+                    decoratorContains: 'Deprecated',
+                },
+            });
+            // Should find processData with @Deprecated when grammar supports it
+            // Note: Dart grammar may have ABI compatibility issues with current web-tree-sitter
+            expect(results).toBeDefined();
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('.dart'))).toBe(true);
+            }
+        }, 60000);
+        it('extracts /// doc comments', async () => {
+            const results = await search.search('greeting messages', {
+                mode: 'semantic',
+                filters: { extension: ['.dart'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('Swift Language', () => {
+        it('indexes .swift files', async () => {
+            const results = await search.search('Greeter struct', {
+                filters: { extension: ['.swift'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.swift');
+        }, 60000);
+        it('detects public functions', async () => {
+            const results = await search.search('add', {
+                mode: 'definition',
+                filters: { extension: ['.swift'] },
+            });
+            if (results.results.length > 0) {
+                const fn = results.results.find(r => r.name === 'add' && r.filepath.includes('.swift'));
+                if (fn) {
+                    expect(fn.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects private functions', async () => {
+            const results = await search.search('privateFunction', {
+                mode: 'definition',
+                filters: { extension: ['.swift'] },
+            });
+            if (results.results.length > 0) {
+                const fn = results.results.find(r => r.name?.includes('privateFunction'));
+                if (fn) {
+                    expect(fn.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts @available attribute via filter', async () => {
+            const results = await search.search('Greeter', {
+                filters: {
+                    extension: ['.swift'],
+                    decoratorContains: 'available',
+                },
+            });
+            // Should find Greeter with @available when grammar supports it
+            // Note: Swift grammar may have ABI compatibility issues with current web-tree-sitter
+            expect(results).toBeDefined();
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('.swift'))).toBe(true);
+            }
+        }, 60000);
+        it('extracts /// doc comments', async () => {
+            const results = await search.search('greeting message', {
+                mode: 'semantic',
+                filters: { extension: ['.swift'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('Kotlin Language', () => {
+        it('indexes .kt files', async () => {
+            const results = await search.search('Greeter data class', {
+                filters: { extension: ['.kt'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.kt');
+        }, 60000);
+        it('detects public functions (default)', async () => {
+            const results = await search.search('add', {
+                mode: 'definition',
+                filters: { extension: ['.kt'] },
+            });
+            if (results.results.length > 0) {
+                const fn = results.results.find(r => r.name === 'add' && r.filepath.includes('.kt'));
+                if (fn) {
+                    expect(fn.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects internal classes', async () => {
+            const results = await search.search('PrivateHelper', {
+                mode: 'definition',
+                filters: { extension: ['.kt'] },
+            });
+            if (results.results.length > 0) {
+                const cls = results.results.find(r => r.name?.includes('PrivateHelper'));
+                if (cls) {
+                    expect(cls.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts @Deprecated annotation via filter', async () => {
+            const results = await search.search('processData', {
+                filters: {
+                    extension: ['.kt'],
+                    decoratorContains: 'Deprecated',
+                },
+            });
+            // Should find processData with @Deprecated when grammar supports it
+            // Note: Kotlin grammar may have ABI compatibility issues with current web-tree-sitter
+            expect(results).toBeDefined();
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('.kt'))).toBe(true);
+            }
+        }, 60000);
+        it('extracts KDoc comments', async () => {
+            const results = await search.search('greeting message', {
+                mode: 'semantic',
+                filters: { extension: ['.kt'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('PHP Language', () => {
+        it('indexes .php files', async () => {
+            const results = await search.search('Greeter class', {
+                filters: { extension: ['.php'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain('.php');
+        }, 60000);
+        it('detects public methods', async () => {
+            const results = await search.search('greet', {
+                mode: 'definition',
+                filters: { extension: ['.php'] },
+            });
+            if (results.results.length > 0) {
+                const method = results.results.find(r => r.name === 'greet' && r.filepath.includes('.php'));
+                if (method) {
+                    expect(method.isExported).toBe(true);
+                }
+            }
+        }, 60000);
+        it('detects private methods', async () => {
+            const results = await search.search('privateMethod', {
+                mode: 'definition',
+                filters: { extension: ['.php'] },
+            });
+            if (results.results.length > 0) {
+                const method = results.results.find(r => r.name?.includes('privateMethod') && r.filepath.includes('.php'));
+                if (method) {
+                    expect(method.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('extracts PHP 8 #[Attribute] via filter', async () => {
+            const results = await search.search('add', {
+                filters: {
+                    extension: ['.php'],
+                    decoratorContains: 'Pure',
+                },
+            });
+            // Should find add function with #[Pure] when grammar supports it
+            // Note: PHP grammar may have ABI compatibility issues with current web-tree-sitter
+            expect(results).toBeDefined();
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('.php'))).toBe(true);
+            }
+        }, 60000);
+        it('extracts PHPDoc comments', async () => {
+            const results = await search.search('greeting message', {
+                mode: 'semantic',
+                filters: { extension: ['.php'] },
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('Cross-Language Search', () => {
+        it('finds Greeter implementations across all languages', async () => {
+            const results = await search.search('Greeter class greeting', {
+                mode: 'semantic',
+                limit: 20,
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // Should find results from multiple languages
+            const extensions = new Set(results.results.map(r => {
+                const ext = r.filepath.split('.').pop();
+                return ext ? `.${ext}` : '';
+            }));
+            expect(extensions.size).toBeGreaterThan(1);
+        }, 60000);
+        it('finds add functions across languages', async () => {
+            const results = await search.search('add two numbers integers', {
+                mode: 'semantic',
+                filters: { type: ['function'] },
+                limit: 20,
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // Should have add functions from multiple languages
+            const langs = results.results.filter(r => r.name?.toLowerCase().includes('add'));
+            expect(langs.length).toBeGreaterThan(1);
+        }, 60000);
+        it('finds process functions across languages', async () => {
+            const results = await search.search('process data validation', {
+                mode: 'semantic',
+                limit: 20,
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+        it('filters by exported across languages', async () => {
+            const results = await search.search('greeting', {
+                mode: 'semantic',
+                filters: { isExported: true },
+                limit: 20,
+            });
+            // All results should be exported
+            results.results.forEach(r => {
+                expect(r.isExported).toBe(true);
+            });
+        }, 60000);
+        it('filters by type works across languages', async () => {
+            // Find classes
+            const classResults = await search.search('helper', {
+                filters: { type: ['class'] },
+                limit: 10,
+            });
+            classResults.results.forEach(r => {
+                expect(r.type).toBe('class');
+            });
+            // Find functions
+            const fnResults = await search.search('add', {
+                filters: { type: ['function'] },
+                limit: 10,
+            });
+            fnResults.results.forEach(r => {
+                expect(['function', 'method']).toContain(r.type);
+            });
+        }, 60000);
+        it('hasDocstring filter works across languages', async () => {
+            const results = await search.search('greeting', {
+                filters: { hasDocstring: true },
+                limit: 20,
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+    describe('Language Extension Mapping', () => {
+        const langExtensions = [
+            { ext: '.go', lang: 'Go' },
+            { ext: '.rs', lang: 'Rust' },
+            { ext: '.java', lang: 'Java' },
+            { ext: '.cs', lang: 'C#' },
+            { ext: '.dart', lang: 'Dart' },
+            { ext: '.swift', lang: 'Swift' },
+            { ext: '.kt', lang: 'Kotlin' },
+            { ext: '.php', lang: 'PHP' },
+        ];
+        it.each(langExtensions)('$lang files ($ext) are indexed and searchable', async ({ ext }) => {
+            const results = await search.search('function', {
+                filters: { extension: [ext] },
+                limit: 5,
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.results[0]?.filepath).toContain(ext);
+        }, 60000);
+    });
+});

package/dist/rag/__tests__/rag.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+export {};