recoder-code 2.2.1 → 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/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 (skip API key check for interactive mode)
+    // 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');
 

package/cli/slash-commands.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');
 
 /**
@@ -10,10 +12,11 @@ const inquirer = require('inquirer');
  * Flexible AI agent framework for specialized tasks
  */
 class SlashCommandsEngine {
-  constructor(contextEngine, projectManager, visionAnalyzer = null) {
+  constructor(contextEngine, projectManager, visionAnalyzer = null, todoManager = null) {
     this.contextEngine = contextEngine;
     this.projectManager = projectManager;
     this.visionAnalyzer = visionAnalyzer;
+    this.todoManager = todoManager;
     this.commands = new Map();
     this.aliases = new Map();
     this.commandHistory = [];
@@ -186,6 +189,21 @@ class SlashCommandsEngine {
       });
     }
 
+    // Todo Management Commands for Production Use
+    this.registerCommand({
+      name: 'todo',
+      aliases: ['task', 'todos'],
+      description: 'Production-ready todo and task management system',
+      category: 'productivity',
+      agent: this.createTodoAgent(),
+      options: {
+        action: { type: 'string', default: 'list', choices: ['list', 'add', 'complete', 'start', 'delete', 'stats', 'search'] },
+        priority: { type: 'string', default: 'medium', choices: ['low', 'medium', 'high'] },
+        category: { type: 'string', default: 'general' },
+        show_completed: { type: 'boolean', default: true }
+      }
+    });
+
     console.log(chalk.green(`✅ Loaded ${this.commands.size} built-in commands`));
   }
 
@@ -234,7 +252,7 @@ class SlashCommandsEngine {
       const mergedOptions = this.mergeOptions(commandDef.options, args, options);
       
       // Generate context for the command
-      const context = await this.generateCommandContext(commandDef, mergedOptions);
+      const context = await this.generateCommandContext(commandDef, mergedOptions, args);
       
       // Execute the agent
       const result = await commandDef.agent.execute(context, mergedOptions);
@@ -310,14 +328,16 @@ class SlashCommandsEngine {
   /**
    * Generate context for command execution
    */
-  async generateCommandContext(commandDef, options) {
+  async generateCommandContext(commandDef, options, args = []) {
     const context = {
       command: commandDef.name,
       category: commandDef.category,
       options: options,
+      args: args,
       codebase: null,
       relevantFiles: [],
-      projectInfo: null
+      projectInfo: null,
+      todoManager: this.todoManager
     };
 
     // Get codebase context if context engine is available
@@ -1185,6 +1205,106 @@ class SlashCommandsEngine {
     }
   }
 
+  /**
+   * Create Todo Management Agent
+   */
+  createTodoAgent() {
+    return {
+      name: 'TodoAgent',
+      async execute(context, options) {
+        // Get todo manager from interactive instance
+        const todoManager = context.todoManager || new (require('./todo-manager.js'))();
+        
+        switch (options.action) {
+          case 'list':
+            console.log('');
+            todoManager.displayTodos(options.show_completed);
+            break;
+            
+          case 'add':
+            if (!context.args || context.args.length === 0) {
+              console.log(chalk.yellow('⚠️  Usage: /todo add <task description>'));
+              return;
+            }
+            const content = context.args.join(' ');
+            const id = todoManager.addTodo(content, options.priority, options.category);
+            console.log(chalk.green(`✅ Added todo: ${content}`));
+            console.log(chalk.gray(`   ID: ${id}, Priority: ${options.priority}, Category: ${options.category}`));
+            break;
+            
+          case 'complete':
+            if (!context.args || context.args.length === 0) {
+              console.log(chalk.yellow('⚠️  Usage: /todo complete <id>'));
+              return;
+            }
+            if (todoManager.completeTodo(context.args[0])) {
+              console.log(chalk.green('✅ Todo marked as completed'));
+            } else {
+              console.log(chalk.red('❌ Todo not found'));
+            }
+            break;
+            
+          case 'start':
+            if (!context.args || context.args.length === 0) {
+              console.log(chalk.yellow('⚠️  Usage: /todo start <id>'));
+              return;
+            }
+            if (todoManager.startTodo(context.args[0])) {
+              console.log(chalk.yellow('◐ Todo marked as in progress'));
+            } else {
+              console.log(chalk.red('❌ Todo not found'));
+            }
+            break;
+            
+          case 'delete':
+            if (!context.args || context.args.length === 0) {
+              console.log(chalk.yellow('⚠️  Usage: /todo delete <id>'));
+              return;
+            }
+            if (todoManager.deleteTodo(context.args[0])) {
+              console.log(chalk.green('✅ Todo deleted'));
+            } else {
+              console.log(chalk.red('❌ Todo not found'));
+            }
+            break;
+            
+          case 'stats':
+            console.log('');
+            todoManager.displayStats();
+            break;
+            
+          case 'search':
+            if (!context.args || context.args.length === 0) {
+              console.log(chalk.yellow('⚠️  Usage: /todo search <query>'));
+              return;
+            }
+            const query = context.args.join(' ');
+            todoManager.searchTodos(query);
+            break;
+            
+          default:
+            console.log(chalk.cyan.bold('Todo Management System'));
+            console.log('');
+            console.log(chalk.white('Available actions:'));
+            console.log(chalk.gray('  /todo list                 - Show all todos'));
+            console.log(chalk.gray('  /todo add <task>          - Add new todo'));
+            console.log(chalk.gray('  /todo complete <id>       - Mark todo as complete'));
+            console.log(chalk.gray('  /todo start <id>          - Mark todo as in progress'));
+            console.log(chalk.gray('  /todo delete <id>         - Delete todo'));
+            console.log(chalk.gray('  /todo stats               - Show statistics'));
+            console.log(chalk.gray('  /todo search <query>      - Search todos'));
+            break;
+        }
+        
+        return {
+          success: true,
+          action: options.action,
+          timestamp: new Date().toISOString()
+        };
+      }
+    };
+  }
+
   /**
    * Get command suggestions based on context
    */
@@ -1203,6 +1323,13 @@ class SlashCommandsEngine {
       suggestions.push('/review --focus performance');
     }
     
+    // Todo-focused suggestions
+    if (context.query && (context.query.toLowerCase().includes('todo') || context.query.toLowerCase().includes('task'))) {
+      suggestions.push('/todo list');
+      suggestions.push('/todo add <task description>');
+      suggestions.push('/todo stats');
+    }
+    
     return suggestions;
   }
 }