@pheem49/mint 1.4.1 → 1.5.0

package/mint-cli-logic.js

@@ -2,14 +2,23 @@
 const { openApp } = require('./src/Automation_Layer/open_app');
 const { openWebsite, openSearch } = require('./src/Automation_Layer/open_website');
 const { createFolder, openFile, deleteFile, findPath } = require('./src/Automation_Layer/file_operations');
-const { indexFile } = require('./src/AI_Brain/knowledge_base');
-const SystemAutomation = require('./src/System/system_automation');
-const pluginManager = require('./src/Plugins/plugin_manager');
+const safetyManager = require('./src/System/safety_manager');
 
-async function executeAction(action) {
+async function executeAction(action, options = {}) {
     if (!action || action.type === 'none') return null;
 
     try {
+        const safety = safetyManager.assertActionAllowed(action, {
+            allowDangerous: options.allowDangerous === true
+        });
+        safetyManager.appendActionLog({
+            source: options.source || 'mint_cli_logic',
+            action: action.type,
+            target: action.target || action.path || '',
+            tier: safety.tier,
+            approved: options.allowDangerous === true || safety.tier !== safetyManager.TIERS.DANGEROUS
+        });
+
         switch (action.type) {
             case 'open_url':
                 openWebsite(action.target);
@@ -24,11 +33,9 @@ async function executeAction(action) {
                 createFolder(action.target);
                 return `Created folder: ${action.target}`;
             case 'open_file':
-                await openFile(action.target);
-                return `Opening: ${action.target}`;
             case 'open_folder':
-                await openFile(action.target);
-                return `Opening folder: ${action.target}`;
+                const res = await openFile(action.target);
+                return res === true ? `Opening: ${action.target}` : res;
             case 'delete_file':
                 await deleteFile(action.target);
                 return `Deleted: ${action.target}`;

package/mint-cli.js

@@ -23,16 +23,27 @@ 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');
+const { runUpdate, runStartupAutoUpdate, shouldRunAutoUpdate } = require('./src/CLI/updater');
+const { runGmailAuth } = require('./src/CLI/gmail_auth');
 
 // Startup Info
 const startupConfig = readConfig();
-const startupModel = startupConfig.geminiModel || 'gemini-2.5-flash';
+const startupProvider = startupConfig.aiProvider || 'gemini';
+const startupModel = startupProvider === 'openai'
+    ? (startupConfig.openaiModel || 'gpt-4o')
+    : startupProvider === 'anthropic'
+        ? (startupConfig.anthropicModel || 'claude-3-5-sonnet-latest')
+        : startupProvider === 'local_openai'
+            ? (startupConfig.localModelName || 'local-model')
+            : 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 Model: ${startupModel}\x1b[0m`);
+console.log(`\x1b[38;5;121m[Mint] v${pkg.version} | ${startupTime} | Active AI: ${startupProvider} • ${startupModel}\x1b[0m`);
 
 // ANSI Colors
 const colors = {
@@ -45,13 +56,68 @@ const colors = {
     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 content = target || message || '';
+    return ` ${icon} ${colors.bright}${label}${colors.reset} ${color}${content}${colors.reset}`;
+}
+
 const program = new Command();
 
 program
-    .name('mint-ai')
+    .name('mint')
     .description('Mint - Your Personal AI Assistant CLI')
     .version(pkg.version);
 
+program.hook('preAction', async (thisCommand, actionCommand) => {
+    if (actionCommand.name() === 'update' || process.env.MINT_SKIP_AUTO_UPDATE === '1') {
+        return;
+    }
+
+    const config = readConfig();
+    if (config.enableAutoUpdate === false) {
+        return;
+    }
+
+    if (!shouldRunAutoUpdate(config)) {
+        return;
+    }
+
+    console.log(`${colors.gray}[Mint Update] Checking for updates...${colors.reset}`);
+    const result = await runStartupAutoUpdate(config, writeConfig);
+    if (result.status === 'updated') {
+        console.log(`${colors.mint}[Mint Update] ${result.message}${colors.reset}`);
+    } else if (result.status === 'error') {
+        console.log(`${colors.gray}[Mint Update] ${result.message}${colors.reset}`);
+    }
+});
+
 // Chat Command (Interactive Mode)
 program
     .command('chat', { isDefault: true })
@@ -107,6 +173,128 @@ program
         console.log(`${colors.gray}You will receive a notification when it's done.${colors.reset}\n`);
     });
 
+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('--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
+            });
+
+            const color = result.status === 'error' ? colors.pink : colors.mint;
+            console.log(`${color}${result.message}${colors.reset}\n`);
+
+            if (result.status === 'error') {
+                process.exitCode = 1;
+            }
+        } catch (error) {
+            console.error(`${colors.pink}Update failed: ${error.message}${colors.reset}\n`);
+            process.exitCode = 1;
+        }
+    });
+
+program
+    .command('mcp')
+    .description('Manage MCP (Model Context Protocol) servers')
+    .addCommand(new Command('add')
+        .description('Add a new MCP server')
+        .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)')
+        .action((name, command, options) => {
+            const config = readConfig();
+            const mcpServers = config.mcpServers || {};
+            
+            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
+            };
+
+            config.mcpServers = mcpServers;
+            writeConfig(config);
+            console.log(`\n${colors.mint}✓${colors.reset} MCP server "${name}" added successfully.`);
+        })
+    )
+    .addCommand(new Command('remove')
+        .description('Remove an MCP server')
+        .argument('<name>', 'Server name')
+        .action((name) => {
+            const config = readConfig();
+            if (config.mcpServers && config.mcpServers[name]) {
+                delete config.mcpServers[name];
+                writeConfig(config);
+                console.log(`\n${colors.mint}✓${colors.reset} MCP server "${name}" removed.`);
+            } else {
+                console.log(`\n${colors.pink}✗${colors.reset} MCP server "${name}" not found.`);
+            }
+        })
+    )
+    .addCommand(new Command('list')
+        .description('List configured MCP servers')
+        .action(() => {
+            const config = readConfig();
+            const servers = Object.keys(config.mcpServers || {});
+            if (servers.length === 0) {
+                console.log(`\n${colors.gray}No MCP servers configured.${colors.reset}`);
+            } else {
+                console.log(`\n${colors.bright}Configured MCP Servers:${colors.reset}`);
+                servers.forEach(name => {
+                    const s = config.mcpServers[name];
+                    console.log(`${colors.mint}• ${colors.bright}${name}${colors.reset}`);
+                    console.log(`  ${colors.gray}Command:${colors.reset} ${s.command} ${(s.args || []).join(' ')}`);
+                });
+            }
+        })
+    )
+    .addCommand(new Command('clear')
+        .description('Remove all MCP servers')
+        .action(() => {
+            const config = readConfig();
+            config.mcpServers = {};
+            writeConfig(config);
+            console.log(`\n${colors.mint}✓${colors.reset} All MCP servers cleared.`);
+        })
+    );
+
+program
+    .command('gmail')
+    .description('Manage Gmail integration')
+    .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')
+        .action(async (options) => {
+            try {
+                const result = await runGmailAuth({
+                    port: options.port ? Number(options.port) : 0,
+                    openBrowser: options.open,
+                    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`);
+            } catch (error) {
+                console.error(`\n${colors.pink}Gmail auth failed:${colors.reset} ${error.message}\n`);
+                process.exitCode = 1;
+            }
+        })
+    );
+
 program
     .command('code')
     .description('Run Mint in workspace-aware coding mode for the current project')
@@ -118,8 +306,8 @@ program
         try {
             const result = await executeCodeTask(task, {
                 cwd: process.cwd(),
-                onProgress: (message) => {
-                    console.log(`${colors.gray}[Mint Code] ${message}${colors.reset}`);
+                onProgress: (info) => {
+                    console.log(formatProgress(info));
                 },
                 requestApproval: requestCodeApproval
             });
@@ -134,15 +322,21 @@ program
         }
     });
 
-program.parse(process.argv);
+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 { screen, appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode } = createChatUI({
+    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(' ');
@@ -200,9 +394,25 @@ async function startInteractiveChat(initialMessage = null) {
                         } 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.\nUsage: /workspace <add|list|remove>");
+                        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;
                 }
@@ -219,43 +429,15 @@ async function startInteractiveChat(initialMessage = null) {
                     // Other slash commands
                     const fakeRl = { close: () => { } };
                     appendMessage('user', text);
-                    await handleSlashCommandUI(text, appendMessage, updateStatusModel, copyLastResponse, setThinking, requestApproval, setMode);
+                    await handleSlashCommandUI(text, appendMessage, updateStatusModel, copyLastResponse, setThinking, requestApproval, setMode, appendCodeStep, updateWorkspace);
                     return;
                 }
             }
             appendMessage('user', text);
 
             const transcript = await getChatTranscript();
-            const routeDecision = await detectCodeIntent(text, process.cwd(), transcript);
-            if (routeDecision.route === 'code') {
-                const approved = await requestApproval({
-                    type: 'code_mode',
-                    label: 'Mint wants to switch this request into Code Mode.',
-                    preview: [
-                        `Request: ${text}`,
-                        `Reason: ${routeDecision.reason}`,
-                        '',
-                        'Code Mode is better for larger coding tasks that may inspect the workspace, run checks, or edit files.'
-                    ].join('\n')
-                });
-                if (!approved) {
-                    appendMessage('system', `Router stayed in Chat Mode. ${routeDecision.reason}`);
-                } else {
-                    appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
-                    await runChatRoutedTask(text, {
-                        appendMessage,
-                        setThinking,
-                        requestApproval,
-                        setMode,
-                        history: transcript
-                    });
-                    return;
-                }
-            }
-
-            setMode('Chat');
+            if (setMode) setMode('Agent');
 
-            // Start thinking timer
             let seconds = 0;
             setThinking(true, seconds);
             const timer = setInterval(() => {
@@ -265,100 +447,34 @@ async function startInteractiveChat(initialMessage = null) {
 
             try {
                 const config = require('./src/System/config_manager').readConfig();
-                const provider = config.aiProvider || 'gemini';
-                const currentAgent = agentOrchestrator.getCurrentAgent();
-                updateStatusModel(currentAgent.name);
-                if (provider === 'gemini') {
-                    // ── Streaming path (Gemini only) ──────────────────────────────────
-                    // Gemini returns JSON so we buffer all chunks and progressively
-                    // extract the "response" field as more of the JSON arrives.
-                    clearInterval(timer);
-
-                    let jsonBuffer = '';
-                    let finalParsed = null;
-                    let streamer = null;
-                    let displayedChars = 0; // chars of response text already sent to TUI
-
-                    try {
-                        for await (const event of handleGeminiChatStream(text)) {
-                            if (event.chunk) {
-                                jsonBuffer += event.chunk;
-
-                                // Progressively extract readable text from the growing JSON buffer
-                                const match = jsonBuffer.match(/"response"\s*:\s*"((?:[^"\\]|\\.)*)"/s);
-                                if (match) {
-                                    const fullText = match[1]
-                                        .replace(/\\n/g, '\n')
-                                        .replace(/\\"/g, '"')
-                                        .replace(/\\\\/g, '\\');
-                                    const newChars = fullText.slice(displayedChars);
-                                    if (newChars.length > 0) {
-                                        if (!streamer) {
-                                            setThinking(false);
-                                            streamer = streamMessage('assistant');
-                                        }
-                                        streamer.appendChunk(newChars);
-                                        displayedChars = fullText.length;
-                                    }
-                                }
-                            } else if (event.done) {
-                                finalParsed = event.parsed;
-                                // Flush any remaining response text not yet displayed
-                                if (finalParsed && finalParsed.response) {
-                                    const remaining = finalParsed.response.slice(displayedChars);
-                                    if (!streamer) {
-                                        setThinking(false);
-                                        streamer = streamMessage('assistant');
-                                    }
-                                    if (remaining) streamer.appendChunk(remaining);
-                                }
-                                if (streamer) {
-                                    streamer.finalize(event.timestamp);
-                                } else {
-                                    setThinking(false);
-                                    appendMessage('assistant',
-                                        finalParsed ? finalParsed.response : '',
-                                        event.timestamp);
-                                }
-                            }
-                        }
-                    } catch (streamErr) {
-                        setThinking(false);
-                        appendMessage('error', streamErr.message);
-                        return;
+                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);
                     }
+                });
 
-                    // 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}`);
-                        }
-                    }
+                clearInterval(timer);
+                setThinking(false);
+                lastResponseText = result.summary;
+                appendMessage('assistant', result.summary, { providerInfo: result.providerInfo });
 
-                } 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);
                 setThinking(false);
-                appendMessage('error', err.message);
+                appendMessage('error', formatErrorMessage(err));
+            } finally {
+                if (setMode) setMode('Chat');
             }
         },
         onExit: () => {
-            screen.destroy();
             // 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
@@ -369,73 +485,45 @@ async function startInteractiveChat(initialMessage = null) {
 
     // 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();
-            const routeDecision = await detectCodeIntent(initialMessage, process.cwd(), transcript);
-            if (routeDecision.route === 'code') {
-                const approved = await requestApproval({
-                    type: 'code_mode',
-                    label: 'Mint wants to switch this request into Code Mode.',
-                    preview: [
-                        `Request: ${initialMessage}`,
-                        `Reason: ${routeDecision.reason}`,
-                        '',
-                        'Code Mode is better for larger coding tasks that may inspect the workspace, run checks, or edit files.'
-                    ].join('\n')
-                });
-                if (approved) {
-                    appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
-                    await runChatRoutedTask(initialMessage, {
-                        appendMessage,
-                        setThinking,
-                        requestApproval,
-                        setMode,
-                        history: transcript
-                    });
-                } else {
-                    appendMessage('system', `Router stayed in Chat Mode. ${routeDecision.reason}`);
-                    setMode('Chat');
-                    let seconds = 0;
-                    setThinking(true, seconds);
-                    const timer = setInterval(() => { seconds++; setThinking(true, seconds); }, 1000);
-                    try {
-                        const response = await handleChat(initialMessage);
-                        clearInterval(timer);
-                        setThinking(false);
-                        appendMessage('assistant', response.response, response.timestamp);
-                        lastResponseText = response.response;
-                        const { executeAction } = require('./mint-cli-logic');
-                        if (response.action && response.action.type !== 'none') {
-                            const result = await executeAction(response.action);
-                            if (result) appendMessage('system', `Action: ${result}`);
-                        }
-                    } catch (err) {
-                        clearInterval(timer);
-                        setThinking(false);
-                        appendMessage('error', err.message);
-                    }
-                }
-            } else {
-            setMode('Chat');
-            let seconds = 0;
+        const transcript = await getChatTranscript();
+        if (setMode) setMode('Agent');
+
+        let seconds = 0;
+        setThinking(true, seconds);
+        const timer = setInterval(() => {
+            seconds++;
             setThinking(true, seconds);
-            const timer = setInterval(() => { seconds++; setThinking(true, seconds); }, 1000);
-            try {
-                const response = await handleChat(initialMessage);
-                clearInterval(timer);
-                setThinking(false);
-                appendMessage('assistant', response.response, response.timestamp);
-                lastResponseText = response.response;
-                const { executeAction } = require('./mint-cli-logic');
-                if (response.action && response.action.type !== 'none') {
-                    const result = await executeAction(response.action);
-                    if (result) appendMessage('system', `Action: ${result}`);
+        }, 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);
                 }
-            } catch (err) {
-                clearInterval(timer);
-                setThinking(false);
-                appendMessage('error', err.message);
-            }
+            });
+
+            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');
         }
     }
 }
@@ -443,7 +531,7 @@ async function startInteractiveChat(initialMessage = null) {
 /**
  * Handles slash commands within the TUI context
  */
-async function handleSlashCommandUI(input, appendMessage, updateStatusModel, copyLastResponse, setThinking, requestApproval, setMode) {
+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);
@@ -453,16 +541,36 @@ 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',
-                '  /clear          — Clear conversation history',
-                '  /reset          — Reset conversation history',
-                '  /exit           — Exit Mint'
+                '  /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();
@@ -521,7 +629,9 @@ async function handleSlashCommandUI(input, appendMessage, updateStatusModel, cop
                 appendMessage,
                 setThinking,
                 requestApproval,
+                appendCodeStep,
                 setMode,
+                askUser: () => Promise.resolve(''),
                 history: await getChatTranscript()
             });
             break;