viberag 0.3.2 → 0.4.0

package/dist/cli/commands/useCommands.js

@@ -0,0 +1,189 @@
+/**
+ * CLI command handling hook.
+ * Consolidates all command routing and handler implementations.
+ */
+import { useCallback } from 'react';
+import { useApp } from 'ink';
+import { runIndex, formatIndexStats, runSearch, getStatus, loadIndexStats, } from './handlers.js';
+import { setupVSCodeTerminal } from '../../common/commands/terminalSetup.js';
+import { useAppDispatch } from '../store/hooks.js';
+import { AppActions } from '../store/app/slice.js';
+export function useCommands({ addOutput, addSearchResults, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }) {
+    const dispatch = useAppDispatch();
+    const { exit } = useApp();
+    // Command handlers
+    const handleHelp = useCallback(() => {
+        addOutput('system', `Commands:
+  /help           - Show this help
+  /clear          - Clear the screen
+  /terminal-setup - Configure terminal for Shift+Enter
+  /init           - Initialize Viberag (interactive wizard)
+  /index          - Index the codebase
+  /reindex        - Force full reindex
+  /search <query> - Search the codebase
+  /status         - Show index status
+  /mcp-setup      - Configure MCP server for AI coding tools
+  /clean          - Remove Viberag from project (delete .viberag/)
+  /quit           - Exit
+
+Multi-line input:
+  Shift+Enter     - iTerm2, Kitty, WezTerm (automatic)
+  Shift+Enter     - VS Code (requires /terminal-setup)
+  Option+Enter    - Most terminals
+  Ctrl+J          - All terminals
+  \\ then Enter    - All terminals
+
+Tips:
+  Ctrl+C          - Clear input (twice to quit)
+  Escape          - Clear input
+  Up/Down         - Command history
+
+Manual MCP Setup:
+  https://github.com/mdrideout/viberag?tab=readme-ov-file#manual-setup-instructions`);
+    }, [addOutput]);
+    const handleClear = useCallback(() => {
+        // Clear screen (\x1B[2J), clear scrollback buffer (\x1B[3J), move cursor home (\x1B[H)
+        stdout.write('\x1B[2J\x1B[3J\x1B[H');
+    }, [stdout]);
+    const handleTerminalSetup = useCallback(() => {
+        setupVSCodeTerminal()
+            .then(result => addOutput('system', result))
+            .catch(err => addOutput('system', `Error: ${err.message}`));
+    }, [addOutput]);
+    // Trigger init wizard
+    const handleInit = useCallback(() => {
+        startInitWizard(isInitialized);
+    }, [startInitWizard, isInitialized]);
+    const handleIndex = useCallback((force) => {
+        const action = force ? 'Reindexing' : 'Indexing';
+        addOutput('system', `${action} codebase...`);
+        // Progress is synced via DaemonStatusContext polling
+        runIndex(projectRoot, force)
+            .then(async (stats) => {
+            if (stats) {
+                addOutput('system', formatIndexStats(stats));
+            }
+            else {
+                addOutput('system', 'Index complete.');
+            }
+            // Reload stats after indexing
+            const newStats = await loadIndexStats(projectRoot);
+            dispatch(AppActions.setIndexStats(newStats));
+        })
+            .catch(err => {
+            addOutput('system', `Index failed: ${err.message}`);
+        });
+    }, [projectRoot, addOutput, dispatch]);
+    const handleSearch = useCallback((query) => {
+        addOutput('system', `Searching for "${query}"...`);
+        dispatch(AppActions.setSearching());
+        runSearch(projectRoot, query)
+            .then(results => {
+            // Use the component-based display with syntax highlighting
+            addSearchResults({
+                query: results.query,
+                elapsedMs: results.elapsedMs,
+                results: results.results.map(r => ({
+                    type: r.type,
+                    name: r.name,
+                    filepath: r.filepath,
+                    filename: r.filename,
+                    startLine: r.startLine,
+                    endLine: r.endLine,
+                    score: r.score,
+                    text: r.text,
+                })),
+            });
+            dispatch(AppActions.setReady());
+        })
+            .catch(err => {
+            addOutput('system', `Search failed: ${err.message}`);
+            dispatch(AppActions.setReady());
+        });
+    }, [projectRoot, addOutput, addSearchResults, dispatch]);
+    const handleStatus = useCallback(() => {
+        getStatus(projectRoot)
+            .then(status => addOutput('system', status))
+            .catch(err => addOutput('system', `Status failed: ${err.message}`));
+    }, [projectRoot, addOutput]);
+    const handleMcpSetup = useCallback(() => {
+        startMcpSetupWizard(false); // showPrompt = false for direct /mcp-setup command
+    }, [startMcpSetupWizard]);
+    const handleClean = useCallback(() => {
+        startCleanWizard();
+    }, [startCleanWizard]);
+    const handleUnknown = useCallback((command) => {
+        addOutput('system', `Unknown command: ${command}. Type /help for available commands.`);
+    }, [addOutput]);
+    // Command detection
+    const isCommand = useCallback((text) => {
+        return text.trim().startsWith('/');
+    }, []);
+    // Command routing
+    const executeCommand = useCallback((text) => {
+        const trimmed = text.trim();
+        const command = trimmed.toLowerCase();
+        // Handle commands with arguments
+        if (command.startsWith('/search ')) {
+            const query = trimmed.slice('/search '.length).trim();
+            if (query) {
+                handleSearch(query);
+            }
+            else {
+                handleUnknown('/search (missing query)');
+            }
+            return;
+        }
+        switch (command) {
+            case '/help':
+                handleHelp();
+                break;
+            case '/clear':
+                handleClear();
+                break;
+            case '/terminal-setup':
+                handleTerminalSetup();
+                break;
+            case '/init':
+                handleInit();
+                break;
+            case '/index':
+                handleIndex(false);
+                break;
+            case '/reindex':
+                handleIndex(true);
+                break;
+            case '/status':
+                handleStatus();
+                break;
+            case '/mcp-setup':
+                handleMcpSetup();
+                break;
+            case '/clean':
+            case '/uninstall':
+                handleClean();
+                break;
+            case '/quit':
+            case '/exit':
+            case '/q':
+                exit();
+                break;
+            default:
+                handleUnknown(command);
+                break;
+        }
+    }, [
+        exit,
+        handleHelp,
+        handleClear,
+        handleTerminalSetup,
+        handleInit,
+        handleIndex,
+        handleSearch,
+        handleStatus,
+        handleMcpSetup,
+        handleClean,
+        handleUnknown,
+    ]);
+    return { isCommand, executeCommand };
+}

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

@@ -2,13 +2,10 @@
  * CLI command handling hook.
  * Consolidates all command routing and handler implementations.
  */
-import { type IndexDisplayStats } from './handlers.js';
-import type { AppStatus, SearchResultsData } from '../../common/types.js';
+import type { SearchResultsData } from '../../common/types.js';
 type RagCommandContext = {
     addOutput: (type: 'user' | 'system', content: string) => void;
     addSearchResults: (data: SearchResultsData) => void;
-    setAppStatus: (status: AppStatus) => void;
-    setIndexStats: (stats: IndexDisplayStats | null) => void;
     projectRoot: string;
     stdout: NodeJS.WriteStream;
     startInitWizard: (isReinit: boolean) => void;
@@ -16,7 +13,7 @@ type RagCommandContext = {
     startCleanWizard: () => void;
     isInitialized: boolean;
 };
-export declare function useRagCommands({ addOutput, addSearchResults, setAppStatus, setIndexStats, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }: RagCommandContext): {
+export declare function useRagCommands({ addOutput, addSearchResults, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }: RagCommandContext): {
     isCommand: (text: string) => boolean;
     executeCommand: (text: string) => void;
 };

package/dist/cli/commands/useRagCommands.js

@@ -6,7 +6,9 @@ import { useCallback } from 'react';
 import { useApp } from 'ink';
 import { runIndex, formatIndexStats, runSearch, getStatus, loadIndexStats, } from './handlers.js';
 import { setupVSCodeTerminal } from '../../common/commands/terminalSetup.js';
-export function useRagCommands({ addOutput, addSearchResults, setAppStatus, setIndexStats, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }) {
+import { useAppDispatch, AppActions } from '../../store/index.js';
+export function useRagCommands({ addOutput, addSearchResults, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }) {
+    const dispatch = useAppDispatch();
     const { exit } = useApp();
     // Command handlers
     const handleHelp = useCallback(() => {
@@ -54,30 +56,21 @@ Manual MCP Setup:
     const handleIndex = useCallback((force) => {
         const action = force ? 'Reindexing' : 'Indexing';
         addOutput('system', `${action} codebase...`);
-        setAppStatus({ state: 'indexing', current: 0, total: 0, stage: action });
-        runIndex(projectRoot, force, (current, total, stage, throttleMessage, chunksProcessed) => setAppStatus({
-            state: 'indexing',
-            current,
-            total,
-            stage,
-            throttleMessage,
-            chunksProcessed,
-        }))
+        // Progress is synced via DaemonStatusContext polling
+        runIndex(projectRoot, force)
             .then(async (stats) => {
             addOutput('system', formatIndexStats(stats));
             // Reload stats after indexing
             const newStats = await loadIndexStats(projectRoot);
-            setIndexStats(newStats);
-            setAppStatus({ state: 'ready' });
+            dispatch(AppActions.setIndexStats(newStats));
         })
             .catch(err => {
             addOutput('system', `Index failed: ${err.message}`);
-            setAppStatus({ state: 'ready' });
         });
-    }, [projectRoot, addOutput, setAppStatus, setIndexStats]);
+    }, [projectRoot, addOutput, dispatch]);
     const handleSearch = useCallback((query) => {
         addOutput('system', `Searching for "${query}"...`);
-        setAppStatus({ state: 'searching' });
+        dispatch(AppActions.setSearching());
         runSearch(projectRoot, query)
             .then(results => {
             // Use the component-based display with syntax highlighting
@@ -95,13 +88,13 @@ Manual MCP Setup:
                     text: r.text,
                 })),
             });
-            setAppStatus({ state: 'ready' });
+            dispatch(AppActions.setReady());
         })
             .catch(err => {
             addOutput('system', `Search failed: ${err.message}`);
-            setAppStatus({ state: 'ready' });
+            dispatch(AppActions.setReady());
         });
-    }, [projectRoot, addOutput, addSearchResults, setAppStatus]);
+    }, [projectRoot, addOutput, addSearchResults, dispatch]);
     const handleStatus = useCallback(() => {
         getStatus(projectRoot)
             .then(status => addOutput('system', status))

package/dist/cli/components/InitWizard.js

@@ -34,16 +34,6 @@ const PROVIDER_CONFIG = {
         note: '~700MB download, ~1.2GB RAM',
         description: 'Offline, no API key needed',
     },
-    'local-4b': {
-        name: 'Local 4B',
-        model: 'Qwen3-4B FP32',
-        modelFull: 'Qwen/Qwen3-Embedding-4B',
-        dims: '2560',
-        context: '32K',
-        cost: 'Free',
-        note: '~8GB download, ~8GB RAM',
-        description: 'Offline, better quality (+5 MTEB)',
-    },
     gemini: {
         name: 'Gemini',
         model: 'gemini-embedding-001',
@@ -66,23 +56,21 @@ const PROVIDER_CONFIG = {
     },
     openai: {
         name: 'OpenAI',
-        model: 'text-embed-3-sm',
-        modelFull: 'text-embedding-3-small',
+        model: 'text-embed-3-lg',
+        modelFull: 'text-embedding-3-large',
         dims: '1536',
         context: '8K',
-        cost: '$0.02/1M',
+        cost: '$0.13/1M',
         note: 'API key required',
-        description: 'Fast and reliable API',
+        description: 'Highest quality embeddings',
     },
 };
-// Simple provider options for selection
-// Note: local-4b exists in code but hidden from UI - no transformers.js-compatible ONNX available yet
+// Simple provider options for selection (ordered by speed/ease of use)
 const PROVIDER_ITEMS = [
-    { label: 'Local     - Qwen3-0.6B Q8 (~700MB, ~1.2GB RAM)', value: 'local' },
-    // {label: 'Local 4B  - Qwen3-4B FP32 (~8GB, ~8GB RAM)', value: 'local-4b'}, // No ONNX available
     { label: 'Gemini    - gemini-embedding-001 (Free tier)', value: 'gemini' },
+    { label: 'OpenAI    - text-embedding-3-large', value: 'openai' },
     { label: 'Mistral   - codestral-embed', value: 'mistral' },
-    { label: 'OpenAI    - text-embedding-3-small', value: 'openai' },
+    { label: 'Local     - Qwen3-0.6B Q8 (slow)', value: 'local' },
 ];
 /**
  * Local model info.
@@ -109,9 +97,9 @@ const FRONTIER_MODELS_DATA = [
     },
     {
         Provider: 'OpenAI',
-        Model: 'text-embed-3-small',
+        Model: 'text-embed-3-large',
         Dims: '1536',
-        Cost: '$0.02/1M',
+        Cost: '$0.13/1M',
     },
 ];
 function SimpleTable({ data, columns, }) {
@@ -158,7 +146,7 @@ function ComparisonTable() {
         React.createElement(Text, { dimColor: true, italic: true }, "* Initial indexing may take time. Future updates are incremental."),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Frontier Models"),
-            React.createElement(Text, { dimColor: true }, " - Fastest, Best Quality")),
+            React.createElement(Text, { dimColor: true }, " - Fastest, Best Quality, Largest Vocabulary")),
         React.createElement(SimpleTable, { data: FRONTIER_MODELS_DATA, columns: frontierColumns })));
 }
 // Reinit confirmation options
@@ -176,6 +164,21 @@ const API_KEY_ACTION_ITEMS = [
     { label: 'Keep existing API key', value: 'keep' },
     { label: 'Enter new API key', value: 'new' },
 ];
+// OpenAI region options for data residency
+const OPENAI_REGION_ITEMS = [
+    {
+        label: 'Default (api.openai.com) - Recommended',
+        value: 'default',
+    },
+    {
+        label: 'US (us.api.openai.com) - US Data Residency',
+        value: 'us',
+    },
+    {
+        label: 'EU (eu.api.openai.com) - EU Data Residency',
+        value: 'eu',
+    },
+];
 /**
  * Simple text input component for API key entry.
  * Uses a ref to accumulate input, which handles paste better than
@@ -227,6 +230,8 @@ export function InitWizard({ step, config, isReinit, existingApiKey, existingPro
     // State for API key input
     const [apiKeyInput, setApiKeyInput] = useState('');
     const [apiKeyAction, setApiKeyAction] = useState(null);
+    // State for OpenAI region selection (shown after API key for OpenAI)
+    const [showRegionSelect, setShowRegionSelect] = useState(false);
     // Handle Escape to cancel
     useInput((input, key) => {
         if (key.escape || (key.ctrl && input === 'c')) {
@@ -275,15 +280,16 @@ export function InitWizard({ step, config, isReinit, existingApiKey, existingPro
     if (effectiveStep === 1) {
         return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
             React.createElement(Text, { bold: true }, "Choose Embedding Provider"),
+            React.createElement(ComparisonTable, null),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(SelectInput, { items: PROVIDER_ITEMS, onSelect: item => {
-                        // Reset API key state when provider changes
+                        // Reset API key and region state when provider changes
                         setApiKeyInput('');
                         setApiKeyAction(null);
+                        setShowRegionSelect(false);
                         // Use relative increment: step + 1
                         onStepChange(normalizedStep + 1, { provider: item.value });
                     } })),
-            React.createElement(ComparisonTable, null),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel"))));
     }
@@ -298,6 +304,21 @@ export function InitWizard({ step, config, isReinit, existingApiKey, existingPro
         const provider = currentProvider;
         const info = PROVIDER_CONFIG[provider];
         const apiKeyUrl = API_KEY_URLS[provider];
+        const isOpenAI = provider === 'openai';
+        // Show OpenAI region selection after API key is entered
+        if (isOpenAI && showRegionSelect) {
+            return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+                React.createElement(Text, { bold: true }, "Select OpenAI API Region"),
+                React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                    React.createElement(Text, { dimColor: true }, "Corporate accounts with data residency require regional endpoints."),
+                    React.createElement(Text, { dimColor: true }, "Most users should select Default.")),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(SelectInput, { items: OPENAI_REGION_ITEMS, onSelect: item => {
+                            onStepChange(normalizedStep + 1, { openaiRegion: item.value });
+                        } })),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel"))));
+        }
         return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
             React.createElement(Text, { bold: true },
                 "Configure ",
@@ -316,8 +337,18 @@ export function InitWizard({ step, config, isReinit, existingApiKey, existingPro
                 React.createElement(Box, { marginTop: 1 },
                     React.createElement(SelectInput, { items: API_KEY_ACTION_ITEMS, onSelect: item => {
                             if (item.value === 'keep') {
-                                // Keep existing key, advance to confirmation
-                                onStepChange(normalizedStep + 1, { apiKey: existingApiKey });
+                                // Keep existing key
+                                onStepChange(normalizedStep, { apiKey: existingApiKey });
+                                if (isOpenAI) {
+                                    // Show region selection for OpenAI
+                                    setShowRegionSelect(true);
+                                }
+                                else {
+                                    // Advance to confirmation for other providers
+                                    onStepChange(normalizedStep + 1, {
+                                        apiKey: existingApiKey,
+                                    });
+                                }
                             }
                             else {
                                 // Show text input for new key
@@ -325,7 +356,15 @@ export function InitWizard({ step, config, isReinit, existingApiKey, existingPro
                             }
                         } })))) : (React.createElement(ApiKeyInputStep, { providerName: info.name, apiKeyInput: apiKeyInput, setApiKeyInput: setApiKeyInput, onSubmit: key => {
                     if (key.trim()) {
-                        onStepChange(normalizedStep + 1, { apiKey: key.trim() });
+                        onStepChange(normalizedStep, { apiKey: key.trim() });
+                        if (isOpenAI) {
+                            // Show region selection for OpenAI
+                            setShowRegionSelect(true);
+                        }
+                        else {
+                            // Advance to confirmation for other providers
+                            onStepChange(normalizedStep + 1, { apiKey: key.trim() });
+                        }
                     }
                 } })),
             React.createElement(Box, { marginTop: 1 },

package/dist/cli/components/McpSetupWizard.js

@@ -77,7 +77,21 @@ export function McpSetupWizard({ step, config, projectRoot, showPrompt, onStepCh
         }
         else {
             // Auto setup
-            result = await writeMcpConfig(currentEditor, config.selectedScope, projectRoot);
+            try {
+                result = await writeMcpConfig(currentEditor, config.selectedScope, projectRoot);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                result = {
+                    success: false,
+                    editor: currentEditor.id,
+                    method: 'file-created',
+                    error: `Failed to write MCP config: ${message}`,
+                };
+                if (addOutput) {
+                    addOutput('system', `Error: ${message}`);
+                }
+            }
         }
         onStepChange('summary', { result });
         setIsProcessing(false);
@@ -89,9 +103,14 @@ export function McpSetupWizard({ step, config, projectRoot, showPrompt, onStepCh
             const relativePath = config.result.configPath.startsWith(projectRoot)
                 ? config.result.configPath.slice(projectRoot.length + 1)
                 : config.result.configPath;
-            const success = await addToGitignore(projectRoot, relativePath);
-            if (success) {
-                setGitignoreAdded(relativePath);
+            try {
+                const success = await addToGitignore(projectRoot, relativePath);
+                if (success) {
+                    setGitignoreAdded(relativePath);
+                }
+            }
+            catch {
+                // Silently fail - gitignore is optional and non-critical
             }
         }
         setGitignoreHandled(true);

package/dist/cli/components/SlotRow.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Individual slot row component for displaying batch processing progress.
+ *
+ * Each SlotRow reads its slot from DaemonStatusContext and renders independently.
+ * This follows the Single Responsibility Principle - each row manages its own
+ * rendering logic based on its slot index.
+ */
+import React from 'react';
+type Props = {
+    /** The slot index (0 to CONCURRENCY-1) */
+    slotIndex: number;
+    /** Whether this is the last visible slot (for tree-drawing) */
+    isLast: boolean;
+};
+/**
+ * Renders a single slot's progress status.
+ *
+ * Always renders a fixed-height row to prevent UI jumping when slots
+ * become active/idle. Idle slots show an empty placeholder.
+ */
+export declare function SlotRow({ slotIndex, isLast }: Props): React.ReactElement;
+export {};

package/dist/cli/components/SlotRow.js

@@ -0,0 +1,55 @@
+/**
+ * Individual slot row component for displaying batch processing progress.
+ *
+ * Each SlotRow reads its slot from DaemonStatusContext and renders independently.
+ * This follows the Single Responsibility Principle - each row manages its own
+ * rendering logic based on its slot index.
+ */
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { useDaemonStatus } from '../contexts/DaemonStatusContext.js';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Braille dots spinner frames */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/** Default idle slot state */
+const IDLE_SLOT = { state: 'idle', batchInfo: null, retryInfo: null };
+/**
+ * Renders a single slot's progress status.
+ *
+ * Always renders a fixed-height row to prevent UI jumping when slots
+ * become active/idle. Idle slots show an empty placeholder.
+ */
+export function SlotRow({ slotIndex, isLast }) {
+    const daemonStatus = useDaemonStatus();
+    const slot = daemonStatus?.slots[slotIndex] ?? IDLE_SLOT;
+    const [frame, setFrame] = useState(0);
+    // Spinner animation - only runs when processing
+    useEffect(() => {
+        if (slot.state !== 'processing')
+            return;
+        const timer = setInterval(() => {
+            setFrame(f => (f + 1) % SPINNER_FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, [slot.state]);
+    // Tree-drawing prefix
+    const prefix = isLast ? '└ ' : '├ ';
+    // Idle slots render empty placeholder to maintain fixed height
+    if (slot.state === 'idle') {
+        return (React.createElement(Box, null,
+            React.createElement(Text, { dimColor: true }, prefix),
+            React.createElement(Text, { dimColor: true }, "\u00B7")));
+    }
+    return (React.createElement(Box, null,
+        React.createElement(Text, { dimColor: true }, prefix),
+        slot.state === 'rate-limited' ? (React.createElement(Text, { color: "yellow" },
+            "\u26A0 ",
+            slot.batchInfo,
+            slot.retryInfo && ` · ${slot.retryInfo}`)) : (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: "cyan" },
+                SPINNER_FRAMES[frame],
+                " "),
+            React.createElement(Text, { dimColor: true }, slot.batchInfo)))));
+}

package/dist/cli/components/StatusBar.d.ts

@@ -0,0 +1,14 @@
+/**
+ * StatusBar Component
+ *
+ * Displays current status and indexing progress.
+ * Uses DaemonStatusContext for daemon state instead of Redux.
+ */
+import React from 'react';
+import type { AppStatus, IndexDisplayStats } from '../../common/types.js';
+type Props = {
+    status: AppStatus;
+    stats: IndexDisplayStats | null | undefined;
+};
+export default function StatusBar({ status, stats }: Props): React.JSX.Element;
+export {};