@pheem49/mint 1.5.1 → 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' },