viberag 0.1.0

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

@@ -0,0 +1,161 @@
+/**
+ * Merkle tree unit tests.
+ * Tests tree structure building and change detection (diffing).
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { MerkleTree } from '../merkle/index.js';
+import { copyFixtureToTemp, addFile, modifyFile, deleteFile, waitForFs, } from './helpers.js';
+/**
+ * Helper to collect all file paths from tree.
+ */
+function collectFiles(node) {
+    if (!node)
+        return [];
+    if (node.type === 'file')
+        return [node.path];
+    const files = [];
+    if (node.children) {
+        for (const child of node.children.values()) {
+            files.push(...collectFiles(child));
+        }
+    }
+    return files;
+}
+describe('MerkleTree', () => {
+    let ctx;
+    beforeEach(async () => {
+        ctx = await copyFixtureToTemp('codebase');
+    });
+    afterEach(async () => {
+        await ctx.cleanup();
+    });
+    describe('Tree structure', () => {
+        it('includes all files from nested directories', async () => {
+            const tree = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx', '.js', '.py'], []);
+            // Count all files in tree
+            const allFiles = collectFiles(tree.root);
+            // Should have all ~15 files (5 original + 10 nested)
+            expect(allFiles.length).toBeGreaterThanOrEqual(10);
+            // Should include deeply nested file
+            expect(allFiles.some(f => f.includes('deep/nested/file.ts'))).toBe(true);
+            // Should include files at different levels
+            expect(allFiles.some(f => f.includes('src/components/Button.tsx'))).toBe(true);
+            expect(allFiles.some(f => f.includes('src/components/forms/LoginForm.tsx'))).toBe(true);
+        });
+        it('populates directory children correctly', async () => {
+            const tree = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx', '.js', '.py'], []);
+            // Navigate to src/components
+            const src = tree.root?.children?.get('src');
+            expect(src).toBeDefined();
+            expect(src?.type).toBe('directory');
+            const components = src?.children?.get('components');
+            expect(components).toBeDefined();
+            expect(components?.type).toBe('directory');
+            // Should have Button.tsx, Input.tsx, and forms/ as children
+            expect(components?.children?.size).toBeGreaterThanOrEqual(2);
+            // Check Button.tsx is a child
+            const button = components?.children?.get('Button.tsx');
+            expect(button).toBeDefined();
+            expect(button?.type).toBe('file');
+        });
+        it('handles 4+ levels of nesting', async () => {
+            const tree = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx', '.js', '.py'], []);
+            // Navigate: src → utils → deep → nested → file.ts
+            const src = tree.root?.children?.get('src');
+            expect(src).toBeDefined();
+            const utils = src?.children?.get('utils');
+            expect(utils).toBeDefined();
+            const deep = utils?.children?.get('deep');
+            expect(deep).toBeDefined();
+            const nested = deep?.children?.get('nested');
+            expect(nested).toBeDefined();
+            const file = nested?.children?.get('file.ts');
+            expect(file).toBeDefined();
+            expect(file?.type).toBe('file');
+            expect(file?.path).toBe('src/utils/deep/nested/file.ts');
+        });
+        it('handles multiple siblings at each level', async () => {
+            const tree = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx', '.js', '.py'], []);
+            // src/services should have api.ts AND auth.ts
+            const services = tree.root?.children
+                ?.get('src')
+                ?.children?.get('services');
+            expect(services?.children?.has('api.ts')).toBe(true);
+            expect(services?.children?.has('auth.ts')).toBe(true);
+            // Root should have src/ AND lib/
+            expect(tree.root?.children?.has('src')).toBe(true);
+            expect(tree.root?.children?.has('lib')).toBe(true);
+        });
+    });
+    describe('Tree diffing', () => {
+        it('detects new file in subdirectory', async () => {
+            const tree1 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            await addFile(ctx.projectRoot, 'src/utils/newHelper.ts', 'export const x = 1;');
+            await waitForFs();
+            const tree2 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], [], tree1);
+            const diff = tree1.compare(tree2);
+            expect(diff.new).toContain('src/utils/newHelper.ts');
+            expect(diff.modified.length).toBe(0);
+            expect(diff.deleted.length).toBe(0);
+        });
+        it('detects modified file in deeply nested directory', async () => {
+            const tree1 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            await modifyFile(ctx.projectRoot, 'src/utils/deep/nested/file.ts', '// changed\nexport const y = 2;');
+            await waitForFs();
+            const tree2 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], [], tree1);
+            const diff = tree1.compare(tree2);
+            expect(diff.modified).toContain('src/utils/deep/nested/file.ts');
+        });
+        it('detects deleted file from subdirectory', async () => {
+            const tree1 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            await deleteFile(ctx.projectRoot, 'src/components/Input.tsx');
+            await waitForFs();
+            const tree2 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], [], tree1);
+            const diff = tree1.compare(tree2);
+            expect(diff.deleted).toContain('src/components/Input.tsx');
+        });
+        it('detects new directory with files', async () => {
+            const tree1 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            // Add new directory with multiple files
+            await addFile(ctx.projectRoot, 'src/newDir/a.ts', 'export const a = 1;');
+            await addFile(ctx.projectRoot, 'src/newDir/b.ts', 'export const b = 2;');
+            await waitForFs();
+            const tree2 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], [], tree1);
+            const diff = tree1.compare(tree2);
+            expect(diff.new).toContain('src/newDir/a.ts');
+            expect(diff.new).toContain('src/newDir/b.ts');
+        });
+        it('directory hash changes when child file changes', async () => {
+            const tree1 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            const srcHash1 = tree1.root?.children?.get('src')?.hash;
+            const utilsHash1 = tree1.root?.children
+                ?.get('src')
+                ?.children?.get('utils')?.hash;
+            await modifyFile(ctx.projectRoot, 'src/utils/helpers.ts', '// changed');
+            await waitForFs();
+            const tree2 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            const srcHash2 = tree2.root?.children?.get('src')?.hash;
+            const utilsHash2 = tree2.root?.children
+                ?.get('src')
+                ?.children?.get('utils')?.hash;
+            // Both parent directories should have different hashes
+            expect(utilsHash2).not.toBe(utilsHash1);
+            expect(srcHash2).not.toBe(srcHash1);
+        });
+        it('sibling directory hash unchanged when other sibling changes', async () => {
+            const tree1 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            const servicesHash1 = tree1.root?.children
+                ?.get('src')
+                ?.children?.get('services')?.hash;
+            // Modify file in utils (sibling of services)
+            await modifyFile(ctx.projectRoot, 'src/utils/helpers.ts', '// changed');
+            await waitForFs();
+            const tree2 = await MerkleTree.build(ctx.projectRoot, ['.ts', '.tsx'], []);
+            const servicesHash2 = tree2.root?.children
+                ?.get('src')
+                ?.children?.get('services')?.hash;
+            // Services hash should be unchanged
+            expect(servicesHash2).toBe(servicesHash1);
+        });
+    });
+});

package/dist/rag/__tests__/metadata-extraction.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for metadata extraction.
+ *
+ * Tests that the Chunker correctly extracts:
+ * - signature: Function/method signature lines
+ * - docstring: JSDoc/Python docstrings
+ * - is_exported: Export keyword detection
+ * - decorator_names: Decorator/annotation extraction
+ */
+export {};

package/dist/rag/__tests__/metadata-extraction.test.js

@@ -0,0 +1,202 @@
+/**
+ * Tests for metadata extraction.
+ *
+ * Tests that the Chunker correctly extracts:
+ * - signature: Function/method signature lines
+ * - docstring: JSDoc/Python docstrings
+ * - is_exported: Export keyword detection
+ * - decorator_names: Decorator/annotation extraction
+ */
+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('Metadata Extraction', () => {
+    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('signature extraction', () => {
+        it('extracts TypeScript function signature', async () => {
+            const results = await search.search('getUser', {
+                mode: 'definition',
+                symbolName: 'getUser',
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            const result = results.results[0];
+            // Signature should contain the function declaration
+            if (result?.signature) {
+                expect(result.signature).toContain('getUser');
+            }
+        }, 60000);
+        it('extracts Python function signature', async () => {
+            const results = await search.search('add_two_numbers', {
+                mode: 'definition',
+                symbolName: 'add_two_numbers',
+            });
+            if (results.results.length > 0) {
+                const result = results.results[0];
+                if (result?.signature) {
+                    expect(result.signature).toContain('add_two_numbers');
+                }
+            }
+        }, 60000);
+        it('extracts class signature', async () => {
+            // Use semantic search with class filter
+            const results = await search.search('UserService class service', {
+                mode: 'semantic',
+                filters: { type: ['class'] },
+            });
+            // Should find some classes with signatures
+            if (results.results.length > 0) {
+                const classResult = results.results.find(r => r.type === 'class');
+                if (classResult?.signature) {
+                    expect(classResult.signature).toContain('class');
+                }
+            }
+        }, 60000);
+    });
+    describe('export detection', () => {
+        it('detects exported functions', async () => {
+            // Search for exported function in exported.ts
+            const results = await search.search('publicUtil', {
+                mode: 'definition',
+                symbolName: 'publicUtil',
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            const result = results.results.find(r => r.filepath.includes('exported.ts'));
+            expect(result?.isExported).toBe(true);
+        }, 60000);
+        it('detects non-exported functions', async () => {
+            // Search for internal helper in exported.ts
+            const results = await search.search('internalHelper', {
+                mode: 'definition',
+                symbolName: 'internalHelper',
+            });
+            if (results.results.length > 0) {
+                const result = results.results.find(r => r.filepath.includes('exported.ts'));
+                if (result) {
+                    expect(result.isExported).toBe(false);
+                }
+            }
+        }, 60000);
+        it('detects exported classes', async () => {
+            // Use semantic search with export filter
+            const results = await search.search('class service user', {
+                mode: 'semantic',
+                filters: {
+                    type: ['class'],
+                    isExported: true,
+                },
+            });
+            // Should find exported classes
+            if (results.results.length > 0) {
+                results.results.forEach(r => {
+                    expect(r.isExported).toBe(true);
+                });
+            }
+        }, 60000);
+        it('filters work with isExported', async () => {
+            // Get only exported symbols
+            const exportedResults = await search.search('user', {
+                filters: { isExported: true },
+            });
+            // All should be exported
+            exportedResults.results.forEach(r => {
+                expect(r.isExported).toBe(true);
+            });
+            // Get non-exported
+            const internalResults = await search.search('helper', {
+                filters: { isExported: false },
+            });
+            // All should NOT be exported
+            internalResults.results.forEach(r => {
+                expect(r.isExported).toBe(false);
+            });
+        }, 60000);
+    });
+    describe('docstring extraction', () => {
+        it('finds documented functions via hasDocstring filter', async () => {
+            const results = await search.search('process', {
+                filters: { hasDocstring: true },
+            });
+            // Should find documented functions
+            expect(results.results.length).toBeGreaterThan(0);
+        }, 60000);
+        it('documented Python functions are findable', async () => {
+            // process_data in decorators.py has a docstring
+            const results = await search.search('process_data', {
+                mode: 'definition',
+                symbolName: 'process_data',
+            });
+            if (results.results.length > 0) {
+                const result = results.results.find(r => r.filepath.includes('decorators.py'));
+                // The function should be found
+                expect(result).toBeDefined();
+            }
+        }, 60000);
+    });
+    describe('decorator extraction', () => {
+        it('finds decorated Python functions', async () => {
+            // Search semantically for Python functions in decorators file
+            const results = await search.search('process data logging decorator python', {
+                mode: 'semantic',
+                filters: { extension: ['.py'] },
+            });
+            // Should find functions from decorators.py
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('decorators.py'))).toBe(true);
+            }
+        }, 60000);
+        it('decoratorContains filter works', async () => {
+            const results = await search.search('function', {
+                filters: { decoratorContains: 'log' },
+            });
+            // Should find functions with 'log' in decorator names
+            // Results may be empty if extraction isn't working, but filter should not error
+            expect(results).toBeDefined();
+        }, 60000);
+        it('finds functions with multiple decorators', async () => {
+            // Search for transform function in Python files
+            const results = await search.search('transform value validate input', {
+                mode: 'semantic',
+                filters: { extension: ['.py'] },
+            });
+            // Should find functions from decorators.py
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('.py'))).toBe(true);
+            }
+        }, 60000);
+    });
+    describe('metadata in search results', () => {
+        it('includes signature in results when available', async () => {
+            const results = await search.search('async function fetch', {
+                mode: 'semantic',
+                limit: 5,
+            });
+            // At least some results should have signatures
+            const withSignature = results.results.filter(r => r.signature);
+            expect(withSignature.length).toBeGreaterThan(0);
+        }, 60000);
+        it('includes isExported in results', async () => {
+            const results = await search.search('export function', {
+                mode: 'semantic',
+                limit: 10,
+            });
+            // Results should have isExported defined
+            results.results.forEach(r => {
+                expect(typeof r.isExported).toBe('boolean');
+            });
+        }, 60000);
+    });
+});

package/dist/rag/__tests__/multi-language.test.d.ts

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