recoder-code 2.2.0 → 2.2.2

package/cli/unified-error-handler.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+/**
+ * Unified Error Handler for Recoder Code
+ * Coordinates all error handling to prevent conflicts
+ */
+class UnifiedErrorHandler {
+  constructor() {
+    this.isInitialized = false;
+    this.errorHandlers = new Map();
+    this.errorStats = {
+      api: 0,
+      mcp: 0,
+      network: 0,
+      general: 0
+    };
+    this.suppressedErrors = new Set([
+      'ENOTFOUND your-resource.openai.azure.com', // Expected MCP connection failure
+      'ECONNREFUSED', // Expected for localhost services
+      'socket hang up', // Expected for unavailable services
+      'EMFILE: too many open files', // File watcher resource exhaustion
+      'spawn EBADF' // Process spawn errors for unavailable tools
+    ]);
+  }
+
+  /**
+   * Initialize unified error handling (call once)
+   */
+  initialize() {
+    if (this.isInitialized) return;
+
+    // Remove any existing handlers to prevent conflicts
+    process.removeAllListeners('unhandledRejection');
+    process.removeAllListeners('uncaughtException');
+
+    // Set up unified handlers
+    process.on('unhandledRejection', (reason, promise) => {
+      this.handleUnhandledRejection(reason, promise);
+    });
+
+    process.on('uncaughtException', (error) => {
+      this.handleUncaughtException(error);
+    });
+
+    this.isInitialized = true;
+    console.log(chalk.gray('🛡️  Unified error handler initialized'));
+  }
+
+  /**
+   * Register a specific error handler for a domain
+   */
+  registerHandler(domain, handler) {
+    this.errorHandlers.set(domain, handler);
+  }
+
+  /**
+   * Handle unhandled promise rejections
+   */
+  handleUnhandledRejection(reason, promise) {
+    const errorInfo = this.analyzeError(reason);
+    
+    // Try domain-specific handlers first
+    if (this.tryDomainHandler(errorInfo.domain, reason)) {
+      return;
+    }
+
+    // Handle based on error type
+    switch (errorInfo.type) {
+      case 'api':
+        this.handleAPIError(reason);
+        break;
+      case 'mcp':
+        this.handleMCPError(reason);
+        break;
+      case 'network':
+        this.handleNetworkError(reason);
+        break;
+      default:
+        this.handleGenericError(reason, 'unhandled_rejection');
+    }
+  }
+
+  /**
+   * Handle uncaught exceptions
+   */
+  handleUncaughtException(error) {
+    const errorInfo = this.analyzeError(error);
+    
+    // Try domain-specific handlers first
+    if (this.tryDomainHandler(errorInfo.domain, error)) {
+      return;
+    }
+
+    // Log critical error
+    console.error(chalk.red('🚨 Critical Error:'), error.message);
+    if (process.env.RECODER_DEBUG === 'true') {
+      console.error(error.stack);
+    }
+    
+    // Don't exit process - maintain availability
+    this.errorStats.general++;
+  }
+
+  /**
+   * Analyze error to determine type and handling strategy
+   */
+  analyzeError(error) {
+    const message = error?.message || error?.toString() || '';
+    const code = error?.code || '';
+    const status = error?.response?.status || error?.status;
+
+    // API errors
+    if (status || message.includes('credits') || message.includes('OpenRouter')) {
+      return { type: 'api', domain: 'openrouter', severity: 'medium' };
+    }
+
+    // MCP connection errors
+    if (message.includes('your-resource.openai.azure.com') || 
+        message.includes('localhost:8080') ||
+        code === 'ENOTFOUND' || 
+        code === 'ECONNREFUSED' ||
+        message.includes('socket hang up')) {
+      return { type: 'mcp', domain: 'mcp', severity: 'low' };
+    }
+
+    // Network errors
+    if (code === 'ENOTFOUND' || code === 'ECONNREFUSED' || message.includes('network')) {
+      return { type: 'network', domain: 'network', severity: 'medium' };
+    }
+
+    return { type: 'generic', domain: 'general', severity: 'high' };
+  }
+
+  /**
+   * Try domain-specific handler
+   */
+  tryDomainHandler(domain, error) {
+    const handler = this.errorHandlers.get(domain);
+    if (handler) {
+      try {
+        handler(error);
+        return true;
+      } catch (handlerError) {
+        console.log(chalk.yellow(`⚠️  Error handler for ${domain} failed:`, handlerError.message));
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Handle API errors (402, 401, etc.)
+   */
+  handleAPIError(error) {
+    const status = error?.response?.status || error?.status;
+    
+    if (status) {
+      switch (status) {
+        case 401:
+          console.error(chalk.red('🔑 Authentication failed - check your API key'));
+          break;
+        case 402:
+          console.error(chalk.yellow('💳 Insufficient credits - add credits to your account'));
+          break;
+        case 429:
+          console.error(chalk.yellow('⏱️  Rate limited - please wait before trying again'));
+          break;
+        default:
+          console.error(chalk.red(`🌐 API Error (${status}):`, error.message));
+      }
+    } else {
+      console.error(chalk.red('🌐 API Error:'), error.message);
+    }
+    
+    this.errorStats.api++;
+  }
+
+  /**
+   * Handle MCP connection errors (graceful degradation)
+   */
+  handleMCPError(error) {
+    const message = error?.message || error?.toString();
+    
+    // Check if this is a suppressed (expected) error
+    if (this.suppressedErrors.has(message) || 
+        this.suppressedErrors.some(suppressed => message.includes(suppressed))) {
+      // Silently track but don't display
+      this.errorStats.mcp++;
+      return;
+    }
+
+    // Log non-critical MCP errors quietly
+    if (process.env.RECODER_DEBUG === 'true') {
+      console.log(chalk.gray('🔌 MCP service unavailable:'), message);
+    }
+    
+    this.errorStats.mcp++;
+  }
+
+  /**
+   * Handle network errors
+   */
+  handleNetworkError(error) {
+    const message = error?.message || error?.toString();
+    
+    // Check if this is a suppressed error first
+    if (this.suppressedErrors.has(message) || 
+        this.suppressedErrors.some(suppressed => message.includes(suppressed))) {
+      this.errorStats.network++;
+      return; // Silently handle
+    }
+
+    console.log(chalk.yellow('🌐 Network issue detected - some features may be limited'));
+    if (process.env.RECODER_DEBUG === 'true') {
+      console.log(chalk.gray('Details:'), error.message);
+    }
+    this.errorStats.network++;
+  }
+
+  /**
+   * Handle generic errors
+   */
+  handleGenericError(error, type = 'generic') {
+    console.error(chalk.red('⚠️  Error:'), error?.message || error);
+    if (process.env.RECODER_DEBUG === 'true' && error?.stack) {
+      console.error(chalk.gray('Stack:'), error.stack);
+    }
+    this.errorStats.general++;
+  }
+
+  /**
+   * Get error statistics
+   */
+  getStats() {
+    return { ...this.errorStats };
+  }
+
+  /**
+   * Reset error statistics
+   */
+  resetStats() {
+    this.errorStats = { api: 0, mcp: 0, network: 0, general: 0 };
+  }
+
+  /**
+   * Check if system is healthy (low error rates)
+   */
+  isHealthy() {
+    const total = Object.values(this.errorStats).reduce((a, b) => a + b, 0);
+    return total < 10 && this.errorStats.general < 3;
+  }
+}
+
+// Global singleton instance
+const unifiedErrorHandler = new UnifiedErrorHandler();
+
+module.exports = UnifiedErrorHandler;
+module.exports.instance = unifiedErrorHandler;

package/cli/user-experience.js

@@ -7,7 +7,9 @@
 
 const { Command } = require('commander');
 const inquirer = require('inquirer');
-const chalk = require('chalk');
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
 const axios = require('axios');
 const fs = require('fs');
 const path = require('path');

package/cli/user-onboarding.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+/**
+ * User Onboarding for Recoder Code
+ * Handles first-time user setup with proper welcome flow
+ */
+class UserOnboarding {
+  constructor() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    this.configDir = path.join(require('os').homedir(), '.recoder-code');
+    this.configFile = path.join(this.configDir, 'config.json');
+    this.defaultConfig = {
+      apiKey: '',
+      model: 'deepseek/deepseek-chat-v3.1:free',
+      userName: '',
+      setupCompleted: false,
+      firstRun: true
+    };
+  }
+
+  /**
+   * Show ASCII logo and welcome message
+   */
+  showWelcome() {
+    console.clear();
+    console.log(chalk.cyan(`
+██████╗ ███████╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗ 
+██╔══██╗██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗
+██████╔╝█████╗  ██║     ██║   ██║██║  ██║█████╗  ██████╔╝
+██╔══██╗██╔══╝  ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗
+██║  ██║███████╗╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║
+╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝
+                                                           
+    `));
+    
+    console.log(chalk.white.bold('Welcome to Recoder Code v2.2.2'));
+    console.log(chalk.gray('Your AI-powered development companion\n'));
+  }
+
+  /**
+   * Check if user needs onboarding
+   */
+  needsOnboarding() {
+    if (!fs.existsSync(this.configFile)) {
+      return true;
+    }
+    
+    try {
+      const config = JSON.parse(fs.readFileSync(this.configFile, 'utf8'));
+      return !config.setupCompleted || !config.apiKey;
+    } catch (error) {
+      return true;
+    }
+  }
+
+  /**
+   * Get user's name
+   */
+  async getUserName() {
+    return new Promise((resolve) => {
+      this.rl.question(chalk.cyan('👋 What\'s your name? '), (name) => {
+        resolve(name.trim() || 'Developer');
+      });
+    });
+  }
+
+  /**
+   * Get API key from user
+   */
+  async getApiKey() {
+    console.log(chalk.yellow('\n🔑 API Key Setup'));
+    console.log(chalk.white('To use Recoder Code, you need an API key from OpenRouter.'));
+    console.log(chalk.gray('💡 Get your free API key at: https://openrouter.ai/keys\n'));
+    
+    return new Promise((resolve) => {
+      this.rl.question(chalk.cyan('Enter your OpenRouter API key: '), (apiKey) => {
+        resolve(apiKey.trim());
+      });
+    });
+  }
+
+  /**
+   * Show model selection
+   */
+  async selectModel() {
+    console.log(chalk.yellow('\n🤖 Model Selection'));
+    console.log(chalk.white('Choose your preferred AI model:'));
+    console.log(chalk.gray('1. DeepSeek Chat v3.1 (Free) - Recommended for most users'));
+    console.log(chalk.gray('2. Claude 3.5 Sonnet - Advanced reasoning and coding'));
+    console.log(chalk.gray('3. GPT-4 Turbo - OpenAI\'s latest model'));
+    console.log(chalk.gray('4. Custom model - Enter your own model name\n'));
+    
+    return new Promise((resolve) => {
+      this.rl.question(chalk.cyan('Select option (1-4) [1]: '), (choice) => {
+        switch (choice.trim() || '1') {
+          case '1':
+            resolve('deepseek/deepseek-chat-v3.1:free');
+            break;
+          case '2':
+            resolve('anthropic/claude-3.5-sonnet');
+            break;
+          case '3':
+            resolve('openai/gpt-4-turbo');
+            break;
+          case '4':
+            this.rl.question(chalk.cyan('Enter custom model name: '), (customModel) => {
+              resolve(customModel.trim() || 'deepseek/deepseek-chat-v3.1:free');
+            });
+            break;
+          default:
+            resolve('deepseek/deepseek-chat-v3.1:free');
+        }
+      });
+    });
+  }
+
+  /**
+   * Save configuration
+   */
+  saveConfig(config) {
+    try {
+      // Create config directory if it doesn't exist
+      if (!fs.existsSync(this.configDir)) {
+        fs.mkdirSync(this.configDir, { recursive: true });
+      }
+
+      // Save configuration
+      fs.writeFileSync(this.configFile, JSON.stringify(config, null, 2));
+      return true;
+    } catch (error) {
+      console.log(chalk.red(`❌ Failed to save configuration: ${error.message}`));
+      return false;
+    }
+  }
+
+  /**
+   * Load existing configuration
+   */
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configFile)) {
+        return JSON.parse(fs.readFileSync(this.configFile, 'utf8'));
+      }
+    } catch (error) {
+      // Return default if config can't be loaded
+    }
+    return { ...this.defaultConfig };
+  }
+
+  /**
+   * Show setup completion
+   */
+  showCompletion(userName, model) {
+    console.log(chalk.green('\n✅ Setup Complete!'));
+    console.log(chalk.white(`Welcome aboard, ${userName}! 🎉`));
+    console.log(chalk.gray(`Model: ${model}`));
+    console.log(chalk.gray('Configuration saved to ~/.recoder-code/config.json\n'));
+    
+    console.log(chalk.cyan('🚀 Quick Start:'));
+    console.log(chalk.white('• Type your questions or requests'));
+    console.log(chalk.white('• Use /help for available commands'));
+    console.log(chalk.white('• Press Ctrl+C to exit anytime\n'));
+  }
+
+  /**
+   * Run complete onboarding flow
+   */
+  async runOnboarding() {
+    this.showWelcome();
+    
+    const userName = await this.getUserName();
+    const apiKey = await this.getApiKey();
+    
+    if (!apiKey) {
+      console.log(chalk.red('\n❌ API key is required to use Recoder Code.'));
+      console.log(chalk.yellow('Get your free key at: https://openrouter.ai/keys'));
+      this.rl.close();
+      process.exit(1);
+    }
+    
+    const model = await this.selectModel();
+    
+    const config = {
+      ...this.defaultConfig,
+      apiKey,
+      model,
+      userName,
+      setupCompleted: true,
+      firstRun: false,
+      setupDate: new Date().toISOString()
+    };
+    
+    if (this.saveConfig(config)) {
+      this.showCompletion(userName, model);
+    } else {
+      console.log(chalk.red('\n❌ Setup failed. Please try again.'));
+      this.rl.close();
+      process.exit(1);
+    }
+    
+    // Set environment variables for immediate use
+    process.env.OPENROUTER_API_KEY = config.apiKey;
+    process.env.OPENROUTER_MODEL = config.model;
+    process.env.RECODER_USER_MODE = 'true'; // Suppress technical messages
+    
+    this.rl.close();
+    return config;
+  }
+
+  /**
+   * Quick start for returning users
+   */
+  async quickStart() {
+    const config = this.loadConfig();
+    
+    if (!config.setupCompleted || !config.apiKey) {
+      return await this.runOnboarding();
+    }
+    
+    // Show welcome for returning users
+    this.showWelcome();
+    console.log(chalk.green(`Welcome back, ${config.userName || 'Developer'}! 👋`));
+    console.log(chalk.gray(`Using model: ${config.model}\n`));
+    
+    // Set environment variables for immediate use
+    process.env.OPENROUTER_API_KEY = config.apiKey;
+    process.env.OPENROUTER_MODEL = config.model;
+    process.env.RECODER_USER_MODE = 'true'; // Suppress technical messages
+    
+    return config;
+  }
+
+  /**
+   * Close readline interface
+   */
+  close() {
+    this.rl.close();
+  }
+}
+
+module.exports = UserOnboarding;

package/cli/vision-analyzer.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;
 
 /**
  * Vision Analysis Engine

package/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Recoder Code - AI Development Platform
- * Main entry point for programmatic usage
+ * Production-ready main entry point for programmatic usage
  * 
  * For CLI usage: Use `recoder-code` command
  * For programmatic usage: require('recoder-code')
@@ -10,6 +10,19 @@
 const path = require('path');
 const config = require('./config.js');
 
+// Handle chalk properly for production
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+// Initialize unified error handling
+const UnifiedErrorHandler = require('./cli/unified-error-handler.js');
+const errorHandler = UnifiedErrorHandler.instance;
+
+// Only initialize in non-test environments
+if (process.env.NODE_ENV !== 'test') {
+  errorHandler.initialize();
+}
+
 // Main RecoderCode class for programmatic usage
 class RecoderCode {
   constructor(options = {}) {
@@ -82,22 +95,81 @@ class RecoderCode {
     const discovery = new ProgressiveDiscovery();
     return discovery.getProgressSummary();
   }
+
+  // Todo management
+  async getTodoManager() {
+    const TodoManager = require('./cli/todo-manager.js');
+    return new TodoManager({ user: this.currentUser || 'developer' });
+  }
+
+  // Production health check
+  async healthCheck() {
+    const checks = {
+      dependencies: false,
+      configuration: false,
+      services: false,
+      todos: false
+    };
+
+    try {
+      // Check dependencies
+      require('chalk');
+      require('openai');
+      checks.dependencies = true;
+    } catch (error) {
+      console.error('Dependency check failed:', error.message);
+    }
+
+    try {
+      // Check configuration
+      const config = require('./config.js');
+      checks.configuration = !!config;
+    } catch (error) {
+      console.error('Configuration check failed:', error.message);
+    }
+
+    try {
+      // Check services
+      const status = await this.getServicesStatus();
+      checks.services = true;
+    } catch (error) {
+      console.error('Services check failed:', error.message);
+    }
+
+    try {
+      // Check todo system
+      const todoManager = await this.getTodoManager();
+      checks.todos = true;
+    } catch (error) {
+      console.error('Todo system check failed:', error.message);
+    }
+
+    return checks;
+  }
 }
 
 // Legacy compatibility - simple OpenAI client function
 async function legacyMain() {
-  const OpenAI = require('openai');
-  
-  const openai = new OpenAI({
-    baseURL: config.apiUrl,
-    apiKey: config.openRouterApiKey,
-    defaultHeaders: {
-      'HTTP-Referer': config.siteUrl || 'https://recoder.xyz',
-      'X-Title': config.siteName || 'Recoder-Code',
-    },
-  });
-
   try {
+    // Check if API key is configured
+    if (!config.openRouterApiKey) {
+      console.log(chalk.yellow('⚠️  No API key configured.'));
+      console.log(chalk.white('To configure: export OPENROUTER_API_KEY="your-key"'));
+      console.log(chalk.white('Or run: recoder-code setup'));
+      return;
+    }
+
+    const OpenAI = require('openai');
+    
+    const openai = new OpenAI({
+      baseURL: config.apiUrl,
+      apiKey: config.openRouterApiKey,
+      defaultHeaders: {
+        'HTTP-Referer': config.siteUrl || 'https://recoder.xyz',
+        'X-Title': config.siteName || 'Recoder-Code',
+      },
+    });
+
     const completion = await openai.chat.completions.create({
       model: config.model || 'deepseek/deepseek-chat',
       messages: [
@@ -110,7 +182,10 @@ async function legacyMain() {
 
     console.log(completion.choices[0].message.content);
   } catch (error) {
-    console.error('API request failed:', error.message);
+    console.error(chalk.red('❌ API request failed:'), error.message);
+    if (error.message.includes('credentials') || error.message.includes('apiKey')) {
+      console.log(chalk.yellow('💡 Tip: Set your API key with: export OPENROUTER_API_KEY="your-key"'));
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recoder-code",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "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": {
@@ -28,6 +28,12 @@
     "security:audit": "npm audit --audit-level moderate",
     "optimize": "node scripts/optimize-package.js",
     "health-check": "node scripts/health-check.js",
+    "todo": "node cli/todo-manager.js",
+    "todo:list": "node cli/todo-manager.js list",
+    "todo:stats": "node cli/todo-manager.js stats",
+    "production:check": "npm run test && 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 installed successfully!\\n\\n✅ Quick Start:\\n  recoder-code\\n\\n💡 If command not found, run setup:\\n  npx recoder-code setup:global\\n\\nOr add npm global bin to PATH manually:\\n  echo \\\"export PATH=\\\\\\\"$(npm config get prefix)/bin:$PATH\\\\\\\"\\\" >> ~/.zshrc\\n  source ~/.zshrc\\n\\n🎉 Then try: recoder-code --help\\n')\"",
     "prepare": "echo 'Package prepared for distribution'",
     "prepublishOnly": "npm run prepare && npm run security:audit"