@pheem49/mint 1.3.0 → 1.4.0

package/README.md

@@ -17,13 +17,17 @@
 
 ---
 
-**Mint** is a powerful AI Assistant built with **Electron**, **Node.js**, and **Google Gemini**. It bridges the gap between your Desktop and Terminal, featuring real-time screen vision, web automation, local knowledge search, and a professional CLI for developers who love the command line.
+**Mint** is a powerful AI Assistant built with **Electron**, **Node.js**, and **Google Gemini** (with extended support for Hugging Face, Anthropic, OpenAI, and Local Models). It bridges the gap between your Desktop and Terminal, featuring real-time screen vision, web automation, local knowledge search, and a professional CLI for developers who love the command line.
 
-## 🌟 Highlights
+## Highlights
 
 - **Dual-Mode AI**: Switch between a beautiful **Desktop GUI** and a professional **CLI**.
 - **Code Agent Mode**: Use `mint code "<task>"` to inspect, edit, and verify a project directly from the current terminal workspace.
 - **Chat-First Workflow**: Regular Mint chat can now auto-route coding requests into workspace Code Mode, so the main chat acts as the control surface.
+- **Advanced Multi-Agent Hub**: 
+  - **Smart Routing**: Intelligently routes coding/general tasks to the most capable configured provider (e.g., Claude, OpenAI, Gemini).
+  - **Agent Collaboration**: Enable Multi-Agent Review so that a primary AI writes the code while a secondary AI automatically reviews it in the same loop.
+  - **Resilient Fallback**: Automatically fallbacks to alternative AI providers (Gemini, Anthropic, OpenAI, Hugging Face, LM Studio, Ollama) if your active provider fails.
 - **Visible Mode State**: The CLI status bar now shows whether Mint is currently in `Chat` or `Code` mode.
 - **Interactive Slash Commands**: Manage models and settings in the terminal with `/model`, `/config`, `/clear`, etc.
 - **Smart TUI Experience**: Professional message framing, character-wrapped Thai text support, and mouse scroll wheel navigation.
@@ -36,7 +40,7 @@
 
 ---
 
-## 📸 Screenshots
+## Screenshots
 
 <p align="center">
   <img src="assets/Agent_Mint.png" alt="Agent Mint UI" width="48%">
@@ -48,7 +52,7 @@
 
 ---
 
-## ⌨️ CLI Usage (Power Users)
+## CLI Usage (Power Users)
 
 Mint CLI is built for speed and efficiency. Use the **`mint`** command from anywhere.
 
@@ -56,21 +60,21 @@ Mint CLI is built for speed and efficiency. Use the **`mint`** command from anyw
   <img src="assets/CLI_Screen.png" alt="Mint CLI Preview" width="100%">
 </p>
 
-### 🚀 Professional Commands
+### Professional Commands
 - **`mint`** : Start interactive chat mode (Default).
 - **`mint code "task"`** : Run Mint as a workspace-aware coding agent in the current project folder.
 - **`mint agent`** : Run Mint as a headless background agent (Monitoring mode).
-- **`mint agent "task"`** : **[NEW]** Start agent and execute an autonomous task immediately.
+- **`mint agent "task"`** : Start agent and execute an autonomous task immediately.
 - **`mint task "task"`** : Delegate a multi-step task to an already running background agent.
 - **`mint onboard`** : Setup API Key, Model, and initialize global configuration in `~/.mint/`.
 - **`mint list`** : See full list of automation actions and plugins.
 
 ---
 
-### 🤖 Autonomous Agent (Task Delegate)
+### Autonomous Agent (Task Delegate)
 Mint isn't just a chatbot—it's an autonomous worker. Assign complex tasks that require multiple steps of reasoning.
 
-### 👨‍💻 Code Agent Mode
+### Code Agent Mode
 Mint now includes a dedicated coding workflow as the first step toward a Claude-Code-like experience in the terminal.
 
 **What it can do now:**
@@ -95,10 +99,10 @@ mint
 Mint will classify the request, switch the status bar to `Code`, and return to `Chat` mode after the coding flow finishes.
 
 **Supported Autonomous Tools:**
-- 🌐 **Web Automation**: Full Puppeteer-based browsing, info extraction, and research.
-- 📁 **File System**: Create, Write, Delete, and Manage folders using `~/` path expansion.
-- 🔍 **Knowledge Search**: Query local files and documentation (RAG).
-- 🛡️ **Safety Mode (Bash)**: Mint proposes commands via notifications; you choose whether to run them.
+- **Web Automation**: Full Puppeteer-based browsing, info extraction, and research.
+- **File System**: Create, Write, Delete, and Manage folders using `~/` path expansion.
+- **Knowledge Search**: Query local files and documentation (RAG).
+- **Safety Mode (Bash)**: Mint proposes commands via notifications; you choose whether to run them.
 
 **Usage Examples:**
 ```bash
@@ -111,28 +115,28 @@ mint task 'Process these 5 files and move them to ~/Documents/Archive'
 
 ---
 
-### ⚡ Slash Commands (Interactive Chat)
+### Slash Commands (Interactive Chat)
 While in terminal chat, type **`/`** to access advanced tools with the new visual autocomplete system.
 > [!TIP]
 > Use **Up/Down arrow keys** to navigate the suggestion list and press **Enter** to select!
 
 - `/help` : View all commands and descriptions.
-- `/models` : List and switch between Gemini/Ollama models.
+- `/models` : List and switch between Gemini, Ollama, Hugging Face, Anthropic, OpenAI, and Local models.
 - `/config` : Check your active API keys and preferences.
 - `/clear` / `/reset` : Clean terminal or reset AI context.
 
 ---
 
-### 🕒 Proactive Monitoring
+### Proactive Monitoring
 When running in `agent` mode, Mint monitors your system in the background:
-- 🔋 **Battery Alerts**: Notifies you when power is low or charging status changes.
-- 🌐 **Network Status**: Alerts you when connection status changes.
-- 📊 **Resource Usage**: Proactive tips if system load is too high (System Metrics).
+- **Battery Alerts**: Notifies you when power is low or charging status changes.
+- **Network Status**: Alerts you when connection status changes.
+- **Resource Usage**: Proactive tips if system load is too high (System Metrics).
 
 
 ---
 
-## 🎨 Desktop GUI Features
+## Desktop GUI Features
 
 - **Floating Widget**: A persistent AI character on your desktop.
 - **Animated Aura**: The widget breathes and glows when Mint is thinking or proactive.
@@ -142,15 +146,15 @@ When running in `agent` mode, Mint monitors your system in the background:
 
 ---
 
-## 🛡️ Security & Privacy
+## Security & Privacy
 
 - **Push Protection**: Automated `.gitignore` patterns for `mint-config.json` and `.env` files.
 - **History Scrubbing**: Integrated tools to ensure API keys are never leaked to Git history.
-- **Local First**: Built-in **Ollama** support for 100% private, offline AI processing.
+- **Local First**: Built-in **Ollama** and **LM Studio (OpenAI Compatible)** support for 100% private, offline AI processing.
 
 ---
 
-## 🛠️ Getting Started
+## Getting Started
 
 ### Prerequisites
 - [Node.js](https://nodejs.org/) (LTS)
@@ -173,7 +177,7 @@ When running in `agent` mode, Mint monitors your system in the background:
 
 ---
 
-## 📂 Project Structure
+## Project Structure
 
 ```text
 Mint/
@@ -191,6 +195,6 @@ Mint/
 
 ---
 
-## 🏛️ License
+## License
 
 Distributed under the **GNU Affero General Public License v3.0**. See `LICENSE` for details.

package/mint-cli.js

@@ -1,7 +1,11 @@
 #!/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');
@@ -128,14 +132,88 @@ 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(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);
 
@@ -162,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);
@@ -248,26 +402,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;
 

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.3.0",
+  "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"
   },
@@ -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": {