recoder-code 2.1.4 → 2.2.1

package/cli/interactive.js

@@ -87,8 +87,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();
@@ -115,6 +117,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 +132,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.cyan('🤖 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,7 +148,7 @@ 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();
@@ -177,7 +156,6 @@ class InteractiveRecoderChat {
       
       // 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);
@@ -212,11 +190,7 @@ class InteractiveRecoderChat {
       // 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 +377,9 @@ class InteractiveRecoderChat {
     const convIndicator = this.currentConversationId === 'main' ? '' : chalk.gray(`[${currentConv.name}] `);
     
     if (this.multiLineMode) {
-      this.rl.setPrompt(chalk.yellow('📝 ... '));
+      this.rl.setPrompt(chalk.gray('... '));
     } else {
-      this.rl.setPrompt(convIndicator + chalk.cyan('🤖 You: '));
+      this.rl.setPrompt(convIndicator + chalk.gray('> '));
     }
   }
 
@@ -793,6 +767,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,63 +957,589 @@ class InteractiveRecoderChat {
     });
   }
 
+  promptForApiKey() {
+    console.clear();
+    console.log('');
+    console.log(chalk.magenta('╭─────────────────────────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  ✨ Welcome to Recoder Code                                ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────────────────────────╯'));
+    console.log('');
+    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('');
+    
+    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();
+  }
+
+  async handleUserInput(input) {
+    if (!input) {
+      this.rl.prompt();
+      return;
+    }
+
+    // Handle slash commands like Claude Code
+    if (input.startsWith('/')) {
+      this.handleSlashCommand(input);
+      return;
+    }
+
+    try {
+      // Track performance metrics
+      const startTime = Date.now();
+      let firstChunkTime = null;
+      let totalChunks = 0;
+      
+      // Start progressive loading with enhanced animations
+      this.startProgressiveLoading();
+      
+      // Create a RecoderCode instance to process the conversation
+      const { RecoderCode } = require('./run.js');
+      const recoder = new RecoderCode();
+      
+      // 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);
+        }
+      });
+      
+      // 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 {
+        // Finalize streaming display
+        this.finalizeStreamingResponse(response, totalDuration);
+      }
+      
+      console.log('');
+      
+    } catch (error) {
+      this.stopProgressiveLoading();
+      this.stopStreamingDisplay();
+      console.log('');
+      this.showEnhancedError(error);
+      console.log('');
+    }
+    
+    this.rl.prompt();
+  }
+
   displayWelcome() {
     console.clear();
     
-    // Simple welcome message like Claude Code
-    console.log('');
-    console.log(chalk.bold('✱ Welcome to Recoder-Code!'));
+    // Beautiful welcome screen with neon purple/white/gray theme
     console.log('');
-    console.log(chalk.gray('/help for help, /status for your current setup'));
+    console.log(chalk.magenta('╭─────────────────────────────────────────────────────────────╮'));
+    console.log(chalk.magenta('│') + chalk.white.bold('  ✨ Welcome to Recoder Code                                ') + chalk.magenta('│'));
+    console.log(chalk.magenta('╰─────────────────────────────────────────────────────────────╯'));
     console.log('');
-    console.log(chalk.gray(`cwd: ${process.cwd()}`));
+    
+    // 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('╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝'));
     console.log('');
+    
+    // Status line
+    console.log(chalk.gray('Press Enter to continue'));
     console.log('');
-    // Show session suggestions if available
-    this.showSessionSuggestions();
     
-    console.log(chalk.green('💬 Start chatting! Just type what you want to do.'));
-    console.log(chalk.white('✨ Examples: build a todo app, fix my login error, deploy this project'));
+    // Add bottom status hints like Claude Code
+    this.showStatusHints();
+    
+    this.rl.prompt();
+  }
+
+  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;
+      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.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('');
+  }
+
+  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.cyan(`📂 Project: ${projectStatus.context.name}`));
-        console.log(chalk.gray(`   Todos: ${projectStatus.todos.pending} pending, ${projectStatus.todos.completed} completed`));
+        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.yellow('🔄 Resume Previous Session?'));
-        console.log(chalk.cyan(`   Session: ${resumeCandidate.id} (${resumeCandidate.activityDescription})`));
-        console.log(chalk.gray(`   Messages: ${resumeCandidate.messageCount} | Model: ${resumeCandidate.model}`));
+        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(`   • Last: "${resumeCandidate.lastUserMessage}"`));
         }
         
-        console.log(chalk.gray('   💡 Type /resume to continue or start fresh'));
+        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.yellow('🕒 Recent Sessions:'));
+          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(`   ${index + 1}. ${session.id} - ${timeAgo} (${session.messageCount} messages)`));
+            console.log(chalk.gray(`   • ${session.id} - ${timeAgo} (${session.messageCount} messages)`));
           });
-          console.log(chalk.gray('   💡 Use /resume <id> to continue a session'));
+          console.log(chalk.gray('   💡 Use ') + chalk.cyan('/resume <id>') + chalk.gray(' to continue a session'));
           console.log('');
         }
       }
@@ -2905,7 +3410,7 @@ class InteractiveRecoderChat {
     // Update legacy reference
     this.conversationHistory = currentConv.history;
 
-    console.log(chalk.blue('\n🤖 Recoder: '), { end: '' });
+    console.log(chalk.magenta('\n🤖 ') + chalk.white.bold('Recoder: '), { end: '' });
 
     try {
       // Start API call timer
@@ -2925,19 +3430,22 @@ 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
         if (response.usage) {
           currentConv.tokens += response.usage.total_tokens || 0;
           this.totalTokens += response.usage.total_tokens || 0;
-          console.log(chalk.gray(`\n💰 ${response.usage.prompt_tokens} + ${response.usage.completion_tokens} = ${response.usage.total_tokens} tokens`));
+          console.log(chalk.gray(`\n💎 ${response.usage.prompt_tokens} + ${response.usage.completion_tokens} = `) + chalk.magenta(`${response.usage.total_tokens} tokens`));
           
           // Log API call metrics
           const apiDuration = this.logger.endTimer('api_call');
@@ -3397,9 +3905,200 @@ ${projectInfo}`
     }
   }
 
+  // Advanced streaming and progressive loading methods
+  startProgressiveLoading() {
+    if (this.progressiveLoader) {
+      clearInterval(this.progressiveLoader.interval);
+    }
+    
+    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;
+    
+    // Add subtle chunk indicators for debugging
+    if (process.env.RECODER_DEBUG === 'true') {
+      process.stdout.write(chalk.gray(`[${chunkNumber}]`));
+    }
+    
+    // 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));
+    }
+    
+    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'));
+    }
+    
+    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')));
+    }
+  }
+
   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;

package/cli/model-manager.js

@@ -2,7 +2,9 @@
 
 const fs = require('fs');
 const path = require('path');
-const chalk = require('chalk');
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
 const inquirer = require('inquirer');
 
 /**

package/cli/run.js

@@ -1193,7 +1193,7 @@ async function main() {
   }
   
   if (args.length === 0) {
-    // Launch interactive mode when no arguments provided
+    // Launch interactive mode when no arguments provided (skip API key check for interactive mode)
     const InteractiveChat = require('./interactive.js');
     const chat = new InteractiveChat();
     chat.start();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recoder-code",
-  "version": "2.1.4",
+  "version": "2.2.1",
   "description": "Complete AI-powered development platform with ML model training, plugin registry, real-time collaboration, monitoring, infrastructure automation, and enterprise deployment capabilities",
   "main": "index.js",
   "scripts": {