kaze-cli 2.0.0

package/dist/cli/repl.js

@@ -0,0 +1,1782 @@
+"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.REPL = void 0;
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs/promises"));
+const universal_client_1 = require("../api/universal-client");
+const renderer_1 = require("../ui/renderer");
+const logger_1 = require("../ui/logger");
+const tui_1 = require("../ui/tui");
+const filesystem_1 = require("../tools/filesystem");
+const terminal_1 = require("../tools/terminal");
+const codebase_1 = require("../tools/codebase");
+const memory_1 = require("../context/memory");
+const todo_1 = require("../tools/todo");
+const config_command_1 = require("./config-command");
+const setup_1 = require("../config/setup");
+const interactive_setup_1 = require("../config/interactive-setup");
+const manager_1 = require("../mcp/manager");
+const manager_2 = require("../personality/manager");
+class REPL {
+    client;
+    renderer;
+    logger;
+    tui;
+    fileTool;
+    terminalTool;
+    codeSearchTool;
+    memoryManager;
+    conversationManager;
+    todoManager;
+    mcpManager;
+    personalityManager;
+    rl;
+    configManager;
+    configCommand;
+    config;
+    running = false;
+    processes = new Map();
+    providerConfig;
+    mcpToolsCache = new Map();
+    tokensUsed = 0;
+    activePersonality;
+    constructor(config) {
+        this.configManager = config.configManager;
+        this.configCommand = new config_command_1.ConfigCommand(config.configManager, config.configDir);
+        this.config = {
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl,
+            model: config.model,
+            provider: config.provider,
+            configManager: config.configManager,
+            configDir: config.configDir,
+            workingDirectory: config.workingDirectory || process.cwd(),
+            maxHistory: config.maxHistory || 50,
+            enableTools: config.enableTools !== false,
+            maxTokens: config.maxTokens || 8192,
+            temperature: config.temperature || 1.0,
+            interfaceConfig: config.interfaceConfig || {},
+            experimentalFeatures: config.experimentalFeatures || { systemPromptToolCalling: false },
+            enableMCP: config.enableMCP !== false,
+            enablePersonalities: config.enablePersonalities !== false
+        };
+        this.providerConfig = {
+            name: config.provider,
+            baseUrl: config.baseUrl,
+            supportsTools: true,
+            supportsStreaming: true,
+            authType: 'bearer'
+        };
+        this.client = new universal_client_1.UniversalClient(this.config.apiKey, this.config.baseUrl, this.config.model, this.config.provider, this.providerConfig, this.config.experimentalFeatures);
+        this.renderer = new renderer_1.StreamRenderer();
+        this.logger = new logger_1.Logger({ level: 1 });
+        this.tui = new tui_1.TUI({ version: '2.0.0' });
+        this.fileTool = new filesystem_1.FileSystemTools();
+        this.terminalTool = new terminal_1.TerminalManager();
+        this.codeSearchTool = new codebase_1.CodebaseSearcher();
+        this.memoryManager = new memory_1.MemoryManager();
+        this.conversationManager = new memory_1.ConversationManager(this.config.workingDirectory);
+        this.todoManager = new todo_1.TodoManager();
+        if (config.enableMCP !== false) {
+            this.mcpManager = new manager_1.MCPManager({
+                configDir: config.configDir,
+                configManager: config.configManager,
+                logger: this.logger
+            });
+        }
+        if (config.enablePersonalities !== false) {
+            this.personalityManager = new manager_2.PersonalityManager(config.configDir);
+        }
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.tui.setInfo({
+            model: this.config.model,
+            provider: this.config.provider,
+            tokensUsed: this.tokensUsed
+        });
+        this.tui.activate();
+        this.tui.render();
+        this.logger.banner({
+            version: `v1.0.0`,
+            model: `${this.config.provider} • ${this.config.model}`,
+            mcpStatus: 'Connecting to MCP...'
+        });
+        if (this.personalityManager) {
+            this.personalityManager.initialize();
+        }
+        this.setupEventHandlers();
+        // Initialize MCP asynchronously after the CLI is running
+        setImmediate(async () => {
+            if (this.mcpManager) {
+                try {
+                    await this.mcpManager.initialize();
+                    await this.mcpManager.connectAllSilent();
+                    await this.updateMCPToolsCache();
+                    const status = await this.mcpManager.getServerStatus();
+                    const mcpServers = status.filter((s) => s.connected).length;
+                    const mcpStatus = `${mcpServers} MCP server${mcpServers !== 1 ? 's' : ''} connected`;
+                    // Update TUI info line with MCP status
+                    this.tui.setInfo({
+                        model: this.config.model,
+                        provider: this.config.provider,
+                        tokensUsed: this.tokensUsed,
+                        mcpStatus
+                    });
+                    this.tui.markDirty();
+                    this.tui.render();
+                }
+                catch (error) {
+                    // If MCP initialization fails, show 0 connected
+                    const mcpStatus = '0 MCP servers connected';
+                    this.tui.setInfo({
+                        model: this.config.model,
+                        provider: this.config.provider,
+                        tokensUsed: this.tokensUsed,
+                        mcpStatus
+                    });
+                    this.tui.markDirty();
+                    this.tui.render();
+                }
+            }
+            else {
+                // No MCP manager, show 0 connected
+                const mcpStatus = '0 MCP servers connected';
+                this.tui.setInfo({
+                    model: this.config.model,
+                    provider: this.config.provider,
+                    tokensUsed: this.tokensUsed,
+                    mcpStatus
+                });
+                this.tui.markDirty();
+                this.tui.render();
+            }
+        });
+        while (this.running) {
+            const input = await this.readMultiline();
+            if (!input.trim())
+                continue;
+            try {
+                await this.handleInput(input);
+            }
+            catch (error) {
+                this.logger.error(String(error));
+            }
+        }
+    }
+    stop() {
+        this.running = false;
+        this.tui.deactivate();
+        this.rl.close();
+        this.processes.forEach((proc, id) => {
+            this.terminalTool.stopProcess(id);
+        });
+    }
+    async updateMCPToolsCache() {
+        if (!this.mcpManager)
+            return;
+        const servers = await this.mcpManager.listServers();
+        for (const server of servers) {
+            if (server.disabled)
+                continue;
+            try {
+                const toolsMap = await this.mcpManager.listTools(server.name);
+                const tools = toolsMap.get(server.name);
+                if (tools) {
+                    this.mcpToolsCache.set(server.name, tools.map((tool) => ({
+                        type: 'function',
+                        function: {
+                            name: `${server.name}_${tool.name}`,
+                            description: tool.description,
+                            parameters: tool.inputSchema
+                        }
+                    })));
+                }
+            }
+            catch (error) {
+                // Silently skip this server - don't let one bad server break the whole MCP system
+                this.logger.warning(`Failed to load tools from MCP server ${server.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    setupEventHandlers() {
+        this.rl.on('SIGINT', () => {
+            if (this.processes.size > 0) {
+                this.logger.warning('Stopping running processes...');
+                this.processes.forEach((proc, id) => {
+                    this.terminalTool.stopProcess(id);
+                });
+                this.processes.clear();
+                this.logger.success('All processes stopped.');
+            }
+            else {
+                console.log(chalk_1.default.hex(logger_1.THEME.dim)('\nUse "exit" or "quit" to leave Kaze CLI.'));
+                this.rl.prompt();
+            }
+        });
+        this.rl.on('close', () => {
+            console.log(chalk_1.default.hex(logger_1.THEME.dim)('Goodbye!'));
+            process.exit(0);
+        });
+    }
+    async readLine() {
+        return new Promise((resolve) => {
+            this.rl.question(chalk_1.default.hex(logger_1.THEME.cyan)('> '), (answer) => {
+                resolve(answer);
+            });
+        });
+    }
+    async readMultiline() {
+        const lines = [];
+        let isFirstLine = true;
+        let shownHint = false;
+        while (true) {
+            if (isFirstLine) {
+                const line = await new Promise((resolve) => {
+                    this.rl.question(chalk_1.default.hex(logger_1.THEME.cyan)('> '), (answer) => {
+                        resolve(answer);
+                    });
+                });
+                if (line.trim() === '') {
+                    return '';
+                }
+                lines.push(line);
+                isFirstLine = false;
+            }
+            else {
+                if (!shownHint) {
+                    console.log(chalk_1.default.dim('... Press enter on newline to submit.'));
+                    shownHint = true;
+                }
+                const line = await new Promise((resolve) => {
+                    this.rl.question(chalk_1.default.dim('... '), (answer) => {
+                        resolve(answer);
+                    });
+                });
+                if (line.trim() === '') {
+                    break;
+                }
+                lines.push(line);
+            }
+        }
+        return lines.join('\n');
+    }
+    async handleInput(input) {
+        const trimmedInput = input.trim();
+        if (trimmedInput.startsWith('/')) {
+            await this.handleCommand(trimmedInput);
+            return;
+        }
+        if (trimmedInput === 'exit' || trimmedInput === 'quit') {
+            this.stop();
+            return;
+        }
+        if (trimmedInput === 'help' || trimmedInput === '?') {
+            this.showHelp();
+            return;
+        }
+        if (trimmedInput === 'clear') {
+            this.logger.clear();
+            return;
+        }
+        await this.sendMessage(trimmedInput);
+    }
+    async handleCommand(command) {
+        const [cmd, ...args] = command.slice(1).split(' ');
+        switch (cmd) {
+            case 'config':
+                await this.configCommand.handle(args);
+                break;
+            case 'read':
+                await this.handleReadCommand(args.join(' '));
+                break;
+            case 'write':
+                await this.handleWriteCommand(args);
+                break;
+            case 'edit':
+                await this.handleEditCommand(args);
+                break;
+            case 'search':
+                await this.handleSearchCommand(args.join(' '));
+                break;
+            case 'run':
+                await this.handleRunCommand(args.join(' '));
+                break;
+            case 'stop':
+                await this.handleStopCommand(args[0]);
+                break;
+            case 'code':
+                await this.handleCodeSearchCommand(args.join(' '));
+                break;
+            case 'ls':
+                await this.handleListCommand(args[0] || '.');
+                break;
+            case 'todo':
+                await this.handleTodoCommand(args);
+                break;
+            case 'mem':
+                await this.handleMemoryCommand(args);
+                break;
+            case 'mcp':
+                await this.handleMcpCommand(args);
+                break;
+            case 'personality':
+            case 'persona':
+                await this.handlePersonalityCommand(args);
+                break;
+            case 'context':
+                this.showContext();
+                break;
+            case 'exit':
+            case 'quit':
+                this.stop();
+                break;
+            default:
+                console.log(chalk_1.default.red(`Unknown command: /${cmd}`));
+                console.log(chalk_1.default.gray('Type "help" for available commands.'));
+        }
+    }
+    async handleSetupCommand() {
+        console.log('');
+        this.logger.info('Starting interactive setup...');
+        const setup = new setup_1.ConfigSetup();
+        const configInfo = await setup.initialize();
+        const interactiveSetup = new interactive_setup_1.InteractiveSetup(configInfo.configDir, configInfo.envFile);
+        const success = await interactiveSetup.run();
+        if (success) {
+            await setup.markSetupComplete();
+            console.log('');
+            this.logger.success('Setup complete. You may need to restart for all changes to take effect.');
+        }
+        else {
+            console.log('');
+            this.logger.error('Setup failed.');
+        }
+    }
+    async handleReadCommand(filePath) {
+        if (!filePath) {
+            console.log(chalk_1.default.red('Usage: /read <file_path>'));
+            return;
+        }
+        try {
+            const content = await this.fileTool.readFile(filePath);
+            console.log(chalk_1.default.cyan('Reading:'), filePath);
+            console.log(content);
+            this.conversationManager.addActiveFile(filePath);
+        }
+        catch (error) {
+            this.logger.error('Error reading file: ' + String(error));
+        }
+    }
+    async handleWriteCommand(args) {
+        if (args.length < 2) {
+            console.log(chalk_1.default.red('Usage: /write <file_path> <content>'));
+            return;
+        }
+        const filePath = args[0];
+        const content = args.slice(1).join(' ');
+        try {
+            await this.fileTool.writeFile(filePath, content);
+            this.logger.success(`Written to ${filePath}`);
+            this.conversationManager.addActiveFile(filePath);
+        }
+        catch (error) {
+            this.logger.error('Error writing file: ' + String(error));
+        }
+    }
+    async handleEditCommand(args) {
+        if (args.length < 3) {
+            console.log(chalk_1.default.red('Usage: /edit <file_path> <search> <replace>'));
+            return;
+        }
+        const filePath = args[0];
+        const search = args[1];
+        const replace = args[2];
+        try {
+            const fileResult = await this.fileTool.readFile(filePath);
+            const originalContent = fileResult.content;
+            this.logger.liveDiff(filePath, originalContent, search, replace);
+            const newContent = originalContent.replace(search, replace);
+            await this.fileTool.writeFile(filePath, newContent);
+            this.logger.success(`Successfully edited ${filePath}`);
+        }
+        catch (error) {
+            this.logger.error(`Error editing file: ${error}`);
+        }
+    }
+    async handleSearchCommand(query) {
+        if (!query) {
+            console.log(chalk_1.default.red('Usage: /search <query> [--path <path>] [--glob <pattern>]'));
+            return;
+        }
+        try {
+            const results = await this.fileTool.searchFiles(query);
+            if (results.length === 0) {
+                this.logger.warning('No matches found.');
+                return;
+            }
+            console.log(chalk_1.default.blue(`Found ${results.length} matches`));
+            results.forEach(result => {
+                console.log(chalk_1.default.white(result.path));
+                result.matches.forEach(match => {
+                    console.log(chalk_1.default.gray(`  Line ${match.line}:`), match.content.trim());
+                });
+            });
+        }
+        catch (error) {
+            this.logger.error('Error searching: ' + String(error));
+        }
+    }
+    async handleRunCommand(command) {
+        if (!command) {
+            console.log(chalk_1.default.red('Usage: /run <command> [--async]'));
+            return;
+        }
+        try {
+            const isAsync = command.includes('--async');
+            const actualCommand = command.replace('--async', '').trim();
+            if (isAsync) {
+                const processId = await this.terminalTool.spawnLongRunningProcess(actualCommand, [], { cwd: this.config.workingDirectory });
+                this.processes.set(processId, actualCommand);
+                this.logger.success(`Started process: ${processId}`);
+                this.logger.info('Use /stop <id> to stop it.');
+            }
+            else {
+                console.log(chalk_1.default.gray('$'), actualCommand);
+                const result = await this.terminalTool.executeCommand(actualCommand, [], { cwd: this.config.workingDirectory });
+                if (result.stdout) {
+                    console.log(result.stdout);
+                }
+                if (result.stderr) {
+                    console.log(chalk_1.default.red(result.stderr));
+                }
+                if (result.exitCode !== 0) {
+                    this.logger.warning(`Exit code: ${result.exitCode}`);
+                }
+                else {
+                    this.logger.success('Command completed successfully');
+                }
+                this.conversationManager.addCommandToHistory(actualCommand);
+            }
+        }
+        catch (error) {
+            this.logger.error('Error running command: ' + String(error));
+        }
+    }
+    async handleStopCommand(commandId) {
+        if (!commandId) {
+            if (this.processes.size === 0) {
+                console.log(chalk_1.default.yellow('No running processes.'));
+                return;
+            }
+            console.log(chalk_1.default.cyan('Running processes:'));
+            this.processes.forEach((_, id) => {
+                console.log(chalk_1.default.gray(`  - ${id}`));
+            });
+            return;
+        }
+        const success = await this.terminalTool.stopProcess(commandId);
+        if (success) {
+            this.processes.delete(commandId);
+            console.log(this.renderer.renderSuccess(`Stopped process: ${commandId}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`Process not found: ${commandId}`));
+        }
+    }
+    async handleCodeSearchCommand(query) {
+        if (!query) {
+            console.log(chalk_1.default.red('Usage: /code <query> [--path <path>] [--max-results <n>]'));
+            return;
+        }
+        try {
+            const results = await this.codeSearchTool.semanticSearch(query);
+            if (results.length === 0) {
+                console.log(chalk_1.default.yellow('No code matches found.'));
+                return;
+            }
+            console.log(chalk_1.default.cyan(`Found ${results.length} code matches:\n`));
+            results.forEach(result => {
+                console.log(chalk_1.default.white(result.filePath));
+                console.log(chalk_1.default.gray(`  Score: ${result.score.toFixed(2)}`));
+                console.log(chalk_1.default.gray(`  Language: ${result.language}`));
+                console.log(chalk_1.default.gray(`  Lines: ${result.startLine}-${result.endLine}`));
+                console.log(chalk_1.default.gray(`  ${result.content.trim().substring(0, 100)}...`));
+                console.log();
+            });
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error searching code:'), error);
+        }
+    }
+    async handleListCommand(path) {
+        try {
+            const entries = await this.fileTool.listDirectory(path);
+            if (entries.length === 0) {
+                console.log(chalk_1.default.yellow('Directory is empty.'));
+                return;
+            }
+            console.log(chalk_1.default.cyan(`Contents of ${path}:\n`));
+            for (const entry of entries) {
+                const fullPath = path.replace(/\/$/, '') + '/' + entry;
+                const exists = await this.fileTool.fileExists(fullPath);
+                const isDir = exists ? (await fs.stat(fullPath)).isDirectory() : false;
+                const icon = isDir ? chalk_1.default.yellow('📁') : chalk_1.default.blue('📄');
+                console.log(`${icon} ${entry}`);
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error listing directory:'), error);
+        }
+    }
+    async handleTodoCommand(args) {
+        const subcommand = args[0];
+        switch (subcommand) {
+            case 'add':
+                this.handleTodoAdd(args.slice(1));
+                break;
+            case 'list':
+                this.handleTodoList();
+                break;
+            case 'done':
+                this.handleTodoDone(args[1]);
+                break;
+            case 'delete':
+                this.handleTodoDelete(args[1]);
+                break;
+            case 'summary':
+                this.showTodoSummary();
+                break;
+            default:
+                console.log(chalk_1.default.red('Usage: /todo <add|list|done|delete|summary> [args]'));
+        }
+    }
+    handleTodoAdd(args) {
+        if (args.length === 0) {
+            this.logger.error('Usage: /todo add <task> [high|medium|low]');
+            return;
+        }
+        const task = args.slice(0, -1).join(' ');
+        const priority = args[args.length - 1] || 'medium';
+        const id = this.todoManager.addTodo(task, priority);
+        this.logger.success(`Added task: ${task} (${id})`);
+    }
+    handleTodoList() {
+        const todos = this.todoManager.getTodoTree();
+        if (todos.length === 0) {
+            this.logger.warning('No tasks.');
+            return;
+        }
+        this.logger.section('Tasks');
+        const printTodo = (todo, indent = 0) => {
+            const prefix = '  '.repeat(indent);
+            const statusIcon = todo.status === 'completed' ? '✓' : todo.status === 'in_progress' ? '→' : '○';
+            const priorityColor = todo.priority === 'high' ? chalk_1.default.red : todo.priority === 'medium' ? chalk_1.default.yellow : chalk_1.default.gray;
+            const statusColor = todo.status === 'completed' ? chalk_1.default.green : chalk_1.default.white;
+            console.log(`${prefix}${statusColor(statusIcon)} ${priorityColor(`[${todo.priority}]`)} ${statusColor(todo.content)}`);
+            if (todo.subtasks && todo.subtasks.length > 0) {
+                todo.subtasks.forEach((subtask) => printTodo(subtask, indent + 1));
+            }
+        };
+        todos.forEach(todo => printTodo(todo));
+    }
+    handleTodoDone(id) {
+        if (!id) {
+            this.logger.error('Usage: /todo done <id>');
+            return;
+        }
+        const success = this.todoManager.setTodoStatus(id, 'completed');
+        if (success) {
+            this.logger.success(`Marked as done: ${id}`);
+        }
+        else {
+            this.logger.error(`Task not found: ${id}`);
+        }
+    }
+    handleTodoDelete(id) {
+        if (!id) {
+            this.logger.error('Usage: /todo delete <id>');
+            return;
+        }
+        const success = this.todoManager.deleteTodo(id);
+        if (success) {
+            this.logger.success(`Deleted task: ${id}`);
+        }
+        else {
+            this.logger.error(`Task not found: ${id}`);
+        }
+    }
+    showTodoSummary() {
+        const summary = this.todoManager.getSummary();
+        this.logger.section('Task Summary');
+        console.log(chalk_1.default.green(`  ✓ Completed: ${summary.completed}`));
+        console.log(chalk_1.default.yellow(`  → In Progress: ${summary.inProgress}`));
+        console.log(chalk_1.default.white(`  ○ Pending: ${summary.pending}`));
+    }
+    async handleMemoryCommand(args) {
+        const subcommand = args[0];
+        switch (subcommand) {
+            case 'add':
+                this.handleMemoryAdd(args.slice(1));
+                break;
+            case 'list':
+                this.handleMemoryList(args[1]);
+                break;
+            case 'delete':
+                this.handleMemoryDelete(args[1]);
+                break;
+            default:
+                console.log(chalk_1.default.red('Usage: /mem <add|list|delete> [args]'));
+        }
+    }
+    handleMemoryAdd(args) {
+        if (args.length < 3) {
+            console.log(chalk_1.default.red('Usage: /mem add <user|project> <category> <content>'));
+            return;
+        }
+        const scope = args[0];
+        const category = args[1];
+        const content = args.slice(2).join(' ');
+        const id = this.memoryManager.addMemory({
+            content,
+            category: category,
+            scope: scope,
+            keywords: content.split(' ').slice(0, 5).join('|'),
+            title: content.substring(0, 50)
+        });
+        console.log(this.renderer.renderSuccess(`Added memory: ${id}`));
+    }
+    handleMemoryList(scope) {
+        const memories = scope === 'user'
+            ? this.memoryManager.getUserMemories()
+            : scope === 'project'
+                ? this.memoryManager.getProjectMemories()
+                : [...this.memoryManager.getUserMemories(), ...this.memoryManager.getProjectMemories()];
+        if (memories.length === 0) {
+            console.log(chalk_1.default.yellow('No memories.'));
+            return;
+        }
+        console.log(chalk_1.default.cyan('Memories:\n'));
+        memories.forEach(mem => {
+            console.log(chalk_1.default.gray(`  [${mem.scope}] [${mem.category}]`));
+            console.log(chalk_1.default.white(`  ${mem.title}`));
+            console.log(chalk_1.default.gray(`  Keywords: ${mem.keywords}`));
+            console.log();
+        });
+    }
+    handleMemoryDelete(id) {
+        if (!id) {
+            console.log(chalk_1.default.red('Usage: /mem delete <id>'));
+            return;
+        }
+        const success = this.memoryManager.deleteMemory(id);
+        if (success) {
+            console.log(this.renderer.renderSuccess(`Deleted memory: ${id}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`Memory not found: ${id}`));
+        }
+    }
+    async handleMcpCommand(args) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        const subcommand = args[0];
+        switch (subcommand) {
+            case 'list':
+                await this.handleMcpList();
+                break;
+            case 'add':
+                await this.handleMcpAdd(args.slice(1));
+                break;
+            case 'remove':
+                await this.handleMcpRemove(args[1]);
+                break;
+            case 'connect':
+                await this.handleMcpConnect(args[1]);
+                break;
+            case 'disconnect':
+                await this.handleMcpDisconnect(args[1]);
+                break;
+            case 'tools':
+                await this.handleMcpTools(args[1]);
+                break;
+            case 'enable':
+                await this.handleMcpEnable(args[1]);
+                break;
+            case 'disable':
+                await this.handleMcpDisable(args[1]);
+                break;
+            default:
+                console.log(chalk_1.default.red('Usage: /mcp <list|add|remove|connect|disconnect|tools|enable|disable> [args]'));
+                console.log(chalk_1.default.gray('  /mcp list              - List all MCP servers'));
+                console.log(chalk_1.default.gray('  /mcp add <name>        - Add a new MCP server (interactive)'));
+                console.log(chalk_1.default.gray('  /mcp remove <name>     - Remove an MCP server'));
+                console.log(chalk_1.default.gray('  /mcp connect <name>    - Connect to an MCP server'));
+                console.log(chalk_1.default.gray('  /mcp disconnect <name> - Disconnect from an MCP server'));
+                console.log(chalk_1.default.gray('  /mcp tools <name>      - List tools from an MCP server'));
+                console.log(chalk_1.default.gray('  /mcp enable <name>    - Enable an MCP server'));
+                console.log(chalk_1.default.gray('  /mcp disable <name>   - Disable an MCP server'));
+        }
+    }
+    async handleMcpList() {
+        try {
+            if (!this.mcpManager) {
+                console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+                return;
+            }
+            const servers = await this.mcpManager.listServers();
+            if (servers.length === 0) {
+                console.log(chalk_1.default.yellow('No MCP servers configured.'));
+                return;
+            }
+            console.log(chalk_1.default.cyan(`MCP Servers (${servers.length}):\n`));
+            for (const server of servers) {
+                if (!server.name)
+                    continue;
+                const isConnected = await this.mcpManager.isConnected(server.name);
+                const status = (server.disabled === true)
+                    ? chalk_1.default.red('disabled')
+                    : (isConnected ? chalk_1.default.green('connected') : chalk_1.default.yellow('disconnected'));
+                const transport = server.transport === 'stdio' ? 'stdio' : 'sse';
+                console.log(chalk_1.default.white(`  ${server.name}`));
+                console.log(chalk_1.default.gray(`    Status: ${status}`));
+                console.log(chalk_1.default.gray(`    Transport: ${transport}`));
+                if (server.transport === 'stdio' && server.command) {
+                    console.log(chalk_1.default.gray(`    Command: ${server.command}`));
+                }
+                console.log();
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error listing MCP servers:'), error);
+        }
+    }
+    async handleMcpAdd(args) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        if (args.length === 0) {
+            console.log(chalk_1.default.red('Usage: /mcp add <server_name>'));
+            return;
+        }
+        const name = args[0];
+        console.log(chalk_1.default.cyan(`Adding MCP server: ${name}`));
+        console.log(chalk_1.default.gray('This will launch an interactive setup. Press Ctrl+C to cancel.\n'));
+        const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const question = (prompt) => {
+            return new Promise((resolve) => {
+                rl.question(prompt, (answer) => resolve(answer));
+            });
+        };
+        try {
+            const transport = await question('Transport (stdio/sse) [default: stdio]: ') || 'stdio';
+            if (transport !== 'stdio' && transport !== 'sse') {
+                console.log(chalk_1.default.red('Invalid transport. Must be stdio or sse.'));
+                rl.close();
+                return;
+            }
+            const config = {
+                name,
+                transport
+            };
+            if (transport === 'stdio') {
+                const command = await question('Command (e.g., npx -y @modelcontextprotocol/server-filesystem): ');
+                if (!command) {
+                    console.log(chalk_1.default.red('Command is required for stdio transport.'));
+                    rl.close();
+                    return;
+                }
+                config.command = command;
+                const argsInput = await question('Arguments (space-separated, optional): ');
+                if (argsInput) {
+                    config.args = argsInput.split(' ');
+                }
+                const envInput = await question('Environment variables (KEY=value, optional): ');
+                if (envInput) {
+                    const env = {};
+                    for (const pair of envInput.split(' ')) {
+                        const [key, value] = pair.split('=');
+                        if (key && value) {
+                            env[key] = value;
+                        }
+                    }
+                    config.env = env;
+                }
+            }
+            else {
+                const url = await question('Server URL: ');
+                if (!url) {
+                    console.log(chalk_1.default.red('URL is required for SSE transport.'));
+                    rl.close();
+                    return;
+                }
+                config.url = url;
+                const headersInput = await question('Headers (JSON format, optional): ');
+                if (headersInput) {
+                    try {
+                        config.headers = JSON.parse(headersInput);
+                    }
+                    catch (error) {
+                        console.log(chalk_1.default.red('Invalid JSON for headers.'));
+                        rl.close();
+                        return;
+                    }
+                }
+            }
+            await this.mcpManager.addServer(config);
+            console.log(this.renderer.renderSuccess(`Added MCP server: ${name}`));
+            await this.updateMCPToolsCache();
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error adding MCP server:'), error);
+        }
+        finally {
+            rl.close();
+        }
+    }
+    async handleMcpRemove(name) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /mcp remove <server_name>'));
+            return;
+        }
+        try {
+            const success = await this.mcpManager.removeServer(name);
+            if (success) {
+                console.log(this.renderer.renderSuccess(`Removed MCP server: ${name}`));
+                this.mcpToolsCache.delete(name);
+            }
+            else {
+                console.log(chalk_1.default.red(`MCP server not found: ${name}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error removing MCP server:'), error);
+        }
+    }
+    async handleMcpConnect(name) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /mcp connect <server_name>'));
+            return;
+        }
+        try {
+            await this.mcpManager.connectServer(name);
+            console.log(this.renderer.renderSuccess(`Connected to MCP server: ${name}`));
+            await this.updateMCPToolsCache();
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error connecting to MCP server:'), error);
+        }
+    }
+    async handleMcpDisconnect(name) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /mcp disconnect <server_name>'));
+            return;
+        }
+        try {
+            await this.mcpManager.disconnectServer(name);
+            console.log(this.renderer.renderSuccess(`Disconnected from MCP server: ${name}`));
+            this.mcpToolsCache.delete(name);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error disconnecting from MCP server:'), error);
+        }
+    }
+    async handleMcpTools(name) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /mcp tools <server_name>'));
+            return;
+        }
+        try {
+            const toolsMap = await this.mcpManager.listTools(name);
+            const tools = toolsMap.get(name);
+            if (!tools || tools.length === 0) {
+                console.log(chalk_1.default.yellow(`No tools found for MCP server: ${name}`));
+                return;
+            }
+            console.log(chalk_1.default.cyan(`Tools from ${name} (${tools.length}):\n`));
+            for (const tool of tools) {
+                console.log(chalk_1.default.white(`  ${tool.name}`));
+                console.log(chalk_1.default.gray(`    Description: ${tool.description || '(none)'}`));
+                console.log();
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error listing tools:'), error);
+        }
+    }
+    async handleMcpEnable(name) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /mcp enable <server_name>'));
+            return;
+        }
+        try {
+            await this.mcpManager.enableServer(name);
+            console.log(this.renderer.renderSuccess(`Enabled MCP server: ${name}`));
+            await this.updateMCPToolsCache();
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error enabling MCP server:'), error);
+        }
+    }
+    async handleMcpDisable(name) {
+        if (!this.mcpManager) {
+            console.log(chalk_1.default.red('MCP is not enabled. Set enableMCP: true in config.'));
+            return;
+        }
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /mcp disable <server_name>'));
+            return;
+        }
+        try {
+            await this.mcpManager.disableServer(name);
+            console.log(this.renderer.renderSuccess(`Disabled MCP server: ${name}`));
+            this.mcpToolsCache.delete(name);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error disabling MCP server:'), error);
+        }
+    }
+    async handlePersonalityCommand(args) {
+        if (!this.personalityManager) {
+            console.log(chalk_1.default.red('Personalities are not enabled.'));
+            return;
+        }
+        const subcommand = args[0];
+        switch (subcommand) {
+            case 'list':
+                this.handlePersonalityList();
+                break;
+            case 'use':
+                await this.handlePersonalityUse(args[1]);
+                break;
+            case 'add':
+                await this.handlePersonalityAdd(args.slice(1));
+                break;
+            case 'remove':
+                await this.handlePersonalityRemove(args[1]);
+                break;
+            case 'import':
+                await this.handlePersonalityImport(args);
+                break;
+            case 'export':
+                await this.handlePersonalityExport(args);
+                break;
+            case 'search':
+                this.handlePersonalitySearch(args[1]);
+                break;
+            case 'clear':
+                this.handlePersonalityClear();
+                break;
+            default:
+                console.log(chalk_1.default.red('Usage: /personality <list|use|add|remove|import|export|search|clear> [args]'));
+                console.log(chalk_1.default.gray('  /personality list                    - List all personalities'));
+                console.log(chalk_1.default.gray('  /personality use <name>              - Use a personality'));
+                console.log(chalk_1.default.gray('  /personality add <json>              - Add a personality from JSON'));
+                console.log(chalk_1.default.gray('  /personality remove <name>           - Remove a personality'));
+                console.log(chalk_1.default.gray('  /personality import <url>             - Import a personality from URL'));
+                console.log(chalk_1.default.gray('  /personality import <file>           - Import a personality from file'));
+                console.log(chalk_1.default.gray('  /personality export <name> <file>    - Export a personality to file'));
+                console.log(chalk_1.default.gray('  /personality search <query>          - Search personalities'));
+                console.log(chalk_1.default.gray('  /personality clear                   - Clear active personality'));
+        }
+    }
+    handlePersonalityList() {
+        const personalities = this.personalityManager?.listPersonalities() || [];
+        if (personalities.length === 0) {
+            console.log(chalk_1.default.yellow('No personalities configured.'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`Personalities (${personalities.length}):\\n`));
+        for (const p of personalities) {
+            const isActive = this.activePersonality?.name === p.name;
+            const status = isActive ? chalk_1.default.green('[active]') : '';
+            console.log(chalk_1.default.white(`  ${p.name} ${status}`));
+            console.log(chalk_1.default.gray(`    Description: ${p.description}`));
+            if (p.author) {
+                console.log(chalk_1.default.gray(`    Author: ${p.author}`));
+            }
+            if (p.tags && p.tags.length > 0) {
+                console.log(chalk_1.default.gray(`    Tags: ${p.tags.join(', ')}`));
+            }
+            console.log();
+        }
+    }
+    async handlePersonalityUse(name) {
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /personality use <name>'));
+            return;
+        }
+        if (!this.personalityManager)
+            return;
+        const personality = this.personalityManager.getPersonality(name);
+        if (!personality) {
+            console.log(chalk_1.default.red(`Personality "${name}" not found.`));
+            return;
+        }
+        this.activePersonality = personality;
+        console.log(this.renderer.renderSuccess(`Using personality: ${personality.name}`));
+        console.log(chalk_1.default.gray(`  ${personality.description}`));
+    }
+    async handlePersonalityAdd(args) {
+        if (!this.personalityManager)
+            return;
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const question = (prompt) => {
+            return new Promise((resolve) => {
+                rl.question(prompt, (answer) => resolve(answer));
+            });
+        };
+        try {
+            if (args.length > 0 && args[0].startsWith('{')) {
+                const jsonStr = args.join(' ');
+                const personality = JSON.parse(jsonStr);
+                await this.personalityManager.addPersonality(personality);
+                console.log(this.renderer.renderSuccess(`Added personality: ${personality.name}`));
+            }
+            else {
+                console.log(chalk_1.default.cyan('Creating a new personality...\\n'));
+                const name = await question('Name: ');
+                if (!name) {
+                    console.log(chalk_1.default.red('Name is required.'));
+                    rl.close();
+                    return;
+                }
+                const description = await question('Description: ');
+                const author = await question('Author (optional): ');
+                const tagsStr = await question('Tags (comma-separated, optional): ');
+                const tags = tagsStr ? tagsStr.split(',').map(t => t.trim()) : [];
+                console.log(chalk_1.default.gray('\\nEnter the system prompt (press Enter on empty line to finish):'));
+                const systemPromptLines = [];
+                while (true) {
+                    const line = await question('> ');
+                    if (line === '')
+                        break;
+                    systemPromptLines.push(line);
+                }
+                const systemPrompt = systemPromptLines.join('\\n');
+                const temperatureStr = await question('Temperature (0-2, optional): ');
+                const temperature = temperatureStr ? parseFloat(temperatureStr) : undefined;
+                const maxTokensStr = await question('Max tokens (optional): ');
+                const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : undefined;
+                const personality = {
+                    name,
+                    description: description || 'No description',
+                    systemPrompt,
+                    temperature,
+                    maxTokens,
+                    version: '1.0.0',
+                    author: author || undefined,
+                    tags
+                };
+                await this.personalityManager.addPersonality(personality);
+                console.log(this.renderer.renderSuccess(`Added personality: ${personality.name}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error adding personality:'), error);
+        }
+        finally {
+            rl.close();
+        }
+    }
+    async handlePersonalityRemove(name) {
+        if (!name) {
+            console.log(chalk_1.default.red('Usage: /personality remove <name>'));
+            return;
+        }
+        if (!this.personalityManager)
+            return;
+        const success = await this.personalityManager.removePersonality(name);
+        if (success) {
+            console.log(this.renderer.renderSuccess(`Removed personality: ${name}`));
+            if (this.activePersonality?.name === name) {
+                this.activePersonality = undefined;
+                console.log(chalk_1.default.gray('Cleared active personality'));
+            }
+        }
+        else {
+            console.log(chalk_1.default.red(`Personality not found: ${name}`));
+        }
+    }
+    async handlePersonalityImport(args) {
+        if (!this.personalityManager)
+            return;
+        if (args.length === 0) {
+            console.log(chalk_1.default.red('Usage: /personality import <url|file>'));
+            return;
+        }
+        const source = args[0];
+        const overwrite = args.includes('--overwrite');
+        try {
+            let personality;
+            if (source.startsWith('http://') || source.startsWith('https://')) {
+                console.log(chalk_1.default.cyan(`Importing personality from URL: ${source}`));
+                personality = await this.personalityManager.importFromURL(source, { overwrite });
+            }
+            else {
+                console.log(chalk_1.default.cyan(`Importing personality from file: ${source}`));
+                personality = await this.personalityManager.importFromFile(source, { overwrite });
+            }
+            console.log(this.renderer.renderSuccess(`Imported personality: ${personality.name}`));
+            console.log(chalk_1.default.gray(`  ${personality.description}`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error importing personality:'), error);
+        }
+    }
+    async handlePersonalityExport(args) {
+        if (!this.personalityManager)
+            return;
+        if (args.length < 2) {
+            console.log(chalk_1.default.red('Usage: /personality export <name> <output_file>'));
+            return;
+        }
+        const name = args[0];
+        const outputFile = args[1];
+        try {
+            await this.personalityManager.exportToFile(name, outputFile);
+            console.log(this.renderer.renderSuccess(`Exported personality "${name}" to ${outputFile}`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error exporting personality:'), error);
+        }
+    }
+    handlePersonalitySearch(query) {
+        if (!query) {
+            console.log(chalk_1.default.red('Usage: /personality search <query>'));
+            return;
+        }
+        if (!this.personalityManager)
+            return;
+        const results = this.personalityManager.search(query);
+        if (results.length === 0) {
+            console.log(chalk_1.default.yellow('No matching personalities found.'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`Found ${results.length} matching personalities:\\n`));
+        for (const p of results) {
+            console.log(chalk_1.default.white(`  ${p.name}`));
+            console.log(chalk_1.default.gray(`    Description: ${p.description}`));
+            console.log();
+        }
+    }
+    handlePersonalityClear() {
+        if (!this.activePersonality) {
+            console.log(chalk_1.default.yellow('No active personality to clear.'));
+            return;
+        }
+        const name = this.activePersonality.name;
+        this.activePersonality = undefined;
+        console.log(this.renderer.renderSuccess(`Cleared active personality: ${name}`));
+    }
+    showContext() {
+        const context = this.conversationManager.getContext();
+        const summary = this.todoManager.getSummary();
+        console.log(chalk_1.default.cyan('Current Context:\n'));
+        console.log(chalk_1.default.gray('Working Directory:'), chalk_1.default.white(context.workingDirectory));
+        console.log(chalk_1.default.gray('Active Files:'), chalk_1.default.white(context.activeFiles.size > 0 ? Array.from(context.activeFiles).join(', ') : '(none)'));
+        console.log(chalk_1.default.gray('Message History:'), chalk_1.default.white(`${context.messages.length} messages`));
+        console.log(chalk_1.default.gray('Task Progress:'), chalk_1.default.white(`${summary.completed}/${summary.total} (${summary.completionPercentage}%)`));
+    }
+    showHelp() {
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(chalk_1.default.cyan('Available Commands:\n'));
+        console.log(chalk_1.default.white('  /setup                '), chalk_1.default.gray('Run interactive setup'));
+        console.log(chalk_1.default.white('  /read <file>          '), chalk_1.default.gray('Read a file'));
+        console.log(chalk_1.default.white('  /write <file> <text>  '), chalk_1.default.gray('Write content to a file'));
+        console.log(chalk_1.default.white('  /edit <file> <search> <replace>'), chalk_1.default.gray('Edit a file'));
+        console.log(chalk_1.default.white('  /search <query>       '), chalk_1.default.gray('Search in files'));
+        console.log(chalk_1.default.white('  /code <query>         '), chalk_1.default.gray('Semantic code search'));
+        console.log(chalk_1.default.white('  /ls [path]            '), chalk_1.default.gray('List directory contents'));
+        console.log(chalk_1.default.white('  /run <cmd> [--async]  '), chalk_1.default.gray('Run a command'));
+        console.log(chalk_1.default.white('  /stop [id]            '), chalk_1.default.gray('Stop a running process'));
+        console.log(chalk_1.default.white('  /todo <subcmd>        '), chalk_1.default.gray('Manage tasks (add/list/done/delete/summary)'));
+        console.log(chalk_1.default.white('  /mem <subcmd>         '), chalk_1.default.gray('Manage memories (add/list/delete)'));
+        console.log(chalk_1.default.white('  /mcp <subcmd>         '), chalk_1.default.gray('Manage MCP servers (list/add/remove/connect/disconnect/tools/enable/disable)'));
+        console.log(chalk_1.default.white('  /context              '), chalk_1.default.gray('Show current context'));
+        console.log(chalk_1.default.white('  /clear                '), chalk_1.default.gray('Clear the screen'));
+        console.log(chalk_1.default.white('  help                  '), chalk_1.default.gray('Show this help message'));
+        console.log(chalk_1.default.white('  exit/quit             '), chalk_1.default.gray('Exit Kaze CLI'));
+    }
+    async sendMessage(message) {
+        const userMessage = {
+            role: 'user',
+            content: message,
+            timestamp: Date.now()
+        };
+        this.tui.appendHistory(`User: ${message}`);
+        this.tui.markDirty();
+        this.tui.render();
+        const contextStr = this.buildContext();
+        const messages = [
+            ...this.conversationManager.getRecentMessages(this.config.maxHistory),
+            userMessage
+        ];
+        this.conversationManager.addMessage(userMessage);
+        let systemPrompt;
+        if (this.activePersonality) {
+            const personality = this.activePersonality;
+            const capabilitiesSection = `
+## Your Capabilities
+
+### File Operations
+- **read_file**: Read the contents of a file
+- **edit_file**: Edit a file using search and replace (DIFF MODE - PREFERRED for editing existing files)
+- **write_file**: Write content to a file (overwrites existing content)
+- **search_files**: Search for files in the codebase
+
+### Command Execution
+- **execute_command**: Run shell commands (install dependencies, run tests, build projects, etc.)
+`;
+            systemPrompt = `${personality.systemPrompt}
+
+${capabilitiesSection}
+
+## Context Information
+${contextStr}`;
+        }
+        else {
+            systemPrompt = `You are a powerful AI coding assistant that helps users with software engineering tasks. You have access to tools that allow you to interact with the user's codebase.
+
+## Your Capabilities
+
+### File Operations
+- **read_file**: Read the contents of a file
+- **edit_file**: Edit a file using search and replace (DIFF MODE - PREFERRED for editing existing files)
+- **write_file**: Write content to a file (overwrites existing content)
+- **search_files**: Search for files in the codebase
+
+### Command Execution
+- **execute_command**: Run shell commands (install dependencies, run tests, build projects, etc.)
+
+## Guidelines
+
+1. **Be Proactive**: Take initiative to help users with their tasks. When users ask you to do something, do it rather than just explaining how.
+
+2. **Default to edit_file**: 
+   - **ALWAYS use edit_file (diff mode) as the DEFAULT method for editing existing files**
+   - Only use write_file when creating entirely new files or completely overwriting a file
+   - The edit_file tool provides real-time progress feedback and shows exactly what changes are being made
+   - It shows a detailed diff with line-by-line changes before applying them
+
+3. **Use Tools Appropriately**: 
+   - Read files to understand the codebase before making changes
+   - Use search to find relevant files
+   - Run commands to test your changes (build, test, lint)
+   - Never assume a library exists - check the codebase first
+
+4. **Follow Conventions**:
+   - Mimic the existing code style and patterns
+   - Use existing libraries and utilities
+   - Follow security best practices (never expose secrets)
+
+5. **Code Style**: Do not add any comments to code unless explicitly asked.
+
+6. **Task Management**: Use the todo system to track complex tasks. Create specific, actionable items and update them as you progress.
+
+7. **Communication**: Be clear and educational. Provide helpful insights while remaining focused on the task.
+
+## Context Information
+${contextStr}`;
+        }
+        messages.unshift({
+            role: 'system',
+            content: systemPrompt
+        });
+        const apiMessages = messages.map(msg => ({
+            role: msg.role,
+            content: msg.content,
+            tool_calls: msg.tool_calls,
+            tool_call_id: msg.tool_call_id
+        }));
+        let assistantToolCalls;
+        let fullResponse = '';
+        let hasToolCalls = false;
+        const effectiveTemperature = this.activePersonality?.temperature ?? this.config.temperature;
+        const effectiveMaxTokens = this.activePersonality?.maxTokens ?? this.config.maxTokens;
+        try {
+            this.logger.startThinking();
+            const response = this.client.chatStreamIterable({
+                model: this.config.model,
+                messages: apiMessages,
+                tools: this.config.enableTools ? this.getTools() : undefined,
+                tool_choice: this.config.enableTools ? 'auto' : undefined,
+                stream: true,
+                max_tokens: effectiveMaxTokens,
+                temperature: effectiveTemperature
+            });
+            let firstChunk = true;
+            let assistantResponse = '';
+            for await (const chunk of response) {
+                if (firstChunk) {
+                    this.logger.stopThinking();
+                    this.tui.appendHistory('Assistant: ');
+                    console.log('');
+                }
+                const delta = chunk.choices[0]?.delta;
+                if (delta?.content) {
+                    process.stdout.write(delta.content);
+                    fullResponse += delta.content;
+                    assistantResponse += delta.content;
+                }
+                if (delta?.tool_calls && this.config.enableTools) {
+                    hasToolCalls = true;
+                    if (!assistantToolCalls) {
+                        assistantToolCalls = [];
+                    }
+                    for (const toolCall of delta.tool_calls) {
+                        const existingIndex = assistantToolCalls.findIndex(tc => tc.id === toolCall.id);
+                        if (existingIndex >= 0) {
+                            assistantToolCalls[existingIndex] = toolCall;
+                        }
+                        else {
+                            assistantToolCalls.push(toolCall);
+                        }
+                    }
+                }
+                firstChunk = false;
+            }
+            console.log('');
+            this.tokensUsed += (message.length + assistantResponse.length);
+            this.tui.setInfo({ tokensUsed: this.tokensUsed });
+            this.tui.appendHistory(assistantResponse);
+            this.tui.markDirty();
+            if (hasToolCalls && assistantToolCalls) {
+                const assistantMessage = {
+                    role: 'assistant',
+                    content: fullResponse,
+                    tool_calls: assistantToolCalls,
+                    timestamp: Date.now()
+                };
+                this.conversationManager.addMessage(assistantMessage);
+                for (const toolCall of assistantToolCalls) {
+                    const result = await this.executeToolCall(toolCall);
+                    this.conversationManager.addMessage({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: JSON.stringify(result)
+                    });
+                }
+                let moreToolCalls = true;
+                while (moreToolCalls) {
+                    this.logger.startThinking();
+                    const followUpMessages = [
+                        ...this.conversationManager.getRecentMessages(this.config.maxHistory)
+                    ];
+                    const followUpApiMessages = followUpMessages.map(msg => ({
+                        role: msg.role,
+                        content: msg.content,
+                        tool_calls: msg.tool_calls,
+                        tool_call_id: msg.tool_call_id
+                    }));
+                    const followUpResponse = this.client.chatStreamIterable({
+                        model: this.config.model,
+                        messages: followUpApiMessages,
+                        tools: this.config.enableTools ? this.getTools() : undefined,
+                        tool_choice: this.config.enableTools ? 'auto' : undefined,
+                        stream: true
+                    });
+                    let followUpToolCalls;
+                    fullResponse = '';
+                    let firstFollowUpChunk = true;
+                    for await (const chunk of followUpResponse) {
+                        const delta = chunk.choices[0]?.delta;
+                        if (firstFollowUpChunk) {
+                            this.logger.stopThinking();
+                            console.log('');
+                            firstFollowUpChunk = false;
+                        }
+                        if (delta?.content) {
+                            process.stdout.write(delta.content);
+                            fullResponse += delta.content;
+                        }
+                        if (delta?.tool_calls && this.config.enableTools) {
+                            moreToolCalls = true;
+                            if (!followUpToolCalls) {
+                                followUpToolCalls = [];
+                            }
+                            for (const toolCall of delta.tool_calls) {
+                                const existingIndex = followUpToolCalls.findIndex(tc => tc.id === toolCall.id);
+                                if (existingIndex >= 0) {
+                                    followUpToolCalls[existingIndex] = toolCall;
+                                }
+                                else {
+                                    followUpToolCalls.push(toolCall);
+                                }
+                            }
+                        }
+                    }
+                    console.log('');
+                    if (followUpToolCalls && followUpToolCalls.length > 0) {
+                        const followUpAssistantMessage = {
+                            role: 'assistant',
+                            content: fullResponse,
+                            tool_calls: followUpToolCalls,
+                            timestamp: Date.now()
+                        };
+                        this.conversationManager.addMessage(followUpAssistantMessage);
+                        for (const toolCall of followUpToolCalls) {
+                            const result = await this.executeToolCall(toolCall);
+                            this.conversationManager.addMessage({
+                                role: 'tool',
+                                tool_call_id: toolCall.id,
+                                content: JSON.stringify(result)
+                            });
+                        }
+                    }
+                    else {
+                        moreToolCalls = false;
+                        const finalAssistantMessage = {
+                            role: 'assistant',
+                            content: fullResponse,
+                            timestamp: Date.now()
+                        };
+                        this.conversationManager.addMessage(finalAssistantMessage);
+                    }
+                }
+            }
+            else {
+                console.log('');
+                const assistantMessage = {
+                    role: 'assistant',
+                    content: fullResponse,
+                    timestamp: Date.now()
+                };
+                this.conversationManager.addMessage(assistantMessage);
+            }
+        }
+        catch (error) {
+            this.logger.stopThinking();
+            this.logger.error(String(error));
+        }
+    }
+    buildContext() {
+        const memories = [...this.memoryManager.getUserMemories(), ...this.memoryManager.getProjectMemories()];
+        const activeFiles = Array.from(this.conversationManager.getContext().activeFiles);
+        const summary = this.todoManager.getSummary();
+        const parts = [];
+        if (this.config.workingDirectory) {
+            parts.push(`Working Directory: ${this.config.workingDirectory}`);
+        }
+        if (activeFiles.length > 0) {
+            parts.push(`Active Files: ${activeFiles.join(', ')}`);
+        }
+        if (summary.total > 0) {
+            parts.push(`Task Progress: ${summary.completed}/${summary.total} (${summary.completionPercentage}%)`);
+        }
+        if (memories.length > 0) {
+            parts.push('\nRelevant Memories:');
+            memories.forEach(mem => {
+                parts.push(`- [${mem.scope}][${mem.category}] ${mem.title}`);
+            });
+        }
+        return parts.length > 0 ? parts.join('\n') : '';
+    }
+    getTools() {
+        const tools = [
+            {
+                type: 'function',
+                function: {
+                    name: 'read_file',
+                    description: 'Read the contents of a file',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            file_path: {
+                                type: 'string',
+                                description: 'The absolute path to the file to read'
+                            }
+                        },
+                        required: ['file_path']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'edit_file',
+                    description: '✨ DEFAULT EDITING METHOD - Edit a file using search and replace with real-time progress tracking. This provides visual feedback showing the percentage complete and displays a detailed diff of changes. This is the PREFERRED method for editing existing files. When you choose to use this tool to edit an existing file, you MUST follow the SEARCH/REPLACE Rules to set the old_str and new_str parameters: 1. The old_str is the SEARCH section that should be a contiguous chunk of lines to search for in the existing source code. 2. The new_str is the REPLACE section that should be lines to replace into the source code. 3. The REPLACE section MUST be different from the SEARCH section. This tool will only replace the first match occurrence of the SEARCH section. Include enough lines in the SEARCH section to uniquely match the set of lines that need to change. Keep your SEARCH and REPLACE sections concise. Include just the changing lines, and a few surrounding lines if needed for uniqueness. Only create SEARCH/REPLACE sections for files that the user has added to the chat. If you want to move code within a file, you need to make two separate edit operations: delete the original code chunk and then insert it in another location.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            file_path: {
+                                type: 'string',
+                                description: 'The absolute path to the file to edit'
+                            },
+                            old_str: {
+                                type: 'string',
+                                description: 'The SEARCH section that should be a contiguous chunk of lines to search for in the existing source code'
+                            },
+                            new_str: {
+                                type: 'string',
+                                description: 'The REPLACE section that should be lines to replace into the source code'
+                            }
+                        },
+                        required: ['file_path', 'old_str', 'new_str']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'write_file',
+                    description: 'Write content to a file (overwrites existing content). ALWAYS prefer editing existing files in the codebase. NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            file_path: {
+                                type: 'string',
+                                description: 'The absolute path to the file to write'
+                            },
+                            content: {
+                                type: 'string',
+                                description: 'The content to write to the file'
+                            }
+                        },
+                        required: ['file_path', 'content']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'search_files',
+                    description: 'Search for files in the codebase by filename or content. Use this when you need to find specific files by name or search within file contents.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: {
+                                type: 'string',
+                                description: 'The search query (filename pattern or content to search within files)'
+                            },
+                            search_mode: {
+                                type: 'string',
+                                enum: ['filename', 'content', 'both'],
+                                description: 'Search mode: filename (find files by name), content (search file contents), or both'
+                            }
+                        },
+                        required: ['query']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'execute_command',
+                    description: 'Run shell commands (install dependencies, run tests, build projects, etc.). Do NOT use this for file editing operations - use edit_file or write_file instead.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            command: {
+                                type: 'string',
+                                description: 'The shell command to execute'
+                            }
+                        },
+                        required: ['command']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'search_code',
+                    description: 'Search the codebase using semantic search',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: {
+                                type: 'string',
+                                description: 'The query to search for in the codebase'
+                            }
+                        },
+                        required: ['query']
+                    }
+                }
+            }
+        ];
+        for (const [serverName, serverTools] of this.mcpToolsCache) {
+            tools.push(...serverTools);
+        }
+        return tools;
+    }
+    async executeToolCall(toolCall) {
+        const { name, arguments: argsString } = toolCall.function;
+        try {
+            const args = JSON.parse(argsString);
+            let result;
+            const startTime = Date.now();
+            switch (name) {
+                case 'read_file':
+                    this.logger.toolAction('Read File', 'Read the contents of a file', { file: args.file_path });
+                    result = await this.fileTool.readFile(args.file_path);
+                    break;
+                case 'edit_file':
+                    this.logger.toolAction('Edit File', 'Edit a file using search and replace', { file: args.file_path });
+                    this.fileTool.onEditProgress((step, progress, total, message) => {
+                        this.logger.editProgress(step, progress, total, message);
+                    });
+                    const originalResult = await this.fileTool.readFile(args.file_path);
+                    const original = originalResult.content;
+                    const editResult = await this.fileTool.editFile(args.file_path, args.old_str, args.new_str);
+                    this.logger.fileEdit(original, original.replace(args.old_str, args.new_str), args.file_path);
+                    // Calculate lines added/removed
+                    const originalLines = original.split('\n');
+                    const newLines = original.replace(args.old_str, args.new_str).split('\n');
+                    const linesAdded = Math.max(0, newLines.length - originalLines.length);
+                    const linesRemoved = Math.max(0, originalLines.length - newLines.length);
+                    this.logger.editFileAction(args.file_path, linesAdded, linesRemoved);
+                    result = editResult;
+                    this.fileTool.onEditProgress(null);
+                    break;
+                case 'write_file':
+                    this.logger.toolAction('Write File', 'Write content to a file', { file: args.file_path });
+                    try {
+                        const exists = await this.fileTool.fileExists(args.file_path);
+                        if (exists) {
+                            const originalResult = await this.fileTool.readFile(args.file_path);
+                            const original = originalResult.content;
+                            this.logger.fileEdit(original, args.content, args.file_path);
+                        }
+                        result = await this.fileTool.writeFile(args.file_path, args.content);
+                        const lines = args.content.split('\n').length;
+                        const size = Buffer.byteLength(args.content, 'utf8');
+                        this.logger.writeFileAction(args.file_path, lines, size);
+                    }
+                    catch (e) {
+                        result = await this.fileTool.writeFile(args.file_path, args.content);
+                        const lines = args.content.split('\n').length;
+                        const size = Buffer.byteLength(args.content, 'utf8');
+                        this.logger.writeFileAction(args.file_path, lines, size);
+                    }
+                    break;
+                case 'search_files':
+                    this.logger.toolAction('Search Files', 'Search for files by name or content', { query: args.query, mode: args.search_mode });
+                    result = await this.fileTool.searchFiles(args.query, {
+                        path: this.config.workingDirectory,
+                        searchMode: args.search_mode || 'filename'
+                    });
+                    const resultsFound = result.reduce((acc, r) => acc + r.matches.length, 0);
+                    this.logger.searchFilesAction(args.query, args.search_mode || 'filename', resultsFound, result.length);
+                    break;
+                case 'execute_command':
+                    this.logger.toolAction('Execute Command', 'Run shell commands', { command: args.command });
+                    const execResult = await this.terminalTool.executeCommand(args.command, [], {
+                        cwd: this.config.workingDirectory
+                    });
+                    const duration = Date.now() - startTime;
+                    this.logger.executeCommandAction(args.command, execResult.exitCode, duration);
+                    result = execResult;
+                    break;
+                case 'search_code':
+                    this.logger.toolAction('Search Code', 'Search codebase using semantic search', { query: args.query });
+                    result = await this.codeSearchTool.semanticSearch(args.query);
+                    this.logger.searchCodeAction(args.query, result.length);
+                    break;
+                default:
+                    if (this.mcpManager && name.includes('_')) {
+                        const [serverName, ...toolParts] = name.split('_');
+                        const toolName = toolParts.join('_');
+                        const displayName = toolName.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+                        this.logger.toolAction(serverName, displayName, args);
+                        try {
+                            result = await this.mcpManager.callTool(serverName, toolName, args);
+                        }
+                        catch (error) {
+                            // MCP tool call failed - return error instead of crashing
+                            this.logger.error(`MCP tool call failed for ${serverName}.${toolName}: ${error instanceof Error ? error.message : String(error)}`);
+                            result = { error: `MCP tool call failed: ${error instanceof Error ? error.message : String(error)}` };
+                        }
+                    }
+                    else {
+                        this.logger.toolAction('Unknown', name, args);
+                        result = { error: `Unknown tool: ${name}` };
+                    }
+            }
+            return result;
+        }
+        catch (error) {
+            return { error: String(error) };
+        }
+    }
+    async handleToolCall(toolCall) {
+        const { name } = toolCall.function;
+        console.log(chalk_1.default.gray(`\n[Tool: ${name}]`));
+        const result = await this.executeToolCall(toolCall);
+        console.log(chalk_1.default.gray(JSON.stringify(result, null, 2)));
+    }
+}
+exports.REPL = REPL;
+//# sourceMappingURL=repl.js.map