@pheem49/mint 1.2.4 → 1.4.0

package/mint-cli.js

@@ -1,12 +1,18 @@
 #!/usr/bin/env node
 require('dotenv').config({ quiet: true });
 const { Command } = require('commander');
-const { handleChat, resetChat } = require('./src/AI_Brain/Gemini_API');
+const { handleChat, handleGeminiChatStream, resetChat, refreshApiKeyFromConfig } = 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');
 const { displayFeatures } = require('./src/CLI/list_features');
 const { readConfig, writeConfig } = require('./src/System/config_manager');
+const { executeCodeTask } = require('./src/CLI/code_agent');
+const { detectCodeIntent, runChatRoutedTask } = require('./src/CLI/chat_router');
 const readline = require('readline');
 const { createChatUI } = require('./src/CLI/chat_ui');
 
@@ -93,23 +99,138 @@ program
         console.log(`${colors.gray}You will receive a notification when it's done.${colors.reset}\n`);
     });
 
+program
+    .command('code')
+    .description('Run Mint in workspace-aware coding mode for the current project')
+    .argument('<task>', 'Coding task to execute in the current working directory')
+    .action(async (task) => {
+        console.log(`\n${colors.mint}${colors.bright}[Mint Code]${colors.reset} Workspace: ${process.cwd()}`);
+        console.log(`${colors.gray}[Mint Code] Task: ${task}${colors.reset}\n`);
+
+        try {
+            const result = await executeCodeTask(task, {
+                cwd: process.cwd(),
+                onProgress: (message) => {
+                    console.log(`${colors.gray}[Mint Code] ${message}${colors.reset}`);
+                },
+                requestApproval: requestCodeApproval
+            });
+
+            console.log(`\n${colors.mint}${colors.bright}Summary${colors.reset}`);
+            console.log(result.summary);
+            console.log(`\n${colors.cyan}Verification:${colors.reset} ${result.verification}`);
+            console.log(`${colors.gray}Completed in ${result.steps} step(s).${colors.reset}\n`);
+        } catch (error) {
+            console.error(`\n${colors.pink}[Mint Code Error]${colors.reset} ${error.message}\n`);
+            process.exitCode = 1;
+        }
+    });
+
 program.parse(process.argv);
 
 /**
  * The Interactive Chat Loop — Gemini-style TUI
  */
 async function startInteractiveChat(initialMessage = null) {
-    const { screen, appendMessage, setThinking, updateStatusModel, copyLastResponse } = 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);
-                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(null, 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());
+            if (routeDecision.route === 'code') {
+                appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
+                await runChatRoutedTask(text, {
+                    appendMessage,
+                    setThinking,
+                    requestApproval,
+                    setMode
+                });
+                return;
+            }
+
+            setMode('Chat');
+
             // Start thinking timer
             let seconds = 0;
             setThinking(true, seconds);
@@ -119,16 +240,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(null, 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);
@@ -149,18 +346,30 @@ async function startInteractiveChat(initialMessage = null) {
     // Handle initial message if passed via CLI arg
     if (initialMessage) {
         appendMessage('user', initialMessage);
-        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);
-        } catch (err) {
-            clearInterval(timer);
-            setThinking(false);
-            appendMessage('error', err.message);
+        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 {
+            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);
+            } catch (err) {
+                clearInterval(timer);
+                setThinking(false);
+                appendMessage('error', err.message);
+            }
         }
     }
 }
@@ -168,7 +377,7 @@ async function startInteractiveChat(initialMessage = null) {
 /**
  * Handles slash commands within the TUI context
  */
-async function handleSlashCommandUI(input, appendMessage, updateStatusModel, copyLastResponse) {
+async function handleSlashCommandUI(input, appendMessage, updateStatusModel, copyLastResponse, setThinking, requestApproval, setMode) {
     const parts = input.split(' ');
     const command = parts[0].toLowerCase();
     const args = parts.slice(1);
@@ -178,6 +387,7 @@ async function handleSlashCommandUI(input, appendMessage, updateStatusModel, cop
         case '/?':
             appendMessage('system', [
                 'Mint Slash Commands:',
+                '  /code <task>     — Force workspace Code Mode',
                 '  /models [name]  — List or switch Gemini models',
                 '  /config         — Show current configuration',
                 '  /copy           — Copy last response to clipboard',
@@ -192,29 +402,63 @@ 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;
 
+        case '/code':
+            if (args.length === 0) {
+                appendMessage('system', 'Usage: /code <task>');
+                break;
+            }
+            await runChatRoutedTask(`/code ${args.join(' ')}`, {
+                appendMessage,
+                setThinking,
+                requestApproval,
+                setMode
+            });
+            break;
+
         case '/config':
             const currentCfg = readConfig();
             appendMessage('system', [
@@ -253,3 +497,36 @@ async function handleSlashCommandUI(input, appendMessage, updateStatusModel, cop
     }
 }
 
+async function requestCodeApproval(request) {
+    const typeLabel = request.type === 'shell'
+        ? 'Shell Command'
+        : request.type === 'patch'
+            ? 'Patch Edit'
+            : 'File Write';
+
+    console.log(`\n${colors.yellow}${colors.bright}[Approval Required]${colors.reset} ${typeLabel}`);
+    if (request.label) {
+        console.log(`${colors.gray}${request.label}${colors.reset}`);
+    }
+    if (request.preview) {
+        console.log(`${colors.gray}${request.preview}${colors.reset}\n`);
+    }
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    const answer = await new Promise((resolve) => {
+        rl.question('Approve this action? [y/N]: ', (value) => {
+            rl.close();
+            resolve((value || '').trim().toLowerCase());
+        });
+    });
+
+    const approved = answer === 'y' || answer === 'yes';
+    console.log(approved
+        ? `${colors.mint}[Mint Code] Approved.${colors.reset}\n`
+        : `${colors.pink}[Mint Code] Denied.${colors.reset}\n`);
+    return approved;
+}

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.2.4",
+  "version": "1.4.0",
   "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"
   },
@@ -22,24 +32,31 @@
   "dependencies": {
     "@google/genai": "^1.44.0",
     "@inkjs/ui": "^2.0.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "axios": "^1.13.6",
     "blessed": "^0.1.81",
     "cheerio": "^1.2.0",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
+    "framer-motion": "^12.38.0",
     "google-tts-api": "^2.0.2",
     "ink": "^7.0.1",
     "ink-text-input": "^6.0.0",
     "inquirer": "^13.4.1",
+    "lucide-react": "^1.9.0",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",
     "puppeteer": "^24.38.0",
     "react": "^19.2.5",
+    "react-dom": "^19.2.5",
     "xlsx": "^0.18.5"
   },
   "devDependencies": {
+    "@vitejs/plugin-react": "^6.0.1",
     "electron": "^40.7.0",
-    "electron-builder": "^26.8.1"
+    "electron-builder": "^26.8.1",
+    "jest": "^30.4.0",
+    "vite": "^8.0.10"
   },
   "build": {
     "appId": "com.pheem49.mint",