recoder-code 2.2.0 → 2.2.2

package/cli/logger.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+/**
+ * Production Logger for Recoder Code
+ * Handles different log levels and environments
+ */
+class Logger {
+  constructor(options = {}) {
+    this.logLevel = options.logLevel || process.env.LOG_LEVEL || 'info';
+    this.silent = options.silent || process.env.RECODER_SILENT === 'true';
+    this.logFile = options.logFile || path.join(process.cwd(), 'logs', 'recoder.log');
+    this.enableFileLogging = options.enableFileLogging !== false;
+    
+    // Create logs directory
+    if (this.enableFileLogging) {
+      const logDir = path.dirname(this.logFile);
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+    }
+    
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3
+    };
+  }
+
+  _shouldLog(level) {
+    return this.levels[level] <= this.levels[this.logLevel];
+  }
+
+  _formatMessage(level, message, ...args) {
+    const timestamp = new Date().toISOString();
+    const formattedArgs = args.map(arg => 
+      typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
+    ).join(' ');
+    
+    return {
+      console: this._colorizeMessage(level, message, formattedArgs),
+      file: `[${timestamp}] ${level.toUpperCase()}: ${message} ${formattedArgs}`.trim()
+    };
+  }
+
+  _colorizeMessage(level, message, args) {
+    const fullMessage = `${message} ${args}`.trim();
+    
+    switch (level) {
+      case 'error':
+        return chalk.red(`❌ ${fullMessage}`);
+      case 'warn':
+        return chalk.yellow(`⚠️  ${fullMessage}`);
+      case 'info':
+        return chalk.blue(`ℹ️  ${fullMessage}`);
+      case 'debug':
+        return chalk.gray(`🔍 ${fullMessage}`);
+      default:
+        return fullMessage;
+    }
+  }
+
+  _writeToFile(message) {
+    if (this.enableFileLogging) {
+      try {
+        fs.appendFileSync(this.logFile, message + '\n');
+      } catch (error) {
+        // Fail silently for file logging errors
+      }
+    }
+  }
+
+  error(message, ...args) {
+    if (this._shouldLog('error')) {
+      const formatted = this._formatMessage('error', message, ...args);
+      if (!this.silent) {
+        console.error(formatted.console);
+      }
+      this._writeToFile(formatted.file);
+    }
+  }
+
+  warn(message, ...args) {
+    if (this._shouldLog('warn')) {
+      const formatted = this._formatMessage('warn', message, ...args);
+      if (!this.silent) {
+        console.warn(formatted.console);
+      }
+      this._writeToFile(formatted.file);
+    }
+  }
+
+  info(message, ...args) {
+    if (this._shouldLog('info')) {
+      const formatted = this._formatMessage('info', message, ...args);
+      if (!this.silent) {
+        console.log(formatted.console);
+      }
+      this._writeToFile(formatted.file);
+    }
+  }
+
+  debug(message, ...args) {
+    if (this._shouldLog('debug')) {
+      const formatted = this._formatMessage('debug', message, ...args);
+      if (!this.silent) {
+        console.log(formatted.console);
+      }
+      this._writeToFile(formatted.file);
+    }
+  }
+
+  // Production-safe console.log replacement
+  log(message, ...args) {
+    // In production, treat as info level
+    if (process.env.NODE_ENV === 'production') {
+      this.info(message, ...args);
+    } else {
+      // In development, allow direct logging
+      console.log(message, ...args);
+    }
+  }
+
+  // Success messages for user feedback
+  success(message, ...args) {
+    const formatted = `✅ ${message} ${args.join(' ')}`.trim();
+    if (!this.silent) {
+      console.log(chalk.green(formatted));
+    }
+    this._writeToFile(`[${new Date().toISOString()}] SUCCESS: ${message} ${args.join(' ')}`.trim());
+  }
+
+  // Progress indicators
+  progress(message, ...args) {
+    const formatted = `⏳ ${message} ${args.join(' ')}`.trim();
+    if (!this.silent) {
+      console.log(chalk.cyan(formatted));
+    }
+  }
+
+  // User prompts and interactive messages
+  user(message, ...args) {
+    const formatted = `${message} ${args.join(' ')}`.trim();
+    if (!this.silent) {
+      console.log(formatted);
+    }
+  }
+}
+
+// Global logger instance
+const logger = new Logger();
+
+// Replace console methods in production
+if (process.env.NODE_ENV === 'production') {
+  // Store original methods
+  const originalConsole = {
+    log: console.log,
+    error: console.error,
+    warn: console.warn,
+    info: console.info
+  };
+
+  // Override console methods
+  console.log = (...args) => logger.log(...args);
+  console.error = (...args) => logger.error(...args);
+  console.warn = (...args) => logger.warn(...args);
+  console.info = (...args) => logger.info(...args);
+
+  // Provide way to restore original console
+  console._restore = () => {
+    Object.assign(console, originalConsole);
+  };
+}
+
+module.exports = Logger;
+module.exports.logger = logger;

package/cli/mcp-client.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 EventEmitter = require('events');
 const WebSocket = require('ws');
 
@@ -47,6 +49,13 @@ class MCPClient extends EventEmitter {
   /**
    * Initialize MCP client
    */
+  async initialize() {
+    return this.initializeMCP();
+  }
+
+  /**
+   * Initialize MCP client implementation
+   */
   async initializeMCP() {
     console.log(chalk.cyan('🔌 Initializing MCP Client...'));
     
@@ -213,24 +222,38 @@ class MCPClient extends EventEmitter {
         });
         
         ws.on('error', (error) => {
-          console.log(chalk.red(`❌ Connection error for ${serverName}: ${error.message}`));
+          // Gracefully handle connection errors - these are expected for external services
           this.connectionStates.set(serverName, 'error');
-          reject(error);
+          
+          // Only log in debug mode
+          if (process.env.RECODER_DEBUG === 'true') {
+            console.log(chalk.gray(`🔌 MCP service ${serverName} unavailable: ${error.message}`));
+          }
+          
+          // Resolve with null instead of rejecting to allow graceful degradation
+          resolve(null);
         });
         
         ws.on('close', () => {
-          console.log(chalk.yellow(`⚠️  Connection closed for ${serverName}`));
+          // Gracefully handle connection close
           this.connectionStates.set(serverName, 'disconnected');
           this.connections.delete(serverName);
           
-          // Attempt reconnection
-          setTimeout(() => {
-            this.reconnectToServer(serverName);
-          }, 5000);
+          // Only log in debug mode
+          if (process.env.RECODER_DEBUG === 'true') {
+            console.log(chalk.gray(`🔌 MCP connection to ${serverName} closed`));
+          }
+          
+          // Don't attempt automatic reconnection to avoid spam
         });
         
       } catch (error) {
-        reject(error);
+        // Gracefully handle any connection setup errors
+        this.connectionStates.set(serverName, 'error');
+        if (process.env.RECODER_DEBUG === 'true') {
+          console.log(chalk.gray(`🔌 MCP setup failed for ${serverName}: ${error.message}`));
+        }
+        resolve(null);
       }
     });
   }

package/cli/ml-training-manager.js

@@ -7,7 +7,9 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const chalk = require('chalk');
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;;
 const crypto = require('crypto');
 const EventEmitter = require('events');
 

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/natural-language-processor.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;
 
 /**
  * Natural Language Processor

package/cli/project-manager.js

@@ -3,7 +3,9 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const chalk = require('chalk');
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
 
 class ProjectManager {
   constructor() {

package/cli/rules-engine.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;
 
 /**
  * User & Repository Rules Engine
@@ -411,9 +413,12 @@ class RulesEngine {
   getProjectLanguages() {
     // Try to get from project context
     if (this.projectManager) {
-      const context = this.projectManager.getProjectContext();
-      if (context && context.language) {
-        return [context.language];
+      // Fallback for missing getProjectContext method
+      if (this.projectManager && typeof this.projectManager.getProjectContext === 'function') {
+        const context = this.projectManager.getProjectContext();
+        if (context && context.language) {
+          return [context.language];
+        }
       }
     }
     

package/cli/run.js

@@ -28,6 +28,11 @@ const ScriptsManager = require('./scripts-manager.js');
 const GitHubManager = require('./github-manager.js');
 const WorkspaceManager = require('./workspace-manager.js');
 
+// Initialize unified error handling
+const UnifiedErrorHandler = require('./unified-error-handler.js');
+const errorHandler = UnifiedErrorHandler.instance;
+errorHandler.initialize();
+
 const execAsync = promisify(exec);
 
 // Create logs directory if it doesn't exist
@@ -92,22 +97,72 @@ class RecoderCode {
         'X-Title': config.siteName,
       },
     });
+
+    // Register API error handler with unified error system
+    errorHandler.registerHandler('openrouter', (error) => {
+      this.handleOpenRouterError(error);
+    });
+
+    // Initialize resource cleanup
+    this.systemsInitialized = false;
+    this.setupResourceCleanup();
+  }
+
+  /**
+   * Setup resource cleanup handlers
+   */
+  setupResourceCleanup() {
+    const cleanup = () => {
+      try {
+        // Stop any running services
+        if (this.mcpClient && typeof this.mcpClient.cleanup === 'function') {
+          this.mcpClient.cleanup();
+        }
+        
+        // Clean up file watchers via manager
+        const FileWatcherManager = require('./file-watcher-manager.js');
+        FileWatcherManager.instance.cleanup();
+        
+        // Clean up context engine
+        if (this.contextEngine && typeof this.contextEngine.cleanup === 'function') {
+          this.contextEngine.cleanup();
+        }
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    };
+
+    process.once('exit', cleanup);
+    process.once('SIGINT', cleanup);
+    process.once('SIGTERM', cleanup);
   }
 
   /**
    * Initialize advanced systems with full integration
    */
   async initializeSystems() {
+    // Prevent duplicate initialization
+    if (this.systemsInitialized) {
+      return;
+    }
+    
     try {
-      console.log(chalk.gray('🚀 Initializing enhanced AI CLI systems...'));
+      // Only show technical messages in debug or non-user mode
+      if (process.env.RECODER_DEBUG === 'true' || process.env.RECODER_USER_MODE !== 'true') {
+        console.log(chalk.gray('🚀 Initializing enhanced AI CLI systems...'));
+      }
       
       // Initialize context engine for codebase understanding
-      this.contextEngine = new ContextEngine();
-      await this.contextEngine.initialize();
+      if (!this.contextEngine) {
+        this.contextEngine = new ContextEngine();
+        await this.contextEngine.initialize();
+      }
       
       // Initialize MCP client for model communication
-      this.mcpClient = new MCPClient();
-      await this.mcpClient.initialize();
+      if (!this.mcpClient) {
+        this.mcpClient = new MCPClient();
+        await this.mcpClient.initialize();
+      }
       
       // Initialize model manager with intelligent selection
       this.modelManager = new ModelManager(this.mcpClient, this.contextEngine);
@@ -168,6 +223,9 @@ class RecoderCode {
         });
       }
       
+      // Mark systems as initialized
+      this.systemsInitialized = true;
+      
     } catch (error) {
       console.log(chalk.yellow(`⚠️  System integration setup failed: ${error.message}`));
     }
@@ -316,8 +374,10 @@ class RecoderCode {
       }
     } catch (error) {
       this.logRequest(payload, null, error);
-      this.handleOpenRouterError(error);
-      throw error;
+      
+      // Let unified error handler manage the error instead of re-throwing
+      // Return null for graceful degradation
+      return null;
     }
   }
 
@@ -748,8 +808,8 @@ Project context: ${this.getProjectContextString()}${this.getRulesContextString()
     
     // Add safety checks for response structure
     if (!response || !response.choices || !response.choices[0]) {
-      console.error('Invalid response structure from OpenRouter');
-      return 'Error: Invalid response received from API';
+      // 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.';
     }
     
     while (response.choices[0].message && response.choices[0].message.tool_calls) {
@@ -771,8 +831,8 @@ Project context: ${this.getProjectContextString()}${this.getRulesContextString()
       
       // Add safety check again
       if (!response || !response.choices || !response.choices[0]) {
-        console.error('Invalid response structure from OpenRouter in tool loop');
-        return 'Error: Invalid response received from API during tool execution';
+        // API error already handled by unified error handler, provide graceful fallback
+        return 'Unable to complete tool execution - API service unavailable. Please check your API key and credits.';
       }
     }
 
@@ -1193,7 +1253,19 @@ async function main() {
   }
   
   if (args.length === 0) {
-    // Launch interactive mode when no arguments provided
+    // Launch interactive mode with proper user onboarding
+    const UserOnboarding = require('./user-onboarding.js');
+    const onboarding = new UserOnboarding();
+    
+    if (onboarding.needsOnboarding()) {
+      // First time user - run full onboarding
+      await onboarding.runOnboarding();
+    } else {
+      // Returning user - quick start
+      await onboarding.quickStart();
+    }
+    
+    // Now launch interactive mode
     const InteractiveChat = require('./interactive.js');
     const chat = new InteractiveChat();
     chat.start();
@@ -2267,7 +2339,12 @@ async function main() {
   }
 
   if (!prompt) {
-    console.error('Error: No prompt provided');
+    console.error(chalk.red('❌ Error: No prompt provided'));
+    console.log(chalk.yellow('💡 Usage examples:'));
+    console.log(chalk.white('  recoder-code "Hello, how can you help me?"'));
+    console.log(chalk.white('  recoder-code --help'));
+    console.log(chalk.white('  recoder-code --setup'));
+    console.log(chalk.gray('\nFor interactive mode, run: recoder-code'));
     process.exit(1);
   }
 

package/cli/setup-wizard.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
 const readline = require('readline');
-const chalk = require('chalk');
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;;
 const fs = require('fs');
 const path = require('path');