@pheem49/mint 1.5.0 → 1.5.2

package/src/CLI/interactive_chat.js

@@ -0,0 +1,479 @@
+'use strict';
+
+const { colors, exitWithGoodbye } = require('./cli_colors');
+const { splitResponseSentences }  = require('./cli_formatters');
+const {
+    isRepoSummaryRequest,
+    parseRepoSummaryArgs,
+    isSymbolIndexRequest,
+    parseSymbolIndexArgs,
+    isSemanticCodeSearchRequest,
+    parseSemanticCodeArgs,
+    extractSemanticCodeQuery
+} = require('./intent_detectors');
+const { handleSlashCommandUI }    = require('./slash_command_handler');
+const { createChatUI }            = require('./chat_ui');
+const { loadImageAsDataUri, loadClipboardImageAsDataUri } = require('./image_input');
+const { summarizeRepository, formatRepoSummary }  = require('./repo_summarizer');
+const { buildSymbolIndex, formatSymbolIndex }      = require('./symbol_indexer');
+const {
+    indexSemanticCode,
+    searchSemanticCode,
+    formatSemanticCodeIndex,
+    formatSemanticCodeSearch
+} = require('./semantic_code_search');
+const { handleChat, getChatTranscript } = require('../AI_Brain/Gemini_API');
+const agentOrchestrator = require('../AI_Brain/agent_orchestrator');
+const systemMonitor     = require('../Plugins/system_monitor');
+const workspaceManager  = require('./workspace_manager');
+const { executeCodeTask } = require('./code_agent');
+const { resetChat }       = require('../AI_Brain/Gemini_API');
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Streams response text sentence-by-sentence into the TUI.
+ */
+async function streamAssistantSentences(text, appendMessage, metadata = {}, streamMessage = null) {
+    const sentences = splitResponseSentences(text);
+    const chunks    = sentences.filter(s => String(s || '').trim());
+
+    if (typeof streamMessage === 'function') {
+        const stream = streamMessage(metadata);
+        for (let i = 0; i < chunks.length; i++) {
+            stream.appendChunk(chunks[i]);
+            if (i < chunks.length - 1) await sleep(90);
+        }
+        stream.finalize();
+        return;
+    }
+
+    for (let i = 0; i < chunks.length; i++) {
+        appendMessage('assistant', chunks[i], i === 0 ? metadata : {});
+        if (i < chunks.length - 1) await sleep(90);
+    }
+}
+
+/**
+ * Runs a timer that increments seconds and calls setThinking every 1s.
+ * Returns a cancel function.
+ */
+function startThinkingTimer(setThinking) {
+    let seconds = 0;
+    setThinking(true, seconds);
+    const timer = setInterval(() => {
+        seconds++;
+        setThinking(true, seconds);
+    }, 1000);
+    return () => clearInterval(timer);
+}
+
+// ---------------------------------------------------------------------------
+// Local tool message senders
+// ---------------------------------------------------------------------------
+
+async function sendRepoSummaryMessage({ rawArgs = '', appendMessage, streamMessage, setThinking }) {
+    const formatErr = (err) => err && err.message ? err.message : String(err || 'Unknown error');
+    try {
+        if (typeof setThinking === 'function') setThinking(false);
+        const opts        = parseRepoSummaryArgs(rawArgs);
+        const summary     = summarizeRepository(opts.targetPath);
+        const responseText = opts.json ? JSON.stringify(summary, null, 2) : formatRepoSummary(summary);
+        await streamAssistantSentences(responseText, appendMessage, {}, streamMessage);
+        return responseText;
+    } catch (err) {
+        if (typeof setThinking === 'function') setThinking(false);
+        appendMessage('error', formatErr(err));
+        return '';
+    }
+}
+
+async function sendSymbolIndexMessage({ rawArgs = '', appendMessage, streamMessage, setThinking }) {
+    const formatErr = (err) => err && err.message ? err.message : String(err || 'Unknown error');
+    try {
+        if (typeof setThinking === 'function') setThinking(false);
+        const opts        = parseSymbolIndexArgs(rawArgs);
+        const index       = buildSymbolIndex(opts.targetPath);
+        const responseText = opts.json
+            ? JSON.stringify(index, null, 2)
+            : formatSymbolIndex(index, { limit: opts.limit });
+        await streamAssistantSentences(responseText, appendMessage, {}, streamMessage);
+        return responseText;
+    } catch (err) {
+        if (typeof setThinking === 'function') setThinking(false);
+        appendMessage('error', formatErr(err));
+        return '';
+    }
+}
+
+async function sendSemanticCodeMessage({ rawArgs = '', appendMessage, streamMessage, setThinking, appendCodeStep }) {
+    const formatErr = (err) => err && err.message ? err.message : String(err || 'Unknown error');
+    const opts = parseSemanticCodeArgs(rawArgs);
+    try {
+        if (typeof setThinking === 'function') setThinking(true, 0);
+        let responseText;
+
+        if (opts.mode === 'index') {
+            const index = await indexSemanticCode(opts.targetPath, {
+                onProgress: (info) => {
+                    if (typeof appendCodeStep === 'function' &&
+                        (info.current === 1 || info.current === info.total || info.current % 25 === 0)) {
+                        appendCodeStep({ action: 'semantic_code_index', target: `${info.current}/${info.total} ${info.file}` });
+                    }
+                }
+            });
+            responseText = opts.json ? JSON.stringify(index, null, 2) : formatSemanticCodeIndex(index);
+        } else {
+            if (!opts.query) throw new Error('Usage: /semantic-code search <query>');
+            const results = await searchSemanticCode(opts.query, opts.targetPath, { topK: opts.topK });
+            responseText  = opts.json ? JSON.stringify(results, null, 2) : formatSemanticCodeSearch(results);
+        }
+
+        if (typeof setThinking === 'function') setThinking(false);
+        await streamAssistantSentences(responseText, appendMessage, {}, streamMessage);
+        return responseText;
+    } catch (err) {
+        if (typeof setThinking === 'function') setThinking(false);
+        appendMessage('error', formatErr(err));
+        return '';
+    }
+}
+
+async function sendImageMessage({ images, image, prompt, appendMessage, streamMessage, setThinking, appendCodeStep }) {
+    const formatErr = (err) => err && err.message ? err.message : String(err || 'Unknown error');
+    const imageList = images || (image ? [image] : []);
+    const message   = prompt || 'Analyze this image.';
+    const labels    = imageList.map((_, i) => `[Image #${i + 1}]`).join(' ');
+    const displayMessage = labels && message.includes(labels) ? message : `${message}\n${labels}`;
+
+    appendMessage('user', displayMessage);
+    if (appendCodeStep) {
+        appendCodeStep({
+            thought: imageList.length > 1
+                ? `Analyzing ${imageList.length} attached images before answering.`
+                : 'Analyzing the attached image before answering.'
+        });
+    }
+
+    const cancelTimer = startThinkingTimer(setThinking);
+    try {
+        const result      = await handleChat(message, imageList.map(item => item.dataUri), null);
+        cancelTimer();
+        setThinking(false);
+
+        const responseText = result.response || '';
+        await streamAssistantSentences(responseText, appendMessage, { providerInfo: result.providerInfo }, streamMessage);
+        return { responseText, labels, imageList };
+    } catch (err) {
+        cancelTimer();
+        setThinking(false);
+        appendMessage('error', formatErr(err));
+        return { responseText: '', labels, imageList };
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Agent task execution (shared by onSubmit + initial message)
+// ---------------------------------------------------------------------------
+
+async function runAgentTask(text, { appendMessage, streamMessage, setThinking, requestApproval, askUser, setMode, appendCodeStep }, sharedState) {
+    const formatErr   = (err) => err && err.message ? err.message : String(err || 'Unknown error');
+    const transcript  = await getChatTranscript();
+    const contextualHistory = sharedState.recentImageContextText
+        ? [...transcript, { sender: 'system', text: sharedState.recentImageContextText, timestamp: new Date().toISOString() }]
+        : transcript;
+
+    if (setMode) setMode('Agent');
+    const cancelTimer = startThinkingTimer(setThinking);
+
+    try {
+        const config             = require('../System/config_manager').readConfig();
+        const availableProviders = require('../System/config_manager').getAvailableProviders(config);
+        const preferredProvider  = require('./code_agent')._helpers.selectSupportedCodeProvider(config, availableProviders);
+        let streamedFinalSummary = false;
+
+        const result = await executeCodeTask(text, {
+            cwd: process.cwd(),
+            requestApproval,
+            askUser,
+            provider: preferredProvider,
+            history:  contextualHistory,
+            onProgress: (info) => { if (appendCodeStep) appendCodeStep(info); },
+            onFinalSummary: async (info) => {
+                cancelTimer();
+                setThinking(false);
+                streamedFinalSummary = true;
+                await streamAssistantSentences(info.summary, appendMessage, { providerInfo: info.providerInfo }, streamMessage);
+            }
+        });
+
+        cancelTimer();
+        setThinking(false);
+        sharedState.lastResponseText = result.summary;
+        if (!streamedFinalSummary) {
+            await streamAssistantSentences(result.summary, appendMessage, { providerInfo: result.providerInfo }, streamMessage);
+        }
+    } catch (err) {
+        cancelTimer();
+        setThinking(false);
+        appendMessage('error', formatErr(err));
+    } finally {
+        if (setMode) setMode('Agent');
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Public: startInteractiveChat
+// ---------------------------------------------------------------------------
+
+/**
+ * Starts the interactive TUI chat session.
+ *
+ * @param {string|null} initialMessage  Optional first message (from CLI arg).
+ * @param {{ imagePath?: string }}  options
+ */
+async function startInteractiveChat(initialMessage = null, options = {}) {
+    const formatErr = (err) => err && err.message ? err.message : String(err || 'Unknown error');
+
+    // Shared mutable state between onSubmit closures
+    const sharedState = {
+        lastResponseText:        '',
+        recentImageContextText:  ''
+    };
+
+    // -----------------------------------------------------------------------
+    const ui = await createChatUI({
+        onPasteImage: async () => {
+            try {
+                const image = loadClipboardImageAsDataUri();
+                return { label: image.path, image };
+            } catch (err) {
+                throw new Error(formatErr(err));
+            }
+        },
+
+        onSubmit: async (text, submitOptions = {}) => {
+            const {
+                appendMessage, streamMessage, setThinking, updateStatusModel,
+                copyLastResponse, requestApproval, setMode, appendCodeStep,
+                updateWorkspace, askUser, attachImage, setInputText,
+                setPendingPasteText, setFastMode, toggleFastMode, getFastMode
+            } = ui;
+
+            // ── Image submission ────────────────────────────────────────────
+            if (submitOptions.images && submitOptions.images.length > 0) {
+                const images = submitOptions.images.map(item => item.image || item);
+                const { responseText, labels, imageList } = await sendImageMessage({
+                    images,
+                    prompt: text.trim() || 'Analyze this image.',
+                    appendMessage, streamMessage, setThinking, appendCodeStep
+                });
+                sharedState.lastResponseText = responseText;
+                if (responseText) {
+                    sharedState.recentImageContextText = [
+                        `Recent image context: the user attached ${imageList.length} image(s) labelled ${labels || '[Image #1]'}.`,
+                        'The terminal UI displays image attachments as labels only; it does not render thumbnails inside the chat.',
+                        `Assistant response to those image(s): ${responseText}`
+                    ].join('\n');
+                }
+                return;
+            }
+
+            // ── Slash commands ──────────────────────────────────────────────
+            if (text.startsWith('/')) {
+                if (text.startsWith('/agent')) {
+                    const aArgs = text.split(' ');
+                    if (aArgs[1] === 'list') {
+                        appendMessage('system', `Available Agents: ${agentOrchestrator.listAgents().join(', ')}`);
+                    } else if (aArgs[1]) {
+                        const success = agentOrchestrator.setAgent(aArgs[1]);
+                        if (success) {
+                            const agent = agentOrchestrator.getCurrentAgent();
+                            appendMessage('system', `Switched to Agent: ${agent.icon} ${agent.name}`);
+                            updateStatusModel(agent.name);
+                            resetChat();
+                        } else {
+                            appendMessage('error', `Agent "${aArgs[1]}" not found. Try /agent list`);
+                        }
+                    } else {
+                        const agent = agentOrchestrator.getCurrentAgent();
+                        appendMessage('system', `Current Agent: ${agent.icon} ${agent.name}\nUsage: /agent <type> or /agent list`);
+                    }
+                    return;
+                }
+
+                if (text.startsWith('/stats')) {
+                    appendMessage('system', '📊 Fetching system statistics...');
+                    const stats = await systemMonitor.execute('stats');
+                    appendMessage('system', stats);
+                    return;
+                }
+
+                if (text.startsWith('/workspace')) {
+                    const wArgs  = text.split(' ');
+                    const subCmd = wArgs[1];
+                    if (subCmd === 'add') {
+                        const name         = wArgs[2];
+                        const wsPath       = wArgs[3] || '.';
+                        const instructions = wArgs.slice(4).join(' ');
+                        if (!name) {
+                            appendMessage('error', 'Usage: /workspace add <name> [path] [instructions]');
+                        } else {
+                            workspaceManager.addWorkspace(name, wsPath, instructions);
+                            appendMessage('system', `Workspace "${name}" registered at ${require('path').resolve(wsPath)}`);
+                            resetChat();
+                        }
+                    } else if (subCmd === 'list') {
+                        const all = workspaceManager.listWorkspaces();
+                        let listMsg = 'Registered Workspaces:\n';
+                        for (const n in all) listMsg += `- ${n}: ${all[n].path}\n`;
+                        appendMessage('system', Object.keys(all).length ? listMsg : 'No workspaces registered.');
+                    } else if (subCmd === 'remove') {
+                        const name = wArgs[2];
+                        if (workspaceManager.removeWorkspace(name)) {
+                            appendMessage('system', `Removed workspace "${name}"`);
+                            resetChat();
+                        } else {
+                            appendMessage('error', `Workspace "${name}" not found.`);
+                        }
+                    } else if (subCmd === 'use' || subCmd === 'switch') {
+                        const name = wArgs[2];
+                        const all  = workspaceManager.listWorkspaces();
+                        if (all[name]) {
+                            const newPath = all[name].path;
+                            try {
+                                process.chdir(newPath);
+                                updateWorkspace(newPath);
+                                appendMessage('system', `✓ Switched to workspace "${name}" at ${newPath}`);
+                                resetChat();
+                            } catch (e) {
+                                appendMessage('error', `Failed to change directory: ${e.message}`);
+                            }
+                        } else {
+                            appendMessage('error', `Workspace "${name}" not found. Try /workspace list`);
+                        }
+                    } else {
+                        const ws = workspaceManager.getWorkspaceByPath(process.cwd());
+                        appendMessage('system', ws
+                            ? `Current Workspace: ${ws.name}\nPath: ${ws.path}`
+                            : `Not currently in a registered workspace.\nActive Path: ${process.cwd()}\nUsage: /workspace <add|use|list|remove>`);
+                    }
+                    return;
+                }
+
+                if (text.startsWith('/review')) {
+                    if (!sharedState.lastResponseText) {
+                        appendMessage('error', 'Nothing to review yet. Get a response first.');
+                        return;
+                    }
+                    agentOrchestrator.setAgent('reviewer');
+                    appendMessage('system', '⚖️ Requesting second-pass review from Mint Reviewer...');
+                    text = `Please review this previous response and provide a critique:\n\n${sharedState.lastResponseText}`;
+                } else {
+                    if (!text.startsWith('/image') && !text.startsWith('/paste')) {
+                        appendMessage('user', text);
+                    }
+                    const slashResult = await handleSlashCommandUI(
+                        text, appendMessage, updateStatusModel, copyLastResponse,
+                        setThinking, requestApproval, setMode, appendCodeStep, updateWorkspace, {
+                            sendImageMessage, formatErrorMessage: formatErr,
+                            attachImage, setInputText, setPendingPasteText,
+                            setFastMode, toggleFastMode, getFastMode,
+                            sendRepoSummaryMessage, sendSymbolIndexMessage,
+                            sendSemanticCodeMessage, streamAssistantSentences,
+                            streamMessage
+                        }
+                    );
+                    if (slashResult && slashResult.lastResponseText) {
+                        sharedState.lastResponseText = slashResult.lastResponseText;
+                    }
+                    return;
+                }
+            }
+
+            appendMessage('user', text);
+
+            // ── Local tool shortcuts (natural language) ─────────────────────
+            if (isRepoSummaryRequest(text)) {
+                const r = await sendRepoSummaryMessage({ appendMessage, streamMessage, setThinking });
+                sharedState.lastResponseText = r;
+                return;
+            }
+            if (isSymbolIndexRequest(text)) {
+                const r = await sendSymbolIndexMessage({ appendMessage, streamMessage, setThinking });
+                sharedState.lastResponseText = r;
+                return;
+            }
+            if (isSemanticCodeSearchRequest(text)) {
+                const query = extractSemanticCodeQuery(text);
+                const r = await sendSemanticCodeMessage({
+                    rawArgs: `search ${query}`,
+                    appendMessage, streamMessage, setThinking, appendCodeStep
+                });
+                sharedState.lastResponseText = r;
+                return;
+            }
+
+            // ── Normal agent task ───────────────────────────────────────────
+            await runAgentTask(text, {
+                appendMessage, streamMessage, setThinking,
+                requestApproval, askUser, setMode, appendCodeStep
+            }, sharedState);
+        },
+
+        onExit: () => exitWithGoodbye(0)
+    });
+
+    // ── Handle initial CLI --image option ───────────────────────────────────
+    if (options.imagePath) {
+        const { appendMessage, streamMessage, setThinking, appendCodeStep } = ui;
+        const image  = loadImageAsDataUri(options.imagePath);
+        const prompt = initialMessage || 'Analyze this image.';
+        const { responseText, labels, imageList } = await sendImageMessage({
+            images: [image], prompt, appendMessage, streamMessage, setThinking, appendCodeStep
+        });
+        sharedState.lastResponseText = responseText;
+        if (responseText) {
+            sharedState.recentImageContextText = [
+                `Recent image context: the user attached ${imageList.length} image(s) labelled ${labels || '[Image #1]'}.`,
+                'The terminal UI displays image attachments as labels only; it does not render thumbnails inside the chat.',
+                `Assistant response to those image(s): ${responseText}`
+            ].join('\n');
+        }
+        return;
+    }
+
+    // ── Handle initial CLI message argument ─────────────────────────────────
+    if (initialMessage) {
+        const { appendMessage, streamMessage, setThinking, requestApproval, setMode, appendCodeStep, askUser } = ui;
+        appendMessage('user', initialMessage);
+
+        if (isRepoSummaryRequest(initialMessage)) {
+            sharedState.lastResponseText = await sendRepoSummaryMessage({ appendMessage, streamMessage, setThinking });
+            return;
+        }
+        if (isSymbolIndexRequest(initialMessage)) {
+            sharedState.lastResponseText = await sendSymbolIndexMessage({ appendMessage, streamMessage, setThinking });
+            return;
+        }
+        if (isSemanticCodeSearchRequest(initialMessage)) {
+            const query = extractSemanticCodeQuery(initialMessage);
+            sharedState.lastResponseText = await sendSemanticCodeMessage({
+                rawArgs: `search ${query}`,
+                appendMessage, streamMessage, setThinking, appendCodeStep
+            });
+            return;
+        }
+
+        await runAgentTask(initialMessage, {
+            appendMessage, streamMessage, setThinking,
+            requestApproval, askUser, setMode, appendCodeStep
+        }, sharedState);
+    }
+}
+
+module.exports = { startInteractiveChat };

package/src/CLI/list_features.js

@@ -22,6 +22,9 @@ function displayFeatures() {
     const commands = [
         { cmd: 'mint', desc: 'Start interactive chat session (Default)' },
         { cmd: 'mint code "<task>"', desc: 'Run workspace-aware coding agent in current directory' },
+        { cmd: 'mint summarize [path]', desc: 'Summarize repository structure, tooling, git state, and key files' },
+        { cmd: 'mint symbols [path]', desc: 'Build a source symbol index for supported languages' },
+        { cmd: 'mint semantic-code', desc: 'Index and search code semantically with embeddings' },
         { cmd: 'mint gmail auth', desc: 'Connect Gmail OAuth and save refresh token' },
         { cmd: 'mint mcp', desc: 'Manage Model Context Protocol (MCP) servers' },
         { cmd: 'mint task "<task>"', desc: 'Queue an autonomous task for the background agent' },

package/src/CLI/onboarding.js

@@ -4,6 +4,35 @@ const { readConfig, writeConfig } = require('../System/config_manager');
 const { installDaemon } = require('../System/daemon_manager');
 const { runGmailAuth } = require('./gmail_auth');
 
+const CUSTOM_MODEL_VALUE = '__custom_model__';
+const ANTHROPIC_MODEL_CHOICES = [
+    'claude-3-5-sonnet-latest',
+    'claude-3-opus-latest',
+    'claude-3-5-haiku-latest'
+];
+const OPENAI_MODEL_CHOICES = [
+    'gpt-4o',
+    'gpt-4o-mini',
+    'o1-preview',
+    'o1-mini'
+];
+
+function buildModelChoices(models, currentModel) {
+    const choices = models.map(model => ({ name: model, value: model }));
+    if (currentModel && !models.includes(currentModel)) {
+        choices.push({ name: `${currentModel} (current)`, value: currentModel });
+    }
+    choices.push({ name: 'Custom...', value: CUSTOM_MODEL_VALUE });
+    return choices;
+}
+
+function resolveCustomModelSelection(answers, modelKey, customKey, fallbackModel) {
+    if (answers[modelKey] !== CUSTOM_MODEL_VALUE) return;
+    const customModel = typeof answers[customKey] === 'string' ? answers[customKey].trim() : '';
+    answers[modelKey] = customModel || fallbackModel;
+    delete answers[customKey];
+}
+
 /**
  * Onboarding Wizard for Mint CLI
  */
@@ -56,10 +85,10 @@ async function runOnboarding(options = {}) {
                 { name: 'Gmail API', value: 'gmail', checked: config.pluginGmailEnabled },
                 { name: 'Notion API', value: 'notion', checked: config.pluginNotionEnabled },
                 new inquirer.Separator(),
-                { name: 'Anthropic (Claude)', value: 'anthropic', checked: config.aiProvider === 'anthropic' || !!config.anthropicApiKey },
-                { name: 'OpenAI (GPT-4o)', value: 'openai', checked: config.aiProvider === 'openai' || !!config.openaiApiKey },
-                { name: 'Hugging Face', value: 'hf', checked: config.aiProvider === 'huggingface' || !!config.hfApiKey },
-                { name: 'Local AI (LM Studio/Ollama)', value: 'local', checked: config.aiProvider === 'local_openai' || (!!config.localApiBaseUrl && config.localApiBaseUrl.length > 0) },
+                { name: 'Anthropic (Claude)', value: 'anthropic', checked: !!config.anthropicApiKey },
+                { name: 'OpenAI (GPT-4o)', value: 'openai', checked: !!config.openaiApiKey },
+                { name: 'Hugging Face', value: 'hf', checked: !!config.hfApiKey },
+                { name: 'Local AI (LM Studio/Ollama)', value: 'local', checked: !!(config.localApiBaseUrl && config.localApiBaseUrl.length > 0) },
                 new inquirer.Separator(),
                 { name: 'Google Search API', value: 'google_search', checked: !!config.googleSearchApiKey },
                 { name: 'Brave Search API', value: 'brave_search', checked: !!config.braveSearchApiKey },
@@ -257,7 +286,23 @@ async function runOnboarding(options = {}) {
                 type: 'input',
                 name: 'anthropicApiKey',
                 message: 'Enter Anthropic API Key:',
-                default: config.anthropicApiKey
+                default: config.anthropicApiKey,
+                validate: (input) => input.trim().length > 0 ? true : 'Anthropic API Key is required when Anthropic is selected.'
+            });
+            dynamicQuestions.push({
+                type: 'list',
+                name: 'anthropicModel',
+                message: 'Select Anthropic model:',
+                choices: buildModelChoices(ANTHROPIC_MODEL_CHOICES, config.anthropicModel),
+                default: config.anthropicModel || 'claude-3-5-sonnet-latest'
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'anthropicModelCustom',
+                message: 'Enter custom Anthropic model:',
+                default: config.anthropicModel || 'claude-3-5-sonnet-latest',
+                when: (answers) => answers.anthropicModel === CUSTOM_MODEL_VALUE,
+                validate: (input) => input.trim().length > 0 ? true : 'Model name is required.'
             });
         }
 
@@ -266,7 +311,23 @@ async function runOnboarding(options = {}) {
                 type: 'input',
                 name: 'openaiApiKey',
                 message: 'Enter OpenAI API Key:',
-                default: config.openaiApiKey
+                default: config.openaiApiKey,
+                validate: (input) => input.trim().length > 0 ? true : 'OpenAI API Key is required when OpenAI is selected.'
+            });
+            dynamicQuestions.push({
+                type: 'list',
+                name: 'openaiModel',
+                message: 'Select OpenAI model:',
+                choices: buildModelChoices(OPENAI_MODEL_CHOICES, config.openaiModel),
+                default: config.openaiModel || 'gpt-4o'
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'openaiModelCustom',
+                message: 'Enter custom OpenAI model:',
+                default: config.openaiModel || 'gpt-4o',
+                when: (answers) => answers.openaiModel === CUSTOM_MODEL_VALUE,
+                validate: (input) => input.trim().length > 0 ? true : 'Model name is required.'
             });
         }
 
@@ -297,19 +358,15 @@ async function runOnboarding(options = {}) {
 
     if (dynamicQuestions.length > 0) {
         const extraAnswers = await inquirer.prompt(dynamicQuestions);
+        resolveCustomModelSelection(extraAnswers, 'anthropicModel', 'anthropicModelCustom', config.anthropicModel || 'claude-3-5-sonnet-latest');
+        resolveCustomModelSelection(extraAnswers, 'openaiModel', 'openaiModelCustom', config.openaiModel || 'gpt-4o');
         config = { ...config, ...extraAnswers };
         
     }
 
-    // Ensure aiProvider reflects the selected primary AI. If no optional AI
-    // provider is selected, keep Gemini as the safe default from basic setup.
-    if (!selections.includes('skip')) {
-        if (selections.includes('anthropic')) config.aiProvider = 'anthropic';
-        else if (selections.includes('openai')) config.aiProvider = 'openai';
-        else if (selections.includes('hf')) config.aiProvider = 'huggingface';
-        else if (selections.includes('local')) config.aiProvider = 'local_openai';
-        else config.aiProvider = 'gemini';
-    }
+    // Onboarding treats Gemini as the primary AI. Other providers are optional
+    // configured backends that become available only when credentials are set.
+    config.aiProvider = 'gemini';
 
     // Save configuration
     writeConfig(config);