@pheem49/mint 1.5.0 → 1.5.2

package/mint-cli.js

@@ -1,35 +1,50 @@
 #!/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')) {
+    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, 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');
-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');
+
+// ── CLI modules ──────────────────────────────────────────────────────────────
+const { colors, exitWithGoodbye }        = require('./src/CLI/cli_colors');
+const { formatProgress }                 = require('./src/CLI/cli_formatters');
+const { startInteractiveChat }           = require('./src/CLI/interactive_chat');
+const { requestCodeApproval }            = require('./src/CLI/approval_handler');
+const { learnSkillFile }                 = require('./src/CLI/skill_manager');
+
+// ── Feature / system modules ────────────────────────────────────────────────
+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 memoryStore                        = require('./src/AI_Brain/memory_store');
 const { runUpdate, runStartupAutoUpdate, shouldRunAutoUpdate } = require('./src/CLI/updater');
-const { runGmailAuth } = require('./src/CLI/gmail_auth');
+const { runGmailAuth }                   = require('./src/CLI/gmail_auth');
+const { loadImageAsDataUri }             = require('./src/CLI/image_input');
+const { summarizeRepository, formatRepoSummary } = require('./src/CLI/repo_summarizer');
+const { buildSymbolIndex, formatSymbolIndex }    = require('./src/CLI/symbol_indexer');
+const {
+    indexSemanticCode,
+    searchSemanticCode,
+    formatSemanticCodeIndex,
+    formatSemanticCodeSearch
+} = require('./src/CLI/semantic_code_search');
+
+const pkg = require('./package.json');
 
-// Startup Info
-const startupConfig = readConfig();
+// ── Startup banner ───────────────────────────────────────────────────────────
+const startupConfig   = readConfig();
 const startupProvider = startupConfig.aiProvider || 'gemini';
-const startupModel = startupProvider === 'openai'
+const startupModel    = startupProvider === 'openai'
     ? (startupConfig.openaiModel || 'gpt-4o')
     : startupProvider === 'anthropic'
         ? (startupConfig.anthropicModel || 'claude-3-5-sonnet-latest')
@@ -38,56 +53,17 @@ const startupModel = startupProvider === 'openai'
             : startupProvider === 'ollama'
                 ? (startupConfig.ollamaModel || 'llama3:latest')
                 : (startupConfig.geminiModel || 'gemini-2.5-flash');
-const startupNow = new Date();
-const startupTime = startupNow.toLocaleString('th-TH', { 
-    day: '2-digit', month: '2-digit', year: 'numeric', 
-    hour: '2-digit', minute: '2-digit', hour12: false 
-}).replace(',', '');
-console.log(`\x1b[38;5;121m[Mint] v${pkg.version} | ${startupTime} | Active AI: ${startupProvider} • ${startupModel}\x1b[0m`);
-
-// ANSI Colors
-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"
-};
-
-function formatProgress(info) {
-    if (typeof info === 'string') return `${colors.gray}[Mint Code] ${info}${colors.reset}`;
 
-    const { step, phase, action, target, message } = info;
-    
-    if (action === 'ask_user') {
-        return `\n${colors.mint}✓${colors.reset} ${colors.bright}Ask User${colors.reset}\n${colors.gray}   ${target || message || ''}${colors.reset}`;
-    }
-
-    let icon = `${colors.mint}✓${colors.reset}`;
-    let label = action || phase;
-    let color = colors.reset;
-
-    switch (action) {
-        case 'thinking': 
-            return `\n${colors.yellow}* ${colors.bright}Thinking${colors.reset}`;
-        case 'web_search': label = 'WebSearch'; break;
-        case 'list_files':
-        case 'find_path': label = 'Explored'; break;
-        case 'read_file': label = 'ReadFile'; break;
-        case 'search_code': label = 'SearchText'; break;
-        case 'apply_patch':
-        case 'write_file': label = 'Edited'; break;
-        case 'run_shell': label = 'Ran command'; break;
-        case 'json_repair': icon = '*'; label = 'Repairing JSON'; break;
-        case 'reviewer_start': label = 'Reviewing'; break;
-    }
+const startupNow  = new Date();
+const startupTime = startupNow.toLocaleString('th-TH', {
+    day: '2-digit', month: '2-digit', year: 'numeric',
+    hour: '2-digit', minute: '2-digit', hour12: false
+}).replace(',', '');
+console.log(`${colors.mint}[Mint] v${pkg.version} | ${startupTime} | Active AI: ${startupProvider} • ${startupModel}${colors.reset}`);
 
-    const content = target || message || '';
-    return ` ${icon} ${colors.bright}${label}${colors.reset} ${color}${content}${colors.reset}`;
-}
+process.once('SIGINT', () => exitWithGoodbye(0));
 
+// ── Commander program ────────────────────────────────────────────────────────
 const program = new Command();
 
 program
@@ -95,20 +71,11 @@ program
     .description('Mint - Your Personal AI Assistant CLI')
     .version(pkg.version);
 
+// Auto-update hook
 program.hook('preAction', async (thisCommand, actionCommand) => {
-    if (actionCommand.name() === 'update' || process.env.MINT_SKIP_AUTO_UPDATE === '1') {
-        return;
-    }
-
+    if (actionCommand.name() === 'update' || process.env.MINT_SKIP_AUTO_UPDATE === '1') return;
     const config = readConfig();
-    if (config.enableAutoUpdate === false) {
-        return;
-    }
-
-    if (!shouldRunAutoUpdate(config)) {
-        return;
-    }
-
+    if (config.enableAutoUpdate === false || !shouldRunAutoUpdate(config)) return;
     console.log(`${colors.gray}[Mint Update] Checking for updates...${colors.reset}`);
     const result = await runStartupAutoUpdate(config, writeConfig);
     if (result.status === 'updated') {
@@ -118,16 +85,17 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
     }
 });
 
-// Chat Command (Interactive Mode)
+// ── Commands ─────────────────────────────────────────────────────────────────
+
 program
     .command('chat', { isDefault: true })
     .description('Start interactive chat session with Mint')
     .argument('[message]', 'Initial message to send to Mint')
-    .action(async (message) => {
-        await startInteractiveChat(message);
+    .option('-i, --image <path>', 'Attach an image file to the initial message')
+    .action(async (message, options) => {
+        await startInteractiveChat(message, { imagePath: options.image });
     });
 
-// Onboard Command
 program
     .command('onboard')
     .description('Setup Mint for the first time')
@@ -136,7 +104,6 @@ program
         await runOnboarding(options);
     });
 
-// Agent Command (Headless Daemon Mode)
 program
     .command('agent')
     .description('Run Mint as a background agent (headless)')
@@ -150,15 +117,135 @@ program
         await startAgent();
     });
 
-// List Command
 program
     .command('list')
     .description('Show list of Mint features and commands')
-    .action(() => {
-        displayFeatures();
+    .action(() => displayFeatures());
+
+program
+    .command('summarize')
+    .alias('summary')
+    .description('Summarize a repository structure, tooling, git state, and key files')
+    .argument('[path]', 'Repository path to summarize', process.cwd())
+    .option('--json', 'Print raw JSON summary')
+    .action((targetPath, options) => {
+        try {
+            const summary = summarizeRepository(targetPath);
+            if (options.json) { console.log(JSON.stringify(summary, null, 2)); return; }
+            console.log(`\n${formatRepoSummary(summary)}\n`);
+        } catch (error) {
+            console.error(`\n${colors.pink}Summarize failed:${colors.reset} ${error.message}\n`);
+            process.exitCode = 1;
+        }
+    });
+
+program
+    .command('symbols')
+    .alias('symbol-index')
+    .description('Build a source symbol index for the current repository')
+    .argument('[path]', 'Repository path to index', process.cwd())
+    .option('--json', 'Print raw JSON symbol index')
+    .option('--limit <count>', 'Limit formatted symbols shown', value => Number(value), 80)
+    .action((targetPath, options) => {
+        try {
+            const index = buildSymbolIndex(targetPath);
+            if (options.json) { console.log(JSON.stringify(index, null, 2)); return; }
+            console.log(`\n${formatSymbolIndex(index, { limit: options.limit })}\n`);
+        } catch (error) {
+            console.error(`\n${colors.pink}Symbol index failed:${colors.reset} ${error.message}\n`);
+            process.exitCode = 1;
+        }
+    });
+
+const semanticCodeCommand = program
+    .command('semantic-code')
+    .alias('semantic')
+    .description('Index and search source code semantically with embeddings');
+
+semanticCodeCommand
+    .command('index')
+    .description('Create embeddings for source code chunks in a repository')
+    .argument('[path]', 'Repository path to index', process.cwd())
+    .option('--json', 'Print raw JSON index metadata')
+    .action(async (targetPath, options) => {
+        try {
+            const index = await indexSemanticCode(targetPath, {
+                onProgress: (info) => {
+                    if (info.current === 1 || info.current === info.total || info.current % 25 === 0) {
+                        console.log(`${colors.gray}[Semantic Code] Embedded ${info.current}/${info.total}: ${info.file}${colors.reset}`);
+                    }
+                }
+            });
+            if (options.json) { console.log(JSON.stringify(index, null, 2)); return; }
+            console.log(`\n${formatSemanticCodeIndex(index)}\n`);
+        } catch (error) {
+            console.error(`\n${colors.pink}Semantic code index failed:${colors.reset} ${error.message}\n`);
+            process.exitCode = 1;
+        }
+    });
+
+semanticCodeCommand
+    .command('search')
+    .description('Search an existing semantic code index')
+    .argument('<query...>', 'Natural language code search query')
+    .option('--path <path>', 'Repository path to search', process.cwd())
+    .option('--json', 'Print raw JSON search results')
+    .option('--top-k <count>', 'Number of results to return', value => Number(value), 5)
+    .action(async (query, options) => {
+        try {
+            const results = await searchSemanticCode(query.join(' '), options.path, { topK: options.topK });
+            if (options.json) { console.log(JSON.stringify(results, null, 2)); return; }
+            console.log(`\n${formatSemanticCodeSearch(results)}\n`);
+        } catch (error) {
+            console.error(`\n${colors.pink}Semantic code search failed:${colors.reset} ${error.message}\n`);
+            process.exitCode = 1;
+        }
+    });
+
+program
+    .command('learn')
+    .description('Read a local markdown/text file and remember it as a Mint skill')
+    .argument('[filePath]', 'Path to a .md or .txt skill/instruction file')
+    .option('--delete <idOrPathOrName>', 'Delete a learned skill by id, path, or name')
+    .option('--list', 'List learned skills')
+    .action((filePath, options) => {
+        try {
+            if (options.list) {
+                const skills = memoryStore.getLearnedSkills(50);
+                if (skills.length === 0) { console.log(`\n${colors.gray}No learned skills stored.${colors.reset}\n`); return; }
+                console.log(`\n${colors.bright}Learned Skills:${colors.reset}`);
+                skills.forEach(skill => {
+                    console.log(`${colors.mint}#${skill.id}${colors.reset} ${skill.name}`);
+                    console.log(`  ${colors.gray}${skill.source_path}${colors.reset}`);
+                });
+                console.log('');
+                return;
+            }
+            if (options.delete) {
+                const deleted = memoryStore.deleteLearnedSkill(options.delete);
+                if (deleted > 0) {
+                    console.log(`\n${colors.mint}✓${colors.reset} Deleted learned skill: ${options.delete}\n`);
+                } else {
+                    console.log(`\n${colors.pink}✗${colors.reset} Learned skill not found: ${options.delete}\n`);
+                    process.exitCode = 1;
+                }
+                return;
+            }
+            if (!filePath) throw new Error('Usage: mint learn <path-to-skill.md>');
+
+            const learned = learnSkillFile(filePath);
+            console.log(`\n${colors.mint}✓${colors.reset} Learned skill: ${learned.name}`);
+            console.log(`${colors.gray}Path: ${learned.source_path}${colors.reset}`);
+            if (learned.stored_length < learned.content_length) {
+                console.log(`${colors.gray}Stored first ${learned.stored_length} of ${learned.content_length} characters.${colors.reset}`);
+            }
+            console.log('');
+        } catch (error) {
+            console.error(`\n${colors.pink}Learn failed:${colors.reset} ${error.message}\n`);
+            process.exitCode = 1;
+        }
     });
 
-// Task Command (Autonomous Background Task)
 program
     .command('task')
     .description('Delegate a complex task to the background agent')
@@ -176,23 +263,18 @@ program
 program
     .command('update')
     .description('Check for and install the latest Mint CLI version from npm')
-    .option('--check', 'Only check whether an update is available')
+    .option('--check',   'Only check whether an update is available')
     .option('--dry-run', 'Show the npm update operation without installing')
     .action(async (options) => {
         console.log(`\n${colors.mint}${colors.bright}[Mint Update]${colors.reset} Checking npm for updates...`);
-
         try {
             const result = await runUpdate({
-                checkOnly: options.check === true,
-                dryRun: options.dryRun === true
+                checkOnly: options.check   === true,
+                dryRun:    options.dryRun  === true
             });
-
             const color = result.status === 'error' ? colors.pink : colors.mint;
             console.log(`${color}${result.message}${colors.reset}\n`);
-
-            if (result.status === 'error') {
-                process.exitCode = 1;
-            }
+            if (result.status === 'error') process.exitCode = 1;
         } catch (error) {
             console.error(`${colors.pink}Update failed: ${error.message}${colors.reset}\n`);
             process.exitCode = 1;
@@ -204,28 +286,21 @@ program
     .description('Manage MCP (Model Context Protocol) servers')
     .addCommand(new Command('add')
         .description('Add a new MCP server')
-        .argument('<name>', 'Server name')
+        .argument('<name>',    'Server name')
         .argument('<command>', 'Command to run (e.g. npx)')
         .option('-a, --args <args...>', 'Command arguments')
-        .option('-e, --env <env...>', 'Environment variables (KEY=VALUE)')
+        .option('-e, --env <env...>',   'Environment variables (KEY=VALUE)')
         .action((name, command, options) => {
-            const config = readConfig();
+            const config     = readConfig();
             const mcpServers = config.mcpServers || {};
-            
-            const env = {};
+            const env        = {};
             if (options.env) {
                 options.env.forEach(kv => {
                     const [k, v] = kv.split('=');
                     if (k && v) env[k] = v;
                 });
             }
-
-            mcpServers[name] = {
-                command,
-                args: options.args || [],
-                env
-            };
-
+            mcpServers[name] = { command, args: options.args || [], env };
             config.mcpServers = mcpServers;
             writeConfig(config);
             console.log(`\n${colors.mint}✓${colors.reset} MCP server "${name}" added successfully.`);
@@ -248,7 +323,7 @@ program
     .addCommand(new Command('list')
         .description('List configured MCP servers')
         .action(() => {
-            const config = readConfig();
+            const config  = readConfig();
             const servers = Object.keys(config.mcpServers || {});
             if (servers.length === 0) {
                 console.log(`\n${colors.gray}No MCP servers configured.${colors.reset}`);
@@ -278,13 +353,13 @@ program
     .addCommand(new Command('auth')
         .description('Open Google OAuth login and save a Gmail refresh token')
         .option('--port <port>', 'Local callback port, defaults to a random available port')
-        .option('--no-open', 'Print the auth link without opening a browser')
+        .option('--no-open',     'Print the auth link without opening a browser')
         .action(async (options) => {
             try {
                 const result = await runGmailAuth({
-                    port: options.port ? Number(options.port) : 0,
+                    port:        options.port ? Number(options.port) : 0,
                     openBrowser: options.open,
-                    logger: console
+                    logger:      console
                 });
                 console.log(`\n${colors.mint}✓${colors.reset} Gmail connected for ${result.userId}. Refresh token saved.`);
                 console.log(`${colors.gray}Scopes: ${result.scopes.join(', ')}${colors.reset}\n`);
@@ -299,16 +374,22 @@ 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) => {
+    .option('-i, --image <path>', 'Attach an image file as context for the coding task')
+    .action(async (task, options) => {
         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 {
+            let image = null;
+            if (options.image) {
+                image = loadImageAsDataUri(options.image);
+                console.log(`${colors.gray}[Mint Code] Image: ${image.path}${colors.reset}`);
+            }
+            console.log(`${colors.gray}[Mint Code] Task: ${task}${colors.reset}\n`);
+
             const result = await executeCodeTask(task, {
-                cwd: process.cwd(),
-                onProgress: (info) => {
-                    console.log(formatProgress(info));
-                },
+                cwd:           process.cwd(),
+                imageDataUri:  image ? image.dataUri : null,
+                imagePath:     image ? image.path    : null,
+                onProgress:    (info) => console.log(formatProgress(info)),
                 requestApproval: requestCodeApproval
             });
 
@@ -322,388 +403,8 @@ program
         }
     });
 
+// ── Parse ────────────────────────────────────────────────────────────────────
 program.parseAsync(process.argv).catch((error) => {
     console.error(`${colors.pink}${error.message}${colors.reset}`);
     process.exitCode = 1;
 });
-
-/**
- * The Interactive Chat Loop — Gemini-style TUI
- */
-async function startInteractiveChat(initialMessage = null) {
-    let lastResponseText = "";
-    const formatErrorMessage = (err) => err && err.message ? err.message : String(err || 'Unknown error');
-    
-    const ui = await createChatUI({
-        onSubmit: async (text) => {
-            const { screen, appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode, appendCodeStep, updateWorkspace, askUser } = ui;
-            if (text.startsWith('/')) {
-                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 if (subCmd === 'use' || subCmd === 'switch') {
-                        const name = args[2];
-                        const all = workspaceManager.listWorkspaces();
-                        if (all[name]) {
-                            const newPath = all[name].path;
-                            try {
-                                process.chdir(newPath);
-                                updateWorkspace(newPath);
-                                appendMessage('system', `✓ Switched to workspace "${name}" at ${newPath}`);
-                                resetChat();
-                            } catch (e) {
-                                appendMessage('error', `Failed to change directory: ${e.message}`);
-                            }
-                        } else {
-                            appendMessage('error', `Workspace "${name}" not found. Try /workspace list`);
-                        }
-                    } else {
-                        const ws = workspaceManager.getWorkspaceByPath(process.cwd());
-                        appendMessage('system', ws ? `Current Workspace: ${ws.name}\nPath: ${ws.path}` : `Not currently in a registered workspace.\nActive Path: ${process.cwd()}\nUsage: /workspace <add|use|list|remove>`);
-                    }
-                    return;
-                }
-
-                if (text.startsWith('/review')) {
-                    if (!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, appendCodeStep, updateWorkspace);
-                    return;
-                }
-            }
-            appendMessage('user', text);
-
-            const transcript = await getChatTranscript();
-            if (setMode) setMode('Agent');
-
-            let seconds = 0;
-            setThinking(true, seconds);
-            const timer = setInterval(() => {
-                seconds++;
-                setThinking(true, seconds);
-            }, 1000);
-
-            try {
-                const config = require('./src/System/config_manager').readConfig();
-                const availableProviders = require('./src/System/config_manager').getAvailableProviders(config);
-                const preferredProvider = require('./src/CLI/code_agent')._helpers.selectSupportedCodeProvider(config, availableProviders);
-
-                const result = await executeCodeTask(text, {
-                    cwd: process.cwd(),
-                    requestApproval,
-                    askUser,
-                    provider: preferredProvider,
-                    history: transcript,
-                    onProgress: (info) => {
-                        if (appendCodeStep) appendCodeStep(info);
-                    }
-                });
-
-                clearInterval(timer);
-                setThinking(false);
-                lastResponseText = result.summary;
-                appendMessage('assistant', result.summary, { providerInfo: result.providerInfo });
-
-            } catch (err) {
-                clearInterval(timer);
-                setThinking(false);
-                appendMessage('error', formatErrorMessage(err));
-            } finally {
-                if (setMode) setMode('Chat');
-            }
-        },
-        onExit: () => {
-            // Explicitly restore terminal state and disable ALL mouse tracking modes
-            process.stdout.write('\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l'); 
-            process.stdout.write('\x1b[?25h');   // Show cursor
-            console.log(`\n${colors.pink}Goodbye! See you again soon!${colors.reset}\n`);
-            process.exit(0);
-        }
-    });
-
-    // Handle initial message if passed via CLI arg
-    if (initialMessage) {
-        const { appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode, appendCodeStep, updateWorkspace, askUser } = ui;
-        appendMessage('user', initialMessage);
-        const transcript = await getChatTranscript();
-        if (setMode) setMode('Agent');
-
-        let seconds = 0;
-        setThinking(true, seconds);
-        const timer = setInterval(() => {
-            seconds++;
-            setThinking(true, seconds);
-        }, 1000);
-
-        try {
-            const config = require('./src/System/config_manager').readConfig();
-            const availableProviders = require('./src/System/config_manager').getAvailableProviders(config);
-            const preferredProvider = require('./src/CLI/code_agent')._helpers.selectSupportedCodeProvider(config, availableProviders);
-
-            const result = await executeCodeTask(initialMessage, {
-                cwd: process.cwd(),
-                requestApproval,
-                askUser,
-                provider: preferredProvider,
-                history: transcript,
-                onProgress: (info) => {
-                    if (appendCodeStep) appendCodeStep(info);
-                }
-            });
-
-            clearInterval(timer);
-            setThinking(false);
-            lastResponseText = result.summary;
-            appendMessage('assistant', result.summary, { providerInfo: result.providerInfo });
-
-        } catch (err) {
-            clearInterval(timer);
-            setThinking(false);
-            appendMessage('error', formatErrorMessage(err));
-        } finally {
-            if (setMode) setMode('Chat');
-        }
-    }
-}
-
-/**
- * Handles slash commands within the TUI context
- */
-async function handleSlashCommandUI(input, appendMessage, updateStatusModel, copyLastResponse, setThinking, requestApproval, setMode, appendCodeStep, updateWorkspace) {
-    const parts = input.split(' ');
-    const command = parts[0].toLowerCase();
-    const args = parts.slice(1);
-
-    switch (command) {
-        case '/help':
-        case '/?':
-            appendMessage('system', [
-                'Mint Slash Commands:',
-                '  /code <task>      — Force workspace Code Mode',
-                '  /cd <path>        — Change current working directory',
-                '  /models [name]   — List or switch Gemini models',
-                '  /config          — Show current configuration',
-                '  /copy            — Copy last response to clipboard',
-                '  /clear           — Clear conversation history',
-                '  /reset           — Reset conversation history',
-                '  /exit            — Exit Mint'
-            ].join('\n'));
-            break;
-
-        case '/cd':
-            if (args.length === 0) {
-                appendMessage('system', `Current Directory: ${process.cwd()}`);
-                break;
-            }
-            try {
-                const newPath = path.resolve(process.cwd(), args[0]);
-                if (fs.existsSync(newPath) && fs.lstatSync(newPath).isDirectory()) {
-                    process.chdir(newPath);
-                    if (updateWorkspace) updateWorkspace(newPath);
-                    appendMessage('system', `✓ Directory changed to: ${newPath}`);
-                } else {
-                    appendMessage('error', `Directory not found: ${newPath}`);
-                }
-            } catch (err) {
-                appendMessage('error', `Error: ${err.message}`);
-            }
-            break;
-
-        case '/model':
-        case '/models':
-            const config = readConfig();
-            if (args.length === 0) {
-                appendMessage('system', [
-                    `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') {
-                    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 {
-                    newProvider = 'gemini';
-                    config.geminiModel = newModel;
-                }
-                
-                config.aiProvider = newProvider;
-                writeConfig(config);
-                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,
-                appendCodeStep,
-                setMode,
-                askUser: () => Promise.resolve(''),
-                history: await getChatTranscript()
-            });
-            break;
-
-        case '/config':
-            const currentCfg = readConfig();
-            appendMessage('system', [
-                'Current Configuration:',
-                `  Version   : v${pkg.version}`,
-                `  Provider  : ${currentCfg.aiProvider}`,
-                `  Model     : ${currentCfg.geminiModel}`,
-                `  Ollama    : ${currentCfg.ollamaModel}`,
-                `  Voice     : ${currentCfg.enableVoiceReply ? 'ON' : 'OFF'}`,
-                `  Language  : ${currentCfg.language}`,
-                `  API Key   : ${currentCfg.apiKey ? 'SET (****)' : 'NOT SET'}`
-            ].join('\n'));
-            break;
-
-        case '/copy':
-            if (copyLastResponse && copyLastResponse()) {
-                appendMessage('system', '✓ Last response copied to clipboard.');
-            } else {
-                appendMessage('system', '✖ Nothing to copy, or xclip/xsel not installed.');
-            }
-            break;
-
-        case '/clear':
-        case '/reset':
-            resetChat();
-            appendMessage('system', 'Conversation history cleared.');
-            break;
-
-        case '/exit':
-        case '/quit':
-            process.exit(0);
-            break;
-
-        default:
-            appendMessage('system', `Unknown command: ${command}. Type /help for options.`);
-    }
-}
-
-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;
-}