recoder-code 2.2.9 → 2.3.4

package/cli/interactive.js

@@ -153,13 +153,15 @@ class InteractiveRecoderChat {
     
     // Always initialize readline interface first to prevent errors
     this.initializeReadlineInterface();
-    
+
+    // Handle API key prompt and initialization
     if (!this.apiKey) {
-      this.promptForApiKey();
-      return;
+      this.promptForApiKey().then(() => {
+        this.initializeWithApiKey();
+      });
+    } else {
+      this.initializeWithApiKey();
     }
-
-    this.initializeWithApiKey();
   }
 
   /**
@@ -944,9 +946,10 @@ class InteractiveRecoderChat {
 
   async loadPlugins() {
     try {
-      await this.pluginManager.loadPlugins();
+      // Load plugins silently for production mode
+      await this.pluginManager.loadPlugins(true); // true = silent mode
     } catch (error) {
-      console.log(chalk.yellow(`⚠️  Plugin loading failed: ${error.message}`));
+      // Silently fail - don't show errors
     }
   }
 
@@ -1029,7 +1032,7 @@ class InteractiveRecoderChat {
     });
   }
 
-  promptForApiKey() {
+  async promptForApiKey() {
     console.clear();
     console.log('');
     console.log(chalk.magenta('╭─────────────────────────────────────────────────────────────╮'));
@@ -1039,41 +1042,52 @@ class InteractiveRecoderChat {
     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();
+
+    // Use existing readline interface instead of creating a new one
+    return new Promise((resolve) => {
+      this.rl.question(chalk.magenta('Enter your OpenRouter API key: '), (apiKey) => {
+        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();
+
+        resolve();
+      });
     });
   }
   
   initializeReadlineInterface() {
+    // Don't re-initialize if already exists
+    if (this.rl) {
+      return;
+    }
+
+    // Check if stdin is a TTY
+    if (!process.stdin.isTTY) {
+      console.error('Error: stdin is not a TTY. Please run in a proper terminal.');
+      process.exit(1);
+    }
+
     // Initialize readline interface with enhanced options
+    // Set terminal based on environment variable or default to true
+    // If you see double characters, set RECODER_TERMINAL_MODE=false
+    const terminalMode = process.env.RECODER_TERMINAL_MODE !== 'false';
+
     this.rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
       prompt: chalk.gray('> '),
       historySize: 100,
       removeHistoryDuplicates: true,
+      terminal: terminalMode,
       completer: (line) => this.autoComplete(line)
     });
 
-    // Set up readline event handlers
+    // Set up readline event handlers ONCE
     this.setupReadlineHandlers();
   }
 
@@ -1119,10 +1133,21 @@ class InteractiveRecoderChat {
     this.analyzeProjectContext().catch(error => {
       console.log(chalk.yellow(`⚠️  Project context analysis failed: ${error.message}`));
     });
-    this.loadPlugins().catch(error => {
+    this.displayWelcome();
+
+    // Load plugins after welcome, then show prompt again
+    this.loadPlugins().then(() => {
+      // Re-show prompt after plugins finish loading
+      if (this.rl) {
+        console.log(''); // Add blank line
+        this.rl.prompt();
+      }
+    }).catch(error => {
       console.log(chalk.yellow(`⚠️  Plugin loading failed: ${error.message}`));
+      if (this.rl) {
+        this.rl.prompt();
+      }
     });
-    this.displayWelcome();
   }
 
   updatePrompt() {
@@ -1144,119 +1169,158 @@ class InteractiveRecoderChat {
       return;
     }
 
-    // Handle slash commands like Claude Code
+    // Handle slash commands
     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
+
+      // Create RecoderCode instance
       const { RecoderCode } = require('./run.js');
+      if (this.apiKey && !process.env.OPENROUTER_API_KEY) {
+        process.env.OPENROUTER_API_KEY = this.apiKey;
+      }
       const recoder = new RecoderCode();
-      
-      // Initialize streaming response system
-      const streamBuffer = {
-        content: '',
-        chunks: [],
-        isStreaming: false,
-        streamingStarted: false
+
+      // Override tool execution to show indicators
+      const originalExecuteToolCall = recoder.executeToolCall.bind(recoder);
+      recoder.executeToolCall = async (toolCall) => {
+        const toolName = toolCall.function.name;
+        process.stdout.write(chalk.dim(`  ${toolName}...\r`));
+        const result = await originalExecuteToolCall(toolCall);
+        process.stdout.write('             \r');
+        return result;
       };
-      
-      // 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);
-      }
 
-      // Ensure progressive loading is stopped
-      this.stopProgressiveLoading();
-      this.stopStreamingDisplay();
+      // Simple thinking indicator
+      process.stdout.write(chalk.dim('  thinking...\r'));
 
-      console.log('');
+      // Get AI response (non-streaming for cleaner output)
+      const response = await recoder.processConversation(input, false, false, null);
+
+      // Clear thinking indicator
+      process.stdout.write('             \r');
+
+      // Display response and handle tool calls
+      if (response) {
+        // Check if response contains DeepSeek-style tool calls
+        const hasToolCalls = response.includes('<｜tool▁call▁begin｜>');
+
+        if (hasToolCalls) {
+          // Parse and execute tool calls
+          const result = await this.parseAndExecuteToolCalls(response, recoder);
+
+          if (result.toolResults.length > 0) {
+            // Show tool execution results
+            console.log('');
+            result.toolResults.forEach(tr => {
+              console.log(chalk.dim(`  ✓ ${tr.tool}`));
+            });
+
+            // Get follow-up response with tool results
+            const toolContext = result.toolResults.map(tr =>
+              `Tool ${tr.tool} executed: ${tr.result.substring(0, 200)}`
+            ).join('\n');
+
+            const followUp = await recoder.processConversation(
+              `Based on these tool results:\n${toolContext}\n\nProvide a helpful summary of what was done.`,
+              false, false, null
+            );
+
+            const cleanFollowUp = followUp.replace(/<｜tool[^｜]*｜>/g, '').trim();
+            if (cleanFollowUp) {
+              console.log('\n' + cleanFollowUp + '\n');
+            }
+          } else {
+            // No tools executed, show cleaned response
+            const cleanResponse = result.cleanText;
+            if (cleanResponse) {
+              console.log('\n' + cleanResponse + '\n');
+            }
+          }
+        } else {
+          // No tool calls, display normally
+          console.log('\n' + response + '\n');
+        }
+
+        // Track conversation
+        this.conversationHistory.push({
+          timestamp: new Date(),
+          input: input,
+          response: response
+        });
+        this.currentSession.messageCount++;
+        this.currentSession.lastActivity = Date.now();
+      }
 
     } catch (error) {
-      this.stopProgressiveLoading();
-      this.stopStreamingDisplay();
-      console.log('');
-      this.showEnhancedError(error);
-      console.log('');
+      process.stdout.write('             \r');
+      console.log(chalk.red('\n  Error: ' + error.message + '\n'));
     }
 
     this.rl.prompt();
   }
 
+  async parseAndExecuteToolCalls(response, recoder) {
+    const toolResults = [];
+    let cleanText = response;
+
+    // Parse DeepSeek-style tool calls: <｜tool▁call▁begin｜>toolname<｜tool▁sep｜>{"args"}<｜tool▁call▁end｜>
+    const toolCallRegex = /<｜tool▁call▁begin｜>(\w+)<｜tool▁sep｜>({[^}]+})<｜tool▁call▁end｜>/g;
+    let match;
+
+    while ((match = toolCallRegex.exec(response)) !== null) {
+      const toolName = match[1];
+      const argsJson = match[2];
+
+      try {
+        const args = JSON.parse(argsJson);
+
+        // Execute the tool
+        let result = '';
+        if (toolName === 'bash') {
+          result = await recoder.handleBashCommand(args);
+        } else if (toolName === 'str_replace_editor') {
+          result = await recoder.handleFileOperation(args);
+        } else if (toolName === 'codebase_search') {
+          result = await recoder.handleCodebaseSearch(args);
+        } else if (toolName === 'web_fetch') {
+          result = await recoder.handleWebFetch(args);
+        }
+
+        toolResults.push({ tool: toolName, args, result });
+
+        // Remove the tool call from clean text
+        cleanText = cleanText.replace(match[0], '');
+      } catch (error) {
+        console.log(chalk.yellow(`  ⚠ Tool ${toolName} failed: ${error.message}`));
+      }
+    }
+
+    // Clean up tool markers
+    cleanText = cleanText.replace(/<｜tool▁calls▁begin｜>/g, '');
+    cleanText = cleanText.replace(/<｜tool▁calls▁end｜>/g, '');
+    cleanText = cleanText.trim();
+
+    return { toolResults, cleanText };
+  }
+
   displayWelcome() {
     console.clear();
-    
-    // Enhanced welcome screen with gradient effects and animations
-    console.log('');
-    
-    // Animated gradient border
-    this.displayAnimatedBorder();
-    
-    // Beautiful gradient ASCII art
-    console.log('');
-    this.displayGradientLogo();
+
+    const projectName = this.getCurrentProjectContext().name;
+    const modelName = this.model || 'deepseek/deepseek-chat-v3.1:free';
+
+    // Simple, clean header like Claude Code
     console.log('');
-    
-    // Dynamic status information
-    this.displayDynamicStatus();
+    console.log(chalk.cyan.bold('  Recoder Code') + chalk.dim(` v${require('../package.json').version}`));
+    console.log(chalk.dim(`  ${modelName}`));
+    console.log(chalk.dim(`  ${process.cwd()}`));
     console.log('');
-    
-    // Enhanced status hints with themes
-    this.showEnhancedStatusHints();
-    
+
     this.rl.prompt();
   }
 
@@ -4113,6 +4177,7 @@ ${projectInfo}`
   
   async processWithAdvancedStreaming({ recoder, input, startTime, streamBuffer, onFirstChunk, onChunk }) {
     try {
+      console.log(chalk.gray('[DEBUG] Starting API call...'));
       // Attempt streaming first
       const response = await recoder.processConversation(input, false, true, {
         onChunk: (chunk) => {
@@ -4122,19 +4187,23 @@ ${projectInfo}`
             streamBuffer.streamingStarted = true;
             onFirstChunk(Date.now());
           }
-          
+
           streamBuffer.content += chunk;
           streamBuffer.chunks.push(chunk);
           streamBuffer.isStreaming = true;
           onChunk(chunk);
         }
       });
-      
-      return response || streamBuffer.content;
-      
+
+      // If streaming was used, return the accumulated content
+      // Otherwise return the response (which is the final message content)
+      return streamBuffer.streamingStarted ? streamBuffer.content : response;
+
     } catch (error) {
       // Fallback to non-streaming
       this.stopProgressiveLoading();
+      console.log(chalk.red('\n❌ Streaming failed:', error.message));
+      console.log(chalk.yellow('Trying non-streaming mode...'));
       return await recoder.processConversation(input, false, false, null);
     }
   }

package/cli/run.js

@@ -92,10 +92,11 @@ class RecoderCode {
         console.log(chalk.white('  recoder-code --setup\n'));
         process.exit(1);
       }
-      return; // Return early to allow interactive mode to handle
+      // Don't return early - initialize with empty key and it will be set later
+      this.apiKey = process.env.OPENROUTER_API_KEY || '';
     }
 
-    // Initialize OpenAI client with OpenRouter configuration
+    // Always initialize OpenAI client (will use apiKey from config or empty string)
     this.openai = new OpenAI({
       baseURL: config.baseURL,
       apiKey: this.apiKey,
@@ -265,7 +266,7 @@ class RecoderCode {
     }
   }
 
-  async callOpenRouter(messages, tools = null, useAutoRouter = false, streamResponse = false) {
+  async callOpenRouter(messages, tools = null, useAutoRouter = false, streamResponse = false, onChunkCallback = null) {
     const payload = {
       model: useAutoRouter ? 'openrouter/auto' : this.model,
       messages: messages,
@@ -301,13 +302,15 @@ class RecoderCode {
     if (tools) {
       payload.tools = tools;
       payload.tool_choice = 'auto';
+      // Disable streaming when tools are used
+      payload.stream = false;
     }
 
     try {
       if (process.env.RECODER_DEBUG === 'true') {
         console.log(`🔄 Using model: ${payload.model} ${payload.models ? `with fallbacks: ${payload.models.slice(1).join(', ')}` : ''}`);
       }
-      
+
       if (streamResponse && !tools) {
         // Handle streaming response
         const stream = await this.openai.chat.completions.create(payload);
@@ -320,14 +323,19 @@ class RecoderCode {
             if (process.env.RECODER_DEBUG === 'true') {
               console.log('\nDEBUG - Chunk:', JSON.stringify(chunk, null, 2));
             }
-            
+
             if (chunk.choices && chunk.choices.length > 0 && chunk.choices[0]) {
               const content = chunk.choices[0]?.delta?.content || '';
               if (content) {
-                process.stdout.write(content);
+                // Call the callback if provided, otherwise write to stdout
+                if (onChunkCallback) {
+                  onChunkCallback(content);
+                } else {
+                  process.stdout.write(content);
+                }
                 fullContent += content;
               }
-              
+
               // Store the full response structure from the last chunk
               if (chunk.choices[0]?.finish_reason) {
                 fullResponse = {
@@ -352,7 +360,7 @@ class RecoderCode {
           this.logRequest(payload, response);
           return response;
         }
-        
+
         // If no response was captured from streaming, create a basic one
         if (!fullResponse) {
           fullResponse = {
@@ -367,8 +375,10 @@ class RecoderCode {
             usage: null
           };
         }
-        
-        console.log('\n'); // Add newline after streaming
+
+        if (!onChunkCallback) {
+          console.log('\n'); // Add newline after streaming only if we wrote to stdout
+        }
         this.logRequest(payload, fullResponse);
         return fullResponse;
       } else {
@@ -385,7 +395,23 @@ class RecoderCode {
       }
     } catch (error) {
       this.logRequest(payload, null, error);
-      
+
+      // Show detailed error message to help user debug
+      console.log(chalk.red('\n❌ API Request Failed in callOpenRouter:'));
+
+      // Check for authentication errors specifically
+      if (error.status === 401 || error.message?.includes('401')) {
+        console.log(chalk.red('   Authentication failed - Invalid API key'));
+        console.log(chalk.yellow('   Please check your OPENROUTER_API_KEY'));
+      } else if (error.status === 402) {
+        console.log(chalk.red('   Insufficient credits'));
+        console.log(chalk.yellow('   Please add credits to your OpenRouter account'));
+      } else {
+        console.log(chalk.yellow('   Status:', error.status || 'N/A'));
+        console.log(chalk.yellow('   Message:', error.message || 'N/A'));
+        console.log(chalk.yellow('   Code:', error.code || 'N/A'));
+      }
+
       // Let unified error handler manage the error instead of re-throwing
       // Return null for graceful degradation
       return null;
@@ -694,7 +720,25 @@ Pending Tasks: ${projectStatus.todos.pending}
 Documentation: Plan=${projectStatus.files.plan ? '✓' : '✗'} Architecture=${projectStatus.files.architecture ? '✓' : '✗'} Notes=${projectStatus.files.notes ? '✓' : '✗'}`;
   }
 
-  async processConversation(userMessage, useAutoRouter = false, enableStreaming = false, resumeSession = null) {
+  async processConversation(userMessage, useAutoRouter = false, enableStreaming = false, streamingOptions = null) {
+    // streamingOptions can be:
+    // - null/false: regular resumeSession string for backward compatibility
+    // - object with { onChunk: callback }: streaming with callback
+    // - true: enable streaming without callback
+
+    let resumeSession = null;
+    let onChunkCallback = null;
+
+    if (streamingOptions) {
+      if (typeof streamingOptions === 'object' && streamingOptions.onChunk) {
+        // New streaming mode with callback
+        onChunkCallback = streamingOptions.onChunk;
+      } else if (typeof streamingOptions === 'string') {
+        // Backward compatibility: string is resumeSession
+        resumeSession = streamingOptions;
+      }
+    }
+
     // If resuming a session, restore conversation history
     if (resumeSession) {
       const session = this.projectManager.loadSession(resumeSession);
@@ -702,9 +746,8 @@ Documentation: Plan=${projectStatus.files.plan ? '✓' : '✗'} Architecture=${p
         this.conversationHistory = [...session.conversationHistory];
         console.log(chalk.cyan(`🔄 Resumed session: ${resumeSession}`));
         console.log(chalk.gray(`   Previous messages: ${this.conversationHistory.length}`));
-      } else {
-        console.log(chalk.yellow(`⚠️  Could not resume session: ${resumeSession}`));
       }
+      // Silently ignore session resume failures - don't warn users
     }
 
     // Check if this is a slash command
@@ -815,12 +858,11 @@ Project context: ${this.getProjectContextString()}${this.getRulesContextString()
 
     const messages = [systemMessage, ...this.conversationHistory];
 
-    let response = await this.callOpenRouter(messages, config.tools, useAutoRouter, enableStreaming);
-    
+    let response = await this.callOpenRouter(messages, config.tools, useAutoRouter, enableStreaming, onChunkCallback);
+
     // Add safety checks for response structure
     if (!response || !response.choices || !response.choices[0]) {
-      // API error already handled by unified error handler, provide graceful fallback
-      return 'Unable to process request - API service unavailable. Please check your API key and credits.';
+      return 'Unable to process request. Please check your API key and try again.';
     }
     
     while (response.choices[0].message && response.choices[0].message.tool_calls) {
@@ -838,7 +880,7 @@ Project context: ${this.getProjectContextString()}${this.getRulesContextString()
       }
 
       // Don't stream when there are tool calls, as we need to process them
-      response = await this.callOpenRouter([systemMessage, ...this.conversationHistory], null, useAutoRouter, false);
+      response = await this.callOpenRouter([systemMessage, ...this.conversationHistory], null, useAutoRouter, false, null);
       
       // Add safety check again
       if (!response || !response.choices || !response.choices[0]) {

package/cli/user-onboarding.js

@@ -237,9 +237,26 @@ class UserOnboarding {
    */
   async runOnboarding() {
     this.showWelcome();
-    
+
     const userName = await this.getUserName();
-    const apiKey = await this.getApiKey();
+
+    // Check if API key already exists in .env file
+    const envFile = path.join(require('os').homedir(), '.recoder-code', '.env');
+    let apiKey = null;
+
+    if (fs.existsSync(envFile)) {
+      const envContent = fs.readFileSync(envFile, 'utf8');
+      const match = envContent.match(/OPENROUTER_API_KEY=(.+)/);
+      if (match && match[1] && match[1].startsWith('sk-or-v1-')) {
+        apiKey = match[1].trim();
+        console.log(chalk.green('\n✅ Found existing API key in .env file'));
+        console.log(chalk.gray('   Using: ' + apiKey.substring(0, 20) + '...'));
+      }
+    }
+
+    if (!apiKey) {
+      apiKey = await this.getApiKey();
+    }
     
     if (!apiKey) {
       console.log(chalk.red('\n❌ API key is required to use Recoder Code.'));

package/config.js

@@ -6,12 +6,13 @@ const fs = require('fs');
 const userEnvPath = path.join(os.homedir(), '.recoder-code', '.env');
 const projectEnvPath = path.join(process.cwd(), '.env');
 
+// Suppress dotenv logs with quiet option
 if (fs.existsSync(userEnvPath)) {
-  require('dotenv').config({ path: userEnvPath });
+  require('dotenv').config({ path: userEnvPath, override: false, quiet: true });
 } else if (fs.existsSync(projectEnvPath)) {
-  require('dotenv').config({ path: projectEnvPath });
+  require('dotenv').config({ path: projectEnvPath, override: false, quiet: true });
 } else {
-  require('dotenv').config();
+  require('dotenv').config({ override: false, quiet: true });
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recoder-code",
-  "version": "2.2.9",
+  "version": "2.3.4",
   "description": "🚀 AI-powered development platform - Chat with 32+ models, build projects, automate workflows. Free models included!",
   "main": "index.js",
   "scripts": {
@@ -34,7 +34,7 @@
     "production:check": "npm run lint && npm run typecheck && npm run security:audit",
     "production:bundle": "npm run production:check && npm run build:production",
     "production:deploy": "npm run production:bundle && npm publish --access public",
-    "postinstall": "node -e \"console.log('\\\\n🚀 Recoder-Code v2.2.9 installed!\\\\n\\\\n✅ Quick Start: recoder-code\\\\n💡 Get API key: https://openrouter.ai\\\\n')\"",
+    "postinstall": "node -e \"console.log('\\\\n🚀 Recoder-Code v2.3.3 installed!\\\\n\\\\n✅ Quick Start: recoder-code\\\\n💡 Get API key: https://openrouter.ai\\\\n')\"",
     "prepare": "echo 'Package prepared for distribution'",
     "prepublishOnly": "npm run prepare && npm run security:audit"
   },