recoder-code 2.2.1 → 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;
     
@@ -106,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;
@@ -152,7 +166,11 @@ class InteractiveRecoderChat {
       
       // 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();
@@ -162,30 +180,46 @@ class InteractiveRecoderChat {
       
       // 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();
@@ -1182,32 +1216,100 @@ class InteractiveRecoderChat {
   displayWelcome() {
     console.clear();
     
-    // Beautiful welcome screen with neon purple/white/gray theme
-    console.log('');
-    console.log(chalk.magenta('╭─────────────────────────────────────────────────────────────╮'));
-    console.log(chalk.magenta('│') + chalk.white.bold('  ✨ Welcome to Recoder Code                                ') + chalk.magenta('│'));
-    console.log(chalk.magenta('╰─────────────────────────────────────────────────────────────╯'));
+    // Enhanced welcome screen with gradient effects and animations
     console.log('');
     
-    // Stylized ASCII art in neon purple
-    console.log(chalk.magenta.bold('██████╗ ███████╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗'));
-    console.log(chalk.magenta.bold('██╔══██╗██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗'));
-    console.log(chalk.magenta.bold('██████╔╝█████╗  ██║     ██║   ██║██║  ██║█████╗  ██████╔╝'));
-    console.log(chalk.white('██╔══██╗██╔══╝  ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗'));
-    console.log(chalk.white('██║  ██║███████╗╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║'));
-    console.log(chalk.gray('╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝'));
+    // Animated gradient border
+    this.displayAnimatedBorder();
+    
+    // Beautiful gradient ASCII art
+    console.log('');
+    this.displayGradientLogo();
     console.log('');
     
-    // Status line
-    console.log(chalk.gray('Press Enter to continue'));
+    // Dynamic status information
+    this.displayDynamicStatus();
     console.log('');
     
-    // Add bottom status hints like Claude Code
-    this.showStatusHints();
+    // Enhanced status hints with themes
+    this.showEnhancedStatusHints();
     
     this.rl.prompt();
   }
 
+  displayAnimatedBorder() {
+    const colors = ['magenta', 'cyan', 'blue', 'magenta'];
+    const border = '╭─────────────────────────────────────────────────────────────╮';
+    const title = '│  ✨ Welcome to Recoder Code - AI Terminal                   │';
+    const bottom = '╰─────────────────────────────────────────────────────────────╯';
+    
+    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 {
+      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('╭─────────────────────────────────────────╮'));
@@ -1324,6 +1426,24 @@ class InteractiveRecoderChat {
       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'));
@@ -1335,17 +1455,37 @@ class InteractiveRecoderChat {
   showHelp() {
     console.log('');
     console.log(chalk.magenta('╭─────────────────────────────────────────╮'));
-    console.log(chalk.magenta('│') + chalk.white.bold('  Available Commands                   ') + chalk.magenta('│'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  🚀 Available Commands                ') + chalk.magenta('│'));
     console.log(chalk.magenta('╰─────────────────────────────────────────╯'));
     console.log('');
-    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('/history ') + chalk.white('Show conversation history'));
-    console.log(chalk.gray('/session ') + chalk.white('Show current session info'));
-    console.log(chalk.gray('/watch   ') + chalk.white('Show watched files'));
-    console.log(chalk.gray('/save    ') + chalk.white('Save current session'));
-    console.log(chalk.gray('/exit    ') + chalk.white('Exit Recoder Code'));
+    
+    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('');
   }
 
@@ -4092,42 +4232,1316 @@ ${projectInfo}`
     }
   }
 
-  async cleanup() {
-    this.logger.info('Starting cleanup process');
+  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('');
     
-    // Clean up streaming and loading animations
-    this.stopProgressiveLoading();
-    this.stopStreamingDisplay();
+    const analysis = this.analyzeCurrentProject();
     
-    if (this.fileWatcher) {
-      this.fileWatcher.close();
-      this.fileWatcher = null;
-      this.logger.debug('File watcher closed');
+    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 = '';
     
-    // Cleanup voice manager
-    if (this.voiceManager) {
-      this.voiceManager.cleanup();
-      this.logger.debug('Voice manager cleaned up');
+    for (const [ext, count] of Object.entries(fileTypes)) {
+      if (count > maxCount && ext !== '.md' && ext !== '.json') {
+        maxCount = count;
+        mainExt = ext;
+      }
     }
     
-    // Cleanup collaboration manager
-    if (this.collaborationManager) {
-      this.collaborationManager.cleanup();
-      this.logger.debug('Collaboration manager cleaned up');
+    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');
     
-    // Cleanup plugins
-    if (this.pluginManager) {
-      await this.pluginManager.cleanup();
-      this.logger.debug('Plugins cleaned up');
+    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('');
     
-    // End session logging
-    if (this.logger) {
-      this.logger.endSession();
-      this.logger.info('Session cleanup completed');
+    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() {