viberag 0.1.0

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

@@ -0,0 +1,133 @@
+/**
+ * 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
+ */
+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 Modes', () => {
+    let ctx;
+    let search;
+    beforeAll(async () => {
+        // Setup once for all tests - 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('definition mode', () => {
+        it('finds function definition by exact name', async () => {
+            const results = await search.search('getUser', {
+                mode: 'definition',
+                symbolName: 'getUser',
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.searchType).toBe('definition');
+            // Should find the function in endpoints.ts
+            expect(results.results.some(r => r.filepath.includes('endpoints.ts'))).toBe(true);
+        }, 60000);
+        it('finds class definition by name', async () => {
+            // Use semantic search to find class - definition mode uses exact name match
+            const results = await search.search('UserService class', {
+                mode: 'semantic',
+                filters: { type: ['class'] },
+            });
+            // Should find the class in exported.ts
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('exported.ts'))).toBe(true);
+            }
+        }, 60000);
+        it('finds method definition by name', async () => {
+            // Use semantic search for method lookup
+            const results = await search.search('fetchData method http', {
+                mode: 'semantic',
+                filters: { type: ['method'] },
+            });
+            // Should find the method in http_client.ts
+            if (results.results.length > 0) {
+                expect(results.results.some(r => r.filepath.includes('http_client.ts'))).toBe(true);
+            }
+        }, 60000);
+        it('returns empty for non-existent symbol', async () => {
+            const results = await search.search('nonExistentSymbolXYZ123', {
+                mode: 'definition',
+                symbolName: 'nonExistentSymbolXYZ123',
+            });
+            expect(results.results.length).toBe(0);
+        }, 60000);
+        it('can filter definitions by type', async () => {
+            const results = await search.search('add', {
+                mode: 'definition',
+                symbolName: 'add_two_numbers',
+                filters: { type: ['function'] },
+            });
+            if (results.results.length > 0) {
+                expect(results.results.every(r => r.type === 'function')).toBe(true);
+            }
+        }, 60000);
+    });
+    describe('similar mode', () => {
+        it('finds similar code by snippet', async () => {
+            // Search for code similar to an async fetch function
+            const snippet = `async function fetchData(url) {
+				const response = await fetch(url);
+				return response.json();
+			}`;
+            const results = await search.search(snippet, {
+                mode: 'similar',
+                codeSnippet: snippet,
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            expect(results.searchType).toBe('similar');
+            // Should find http_client.ts which has similar fetch logic
+            expect(results.results.some(r => r.filepath.includes('http_client.ts'))).toBe(true);
+        }, 60000);
+        it('finds similar Python code', async () => {
+            const snippet = `def calculate(a, b):
+				return a + b`;
+            const results = await search.search(snippet, {
+                mode: 'similar',
+                codeSnippet: snippet,
+            });
+            expect(results.results.length).toBeGreaterThan(0);
+            // Should find math.py which has similar arithmetic functions
+            expect(results.results.some(r => r.filepath.includes('math.py'))).toBe(true);
+        }, 60000);
+        it('respects limit parameter', async () => {
+            const snippet = `function helper() { return true; }`;
+            const results = await search.search(snippet, {
+                mode: 'similar',
+                codeSnippet: snippet,
+                limit: 3,
+            });
+            expect(results.results.length).toBeLessThanOrEqual(3);
+        }, 60000);
+    });
+    describe('mode selection', () => {
+        it('defaults to hybrid mode', async () => {
+            const results = await search.search('function');
+            expect(results.searchType).toBe('hybrid');
+        }, 60000);
+        it('semantic mode returns semantic type', async () => {
+            const results = await search.search('how does authentication work', {
+                mode: 'semantic',
+            });
+            expect(results.searchType).toBe('semantic');
+        }, 60000);
+        it('exact mode returns exact type', async () => {
+            const results = await search.search('fetchData', {
+                mode: 'exact',
+            });
+            expect(results.searchType).toBe('exact');
+        }, 60000);
+    });
+});

package/dist/rag/config/index.d.ts

@@ -0,0 +1,61 @@
+import type { EmbeddingProviderType } from '../../common/types.js';
+export type { EmbeddingProviderType };
+/**
+ * File watcher configuration for auto-indexing.
+ */
+export interface WatchConfig {
+    /** Enable file watching for auto-index (default: true) */
+    enabled: boolean;
+    /** Debounce delay before processing changes (default: 500ms) */
+    debounceMs: number;
+    /** Batch window to collect changes before indexing (default: 2000ms) */
+    batchWindowMs: number;
+    /** Wait for file writes to complete before indexing (default: true) */
+    awaitWriteFinish: boolean;
+}
+export interface ViberagConfig {
+    version: number;
+    embeddingProvider: EmbeddingProviderType;
+    embeddingModel: string;
+    embeddingDimensions: number;
+    /** API key for cloud providers (gemini, mistral, openai) */
+    apiKey?: string;
+    extensions: string[];
+    excludePatterns: string[];
+    chunkMaxSize: number;
+    /** @deprecated Use watch.debounceMs instead */
+    watchDebounceMs: number;
+    /** File watcher configuration */
+    watch: WatchConfig;
+}
+/**
+ * Provider-specific embedding configurations.
+ */
+export declare const PROVIDER_CONFIGS: Record<EmbeddingProviderType, {
+    model: string;
+    dimensions: number;
+}>;
+/**
+ * Create config for a specific provider.
+ */
+export declare function createConfigForProvider(provider: EmbeddingProviderType): ViberagConfig;
+/**
+ * Default watch configuration.
+ */
+export declare const DEFAULT_WATCH_CONFIG: WatchConfig;
+export declare const DEFAULT_CONFIG: ViberagConfig;
+/**
+ * Load config from disk, merging with defaults.
+ * Returns DEFAULT_CONFIG if no config file exists.
+ * Handles nested watch config merge for backward compatibility.
+ */
+export declare function loadConfig(projectRoot: string): Promise<ViberagConfig>;
+/**
+ * Save config to disk.
+ * Creates the .viberag directory if it doesn't exist.
+ */
+export declare function saveConfig(projectRoot: string, config: ViberagConfig): Promise<void>;
+/**
+ * Check if a config file exists.
+ */
+export declare function configExists(projectRoot: string): Promise<boolean>;

package/dist/rag/config/index.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import { getConfigPath, getViberagDir } from '../constants.js';
+/**
+ * Provider-specific embedding configurations.
+ */
+export const PROVIDER_CONFIGS = {
+    local: {
+        model: 'Qwen/Qwen3-Embedding-0.6B',
+        dimensions: 1024,
+    },
+    'local-4b': {
+        model: 'Qwen/Qwen3-Embedding-4B',
+        dimensions: 2560,
+    },
+    gemini: {
+        model: 'gemini-embedding-001',
+        dimensions: 1536,
+    },
+    mistral: {
+        model: 'codestral-embed',
+        dimensions: 1024,
+    },
+    openai: {
+        model: 'text-embedding-3-small',
+        dimensions: 1536,
+    },
+};
+/**
+ * Create config for a specific provider.
+ */
+export function createConfigForProvider(provider) {
+    const providerConfig = PROVIDER_CONFIGS[provider];
+    return {
+        ...DEFAULT_CONFIG,
+        embeddingProvider: provider,
+        embeddingModel: providerConfig.model,
+        embeddingDimensions: providerConfig.dimensions,
+    };
+}
+/**
+ * Default watch configuration.
+ */
+export const DEFAULT_WATCH_CONFIG = {
+    enabled: true,
+    debounceMs: 500,
+    batchWindowMs: 2000,
+    awaitWriteFinish: true,
+};
+export const DEFAULT_CONFIG = {
+    version: 1,
+    embeddingProvider: 'gemini',
+    embeddingModel: PROVIDER_CONFIGS['gemini'].model,
+    embeddingDimensions: PROVIDER_CONFIGS['gemini'].dimensions,
+    // Extensions to index. Empty array = index ALL text files (recommended).
+    // Binary files are automatically detected and skipped.
+    // Use .gitignore for exclusions.
+    extensions: [],
+    // DEPRECATED: Use .gitignore instead. This field is ignored.
+    excludePatterns: [],
+    chunkMaxSize: 2000,
+    watchDebounceMs: 500,
+    watch: DEFAULT_WATCH_CONFIG,
+};
+/**
+ * Load config from disk, merging with defaults.
+ * Returns DEFAULT_CONFIG if no config file exists.
+ * Handles nested watch config merge for backward compatibility.
+ */
+export async function loadConfig(projectRoot) {
+    const configPath = getConfigPath(projectRoot);
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        const loaded = JSON.parse(content);
+        // Deep merge watch config with defaults
+        const watchConfig = {
+            ...DEFAULT_WATCH_CONFIG,
+            ...(loaded.watch ?? {}),
+        };
+        return {
+            ...DEFAULT_CONFIG,
+            ...loaded,
+            watch: watchConfig,
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+/**
+ * Save config to disk.
+ * Creates the .viberag directory if it doesn't exist.
+ */
+export async function saveConfig(projectRoot, config) {
+    const viberagDir = getViberagDir(projectRoot);
+    await fs.mkdir(viberagDir, { recursive: true });
+    const configPath = getConfigPath(projectRoot);
+    await fs.writeFile(configPath, JSON.stringify(config, null, '\t') + '\n');
+}
+/**
+ * Check if a config file exists.
+ */
+export async function configExists(projectRoot) {
+    const configPath = getConfigPath(projectRoot);
+    try {
+        await fs.access(configPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/rag/constants.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Directory name for Viberag storage.
+ * This directory should be added to .gitignore.
+ */
+export declare const VIBERAG_DIR = ".viberag";
+/**
+ * Get the absolute path to the Viberag directory for a project.
+ */
+export declare function getViberagDir(projectRoot: string): string;
+/**
+ * Get the path to the config file.
+ */
+export declare function getConfigPath(projectRoot: string): string;
+/**
+ * Get the path to the manifest file.
+ */
+export declare function getManifestPath(projectRoot: string): string;
+/**
+ * Get the path to the LanceDB database directory.
+ */
+export declare function getLanceDbPath(projectRoot: string): string;
+/**
+ * Get the path to the logs directory.
+ */
+export declare function getLogsDir(projectRoot: string): string;
+/**
+ * LanceDB table names.
+ */
+export declare const TABLE_NAMES: {
+    readonly CODE_CHUNKS: "code_chunks";
+    readonly EMBEDDING_CACHE: "embedding_cache";
+};
+/**
+ * File extensions supported for parsing.
+ * Maps extension to language identifier.
+ */
+export declare const EXTENSION_TO_LANGUAGE: Record<string, string>;
+/**
+ * Embedding dimensions for default model (BGE-base-en-v1.5).
+ */
+export declare const DEFAULT_EMBEDDING_DIMENSIONS = 768;

package/dist/rag/constants.js

@@ -0,0 +1,57 @@
+import path from 'node:path';
+/**
+ * Directory name for Viberag storage.
+ * This directory should be added to .gitignore.
+ */
+export const VIBERAG_DIR = '.viberag';
+/**
+ * Get the absolute path to the Viberag directory for a project.
+ */
+export function getViberagDir(projectRoot) {
+    return path.join(projectRoot, VIBERAG_DIR);
+}
+/**
+ * Get the path to the config file.
+ */
+export function getConfigPath(projectRoot) {
+    return path.join(getViberagDir(projectRoot), 'config.json');
+}
+/**
+ * Get the path to the manifest file.
+ */
+export function getManifestPath(projectRoot) {
+    return path.join(getViberagDir(projectRoot), 'manifest.json');
+}
+/**
+ * Get the path to the LanceDB database directory.
+ */
+export function getLanceDbPath(projectRoot) {
+    return path.join(getViberagDir(projectRoot), 'lancedb');
+}
+/**
+ * Get the path to the logs directory.
+ */
+export function getLogsDir(projectRoot) {
+    return path.join(getViberagDir(projectRoot), 'logs');
+}
+/**
+ * LanceDB table names.
+ */
+export const TABLE_NAMES = {
+    CODE_CHUNKS: 'code_chunks',
+    EMBEDDING_CACHE: 'embedding_cache',
+};
+/**
+ * File extensions supported for parsing.
+ * Maps extension to language identifier.
+ */
+export const EXTENSION_TO_LANGUAGE = {
+    '.py': 'python',
+    '.js': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+};
+/**
+ * Embedding dimensions for default model (BGE-base-en-v1.5).
+ */
+export const DEFAULT_EMBEDDING_DIMENSIONS = 768;

package/dist/rag/embeddings/fastembed.d.ts

@@ -0,0 +1,62 @@
+/**
+ * FastEmbed provider using ONNX runtime with quantized models.
+ *
+ * Uses BGE models which are general-purpose text embeddings.
+ * Much faster than Jina due to smaller models and int8 quantization.
+ */
+import { EmbeddingModel } from 'fastembed';
+import type { EmbeddingProvider } from './types.js';
+/**
+ * Model configurations for FastEmbed.
+ */
+declare const MODEL_CONFIG: {
+    readonly small: {
+        readonly model: EmbeddingModel.BGESmallENV15;
+        readonly dimensions: 384;
+        readonly name: "bge-small-en-v1.5";
+        readonly size: "32MB";
+    };
+    readonly base: {
+        readonly model: EmbeddingModel.BGEBaseENV15;
+        readonly dimensions: 768;
+        readonly name: "bge-base-en-v1.5";
+        readonly size: "134MB";
+    };
+};
+export type FastEmbedModelSize = keyof typeof MODEL_CONFIG;
+/**
+ * FastEmbed provider for fast local embeddings.
+ * Uses quantized BGE models via ONNX runtime.
+ */
+export declare class FastEmbedProvider implements EmbeddingProvider {
+    readonly dimensions: number;
+    private modelSize;
+    private model;
+    private initialized;
+    private initPromise;
+    /**
+     * Create a FastEmbed provider.
+     * @param modelSize - 'small' (384d, 32MB) or 'base' (768d, 134MB)
+     */
+    constructor(modelSize?: FastEmbedModelSize);
+    /**
+     * Initialize the embedding model.
+     * Downloads the quantized ONNX model on first use.
+     */
+    initialize(): Promise<void>;
+    private _doInitialize;
+    /**
+     * Generate embeddings for multiple texts.
+     * FastEmbed handles batching internally via generator.
+     */
+    embed(texts: string[]): Promise<number[][]>;
+    /**
+     * Generate embedding for a single text.
+     */
+    embedSingle(text: string): Promise<number[]>;
+    /**
+     * Close the provider and free resources.
+     */
+    close(): void;
+}
+export {};

package/dist/rag/embeddings/fastembed.js

@@ -0,0 +1,124 @@
+/**
+ * FastEmbed provider using ONNX runtime with quantized models.
+ *
+ * Uses BGE models which are general-purpose text embeddings.
+ * Much faster than Jina due to smaller models and int8 quantization.
+ */
+import { EmbeddingModel, FlagEmbedding } from 'fastembed';
+/**
+ * Model configurations for FastEmbed.
+ */
+const MODEL_CONFIG = {
+    small: {
+        model: EmbeddingModel.BGESmallENV15,
+        dimensions: 384,
+        name: 'bge-small-en-v1.5',
+        size: '32MB',
+    },
+    base: {
+        model: EmbeddingModel.BGEBaseENV15,
+        dimensions: 768,
+        name: 'bge-base-en-v1.5',
+        size: '134MB',
+    },
+};
+/**
+ * FastEmbed provider for fast local embeddings.
+ * Uses quantized BGE models via ONNX runtime.
+ */
+export class FastEmbedProvider {
+    /**
+     * Create a FastEmbed provider.
+     * @param modelSize - 'small' (384d, 32MB) or 'base' (768d, 134MB)
+     */
+    constructor(modelSize = 'small') {
+        Object.defineProperty(this, "dimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "initPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.modelSize = modelSize;
+        this.dimensions = MODEL_CONFIG[modelSize].dimensions;
+    }
+    /**
+     * Initialize the embedding model.
+     * Downloads the quantized ONNX model on first use.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._doInitialize();
+        await this.initPromise;
+    }
+    async _doInitialize() {
+        const config = MODEL_CONFIG[this.modelSize];
+        const startTime = Date.now();
+        console.error(`[FastEmbedProvider] Loading ${config.name} (~${config.size})...`);
+        this.model = await FlagEmbedding.init({
+            model: config.model,
+        });
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.error(`[FastEmbedProvider] Model loaded in ${elapsed}s`);
+        this.initialized = true;
+    }
+    /**
+     * Generate embeddings for multiple texts.
+     * FastEmbed handles batching internally via generator.
+     */
+    async embed(texts) {
+        if (!this.initialized || !this.model) {
+            await this.initialize();
+        }
+        if (texts.length === 0) {
+            return [];
+        }
+        const results = [];
+        // FastEmbed uses a generator pattern for batch processing
+        for await (const batch of this.model.embed(texts)) {
+            results.push(...batch);
+        }
+        return results;
+    }
+    /**
+     * Generate embedding for a single text.
+     */
+    async embedSingle(text) {
+        const results = await this.embed([text]);
+        return results[0];
+    }
+    /**
+     * Close the provider and free resources.
+     */
+    close() {
+        this.model = null;
+        this.initialized = false;
+    }
+}

package/dist/rag/embeddings/gemini.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gemini embedding provider using Google's Generative AI API.
+ *
+ * Uses gemini-embedding-001 model with 1536 dimensions.
+ * Note: The model defaults to 3072 dims but we explicitly request 1536 for:
+ * - Good balance of quality and storage
+ * - Matches OpenAI text-embedding-3-small dimensions
+ *
+ * Free tier available with generous limits.
+ */
+import type { EmbeddingProvider, ModelProgressCallback } from './types.js';
+/**
+ * Gemini embedding provider.
+ * Uses gemini-embedding-001 model via Google's Generative AI API.
+ */
+export declare class GeminiEmbeddingProvider implements EmbeddingProvider {
+    readonly dimensions = 1536;
+    private apiKey;
+    private initialized;
+    constructor(apiKey?: string);
+    initialize(_onProgress?: ModelProgressCallback): Promise<void>;
+    embed(texts: string[]): Promise<number[][]>;
+    private embedBatch;
+    embedSingle(text: string): Promise<number[]>;
+    close(): void;
+}