@indiccoder/mentis-cli 1.0.3

package/dist/repl/ReplManager.js

@@ -0,0 +1,813 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplManager = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const ConfigManager_1 = require("../config/ConfigManager");
+const OpenAIClient_1 = require("../llm/OpenAIClient");
+const ContextManager_1 = require("../context/ContextManager");
+const UIManager_1 = require("../ui/UIManager");
+const FileTools_1 = require("../tools/FileTools");
+const SearchTools_1 = require("../tools/SearchTools");
+const PersistentShellTool_1 = require("../tools/PersistentShellTool");
+const PersistentShell_1 = require("./PersistentShell");
+const WebSearchTool_1 = require("../tools/WebSearchTool");
+const GitTools_1 = require("../tools/GitTools");
+const McpClient_1 = require("../mcp/McpClient");
+const CheckpointManager_1 = require("../checkpoint/CheckpointManager");
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const marked_1 = require("marked");
+const marked_terminal_1 = __importDefault(require("marked-terminal"));
+const HISTORY_FILE = path.join(os.homedir(), '.mentis_history');
+class ReplManager {
+    constructor() {
+        this.history = [];
+        this.mode = 'BUILD';
+        this.tools = [];
+        this.mcpClients = [];
+        this.currentModelName = 'Unknown';
+        this.configManager = new ConfigManager_1.ConfigManager();
+        this.contextManager = new ContextManager_1.ContextManager();
+        this.checkpointManager = new CheckpointManager_1.CheckpointManager();
+        this.shell = new PersistentShell_1.PersistentShell();
+        this.tools = [
+            new FileTools_1.WriteFileTool(),
+            new FileTools_1.ReadFileTool(),
+            new FileTools_1.ListDirTool(),
+            new SearchTools_1.SearchFileTool(), // grep
+            new WebSearchTool_1.WebSearchTool(),
+            new GitTools_1.GitStatusTool(),
+            new GitTools_1.GitDiffTool(),
+            new GitTools_1.GitCommitTool(),
+            new GitTools_1.GitPushTool(),
+            new GitTools_1.GitPullTool(),
+            new PersistentShellTool_1.PersistentShellTool(this.shell) // /run
+        ];
+        // Configure Markdown Renderer
+        marked_1.marked.setOptions({
+            // @ts-ignore
+            renderer: new marked_terminal_1.default()
+        });
+        // Default to Ollama if not specified, assuming compatible endpoint
+        this.initializeClient();
+    }
+    initializeClient() {
+        const config = this.configManager.getConfig();
+        const provider = config.defaultProvider || 'ollama';
+        let baseUrl;
+        let apiKey;
+        let model;
+        if (provider === 'gemini') {
+            baseUrl = 'https://generativelanguage.googleapis.com/v1beta/openai/';
+            apiKey = config.gemini?.apiKey || '';
+            model = config.gemini?.model || 'gemini-2.5-flash';
+        }
+        else if (provider === 'openai') {
+            baseUrl = config.openai?.baseUrl || 'https://api.openai.com/v1';
+            apiKey = config.openai?.apiKey || '';
+            model = config.openai?.model || 'gpt-4o';
+        }
+        else if (provider === 'glm') {
+            // Use the "Coding Plan" endpoint which supports glm-4.6 and this specific key type
+            baseUrl = config.glm?.baseUrl || 'https://api.z.ai/api/coding/paas/v4/';
+            apiKey = config.glm?.apiKey || '';
+            model = config.glm?.model || 'glm-4.6';
+        }
+        else { // Default to Ollama
+            baseUrl = config.ollama?.baseUrl || 'http://localhost:11434/v1';
+            apiKey = 'ollama'; // Ollama typically doesn't use an API key in the same way
+            model = config.ollama?.model || 'llama3:latest';
+        }
+        this.currentModelName = model;
+        this.modelClient = new OpenAIClient_1.OpenAIClient(baseUrl, apiKey, model);
+        // console.log(chalk.dim(`Initialized ${provider} client with model ${model}`));
+    }
+    async start() {
+        UIManager_1.UIManager.displayLogo();
+        UIManager_1.UIManager.displayWelcome();
+        // Load History
+        let commandHistory = [];
+        if (fs.existsSync(HISTORY_FILE)) {
+            try {
+                commandHistory = fs.readFileSync(HISTORY_FILE, 'utf-8').split('\n').filter(Boolean).reverse(); // readline expects newest first? No, newest is usually 0? Check.
+                // readline.history is [newest, ..., oldest]
+                // If I read from file where newest is at bottom (standard append), I need to reverse it.
+                // Let's assume standard file: line 1 (old), line 2 (new).
+                // So split -> reverse -> history.
+            }
+            catch (e) { }
+        }
+        while (true) {
+            UIManager_1.UIManager.printSeparator();
+            // console.log(chalk.dim(`  /help for help | Model: ${chalk.cyan(this.currentModelName)}`));
+            // Removed redundancy to keep CLI clean, prompt has info? No, prompt is minimal.
+            const modeLabel = this.mode === 'PLAN' ? chalk_1.default.magenta('PLAN') : chalk_1.default.blue('BUILD');
+            const promptText = `${modeLabel} ${chalk_1.default.cyan('>')}`;
+            // Use readline for basic input to support history
+            const answer = await new Promise((resolve) => {
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                    history: commandHistory,
+                    historySize: 1000,
+                    prompt: promptText + ' '
+                });
+                rl.prompt();
+                rl.on('line', (line) => {
+                    rl.close();
+                    resolve(line);
+                });
+            });
+            // Update history manually or grab from rl? 
+            // rl.history gets updated when user hits enter.
+            // But we closed rl. We should manually save the input to our tracking array and file.
+            const input = answer.trim();
+            if (input) {
+                // Update in-memory history (for next readline instance)
+                // Readline history has newest at 0.
+                // Avoid duplicates if needed, but standard shell keeps them.
+                if (commandHistory[0] !== input) {
+                    commandHistory.unshift(input);
+                }
+                // Append to file (as standard log, so append at end)
+                try {
+                    fs.appendFileSync(HISTORY_FILE, input + '\n');
+                }
+                catch (e) { }
+            }
+            if (!answer.trim())
+                continue; // Skip empty but allow it to close readline loop
+            if (input.startsWith('/')) {
+                await this.handleCommand(input);
+                continue;
+            }
+            await this.handleChat(input);
+        }
+    }
+    async handleCommand(input) {
+        const [command, ...args] = input.split(' ');
+        switch (command) {
+            case '/help':
+                console.log(chalk_1.default.yellow('Available commands:'));
+                console.log('  /help    - Show this help message');
+                console.log('  /clear   - Clear chat history');
+                console.log('  /exit    - Exit the application');
+                console.log('  /config  - Configure settings');
+                console.log('  /add <file> - Add file to context');
+                console.log('  /drop <file> - Remove file from context');
+                console.log('  /plan    - Switch to PLAN mode');
+                console.log('  /build   - Switch to BUILD mode');
+                console.log('  /plan    - Switch to PLAN mode');
+                console.log('  /build   - Switch to BUILD mode');
+                console.log('  /model   - Interactively select Provider & Model');
+                console.log('  /use <provider> [model] - Quick switch (legacy)');
+                console.log('  /mcp <cmd> - Manage MCP servers');
+                console.log('  /resume  - Resume last session');
+                console.log('  /checkpoint <save|load|list> [name] - Manage checkpoints');
+                console.log('  /search <query> - Search codebase');
+                console.log('  /run <cmd> - Run shell command');
+                console.log('  /commit [msg] - Git commit all changes');
+                break;
+            case '/plan':
+                this.mode = 'PLAN';
+                console.log(chalk_1.default.blue('Switched to PLAN mode.'));
+                break;
+            case '/build':
+                this.mode = 'BUILD';
+                console.log(chalk_1.default.yellow('Switched to BUILD mode.'));
+                break;
+            case '/build':
+                this.mode = 'BUILD';
+                console.log(chalk_1.default.yellow('Switched to BUILD mode.'));
+                break;
+            case '/model':
+                await this.handleModelCommand(args);
+                break;
+            case '/connect':
+                console.log(chalk_1.default.dim('Tip: Use /model for an interactive menu.'));
+                await this.handleConnectCommand(args);
+                break;
+            case '/use':
+                await this.handleUseCommand(args);
+                break;
+            case '/mcp':
+                await this.handleMcpCommand(args);
+                break;
+            case '/resume':
+                await this.handleResumeCommand();
+                break;
+            case '/checkpoint':
+                await this.handleCheckpointCommand(args);
+                break;
+            case '/clear':
+                this.history = [];
+                this.contextManager.clear();
+                UIManager_1.UIManager.displayLogo(); // Redraw logo on clear
+                console.log(chalk_1.default.yellow('Chat history and context cleared.'));
+                break;
+            case '/add':
+                if (args.length === 0) {
+                    console.log(chalk_1.default.red('Usage: /add <file_path>'));
+                }
+                else {
+                    const result = await this.contextManager.addFile(args[0]);
+                    console.log(chalk_1.default.yellow(result));
+                }
+                break;
+            case '/drop':
+                if (args.length === 0) {
+                    console.log(chalk_1.default.red('Usage: /drop <file_path>'));
+                }
+                else {
+                    const result = await this.contextManager.removeFile(args[0]);
+                    console.log(chalk_1.default.yellow(result));
+                }
+                break;
+            case '/config':
+                await this.handleConfigCommand();
+                break;
+            case '/exit':
+                // Auto-save on exit
+                this.checkpointManager.save('latest', this.history, this.contextManager.getFiles());
+                this.shell.kill(); // Kill the shell process
+                console.log(chalk_1.default.green('Session saved. Goodbye!'));
+                process.exit(0);
+                break;
+            default:
+                console.log(chalk_1.default.red(`Unknown command: ${command}`));
+        }
+    }
+    async handleChat(input) {
+        const context = this.contextManager.getContextString();
+        let fullInput = input;
+        let modeInstruction = '';
+        if (this.mode === 'PLAN') {
+            modeInstruction = '\n[SYSTEM: You are in PLAN mode. Focus on high-level architecture, requirements analysis, and creating a sturdy plan. Do not write full code implementation yet, just scaffolds or pseudocode if needed.]';
+        }
+        else {
+            modeInstruction = '\n[SYSTEM: You are in BUILD mode. Focus on implementing working code that solves the user request efficiently.]';
+        }
+        fullInput = `${input}${modeInstruction}`;
+        if (context) {
+            fullInput = `${context}\n\nUser Question: ${fullInput}`;
+        }
+        this.history.push({ role: 'user', content: fullInput });
+        let spinner = (0, ora_1.default)('Thinking... (Press Esc to cancel)').start();
+        const controller = new AbortController();
+        // Setup cancellation listener
+        const keyListener = (str, key) => {
+            if (key.name === 'escape') {
+                controller.abort();
+            }
+        };
+        if (process.stdin.isTTY) {
+            readline.emitKeypressEvents(process.stdin);
+            process.stdin.setRawMode(true);
+            process.stdin.on('keypress', keyListener);
+        }
+        try {
+            // First call
+            let response = await this.modelClient.chat(this.history, this.tools.map(t => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters
+                }
+            })), controller.signal);
+            // Loop for tool calls
+            while (response.tool_calls && response.tool_calls.length > 0) {
+                if (controller.signal.aborted)
+                    throw new Error('Request cancelled by user');
+                spinner.stop();
+                // Add the assistant's request to use tool to history
+                this.history.push({
+                    role: 'assistant',
+                    content: response.content,
+                    tool_calls: response.tool_calls
+                });
+                // Execute tools
+                for (const toolCall of response.tool_calls) {
+                    if (controller.signal.aborted)
+                        break;
+                    const toolName = toolCall.function.name;
+                    const toolArgsStr = toolCall.function.arguments;
+                    const toolArgs = JSON.parse(toolArgsStr);
+                    // Truncate long arguments
+                    let displayArgs = toolArgsStr;
+                    if (displayArgs.length > 100) {
+                        displayArgs = displayArgs.substring(0, 100) + '...';
+                    }
+                    console.log(chalk_1.default.dim(`  [Action] ${toolName}(${displayArgs})`));
+                    // Safety check for write_file
+                    if (toolName === 'write_file') {
+                        // Pause cancellation listener during user interaction
+                        if (process.stdin.isTTY) {
+                            process.stdin.removeListener('keypress', keyListener);
+                            process.stdin.setRawMode(false);
+                            process.stdin.pause(); // Explicitly pause before inquirer
+                        }
+                        spinner.stop(); // Stop spinner to allow input
+                        const { confirm } = await inquirer_1.default.prompt([
+                            {
+                                type: 'confirm',
+                                name: 'confirm',
+                                message: `Allow writing to ${chalk_1.default.yellow(toolArgs.filePath)}?`,
+                                default: true
+                            }
+                        ]);
+                        // Resume cancellation listener
+                        if (process.stdin.isTTY) {
+                            process.stdin.setRawMode(true);
+                            process.stdin.resume(); // Explicitly resume
+                            process.stdin.on('keypress', keyListener);
+                        }
+                        if (!confirm) {
+                            this.history.push({
+                                role: 'tool',
+                                tool_call_id: toolCall.id,
+                                name: toolName,
+                                content: 'Error: User rejected write operation.'
+                            });
+                            console.log(chalk_1.default.red('  Action cancelled by user.'));
+                            // Do not restart spinner here. Let the outer loop logic or next step handle it.
+                            // If we continue, we go to next tool or finish loop.
+                            // If finished, lines following loop will start spinner.
+                            continue;
+                        }
+                        spinner = (0, ora_1.default)('Executing...').start();
+                    }
+                    const tool = this.tools.find(t => t.name === toolName);
+                    let result = '';
+                    if (tool) {
+                        try {
+                            // Tools typically run synchronously or promise-based. 
+                            // Verify if we want Tools to be cancellable?
+                            // For now, if aborted during tool, we let tool finish but stop loop.
+                            result = await tool.execute(toolArgs);
+                        }
+                        catch (e) {
+                            result = `Error: ${e.message}`;
+                        }
+                    }
+                    else {
+                        result = `Error: Tool ${toolName} not found.`;
+                    }
+                    if (spinner.isSpinning) {
+                        spinner.stop();
+                    }
+                    this.history.push({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        name: toolName,
+                        content: result
+                    });
+                }
+                if (controller.signal.aborted)
+                    throw new Error('Request cancelled by user');
+                spinner = (0, ora_1.default)('Thinking (processing tools)...').start();
+                // Get next response
+                response = await this.modelClient.chat(this.history, this.tools.map(t => ({
+                    type: 'function',
+                    function: {
+                        name: t.name,
+                        description: t.description,
+                        parameters: t.parameters
+                    }
+                })), controller.signal);
+            }
+            spinner.stop();
+            console.log('');
+            if (response.content) {
+                console.log(chalk_1.default.bold.blue('Mentis:'));
+                console.log((0, marked_1.marked)(response.content));
+                if (response.usage) {
+                    const { input_tokens, output_tokens } = response.usage;
+                    const totalCost = this.estimateCost(input_tokens, output_tokens);
+                    console.log(chalk_1.default.dim(`\n(Tokens: ${input_tokens} in / ${output_tokens} out | Est. Cost: $${totalCost.toFixed(5)})`));
+                }
+                console.log('');
+                this.history.push({ role: 'assistant', content: response.content });
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            if (error.message === 'Request cancelled by user') {
+                console.log(chalk_1.default.yellow('\nRequest cancelled by user.'));
+            }
+            else {
+                spinner.fail('Error getting response from model.');
+                console.error(error.message);
+            }
+        }
+        finally {
+            if (process.stdin.isTTY) {
+                process.stdin.removeListener('keypress', keyListener);
+                process.stdin.setRawMode(false);
+                process.stdin.pause(); // Reset flow
+            }
+        }
+    }
+    async handleConfigCommand() {
+        const config = this.configManager.getConfig();
+        const { action } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'Configuration',
+                prefix: '',
+                choices: [
+                    'Show Current Configuration',
+                    'Set Active Provider',
+                    'Set API Key (for active provider)',
+                    'Set Base URL (for active provider)',
+                    'Back'
+                ]
+            }
+        ]);
+        if (action === 'Back')
+            return;
+        if (action === 'Show Current Configuration') {
+            console.log(JSON.stringify(config, null, 2));
+            return;
+        }
+        if (action === 'Set Active Provider') {
+            const { provider } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'provider',
+                    message: 'Select Provider:',
+                    choices: ['Gemini', 'Ollama', 'OpenAI', 'GLM']
+                }]);
+            const key = provider.toLowerCase();
+            this.configManager.updateConfig({ defaultProvider: key });
+            console.log(chalk_1.default.green(`Active provider set to: ${provider}`));
+            this.initializeClient();
+            return;
+        }
+        const currentProvider = config.defaultProvider;
+        if (action === 'Set API Key (for active provider)') {
+            if (currentProvider === 'ollama') {
+                console.log(chalk_1.default.yellow('Ollama typically does not require an API key.'));
+            }
+            const { value } = await inquirer_1.default.prompt([{
+                    type: 'password',
+                    name: 'value',
+                    message: `Enter API Key for ${currentProvider}:`,
+                    mask: '*'
+                }]);
+            const updates = {};
+            updates[currentProvider] = { ...(config[currentProvider] || {}), apiKey: value };
+            this.configManager.updateConfig(updates);
+            console.log(chalk_1.default.green(`API Key updated for ${currentProvider}.`));
+            this.initializeClient();
+        }
+        if (action === 'Set Base URL (for active provider)') {
+            const defaultUrl = config[currentProvider]?.baseUrl || '';
+            const { value } = await inquirer_1.default.prompt([{
+                    type: 'input',
+                    name: 'value',
+                    message: `Enter Base URL for ${currentProvider}:`,
+                    default: defaultUrl
+                }]);
+            const updates = {};
+            updates[currentProvider] = { ...(config[currentProvider] || {}), baseUrl: value };
+            this.configManager.updateConfig(updates);
+            console.log(chalk_1.default.green(`Base URL updated for ${currentProvider}.`));
+            this.initializeClient();
+        }
+    }
+    async handleModelCommand(args) {
+        const config = this.configManager.getConfig();
+        const provider = config.defaultProvider || 'ollama';
+        // If argument provided, use it directly
+        if (args.length > 0) {
+            const modelName = args[0];
+            const updates = {};
+            updates[provider] = { ...(config[provider] || {}), model: modelName };
+            this.configManager.updateConfig(updates);
+            this.initializeClient(); // Re-init with new model
+            console.log(chalk_1.default.green(`\nModel set to ${chalk_1.default.bold(modelName)} for ${provider}!`));
+            return;
+        }
+        let models = [];
+        if (provider === 'gemini') {
+            models = ['gemini-2.5-flash', 'gemini-1.5-pro', 'gemini-1.0-pro', 'Other...'];
+        }
+        else if (provider === 'ollama') {
+            models = ['llama3:latest', 'deepseek-r1:latest', 'mistral:latest', 'Other...'];
+        }
+        else if (provider === 'openai') {
+            models = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'Other...'];
+        }
+        else if (provider === 'glm') {
+            models = ['glm-4.6', 'glm-4-plus', 'glm-4', 'glm-4-air', 'glm-4-flash', 'Other...'];
+        }
+        else if (provider === 'anthropic') {
+            models = ['claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-sonnet-20240229', 'claude-3-haiku-20240307', 'glm-4.6', 'Other...'];
+        }
+        else {
+            models = ['Other...'];
+        }
+        console.log(chalk_1.default.blue(`Configuring model for active provider: ${chalk_1.default.bold(provider)}`));
+        let { model } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select Model:',
+                choices: models,
+            }
+        ]);
+        if (model === 'Other...') {
+            const { customModel } = await inquirer_1.default.prompt([{
+                    type: 'input',
+                    name: 'customModel',
+                    message: 'Enter model name:'
+                }]);
+            model = customModel;
+        }
+        const updates = {};
+        updates[provider] = { ...(config[provider] || {}), model: model };
+        this.configManager.updateConfig(updates);
+        this.initializeClient();
+        console.log(chalk_1.default.green(`\nModel set to ${model} for ${provider}!`));
+    }
+    async handleConnectCommand(args) {
+        if (args.length < 1) {
+            console.log(chalk_1.default.red('Usage: /connect <provider> [key_or_url]'));
+            return;
+        }
+        const provider = args[0].toLowerCase();
+        const value = args[1]; // Optional for ollama (defaults), required for others usually
+        const config = this.configManager.getConfig();
+        if (provider === 'gemini') {
+            if (!value) {
+                console.log(chalk_1.default.red('Error: API Key required for Gemini. usage: /connect gemini <api_key>'));
+                return;
+            }
+            this.configManager.updateConfig({
+                gemini: { ...config.gemini, apiKey: value },
+                defaultProvider: 'gemini'
+            });
+            console.log(chalk_1.default.green(`Connected to Gemini with key: ${value.substring(0, 8)}...`));
+        }
+        else if (provider === 'ollama') {
+            const url = value || 'http://localhost:11434/v1';
+            this.configManager.updateConfig({
+                ollama: { ...config.ollama, baseUrl: url },
+                defaultProvider: 'ollama'
+            });
+            console.log(chalk_1.default.green(`Connected to Ollama at ${url}`));
+        }
+        else if (provider === 'openai') { // Support OpenAI since client supports it
+            if (!value) {
+                console.log(chalk_1.default.red('Error: API Key required for OpenAI. usage: /connect openai <api_key>'));
+                return;
+            }
+            this.configManager.updateConfig({
+                openai: { ...config.openai, apiKey: value },
+                defaultProvider: 'openai' // We might need to handle 'openai' in initializeClient if we add it officially
+            });
+            console.log(chalk_1.default.green(`Connected to OpenAI.`));
+        }
+        else if (provider === 'glm') {
+            if (!value) {
+                console.log(chalk_1.default.red('Error: API Key required for GLM. usage: /connect glm <api_key>'));
+                return;
+            }
+            this.configManager.updateConfig({
+                glm: { ...config.glm, apiKey: value },
+                defaultProvider: 'glm'
+            });
+            console.log(chalk_1.default.green(`Connected to GLM (ZhipuAI).`));
+        }
+        else {
+            console.log(chalk_1.default.red(`Unknown provider: ${provider}. Use 'gemini', 'ollama', 'openai', or 'glm'.`));
+            return;
+        }
+        this.initializeClient();
+    }
+    async handleUseCommand(args) {
+        if (args.length < 1) {
+            console.log(chalk_1.default.red('Usage: /use <provider> [model_name]'));
+            return;
+        }
+        const provider = args[0].toLowerCase();
+        const model = args[1]; // Optional
+        const config = this.configManager.getConfig();
+        if (provider === 'gemini') {
+            const updates = { defaultProvider: 'gemini' };
+            if (model) {
+                updates.gemini = { ...config.gemini, model: model };
+            }
+            this.configManager.updateConfig(updates);
+        }
+        else if (provider === 'ollama') {
+            const updates = { defaultProvider: 'ollama' };
+            if (model) {
+                updates.ollama = { ...config.ollama, model: model };
+            }
+            this.configManager.updateConfig(updates);
+        }
+        else if (provider === 'glm') {
+            const updates = { defaultProvider: 'glm' };
+            if (model) {
+                updates.glm = { ...config.glm, model: model };
+            }
+            this.configManager.updateConfig(updates);
+            // Auto switch if connecting to a new provider
+            if (provider === 'gemini') {
+                updates.defaultProvider = 'gemini';
+                this.configManager.updateConfig(updates);
+            }
+            else if (provider === 'ollama') {
+                updates.defaultProvider = 'ollama';
+                this.configManager.updateConfig(updates);
+            }
+        }
+        else {
+            console.log(chalk_1.default.red(`Unknown provider: ${provider}`));
+            return;
+        }
+        this.initializeClient();
+        console.log(chalk_1.default.green(`Switched to ${provider} ${model ? `using model ${model}` : ''}`));
+    }
+    async handleMcpCommand(args) {
+        if (args.length < 1) {
+            console.log(chalk_1.default.red('Usage: /mcp <connect|list|disconnect> [args]'));
+            return;
+        }
+        const action = args[0];
+        if (action === 'connect') {
+            const commandParts = args.slice(1);
+            if (commandParts.length === 0) {
+                console.log(chalk_1.default.red('Usage: /mcp connect <command> [args...]'));
+                return;
+            }
+            // Example: /mcp connect npx -y @modelcontextprotocol/server-memory
+            // On Windows, npx might be npx.cmd
+            const cmd = process.platform === 'win32' && commandParts[0] === 'npx' ? 'npx.cmd' : commandParts[0];
+            const cmdArgs = commandParts.slice(1);
+            const spinner = (0, ora_1.default)(`Connecting to MCP server: ${cmd} ${cmdArgs.join(' ')}...`).start();
+            try {
+                const client = new McpClient_1.McpClient(cmd, cmdArgs);
+                await client.initialize();
+                const mcpTools = await client.listTools();
+                this.mcpClients.push(client);
+                this.tools.push(...mcpTools);
+                spinner.succeed(chalk_1.default.green(`Connected to ${client.serverName}!`));
+                console.log(chalk_1.default.green(`Added ${mcpTools.length} tools:`));
+                mcpTools.forEach(t => console.log(chalk_1.default.dim(`  - ${t.name}: ${t.description.substring(0, 50)}...`)));
+            }
+            catch (e) {
+                spinner.fail(chalk_1.default.red(`Failed to connect: ${e.message}`));
+            }
+        }
+        else if (action === 'list') {
+            if (this.mcpClients.length === 0) {
+                console.log('No active MCP connections.');
+            }
+            else {
+                console.log(chalk_1.default.cyan('Active MCP Connections:'));
+                this.mcpClients.forEach((client, idx) => {
+                    console.log(`${idx + 1}. ${client.serverName}`);
+                });
+            }
+        }
+        else if (action === 'disconnect') {
+            // Basic disconnect all for now or by index if we wanted
+            console.log(chalk_1.default.yellow('Disconnecting all MCP clients...'));
+            this.mcpClients.forEach(c => c.disconnect());
+            this.mcpClients = [];
+            // Re-init core tools
+            this.tools = [
+                new FileTools_1.WriteFileTool(),
+                new FileTools_1.ReadFileTool(),
+                new FileTools_1.ListDirTool(),
+                new SearchTools_1.SearchFileTool(),
+                new PersistentShellTool_1.PersistentShellTool(this.shell),
+                new WebSearchTool_1.WebSearchTool(),
+                new GitTools_1.GitStatusTool(),
+                new GitTools_1.GitDiffTool(),
+                new GitTools_1.GitCommitTool(),
+                new GitTools_1.GitPushTool(),
+                new GitTools_1.GitPullTool()
+            ];
+        }
+        else {
+            console.log(chalk_1.default.red(`Unknown MCP action: ${action}`));
+        }
+    }
+    async handleResumeCommand() {
+        if (!this.checkpointManager.exists('latest')) {
+            console.log(chalk_1.default.yellow('No previous session found to resume.'));
+            return;
+        }
+        await this.loadCheckpoint('latest');
+    }
+    async handleCheckpointCommand(args) {
+        if (args.length < 1) {
+            console.log(chalk_1.default.red('Usage: /checkpoint <save|load|list> [name]'));
+            return;
+        }
+        const action = args[0];
+        const name = args[1] || 'default';
+        if (action === 'save') {
+            this.checkpointManager.save(name, this.history, this.contextManager.getFiles());
+            console.log(chalk_1.default.green(`Checkpoint '${name}' saved.`));
+        }
+        else if (action === 'load') {
+            await this.loadCheckpoint(name);
+        }
+        else if (action === 'list') {
+            const points = this.checkpointManager.list();
+            console.log(chalk_1.default.cyan('Available Checkpoints:'));
+            points.forEach(p => console.log(` - ${p}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`Unknown action: ${action}`));
+        }
+    }
+    async loadCheckpoint(name) {
+        const cp = this.checkpointManager.load(name);
+        if (!cp) {
+            console.log(chalk_1.default.red(`Checkpoint '${name}' not found.`));
+            return;
+        }
+        this.history = cp.history;
+        this.contextManager.clear();
+        // Restore context files
+        if (cp.files && cp.files.length > 0) {
+            console.log(chalk_1.default.dim('Restoring context files...'));
+            for (const file of cp.files) {
+                await this.contextManager.addFile(file);
+            }
+        }
+        console.log(chalk_1.default.green(`Resumed session '${name}' (${new Date(cp.timestamp).toLocaleString()})`));
+        // Re-display last assistant message if any
+        const lastMsg = this.history[this.history.length - 1];
+        if (lastMsg && lastMsg.role === 'assistant' && lastMsg.content) {
+            console.log(chalk_1.default.blue('\nLast message:'));
+            console.log(lastMsg.content);
+        }
+    }
+    estimateCost(input, output) {
+        const config = this.configManager.getConfig();
+        const provider = config.defaultProvider;
+        let rateIn = 0;
+        let rateOut = 0;
+        if (provider === 'openai') {
+            rateIn = 5.00 / 1000000;
+            rateOut = 15.00 / 1000000;
+        }
+        else if (provider === 'gemini') {
+            rateIn = 0.35 / 1000000;
+            rateOut = 0.70 / 1000000;
+        }
+        else if (provider === 'glm') {
+            rateIn = 14.00 / 1000000; // Approximate for GLM-4
+            rateOut = 14.00 / 1000000;
+        }
+        return (input * rateIn) + (output * rateOut);
+    }
+}
+exports.ReplManager = ReplManager;