recoder-code 2.2.0 → 2.2.2

package/cli/interactive.js

@@ -25,6 +25,7 @@ const TaskManager = require('./task-manager.js');
 const DevToolsIntegration = require('./dev-tools-integration.js');
 const VisionAnalyzer = require('./vision-analyzer.js');
 const NaturalLanguageProcessor = require('./natural-language-processor.js');
+const TodoManager = require('./todo-manager.js');
 
 // Create logs and sessions directories
 const logsDir = path.join(process.cwd(), 'logs');
@@ -35,10 +36,17 @@ const sessionsDir = path.join(process.cwd(), 'sessions');
   }
 });
 
+// Initialize unified error handling for interactive mode
+const UnifiedErrorHandler = require('./unified-error-handler.js');
+const errorHandler = UnifiedErrorHandler.instance;
+errorHandler.initialize();
+
 class InteractiveRecoderChat {
   constructor() {
-    this.apiKey = config.apiKey;
-    this.model = config.model;
+    // Load user configuration
+    this.userConfig = this.loadUserConfig();
+    this.apiKey = this.userConfig.apiKey || config.apiKey;
+    this.model = this.userConfig.model || config.model;
     this.maxTokens = config.maxTokens;
     this.temperature = config.temperature;
     
@@ -87,8 +95,10 @@ class InteractiveRecoderChat {
     // Initialize plugin manager
     this.pluginManager = new PluginManager();
     
-    // Initialize voice manager
+    // Initialize voice manager (silently disabled)
     this.voiceManager = new VoiceManager();
+    // Silently disable TTS without console output
+    this.voiceManager.ttsEnabled = false;
     
     // Initialize collaboration manager
     this.collaborationManager = new CollaborationManager();
@@ -104,6 +114,12 @@ class InteractiveRecoderChat {
       sessionId: this.sessionId
     });
     
+    // Initialize todo manager for production-ready task tracking
+    this.todoManager = new TodoManager({ user: process.env.USER || 'developer' });
+
+    // Add comprehensive promise rejection handling
+    this.setupGlobalErrorHandlers();
+    
     // Initialize advanced systems
     this.contextEngine = null;
     this.slashCommands = null;
@@ -115,6 +131,14 @@ class InteractiveRecoderChat {
     this.visionAnalyzer = null;
     this.nlProcessor = null;
     
+    // Enhanced conversation tracking
+    this.conversationHistory = [];
+    this.currentSession = {
+      startTime: Date.now(),
+      messageCount: 0,
+      lastActivity: Date.now()
+    };
+    
     this.initializeAdvancedSystems().catch(error => {
       console.log(chalk.yellow(`⚠️  Advanced features initialization failed: ${error.message}`));
     });
@@ -122,46 +146,15 @@ class InteractiveRecoderChat {
     // Initialize project manager for persistence
     this.projectManager = new ProjectManager();
     
+    // Always initialize readline interface first to prevent errors
+    this.initializeReadlineInterface();
+    
     if (!this.apiKey) {
-      console.log(chalk.red('❌ Error: OPENROUTER_API_KEY environment variable is required'));
-      console.log(chalk.yellow('Please set your OpenRouter API key:'));
-      console.log(chalk.gray('export OPENROUTER_API_KEY=your_api_key_here'));
-      process.exit(1);
+      this.promptForApiKey();
+      return;
     }
 
-    // Initialize OpenAI client with OpenRouter configuration
-    this.openai = new OpenAI({
-      baseURL: config.baseURL,
-      apiKey: this.apiKey,
-      defaultHeaders: {
-        'HTTP-Referer': config.siteUrl,
-        'X-Title': config.siteName,
-      },
-    });
-
-    // Initialize readline interface with enhanced options
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      prompt: chalk.magenta('▶ ') + chalk.white.bold('You: '),
-      historySize: 100,
-      removeHistoryDuplicates: true,
-      completer: this.autoComplete.bind(this)
-    });
-
-    // Set up custom prompt and keyboard shortcuts
-    this.updatePrompt();
-    this.setupKeyboardShortcuts();
-
-    this.setupEventHandlers();
-    this.initializeFileWatcher();
-    this.analyzeProjectContext().catch(error => {
-      console.log(chalk.yellow(`⚠️  Project context analysis failed: ${error.message}`));
-    });
-    this.loadPlugins().catch(error => {
-      console.log(chalk.yellow(`⚠️  Plugin loading failed: ${error.message}`));
-    });
-    this.displayWelcome();
+    this.initializeWithApiKey();
   }
 
   /**
@@ -169,54 +162,69 @@ class InteractiveRecoderChat {
    */
   async initializeAdvancedSystems() {
     try {
-      console.log(chalk.gray('🚀 Initializing advanced features...'));
+      // Silently initialize advanced features (no console.log for clean startup)
       
       // Initialize context engine for codebase understanding
       this.contextEngine = new ContextEngine();
-      await this.contextEngine.initialize();
+      try {
+        await this.contextEngine.initialize();
+      } catch (contextError) {
+        console.log(chalk.yellow(`⚠️  Context engine initialization failed: ${contextError.message}`));
+      }
       
       // Initialize MCP client for model communication
       this.mcpClient = new MCPClient();
-      await this.mcpClient.initialize();
       
       // Initialize model manager with MCP and context engine
       this.modelManager = new ModelManager(this.mcpClient, this.contextEngine);
       
       // Initialize rules engine with project context
       this.rulesEngine = new RulesEngine(this.projectManager);
-      await this.rulesEngine.autoDiscoverProjectRules();
+      try {
+        await this.rulesEngine.autoDiscoverProjectRules();
+      } catch (rulesError) {
+        console.log(chalk.yellow(`⚠️  Rules engine initialization failed: ${rulesError.message}`));
+      }
       
       // Initialize task manager with full integration
       this.taskManager = new TaskManager(this.projectManager, this.contextEngine, this.rulesEngine);
-      this.taskManager.setupSmartAutomationTriggers();
+      try {
+        this.taskManager.setupSmartAutomationTriggers();
+      } catch (automationError) {
+        console.log(chalk.yellow(`⚠️  Automation setup failed: ${automationError.message}`));
+      }
       
       // Initialize development tools integration
       this.devTools = new DevToolsIntegration(this.contextEngine, this.projectManager, this.taskManager);
-      await this.devTools.setupIDEIntegration();
-      await this.devTools.setupGitIntegration();
-      await this.devTools.setupDatabaseIntegration();
-      await this.devTools.setupPerformanceMonitoring();
+      try {
+        await this.devTools.setupIDEIntegration();
+        await this.devTools.setupGitIntegration();
+        await this.devTools.setupDatabaseIntegration();
+        await this.devTools.setupPerformanceMonitoring();
+      } catch (devToolsError) {
+        console.log(chalk.yellow(`⚠️  Dev tools setup failed: ${devToolsError.message}`));
+      }
       
       // Initialize vision analyzer with model manager and context engine
       this.visionAnalyzer = new VisionAnalyzer(this.modelManager, this.contextEngine);
       
-      // Initialize slash commands system with all dependencies including vision analyzer
-      this.slashCommands = new SlashCommandsEngine(this.contextEngine, this.projectManager, this.visionAnalyzer);
+      // Initialize slash commands system with all dependencies including vision analyzer and todo manager
+      this.slashCommands = new SlashCommandsEngine(this.contextEngine, this.projectManager, this.visionAnalyzer, this.todoManager);
       
       // Initialize natural language processor with access to all systems
       this.nlProcessor = new NaturalLanguageProcessor(this);
       
       // Set up system integrations
-      await this.setupSystemIntegrations();
+      try {
+        await this.setupSystemIntegrations();
+      } catch (integrationError) {
+        console.log(chalk.yellow(`⚠️  System integrations setup failed: ${integrationError.message}`));
+      }
       
       // Enable auto model switching based on context
       this.enableIntelligentModelSwitching();
       
-      console.log(chalk.green('✅ Advanced features initialized and integrated'));
-      console.log(chalk.gray(`   🤖 Model Manager: ${this.modelManager.models.size} models available`));
-      console.log(chalk.gray(`   📋 Rules Engine: Auto-discovered project rules`));
-      console.log(chalk.gray(`   🎯 Task Manager: Automation triggers active`));
-      console.log(chalk.gray(`   🔧 Dev Tools: Native integrations enabled`));
+      // Advanced features initialized silently
       
     } catch (error) {
       console.log(chalk.yellow(`⚠️  Some advanced features may be limited: ${error.message}`));
@@ -403,9 +411,9 @@ class InteractiveRecoderChat {
     const convIndicator = this.currentConversationId === 'main' ? '' : chalk.gray(`[${currentConv.name}] `);
     
     if (this.multiLineMode) {
-      this.rl.setPrompt(chalk.magenta('┃ ') + chalk.gray('... '));
+      this.rl.setPrompt(chalk.gray('... '));
     } else {
-      this.rl.setPrompt(convIndicator + chalk.magenta('▶ ') + chalk.white.bold('You: '));
+      this.rl.setPrompt(convIndicator + chalk.gray('> '));
     }
   }
 
@@ -793,6 +801,11 @@ class InteractiveRecoderChat {
         case 14: // Ctrl+N (New/Clear conversation)
           this.handleCtrlN();
           break;
+          
+        case 27: // ESC (Exit)
+          console.log(chalk.yellow('\n👋 Goodbye!'));
+          process.exit(0);
+          break;
       }
     }
   }
@@ -978,111 +991,723 @@ class InteractiveRecoderChat {
     });
   }
 
-  displayWelcome() {
+  promptForApiKey() {
     console.clear();
-    
-    // Stunning purple/gray/black UI with recoder.xyz branding
-    console.log('');
-    console.log(chalk.magenta.bold('╭─────────────────────────────────────────────────────────────────╮'));
-    console.log(chalk.magenta.bold('│') + chalk.black.bgMagenta.bold('                        RECODER.XYZ                        ') + chalk.magenta.bold('│'));
-    console.log(chalk.magenta.bold('│') + chalk.gray('                  AI-Powered Development Terminal              ') + chalk.magenta.bold('│'));
-    console.log(chalk.magenta.bold('╰─────────────────────────────────────────────────────────────────╯'));
-    console.log('');
-    
-    // ASCII Art Logo
-    console.log(chalk.magenta.bold('██████╗ ███████╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗'));
-    console.log(chalk.magenta.bold('██╔══██╗██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗'));
-    console.log(chalk.magenta.bold('██████╔╝█████╗  ██║     ██║   ██║██║  ██║█████╗  ██████╔╝'));
-    console.log(chalk.gray('██╔══██╗██╔══╝  ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗'));
-    console.log(chalk.gray('██║  ██║███████╗╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║'));
-    console.log(chalk.gray('╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝'));
     console.log('');
-    
-    // Status Bar
-    console.log(chalk.magenta('▶ ') + chalk.white.bold('Ready') + chalk.gray(' │ ') + chalk.gray(`${process.cwd()}`));
-    console.log(chalk.gray('─'.repeat(65)));
+    console.log(chalk.magenta('╭─────────────────────────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  ✨ Welcome to Recoder Code                                ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────────────────────────╯'));
     console.log('');
-    
-    // Show session suggestions if available
-    this.showSessionSuggestions();
-    
-    // Quick actions
-    console.log(chalk.magenta('⚡ ') + chalk.white.bold('Quick Actions:'));
-    console.log(chalk.gray('  • ') + chalk.cyan('/help') + chalk.gray(' - Show available commands'));
-    console.log(chalk.gray('  • ') + chalk.cyan('/status') + chalk.gray(' - System status & configuration'));
-    console.log(chalk.gray('  • ') + chalk.cyan('/models') + chalk.gray(' - Switch AI models'));
+    console.log(chalk.white('🔑 API key required to continue'));
+    console.log(chalk.gray('Get your free API key at: ') + chalk.magenta('https://openrouter.ai'));
     console.log('');
     
-    console.log(chalk.magenta('💬 ') + chalk.white.bold('Start coding with AI assistance!'));
-    console.log(chalk.gray('✨ Try: ') + chalk.cyan('"build a React app"') + chalk.gray(' or ') + chalk.cyan('"debug my Python code"'));
-    console.log('');
+    const keyPrompt = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
     
+    keyPrompt.question(chalk.magenta('Enter your OpenRouter API key: '), (apiKey) => {
+      keyPrompt.close();
+      
+      if (!apiKey || apiKey.trim() === '') {
+        console.log(chalk.red('No API key provided. Exiting...'));
+        process.exit(1);
+      }
+      
+      // Save the API key to environment
+      process.env.OPENROUTER_API_KEY = apiKey.trim();
+      this.apiKey = apiKey.trim();
+      
+      // Continue initialization
+      this.initializeWithApiKey();
+    });
+  }
+  
+  initializeReadlineInterface() {
+    // Initialize readline interface with enhanced options
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: chalk.gray('> '),
+      historySize: 100,
+      removeHistoryDuplicates: true,
+      completer: (line) => this.autoComplete(line)
+    });
+
+    // Set up readline event handlers
+    this.setupReadlineHandlers();
+  }
+
+  setupReadlineHandlers() {
+    if (!this.rl) return;
+
+    this.rl.on('line', async (input) => {
+      await this.handleUserInput(input.trim());
+    });
+
+    this.rl.on('close', () => {
+      console.log('\nGoodbye!');
+      process.exit(0);
+    });
+
+    // Handle advanced keyboard shortcuts
+    process.stdin.on('keypress', (str, key) => {
+      if (key && key.ctrl) {
+        this.handleCtrlKeys(key);
+      }
+    });
+  }
+
+  initializeWithApiKey() {
+    // Initialize OpenAI client with OpenRouter configuration
+    this.openai = new OpenAI({
+      baseURL: config.baseURL,
+      apiKey: this.apiKey,
+      defaultHeaders: {
+        'HTTP-Referer': config.siteUrl,
+        'X-Title': config.siteName,
+      },
+    });
+
+    // If readline interface wasn't already initialized, do it now
+    if (!this.rl) {
+      this.initializeReadlineInterface();
+    }
+
+    // Set up custom prompt and keyboard shortcuts
+    this.updatePrompt();
+    this.setupKeyboardShortcuts();
+
+    this.setupEventHandlers();
+    this.initializeFileWatcher();
+    this.analyzeProjectContext().catch(error => {
+      console.log(chalk.yellow(`⚠️  Project context analysis failed: ${error.message}`));
+    });
+    this.loadPlugins().catch(error => {
+      console.log(chalk.yellow(`⚠️  Plugin loading failed: ${error.message}`));
+    });
+    this.displayWelcome();
+  }
+
+  updatePrompt() {
+    // Neon purple prompt with white text
+    if (this.rl) {
+      this.rl.setPrompt(chalk.magenta('> '));
+    }
+  }
+
+  setupEventHandlers() {
+    // Set up readline event handlers for user input
+    this.rl.on('line', async (input) => {
+      await this.handleUserInput(input.trim());
+    });
+
+    this.rl.on('close', () => {
+      console.log('\nGoodbye!');
+      process.exit(0);
+    });
+
+    // Handle advanced keyboard shortcuts
+    process.stdin.on('keypress', (str, key) => {
+      if (key) {
+        this.handleKeyboardShortcuts(key);
+      }
+    });
+
+    // Start the prompt
     this.rl.prompt();
   }
 
-  showSessionSuggestions() {
+  async handleUserInput(input) {
+    if (!input) {
+      this.rl.prompt();
+      return;
+    }
+
+    // Handle slash commands like Claude Code
+    if (input.startsWith('/')) {
+      this.handleSlashCommand(input);
+      return;
+    }
+
     try {
-      // Check if project exists
-      const projectStatus = this.projectManager.getProjectStatus();
+      // Track performance metrics
+      const startTime = Date.now();
+      let firstChunkTime = null;
+      let totalChunks = 0;
       
-      if (projectStatus.exists) {
-        console.log(chalk.magenta('📂 ') + chalk.white.bold(`Project: ${projectStatus.context.name}`));
-        console.log(chalk.gray(`   • Todos: ${projectStatus.todos.pending} pending, ${projectStatus.todos.completed} completed`));
-      }
+      // Start progressive loading with enhanced animations
+      this.startProgressiveLoading();
       
-      // Check for intelligent auto-resume candidate
-      const resumeCandidate = this.projectManager.shouldOfferAutoResume();
+      // Create a RecoderCode instance to process the conversation
+      const { RecoderCode } = require('./run.js');
+      const recoder = new RecoderCode();
       
-      if (resumeCandidate) {
-        console.log(chalk.magenta('🔄 ') + chalk.white.bold('Resume Previous Session?'));
-        console.log(chalk.gray(`   • Session: ${resumeCandidate.id} (${resumeCandidate.activityDescription})`));
-        console.log(chalk.gray(`   • Messages: ${resumeCandidate.messageCount} | Model: ${resumeCandidate.model}`));
-        
-        if (resumeCandidate.lastUserMessage) {
-          console.log(chalk.gray(`   • Last: "${resumeCandidate.lastUserMessage}"`));
+      // Initialize streaming response system
+      const streamBuffer = {
+        content: '',
+        chunks: [],
+        isStreaming: false,
+        streamingStarted: false
+      };
+      
+      // Enhanced streaming response handler
+      const response = await this.processWithAdvancedStreaming({
+        recoder,
+        input,
+        startTime,
+        streamBuffer,
+        onFirstChunk: (time) => { firstChunkTime = time; },
+        onChunk: (chunk) => { 
+          totalChunks++;
+          this.displayStreamingChunk(chunk, totalChunks);
         }
-        
-        console.log(chalk.gray('   💡 Type ') + chalk.cyan('/resume') + chalk.gray(' to continue or start fresh'));
-        console.log('');
+      });
+      
+      // Calculate comprehensive metrics
+      const totalDuration = Math.round((Date.now() - startTime) / 1000);
+      const timeToFirstChunk = firstChunkTime ? Math.round((firstChunkTime - startTime) / 1000) : null;
+      
+      // Track conversation history with enhanced metadata
+      this.conversationHistory.push({
+        timestamp: new Date(),
+        input: input,
+        response: response,
+        duration: totalDuration,
+        timeToFirstChunk,
+        totalChunks,
+        streamingUsed: streamBuffer.isStreaming
+      });
+      this.currentSession.messageCount++;
+      this.currentSession.lastActivity = Date.now();
+      
+      console.log('');
+      
+      // Show performance metrics and tool usage
+      this.showAdvancedMetrics({
+        duration: totalDuration,
+        timeToFirstChunk,
+        totalChunks,
+        streamingUsed: streamBuffer.isStreaming
+      });
+      
+      // Enhanced response display if not already streamed
+      if (!streamBuffer.streamingStarted) {
+        await this.displayAdvancedTypingResponse(response, startTime);
       } else {
-        // Get recent sessions if no auto-resume candidate
-        const recentSessions = this.projectManager.listSessions({ limit: 3 });
-        
-        if (recentSessions.length > 0) {
-          console.log(chalk.magenta('🕒 ') + chalk.white.bold('Recent Sessions:'));
-          recentSessions.forEach((session, index) => {
-            const timeAgo = this.getTimeAgo(new Date(session.modified));
-            console.log(chalk.gray(`   • ${session.id} - ${timeAgo} (${session.messageCount} messages)`));
-          });
-          console.log(chalk.gray('   💡 Use ') + chalk.cyan('/resume <id>') + chalk.gray(' to continue a session'));
-          console.log('');
-        }
+        // Finalize streaming display
+        this.finalizeStreamingResponse(response, totalDuration);
       }
       
+      console.log('');
+      
     } catch (error) {
-      // Silently ignore errors in session suggestions
+      this.stopProgressiveLoading();
+      this.stopStreamingDisplay();
+      console.log('');
+      this.showEnhancedError(error);
+      console.log('');
     }
+    
+    this.rl.prompt();
   }
 
-  getTimeAgo(date) {
-    const now = new Date();
-    const seconds = Math.floor((now - date) / 1000);
+  displayWelcome() {
+    console.clear();
     
-    if (seconds < 60) return 'just now';
-    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
-    if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
-    return `${Math.floor(seconds / 86400)}d ago`;
+    // Enhanced welcome screen with gradient effects and animations
+    console.log('');
+    
+    // Animated gradient border
+    this.displayAnimatedBorder();
+    
+    // Beautiful gradient ASCII art
+    console.log('');
+    this.displayGradientLogo();
+    console.log('');
+    
+    // Dynamic status information
+    this.displayDynamicStatus();
+    console.log('');
+    
+    // Enhanced status hints with themes
+    this.showEnhancedStatusHints();
+    
+    this.rl.prompt();
   }
 
-  async handleCommand(command) {
-    const [cmd, ...args] = command.slice(1).split(' ');
-    const startTime = Date.now();
+  displayAnimatedBorder() {
+    const colors = ['magenta', 'cyan', 'blue', 'magenta'];
+    const border = '╭─────────────────────────────────────────────────────────────╮';
+    const title = '│  ✨ Welcome to Recoder Code - AI Terminal                   │';
+    const bottom = '╰─────────────────────────────────────────────────────────────╯';
     
-    // Log command execution
-    this.logger.debug(`Executing command: ${cmd}`, { args });
+    console.log(chalk[colors[0]](border));
+    console.log(chalk[colors[1]](title));
+    console.log(chalk[colors[2]](bottom));
+  }
+
+  displayGradientLogo() {
+    // Beautiful gradient ASCII art with purple to cyan transition
+    const lines = [
+      '██████╗ ███████╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗',
+      '██╔══██╗██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗',
+      '██████╔╝█████╗  ██║     ██║   ██║██║  ██║█████╗  ██████╔╝',
+      '██╔══██╗██╔══╝  ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗',
+      '██║  ██║███████╗╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║',
+      '╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝'
+    ];
     
+    const gradientColors = ['magenta', 'magenta', 'cyan', 'blue', 'blue', 'gray'];
+    
+    lines.forEach((line, index) => {
+      console.log(chalk[gradientColors[index]].bold(line));
+    });
+  }
+
+  displayDynamicStatus() {
+    const currentTime = new Date().toLocaleTimeString();
+    const projectContext = this.getCurrentProjectContext();
+    
+    console.log(chalk.gray('┌─ Session Info ─────────────────────────────────────────────┐'));
+    console.log(chalk.gray('│') + chalk.white(`  🕐 Started: ${currentTime}`) + 
+                chalk.gray('                                     │'));
+    console.log(chalk.gray('│') + chalk.cyan(`  📁 Project: ${projectContext.name || 'recoder-code'}`) + 
+                chalk.gray('                                │'));
+    console.log(chalk.gray('│') + chalk.green(`  🤖 Model: ${this.model || 'claude-sonnet-4'}`) + 
+                chalk.gray('                      │'));
+    console.log(chalk.gray('└────────────────────────────────────────────────────────────┘'));
+  }
+
+  getCurrentProjectContext() {
     try {
-      switch (cmd.toLowerCase()) {
+      const packageJson = require(process.cwd() + '/package.json');
+      return {
+        name: packageJson.name || 'Unknown Project',
+        version: packageJson.version || '1.0.0'
+      };
+    } catch (error) {
+      return { name: 'recoder-code', version: '2.0.0' };
+    }
+  }
+
+  showEnhancedStatusHints() {
+    console.log(chalk.gray('┌─ Quick Commands ───────────────────────────────────────────┐'));
+    console.log(chalk.gray('│') + chalk.yellow('  ! ') + chalk.white('bash mode') + 
+                chalk.gray(' • ') + chalk.yellow('/ ') + chalk.white('commands') + 
+                chalk.gray(' • ') + chalk.yellow('tab ') + chalk.white('autocomplete') + 
+                chalk.gray('         ') + chalk.red('ESC ') + chalk.white('exit') + 
+                chalk.gray(' │'));
+    console.log(chalk.gray('└────────────────────────────────────────────────────────────┘'));
+    
+    console.log(chalk.gray('┌─ Features ─────────────────────────────────────────────────┐'));
+    console.log(chalk.gray('│') + chalk.magenta('  📁 ') + chalk.white(this.getCurrentProjectContext().name) + 
+                chalk.gray(' • ') + chalk.green('✨ ') + chalk.white('AI Ready') + 
+                chalk.gray(' • ') + chalk.cyan('Ctrl+S ') + chalk.white('save') + 
+                chalk.gray(' • ') + chalk.blue('Ctrl+H ') + chalk.white('help') + 
+                chalk.gray(' │'));
+    console.log(chalk.gray('└────────────────────────────────────────────────────────────┘'));
+  }
+
+  showError(error) {
+    // Beautiful error display like Claude Code
+    console.log(chalk.red('╭─────────────────────────────────────────╮'));
+    console.log(chalk.red('│') + chalk.white.bold('  ❌ Error                             ') + chalk.red('│'));
+    console.log(chalk.red('╰─────────────────────────────────────────╯'));
+    console.log('');
+    console.log(chalk.white(error.message));
+    console.log('');
+    
+    // Show helpful suggestions based on error type
+    if (error.message.includes('429')) {
+      console.log(chalk.gray('💡 Rate limit reached. Try again in a few seconds.'));
+    } else if (error.message.includes('API key')) {
+      console.log(chalk.gray('💡 Check your API key with /status command.'));
+    } else if (error.message.includes('timeout')) {
+      console.log(chalk.gray('💡 Request timed out. Try a simpler query.'));
+    } else {
+      console.log(chalk.gray('💡 Type /help for available commands.'));
+    }
+  }
+
+  showStatusHints() {
+    // Show helpful hints at bottom like Claude Code with project context
+    const projectName = path.basename(process.cwd());
+    console.log(chalk.gray(`! for bash mode • / for commands • tab to autocomplete         ESC to exit`));
+    console.log(chalk.gray(`📁 ${projectName} • ✨ Recoder Code ready • Ctrl+S save • Ctrl+H help`));
+  }
+
+  startProcessingAnimation() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIndex = 0;
+    
+    this.processingInterval = setInterval(() => {
+      const frame = frames[frameIndex % frames.length];
+      process.stdout.write(`\r${chalk.magenta(frame)} ${chalk.gray('Processing...')}`);
+      frameIndex++;
+    }, 80);
+  }
+
+  stopProcessingAnimation() {
+    if (this.processingInterval) {
+      clearInterval(this.processingInterval);
+      this.processingInterval = null;
+      process.stdout.write('\r'); // Clear the line
+    }
+  }
+
+  showToolUsage() {
+    // Show tool usage indicators like Claude Code
+    const tools = ['Read', 'Analyze', 'Generate'];
+    tools.forEach(tool => {
+      console.log(chalk.gray('● ') + chalk.white(`${tool}(project_structure)...`));
+    });
+  }
+
+  formatResponse(response) {
+    // Format response with rich styling like Claude Code
+    if (!response) return '';
+    
+    // Add bullet points and styling
+    const formatted = response
+      .split('\n')
+      .map(line => {
+        if (line.trim().startsWith('-') || line.trim().startsWith('*')) {
+          return chalk.gray('● ') + chalk.white(line.replace(/^[\s\-\*]+/, ''));
+        }
+        return chalk.white(line);
+      })
+      .join('\n');
+    
+    return formatted;
+  }
+
+  async typeResponse(text) {
+    // Type out response character by character like Claude Code
+    const lines = text.split('\n');
+    for (const line of lines) {
+      for (let i = 0; i < line.length; i++) {
+        process.stdout.write(line[i]);
+        await new Promise(resolve => setTimeout(resolve, 15)); // 15ms per character
+      }
+      console.log(''); // New line after each line
+    }
+  }
+
+  handleSlashCommand(input) {
+    const command = input.slice(1).toLowerCase();
+    
+    switch (command) {
+      case 'help':
+        this.showHelp();
+        break;
+      case 'clear':
+        console.clear();
+        this.displayWelcome();
+        return; // Don't show prompt again
+      case 'exit':
+      case 'quit':
+        console.log(chalk.magenta('\nGoodbye! ✨'));
+        process.exit(0);
+        break;
+      case 'status':
+        this.showStatus();
+        break;
+      case 'history':
+        this.showHistory();
+        break;
+      case 'session':
+        this.showSession();
+        break;
+      case 'watch':
+        this.showWatchedFiles();
+        break;
+      case 'save':
+        this.saveCurrentSession();
+        break;
+      case 'analyze':
+        this.performCodeAnalysis();
+        break;
+      case 'git':
+        this.showGitStatus();
+        break;
+      case 'review':
+        this.performCodeReview();
+        break;
+      case 'optimize':
+        this.performOptimizationAnalysis();
+        break;
+      case 'security':
+        this.performSecurityAnalysis();
+        break;
+      case 'theme':
+        this.cycleTheme();
+        break;
+      default:
+        console.log(chalk.red(`Unknown command: ${input}`));
+        console.log(chalk.gray('Type /help for available commands'));
+    }
+    
+    this.rl.prompt();
+  }
+
+  showHelp() {
+    console.log('');
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  🚀 Available Commands                ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    console.log(chalk.cyan('📋 Basic Commands:'));
+    console.log(chalk.gray('  /help    ') + chalk.white('Show this help message'));
+    console.log(chalk.gray('  /clear   ') + chalk.white('Clear the screen'));
+    console.log(chalk.gray('  /status  ') + chalk.white('Show system status'));
+    console.log(chalk.gray('  /exit    ') + chalk.white('Exit the terminal'));
+    console.log('');
+    
+    console.log(chalk.green('🔍 Analysis Commands:'));
+    console.log(chalk.gray('  /analyze ') + chalk.white('Perform intelligent code analysis'));
+    console.log(chalk.gray('  /review  ') + chalk.white('AI-powered code review'));
+    console.log(chalk.gray('  /security') + chalk.white('Security vulnerability analysis'));
+    console.log(chalk.gray('  /optimize') + chalk.white('Performance optimization suggestions'));
+    console.log('');
+    
+    console.log(chalk.blue('🌿 Git Commands:'));
+    console.log(chalk.gray('  /git     ') + chalk.white('Show git repository status'));
+    console.log('');
+    
+    console.log(chalk.magenta('🎨 Customization:'));
+    console.log(chalk.gray('  /theme   ') + chalk.white('Cycle through visual themes'));
+    console.log('');
+    
+    console.log(chalk.yellow('💾 Session Management:'));
+    console.log(chalk.gray('  /history ') + chalk.white('Show conversation history'));
+    console.log(chalk.gray('  /session ') + chalk.white('Show current session info'));
+    console.log(chalk.gray('  /save    ') + chalk.white('Save current session'));
+    console.log(chalk.gray('  /watch   ') + chalk.white('Show watched files'));
+    console.log('');
+  }
+
+  showStatus() {
+    console.log('');
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  System Status                        ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    console.log(chalk.gray('Model:    ') + chalk.white(this.model || 'Default'));
+    console.log(chalk.gray('Session:  ') + chalk.white(this.sessionId.slice(0, 8) + '...'));
+    console.log(chalk.gray('Directory:') + chalk.white(process.cwd().replace(process.env.HOME, '~')));
+    console.log('');
+  }
+
+  showHistory() {
+    console.log('');
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  Conversation History                 ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    if (this.conversationHistory.length === 0) {
+      console.log(chalk.gray('No conversation history yet.'));
+    } else {
+      const recent = this.conversationHistory.slice(-5); // Show last 5 exchanges
+      recent.forEach((entry, index) => {
+        const time = entry.timestamp.toLocaleTimeString();
+        console.log(chalk.gray(`[${time}] `) + chalk.white(entry.input.slice(0, 50) + '...'));
+        console.log(chalk.gray(`  → Response in ${entry.duration}s`));
+        if (index < recent.length - 1) console.log('');
+      });
+    }
+    console.log('');
+  }
+
+  showSession() {
+    console.log('');
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  Current Session                      ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    const sessionDuration = Math.round((Date.now() - this.currentSession.startTime) / 1000 / 60);
+    const lastActivity = Math.round((Date.now() - this.currentSession.lastActivity) / 1000);
+    
+    console.log(chalk.gray('Session ID:     ') + chalk.white(this.sessionId.slice(0, 8) + '...'));
+    console.log(chalk.gray('Duration:       ') + chalk.white(`${sessionDuration} minutes`));
+    console.log(chalk.gray('Messages:       ') + chalk.white(this.currentSession.messageCount));
+    console.log(chalk.gray('Last Activity:  ') + chalk.white(`${lastActivity}s ago`));
+    console.log(chalk.gray('Model:          ') + chalk.white(this.model || 'Default'));
+    console.log('');
+  }
+
+  smartAutoComplete(line) {
+    // Smart autocomplete for commands and context-aware suggestions
+    const completions = [];
+    
+    if (line.startsWith('/')) {
+      // Slash command completions
+      const commands = ['help', 'clear', 'status', 'history', 'session', 'exit'];
+      const matches = commands.filter(cmd => cmd.startsWith(line.slice(1)));
+      completions.push(...matches.map(cmd => '/' + cmd));
+    } else if (line.startsWith('!')) {
+      // Bash command completions
+      const bashCommands = ['ls', 'cd', 'pwd', 'cat', 'grep', 'find', 'git', 'npm', 'node'];
+      const matches = bashCommands.filter(cmd => cmd.startsWith(line.slice(1)));
+      completions.push(...matches.map(cmd => '!' + cmd));
+    } else {
+      // Context-aware suggestions based on project
+      const suggestions = [
+        'explain this project structure',
+        'help me debug this code',
+        'create a README file',
+        'optimize this function',
+        'add error handling',
+        'write unit tests',
+        'refactor this code'
+      ];
+      const matches = suggestions.filter(s => s.toLowerCase().includes(line.toLowerCase()));
+      completions.push(...matches);
+    }
+    
+    return [completions, line];
+  }
+
+  showWatchedFiles() {
+    console.log('');
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  Watched Files                        ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    if (this.watchedFiles && this.watchedFiles.size > 0) {
+      this.watchedFiles.forEach(file => {
+        console.log(chalk.gray('📁 ') + chalk.white(file));
+      });
+    } else {
+      console.log(chalk.gray('No files being watched.'));
+      console.log(chalk.gray('Files will be automatically watched during conversations.'));
+    }
+    console.log('');
+  }
+
+  saveCurrentSession() {
+    console.log('');
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  Session Saved                        ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    const sessionData = {
+      id: this.sessionId,
+      startTime: this.currentSession.startTime,
+      history: this.conversationHistory,
+      messageCount: this.currentSession.messageCount,
+      lastActivity: this.currentSession.lastActivity,
+      savedAt: Date.now()
+    };
+    
+    try {
+      const sessionsDir = path.join(process.cwd(), 'sessions');
+      if (!fs.existsSync(sessionsDir)) {
+        fs.mkdirSync(sessionsDir, { recursive: true });
+      }
+      
+      const filename = `session-${this.sessionId}.json`;
+      const filepath = path.join(sessionsDir, filename);
+      fs.writeFileSync(filepath, JSON.stringify(sessionData, null, 2));
+      
+      console.log(chalk.white(`Session saved to: ${filename}`));
+      console.log(chalk.gray(`${this.conversationHistory.length} messages preserved`));
+    } catch (error) {
+      console.log(chalk.red(`Failed to save session: ${error.message}`));
+    }
+    console.log('');
+  }
+
+  handleKeyboardShortcuts(key) {
+    // Advanced keyboard shortcuts like in modern IDEs
+    if (key.name === 'escape') {
+      console.log(chalk.magenta('\n✨ Goodbye!'));
+      process.exit(0);
+    } else if (key.ctrl && key.name === 'l') {
+      // Ctrl+L: Clear and restart
+      console.clear();
+      this.displayWelcome();
+    } else if (key.ctrl && key.name === 's') {
+      // Ctrl+S: Quick save session
+      this.rl.write('\r/save\r');
+    } else if (key.ctrl && key.name === 'h') {
+      // Ctrl+H: Show help
+      this.rl.write('\r/help\r');
+    } else if (key.ctrl && key.name === 'u') {
+      // Ctrl+U: Show status
+      this.rl.write('\r/status\r');
+    }
+  }
+
+  showSessionSuggestions() {
+    try {
+      // Check if project exists
+      const projectStatus = this.projectManager.getProjectStatus();
+      
+      if (projectStatus.exists) {
+        console.log(chalk.magenta('📂 ') + chalk.white.bold(`Project: ${projectStatus.context.name}`));
+        console.log(chalk.gray(`   • Todos: ${projectStatus.todos.pending} pending, ${projectStatus.todos.completed} completed`));
+      }
+      
+      // Check for intelligent auto-resume candidate
+      const resumeCandidate = this.projectManager.shouldOfferAutoResume();
+      
+      if (resumeCandidate) {
+        console.log(chalk.magenta('🔄 ') + chalk.white.bold('Resume Previous Session?'));
+        console.log(chalk.gray(`   • Session: ${resumeCandidate.id} (${resumeCandidate.activityDescription})`));
+        console.log(chalk.gray(`   • Messages: ${resumeCandidate.messageCount} | Model: ${resumeCandidate.model}`));
+        
+        if (resumeCandidate.lastUserMessage) {
+          console.log(chalk.gray(`   • Last: "${resumeCandidate.lastUserMessage}"`));
+        }
+        
+        console.log(chalk.gray('   💡 Type ') + chalk.cyan('/resume') + chalk.gray(' to continue or start fresh'));
+        console.log('');
+      } else {
+        // Get recent sessions if no auto-resume candidate
+        const recentSessions = this.projectManager.listSessions({ limit: 3 });
+        
+        if (recentSessions.length > 0) {
+          console.log(chalk.magenta('🕒 ') + chalk.white.bold('Recent Sessions:'));
+          recentSessions.forEach((session, index) => {
+            const timeAgo = this.getTimeAgo(new Date(session.modified));
+            console.log(chalk.gray(`   • ${session.id} - ${timeAgo} (${session.messageCount} messages)`));
+          });
+          console.log(chalk.gray('   💡 Use ') + chalk.cyan('/resume <id>') + chalk.gray(' to continue a session'));
+          console.log('');
+        }
+      }
+      
+    } catch (error) {
+      // Silently ignore errors in session suggestions
+    }
+  }
+
+  getTimeAgo(date) {
+    const now = new Date();
+    const seconds = Math.floor((now - date) / 1000);
+    
+    if (seconds < 60) return 'just now';
+    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+  }
+
+  async handleCommand(command) {
+    const [cmd, ...args] = command.slice(1).split(' ');
+    const startTime = Date.now();
+    
+    // Log command execution
+    this.logger.debug(`Executing command: ${cmd}`, { args });
+    
+    try {
+      switch (cmd.toLowerCase()) {
       case 'help':
         this.showHelp();
         break;
@@ -2945,12 +3570,15 @@ class InteractiveRecoderChat {
 
         console.log(chalk.white(assistantMessage));
         
-        // Optional voice output for AI responses
-        if (this.voiceManager.textToSpeechEnabled) {
-          // Speak the response (in background, don't wait)
-          this.voiceManager.speakText(assistantMessage).catch(err => {
-            // Ignore TTS errors to not interrupt the conversation
-          });
+        // Only speak if user specifically requested it
+        if (this.shouldSpeak || userInput.toLowerCase().includes('speak') || userInput.toLowerCase().includes('read loud')) {
+          if (this.voiceManager.textToSpeechEnabled) {
+            console.log(chalk.gray('🔊 Speaking response...'));
+            this.voiceManager.speakText(assistantMessage).catch(err => {
+              // Ignore TTS errors to not interrupt the conversation
+            });
+          }
+          this.shouldSpeak = false; // Reset flag
         }
         
         // Update conversation-specific stats
@@ -3417,40 +4045,1505 @@ ${projectInfo}`
     }
   }
 
-  async cleanup() {
-    this.logger.info('Starting cleanup process');
+  // Advanced streaming and progressive loading methods
+  startProgressiveLoading() {
+    if (this.progressiveLoader) {
+      clearInterval(this.progressiveLoader.interval);
+    }
     
-    if (this.fileWatcher) {
-      this.fileWatcher.close();
-      this.fileWatcher = null;
-      this.logger.debug('File watcher closed');
+    const stages = [
+      { text: 'Initializing...', color: 'cyan', icon: '⚡' },
+      { text: 'Connecting to AI...', color: 'blue', icon: '🔗' },
+      { text: 'Processing request...', color: 'magenta', icon: '🧠' },
+      { text: 'Generating response...', color: 'yellow', icon: '✨' }
+    ];
+    
+    let currentStage = 0;
+    let dots = 0;
+    
+    this.progressiveLoader = {
+      interval: setInterval(() => {
+        const stage = stages[currentStage % stages.length];
+        const dotString = '.'.repeat((dots % 3) + 1).padEnd(3);
+        
+        process.stdout.write('\r' + ' '.repeat(50) + '\r');
+        process.stdout.write(
+          chalk[stage.color](stage.icon + ' ' + stage.text + dotString)
+        );
+        
+        dots++;
+        if (dots % 6 === 0) {
+          currentStage++;
+        }
+      }, 200),
+      stage: 0
+    };
+  }
+  
+  stopProgressiveLoading(loader = this.progressiveLoader) {
+    if (loader && loader.interval) {
+      clearInterval(loader.interval);
+      process.stdout.write('\r' + ' '.repeat(50) + '\r');
+    }
+    this.progressiveLoader = null;
+  }
+  
+  async processWithAdvancedStreaming({ recoder, input, startTime, streamBuffer, onFirstChunk, onChunk }) {
+    try {
+      // Attempt streaming first
+      const response = await recoder.processConversation(input, false, true, {
+        onChunk: (chunk) => {
+          if (!streamBuffer.streamingStarted) {
+            this.stopProgressiveLoading();
+            this.startStreamingDisplay();
+            streamBuffer.streamingStarted = true;
+            onFirstChunk(Date.now());
+          }
+          
+          streamBuffer.content += chunk;
+          streamBuffer.chunks.push(chunk);
+          streamBuffer.isStreaming = true;
+          onChunk(chunk);
+        }
+      });
+      
+      return response || streamBuffer.content;
+      
+    } catch (error) {
+      // Fallback to non-streaming
+      this.stopProgressiveLoading();
+      return await recoder.processConversation(input, false, false, null);
+    }
+  }
+  
+  startStreamingDisplay() {
+    if (!this.streamingActive) {
+      console.log('\n' + chalk.cyan('🔥 Streaming response...'));
+      this.streamingActive = true;
+      this.streamCursor = 0;
     }
+  }
+  
+  displayStreamingChunk(chunk, chunkNumber) {
+    if (!this.streamingActive) return;
     
-    // Cleanup voice manager
-    if (this.voiceManager) {
-      this.voiceManager.cleanup();
-      this.logger.debug('Voice manager cleaned up');
+    // Add subtle chunk indicators for debugging
+    if (process.env.RECODER_DEBUG === 'true') {
+      process.stdout.write(chalk.gray(`[${chunkNumber}]`));
     }
     
-    // Cleanup collaboration manager
-    if (this.collaborationManager) {
-      this.collaborationManager.cleanup();
-      this.logger.debug('Collaboration manager cleaned up');
+    // Display chunk with subtle animation
+    const chars = chunk.split('');
+    chars.forEach((char, index) => {
+      setTimeout(() => {
+        process.stdout.write(chalk.white(char));
+      }, index * 2); // Very fast typing effect
+    });
+  }
+  
+  stopStreamingDisplay() {
+    this.streamingActive = false;
+    this.streamCursor = 0;
+  }
+  
+  finalizeStreamingResponse(response, duration) {
+    this.stopStreamingDisplay();
+    console.log('\n');
+    console.log(chalk.gray(`✅ Stream complete (${duration}s)`));
+  }
+  
+  async displayAdvancedTypingResponse(response, startTime) {
+    if (!response) return;
+    
+    const formattedResponse = this.formatResponse(response);
+    const duration = Math.round((Date.now() - startTime) / 1000);
+    
+    // Enhanced typing animation with word-by-word display
+    const words = formattedResponse.split(' ');
+    let currentLine = '';
+    
+    for (const word of words) {
+      currentLine += word + ' ';
+      
+      // Display word
+      process.stdout.write(chalk.white(word + ' '));
+      
+      // Variable delay based on word length and content
+      let delay = 30; // Base delay
+      if (word.includes('\n')) delay += 100; // Pause at line breaks
+      if (word.length > 10) delay += 20; // Slower for long words
+      if (word.includes('.') || word.includes('!') || word.includes('?')) delay += 150; // Pause at sentences
+      
+      await new Promise(resolve => setTimeout(resolve, delay));
     }
     
-    // Cleanup plugins
-    if (this.pluginManager) {
-      await this.pluginManager.cleanup();
-      this.logger.debug('Plugins cleaned up');
+    console.log('\n' + chalk.gray(`(${duration}s • advanced typing)`));
+  }
+  
+  showAdvancedMetrics({ duration, timeToFirstChunk, totalChunks, streamingUsed }) {
+    const metrics = [];
+    
+    if (streamingUsed) {
+      metrics.push(chalk.green(`🚀 Streamed ${totalChunks} chunks`));
+      if (timeToFirstChunk) {
+        metrics.push(chalk.blue(`⚡ First response: ${timeToFirstChunk}s`));
+      }
+    } else {
+      metrics.push(chalk.yellow('📄 Standard response'));
     }
     
-    // End session logging
-    if (this.logger) {
-      this.logger.endSession();
-      this.logger.info('Session cleanup completed');
+    metrics.push(chalk.gray(`⏱️ Total: ${duration}s`));
+    
+    // Show tool usage indicators
+    this.showToolUsage();
+    
+    console.log(chalk.gray('Performance: ') + metrics.join(' • '));
+  }
+  
+  showEnhancedError(error) {
+    // Enhanced error display with better formatting
+    console.log(chalk.red('╭─────────────────────────────────────────╮'));
+    console.log(chalk.red('│') + chalk.white.bold('  ❌ Error                             ') + chalk.red('│'));
+    console.log(chalk.red('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    // Error details
+    console.log(chalk.white(error.message));
+    console.log('');
+    
+    // Enhanced contextual suggestions
+    if (error.message.includes('429')) {
+      console.log(chalk.yellow('💡 Rate limit: Wait 10-30 seconds before retrying'));
+    } else if (error.message.includes('API key')) {
+      console.log(chalk.yellow('💡 Set your API key: export OPENROUTER_API_KEY=your_key'));
+    } else if (error.message.includes('network') || error.message.includes('timeout')) {
+      console.log(chalk.yellow('💡 Network issue: Check connection and try again'));
+    } else if (error.message.includes('model')) {
+      console.log(chalk.yellow('💡 Model issue: Try switching models with /model command'));
+    } else {
+      console.log(chalk.yellow('💡 Try: /help for available commands or /reset to start fresh'));
+    }
+    
+    // Debug information if enabled
+    if (process.env.RECODER_DEBUG === 'true') {
+      console.log('');
+      console.log(chalk.gray('Debug details:'));
+      console.log(chalk.gray(error.stack?.split('\n').slice(0, 3).join('\n')));
     }
   }
 
+  setupGlobalErrorHandlers() {
+    // Register domain-specific handlers with unified error handler
+    errorHandler.registerHandler('interactive', (error) => {
+      if (this.logger) {
+        this.logger.error('Interactive mode error', { 
+          error: error?.toString(), 
+          stack: error?.stack 
+        });
+      }
+      
+      // In debug mode, show detailed error for interactive context
+      if (process.env.RECODER_DEBUG === 'true') {
+        console.log(chalk.blue('\n🔍 Interactive Context Error:'));
+        console.log(chalk.gray(error?.toString()));
+        if (error?.stack) {
+          console.log(chalk.gray(error.stack.split('\n').slice(0, 5).join('\n')));
+        }
+      }
+    });
+
+    // Register MCP error handler for graceful degradation
+    errorHandler.registerHandler('mcp', (error) => {
+      // MCP errors are non-critical, just log for debugging
+      if (process.env.RECODER_DEBUG === 'true') {
+        console.log(chalk.gray('🔌 MCP connection issue (non-critical):'), error?.message);
+      }
+    });
+
+    // Handle warnings specifically
+    process.on('warning', (warning) => {
+      if (warning.name === 'PromiseRejectionHandledWarning' || 
+          warning.name === 'UnhandledPromiseRejectionWarning') {
+        if (this.logger) {
+          this.logger.warn('Promise warning', { name: warning.name, message: warning.message });
+        }
+      }
+    });
+  }
+
+  // ========== INTELLIGENT FEATURES ==========
+
+  performCodeAnalysis() {
+    console.log(chalk.cyan('🔍 Analyzing Codebase...'));
+    console.log('');
+    
+    const analysis = this.analyzeCurrentProject();
+    
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  📊 Code Analysis Results             ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    console.log(chalk.cyan('📁 Project Structure:'));
+    console.log(chalk.white(`   • Files: ${analysis.fileCount}`));
+    console.log(chalk.white(`   • Languages: ${analysis.languages.join(', ')}`));
+    console.log(chalk.white(`   • Main Language: ${analysis.mainLanguage}`));
+    console.log('');
+    
+    console.log(chalk.green('✅ Strengths:'));
+    analysis.strengths.forEach(strength => {
+      console.log(chalk.white(`   • ${strength}`));
+    });
+    console.log('');
+    
+    console.log(chalk.yellow('💡 Suggestions:'));
+    analysis.suggestions.forEach(suggestion => {
+      console.log(chalk.white(`   • ${suggestion}`));
+    });
+    console.log('');
+  }
+
+  analyzeCurrentProject() {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      const analysis = {
+        fileCount: 0,
+        languages: new Set(),
+        fileTypes: {},
+        dependencies: [],
+        devDependencies: [],
+        strengths: [],
+        issues: [],
+        suggestions: []
+      };
+
+      // Scan actual files in project
+      const scanDirectory = (dir, depth = 0) => {
+        if (depth > 3) return; // Limit depth
+        
+        try {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            
+            // Skip node_modules, .git, etc.
+            if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+            
+            if (entry.isFile()) {
+              analysis.fileCount++;
+              const ext = path.extname(entry.name).toLowerCase();
+              
+              // Count file types
+              analysis.fileTypes[ext] = (analysis.fileTypes[ext] || 0) + 1;
+              
+              // Detect languages
+              const languageMap = {
+                '.js': 'JavaScript',
+                '.ts': 'TypeScript', 
+                '.py': 'Python',
+                '.java': 'Java',
+                '.cpp': 'C++',
+                '.c': 'C',
+                '.cs': 'C#',
+                '.go': 'Go',
+                '.rs': 'Rust',
+                '.php': 'PHP',
+                '.rb': 'Ruby',
+                '.json': 'JSON',
+                '.md': 'Markdown',
+                '.html': 'HTML',
+                '.css': 'CSS',
+                '.scss': 'SCSS',
+                '.yaml': 'YAML',
+                '.yml': 'YAML'
+              };
+              
+              if (languageMap[ext]) {
+                analysis.languages.add(languageMap[ext]);
+              }
+            } else if (entry.isDirectory()) {
+              scanDirectory(fullPath, depth + 1);
+            }
+          }
+        } catch (error) {
+          // Skip directories we can't read
+        }
+      };
+
+      // Scan from current directory
+      scanDirectory(process.cwd());
+
+      // Analyze package.json if it exists
+      try {
+        const packagePath = path.join(process.cwd(), 'package.json');
+        if (fs.existsSync(packagePath)) {
+          const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+          analysis.dependencies = Object.keys(packageJson.dependencies || {});
+          analysis.devDependencies = Object.keys(packageJson.devDependencies || {});
+          
+          // Analyze dependencies for insights
+          if (analysis.dependencies.includes('express')) analysis.strengths.push('Express.js web framework detected');
+          if (analysis.dependencies.includes('react')) analysis.strengths.push('React frontend framework detected');
+          if (analysis.dependencies.includes('chalk')) analysis.strengths.push('Terminal styling with chalk');
+          if (analysis.devDependencies.includes('jest')) analysis.strengths.push('Jest testing framework configured');
+          if (analysis.devDependencies.includes('eslint')) analysis.strengths.push('ESLint code linting configured');
+        }
+      } catch (error) {
+        analysis.issues.push('Could not read package.json');
+      }
+
+      // Generate insights based on actual analysis
+      const languageArray = Array.from(analysis.languages);
+      const mainLanguage = this.determineMainLanguage(analysis.fileTypes);
+      
+      if (analysis.fileCount === 0) {
+        analysis.issues.push('No files found in project');
+      } else if (analysis.fileCount > 1000) {
+        analysis.issues.push('Large project detected - consider optimization');
+      }
+
+      if (!languageArray.includes('TypeScript') && languageArray.includes('JavaScript')) {
+        analysis.suggestions.push('Consider migrating to TypeScript for better type safety');
+      }
+
+      if (!analysis.fileTypes['.md']) {
+        analysis.suggestions.push('Add README.md and documentation');
+      }
+
+      if (analysis.dependencies.length === 0) {
+        analysis.suggestions.push('Consider using npm/yarn for dependency management');
+      }
+
+      if (!analysis.devDependencies.includes('jest') && !analysis.devDependencies.includes('mocha')) {
+        analysis.suggestions.push('Add testing framework (Jest/Mocha)');
+      }
+
+      return {
+        fileCount: analysis.fileCount,
+        languages: languageArray,
+        mainLanguage: mainLanguage,
+        fileTypes: analysis.fileTypes,
+        dependencies: analysis.dependencies,
+        devDependencies: analysis.devDependencies,
+        strengths: analysis.strengths.length > 0 ? analysis.strengths : ['Project structure analyzed'],
+        issues: analysis.issues,
+        suggestions: analysis.suggestions.length > 0 ? analysis.suggestions : ['Project appears well-structured']
+      };
+      
+    } catch (error) {
+      return {
+        fileCount: 0,
+        languages: ['Unknown'],
+        mainLanguage: 'Unknown',
+        fileTypes: {},
+        dependencies: [],
+        devDependencies: [],
+        strengths: ['Basic analysis attempted'],
+        issues: [`Analysis error: ${error.message}`],
+        suggestions: ['Ensure proper file permissions']
+      };
+    }
+  }
+
+  determineMainLanguage(fileTypes) {
+    let maxCount = 0;
+    let mainExt = '';
+    
+    for (const [ext, count] of Object.entries(fileTypes)) {
+      if (count > maxCount && ext !== '.md' && ext !== '.json') {
+        maxCount = count;
+        mainExt = ext;
+      }
+    }
+    
+    const languageMap = {
+      '.js': 'JavaScript',
+      '.ts': 'TypeScript',
+      '.py': 'Python',
+      '.java': 'Java',
+      '.cpp': 'C++',
+      '.go': 'Go',
+      '.rs': 'Rust'
+    };
+    
+    return languageMap[mainExt] || 'Mixed';
+  }
+
+  showGitStatus() {
+    console.log(chalk.cyan('📊 Git Repository Status'));
+    console.log('');
+    
+    const { execSync } = require('child_process');
+    
+    try {
+      // Check if git is available
+      execSync('git --version', { stdio: 'ignore' });
+      
+      // Check if we're in a git repository
+      execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+      
+      console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+      console.log(chalk.magenta('│') + chalk.white.bold('  🌿 Git Repository Analysis           ') + chalk.magenta('│'));
+      console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+      console.log('');
+      
+      // Get comprehensive git information
+      const gitInfo = this.getGitInformation();
+      
+      // Display branch information
+      console.log(chalk.green(`🌿 Current Branch: ${gitInfo.currentBranch}`));
+      if (gitInfo.upstreamBranch) {
+        console.log(chalk.blue(`🔗 Upstream: ${gitInfo.upstreamBranch}`));
+      }
+      
+      // Show commits ahead/behind
+      if (gitInfo.aheadBehind.ahead > 0 || gitInfo.aheadBehind.behind > 0) {
+        console.log(chalk.yellow(`📊 Sync Status: ${gitInfo.aheadBehind.ahead} ahead, ${gitInfo.aheadBehind.behind} behind`));
+      }
+      console.log('');
+      
+      // Show working directory status
+      if (gitInfo.statusFiles.length > 0) {
+        console.log(chalk.yellow('📝 Working Directory Changes:'));
+        
+        const statusCounts = { modified: 0, added: 0, deleted: 0, untracked: 0 };
+        
+        gitInfo.statusFiles.forEach(file => {
+          let statusIcon = '❓';
+          let statusColor = 'white';
+          
+          if (file.status.includes('M')) {
+            statusIcon = '📝';
+            statusColor = 'yellow';
+            statusCounts.modified++;
+          } else if (file.status.includes('A')) {
+            statusIcon = '➕';
+            statusColor = 'green';
+            statusCounts.added++;
+          } else if (file.status.includes('D')) {
+            statusIcon = '🗑️';
+            statusColor = 'red';
+            statusCounts.deleted++;
+          } else if (file.status.includes('??')) {
+            statusIcon = '❔';
+            statusColor = 'gray';
+            statusCounts.untracked++;
+          }
+          
+          console.log(chalk[statusColor](`   ${statusIcon} ${file.file}`));
+        });
+        
+        console.log('');
+        console.log(chalk.cyan('📊 Summary:'));
+        if (statusCounts.modified > 0) console.log(chalk.yellow(`   📝 ${statusCounts.modified} modified`));
+        if (statusCounts.added > 0) console.log(chalk.green(`   ➕ ${statusCounts.added} added`));
+        if (statusCounts.deleted > 0) console.log(chalk.red(`   🗑️ ${statusCounts.deleted} deleted`));
+        if (statusCounts.untracked > 0) console.log(chalk.gray(`   ❔ ${statusCounts.untracked} untracked`));
+        
+      } else {
+        console.log(chalk.green('✅ Working directory clean'));
+      }
+      
+      console.log('');
+      
+      // Show recent commits with more detail
+      console.log(chalk.blue('📚 Recent Commits:'));
+      gitInfo.recentCommits.forEach((commit, index) => {
+        const timeAgo = this.getTimeAgo(commit.date);
+        console.log(chalk.gray(`   ${index + 1}. ${commit.hash} ${commit.message}`));
+        console.log(chalk.gray(`      by ${commit.author} ${timeAgo}`));
+      });
+      
+      console.log('');
+      
+      // Show repository statistics
+      console.log(chalk.cyan('📈 Repository Stats:'));
+      console.log(chalk.white(`   🏷️ Total Tags: ${gitInfo.stats.totalTags}`));
+      console.log(chalk.white(`   🌿 Total Branches: ${gitInfo.stats.totalBranches}`));
+      console.log(chalk.white(`   📝 Total Commits: ${gitInfo.stats.totalCommits}`));
+      console.log(chalk.white(`   👥 Contributors: ${gitInfo.stats.contributors}`));
+      
+    } catch (error) {
+      if (error.message.includes('not a git repository')) {
+        console.log(chalk.red('❌ Not a git repository'));
+        console.log(chalk.gray('Initialize with: git init'));
+      } else if (error.message.includes('git --version')) {
+        console.log(chalk.red('❌ Git not installed or not in PATH'));
+      } else {
+        console.log(chalk.red(`❌ Git error: ${error.message}`));
+      }
+    }
+    console.log('');
+  }
+
+  getGitInformation() {
+    const { execSync } = require('child_process');
+    
+    try {
+      // Get current branch
+      const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+      
+      // Get upstream branch
+      let upstreamBranch = null;
+      try {
+        upstreamBranch = execSync('git rev-parse --abbrev-ref @{upstream}', { encoding: 'utf8' }).trim();
+      } catch (e) {
+        // No upstream branch
+      }
+      
+      // Get ahead/behind count
+      let aheadBehind = { ahead: 0, behind: 0 };
+      if (upstreamBranch) {
+        try {
+          const aheadBehindOutput = execSync(`git rev-list --count --left-right ${upstreamBranch}...HEAD`, { encoding: 'utf8' }).trim();
+          const [behind, ahead] = aheadBehindOutput.split('\t').map(Number);
+          aheadBehind = { ahead, behind };
+        } catch (e) {
+          // Can't determine ahead/behind
+        }
+      }
+      
+      // Get status files
+      const statusOutput = execSync('git status --porcelain', { encoding: 'utf8' });
+      const statusFiles = statusOutput.split('\n')
+        .filter(line => line.trim())
+        .map(line => ({
+          status: line.substring(0, 2),
+          file: line.substring(3)
+        }));
+      
+      // Get recent commits with detailed info
+      const commitOutput = execSync('git log --oneline --format="%H|%s|%an|%ad" --date=iso -10', { encoding: 'utf8' });
+      const recentCommits = commitOutput.split('\n')
+        .filter(line => line.trim())
+        .map(line => {
+          const [hash, message, author, date] = line.split('|');
+          return {
+            hash: hash.substring(0, 8),
+            message,
+            author,
+            date: new Date(date)
+          };
+        });
+      
+      // Get repository statistics
+      const totalTags = execSync('git tag --list | wc -l', { encoding: 'utf8' }).trim();
+      const totalBranches = execSync('git branch -a | wc -l', { encoding: 'utf8' }).trim();
+      const totalCommits = execSync('git rev-list --count HEAD', { encoding: 'utf8' }).trim();
+      const contributors = execSync('git shortlog -sn | wc -l', { encoding: 'utf8' }).trim();
+      
+      return {
+        currentBranch,
+        upstreamBranch,
+        aheadBehind,
+        statusFiles,
+        recentCommits,
+        stats: {
+          totalTags: parseInt(totalTags) || 0,
+          totalBranches: parseInt(totalBranches) || 0,
+          totalCommits: parseInt(totalCommits) || 0,
+          contributors: parseInt(contributors) || 0
+        }
+      };
+      
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  getTimeAgo(date) {
+    const now = new Date();
+    const diffMs = now - date;
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+    
+    if (diffMins < 60) return `${diffMins} minutes ago`;
+    if (diffHours < 24) return `${diffHours} hours ago`;
+    if (diffDays < 30) return `${diffDays} days ago`;
+    return date.toLocaleDateString();
+  }
+
+  performCodeReview() {
+    console.log(chalk.cyan('🔍 Performing AI Code Review...'));
+    console.log('');
+    
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  🤖 AI Code Review                    ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    const review = this.generateRealCodeReview();
+    
+    // Display scores with color coding
+    const getScoreColor = (score) => {
+      if (score >= 90) return 'green';
+      if (score >= 75) return 'yellow';
+      return 'red';
+    };
+    
+    console.log(chalk[getScoreColor(review.scores.quality)](`✅ Code Quality: ${review.scores.quality}/100`));
+    console.log(chalk[getScoreColor(review.scores.maintainability)](`📊 Maintainability: ${review.scores.maintainability}/100`));
+    console.log(chalk[getScoreColor(review.scores.security)](`🛡️ Security: ${review.scores.security}/100`));
+    console.log(chalk[getScoreColor(review.scores.testCoverage)](`🧪 Test Coverage: ${review.scores.testCoverage}/100`));
+    console.log('');
+    
+    // Display architecture analysis
+    if (review.architecture.length > 0) {
+      console.log(chalk.blue('🏗️ Architecture Analysis:'));
+      review.architecture.forEach(item => {
+        console.log(chalk.white(`   • ${item.type}: ${item.description}`));
+        if (item.file) {
+          console.log(chalk.gray(`     File: ${item.file}`));
+        }
+      });
+      console.log('');
+    }
+    
+    // Display code quality issues
+    if (review.qualityIssues.length > 0) {
+      console.log(chalk.yellow('⚠️ Code Quality Issues:'));
+      review.qualityIssues.forEach(issue => {
+        console.log(chalk.white(`   • ${issue.type}: ${issue.description}`));
+        console.log(chalk.gray(`     File: ${issue.file}:${issue.line}`));
+      });
+      console.log('');
+    }
+    
+    // Display maintainability metrics
+    if (review.maintainabilityMetrics.length > 0) {
+      console.log(chalk.cyan('📈 Maintainability Metrics:'));
+      review.maintainabilityMetrics.forEach(metric => {
+        console.log(chalk.white(`   • ${metric.metric}: ${metric.value} (${metric.assessment})`));
+        if (metric.suggestion) {
+          console.log(chalk.gray(`     Suggestion: ${metric.suggestion}`));
+        }
+      });
+      console.log('');
+    }
+    
+    // Display AI recommendations
+    if (review.recommendations.length > 0) {
+      console.log(chalk.cyan('💡 AI-Powered Recommendations:'));
+      review.recommendations.forEach(rec => {
+        console.log(chalk.white(`   • ${rec.category}: ${rec.suggestion}`));
+        if (rec.priority) {
+          console.log(chalk.gray(`     Priority: ${rec.priority}`));
+        }
+      });
+      console.log('');
+    }
+    
+    // Display overall assessment
+    const overallScore = Math.round((review.scores.quality + review.scores.maintainability + review.scores.security + review.scores.testCoverage) / 4);
+    console.log(chalk[getScoreColor(overallScore)](`🎯 Overall Code Health: ${overallScore}/100`));
+  }
+
+  generateRealCodeReview() {
+    const fs = require('fs');
+    const path = require('path');
+    
+    const review = {
+      scores: {
+        quality: 100,
+        maintainability: 100,
+        security: 100,
+        testCoverage: 50
+      },
+      architecture: [],
+      qualityIssues: [],
+      maintainabilityMetrics: [],
+      recommendations: []
+    };
+
+    // Code quality patterns to analyze
+    const qualityPatterns = [
+      { pattern: /function\s+\w+\s*\([^)]*\)\s*\{[\s\S]{500,}?\}/, type: 'Long Function', description: 'Function exceeds recommended length' },
+      { pattern: /if\s*\([^)]+\)\s*\{[\s\S]*?if\s*\([^)]+\)\s*\{[\s\S]*?if\s*\([^)]+\)/, type: 'Deep Nesting', description: 'Excessive nesting depth detected' },
+      { pattern: /var\s+\w+/, type: 'Var Usage', description: 'Use const/let instead of var' },
+      { pattern: /==\s*(?!null)/, type: 'Loose Equality', description: 'Use strict equality (===) instead' },
+      { pattern: /console\.log/, type: 'Debug Code', description: 'Remove console.log from production code' },
+      { pattern: /\.catch\s*\(\s*\(\s*\)\s*=>\s*\{\s*\}\s*\)/, type: 'Empty Catch', description: 'Empty catch block - handle errors properly' }
+    ];
+
+    // Maintainability patterns
+    const maintainabilityPatterns = [
+      { pattern: /\/\*[\s\S]*?\*\/|\/\/.*$/gm, type: 'Comments', description: 'Code documentation' },
+      { pattern: /class\s+\w+/, type: 'Classes', description: 'Object-oriented structure' },
+      { pattern: /export\s+/, type: 'Modules', description: 'Modular architecture' },
+      { pattern: /import\s+.*from/, type: 'Dependencies', description: 'Dependency management' }
+    ];
+
+    // Architecture patterns
+    const architecturePatterns = [
+      { pattern: /class\s+\w+Manager/, type: 'Manager Pattern', description: 'Centralized management logic' },
+      { pattern: /\.on\(|\.emit\(/, type: 'Event-Driven', description: 'Event-driven architecture' },
+      { pattern: /async\s+function|await\s+/, type: 'Async Pattern', description: 'Asynchronous programming patterns' },
+      { pattern: /module\.exports\s*=/, type: 'Module System', description: 'CommonJS module pattern' }
+    ];
+
+    let totalLines = 0;
+    let totalFunctions = 0;
+    let totalClasses = 0;
+    let commentLines = 0;
+    let testFiles = 0;
+
+    // Analyze codebase
+    const analyzeDirectory = (dir, depth = 0) => {
+      if (depth > 3) return;
+      
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          
+          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+          
+          if (entry.isFile() && this.isCodeFile(entry.name)) {
+            this.analyzeCodeFile(fullPath, qualityPatterns, maintainabilityPatterns, architecturePatterns, review);
+            
+            // Count metrics
+            const content = fs.readFileSync(fullPath, 'utf8');
+            const lines = content.split('\n');
+            totalLines += lines.length;
+            
+            // Count functions and classes
+            totalFunctions += (content.match(/function\s+\w+|=>\s*\{|\w+\s*:\s*function/g) || []).length;
+            totalClasses += (content.match(/class\s+\w+/g) || []).length;
+            
+            // Count comments
+            commentLines += (content.match(/\/\*[\s\S]*?\*\/|\/\/.*$/gm) || []).length;
+            
+            // Check if it's a test file
+            if (entry.name.includes('test') || entry.name.includes('spec')) {
+              testFiles++;
+            }
+            
+          } else if (entry.isDirectory()) {
+            analyzeDirectory(fullPath, depth + 1);
+          }
+        }
+      } catch (error) {
+        // Skip directories we can't read
+      }
+    };
+
+    analyzeDirectory(process.cwd());
+
+    // Calculate scores based on findings
+    const qualityIssueCount = review.qualityIssues.length;
+    review.scores.quality = Math.max(0, 100 - (qualityIssueCount * 5));
+
+    // Maintainability score based on structure and documentation
+    const commentRatio = totalLines > 0 ? (commentLines / totalLines) * 100 : 0;
+    const avgFunctionsPerFile = totalFunctions > 0 ? totalFunctions / (totalLines / 50) : 0;
+    
+    review.scores.maintainability = Math.max(0, 100 - 
+      (avgFunctionsPerFile > 10 ? 20 : 0) - 
+      (commentRatio < 10 ? 15 : 0) - 
+      (totalClasses === 0 ? 10 : 0));
+
+    // Test coverage estimation
+    review.scores.testCoverage = Math.min(100, testFiles * 20);
+
+    // Add maintainability metrics
+    review.maintainabilityMetrics.push({
+      metric: 'Comment Ratio',
+      value: `${commentRatio.toFixed(1)}%`,
+      assessment: commentRatio > 15 ? 'Good' : commentRatio > 5 ? 'Fair' : 'Poor',
+      suggestion: commentRatio < 10 ? 'Add more documentation' : null
+    });
+
+    review.maintainabilityMetrics.push({
+      metric: 'Total Lines of Code',
+      value: totalLines.toString(),
+      assessment: totalLines < 5000 ? 'Manageable' : totalLines < 15000 ? 'Large' : 'Very Large'
+    });
+
+    review.maintainabilityMetrics.push({
+      metric: 'Functions Count',
+      value: totalFunctions.toString(),
+      assessment: 'Active'
+    });
+
+    review.maintainabilityMetrics.push({
+      metric: 'Classes Count',
+      value: totalClasses.toString(),
+      assessment: totalClasses > 0 ? 'Object-oriented' : 'Functional'
+    });
+
+    // Generate AI-powered recommendations
+    if (qualityIssueCount > 0) {
+      review.recommendations.push({
+        category: 'Code Quality',
+        suggestion: 'Address code quality issues to improve maintainability',
+        priority: 'High'
+      });
+    }
+
+    if (review.scores.testCoverage < 70) {
+      review.recommendations.push({
+        category: 'Testing',
+        suggestion: 'Increase test coverage with unit and integration tests',
+        priority: 'High'
+      });
+    }
+
+    if (commentRatio < 10) {
+      review.recommendations.push({
+        category: 'Documentation',
+        suggestion: 'Add more inline documentation and comments',
+        priority: 'Medium'
+      });
+    }
+
+    review.recommendations.push({
+      category: 'Architecture',
+      suggestion: 'Consider implementing design patterns for better code organization',
+      priority: 'Medium'
+    });
+
+    review.recommendations.push({
+      category: 'Performance',
+      suggestion: 'Profile critical code paths and optimize bottlenecks',
+      priority: 'Low'
+    });
+
+    review.recommendations.push({
+      category: 'Security',
+      suggestion: 'Implement input validation and security best practices',
+      priority: 'High'
+    });
+
+    return review;
+  }
+
+  analyzeCodeFile(filePath, qualityPatterns, maintainabilityPatterns, architecturePatterns, review) {
+    const fs = require('fs');
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      // Check for quality issues
+      for (const patternInfo of qualityPatterns) {
+        if (patternInfo.pattern.test(content)) {
+          review.qualityIssues.push({
+            type: patternInfo.type,
+            description: patternInfo.description,
+            file: filePath.replace(process.cwd(), '.'),
+            line: this.findPatternLine(lines, patternInfo.pattern)
+          });
+        }
+      }
+      
+      // Check architecture patterns
+      for (const patternInfo of architecturePatterns) {
+        if (patternInfo.pattern.test(content)) {
+          review.architecture.push({
+            type: patternInfo.type,
+            description: patternInfo.description,
+            file: filePath.replace(process.cwd(), '.')
+          });
+        }
+      }
+      
+    } catch (error) {
+      // Skip files we can't read
+    }
+  }
+
+  findPatternLine(lines, pattern) {
+    for (let i = 0; i < lines.length; i++) {
+      if (pattern.test(lines[i])) {
+        return i + 1;
+      }
+    }
+    return 1;
+  }
+
+  performSecurityAnalysis() {
+    console.log(chalk.cyan('🛡️ Performing Security Analysis...'));
+    console.log('');
+    
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  🛡️ Security Vulnerability Scan       ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    const securityReport = this.performRealSecurityScan();
+    
+    // Display security score
+    let scoreColor = 'green';
+    if (securityReport.score < 70) scoreColor = 'red';
+    else if (securityReport.score < 85) scoreColor = 'yellow';
+    
+    console.log(chalk[scoreColor](`🛡️ Security Score: ${securityReport.score}/100`));
+    console.log('');
+    
+    // Display vulnerabilities by severity
+    if (securityReport.vulnerabilities.critical.length > 0) {
+      console.log(chalk.red('🚨 Critical Vulnerabilities:'));
+      securityReport.vulnerabilities.critical.forEach(vuln => {
+        console.log(chalk.red(`   • ${vuln.type}: ${vuln.description}`));
+        console.log(chalk.gray(`     File: ${vuln.file}:${vuln.line}`));
+      });
+      console.log('');
+    }
+    
+    if (securityReport.vulnerabilities.high.length > 0) {
+      console.log(chalk.red('⚠️ High Risk Issues:'));
+      securityReport.vulnerabilities.high.forEach(vuln => {
+        console.log(chalk.yellow(`   • ${vuln.type}: ${vuln.description}`));
+        console.log(chalk.gray(`     File: ${vuln.file}:${vuln.line}`));
+      });
+      console.log('');
+    }
+    
+    if (securityReport.vulnerabilities.medium.length > 0) {
+      console.log(chalk.yellow('⚠️ Medium Risk Issues:'));
+      securityReport.vulnerabilities.medium.forEach(vuln => {
+        console.log(chalk.yellow(`   • ${vuln.type}: ${vuln.description}`));
+        console.log(chalk.gray(`     File: ${vuln.file}:${vuln.line}`));
+      });
+      console.log('');
+    }
+    
+    if (securityReport.vulnerabilities.low.length > 0) {
+      console.log(chalk.cyan('ℹ️ Low Risk Issues:'));
+      securityReport.vulnerabilities.low.forEach(vuln => {
+        console.log(chalk.cyan(`   • ${vuln.type}: ${vuln.description}`));
+        console.log(chalk.gray(`     File: ${vuln.file}:${vuln.line}`));
+      });
+      console.log('');
+    }
+    
+    // Show dependency vulnerabilities
+    if (securityReport.dependencyIssues.length > 0) {
+      console.log(chalk.yellow('📦 Dependency Vulnerabilities:'));
+      securityReport.dependencyIssues.forEach(dep => {
+        console.log(chalk.yellow(`   • ${dep.name}@${dep.version}: ${dep.issue}`));
+        console.log(chalk.gray(`     Severity: ${dep.severity}, Fix: ${dep.fix}`));
+      });
+      console.log('');
+    }
+    
+    // Show recommendations
+    if (securityReport.recommendations.length > 0) {
+      console.log(chalk.cyan('💡 Security Recommendations:'));
+      securityReport.recommendations.forEach(rec => {
+        console.log(chalk.white(`   • ${rec}`));
+      });
+      console.log('');
+    }
+    
+    // Summary
+    const totalIssues = securityReport.vulnerabilities.critical.length + 
+                       securityReport.vulnerabilities.high.length + 
+                       securityReport.vulnerabilities.medium.length + 
+                       securityReport.vulnerabilities.low.length;
+    
+    if (totalIssues === 0) {
+      console.log(chalk.green('✅ No security vulnerabilities detected in code scan'));
+    } else {
+      console.log(chalk.yellow(`📊 Total Issues Found: ${totalIssues}`));
+    }
+  }
+
+  performRealSecurityScan() {
+    const fs = require('fs');
+    const path = require('path');
+    
+    const securityReport = {
+      score: 100,
+      vulnerabilities: {
+        critical: [],
+        high: [],
+        medium: [],
+        low: []
+      },
+      dependencyIssues: [],
+      recommendations: []
+    };
+
+    // Security patterns to detect
+    const securityPatterns = {
+      critical: [
+        { pattern: /password\s*=\s*['"][^'"]+['"]/, type: 'Hardcoded Password', description: 'Hardcoded password detected' },
+        { pattern: /api[_-]?key\s*=\s*['"][^'"]+['"]/, type: 'Hardcoded API Key', description: 'Hardcoded API key detected' },
+        { pattern: /secret\s*=\s*['"][^'"]+['"]/, type: 'Hardcoded Secret', description: 'Hardcoded secret detected' },
+        { pattern: /eval\s*\(/, type: 'Code Injection', description: 'Use of eval() detected - potential code injection risk' }
+      ],
+      high: [
+        { pattern: /exec\s*\(.*\$/, type: 'Command Injection', description: 'Potential command injection vulnerability' },
+        { pattern: /innerHTML\s*=/, type: 'XSS Risk', description: 'Use of innerHTML - potential XSS vulnerability' },
+        { pattern: /document\.write\s*\(/, type: 'XSS Risk', description: 'Use of document.write - potential XSS vulnerability' },
+        { pattern: /sql\s*=.*\+/, type: 'SQL Injection', description: 'Potential SQL injection vulnerability' }
+      ],
+      medium: [
+        { pattern: /console\.log\s*\(.*password/, type: 'Information Disclosure', description: 'Password logged to console' },
+        { pattern: /console\.log\s*\(.*token/, type: 'Information Disclosure', description: 'Token logged to console' },
+        { pattern: /http:\/\//, type: 'Insecure Protocol', description: 'Use of insecure HTTP protocol' },
+        { pattern: /Math\.random\s*\(\)/, type: 'Weak Cryptography', description: 'Use of Math.random() for security purposes' }
+      ],
+      low: [
+        { pattern: /TODO.*security/, type: 'Security TODO', description: 'Security-related TODO comment' },
+        { pattern: /FIXME.*security/, type: 'Security FIXME', description: 'Security-related FIXME comment' },
+        { pattern: /\.trim\s*\(\)\.length/, type: 'Input Validation', description: 'Consider more robust input validation' }
+      ]
+    };
+
+    // Scan files for security issues
+    const scanDirectory = (dir, depth = 0) => {
+      if (depth > 3) return;
+      
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          
+          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+          
+          if (entry.isFile() && this.isCodeFile(entry.name)) {
+            this.scanFileForSecurity(fullPath, securityPatterns, securityReport);
+          } else if (entry.isDirectory()) {
+            scanDirectory(fullPath, depth + 1);
+          }
+        }
+      } catch (error) {
+        // Skip directories we can't read
+      }
+    };
+
+    scanDirectory(process.cwd());
+
+    // Check dependencies for known vulnerabilities
+    this.checkDependencyVulnerabilities(securityReport);
+
+    // Calculate final score
+    const criticalCount = securityReport.vulnerabilities.critical.length;
+    const highCount = securityReport.vulnerabilities.high.length;
+    const mediumCount = securityReport.vulnerabilities.medium.length;
+    const lowCount = securityReport.vulnerabilities.low.length;
+    
+    securityReport.score = Math.max(0, 100 - (criticalCount * 25) - (highCount * 15) - (mediumCount * 10) - (lowCount * 5));
+
+    // Generate recommendations based on findings
+    if (criticalCount > 0) {
+      securityReport.recommendations.push('🚨 Address critical vulnerabilities immediately');
+    }
+    if (highCount > 0) {
+      securityReport.recommendations.push('⚠️ Review and fix high-risk security issues');
+    }
+    
+    securityReport.recommendations.push('🔒 Use environment variables for sensitive data');
+    securityReport.recommendations.push('🛡️ Implement input validation and sanitization');
+    securityReport.recommendations.push('📦 Keep dependencies updated regularly');
+    securityReport.recommendations.push('🔍 Consider using a security linter (ESLint security plugin)');
+
+    return securityReport;
+  }
+
+  isCodeFile(filename) {
+    const codeExtensions = ['.js', '.ts', '.py', '.java', '.cpp', '.c', '.cs', '.go', '.rs', '.php', '.rb'];
+    return codeExtensions.some(ext => filename.toLowerCase().endsWith(ext));
+  }
+
+  scanFileForSecurity(filePath, patterns, report) {
+    const fs = require('fs');
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      for (const [severity, patternList] of Object.entries(patterns)) {
+        for (const patternInfo of patternList) {
+          for (let i = 0; i < lines.length; i++) {
+            if (patternInfo.pattern.test(lines[i])) {
+              report.vulnerabilities[severity].push({
+                type: patternInfo.type,
+                description: patternInfo.description,
+                file: filePath.replace(process.cwd(), '.'),
+                line: i + 1,
+                code: lines[i].trim()
+              });
+            }
+          }
+        }
+      }
+    } catch (error) {
+      // Skip files we can't read
+    }
+  }
+
+  checkDependencyVulnerabilities(report) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      const packagePath = path.join(process.cwd(), 'package.json');
+      if (!fs.existsSync(packagePath)) return;
+      
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      
+      // Check for known vulnerable packages (simplified check)
+      const knownVulnerablePackages = {
+        'lodash': { versions: ['< 4.17.21'], issue: 'Prototype pollution vulnerability', severity: 'High', fix: 'Update to latest version' },
+        'node-forge': { versions: ['< 1.0.0'], issue: 'RSA PKCS#1 signature verification issue', severity: 'High', fix: 'Update to 1.0.0+' },
+        'axios': { versions: ['< 0.21.2'], issue: 'Server-side request forgery', severity: 'Medium', fix: 'Update to 0.21.2+' }
+      };
+      
+      for (const [depName, version] of Object.entries(dependencies)) {
+        if (knownVulnerablePackages[depName]) {
+          const vuln = knownVulnerablePackages[depName];
+          report.dependencyIssues.push({
+            name: depName,
+            version: version,
+            issue: vuln.issue,
+            severity: vuln.severity,
+            fix: vuln.fix
+          });
+        }
+      }
+    } catch (error) {
+      // Could not check dependencies
+    }
+  }
+
+  performOptimizationAnalysis() {
+    console.log(chalk.cyan('⚡ Analyzing Performance...'));
+    console.log('');
+    
+    console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  ⚡ Performance Analysis               ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
+    console.log('');
+    
+    const perfReport = this.performRealPerformanceAnalysis();
+    
+    // Display performance score
+    let scoreColor = 'green';
+    if (perfReport.score < 60) scoreColor = 'red';
+    else if (perfReport.score < 80) scoreColor = 'yellow';
+    
+    console.log(chalk[scoreColor](`⚡ Performance Score: ${perfReport.score}/100`));
+    console.log('');
+    
+    // Display bottlenecks
+    if (perfReport.bottlenecks.length > 0) {
+      console.log(chalk.yellow('🐌 Performance Bottlenecks Detected:'));
+      perfReport.bottlenecks.forEach(bottleneck => {
+        console.log(chalk.white(`   • ${bottleneck.type}: ${bottleneck.description}`));
+        console.log(chalk.gray(`     File: ${bottleneck.file}:${bottleneck.line}`));
+      });
+      console.log('');
+    }
+    
+    // Display file size issues
+    if (perfReport.fileSizeIssues.length > 0) {
+      console.log(chalk.yellow('📁 Large File Issues:'));
+      perfReport.fileSizeIssues.forEach(issue => {
+        console.log(chalk.white(`   • ${issue.file}: ${issue.sizeKB}KB (${issue.description})`));
+      });
+      console.log('');
+    }
+    
+    // Display dependency analysis
+    if (perfReport.dependencyImpact.heavyDependencies.length > 0) {
+      console.log(chalk.yellow('📦 Heavy Dependencies:'));
+      perfReport.dependencyImpact.heavyDependencies.forEach(dep => {
+        console.log(chalk.white(`   • ${dep}: Large bundle size impact`));
+      });
+      console.log('');
+    }
+    
+    // Display optimization suggestions
+    if (perfReport.optimizations.length > 0) {
+      console.log(chalk.cyan('🚀 Optimization Suggestions:'));
+      perfReport.optimizations.forEach(opt => {
+        console.log(chalk.white(`   • ${opt}`));
+      });
+      console.log('');
+    }
+    
+    // Show memory usage patterns
+    if (perfReport.memoryPatterns.length > 0) {
+      console.log(chalk.blue('🧠 Memory Usage Patterns:'));
+      perfReport.memoryPatterns.forEach(pattern => {
+        console.log(chalk.white(`   • ${pattern.type}: ${pattern.description}`));
+        if (pattern.file) {
+          console.log(chalk.gray(`     File: ${pattern.file}:${pattern.line}`));
+        }
+      });
+      console.log('');
+    }
+    
+    // Summary
+    const totalIssues = perfReport.bottlenecks.length + perfReport.fileSizeIssues.length;
+    if (totalIssues === 0) {
+      console.log(chalk.green('✅ No major performance issues detected'));
+    } else {
+      console.log(chalk.yellow(`📊 Total Performance Issues: ${totalIssues}`));
+    }
+  }
+
+  performRealPerformanceAnalysis() {
+    const fs = require('fs');
+    const path = require('path');
+    
+    const perfReport = {
+      score: 100,
+      bottlenecks: [],
+      fileSizeIssues: [],
+      dependencyImpact: {
+        heavyDependencies: [],
+        totalDependencies: 0
+      },
+      memoryPatterns: [],
+      optimizations: []
+    };
+
+    // Performance anti-patterns to detect
+    const performancePatterns = [
+      { pattern: /for\s*\(.*\.length.*\)/, type: 'Loop Optimization', description: 'Loop with .length in condition - cache length outside loop' },
+      { pattern: /document\.getElementById.*\(/, type: 'DOM Query', description: 'Repeated DOM queries - consider caching elements' },
+      { pattern: /\$\(.*\)\..*\$\(.*\)/, type: 'jQuery Chaining', description: 'Multiple jQuery selectors - consider chaining or caching' },
+      { pattern: /setInterval\s*\(.*1\)/, type: 'High Frequency Timer', description: 'Very high frequency interval detected' },
+      { pattern: /JSON\.parse\s*\(.*JSON\.stringify/, type: 'Deep Clone', description: 'Inefficient deep cloning - consider structured clone or lodash' },
+      { pattern: /new\s+Array\s*\(/, type: 'Array Constructor', description: 'Use array literal [] instead of new Array()' },
+      { pattern: /\.innerHTML\s*\+=/, type: 'DOM Manipulation', description: 'Inefficient DOM updates - consider batch operations' },
+      { pattern: /require\s*\(.*\).*require\s*\(.*\)/, type: 'Module Loading', description: 'Multiple requires in same scope - consider combining imports' }
+    ];
+
+    // Memory leak patterns
+    const memoryPatterns = [
+      { pattern: /addEventListener.*(?!removeEventListener)/, type: 'Event Listener Leak', description: 'Event listener without cleanup' },
+      { pattern: /setInterval.*(?!clearInterval)/, type: 'Timer Leak', description: 'setInterval without clearInterval' },
+      { pattern: /setTimeout.*(?!clearTimeout)/, type: 'Timer Leak', description: 'setTimeout pattern that might not clear' },
+      { pattern: /closure.*function.*closure/, type: 'Closure Chain', description: 'Potential closure memory retention' }
+    ];
+
+    // Scan files for performance issues
+    const scanDirectory = (dir, depth = 0) => {
+      if (depth > 3) return;
+      
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          
+          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+          
+          if (entry.isFile()) {
+            // Check file size
+            const stats = fs.statSync(fullPath);
+            const sizeKB = Math.round(stats.size / 1024);
+            
+            if (sizeKB > 500 && this.isCodeFile(entry.name)) {
+              perfReport.fileSizeIssues.push({
+                file: fullPath.replace(process.cwd(), '.'),
+                sizeKB: sizeKB,
+                description: sizeKB > 1000 ? 'Very large file - consider splitting' : 'Large file - review for optimization'
+              });
+            }
+            
+            // Scan code files for performance patterns
+            if (this.isCodeFile(entry.name)) {
+              this.scanFileForPerformance(fullPath, performancePatterns, memoryPatterns, perfReport);
+            }
+          } else if (entry.isDirectory()) {
+            scanDirectory(fullPath, depth + 1);
+          }
+        }
+      } catch (error) {
+        // Skip directories we can't read
+      }
+    };
+
+    scanDirectory(process.cwd());
+
+    // Analyze dependencies
+    this.analyzeDependencyPerformance(perfReport);
+
+    // Calculate score based on findings
+    const bottleneckCount = perfReport.bottlenecks.length;
+    const fileSizeIssueCount = perfReport.fileSizeIssues.length;
+    const memoryIssueCount = perfReport.memoryPatterns.length;
+    
+    perfReport.score = Math.max(0, 100 - (bottleneckCount * 10) - (fileSizeIssueCount * 5) - (memoryIssueCount * 8));
+
+    // Generate optimization recommendations
+    if (bottleneckCount > 0) {
+      perfReport.optimizations.push('🔧 Address performance bottlenecks in critical code paths');
+    }
+    if (fileSizeIssueCount > 0) {
+      perfReport.optimizations.push('📦 Consider code splitting for large files');
+    }
+    if (memoryIssueCount > 0) {
+      perfReport.optimizations.push('🧠 Implement proper memory management and cleanup');
+    }
+    
+    perfReport.optimizations.push('⚡ Use Web Workers for CPU-intensive tasks');
+    perfReport.optimizations.push('🗂️ Implement lazy loading for non-critical resources');
+    perfReport.optimizations.push('📊 Add performance monitoring and profiling');
+    perfReport.optimizations.push('🔄 Consider using virtual scrolling for large lists');
+
+    return perfReport;
+  }
+
+  scanFileForPerformance(filePath, performancePatterns, memoryPatterns, report) {
+    const fs = require('fs');
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      // Check for performance bottlenecks
+      for (const patternInfo of performancePatterns) {
+        for (let i = 0; i < lines.length; i++) {
+          if (patternInfo.pattern.test(lines[i])) {
+            report.bottlenecks.push({
+              type: patternInfo.type,
+              description: patternInfo.description,
+              file: filePath.replace(process.cwd(), '.'),
+              line: i + 1,
+              code: lines[i].trim()
+            });
+          }
+        }
+      }
+      
+      // Check for memory patterns
+      for (const patternInfo of memoryPatterns) {
+        for (let i = 0; i < lines.length; i++) {
+          if (patternInfo.pattern.test(lines[i])) {
+            report.memoryPatterns.push({
+              type: patternInfo.type,
+              description: patternInfo.description,
+              file: filePath.replace(process.cwd(), '.'),
+              line: i + 1,
+              code: lines[i].trim()
+            });
+          }
+        }
+      }
+    } catch (error) {
+      // Skip files we can't read
+    }
+  }
+
+  analyzeDependencyPerformance(report) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      const packagePath = path.join(process.cwd(), 'package.json');
+      if (!fs.existsSync(packagePath)) return;
+      
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      
+      report.dependencyImpact.totalDependencies = Object.keys(dependencies).length;
+      
+      // Known heavy dependencies that impact performance
+      const heavyDependencies = ['lodash', 'moment', 'jquery', 'axios', 'react', 'vue', 'angular'];
+      
+      for (const depName of Object.keys(dependencies)) {
+        if (heavyDependencies.includes(depName)) {
+          report.dependencyImpact.heavyDependencies.push(depName);
+        }
+      }
+      
+      // Add recommendations based on dependency analysis
+      if (dependencies['lodash']) {
+        report.optimizations.push('Consider using native ES6 methods instead of lodash where possible');
+      }
+      if (dependencies['moment']) {
+        report.optimizations.push('Consider using date-fns or dayjs instead of moment.js for smaller bundle size');
+      }
+      
+    } catch (error) {
+      // Skip dependency analysis if package.json is not readable
+    }
+  }
+
+  cycleTheme() {
+    if (!this.currentTheme) this.currentTheme = 'neon-purple';
+    
+    const themes = ['neon-purple', 'matrix-green', 'ocean-blue', 'sunset-orange'];
+    const currentIndex = themes.indexOf(this.currentTheme);
+    const nextIndex = (currentIndex + 1) % themes.length;
+    this.currentTheme = themes[nextIndex];
+    
+    console.log(chalk.cyan(`🎨 Theme switched to: ${this.currentTheme}`));
+    console.log(chalk.gray('New color scheme will apply to future messages'));
+    console.log('');
+  }
+
+  async cleanup() {
+    this.logger.info('Starting cleanup process');
+    
+    // Clean up streaming and loading animations
+    this.stopProgressiveLoading();
+    this.stopStreamingDisplay();
+    
+    if (this.fileWatcher) {
+      this.fileWatcher.close();
+      this.fileWatcher = null;
+      this.logger.debug('File watcher closed');
+    }
+    
+    // Cleanup voice manager
+    if (this.voiceManager) {
+      this.voiceManager.cleanup();
+      this.logger.debug('Voice manager cleaned up');
+    }
+    
+    // Cleanup collaboration manager
+    if (this.collaborationManager) {
+      this.collaborationManager.cleanup();
+      this.logger.debug('Collaboration manager cleaned up');
+    }
+    
+    // Cleanup plugins
+    if (this.pluginManager) {
+      await this.pluginManager.cleanup();
+      this.logger.debug('Plugins cleaned up');
+    }
+    
+    // End session logging
+    if (this.logger) {
+      this.logger.endSession();
+      this.logger.info('Session cleanup completed');
+    }
+  }
+
+  /**
+   * Load user configuration from onboarding
+   */
+  loadUserConfig() {
+    const path = require('path');
+    const fs = require('fs');
+    const configFile = path.join(require('os').homedir(), '.recoder-code', 'config.json');
+    
+    try {
+      if (fs.existsSync(configFile)) {
+        return JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      }
+    } catch (error) {
+      // Return empty config if can't load
+    }
+    
+    return {};
+  }
+
   start() {
     this.rl.prompt();
   }