viberag 0.3.2 → 0.4.0

package/README.md

@@ -575,13 +575,13 @@ Choose your embedding provider during `/init`:
 - Initial indexing may take time; future updates are incremental
 - Works great for code and natural language (docs, docstrings, code comments, etc.)
 
-### Cloud Providers - Fastest, Best Quality
+### Cloud Providers - Fastest, Best Quality, Largest Vocabulary
 
 | Provider | Model                  | Dims | Cost      | Get API Key                                             |
 | -------- | ---------------------- | ---- | --------- | ------------------------------------------------------- |
 | Gemini   | gemini-embedding-001   | 1536 | Free tier | [Google AI Studio](https://aistudio.google.com)         |
 | Mistral  | codestral-embed        | 1536 | $0.10/1M  | [Mistral Console](https://console.mistral.ai/api-keys/) |
-| OpenAI   | text-embedding-3-small | 1536 | $0.02/1M  | [OpenAI Platform](https://platform.openai.com/api-keys) |
+| OpenAI   | text-embedding-3-large | 1536 | $0.13/1M  | [OpenAI Platform](https://platform.openai.com/api-keys) |
 
 - **Gemini** - Free tier available, great for getting started
 - **Mistral** - Code-optimized embeddings for technical content

package/dist/cli/app.d.ts

@@ -1,2 +1,5 @@
 import React from 'react';
+/**
+ * Main App component with Redux Provider and DaemonStatusProvider.
+ */
 export default function App(): React.JSX.Element;

package/dist/cli/app.js

@@ -1,9 +1,16 @@
-import React, { useState, useEffect, useCallback } from 'react';
+import React, { useEffect, useCallback } from 'react';
 import { createRequire } from 'node:module';
 import { Box, Text, useStdout } from 'ink';
+import { Provider } from 'react-redux';
+import { store } from './store/store.js';
+import { useAppDispatch, useAppSelector } from './store/hooks.js';
+import { WizardActions } from './store/wizard/slice.js';
+import { selectActiveWizard, selectInitStep, selectMcpStep, selectInitConfig, selectMcpConfig, selectIsReinit, selectShowMcpPrompt, selectExistingApiKey, selectExistingProvider, } from './store/wizard/selectors.js';
+import { AppActions } from './store/app/slice.js';
+import { selectIsInitialized, selectIndexStats, selectAppStatus, selectOutputItems, selectStartupLoaded, } from './store/app/selectors.js';
 // Common infrastructure
 import TextInput from '../common/components/TextInput.js';
-import StatusBar from '../common/components/StatusBar.js';
+import StatusBar from './components/StatusBar.js';
 import StaticWithResize from '../common/components/StaticWithResize.js';
 import { useCtrlC } from '../common/hooks/useCtrlC.js';
 import { useCommandHistory } from '../common/hooks/useCommandHistory.js';
@@ -14,9 +21,11 @@ import SearchResultsDisplay from './components/SearchResultsDisplay.js';
 import InitWizard from './components/InitWizard.js';
 import McpSetupWizard from './components/McpSetupWizard.js';
 import CleanWizard from './components/CleanWizard.js';
-import { useRagCommands } from './commands/useRagCommands.js';
+import { useCommands } from './commands/useCommands.js';
+import { DaemonStatusProvider } from './contexts/DaemonStatusContext.js';
 import { checkInitialized, loadIndexStats, runInit, runIndex, formatIndexStats, } from './commands/handlers.js';
-import { getViberagDir, loadConfig } from '../rag/index.js';
+import { getViberagDir } from '../daemon/lib/constants.js';
+import { loadConfig } from '../daemon/lib/config.js';
 const require = createRequire(import.meta.url);
 // Path is relative from dist/ after compilation
 const { version } = require('../../package.json');
@@ -37,18 +46,28 @@ const COMMANDS = [
     { command: '/clean', description: 'Remove Viberag from project' },
     { command: '/quit', description: 'Exit the application' },
 ];
-// Module-level counter for unique IDs
-let nextId = 0;
-export default function App() {
-    const [outputItems, setOutputItems] = useState([]);
-    const [appStatus, setAppStatus] = useState({ state: 'ready' });
-    // undefined = not loaded yet, null = loaded but no manifest, {...} = loaded with stats
-    const [indexStats, setIndexStats] = useState(undefined);
-    const [isInitialized, setIsInitialized] = useState(undefined);
-    const [wizardMode, setWizardMode] = useState({ active: false });
-    // Existing config for reinit flow (API key preservation)
-    const [existingApiKey, setExistingApiKey] = useState(undefined);
-    const [existingProvider, setExistingProvider] = useState(undefined);
+/**
+ * Inner app content that uses Redux hooks.
+ * Must be rendered inside Provider.
+ */
+function AppContent() {
+    const dispatch = useAppDispatch();
+    // Redux wizard state
+    const activeWizard = useAppSelector(selectActiveWizard);
+    const initStep = useAppSelector(selectInitStep);
+    const mcpStep = useAppSelector(selectMcpStep);
+    const initConfig = useAppSelector(selectInitConfig);
+    const mcpConfig = useAppSelector(selectMcpConfig);
+    const isReinit = useAppSelector(selectIsReinit);
+    const showMcpPrompt = useAppSelector(selectShowMcpPrompt);
+    const existingApiKey = useAppSelector(selectExistingApiKey);
+    const existingProvider = useAppSelector(selectExistingProvider);
+    // Redux app state (migrated from useState)
+    const isInitialized = useAppSelector(selectIsInitialized);
+    const indexStats = useAppSelector(selectIndexStats);
+    const appStatus = useAppSelector(selectAppStatus);
+    const outputItems = useAppSelector(selectOutputItems);
+    const startupLoaded = useAppSelector(selectStartupLoaded);
     const { stdout } = useStdout();
     // Enable Kitty keyboard protocol for Shift+Enter support in iTerm2/Kitty/WezTerm
     useKittyKeyboard();
@@ -57,144 +76,115 @@ export default function App() {
     // Check initialization status and load stats on mount
     useEffect(() => {
         checkInitialized(projectRoot).then(async (initialized) => {
-            setIsInitialized(initialized);
+            dispatch(AppActions.setInitialized(initialized));
             // Load existing config for API key preservation during reinit
             if (initialized) {
                 const config = await loadConfig(projectRoot);
-                setExistingApiKey(config.apiKey);
-                setExistingProvider(config.embeddingProvider);
+                dispatch(WizardActions.setExistingConfig({
+                    apiKey: config.apiKey,
+                    provider: config.embeddingProvider,
+                }));
             }
         });
-        loadIndexStats(projectRoot).then(setIndexStats);
-    }, [projectRoot]);
+        loadIndexStats(projectRoot).then(stats => dispatch(AppActions.setIndexStats(stats)));
+    }, [projectRoot, dispatch]);
     // Command history
     const { addToHistory, navigateUp, navigateDown, resetIndex } = useCommandHistory();
-    const addOutput = (type, content) => {
-        const id = String(nextId++);
-        setOutputItems(prev => [
-            ...prev,
-            {
-                id,
-                type,
-                content,
-            },
-        ]);
-    };
-    const addSearchResults = (data) => {
-        const id = String(nextId++);
-        setOutputItems(prev => [
-            ...prev,
-            {
-                id,
-                type: 'search-results',
-                data,
-            },
-        ]);
-    };
+    const addOutput = useCallback((type, content) => {
+        dispatch(AppActions.addOutput({ type, content }));
+    }, [dispatch]);
+    const addSearchResults = useCallback((data) => {
+        dispatch(AppActions.addSearchResults(data));
+    }, [dispatch]);
     // Start the init wizard
     const startInitWizard = useCallback((isReinit) => {
-        setWizardMode({ active: true, type: 'init', step: 0, config: {}, isReinit });
-    }, []);
+        dispatch(WizardActions.startInit({
+            isReinit,
+            existingApiKey: existingApiKey ?? undefined,
+            existingProvider: existingProvider ?? undefined,
+        }));
+    }, [dispatch, existingApiKey, existingProvider]);
     // Start the MCP setup wizard
     const startMcpSetupWizard = useCallback((showPrompt = false) => {
-        setWizardMode({
-            active: true,
-            type: 'mcp-setup',
-            step: showPrompt ? 'prompt' : 'select',
-            config: {},
-            showPrompt,
-        });
-    }, []);
+        dispatch(WizardActions.startMcpSetup({ showPrompt }));
+    }, [dispatch]);
     // Start the clean wizard
     const startCleanWizard = useCallback(() => {
-        setWizardMode({ active: true, type: 'clean' });
-    }, []);
+        dispatch(WizardActions.startClean());
+    }, [dispatch]);
     // Handle clean wizard completion
     const handleCleanWizardComplete = useCallback(() => {
-        setWizardMode({ active: false });
+        dispatch(WizardActions.close());
         // Reset app state to uninitialized after cleaning
-        setIndexStats(null);
-        setIsInitialized(false);
-    }, []);
+        dispatch(AppActions.resetInitialized());
+    }, [dispatch]);
     // Handle init wizard step changes
     const handleInitWizardStep = useCallback((step, data) => {
-        setWizardMode(prev => prev.active && prev.type === 'init'
-            ? { ...prev, step, config: { ...prev.config, ...data } }
-            : prev);
-    }, []);
+        dispatch(WizardActions.setInitStep({ step, config: data }));
+    }, [dispatch]);
     // Handle MCP wizard step changes
     const handleMcpWizardStep = useCallback((step, data) => {
-        setWizardMode(prev => prev.active && prev.type === 'mcp-setup'
-            ? { ...prev, step, config: { ...prev.config, ...data } }
-            : prev);
-    }, []);
+        dispatch(WizardActions.setMcpStep({ step, config: data }));
+    }, [dispatch]);
     // Handle init wizard completion
     const handleInitWizardComplete = useCallback(async (config) => {
         // Close wizard first, then run init after a tick to ensure proper re-render
-        setWizardMode({ active: false });
+        dispatch(WizardActions.close());
         // Wait for next tick so wizard unmounts before we add output
         await new Promise(resolve => setTimeout(resolve, 50));
         addOutput('system', 'Initializing Viberag...');
-        setAppStatus({ state: 'warning', message: 'Initializing...' });
+        dispatch(AppActions.setWarning('Initializing...'));
         try {
             const result = await runInit(projectRoot, isInitialized ?? false, config);
             addOutput('system', result);
-            setIsInitialized(true);
+            dispatch(AppActions.setInitialized(true));
             // Automatically start indexing after init
             addOutput('system', 'Indexing codebase...');
-            setAppStatus({
-                state: 'indexing',
-                current: 0,
-                total: 0,
-                stage: 'Indexing',
-            });
-            const stats = await runIndex(projectRoot, true, (current, total, stage, throttleMessage, chunksProcessed) => setAppStatus({
-                state: 'indexing',
-                current,
-                total,
-                stage,
-                throttleMessage,
-                chunksProcessed,
-            }));
-            addOutput('system', formatIndexStats(stats));
+            // Progress is synced via DaemonStatusContext polling
+            const stats = await runIndex(projectRoot, true);
+            if (stats) {
+                addOutput('system', formatIndexStats(stats));
+            }
+            else {
+                addOutput('system', 'Index complete.');
+            }
             // Reload stats after indexing
             const newStats = await loadIndexStats(projectRoot);
-            setIndexStats(newStats);
-            setAppStatus({ state: 'ready' });
+            dispatch(AppActions.setIndexStats(newStats));
             // Prompt for MCP setup after init completes
             await new Promise(resolve => setTimeout(resolve, 100));
             startMcpSetupWizard(true); // showPrompt = true for post-init flow
         }
         catch (err) {
             addOutput('system', `Init failed: ${err instanceof Error ? err.message : String(err)}`);
-            setAppStatus({ state: 'ready' });
         }
-    }, [projectRoot, isInitialized, startMcpSetupWizard]);
+        finally {
+            dispatch(AppActions.setReady());
+        }
+    }, [projectRoot, isInitialized, startMcpSetupWizard, dispatch, addOutput]);
     // Handle MCP wizard completion
     const handleMcpWizardComplete = useCallback((_config) => {
-        setWizardMode({ active: false });
+        dispatch(WizardActions.close());
         // Results are already shown in the wizard summary
-    }, []);
+    }, [dispatch]);
     // Handle wizard cancellation
     const handleWizardCancel = useCallback(() => {
-        const wasInit = wizardMode.active && wizardMode.type === 'init';
-        setWizardMode({ active: false });
+        const wasInit = activeWizard === 'init';
+        dispatch(WizardActions.close());
         if (wasInit) {
             addOutput('system', 'Initialization cancelled.');
         }
         // MCP wizard cancel just closes silently
-    }, [wizardMode]);
+    }, [dispatch, activeWizard]);
     // Handle Ctrl+C with status message callback
     const { handleCtrlC } = useCtrlC({
-        onFirstPress: () => setAppStatus({ state: 'warning', message: 'Press Ctrl+C again to quit' }),
-        onStatusClear: () => setAppStatus({ state: 'ready' }),
+        onFirstPress: () => dispatch(AppActions.setWarning('Press Ctrl+C again to quit')),
+        onStatusClear: () => dispatch(AppActions.setReady()),
     });
     // Command handling (all logic consolidated in useRagCommands)
-    const { isCommand, executeCommand } = useRagCommands({
+    const { isCommand, executeCommand } = useCommands({
         addOutput,
         addSearchResults,
-        setAppStatus,
-        setIndexStats,
         projectRoot,
         stdout,
         startInitWizard,
@@ -218,8 +208,7 @@ export default function App() {
         }
     };
     // Prepend welcome banner as first static item (only after BOTH init status AND stats are loaded)
-    // This prevents race condition where banner shows stale "Run /index" while stats are loading
-    const startupLoaded = isInitialized !== undefined && indexStats !== undefined;
+    // startupLoaded is computed via Redux selector
     const staticItems = [
         ...(startupLoaded
             ? [{ id: 'welcome', type: 'welcome', content: '' }]
@@ -241,5 +230,14 @@ export default function App() {
                 item.content)) : (React.createElement(Text, null, item.content))));
         }),
         React.createElement(StatusBar, { status: appStatus, stats: indexStats }),
-        wizardMode.active && wizardMode.type === 'init' ? (React.createElement(InitWizard, { step: wizardMode.step, config: wizardMode.config, isReinit: wizardMode.isReinit, existingApiKey: existingApiKey, existingProvider: existingProvider, onStepChange: handleInitWizardStep, onComplete: handleInitWizardComplete, onCancel: handleWizardCancel })) : wizardMode.active && wizardMode.type === 'mcp-setup' ? (React.createElement(McpSetupWizard, { step: wizardMode.step, config: wizardMode.config, projectRoot: projectRoot, showPrompt: wizardMode.showPrompt, onStepChange: handleMcpWizardStep, onComplete: handleMcpWizardComplete, onCancel: handleWizardCancel, addOutput: addOutput })) : wizardMode.active && wizardMode.type === 'clean' ? (React.createElement(CleanWizard, { projectRoot: projectRoot, viberagDir: getViberagDir(projectRoot), onComplete: handleCleanWizardComplete, onCancel: handleWizardCancel, addOutput: addOutput })) : (React.createElement(TextInput, { onSubmit: handleSubmit, onCtrlC: handleCtrlC, commands: COMMANDS, navigateHistoryUp: navigateUp, navigateHistoryDown: navigateDown, resetHistoryIndex: resetIndex }))));
+        activeWizard === 'init' ? (React.createElement(InitWizard, { step: initStep, config: initConfig, isReinit: isReinit, existingApiKey: existingApiKey ?? undefined, existingProvider: existingProvider ?? undefined, onStepChange: handleInitWizardStep, onComplete: handleInitWizardComplete, onCancel: handleWizardCancel })) : activeWizard === 'mcp-setup' ? (React.createElement(McpSetupWizard, { step: mcpStep, config: mcpConfig, projectRoot: projectRoot, showPrompt: showMcpPrompt, onStepChange: handleMcpWizardStep, onComplete: handleMcpWizardComplete, onCancel: handleWizardCancel, addOutput: addOutput })) : activeWizard === 'clean' ? (React.createElement(CleanWizard, { projectRoot: projectRoot, viberagDir: getViberagDir(projectRoot), onComplete: handleCleanWizardComplete, onCancel: handleWizardCancel, addOutput: addOutput })) : (React.createElement(TextInput, { onSubmit: handleSubmit, onCtrlC: handleCtrlC, commands: COMMANDS, navigateHistoryUp: navigateUp, navigateHistoryDown: navigateDown, resetHistoryIndex: resetIndex }))));
+}
+/**
+ * Main App component with Redux Provider and DaemonStatusProvider.
+ */
+export default function App() {
+    const projectRoot = process.cwd();
+    return (React.createElement(Provider, { store: store },
+        React.createElement(DaemonStatusProvider, { projectRoot: projectRoot },
+            React.createElement(AppContent, null))));
 }

package/dist/cli/commands/handlers.d.ts

@@ -1,7 +1,7 @@
 /**
  * RAG commands for the CLI.
  */
-import { type IndexStats, type SearchResults } from '../../rag/index.js';
+import type { IndexStats, SearchResults } from '../../client/types.js';
 import type { InitWizardConfig } from '../../common/types.js';
 /**
  * Index display stats type (re-exported for convenience).
@@ -21,21 +21,23 @@ export declare function loadIndexStats(projectRoot: string): Promise<IndexDispla
 /**
  * Initialize a project for Viberag.
  * Creates .viberag/ directory with config.json.
- * With isReinit=true, deletes everything and starts fresh.
+ * With isReinit=true, shuts down daemon and deletes everything first.
  */
 export declare function runInit(projectRoot: string, isReinit?: boolean, wizardConfig?: InitWizardConfig): Promise<string>;
 /**
  * Run the indexer and return stats.
- * When force=true, also updates config dimensions to match current PROVIDER_CONFIGS
- * (handles dimension changes after viberag upgrades).
+ * Delegates to daemon which handles dimension sync internally.
+ *
+ * Note: Indexing starts asynchronously; completion is detected via status polling.
  */
-export declare function runIndex(projectRoot: string, force?: boolean, onProgress?: (current: number, total: number, stage: string, throttleMessage?: string | null, chunksProcessed?: number) => void): Promise<IndexStats>;
+export declare function runIndex(projectRoot: string, force?: boolean): Promise<IndexStats | null>;
 /**
  * Format index stats for display.
  */
 export declare function formatIndexStats(stats: IndexStats): string;
 /**
  * Run a search query and return results.
+ * Delegates to daemon for search.
  */
 export declare function runSearch(projectRoot: string, query: string, limit?: number): Promise<SearchResults>;
 /**
@@ -48,7 +50,7 @@ export declare function formatSearchResults(results: SearchResults): string;
 export declare function getStatus(projectRoot: string): Promise<string>;
 /**
  * Clean/uninstall Viberag from a project.
- * Removes the entire .viberag/ directory.
+ * Shuts down daemon first, then removes the entire .viberag/ directory.
  */
 export declare function runClean(projectRoot: string): Promise<string>;
 /**

package/dist/cli/commands/handlers.js

@@ -4,7 +4,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { Indexer, SearchEngine, loadManifest, manifestExists, configExists, saveConfig, DEFAULT_CONFIG, PROVIDER_CONFIGS, getViberagDir, } from '../../rag/index.js';
+import { loadManifest, manifestExists } from '../../daemon/lib/manifest.js';
+import { configExists, saveConfig, DEFAULT_CONFIG, PROVIDER_CONFIGS, } from '../../daemon/lib/config.js';
+import { getViberagDir } from '../../daemon/lib/constants.js';
+import { DaemonClient } from '../../client/index.js';
 /**
  * Check if project is initialized.
  */
@@ -27,13 +30,28 @@ export async function loadIndexStats(projectRoot) {
 /**
  * Initialize a project for Viberag.
  * Creates .viberag/ directory with config.json.
- * With isReinit=true, deletes everything and starts fresh.
+ * With isReinit=true, shuts down daemon and deletes everything first.
  */
 export async function runInit(projectRoot, isReinit = false, wizardConfig) {
     const viberagDir = getViberagDir(projectRoot);
     const isExisting = await configExists(projectRoot);
-    // If reinit, delete entire .viberag directory first
+    // If reinit, shutdown daemon and delete entire .viberag directory first
     if (isReinit && isExisting) {
+        const client = new DaemonClient(projectRoot);
+        try {
+            if (await client.isRunning()) {
+                await client.connect();
+                await client.shutdown('reinit');
+                // Wait for daemon to exit
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+        catch {
+            // Ignore errors - daemon may not be running
+        }
+        finally {
+            await client.disconnect();
+        }
         await fs.rm(viberagDir, { recursive: true, force: true });
     }
     // Create .viberag directory
@@ -41,12 +59,21 @@ export async function runInit(projectRoot, isReinit = false, wizardConfig) {
     // Build config from wizard choices
     const provider = wizardConfig?.provider ?? 'gemini';
     const { model, dimensions } = PROVIDER_CONFIGS[provider];
+    // Map OpenAI region to base URL
+    const openaiBaseUrl = wizardConfig?.openaiRegion
+        ? {
+            default: undefined,
+            us: 'https://us.api.openai.com/v1',
+            eu: 'https://eu.api.openai.com/v1',
+        }[wizardConfig.openaiRegion]
+        : undefined;
     const config = {
         ...DEFAULT_CONFIG,
         embeddingProvider: provider,
         embeddingModel: model,
         embeddingDimensions: dimensions,
         ...(wizardConfig?.apiKey && { apiKey: wizardConfig.apiKey }),
+        ...(openaiBaseUrl && { openaiBaseUrl }),
     };
     // Save config
     await saveConfig(projectRoot, config);
@@ -68,35 +95,48 @@ export async function runInit(projectRoot, isReinit = false, wizardConfig) {
 }
 /**
  * Run the indexer and return stats.
- * When force=true, also updates config dimensions to match current PROVIDER_CONFIGS
- * (handles dimension changes after viberag upgrades).
+ * Delegates to daemon which handles dimension sync internally.
+ *
+ * Note: Indexing starts asynchronously; completion is detected via status polling.
  */
-export async function runIndex(projectRoot, force = false, onProgress) {
-    // When forcing reindex, sync config dimensions with current provider settings
-    // This handles cases where PROVIDER_CONFIGS dimensions changed (e.g., Gemini 768→1536)
-    if (force) {
-        const { loadConfig } = await import('../../rag/config/index.js');
-        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);
+export async function runIndex(projectRoot, force = false) {
+    const client = new DaemonClient(projectRoot);
     try {
-        const stats = await indexer.index({
-            force,
-            progressCallback: onProgress,
-        });
-        return stats;
+        await client.connect();
+        const initialStatus = await client.status();
+        const previousCompletion = initialStatus.indexing.lastCompleted;
+        await client.indexAsync({ force });
+        return await waitForIndexCompletion(client, previousCompletion);
     }
     finally {
-        indexer.close();
+        await client.disconnect();
+    }
+}
+/**
+ * Poll daemon status until a new index completion is observed.
+ */
+async function waitForIndexCompletion(client, previousLastCompleted) {
+    const pollIntervalMs = 500;
+    const statsGraceMs = 5000;
+    let completionDetectedAt = null;
+    for (;;) {
+        const status = await client.status();
+        if (status.indexing.status === 'error') {
+            throw new Error(status.indexing.error ?? 'Index failed');
+        }
+        const lastCompleted = status.indexing.lastCompleted;
+        if (lastCompleted && lastCompleted !== previousLastCompleted) {
+            if (status.indexing.lastStats) {
+                return status.indexing.lastStats;
+            }
+            if (completionDetectedAt === null) {
+                completionDetectedAt = Date.now();
+            }
+            else if (Date.now() - completionDetectedAt > statsGraceMs) {
+                return null;
+            }
+        }
+        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
     }
 }
 /**
@@ -118,14 +158,16 @@ export function formatIndexStats(stats) {
 }
 /**
  * Run a search query and return results.
+ * Delegates to daemon for search.
  */
 export async function runSearch(projectRoot, query, limit = 10) {
-    const engine = new SearchEngine(projectRoot);
+    const client = new DaemonClient(projectRoot);
     try {
-        return await engine.search(query, { limit });
+        await client.connect();
+        return await client.search(query, { limit });
     }
     finally {
-        engine.close();
+        await client.disconnect();
     }
 }
 /**
@@ -198,7 +240,7 @@ export async function getStatus(projectRoot) {
 }
 /**
  * Clean/uninstall Viberag from a project.
- * Removes the entire .viberag/ directory.
+ * Shuts down daemon first, then removes the entire .viberag/ directory.
  */
 export async function runClean(projectRoot) {
     const viberagDir = getViberagDir(projectRoot);
@@ -206,6 +248,22 @@ export async function runClean(projectRoot) {
     if (!exists) {
         return 'Viberag is not initialized in this project. Nothing to clean.';
     }
+    // Shutdown daemon if running
+    const client = new DaemonClient(projectRoot);
+    try {
+        if (await client.isRunning()) {
+            await client.connect();
+            await client.shutdown('clean');
+            // Wait for daemon to exit
+            await new Promise(r => setTimeout(r, 500));
+        }
+    }
+    catch {
+        // Ignore errors - daemon may not be running
+    }
+    finally {
+        await client.disconnect();
+    }
     await fs.rm(viberagDir, { recursive: true, force: true });
     return `Removed ${viberagDir}\nViberag has been uninstalled from this project.\nRun /init to reinitialize.`;
 }

package/dist/cli/commands/useCommands.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CLI command handling hook.
+ * Consolidates all command routing and handler implementations.
+ */
+import type { SearchResultsData } from '../../common/types.js';
+type CommandContext = {
+    addOutput: (type: 'user' | 'system', content: string) => void;
+    addSearchResults: (data: SearchResultsData) => void;
+    projectRoot: string;
+    stdout: NodeJS.WriteStream;
+    startInitWizard: (isReinit: boolean) => void;
+    startMcpSetupWizard: (showPrompt?: boolean) => void;
+    startCleanWizard: () => void;
+    isInitialized: boolean;
+};
+export declare function useCommands({ addOutput, addSearchResults, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }: CommandContext): {
+    isCommand: (text: string) => boolean;
+    executeCommand: (text: string) => void;
+};
+export {};