@pheem49/mint 1.3.0 → 1.4.1

package/mint-cli.js

@@ -1,7 +1,19 @@
 #!/usr/bin/env node
 require('dotenv').config({ quiet: true });
+// Suppress experimental SQLite warning
+const originalEmit = process.emit;
+process.emit = function (name, data, ...args) {
+    if (name === 'warning' && typeof data === 'object' && data.name === 'ExperimentalWarning' && data.message.includes('SQLite')) {
+        return false;
+    }
+    return originalEmit.apply(process, [name, data, ...args]);
+};
 const { Command } = require('commander');
-const { handleChat, resetChat } = require('./src/AI_Brain/Gemini_API');
+const { handleChat, handleGeminiChatStream, resetChat, refreshApiKeyFromConfig, getChatTranscript } = require('./src/AI_Brain/Gemini_API');
+const agentOrchestrator = require('./src/AI_Brain/agent_orchestrator');
+const workspaceManager = require('./src/CLI/workspace_manager');
+const systemMonitor = require('./src/Plugins/system_monitor');
+const { sendNotification } = require('./src/System/notifications');
 const pkg = require('./package.json');
 const { runOnboarding } = require('./src/CLI/onboarding');
 const { startAgent } = require('./src/AI_Brain/headless_agent');
@@ -128,27 +140,117 @@ program.parse(process.argv);
  * The Interactive Chat Loop — Gemini-style TUI
  */
 async function startInteractiveChat(initialMessage = null) {
-    const { screen, appendMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode } = createChatUI({
+    let lastResponseText = "";
+    const { screen, appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode } = createChatUI({
         onSubmit: async (text) => {
             if (text.startsWith('/')) {
-                // Slash commands via fake rl-compatible object
-                const fakeRl = { close: () => { } };
-                appendMessage('user', text);
-                await handleSlashCommandUI(text, appendMessage, updateStatusModel, copyLastResponse, setThinking, requestApproval, setMode);
-                return;
+                if (text.startsWith('/agent')) {
+                    const args = text.split(' ');
+                    if (args[1] === 'list') {
+                        appendMessage('system', `Available Agents: ${agentOrchestrator.listAgents().join(', ')}`);
+                    } else if (args[1]) {
+                        const success = agentOrchestrator.setAgent(args[1]);
+                        if (success) {
+                            const agent = agentOrchestrator.getCurrentAgent();
+                            appendMessage('system', `Switched to Agent: ${agent.icon} ${agent.name}`);
+                            updateStatusModel(agent.name); // Pass name to status bar
+                            resetChat(); // Reset to apply new system prompt
+                        } else {
+                            appendMessage('error', `Agent "${args[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 args = text.split(' ');
+                    const subCmd = args[1];
+
+                    if (subCmd === 'add') {
+                        const name = args[2];
+                        const wsPath = args[3] || '.';
+                        const instructions = args.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 ${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 = args[2];
+                        if (workspaceManager.removeWorkspace(name)) {
+                            appendMessage('system', `Removed workspace "${name}"`);
+                            resetChat();
+                        } else {
+                            appendMessage('error', `Workspace "${name}" not found.`);
+                        }
+                    } else {
+                        const ws = workspaceManager.getWorkspaceByPath(process.cwd());
+                        appendMessage('system', ws ? `Current Workspace: ${ws.name}\nPath: ${ws.path}` : "Not currently in a registered workspace.\nUsage: /workspace <add|list|remove>");
+                    }
+                    return;
+                }
+
+                if (text.startsWith('/review')) {
+                    if (!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${lastResponseText}`;
+                } else {
+                    // Other slash commands
+                    const fakeRl = { close: () => { } };
+                    appendMessage('user', text);
+                    await handleSlashCommandUI(text, appendMessage, updateStatusModel, copyLastResponse, setThinking, requestApproval, setMode);
+                    return;
+                }
             }
             appendMessage('user', text);
 
-            const routeDecision = await detectCodeIntent(text, process.cwd());
+            const transcript = await getChatTranscript();
+            const routeDecision = await detectCodeIntent(text, process.cwd(), transcript);
             if (routeDecision.route === 'code') {
-                appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
-                await runChatRoutedTask(text, {
-                    appendMessage,
-                    setThinking,
-                    requestApproval,
-                    setMode
+                const approved = await requestApproval({
+                    type: 'code_mode',
+                    label: 'Mint wants to switch this request into Code Mode.',
+                    preview: [
+                        `Request: ${text}`,
+                        `Reason: ${routeDecision.reason}`,
+                        '',
+                        'Code Mode is better for larger coding tasks that may inspect the workspace, run checks, or edit files.'
+                    ].join('\n')
                 });
-                return;
+                if (!approved) {
+                    appendMessage('system', `Router stayed in Chat Mode. ${routeDecision.reason}`);
+                } else {
+                    appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
+                    await runChatRoutedTask(text, {
+                        appendMessage,
+                        setThinking,
+                        requestApproval,
+                        setMode,
+                        history: transcript
+                    });
+                    return;
+                }
             }
 
             setMode('Chat');
@@ -162,16 +264,92 @@ async function startInteractiveChat(initialMessage = null) {
             }, 1000);
 
             try {
-                const response = await handleChat(text);
-                clearInterval(timer);
-                setThinking(false);
-                appendMessage('assistant', response.response, response.timestamp);
+                const config = require('./src/System/config_manager').readConfig();
+                const provider = config.aiProvider || 'gemini';
+                const currentAgent = agentOrchestrator.getCurrentAgent();
+                updateStatusModel(currentAgent.name);
+                if (provider === 'gemini') {
+                    // ── Streaming path (Gemini only) ──────────────────────────────────
+                    // Gemini returns JSON so we buffer all chunks and progressively
+                    // extract the "response" field as more of the JSON arrives.
+                    clearInterval(timer);
+
+                    let jsonBuffer = '';
+                    let finalParsed = null;
+                    let streamer = null;
+                    let displayedChars = 0; // chars of response text already sent to TUI
+
+                    try {
+                        for await (const event of handleGeminiChatStream(text)) {
+                            if (event.chunk) {
+                                jsonBuffer += event.chunk;
+
+                                // Progressively extract readable text from the growing JSON buffer
+                                const match = jsonBuffer.match(/"response"\s*:\s*"((?:[^"\\]|\\.)*)"/s);
+                                if (match) {
+                                    const fullText = match[1]
+                                        .replace(/\\n/g, '\n')
+                                        .replace(/\\"/g, '"')
+                                        .replace(/\\\\/g, '\\');
+                                    const newChars = fullText.slice(displayedChars);
+                                    if (newChars.length > 0) {
+                                        if (!streamer) {
+                                            setThinking(false);
+                                            streamer = streamMessage('assistant');
+                                        }
+                                        streamer.appendChunk(newChars);
+                                        displayedChars = fullText.length;
+                                    }
+                                }
+                            } else if (event.done) {
+                                finalParsed = event.parsed;
+                                // Flush any remaining response text not yet displayed
+                                if (finalParsed && finalParsed.response) {
+                                    const remaining = finalParsed.response.slice(displayedChars);
+                                    if (!streamer) {
+                                        setThinking(false);
+                                        streamer = streamMessage('assistant');
+                                    }
+                                    if (remaining) streamer.appendChunk(remaining);
+                                }
+                                if (streamer) {
+                                    streamer.finalize(event.timestamp);
+                                } else {
+                                    setThinking(false);
+                                    appendMessage('assistant',
+                                        finalParsed ? finalParsed.response : '',
+                                        event.timestamp);
+                                }
+                            }
+                        }
+                    } catch (streamErr) {
+                        setThinking(false);
+                        appendMessage('error', streamErr.message);
+                        return;
+                    }
+
+                    // Execute Actions from the final parsed response
+                    if (finalParsed) {
+                        const { executeAction } = require('./mint-cli-logic');
+                        if (finalParsed.action && finalParsed.action.type !== 'none') {
+                            const result = await executeAction(finalParsed.action);
+                            if (result) appendMessage('system', `Action: ${result}`);
+                        }
+                    }
 
-                // Execute Actions
-                const { executeAction } = require('./mint-cli-logic');
-                if (response.action && response.action.type !== 'none') {
-                    const result = await executeAction(response.action);
-                    if (result) appendMessage('system', `Action: ${result}`);
+                } else {
+                    // ── Non-streaming fallback (Ollama, Anthropic, OpenAI, etc.) ──
+                    const response = await handleChat(text);
+                    clearInterval(timer);
+                    setThinking(false);
+                    lastResponseText = response.response;
+                    appendMessage('assistant', response.response, response.timestamp);
+
+                    const { executeAction } = require('./mint-cli-logic');
+                    if (response.action && response.action.type !== 'none') {
+                        const result = await executeAction(response.action);
+                        if (result) appendMessage('system', `Action: ${result}`);
+                    }
                 }
             } catch (err) {
                 clearInterval(timer);
@@ -192,16 +370,52 @@ async function startInteractiveChat(initialMessage = null) {
     // Handle initial message if passed via CLI arg
     if (initialMessage) {
         appendMessage('user', initialMessage);
-        const routeDecision = await detectCodeIntent(initialMessage, process.cwd());
-        if (routeDecision.route === 'code') {
-            appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
-            await runChatRoutedTask(initialMessage, {
-                appendMessage,
-                setThinking,
-                requestApproval,
-                setMode
-            });
-        } else {
+            const transcript = await getChatTranscript();
+            const routeDecision = await detectCodeIntent(initialMessage, process.cwd(), transcript);
+            if (routeDecision.route === 'code') {
+                const approved = await requestApproval({
+                    type: 'code_mode',
+                    label: 'Mint wants to switch this request into Code Mode.',
+                    preview: [
+                        `Request: ${initialMessage}`,
+                        `Reason: ${routeDecision.reason}`,
+                        '',
+                        'Code Mode is better for larger coding tasks that may inspect the workspace, run checks, or edit files.'
+                    ].join('\n')
+                });
+                if (approved) {
+                    appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
+                    await runChatRoutedTask(initialMessage, {
+                        appendMessage,
+                        setThinking,
+                        requestApproval,
+                        setMode,
+                        history: transcript
+                    });
+                } else {
+                    appendMessage('system', `Router stayed in Chat Mode. ${routeDecision.reason}`);
+                    setMode('Chat');
+                    let seconds = 0;
+                    setThinking(true, seconds);
+                    const timer = setInterval(() => { seconds++; setThinking(true, seconds); }, 1000);
+                    try {
+                        const response = await handleChat(initialMessage);
+                        clearInterval(timer);
+                        setThinking(false);
+                        appendMessage('assistant', response.response, response.timestamp);
+                        lastResponseText = response.response;
+                        const { executeAction } = require('./mint-cli-logic');
+                        if (response.action && response.action.type !== 'none') {
+                            const result = await executeAction(response.action);
+                            if (result) appendMessage('system', `Action: ${result}`);
+                        }
+                    } catch (err) {
+                        clearInterval(timer);
+                        setThinking(false);
+                        appendMessage('error', err.message);
+                    }
+                }
+            } else {
             setMode('Chat');
             let seconds = 0;
             setThinking(true, seconds);
@@ -211,6 +425,12 @@ async function startInteractiveChat(initialMessage = null) {
                 clearInterval(timer);
                 setThinking(false);
                 appendMessage('assistant', response.response, response.timestamp);
+                lastResponseText = response.response;
+                const { executeAction } = require('./mint-cli-logic');
+                if (response.action && response.action.type !== 'none') {
+                    const result = await executeAction(response.action);
+                    if (result) appendMessage('system', `Action: ${result}`);
+                }
             } catch (err) {
                 clearInterval(timer);
                 setThinking(false);
@@ -248,26 +468,47 @@ async function handleSlashCommandUI(input, appendMessage, updateStatusModel, cop
             const config = readConfig();
             if (args.length === 0) {
                 appendMessage('system', [
-                    `Current Model: ${config.geminiModel}`,
-                    'Available Presets:',
-                    '  - gemini-2.5-flash (Default)',
-                    '  - gemini-3.1-flash-lite-preview',
-                    '  - gemini-3.1-flash-lite',
-                    '  - ollama (local provider)',
+                    `Current Provider: ${config.aiProvider}`,
+                    `Current Gemini Model: ${config.geminiModel}`,
+                    'Available Providers/Presets:',
+                    '  - gemini-2.5-flash (Default Gemini)',
+                    '  - ollama (Local provider)',
+                    '  - anthropic (Claude)',
+                    '  - openai (GPT)',
+                    '  - huggingface (Inference API)',
+                    '  - local (LM Studio / OpenAI Compatible)',
                     'Usage: /models <name> to switch'
                 ].join('\n'));
             } else {
                 const { writeConfig } = require('./src/System/config_manager');
                 const newModel = args[0];
+                let newProvider = 'gemini';
+                
                 if (newModel === 'ollama') {
-                    config.aiProvider = 'ollama';
+                    newProvider = 'ollama';
+                } else if (newModel === 'anthropic') {
+                    newProvider = 'anthropic';
+                } else if (newModel === 'openai') {
+                    newProvider = 'openai';
+                } else if (newModel === 'huggingface') {
+                    newProvider = 'huggingface';
+                } else if (newModel === 'local' || newModel === 'local_openai') {
+                    newProvider = 'local_openai';
+                } else if (newModel.startsWith('gpt-')) {
+                    newProvider = 'openai';
+                    config.openaiModel = newModel;
+                } else if (newModel.startsWith('claude-')) {
+                    newProvider = 'anthropic';
+                    config.anthropicModel = newModel;
                 } else {
-                    config.aiProvider = 'gemini';
+                    newProvider = 'gemini';
                     config.geminiModel = newModel;
                 }
+                
+                config.aiProvider = newProvider;
                 writeConfig(config);
-                appendMessage('system', `✅ Switched to: ${newModel}`);
-                if (updateStatusModel) updateStatusModel(newModel);
+                appendMessage('system', `✅ Switched to: ${newProvider} ${newProvider === 'gemini' ? `(${newModel})` : ''}`);
+                if (updateStatusModel) updateStatusModel(newProvider === 'gemini' ? newModel : newProvider);
             }
             break;
 
@@ -280,7 +521,8 @@ async function handleSlashCommandUI(input, appendMessage, updateStatusModel, cop
                 appendMessage,
                 setThinking,
                 requestApproval,
-                setMode
+                setMode,
+                history: await getChatTranscript()
             });
             break;
 

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "A powerful Electron-based AI desktop assistant powered by Google Gemini, featuring screen vision, web automation, and proactive suggestions.",
   "main": "main.js",
   "scripts": {
     "start": "electron .",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest --testPathPatterns=tests/",
+    "test:watch": "jest --testPathPatterns=tests/ --watch",
     "build:linux": "electron-builder --linux",
     "cli": "node mint-cli.js"
   },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": ["**/tests/**/*.test.js"],
+    "collectCoverageFrom": [
+      "src/AI_Brain/memory_store.js",
+      "src/AI_Brain/knowledge_base.js",
+      "src/System/config_manager.js"
+    ]
+  },
   "bin": {
     "mint": "mint-cli.js"
   },
@@ -45,6 +55,7 @@
     "@vitejs/plugin-react": "^6.0.1",
     "electron": "^40.7.0",
     "electron-builder": "^26.8.1",
+    "jest": "^30.4.0",
     "vite": "^8.0.10"
   },
   "build": {