@pheem49/mint 1.5.1 → 1.5.2

package/models/Shiroko_Model/Shiroko/Shiroko_Core//345/221/206/347/214/253.exp3.json

@@ -5,6 +5,36 @@
             "Id": "Param93",
             "Value": 1.0,
             "Blend": "Add"
+        },
+        {
+            "Id": "Param91",
+            "Value": 0.45,
+            "Blend": "Add"
+        },
+        {
+            "Id": "ParamAngleY",
+            "Value": -8.0,
+            "Blend": "Add"
+        },
+        {
+            "Id": "ParamAngleZ",
+            "Value": 8.0,
+            "Blend": "Add"
+        },
+        {
+            "Id": "ParamEyeBallY",
+            "Value": -0.35,
+            "Blend": "Add"
+        },
+        {
+            "Id": "ParamMouthForm",
+            "Value": 0.25,
+            "Blend": "Add"
+        },
+        {
+            "Id": "ParamMouthOpenY",
+            "Value": 0.25,
+            "Blend": "Add"
         }
     ]
-}
+}

package/models/Shiroko_Model/Shiroko/Shiroko_Core//347/202/271/344/270/200/344/270/213.exp3.json

@@ -5,6 +5,11 @@
             "Id": "Param76",
             "Value": 1.0,
             "Blend": "Add"
+        },
+        {
+            "Id": "Param91",
+            "Value": 0.75,
+            "Blend": "Add"
         }
     ]
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "A powerful Electron-based AI desktop assistant powered by Google Gemini, featuring screen vision, web automation, and proactive suggestions.",
   "main": "main.js",
   "scripts": {
@@ -36,40 +36,38 @@
   "type": "commonjs",
   "dependencies": {
     "@google/genai": "^1.44.0",
-    "@hazart-pkg/live2d-core": "^1.0.1",
     "@inkjs/ui": "^2.0.0",
-    "@line/bot-sdk": "^11.0.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@slack/bolt": "^4.7.2",
     "axios": "^1.13.6",
-    "blessed": "^0.1.81",
     "cheerio": "^1.2.0",
     "commander": "^14.0.3",
-    "discord.js": "^14.26.4",
     "dotenv": "^17.3.1",
-    "express": "^5.2.1",
-    "framer-motion": "^12.38.0",
     "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",
-    "pixi-live2d-display": "^0.4.0",
-    "pixi.js": "^6.5.10",
-    "puppeteer": "^24.38.0",
-    "qrcode-terminal": "^0.12.0",
-    "react": "^19.2.5",
-    "react-dom": "^19.2.5",
-    "read-excel-file": "^9.0.9",
-    "telegraf": "^4.16.3",
-    "whatsapp-web.js": "^1.34.7"
+    "react": "^19.2.5"
+  },
+  "peerDependenciesOptional": {
+    "puppeteer": ">=22.0.0",
+    "whatsapp-web.js": ">=1.0.0",
+    "qrcode-terminal": ">=0.12.0",
+    "discord.js": ">=14.0.0",
+    "@slack/bolt": ">=4.0.0",
+    "telegraf": ">=4.0.0",
+    "@line/bot-sdk": ">=11.0.0",
+    "express": ">=4.0.0"
   },
   "devDependencies": {
+    "@hazart-pkg/live2d-core": "^1.0.1",
     "@vitejs/plugin-react": "^6.0.1",
     "electron": "^40.7.0",
     "electron-builder": "^26.8.1",
+    "framer-motion": "^12.38.0",
     "jest": "^30.4.0",
+    "lucide-react": "^1.9.0",
+    "pixi-live2d-display": "^0.4.0",
+    "pixi.js": "^6.5.10",
+    "react-dom": "^19.2.5",
     "vite": "^8.0.10"
   },
   "build": {

package/src/AI_Brain/proactive_engine.js

@@ -5,9 +5,14 @@ const { readConfig } = require('../System/config_manager');
 // Proactive Engine — Smart Suggestion Engine (Multi-Choice)
 // ============================================================
 
-const ai = new GoogleGenAI({});
 const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
 let lastLoggedModel = '';
+let _ai = null;
+
+function getAi(apiKey) {
+    if (!_ai) _ai = new GoogleGenAI({ apiKey });
+    return _ai;
+}
 
 const PROACTIVE_SYSTEM_PROMPT = `You are a Smart Suggestion Engine built into a Desktop AI Agent called "Mint".
 Your job: observe the user's screen + behavior, then offer MULTIPLE relevant quick-action options — NOT just one question.
@@ -89,11 +94,15 @@ function getMinSuggestionIntervalMs() {
  */
 async function analyzeAndSuggest(base64Image, behaviorSummary) {
     try {
-        const model = resolveGeminiModel();
+        const cfg = readConfig();
+        const apiKey = cfg.apiKey || process.env.GEMINI_API_KEY;
+        if (!apiKey) return null; // silently skip if no API key configured
+        const model = (cfg.geminiModel || '').trim() || DEFAULT_GEMINI_MODEL;
         if (model && model !== lastLoggedModel) {
             console.log(`[Gemini] Proactive Engine model: ${model}`);
             lastLoggedModel = model;
         }
+        const ai = getAi(apiKey);
 
         const now = Date.now();
         const minInterval = getMinSuggestionIntervalMs();
@@ -127,6 +136,7 @@ Rules: Only suggest if you see a clear opportunity. Return 2–4 relevant chips.
             contents: [{ role: 'user', parts: userMessage }]
         });
 
+
         let parsed;
         try {
             parsed = JSON.parse(response.text);

package/src/Automation_Layer/browser_automation.js

@@ -1,10 +1,10 @@
-const puppeteer = require('puppeteer');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { GoogleGenAI } = require('@google/genai');
 const { readConfig } = require('../System/config_manager');
 
-const ai = new GoogleGenAI({});
-const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
-let lastLoggedModel = '';
+
 
 const BROWSER_SYSTEM_PROMPT = `You are an Autonomous Browser Agent. Your goal is to fulfill the user's web instruction by driving a headless browser.
 
@@ -24,6 +24,9 @@ Actions:
 
 You will receive the result of your previous action in the next message. If you get stuck or fail, try another approach or use "done" to report the failure.`;
 
+const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
+let lastLoggedModel = '';
+
 function resolveGeminiModel() {
     try {
         const cfg = readConfig();
@@ -35,11 +38,14 @@ function resolveGeminiModel() {
 }
 
 async function performWebAutomation(query) {
-    if (!query) return "No query provided.";
+    if (!query) return 'No query provided.';
 
-    console.log("Starting web automation for:", query);
+    // Dynamic require — user must install puppeteer separately
+    const puppeteer = requireOptional('puppeteer', 'npm install puppeteer');
 
     const config = readConfig();
+    const apiKey  = config.apiKey || process.env.GEMINI_API_KEY;
+    const ai = new GoogleGenAI({ apiKey });
     const browserPath = config.automationBrowser;
 
     let browser;
@@ -50,7 +56,6 @@ async function performWebAutomation(query) {
             args: ['--start-maximized']
         };
 
-        // If it's a specific path (like /usr/bin/firefox), set executablePath
         if (browserPath && browserPath !== 'chromium') {
             launchOptions.executablePath = browserPath;
             if (browserPath.toLowerCase().includes('firefox')) {
@@ -59,9 +64,8 @@ async function performWebAutomation(query) {
         }
 
         browser = await puppeteer.launch(launchOptions);
-
         const page = await browser.newPage();
-        
+
         const model = resolveGeminiModel();
         if (model && model !== lastLoggedModel) {
             console.log(`[Gemini] Web Automation model: ${model}`);
@@ -72,12 +76,12 @@ async function performWebAutomation(query) {
             model,
             config: {
                 systemInstruction: BROWSER_SYSTEM_PROMPT,
-                responseMimeType: "application/json"
+                responseMimeType: 'application/json'
             }
         });
 
         let currentObservation = `Goal: ${query}\nSystem Note: You have a blank browser page. What is your first action? Start by using "goto" to navigate to a relevant search engine or website.`;
-        
+
         let maxSteps = 10;
         let step = 0;
 
@@ -87,27 +91,26 @@ async function performWebAutomation(query) {
             console.log(`Observation:`, currentObservation.substring(0, 150) + (currentObservation.length > 150 ? '...' : ''));
 
             const response = await chat.sendMessage({ message: currentObservation });
-            
+
             let parsed;
             try {
                 const text = response.text;
                 const cleanText = text.replace(/^```json\n/, '').replace(/\n```$/, '').trim();
                 parsed = JSON.parse(cleanText);
             } catch (e) {
-                console.error("Agent failed to return valid JSON:", response.text);
-                currentObservation = "Error: Invalid JSON returned. Please reply with ONLY valid JSON matching the schema.";
+                console.error('Agent failed to return valid JSON:', response.text);
+                currentObservation = 'Error: Invalid JSON returned. Please reply with ONLY valid JSON matching the schema.';
                 continue;
             }
 
-            console.log("Agent Thought:", parsed.thought);
-            console.log("Agent Action:", parsed.action);
-            console.log("Agent Target:", parsed.target);
+            console.log('Agent Thought:', parsed.thought);
+            console.log('Agent Action:', parsed.action);
+            console.log('Agent Target:', parsed.target);
 
             const { action, target } = parsed;
 
             if (action === 'done') {
-                console.log("Agent finished with answer:", target);
-                // Intentionally keeping the browser open so the user can see the page.
+                console.log('Agent finished with answer:', target);
                 return `🤖 Web Automation Result: ${target}`;
             }
 
@@ -119,7 +122,7 @@ async function performWebAutomation(query) {
                 } else if (action === 'click') {
                     await page.waitForSelector(target, { timeout: 5000 });
                     await page.click(target);
-                    await new Promise(r => setTimeout(r, 2000)); 
+                    await new Promise(r => setTimeout(r, 2000));
                     const pageTitle = await page.title();
                     currentObservation = `Clicked element. Current page: ${pageTitle}. ` + await page.evaluate(() => document.body.innerText.substring(0, 1500));
                 } else if (action === 'eval') {
@@ -129,16 +132,15 @@ async function performWebAutomation(query) {
                     currentObservation = `Error: Unknown action type "${action}".`;
                 }
             } catch (actionError) {
-                console.error("Action execution failed:", actionError);
+                console.error('Action execution failed:', actionError);
                 currentObservation = `Action failed: ${actionError.message}. Please try again or use another method (for instance, try a different CSS selector or just read the current page).`;
             }
         }
 
-        // Intentionally keeping the browser open
-        return "Agent reached maximum steps (10) without finding a final answer.";
+        return 'Agent reached maximum steps (10) without finding a final answer.';
 
     } catch (error) {
-        console.error("Web Automation Error:", error);
+        console.error('Web Automation Error:', error);
         if (browser) browser.close();
         return `I encountered an overall error while automating the browser: ${error.message}`;
     }

package/src/CLI/approval_handler.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const readline = require('readline');
+const { colors } = require('./cli_colors');
+
+/**
+ * Prompts the user in the terminal to approve or deny a code-agent action.
+ * Used by the non-interactive `mint code <task>` command.
+ *
+ * @param {{ type: string, label?: string, preview?: string }} request
+ * @returns {Promise<boolean>}  true = approved, false = denied
+ */
+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;
+}
+
+module.exports = { requestCodeApproval };

package/src/CLI/chat_ui.js

@@ -32,6 +32,127 @@ const SLASH_COMMANDS = [
     { cmd: '/exit', desc: 'Exit Mint' }
 ];
 
+const MAX_BLANK_LINES = 1;
+
+function compactPathLabel(value) {
+    const text = String(value || '').trim();
+    if (!text) return '';
+    return path.basename(text) || text;
+}
+
+function formatActivityStep(info = {}) {
+    if (!info || typeof info !== 'object') return null;
+
+    const { action, phase, target, message } = info;
+    const rawText = String(target || message || '').trim();
+    const kind = action || phase || 'activity';
+    if (!rawText) return null;
+
+    switch (kind) {
+        case 'list_files':
+            return { title: 'Explored', detail: `List ${rawText}` };
+        case 'find_path':
+            return { title: 'Explored', detail: `Find ${rawText}` };
+        case 'read_file':
+            return { title: 'Explored', detail: `Read ${compactPathLabel(rawText)}` };
+        case 'search_code':
+            return { title: 'Explored', detail: `Search ${rawText}` };
+        case 'web_search':
+            return { title: 'Searched', detail: rawText };
+        case 'warn':
+            return { title: '⚠ Notice', detail: rawText };
+        case 'run_shell':
+            return { title: 'Ran', detail: rawText };
+        case 'apply_patch':
+        case 'write_file':
+            return { title: 'Edited', detail: rawText };
+        case 'evaluator':
+            return { title: 'Checked', detail: rawText };
+        case 'reviewer_start':
+            return { title: 'Reviewing', detail: rawText };
+        case 'ask_user':
+            return { title: 'Ask User', detail: rawText };
+        default:
+            return { title: kind, detail: rawText };
+    }
+}
+
+function stripInlineMarkdown(value) {
+    return String(value || '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/\*([^*\n]+)\*/g, '$1')
+        .replace(/__([^_]+)__/g, '$1')
+        .replace(/`([^`\n]+)`/g, '$1');
+}
+
+function cleanDisplayText(text, role = 'assistant') {
+    const raw = String(text || '').replace(/\r\n/g, '\n').trim();
+    if (!raw) return '';
+
+    const shouldPolishMarkdown = role === 'assistant' || role === 'system';
+    const lines = raw.split('\n');
+    const cleaned = [];
+    let inCodeBlock = false;
+    let blankCount = 0;
+
+    for (const sourceLine of lines) {
+        let line = sourceLine.replace(/\s+$/g, '');
+        const fence = line.match(/^\s*```(.*)$/);
+
+        if (fence) {
+            inCodeBlock = !inCodeBlock;
+            const label = fence[1] ? `code: ${fence[1].trim()}` : 'code';
+            line = inCodeBlock ? label : '';
+        } else if (inCodeBlock) {
+            line = line ? `  ${line}` : '';
+        } else if (shouldPolishMarkdown) {
+            const heading = line.match(/^\s{0,3}#{1,6}\s+(.+)$/);
+            const bullet = line.match(/^(\s*)[-*]\s+(.+)$/);
+            const numbered = line.match(/^(\s*)\d+[.)]\s+(.+)$/);
+
+            if (heading) {
+                if (cleaned.length > 0 && cleaned[cleaned.length - 1] !== '') cleaned.push('');
+                line = stripInlineMarkdown(heading[1]).trim();
+            } else if (bullet) {
+                line = `${bullet[1]}• ${stripInlineMarkdown(bullet[2]).trim()}`;
+            } else if (numbered) {
+                line = `${numbered[1]}${stripInlineMarkdown(line).trim()}`;
+            } else {
+                line = stripInlineMarkdown(line);
+            }
+        }
+
+        if (!line.trim()) {
+            blankCount++;
+            if (blankCount <= MAX_BLANK_LINES && cleaned.length > 0) cleaned.push('');
+            continue;
+        }
+
+        blankCount = 0;
+        cleaned.push(line);
+    }
+
+    while (cleaned[0] === '') cleaned.shift();
+    while (cleaned[cleaned.length - 1] === '') cleaned.pop();
+    return cleaned.join('\n');
+}
+
+function formatDuration(totalSeconds) {
+    const seconds = Math.max(0, Math.floor(Number(totalSeconds) || 0));
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+
+    if (minutes <= 0) return `${remainingSeconds}s`;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+
+function shouldAppendMessage(role, text) {
+    if (role === 'assistant' || role === 'system') {
+        return String(text || '').trim().length > 0;
+    }
+    return true;
+}
+
 /**
  * We wrap everything in an async function to load ESM modules
  */
@@ -48,6 +169,7 @@ async function createChatUI(options) {
         const [history, setHistory] = useState(initialHistory);
         const [liveAssistant, setLiveAssistant] = useState(null);
         const [thinking, setThinking] = useState(false);
+        const [workingSeconds, setWorkingSeconds] = useState(0);
         const [fastMode, setFastMode] = useState(false);
         const [mode, setMode] = useState('Agent');
         const [model, setModel] = useState('');
@@ -67,6 +189,7 @@ async function createChatUI(options) {
         const pendingPasteRef = React.useRef(pendingPaste);
         const pendingPastePrefixRef = React.useRef(pendingPastePrefix);
         const liveAssistantRef = React.useRef(liveAssistant);
+        const thinkingStartedAtRef = React.useRef(null);
         const fastModeRef = React.useRef(fastMode);
         const suppressPasteCharRef = React.useRef(false);
         const selectedIndexRef = React.useRef(selectedIndex);
@@ -111,6 +234,17 @@ async function createChatUI(options) {
             liveAssistantRef.current = liveAssistant;
         }, [liveAssistant]);
 
+        useEffect(() => {
+            if (!thinking) return undefined;
+
+            const timer = setInterval(() => {
+                if (!thinkingStartedAtRef.current) return;
+                setWorkingSeconds(Math.floor((Date.now() - thinkingStartedAtRef.current) / 1000));
+            }, 1000);
+
+            return () => clearInterval(timer);
+        }, [thinking]);
+
         useEffect(() => {
             fastModeRef.current = fastMode;
         }, [fastMode]);
@@ -148,6 +282,7 @@ async function createChatUI(options) {
         // Export methods to the outside world via ref
         useImperativeHandle(ref, () => ({
             appendMessage: (role, text, metadata = {}) => {
+                if (!shouldAppendMessage(role, text)) return;
                 setHistory(prev => [...prev, { role, text, time: new Date(), ...metadata }]);
                 if (metadata.providerInfo) {
                     const { provider, model } = metadata.providerInfo;
@@ -164,6 +299,7 @@ async function createChatUI(options) {
                 }
             },
             appendAssistantStreamChunk: (chunk) => {
+                if (!String(chunk || '').trim()) return;
                 const current = liveAssistantRef.current || { role: 'assistant', text: '', time: new Date() };
                 const next = { ...current, text: `${current.text || ''}${chunk}` };
                 liveAssistantRef.current = next;
@@ -177,7 +313,21 @@ async function createChatUI(options) {
                     setHistory(prev => [...prev, current]);
                 }
             },
-            setThinking: (val) => setThinking(val),
+            setThinking: (val, seconds = 0) => {
+                if (val) {
+                    const elapsed = Number.isFinite(seconds) ? Math.max(0, seconds) : 0;
+                    if (!thinkingStartedAtRef.current) {
+                        thinkingStartedAtRef.current = Date.now() - (elapsed * 1000);
+                    }
+                    setWorkingSeconds(Math.floor((Date.now() - thinkingStartedAtRef.current) / 1000));
+                    setThinking(true);
+                    return;
+                }
+
+                thinkingStartedAtRef.current = null;
+                setWorkingSeconds(0);
+                setThinking(false);
+            },
             setMode: (val) => setMode(val),
             setFastMode: (val) => {
                 const next = Boolean(val);
@@ -230,6 +380,9 @@ async function createChatUI(options) {
                         return;
                     }
                     if (thought) {
+                        if (process.env.MINT_SHOW_THINKING_TRACE !== '1') {
+                            return;
+                        }
                         text = thought;
                         label = 'Thinking';
                         labelColor = 'gray';
@@ -237,6 +390,25 @@ async function createChatUI(options) {
                     } else if (action === 'thinking' || phase === 'thinking') {
                         return;
                     } else {
+                        const activity = formatActivityStep(info);
+                        if (activity) {
+                            const fullText = `[${activity.title}] ${activity.detail}`;
+                            if (fullText === lastSystemMessage.current) return;
+                            lastSystemMessage.current = fullText;
+
+                            setHistory(prev => [...prev, {
+                                role: 'system',
+                                label: activity.title,
+                                labelColor: 'blueBright',
+                                text: activity.detail,
+                                isActivity: true,
+                                activityTitle: activity.title,
+                                activityDetail: activity.detail,
+                                time: new Date()
+                            }]);
+                            return;
+                        }
+
                         label = action || phase || 'Action';
                         text = target || message || '';
                         if (!text) return;
@@ -474,6 +646,19 @@ async function createChatUI(options) {
                 );
             }
 
+            if (msg.isActivity) {
+                return h(Box, { key: `${keyPrefix}-${index}`, flexDirection: 'column', marginBottom: 0 },
+                    h(Box, null,
+                        h(Text, { color: 'greenBright' }, '• '),
+                        h(Text, { bold: true, color: msg.labelColor || 'blueBright' }, msg.activityTitle || msg.label || 'Activity')
+                    ),
+                    h(Box, { paddingLeft: 2, marginBottom: 1 },
+                        h(Text, { color: 'gray' }, '└ '),
+                        h(Text, { color: 'cyanBright', wrap: 'wrap' }, msg.activityDetail || msg.text)
+                    )
+                );
+            }
+
             let name = 'Mint';
             let nameColor = 'greenBright';
 
@@ -494,7 +679,7 @@ async function createChatUI(options) {
                     h(Text, { color: 'gray' }, ` ${msg.time instanceof Date ? msg.time.toLocaleTimeString() : ''}`)
                 ),
                 h(Box, { paddingLeft: 2, marginBottom: 1 },
-                    h(Text, null, msg.text)
+                    h(Text, { wrap: 'wrap' }, cleanDisplayText(msg.text, msg.role))
                 )
             );
         };
@@ -506,7 +691,8 @@ async function createChatUI(options) {
 
             // Floating (Persistent) UI part
             h(Box, { flexDirection: 'column' },
-                thinking && h(Box, { marginBottom: 1 },
+                thinking && h(Box, { flexDirection: 'column', marginBottom: 1 },
+                    h(Text, { color: 'gray', dimColor: true }, `─ Working for ${formatDuration(workingSeconds)} ─────────────────────────────────────────────────────────`),
                     h(Text, { color: 'yellow' }, '● Mint is thinking...')
                 ),
 
@@ -607,7 +793,7 @@ async function createChatUI(options) {
 
     return {
         appendMessage: (role, text, metadata) => ref.current?.appendMessage(role, text, metadata),
-        setThinking: (val) => ref.current?.setThinking(val),
+        setThinking: (val, seconds) => ref.current?.setThinking(val, seconds),
         setMode: (val) => ref.current?.setMode(val),
         setFastMode: (val) => ref.current?.setFastMode(val),
         toggleFastMode: () => ref.current?.toggleFastMode(),
@@ -619,11 +805,10 @@ async function createChatUI(options) {
         attachImage: (image) => ref.current?.attachImage(image),
         appendCodeStep: (info) => ref.current?.appendCodeStep(info),
         streamMessage: (metadata = {}) => {
-            let fullText = '';
             ref.current?.beginAssistantStream(metadata);
             return {
                 appendChunk: (chunk) => {
-                    fullText += chunk;
+                    if (!String(chunk || '').trim()) return;
                     ref.current?.appendAssistantStreamChunk(chunk);
                 },
                 finalize: () => {
@@ -637,4 +822,4 @@ async function createChatUI(options) {
     };
 }
 
-module.exports = { createChatUI };
+module.exports = { createChatUI, _helpers: { cleanDisplayText, stripInlineMarkdown, compactPathLabel, formatActivityStep, formatDuration, shouldAppendMessage } };

package/src/CLI/cli_colors.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * ANSI color constants for Mint CLI output.
+ */
+const colors = {
+    reset:  '\x1b[0m',
+    bright: '\x1b[1m',
+    mint:   '\x1b[38;5;121m',
+    pink:   '\x1b[38;5;213m',
+    gray:   '\x1b[90m',
+    cyan:   '\x1b[36m',
+    yellow: '\x1b[33m'
+};
+
+let isExiting = false;
+
+/**
+ * Restore terminal state, print goodbye, and exit.
+ * @param {number} [code=0]
+ */
+function exitWithGoodbye(code = 0) {
+    if (isExiting) return;
+    isExiting = true;
+
+    process.stdout.write('\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l');
+    process.stdout.write('\x1b[?25h');
+    console.log(`\n${colors.pink}Goodbye! See you again soon!${colors.reset}\n`);
+    process.exit(code);
+}
+
+module.exports = { colors, exitWithGoodbye };