viberag 0.1.0

package/dist/mcp/watcher.d.ts

@@ -0,0 +1,86 @@
+/**
+ * File Watcher for Auto-Indexing
+ *
+ * Watches the project directory for file changes and triggers
+ * incremental indexing with debouncing and batching.
+ */
+import { type IndexStats } from '../rag/index.js';
+/**
+ * Watcher status for reporting.
+ */
+export interface WatcherStatus {
+    /** Whether the watcher is currently active */
+    watching: boolean;
+    /** Number of files being watched */
+    filesWatched: number;
+    /** Number of changes pending in the batch */
+    pendingChanges: number;
+    /** Paths of pending changes */
+    pendingPaths: string[];
+    /** Last index update timestamp (ISO string) */
+    lastIndexUpdate: string | null;
+    /** Whether the index is up to date */
+    indexUpToDate: boolean;
+    /** Last error message if any */
+    lastError: string | null;
+}
+/**
+ * Result of an index update triggered by the watcher.
+ */
+export interface WatcherIndexResult {
+    success: boolean;
+    stats?: IndexStats;
+    error?: string;
+    filesProcessed: string[];
+}
+/**
+ * File watcher that triggers incremental indexing on changes.
+ */
+export declare class FileWatcher {
+    private readonly projectRoot;
+    private config;
+    private watcher;
+    private logger;
+    private gitignore;
+    private pendingChanges;
+    private batchTimeout;
+    private debounceTimeout;
+    private filesWatched;
+    private lastIndexUpdate;
+    private indexUpToDate;
+    private lastError;
+    private isIndexing;
+    constructor(projectRoot: string);
+    /**
+     * Start watching the project directory.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the file watcher.
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current watcher status.
+     */
+    getStatus(): WatcherStatus;
+    /**
+     * Check if watcher is active.
+     */
+    isWatching(): boolean;
+    /**
+     * Handle a file change event.
+     */
+    private handleChange;
+    /**
+     * Process the batch of pending changes.
+     */
+    private processBatch;
+    /**
+     * Force an immediate index update.
+     */
+    forceUpdate(): Promise<WatcherIndexResult>;
+    /**
+     * Log a message.
+     */
+    private log;
+}

package/dist/mcp/watcher.js

@@ -0,0 +1,334 @@
+/**
+ * File Watcher for Auto-Indexing
+ *
+ * Watches the project directory for file changes and triggers
+ * incremental indexing with debouncing and batching.
+ */
+import { watch } from 'chokidar';
+import { Indexer, loadConfig, hasValidExtension, loadGitignore, createLogger, getLogsDir, } from '../rag/index.js';
+/**
+ * File watcher that triggers incremental indexing on changes.
+ */
+export class FileWatcher {
+    constructor(projectRoot) {
+        Object.defineProperty(this, "projectRoot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "watcher", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "gitignore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Batching state
+        Object.defineProperty(this, "pendingChanges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "batchTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "debounceTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Status tracking
+        Object.defineProperty(this, "filesWatched", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "lastIndexUpdate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "indexUpToDate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "lastError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "isIndexing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.projectRoot = projectRoot;
+    }
+    /**
+     * Start watching the project directory.
+     */
+    async start() {
+        if (this.watcher) {
+            return; // Already watching
+        }
+        // Load config
+        this.config = await loadConfig(this.projectRoot);
+        const watchConfig = this.config.watch;
+        if (!watchConfig.enabled) {
+            this.log('info', 'File watching disabled in config');
+            return;
+        }
+        // Load gitignore rules
+        this.gitignore = await loadGitignore(this.projectRoot);
+        // Initialize logger
+        try {
+            const logsDir = getLogsDir(this.projectRoot);
+            this.logger = createLogger(logsDir);
+        }
+        catch {
+            // Logs dir may not exist yet, that's ok
+        }
+        this.log('info', `Starting file watcher for ${this.projectRoot}`);
+        // Chokidar v5: watch directory '.' instead of glob '**/*'
+        // Paths are relative to cwd when cwd is set
+        // ignored must be a function (glob arrays removed in v4+)
+        const ignored = (filePath) => {
+            // Normalize path separators for cross-platform
+            const normalized = filePath.replace(/\\/g, '/');
+            // Check if path starts with or contains ignored directories
+            // Paths are relative to cwd, e.g.: '.git', 'src/index.ts', 'node_modules/pkg/...'
+            const ignoredDirs = ['.git', '.viberag', 'node_modules'];
+            for (const dir of ignoredDirs) {
+                if (normalized === dir ||
+                    normalized.startsWith(`${dir}/`) ||
+                    normalized.includes(`/${dir}/`) ||
+                    normalized.includes(`/${dir}`)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        // Create watcher - watch '.' (current directory) recursively
+        this.watcher = watch('.', {
+            cwd: this.projectRoot,
+            ignored,
+            persistent: true,
+            // Emit events for existing files so we can count them
+            ignoreInitial: false,
+            awaitWriteFinish: watchConfig.awaitWriteFinish
+                ? {
+                    stabilityThreshold: 300,
+                    pollInterval: 100,
+                }
+                : false,
+            depth: 20, // Reasonable depth limit
+        });
+        // Wait for initial scan to complete before returning
+        await new Promise((resolve, reject) => {
+            if (!this.watcher) {
+                reject(new Error('Watcher not initialized'));
+                return;
+            }
+            // Track file count
+            this.watcher.on('add', path => {
+                this.filesWatched++;
+                this.handleChange('add', path);
+            });
+            this.watcher.on('change', path => {
+                this.handleChange('change', path);
+            });
+            this.watcher.on('unlink', path => {
+                this.filesWatched = Math.max(0, this.filesWatched - 1);
+                this.handleChange('unlink', path);
+            });
+            this.watcher.on('error', error => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.lastError = message;
+                this.log('error', `Watcher error: ${message}`);
+                // Don't reject on error - watcher can continue with partial coverage
+            });
+            this.watcher.on('ready', () => {
+                this.log('info', `Watcher ready, watching ${this.filesWatched} files`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the file watcher.
+     */
+    async stop() {
+        if (!this.watcher) {
+            return;
+        }
+        this.log('info', 'Stopping file watcher');
+        // Clear any pending timeouts
+        if (this.debounceTimeout) {
+            clearTimeout(this.debounceTimeout);
+            this.debounceTimeout = null;
+        }
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        // Flush pending changes before stopping
+        if (this.pendingChanges.size > 0 && !this.isIndexing) {
+            this.log('info', 'Flushing pending changes before stop');
+            await this.processBatch();
+        }
+        await this.watcher.close();
+        this.watcher = null;
+        this.filesWatched = 0;
+        this.pendingChanges.clear();
+    }
+    /**
+     * Get current watcher status.
+     */
+    getStatus() {
+        return {
+            watching: this.watcher !== null,
+            filesWatched: this.filesWatched,
+            pendingChanges: this.pendingChanges.size,
+            pendingPaths: Array.from(this.pendingChanges).slice(0, 10), // Limit to 10
+            lastIndexUpdate: this.lastIndexUpdate,
+            indexUpToDate: this.indexUpToDate && this.pendingChanges.size === 0,
+            lastError: this.lastError,
+        };
+    }
+    /**
+     * Check if watcher is active.
+     */
+    isWatching() {
+        return this.watcher !== null;
+    }
+    /**
+     * Handle a file change event.
+     */
+    handleChange(event, path) {
+        if (!this.config || !this.gitignore)
+            return;
+        // Skip if path is ignored by gitignore
+        if (this.gitignore.ignores(path)) {
+            return;
+        }
+        // If extensions configured, filter by extension
+        // Empty extensions array means watch all files
+        if (event !== 'unlink' &&
+            this.config.extensions.length > 0 &&
+            !hasValidExtension(path, this.config.extensions)) {
+            return;
+        }
+        this.log('debug', `File ${event}: ${path}`);
+        // Add to pending changes
+        this.pendingChanges.add(path);
+        this.indexUpToDate = false;
+        // Debounce: reset the debounce timer on each change
+        if (this.debounceTimeout) {
+            clearTimeout(this.debounceTimeout);
+        }
+        const watchConfig = this.config.watch;
+        this.debounceTimeout = setTimeout(() => {
+            this.debounceTimeout = null;
+            // Start batch window if not already started
+            if (!this.batchTimeout) {
+                this.batchTimeout = setTimeout(() => {
+                    this.batchTimeout = null;
+                    this.processBatch();
+                }, watchConfig.batchWindowMs);
+            }
+        }, watchConfig.debounceMs);
+    }
+    /**
+     * Process the batch of pending changes.
+     */
+    async processBatch() {
+        if (this.pendingChanges.size === 0) {
+            return { success: true, filesProcessed: [] };
+        }
+        if (this.isIndexing) {
+            this.log('debug', 'Index already in progress, skipping batch');
+            return { success: false, error: 'Index in progress', filesProcessed: [] };
+        }
+        const filesToProcess = Array.from(this.pendingChanges);
+        this.pendingChanges.clear();
+        this.log('info', `Processing batch of ${filesToProcess.length} changed files`);
+        this.isIndexing = true;
+        try {
+            const indexer = new Indexer(this.projectRoot, this.logger ?? undefined);
+            const stats = await indexer.index({ force: false });
+            indexer.close();
+            this.lastIndexUpdate = new Date().toISOString();
+            this.indexUpToDate = true;
+            this.lastError = null;
+            this.log('info', `Index updated: ${stats.chunksAdded} added, ${stats.chunksDeleted} deleted`);
+            return { success: true, stats, filesProcessed: filesToProcess };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.lastError = message;
+            this.log('error', `Index update failed: ${message}`);
+            // Put files back in pending queue for retry
+            filesToProcess.forEach(f => this.pendingChanges.add(f));
+            return { success: false, error: message, filesProcessed: [] };
+        }
+        finally {
+            this.isIndexing = false;
+        }
+    }
+    /**
+     * Force an immediate index update.
+     */
+    async forceUpdate() {
+        // Clear timeouts
+        if (this.debounceTimeout) {
+            clearTimeout(this.debounceTimeout);
+            this.debounceTimeout = null;
+        }
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        return this.processBatch();
+    }
+    /**
+     * Log a message.
+     */
+    log(level, message) {
+        const prefix = '[Watcher]';
+        if (this.logger) {
+            this.logger[level](prefix, message);
+        }
+        // Also log to stderr for MCP visibility
+        if (level === 'error') {
+            console.error(`${prefix} ${message}`);
+        }
+    }
+}

package/dist/rag/__tests__/grammar-smoke.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Grammar Smoke Tests
+ *
+ * Fast tests that verify each web-tree-sitter WASM grammar loads and can parse basic code.
+ * These tests run in ~2 seconds and catch WASM loading issues early.
+ *
+ * Critical for CI/CD to verify WASM grammars work on all platforms.
+ */
+export {};

package/dist/rag/__tests__/grammar-smoke.test.js

@@ -0,0 +1,161 @@
+/**
+ * Grammar Smoke Tests
+ *
+ * Fast tests that verify each web-tree-sitter WASM grammar loads and can parse basic code.
+ * These tests run in ~2 seconds and catch WASM loading issues early.
+ *
+ * Critical for CI/CD to verify WASM grammars work on all platforms.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import Parser from 'web-tree-sitter';
+const require = createRequire(import.meta.url);
+const GRAMMARS = [
+    {
+        name: 'javascript',
+        wasmFile: 'tree-sitter-javascript.wasm',
+        code: 'function foo() { return 42; }',
+        expectedRootType: 'program',
+    },
+    {
+        name: 'typescript',
+        wasmFile: 'tree-sitter-typescript.wasm',
+        code: 'const x: number = 1;',
+        expectedRootType: 'program',
+    },
+    {
+        name: 'tsx',
+        wasmFile: 'tree-sitter-tsx.wasm',
+        code: 'const X = () => <div>Hello</div>;',
+        expectedRootType: 'program',
+    },
+    {
+        name: 'python',
+        wasmFile: 'tree-sitter-python.wasm',
+        code: 'def foo():\n    return 42',
+        expectedRootType: 'module',
+    },
+    {
+        name: 'go',
+        wasmFile: 'tree-sitter-go.wasm',
+        code: 'package main\n\nfunc main() {}',
+        expectedRootType: 'source_file',
+    },
+    {
+        name: 'rust',
+        wasmFile: 'tree-sitter-rust.wasm',
+        code: 'fn main() { println!("Hello"); }',
+        expectedRootType: 'source_file',
+    },
+    {
+        name: 'java',
+        wasmFile: 'tree-sitter-java.wasm',
+        code: 'public class Main { public static void main(String[] args) {} }',
+        expectedRootType: 'program',
+    },
+    {
+        name: 'csharp',
+        wasmFile: 'tree-sitter-c_sharp.wasm',
+        code: 'namespace Sample { public class Foo {} }',
+        expectedRootType: 'compilation_unit',
+    },
+    {
+        name: 'kotlin',
+        wasmFile: 'tree-sitter-kotlin.wasm',
+        code: 'fun main() { println("Hello") }',
+        expectedRootType: 'source_file',
+    },
+    {
+        name: 'swift',
+        wasmFile: 'tree-sitter-swift.wasm',
+        code: 'func greet() -> String { return "Hello" }',
+        expectedRootType: 'source_file',
+    },
+    // Note: Dart grammar temporarily disabled due to tree-sitter version mismatch
+    // tree-sitter-wasms Dart WASM is version 15, but web-tree-sitter 0.24.7 supports 13-14
+    // TODO: Re-enable when web-tree-sitter updates or use alternative Dart WASM
+    // {
+    // 	name: 'dart',
+    // 	wasmFile: 'tree-sitter-dart.wasm',
+    // 	code: 'void main() { print("Hello"); }',
+    // 	expectedRootType: 'program',
+    // },
+    {
+        name: 'php',
+        wasmFile: 'tree-sitter-php.wasm',
+        code: '<?php\nfunction foo() { return 42; }',
+        expectedRootType: 'program',
+    },
+];
+// Resolve WASM base path
+const wasmPackagePath = require.resolve('tree-sitter-wasms/package.json');
+const wasmBasePath = path.join(path.dirname(wasmPackagePath), 'out');
+describe('Grammar Smoke Tests', () => {
+    let parser;
+    beforeAll(async () => {
+        // Initialize web-tree-sitter WASM module
+        await Parser.init();
+        parser = new Parser();
+    });
+    it.each(GRAMMARS)('$name: loads and parses correctly', async ({ wasmFile, code }) => {
+        // Load grammar from WASM
+        const wasmPath = path.join(wasmBasePath, wasmFile);
+        const language = await Parser.Language.load(wasmPath);
+        // Set language and parse
+        parser.setLanguage(language);
+        const tree = parser.parse(code);
+        // Verify parsing succeeded
+        expect(tree).toBeDefined();
+        expect(tree.rootNode).toBeDefined();
+        expect(tree.rootNode.type).toBeDefined();
+        // Verify no parse errors (syntax errors in the test code)
+        expect(tree.rootNode.hasError).toBe(false);
+    });
+    it.each(GRAMMARS)('$name: root node type is $expectedRootType', async ({ wasmFile, code, expectedRootType }) => {
+        if (!expectedRootType)
+            return; // Skip if no expected type
+        const wasmPath = path.join(wasmBasePath, wasmFile);
+        const language = await Parser.Language.load(wasmPath);
+        parser.setLanguage(language);
+        const tree = parser.parse(code);
+        expect(tree.rootNode.type).toBe(expectedRootType);
+    });
+    it('reports platform and Node.js info', () => {
+        const info = {
+            platform: process.platform,
+            arch: process.arch,
+            nodeVersion: process.version,
+            grammarsLoaded: GRAMMARS.length,
+            wasmBasePath,
+        };
+        console.log('Platform info:', JSON.stringify(info, null, 2));
+        // Verify we're on a supported platform
+        expect(['darwin', 'linux', 'win32']).toContain(process.platform);
+        expect(['x64', 'arm64']).toContain(process.arch);
+    });
+    it('web-tree-sitter core loads correctly', async () => {
+        expect(Parser).toBeDefined();
+        expect(typeof Parser).toBe('function');
+        // Parser.init() already called in beforeAll
+        const testParser = new Parser();
+        expect(testParser).toBeDefined();
+    });
+    it('all 11 grammars are tested (Dart temporarily disabled)', () => {
+        // Note: Dart disabled due to tree-sitter version mismatch (version 15 vs supported 13-14)
+        expect(GRAMMARS.length).toBe(11);
+        const names = GRAMMARS.map(g => g.name);
+        expect(names).toContain('javascript');
+        expect(names).toContain('typescript');
+        expect(names).toContain('tsx');
+        expect(names).toContain('python');
+        expect(names).toContain('go');
+        expect(names).toContain('rust');
+        expect(names).toContain('java');
+        expect(names).toContain('csharp');
+        expect(names).toContain('kotlin');
+        expect(names).toContain('swift');
+        // expect(names).toContain('dart'); // Temporarily disabled
+        expect(names).toContain('php');
+    });
+});

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

@@ -0,0 +1,30 @@
+/**
+ * Test helpers for E2E tests.
+ */
+/** Path to the checked-in test fixtures */
+export declare const FIXTURES_ROOT: string;
+/** Test context with temp directory and cleanup */
+export interface TestContext {
+    projectRoot: string;
+    cleanup: () => Promise<void>;
+}
+/**
+ * Copy fixture directory to a unique temp directory.
+ */
+export declare function copyFixtureToTemp(fixtureName?: string): Promise<TestContext>;
+/**
+ * Add a new file to the temp project.
+ */
+export declare function addFile(projectRoot: string, relativePath: string, content: string): Promise<void>;
+/**
+ * Modify an existing file in the temp project.
+ */
+export declare function modifyFile(projectRoot: string, relativePath: string, content: string): Promise<void>;
+/**
+ * Delete a file from the temp project.
+ */
+export declare function deleteFile(projectRoot: string, relativePath: string): Promise<void>;
+/**
+ * Wait for filesystem changes to propagate (mtime resolution).
+ */
+export declare function waitForFs(ms?: number): Promise<void>;

package/dist/rag/__tests__/helpers.js

@@ -0,0 +1,67 @@
+/**
+ * Test helpers for E2E tests.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+/** Path to the checked-in test fixtures */
+export const FIXTURES_ROOT = path.join(process.cwd(), 'test-fixtures');
+/**
+ * Copy fixture directory to a unique temp directory.
+ */
+export async function copyFixtureToTemp(fixtureName = 'codebase') {
+    const fixtureSource = path.join(FIXTURES_ROOT, fixtureName);
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'viberag-test-'));
+    await copyDirectory(fixtureSource, tempDir);
+    return {
+        projectRoot: tempDir,
+        cleanup: async () => {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        },
+    };
+}
+/**
+ * Copy a directory recursively.
+ */
+async function copyDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Add a new file to the temp project.
+ */
+export async function addFile(projectRoot, relativePath, content) {
+    const fullPath = path.join(projectRoot, relativePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content);
+}
+/**
+ * Modify an existing file in the temp project.
+ */
+export async function modifyFile(projectRoot, relativePath, content) {
+    const fullPath = path.join(projectRoot, relativePath);
+    await fs.writeFile(fullPath, content);
+}
+/**
+ * Delete a file from the temp project.
+ */
+export async function deleteFile(projectRoot, relativePath) {
+    const fullPath = path.join(projectRoot, relativePath);
+    await fs.unlink(fullPath);
+}
+/**
+ * Wait for filesystem changes to propagate (mtime resolution).
+ */
+export async function waitForFs(ms = 100) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Merkle tree unit tests.
+ * Tests tree structure building and change detection (diffing).
+ */
+export {};