snow-ai 0.3.31 → 0.3.32

package/dist/ui/pages/ChatScreen.js

@@ -32,6 +32,9 @@ import { convertSessionMessagesToUI } from '../../utils/sessionConverter.js';
 import { incrementalSnapshotManager } from '../../utils/incrementalSnapshot.js';
 import { formatElapsedTime } from '../../utils/textUtils.js';
 import { shouldAutoCompress, performAutoCompression, } from '../../utils/autoCompress.js';
+import { CodebaseIndexAgent } from '../../agents/codebaseIndexAgent.js';
+import { loadCodebaseConfig } from '../../utils/codebaseConfig.js';
+import { logger } from '../../utils/logger.js';
 // Import commands to register them
 import '../../utils/commands/clear.js';
 import '../../utils/commands/resume.js';
@@ -85,6 +88,12 @@ export default function ChatScreen({ skipWelcome }) {
     const { stdout } = useStdout();
     const workingDirectory = process.cwd();
     const isInitialMount = useRef(true);
+    // Codebase indexing state
+    const [codebaseIndexing, setCodebaseIndexing] = useState(false);
+    const [codebaseProgress, setCodebaseProgress] = useState(null);
+    const [watcherEnabled, setWatcherEnabled] = useState(false);
+    const [fileUpdateNotification, setFileUpdateNotification] = useState(null);
+    const codebaseAgentRef = useRef(null);
     // Use custom hooks
     const streamingState = useStreamingState();
     const vscodeState = useVSCodeState();
@@ -95,6 +104,154 @@ export default function ChatScreen({ skipWelcome }) {
     useEffect(() => {
         pendingMessagesRef.current = pendingMessages;
     }, [pendingMessages]);
+    // Auto-start codebase indexing on mount if enabled
+    useEffect(() => {
+        const startCodebaseIndexing = async () => {
+            try {
+                const config = loadCodebaseConfig();
+                // Only start if enabled and not already indexing
+                if (!config.enabled || codebaseIndexing) {
+                    return;
+                }
+                // Initialize agent
+                const agent = new CodebaseIndexAgent(workingDirectory);
+                codebaseAgentRef.current = agent;
+                // Check if indexing is needed
+                const progress = agent.getProgress();
+                // If indexing is already completed, start watcher and return early
+                if (progress.status === 'completed' && progress.totalChunks > 0) {
+                    agent.startWatching(progressData => {
+                        setCodebaseProgress({
+                            totalFiles: progressData.totalFiles,
+                            processedFiles: progressData.processedFiles,
+                            totalChunks: progressData.totalChunks,
+                            currentFile: progressData.currentFile,
+                            status: progressData.status,
+                        });
+                        // Handle file update notifications
+                        if (progressData.totalFiles === 0 && progressData.currentFile) {
+                            setFileUpdateNotification({
+                                file: progressData.currentFile,
+                                timestamp: Date.now(),
+                            });
+                            // Clear notification after 3 seconds
+                            setTimeout(() => {
+                                setFileUpdateNotification(null);
+                            }, 3000);
+                        }
+                    });
+                    setWatcherEnabled(true);
+                    return;
+                }
+                // If watcher was enabled before but indexing not completed, restore it
+                const wasWatcherEnabled = agent.isWatcherEnabled();
+                if (wasWatcherEnabled) {
+                    logger.info('Restoring file watcher from previous session');
+                    agent.startWatching(progressData => {
+                        setCodebaseProgress({
+                            totalFiles: progressData.totalFiles,
+                            processedFiles: progressData.processedFiles,
+                            totalChunks: progressData.totalChunks,
+                            currentFile: progressData.currentFile,
+                            status: progressData.status,
+                        });
+                        // Handle file update notifications
+                        if (progressData.totalFiles === 0 && progressData.currentFile) {
+                            setFileUpdateNotification({
+                                file: progressData.currentFile,
+                                timestamp: Date.now(),
+                            });
+                            // Clear notification after 3 seconds
+                            setTimeout(() => {
+                                setFileUpdateNotification(null);
+                            }, 3000);
+                        }
+                    });
+                    setWatcherEnabled(true);
+                }
+                // Start or resume indexing in background
+                setCodebaseIndexing(true);
+                agent.start(progressData => {
+                    setCodebaseProgress({
+                        totalFiles: progressData.totalFiles,
+                        processedFiles: progressData.processedFiles,
+                        totalChunks: progressData.totalChunks,
+                        currentFile: progressData.currentFile,
+                        status: progressData.status,
+                    });
+                    // Handle file update notifications (when totalFiles is 0, it's a file update)
+                    if (progressData.totalFiles === 0 && progressData.currentFile) {
+                        setFileUpdateNotification({
+                            file: progressData.currentFile,
+                            timestamp: Date.now(),
+                        });
+                        // Clear notification after 3 seconds
+                        setTimeout(() => {
+                            setFileUpdateNotification(null);
+                        }, 3000);
+                    }
+                    // Stop indexing when completed or error
+                    if (progressData.status === 'completed' ||
+                        progressData.status === 'error') {
+                        setCodebaseIndexing(false);
+                        // Start file watcher after initial indexing is completed
+                        if (progressData.status === 'completed' && agent) {
+                            agent.startWatching(watcherProgressData => {
+                                setCodebaseProgress({
+                                    totalFiles: watcherProgressData.totalFiles,
+                                    processedFiles: watcherProgressData.processedFiles,
+                                    totalChunks: watcherProgressData.totalChunks,
+                                    currentFile: watcherProgressData.currentFile,
+                                    status: watcherProgressData.status,
+                                });
+                                // Handle file update notifications
+                                if (watcherProgressData.totalFiles === 0 &&
+                                    watcherProgressData.currentFile) {
+                                    setFileUpdateNotification({
+                                        file: watcherProgressData.currentFile,
+                                        timestamp: Date.now(),
+                                    });
+                                    // Clear notification after 3 seconds
+                                    setTimeout(() => {
+                                        setFileUpdateNotification(null);
+                                    }, 3000);
+                                }
+                            });
+                            setWatcherEnabled(true);
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                console.error('Failed to start codebase indexing:', error);
+                setCodebaseIndexing(false);
+            }
+        };
+        startCodebaseIndexing();
+        // Cleanup on unmount - just stop indexing, don't close database
+        // This allows resuming when returning to chat screen
+        return () => {
+            if (codebaseAgentRef.current) {
+                codebaseAgentRef.current.stop();
+                codebaseAgentRef.current.stopWatching();
+                setWatcherEnabled(false);
+                // Don't call close() - let it resume when returning
+            }
+        };
+    }, []); // Only run once on mount
+    // Export stop function for use in commands (like /home)
+    useEffect(() => {
+        // Store global reference to stop function for /home command
+        global.__stopCodebaseIndexing = async () => {
+            if (codebaseAgentRef.current) {
+                await codebaseAgentRef.current.stop();
+                setCodebaseIndexing(false);
+            }
+        };
+        return () => {
+            delete global.__stopCodebaseIndexing;
+        };
+    }, []);
     // Persist yolo mode to localStorage
     useEffect(() => {
         try {
@@ -1161,7 +1318,24 @@ export default function ChatScreen({ skipWelcome }) {
                         ` | ${vscodeState.editorContext.activeFile}`,
                     vscodeState.vscodeConnectionStatus === 'connected' &&
                         vscodeState.editorContext.selectedText &&
-                        ` | ${vscodeState.editorContext.selectedText.length} chars selected`))))),
+                        ` | ${vscodeState.editorContext.selectedText.length} chars selected`))),
+            codebaseIndexing && codebaseProgress && (React.createElement(Box, { marginTop: 1, paddingX: 1 },
+                React.createElement(Text, { color: "cyan", dimColor: true },
+                    React.createElement(Spinner, { type: "dots" }),
+                    " Indexing codebase...",
+                    ' ',
+                    codebaseProgress.processedFiles,
+                    "/",
+                    codebaseProgress.totalFiles,
+                    " files",
+                    codebaseProgress.totalChunks > 0 &&
+                        ` (${codebaseProgress.totalChunks} chunks)`))),
+            !codebaseIndexing && watcherEnabled && (React.createElement(Box, { marginTop: 1, paddingX: 1 },
+                React.createElement(Text, { color: "green", dimColor: true }, "\u2609 File watcher active - monitoring code changes"))),
+            fileUpdateNotification && (React.createElement(Box, { marginTop: 1, paddingX: 1 },
+                React.createElement(Text, { color: "yellow", dimColor: true },
+                    "\u26C1 Updated: ",
+                    fileUpdateNotification.file))))),
         isCompressing && (React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { color: "cyan" },
                 React.createElement(Spinner, { type: "dots" }),

package/dist/ui/pages/CodeBaseConfigScreen.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type Props = {
+    onBack: () => void;
+    onSave?: () => void;
+    inlineMode?: boolean;
+};
+export default function CodeBaseConfigScreen({ onBack, onSave, inlineMode, }: Props): React.JSX.Element;
+export {};

package/dist/ui/pages/CodeBaseConfigScreen.js

@@ -0,0 +1,323 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Gradient from 'ink-gradient';
+import { Alert } from '@inkjs/ui';
+import TextInput from 'ink-text-input';
+import { loadCodebaseConfig, saveCodebaseConfig, } from '../../utils/codebaseConfig.js';
+const focusEventTokenRegex = /(?:\x1b)?\[[0-9;]*[IO]/g;
+const isFocusEventInput = (value) => {
+    if (!value) {
+        return false;
+    }
+    if (value === '\x1b[I' ||
+        value === '\x1b[O' ||
+        value === '[I' ||
+        value === '[O') {
+        return true;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const tokens = trimmed.match(focusEventTokenRegex);
+    if (!tokens) {
+        return false;
+    }
+    const normalized = trimmed.replace(/\s+/g, '');
+    const tokensCombined = tokens.join('');
+    return tokensCombined === normalized;
+};
+const stripFocusArtifacts = (value) => {
+    if (!value) {
+        return '';
+    }
+    return value
+        .replace(/\x1b\[[0-9;]*[IO]/g, '')
+        .replace(/\[[0-9;]*[IO]/g, '')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+};
+export default function CodeBaseConfigScreen({ onBack, onSave, inlineMode = false, }) {
+    // Configuration state
+    const [enabled, setEnabled] = useState(false);
+    const [embeddingModelName, setEmbeddingModelName] = useState('');
+    const [embeddingBaseUrl, setEmbeddingBaseUrl] = useState('');
+    const [embeddingApiKey, setEmbeddingApiKey] = useState('');
+    const [embeddingDimensions, setEmbeddingDimensions] = useState(1536);
+    const [batchMaxLines, setBatchMaxLines] = useState(10);
+    const [batchConcurrency, setBatchConcurrency] = useState(1);
+    // UI state
+    const [currentField, setCurrentField] = useState('enabled');
+    const [isEditing, setIsEditing] = useState(false);
+    const [errors, setErrors] = useState([]);
+    // Scrolling configuration
+    const MAX_VISIBLE_FIELDS = 8;
+    const allFields = [
+        'enabled',
+        'embeddingModelName',
+        'embeddingBaseUrl',
+        'embeddingApiKey',
+        'embeddingDimensions',
+        'batchMaxLines',
+        'batchConcurrency',
+    ];
+    const currentFieldIndex = allFields.indexOf(currentField);
+    const totalFields = allFields.length;
+    useEffect(() => {
+        loadConfiguration();
+    }, []);
+    const loadConfiguration = () => {
+        const config = loadCodebaseConfig();
+        setEnabled(config.enabled);
+        setEmbeddingModelName(config.embedding.modelName);
+        setEmbeddingBaseUrl(config.embedding.baseUrl);
+        setEmbeddingApiKey(config.embedding.apiKey);
+        setEmbeddingDimensions(config.embedding.dimensions);
+        setBatchMaxLines(config.batch.maxLines);
+        setBatchConcurrency(config.batch.concurrency);
+    };
+    const saveConfiguration = () => {
+        // Validation
+        const validationErrors = [];
+        if (enabled) {
+            // Embedding configuration is required
+            if (!embeddingModelName.trim()) {
+                validationErrors.push('Embedding model name is required when enabled');
+            }
+            if (!embeddingBaseUrl.trim()) {
+                validationErrors.push('Embedding base URL is required when enabled');
+            }
+            if (!embeddingApiKey.trim()) {
+                validationErrors.push('Embedding API key is required when enabled');
+            }
+            if (embeddingDimensions <= 0) {
+                validationErrors.push('Embedding dimensions must be greater than 0');
+            }
+            // Batch configuration validation
+            if (batchMaxLines <= 0) {
+                validationErrors.push('Batch max lines must be greater than 0');
+            }
+            if (batchConcurrency <= 0) {
+                validationErrors.push('Batch concurrency must be greater than 0');
+            }
+            // LLM is optional - no validation needed
+        }
+        if (validationErrors.length > 0) {
+            setErrors(validationErrors);
+            return;
+        }
+        try {
+            const config = {
+                enabled,
+                embedding: {
+                    modelName: embeddingModelName,
+                    baseUrl: embeddingBaseUrl,
+                    apiKey: embeddingApiKey,
+                    dimensions: embeddingDimensions,
+                },
+                llm: {
+                    modelName: '',
+                    baseUrl: '',
+                    apiKey: '',
+                },
+                batch: {
+                    maxLines: batchMaxLines,
+                    concurrency: batchConcurrency,
+                },
+            };
+            saveCodebaseConfig(config);
+            setErrors([]);
+            // Trigger codebase config reload in ChatScreen
+            if (global.__reloadCodebaseConfig) {
+                global.__reloadCodebaseConfig();
+            }
+            onSave?.();
+        }
+        catch (error) {
+            setErrors([
+                error instanceof Error ? error.message : 'Failed to save configuration',
+            ]);
+        }
+    };
+    const renderField = (field) => {
+        const isActive = field === currentField;
+        const isCurrentlyEditing = isActive && isEditing;
+        switch (field) {
+            case 'enabled':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "CodeBase Enabled:"),
+                    React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" },
+                            enabled ? '[✓] Enabled' : '[ ] Disabled',
+                            " (Press Enter to toggle)"))));
+            case 'embeddingModelName':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Embedding Model Name:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            React.createElement(TextInput, { value: embeddingModelName, onChange: value => setEmbeddingModelName(stripFocusArtifacts(value)), onSubmit: () => setIsEditing(false) })))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, embeddingModelName || 'Not set')))));
+            case 'embeddingBaseUrl':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Embedding Base URL:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            React.createElement(TextInput, { value: embeddingBaseUrl, onChange: value => setEmbeddingBaseUrl(stripFocusArtifacts(value)), onSubmit: () => setIsEditing(false) })))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, embeddingBaseUrl || 'Not set')))));
+            case 'embeddingApiKey':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Embedding API Key:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            React.createElement(TextInput, { value: embeddingApiKey, onChange: value => setEmbeddingApiKey(stripFocusArtifacts(value)), onSubmit: () => setIsEditing(false), mask: "*" })))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, embeddingApiKey ? '••••••••' : 'Not set')))));
+            case 'embeddingDimensions':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Embedding Dimensions:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            React.createElement(TextInput, { value: embeddingDimensions.toString(), onChange: value => {
+                                    const num = parseInt(stripFocusArtifacts(value) || '0');
+                                    if (!isNaN(num)) {
+                                        setEmbeddingDimensions(num);
+                                    }
+                                }, onSubmit: () => setIsEditing(false) })))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, embeddingDimensions)))));
+            case 'batchMaxLines':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Batch Max Lines:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            React.createElement(TextInput, { value: batchMaxLines.toString(), onChange: value => {
+                                    const num = parseInt(stripFocusArtifacts(value) || '0');
+                                    if (!isNaN(num)) {
+                                        setBatchMaxLines(num);
+                                    }
+                                }, onSubmit: () => setIsEditing(false) })))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, batchMaxLines)))));
+            case 'batchConcurrency':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Batch Concurrency:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            React.createElement(TextInput, { value: batchConcurrency.toString(), onChange: value => {
+                                    const num = parseInt(stripFocusArtifacts(value) || '0');
+                                    if (!isNaN(num)) {
+                                        setBatchConcurrency(num);
+                                    }
+                                }, onSubmit: () => setIsEditing(false) })))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, batchConcurrency)))));
+            default:
+                return null;
+        }
+    };
+    useInput((rawInput, key) => {
+        const input = stripFocusArtifacts(rawInput);
+        if (!input && isFocusEventInput(rawInput)) {
+            return;
+        }
+        if (isFocusEventInput(rawInput)) {
+            return;
+        }
+        // When editing, only handle submission
+        if (isEditing) {
+            // TextInput handles the actual editing
+            // Escape to cancel editing
+            if (key.escape) {
+                setIsEditing(false);
+                loadConfiguration(); // Reset to saved values
+            }
+            return;
+        }
+        // Navigation
+        if (key.upArrow) {
+            const currentIndex = allFields.indexOf(currentField);
+            if (currentIndex > 0) {
+                setCurrentField(allFields[currentIndex - 1]);
+            }
+            return;
+        }
+        if (key.downArrow) {
+            const currentIndex = allFields.indexOf(currentField);
+            if (currentIndex < allFields.length - 1) {
+                setCurrentField(allFields[currentIndex + 1]);
+            }
+            return;
+        }
+        // Toggle enabled field
+        if (key.return && currentField === 'enabled') {
+            setEnabled(!enabled);
+            return;
+        }
+        // Enter editing mode for text fields
+        if (key.return && currentField !== 'enabled') {
+            setIsEditing(true);
+            return;
+        }
+        // Save configuration (Ctrl+S or Escape when not editing)
+        if ((key.ctrl && input === 's') || key.escape) {
+            saveConfiguration();
+            if (!errors.length) {
+                onBack();
+            }
+            return;
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        !inlineMode && (React.createElement(Box, { marginBottom: 1, borderStyle: "double", borderColor: 'cyan', paddingX: 2 },
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Gradient, { name: "rainbow" }, "CodeBase Configuration"),
+                React.createElement(Text, { color: "gray", dimColor: true }, "Configure codebase indexing and search settings")))),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "yellow", bold: true },
+                "Settings (",
+                currentFieldIndex + 1,
+                "/",
+                totalFields,
+                ")"),
+            totalFields > MAX_VISIBLE_FIELDS && (React.createElement(Text, { color: "gray", dimColor: true },
+                ' ',
+                "\u00B7 \u2191\u2193 to scroll"))),
+        React.createElement(Box, { flexDirection: "column" }, (() => {
+            // Calculate visible window
+            if (allFields.length <= MAX_VISIBLE_FIELDS) {
+                // Show all fields if less than max
+                return allFields.map(field => renderField(field));
+            }
+            // Calculate scroll window
+            const halfWindow = Math.floor(MAX_VISIBLE_FIELDS / 2);
+            let startIndex = Math.max(0, currentFieldIndex - halfWindow);
+            let endIndex = Math.min(allFields.length, startIndex + MAX_VISIBLE_FIELDS);
+            // Adjust if we're near the end
+            if (endIndex - startIndex < MAX_VISIBLE_FIELDS) {
+                startIndex = Math.max(0, endIndex - MAX_VISIBLE_FIELDS);
+            }
+            const visibleFields = allFields.slice(startIndex, endIndex);
+            return visibleFields.map(field => renderField(field));
+        })()),
+        errors.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: "red", bold: true }, "Errors:"),
+            errors.map((error, index) => (React.createElement(Text, { key: index, color: "red" },
+                "\u2022 ",
+                error))))),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, isEditing ? (React.createElement(Alert, { variant: "info" }, "Editing mode: Type to edit, Enter to save, Esc to cancel")) : (React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate, Enter to edit/toggle, Ctrl+S or Esc to save")))));
+}

package/dist/ui/pages/SubAgentConfigScreen.js

@@ -62,6 +62,10 @@ const toolCategories = [
             'ace-clear_cache',
         ],
     },
+    {
+        name: 'Codebase Search Tools',
+        tools: ['codebase-search'],
+    },
     {
         name: 'Terminal Tools',
         tools: ['terminal-execute'],

package/dist/ui/pages/WelcomeScreen.js

@@ -10,6 +10,7 @@ import ProxyConfigScreen from './ProxyConfigScreen.js';
 import SubAgentConfigScreen from './SubAgentConfigScreen.js';
 import SubAgentListScreen from './SubAgentListScreen.js';
 import SensitiveCommandConfigScreen from './SensitiveCommandConfigScreen.js';
+import CodeBaseConfigScreen from './CodeBaseConfigScreen.js';
 export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
     const [infoText, setInfoText] = useState('Start a new chat conversation');
     const [inlineView, setInlineView] = useState('menu');
@@ -35,6 +36,11 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
             value: 'proxy',
             infoText: 'Configure system proxy and browser for web search and fetch',
         },
+        {
+            label: 'CodeBase Settings',
+            value: 'codebase',
+            infoText: 'Configure codebase indexing with embedding and LLM models',
+        },
         {
             label: 'System Prompt Settings',
             value: 'systemprompt',
@@ -71,13 +77,16 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
         setInfoText(newInfoText);
     }, []);
     const handleInlineMenuSelect = useCallback((value) => {
-        // Handle inline views (config, proxy, subagent) or pass through to parent
+        // Handle inline views (config, proxy, codebase, subagent) or pass through to parent
         if (value === 'config') {
             setInlineView('config');
         }
         else if (value === 'proxy') {
             setInlineView('proxy-config');
         }
+        else if (value === 'codebase') {
+            setInlineView('codebase-config');
+        }
         else if (value === 'subagent') {
             setInlineView('subagent-list');
         }
@@ -141,6 +150,8 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
             React.createElement(ConfigScreen, { onBack: handleBackToMenu, onSave: handleConfigSave, inlineMode: true }))),
         inlineView === 'proxy-config' && (React.createElement(Box, { paddingX: 1 },
             React.createElement(ProxyConfigScreen, { onBack: handleBackToMenu, onSave: handleConfigSave, inlineMode: true }))),
+        inlineView === 'codebase-config' && (React.createElement(Box, { paddingX: 1 },
+            React.createElement(CodeBaseConfigScreen, { onBack: handleBackToMenu, onSave: handleConfigSave, inlineMode: true }))),
         inlineView === 'subagent-list' && (React.createElement(Box, { paddingX: 1 },
             React.createElement(SubAgentListScreen, { onBack: handleBackToMenu, onAdd: handleSubAgentAdd, onEdit: handleSubAgentEdit, inlineMode: true }))),
         inlineView === 'subagent-add' && (React.createElement(Box, { paddingX: 1 },

package/dist/utils/codebaseConfig.d.ts

@@ -0,0 +1,20 @@
+export interface CodebaseConfig {
+    enabled: boolean;
+    embedding: {
+        modelName: string;
+        baseUrl: string;
+        apiKey: string;
+        dimensions: number;
+    };
+    llm: {
+        modelName: string;
+        baseUrl: string;
+        apiKey: string;
+    };
+    batch: {
+        maxLines: number;
+        concurrency: number;
+    };
+}
+export declare const loadCodebaseConfig: () => CodebaseConfig;
+export declare const saveCodebaseConfig: (config: CodebaseConfig) => void;