viberag 0.3.2 → 0.4.0

package/dist/mcp/index.js

@@ -4,78 +4,62 @@
  *
  * Exposes VibeRAG functionality via Model Context Protocol.
  * Uses current working directory as project root.
- * Includes file watcher for automatic incremental indexing.
+ * Connects to the daemon for all RAG operations.
  *
  * Usage with Claude Code:
  *   claude mcp add viberag -- npx viberag-mcp
  */
 import { createMcpServer } from './server.js';
-import { configExists, Indexer } from '../rag/index.js';
+import { configExists } from '../daemon/lib/config.js';
 // Use current working directory as project root (same behavior as CLI)
 const projectRoot = process.cwd();
-const { server, startWatcher, stopWatcher, startWarmup, warmupManager } = createMcpServer(projectRoot);
+const { server, connectDaemon, disconnectDaemon } = createMcpServer(projectRoot);
 // Handle shutdown signals
 async function shutdown(signal) {
     console.error(`[viberag-mcp] Received ${signal}, shutting down...`);
-    await stopWatcher();
+    await disconnectDaemon();
     process.exit(0);
 }
-process.on('SIGINT', () => shutdown('SIGINT'));
-process.on('SIGTERM', () => shutdown('SIGTERM'));
-// Start the server, then start the watcher
-server.start({
-    transportType: 'stdio',
+process.on('SIGINT', () => {
+    void shutdown('SIGINT');
 });
-// Start warmup, watcher, and sync index after server is running
-// Use setImmediate to ensure server.start() completes first
-setImmediate(async () => {
-    // Start warmup FIRST (most important for tool responsiveness)
-    // This runs in background - tools will wait for it to complete
-    try {
-        if (await configExists(projectRoot)) {
-            startWarmup();
-            console.error('[viberag-mcp] Warmup started');
-            // Monitor warmup completion for logging (non-blocking)
-            warmupManager.getWarmupPromise()?.catch(error => {
-                console.error('[viberag-mcp] Warmup failed:', error instanceof Error ? error.message : error);
-            });
-        }
-    }
-    catch (error) {
-        console.error('[viberag-mcp] Failed to start warmup:', error instanceof Error ? error.message : error);
-    }
-    // Start watcher (will queue any changes during sync)
-    try {
-        await startWatcher();
-    }
-    catch (error) {
-        // Watcher errors shouldn't crash the server
-        console.error('[viberag-mcp] Failed to start watcher:', error instanceof Error ? error.message : error);
-    }
-    // Sync index on startup if project is initialized
-    // This catches any changes made while MCP server was offline
-    try {
-        if (await configExists(projectRoot)) {
-            console.error('[viberag-mcp] Running startup sync...');
-            const indexer = new Indexer(projectRoot);
-            try {
-                const stats = await indexer.index({ force: false });
-                if (stats.filesNew > 0 ||
-                    stats.filesModified > 0 ||
-                    stats.filesDeleted > 0) {
-                    console.error(`[viberag-mcp] Startup sync complete: ${stats.filesNew} new, ${stats.filesModified} modified, ${stats.filesDeleted} deleted`);
-                }
-                else {
-                    console.error('[viberag-mcp] Startup sync: index up to date');
-                }
-            }
-            finally {
-                indexer.close();
-            }
-        }
-    }
-    catch (error) {
-        // Sync errors shouldn't crash the server
-        console.error('[viberag-mcp] Startup sync failed:', error instanceof Error ? error.message : error);
+process.on('SIGTERM', () => {
+    void shutdown('SIGTERM');
+});
+/**
+ * Run startup tasks after MCP client connects.
+ * This is deferred to ensure the MCP handshake completes first.
+ */
+async function runStartupTasks() {
+    // Check if project is initialized
+    const isInitialized = await configExists(projectRoot);
+    if (!isInitialized) {
+        console.error('[viberag-mcp] Project not initialized.');
+        console.error('[viberag-mcp] Run "npx viberag" in this directory and use /init to configure.');
+        console.error('[viberag-mcp] Use viberag_status tool for details on how to initialize.');
+        // For uninitialized projects, we're done
+        return;
     }
+    // Connect to daemon (starts it if needed)
+    // The daemon handles warmup, watcher, and startup sync
+    await connectDaemon();
+}
+// Wait for client to connect before running startup tasks
+// This ensures the MCP handshake completes before any file I/O
+server.on('connect', () => {
+    // Run startup tasks in the background (don't block the connection)
+    runStartupTasks().catch(error => {
+        // Pass Error object directly to preserve stack trace (ADR-011)
+        console.error('[viberag-mcp] Startup tasks failed:', error);
+    });
+});
+// Start the server (await to ensure transport is ready)
+server
+    .start({
+    transportType: 'stdio',
+})
+    .catch(error => {
+    // Pass Error object directly to preserve stack trace (ADR-011)
+    console.error('[viberag-mcp] Failed to start server:', error);
+    process.exit(1);
 });

package/dist/mcp/server.d.ts

@@ -7,23 +7,19 @@
  * Includes file watcher for automatic incremental indexing.
  */
 import { FastMCP } from 'fastmcp';
-import { FileWatcher } from './watcher.js';
-import { WarmupManager } from './warmup.js';
+import { DaemonClient } from '../client/index.js';
 /**
- * MCP server with file watcher and warmup manager.
+ * MCP server with daemon client.
  */
-export interface McpServerWithWatcher {
+export interface McpServerWithDaemon {
     server: FastMCP;
-    watcher: FileWatcher;
-    warmupManager: WarmupManager;
-    /** Start the watcher (call after server.start) */
-    startWatcher: () => Promise<void>;
-    /** Stop the watcher (call before exit) */
-    stopWatcher: () => Promise<void>;
-    /** Start warmup (call after server.start) */
-    startWarmup: () => void;
+    client: DaemonClient;
+    /** Connect to daemon (call after server.start) */
+    connectDaemon: () => Promise<void>;
+    /** Disconnect from daemon (call before exit) */
+    disconnectDaemon: () => Promise<void>;
 }
 /**
- * Create and configure the MCP server with file watcher and warmup manager.
+ * Create and configure the MCP server with daemon client.
  */
-export declare function createMcpServer(projectRoot: string): McpServerWithWatcher;
+export declare function createMcpServer(projectRoot: string): McpServerWithDaemon;

package/dist/mcp/server.js

@@ -9,9 +9,11 @@
 import { createRequire } from 'node:module';
 import { FastMCP } from 'fastmcp';
 import { z } from 'zod';
-import { Indexer, configExists, loadManifest, manifestExists, loadConfig, saveConfig, PROVIDER_CONFIGS, getSchemaVersionInfo, } from '../rag/index.js';
-import { FileWatcher } from './watcher.js';
-import { WarmupManager } from './warmup.js';
+// Direct imports from daemon for fast startup (avoid barrel file)
+import { configExists, loadConfig } from '../daemon/lib/config.js';
+import { loadManifest, manifestExists, getSchemaVersionInfo, } from '../daemon/lib/manifest.js';
+import { DaemonClient } from '../client/index.js';
+import { createServiceLogger } from '../daemon/lib/logger.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 /**
@@ -20,7 +22,7 @@ const pkg = require('../../package.json');
 class NotInitializedError extends Error {
     constructor(projectRoot) {
         super(`VibeRAG not initialized in ${projectRoot}. ` +
-            `Run 'npx viberag' and use /init command first.`);
+            `Use viberag_status tool for details, or run 'npx viberag' CLI and use /init command.`);
         this.name = 'NotInitializedError';
     }
 }
@@ -187,17 +189,23 @@ function formatIndexStats(stats) {
     });
 }
 /**
- * Create and configure the MCP server with file watcher and warmup manager.
+ * Create and configure the MCP server with daemon client.
  */
 export function createMcpServer(projectRoot) {
     const server = new FastMCP({
         name: 'viberag',
         version: pkg.version,
     });
-    // Create file watcher
-    const watcher = new FileWatcher(projectRoot);
-    // Create warmup manager for shared SearchEngine
-    const warmupManager = new WarmupManager(projectRoot);
+    // Create daemon client (auto-starts daemon if needed)
+    const client = new DaemonClient(projectRoot);
+    // Create logger for error tracking (writes to .viberag/logs/mcp/)
+    let logger = null;
+    const getLogger = () => {
+        if (!logger) {
+            logger = createServiceLogger(projectRoot, 'mcp');
+        }
+        return logger;
+    };
     // Filters schema for transparent, AI-controlled filtering
     const filtersSchema = z
         .object({
@@ -408,16 +416,15 @@ Production code: { path_not_contains: ["test", "mock", "fixture"], is_exported:
                     hasDocstring: args.filters.has_docstring,
                 }
                 : undefined;
-            // Get shared search engine from warmup manager (waits for warmup if needed)
-            const engine = await warmupManager.getSearchEngine();
             // Determine if debug info should be returned
             const returnDebug = args.return_debug ??
                 (args.mode === 'hybrid' || args.mode === undefined);
-            const results = await engine.search(args.query, {
+            // Search via daemon client
+            const results = await client.search(args.query, {
                 mode: args.mode,
                 limit: args.limit,
                 minScore: args.min_score,
-                filters,
+                filters: filters,
                 codeSnippet: args.code_snippet,
                 symbolName: args.symbol_name,
                 bm25Weight: args.bm25_weight,
@@ -425,7 +432,6 @@ Production code: { path_not_contains: ["test", "mock", "fixture"], is_exported:
                 autoBoostThreshold: args.auto_boost_threshold,
                 returnDebug,
             });
-            // Don't close engine - it's shared across calls
             return formatSearchResults(results, returnDebug, args.max_response_size);
         },
     });
@@ -446,29 +452,9 @@ Production code: { path_not_contains: ["test", "mock", "fixture"], is_exported:
         }),
         execute: async (args) => {
             await ensureInitialized(projectRoot);
-            // When forcing reindex, sync config dimensions with current provider settings
-            // This handles cases where PROVIDER_CONFIGS dimensions changed (e.g., Gemini 768→1536)
-            if (args.force) {
-                const config = await loadConfig(projectRoot);
-                const currentDimensions = PROVIDER_CONFIGS[config.embeddingProvider]?.dimensions;
-                if (currentDimensions &&
-                    config.embeddingDimensions !== currentDimensions) {
-                    const updatedConfig = {
-                        ...config,
-                        embeddingDimensions: currentDimensions,
-                        embeddingModel: PROVIDER_CONFIGS[config.embeddingProvider].model,
-                    };
-                    await saveConfig(projectRoot, updatedConfig);
-                }
-            }
-            const indexer = new Indexer(projectRoot);
-            try {
-                const stats = await indexer.index({ force: args.force });
-                return formatIndexStats(stats);
-            }
-            finally {
-                indexer.close();
-            }
+            // Index via daemon client (handles dimension sync internally)
+            const stats = await client.index({ force: args.force });
+            return formatIndexStats(stats);
         },
     });
     // Tool: viberag_status
@@ -476,10 +462,24 @@ Production code: { path_not_contains: ["test", "mock", "fixture"], is_exported:
         name: 'viberag_status',
         description: 'Get index status including file count, chunk count, embedding provider, schema version, and last update time. ' +
             'If schema version is outdated, run viberag_index with force=true to reindex. ' +
-            'TIP: Check status before delegating exploration to sub-agents to ensure the index is current.',
+            'TIP: Check status before delegating exploration to sub-agents to ensure the index is current. ' +
+            'This tool also works when the project is not initialized, providing guidance on how to set up.',
         parameters: z.object({}),
         execute: async () => {
-            await ensureInitialized(projectRoot);
+            // Check if project is initialized (don't throw, return helpful status)
+            if (!(await configExists(projectRoot))) {
+                return JSON.stringify({
+                    status: 'not_initialized',
+                    message: 'VibeRAG is not initialized in this project.',
+                    projectRoot,
+                    instructions: {
+                        step1: 'Run "npx viberag" in a terminal in this project directory',
+                        step2: 'Use the /init command to configure an embedding provider',
+                        providers: 'Choose from: Gemini (free tier), OpenAI, Mistral, or Local (no API key)',
+                        note: 'After initialization, run viberag_index to create the search index',
+                    },
+                });
+            }
             if (!(await manifestExists(projectRoot))) {
                 return JSON.stringify({
                     status: 'not_indexed',
@@ -507,16 +507,25 @@ Production code: { path_not_contains: ["test", "mock", "fixture"], is_exported:
                     `Schema version ${schemaInfo.current} is outdated (current: ${schemaInfo.required}). ` +
                         `Run viberag_index with force=true to reindex and enable new features.`;
             }
-            // Add warmup state
-            const warmupState = warmupManager.getState();
-            response['warmup'] = {
-                status: warmupState.status,
-                provider: warmupState.provider,
-                startedAt: warmupState.startedAt,
-                readyAt: warmupState.readyAt,
-                elapsedMs: warmupState.elapsedMs,
-                error: warmupState.error,
-            };
+            // Add warmup state from daemon status
+            try {
+                const daemonStatus = await client.status();
+                response['warmup'] = {
+                    status: daemonStatus.warmupStatus,
+                    elapsedMs: daemonStatus.warmupElapsedMs,
+                };
+            }
+            catch (error) {
+                // Log unexpected errors (expected: daemon not running)
+                const message = error instanceof Error ? error.message : String(error);
+                const isExpected = message.includes('ENOENT') || message.includes('ECONNREFUSED');
+                if (!isExpected) {
+                    // Log to both stderr and debug.log - pass Error object for full stack
+                    console.error('[mcp] Failed to get daemon warmup status:', error);
+                    getLogger().error('MCP', 'Failed to get daemon warmup status', error instanceof Error ? error : new Error(message));
+                }
+                response['warmup'] = { status: 'unknown' };
+            }
             return JSON.stringify(response);
         },
     });
@@ -527,7 +536,7 @@ Production code: { path_not_contains: ["test", "mock", "fixture"], is_exported:
             'how many files are being watched, pending changes, and last update time.',
         parameters: z.object({}),
         execute: async () => {
-            const status = watcher.getStatus();
+            const status = await client.watchStatus();
             return JSON.stringify(status);
         },
     });
@@ -666,14 +675,12 @@ Metadata filters:
                 .max(MAX_RESPONSE_SIZE)
                 .optional()
                 .default(DEFAULT_MAX_RESPONSE_SIZE)
-                .describe('Maximum response size in bytes (default: 100KB). ' +
+                .describe('Maximum response size in bytes (default: 50KB, max: 100KB). ' +
                 'Reduces merged result count to fit; does NOT truncate text.'),
         }),
         execute: async (args) => {
             await ensureInitialized(projectRoot);
-            // Get shared search engine from warmup manager (waits for warmup if needed)
-            const engine = await warmupManager.getSearchEngine();
-            // Run all searches in parallel
+            // Run all searches in parallel via daemon client
             const searchPromises = args.searches.map(async (config, index) => {
                 const filters = config.filters
                     ? {
@@ -687,10 +694,10 @@ Metadata filters:
                         hasDocstring: config.filters.has_docstring,
                     }
                     : undefined;
-                const results = await engine.search(config.query, {
+                const results = await client.search(config.query, {
                     mode: config.mode,
                     limit: config.limit,
-                    filters,
+                    filters: filters,
                     bm25Weight: config.bm25_weight,
                     autoBoost: config.auto_boost,
                     returnDebug: true,
@@ -813,7 +820,6 @@ Metadata filters:
                     results: mergedResults,
                 };
             }
-            // Don't close engine - it's shared across calls
             return JSON.stringify({
                 searchCount: args.searches.length,
                 individual,
@@ -823,26 +829,21 @@ Metadata filters:
     });
     return {
         server,
-        watcher,
-        warmupManager,
-        startWatcher: async () => {
-            // Only start watcher if project is initialized
+        client,
+        connectDaemon: async () => {
+            // Only connect if project is initialized
             if (await configExists(projectRoot)) {
-                await watcher.start();
+                try {
+                    await client.connect();
+                    console.error('[viberag-mcp] Connected to daemon');
+                }
+                catch (error) {
+                    console.error('[viberag-mcp] Failed to connect to daemon:', error instanceof Error ? error.message : error);
+                }
             }
         },
-        stopWatcher: async () => {
-            await watcher.stop();
-            warmupManager.close();
-        },
-        startWarmup: () => {
-            warmupManager.startWarmup({
-                onProgress: state => {
-                    if (state.status === 'ready') {
-                        console.error(`[viberag-mcp] Warmup complete (${state.elapsedMs}ms)`);
-                    }
-                },
-            });
+        disconnectDaemon: async () => {
+            await client.disconnect();
         },
     };
 }

package/dist/mcp/services/lazy-loader.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lazy Loader Service
+ *
+ * Provides lazy-loaded access to heavy RAG modules that have native dependencies.
+ * These modules (Indexer, SearchEngine) load tree-sitter WASM and lancedb native bindings,
+ * which takes ~500-1000ms. By loading them lazily, the MCP server can respond to
+ * the initialize handshake immediately.
+ *
+ * Pattern: Singleton with memoization
+ * Thread-safety: Safe - single-threaded Node.js environment
+ */
+import type { Indexer as IndexerType } from '../../rag/indexer/index.js';
+import type { SearchEngine as SearchEngineType } from '../../rag/search/index.js';
+/**
+ * Get the Indexer class, loading the module on first access.
+ * Subsequent calls return the cached reference.
+ */
+export declare function getIndexer(): Promise<typeof IndexerType>;
+/**
+ * Get the SearchEngine class, loading the module on first access.
+ * Subsequent calls return the cached reference.
+ */
+export declare function getSearchEngine(): Promise<typeof SearchEngineType>;

package/dist/mcp/services/lazy-loader.js

@@ -0,0 +1,34 @@
+/**
+ * Lazy Loader Service
+ *
+ * Provides lazy-loaded access to heavy RAG modules that have native dependencies.
+ * These modules (Indexer, SearchEngine) load tree-sitter WASM and lancedb native bindings,
+ * which takes ~500-1000ms. By loading them lazily, the MCP server can respond to
+ * the initialize handshake immediately.
+ *
+ * Pattern: Singleton with memoization
+ * Thread-safety: Safe - single-threaded Node.js environment
+ */
+// Memoized module references
+let indexerModule = null;
+let searchModule = null;
+/**
+ * Get the Indexer class, loading the module on first access.
+ * Subsequent calls return the cached reference.
+ */
+export async function getIndexer() {
+    if (!indexerModule) {
+        indexerModule = await import('../../rag/indexer/index.js');
+    }
+    return indexerModule.Indexer;
+}
+/**
+ * Get the SearchEngine class, loading the module on first access.
+ * Subsequent calls return the cached reference.
+ */
+export async function getSearchEngine() {
+    if (!searchModule) {
+        searchModule = await import('../../rag/search/index.js');
+    }
+    return searchModule.SearchEngine;
+}

package/dist/mcp/warmup.d.ts

@@ -4,12 +4,13 @@
  * Manages singleton SearchEngine initialization and state.
  * Ensures embedding model is loaded once and shared across tool calls.
  *
+ * State is tracked in Redux for consistency with the rest of the codebase.
  * The idempotent promise pattern solves the race condition:
  * - First call: Creates the warmup promise, starts initialization
  * - Concurrent calls: All await the SAME promise (no duplicate work)
  * - After ready: Returns cached SearchEngine immediately
  */
-import { SearchEngine } from '../rag/index.js';
+import type { SearchEngine } from '../rag/search/index.js';
 /**
  * Warmup status enum.
  */
@@ -41,10 +42,9 @@ export declare class WarmupManager {
     private readonly projectRoot;
     private searchEngine;
     private warmupPromise;
-    private state;
     constructor(projectRoot: string);
     /**
-     * Get current warmup state.
+     * Get current warmup state from Redux.
      */
     getState(): WarmupState;
     /**