vibecodingmachine-core 1.0.0

package/src/autonomous-mode/feature-implementer.js

@@ -0,0 +1,425 @@
+// @vibecodingmachine/core - Feature Implementer
+// Handles autonomous mode feature implementation and development workflow
+
+import { QuotaDetector } from '../ide-integration/quota-detector.js';
+import { ChatManager } from '../chat-management/chat-manager.js';
+
+/**
+ * Feature Implementer for autonomous development
+ * Manages autonomous mode workflow, quota checking, and feature implementation
+ */
+export class FeatureImplementer {
+  constructor(options = {}) {
+    this.logger = options.logger || console;
+    this.electronAPI = options.electronAPI || null;
+    this.onStatusUpdate = options.onStatusUpdate || (() => {});
+    this.onProgressUpdate = options.onProgressUpdate || (() => {});
+    this.onMessageUpdate = options.onMessageUpdate || (() => {});
+    this.onErrorUpdate = options.onErrorUpdate || (() => {});
+    this.onCompleteUpdate = options.onCompleteUpdate || (() => {});
+
+    // Managers
+    this.quotaDetector = new QuotaDetector();
+    this.chatManager = new ChatManager({
+      logger: this.logger,
+      electronAPI: this.electronAPI,
+      onMessageUpdate: this.onMessageUpdate,
+      onStatusUpdate: this.onStatusUpdate,
+      onProgressUpdate: this.onProgressUpdate
+    });
+
+    // State
+    this.isAutonomousMode = false;
+    this.isPaused = false;
+    this.isStopped = false;
+    this.currentProgress = 0;
+    this.taskCount = 0;
+    this.maxTasks = 10;
+    this.completedFeatures = [];
+    this.errorLog = [];
+  }
+
+  /**
+   * Start autonomous mode with recovery capabilities
+   * @param {string} ide - The IDE to use for autonomous mode
+   * @param {string} tabId - The tab ID for tracking
+   * @returns {Promise<Object>} Result of autonomous mode execution
+   */
+  async startAutonomousMode(ide, tabId) {
+    this.logger.log('🤖 ===== AUTONOMOUS MODE START =====');
+    this.logger.log('🤖 startAutonomousMode called for:', ide);
+
+    this.isAutonomousMode = true;
+    this.isStopped = false;
+    this.currentProgress = 0;
+    this.taskCount = 0;
+    this.completedFeatures = [];
+    this.errorLog = [];
+
+    this.onStatusUpdate(tabId, '🤖 Starting enhanced autonomous mode with backend integration...');
+
+    try {
+      // Check if this is a Windsurf tab for enhanced functionality
+      const isWindsurfTab = ide === 'windsurf';
+      this.logger.log('🤖 Is Windsurf tab:', isWindsurfTab);
+
+      if (isWindsurfTab) {
+        this.onStatusUpdate(tabId, '🚀 Starting Windsurf-specific autonomous development...');
+        this.logger.log('🤖 Windsurf tab detected - using enhanced autonomous mode');
+      } else {
+        this.onStatusUpdate(tabId, '🤖 Starting standard autonomous mode...');
+        this.logger.log('🤖 Standard IDE tab detected - using standard autonomous mode');
+      }
+
+      // Enhanced autonomous mode for Windsurf
+      if (isWindsurfTab) {
+        this.logger.log('🤖 Using enhanced Windsurf autonomous mode...');
+        this.onStatusUpdate(tabId, '🤖 Starting enhanced Windsurf autonomous mode...');
+
+        // Check for quota warning in Windsurf first
+        this.logger.log('🤖 Checking Windsurf quota before starting autonomous mode...');
+        this.onStatusUpdate(tabId, '🤖 Checking Windsurf quota...');
+
+        const quotaCheck = await this.checkQuotaAndSwitch('windsurf');
+
+        if (quotaCheck.switched) {
+          this.logger.log('🤖 ✅ Switched from Windsurf to another IDE due to quota warning');
+          this.onStatusUpdate(tabId, `🤖 Switched to ${quotaCheck.newIde} due to Windsurf quota warning`);
+
+          // Continue with autonomous mode using the new IDE
+          this.logger.log('🤖 Continuing autonomous mode with new IDE...');
+          this.onStatusUpdate(tabId, `🤖 Continuing autonomous mode with ${quotaCheck.newIde}...`);
+
+          // Reset states for the new IDE
+          this.isStopped = false;
+          this.currentProgress = 0;
+
+          // Use the new IDE for autonomous mode
+          const newIde = quotaCheck.newIde;
+          this.logger.log(`🤖 Using ${newIde} for autonomous mode instead of Windsurf`);
+
+          return await this.runAutonomousLoop(newIde, tabId);
+        } else if (quotaCheck.error) {
+          this.logger.log('🤖 ⚠️ Quota check failed:', quotaCheck.error);
+          // Continue with Windsurf even if quota check failed
+        } else {
+          this.logger.log('🤖 ✅ No quota warning in Windsurf, proceeding with Windsurf autonomous mode');
+          this.onStatusUpdate(tabId, '🤖 Windsurf quota OK, starting autonomous mode...');
+        }
+      }
+
+      // Run autonomous loop with the specified IDE
+      return await this.runAutonomousLoop(ide, tabId);
+
+    } catch (error) {
+      this.logger.error('❌ Error starting autonomous mode:', error);
+      this.onErrorUpdate(tabId, `Error starting autonomous mode: ${error.message}`);
+      this.stopAutonomousMode();
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Run the autonomous development loop
+   * @param {string} ide - The IDE to use
+   * @param {string} tabId - The tab ID for tracking
+   * @returns {Promise<Object>} Result of autonomous loop execution
+   */
+  async runAutonomousLoop(ide, tabId) {
+    this.logger.log(`🤖 Starting ${ide} autonomous loop...`);
+
+    // Send initial command to start autonomous development
+    const initialCommand = 'Follow the instructions in the INSTRUCTIONS.md file in the root of the repo. Please implement the features and report progress percentage after each task.';
+
+    let currentProgress = 0;
+    let taskCount = 0;
+
+    this.logger.log('🤖 Initial conditions:', { currentProgress, taskCount, maxTasks: this.maxTasks, isStopped: this.isStopped, isAutonomousMode: this.isAutonomousMode });
+
+    // Main autonomous loop
+    while (currentProgress < 100 && taskCount < this.maxTasks && !this.isStopped && this.isAutonomousMode) {
+      // Check if paused
+      while (this.isPaused && this.isAutonomousMode && !this.isStopped) {
+        this.logger.log('⏸️ Autonomous mode paused, waiting...');
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+
+      // Check if stopped
+      if (this.isStopped || !this.isAutonomousMode) {
+        this.logger.log('🛑 Autonomous mode stopped, exiting...');
+        break;
+      }
+
+      taskCount++;
+      this.taskCount = taskCount;
+      this.onStatusUpdate(tabId, `🤖 Task ${taskCount}: Implementing features (${currentProgress}% complete)...`);
+
+      // Send command and wait for response
+      const commandResult = await this.sendAutonomousCommand(initialCommand, ide, tabId);
+
+      if (commandResult.success) {
+        if (commandResult.progress !== undefined) {
+          currentProgress = commandResult.progress;
+          this.currentProgress = currentProgress;
+          this.onProgressUpdate(currentProgress);
+        }
+
+        if (commandResult.completed) {
+          this.onStatusUpdate(tabId, '🎉 All features implemented! Autonomous development complete!');
+          this.onCompleteUpdate(tabId, true);
+          this.stopAutonomousMode();
+
+          return {
+            success: true,
+            progress: 100,
+            completed: true,
+            taskCount: taskCount
+          };
+        }
+
+        // Wait before next task
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      } else {
+        this.logger.log('❌ Command failed:', commandResult.error);
+        this.onErrorUpdate(tabId, `Task ${taskCount} failed: ${commandResult.error}`);
+
+        // Add to error log
+        this.errorLog.push({
+          task: taskCount,
+          error: commandResult.error,
+          timestamp: Date.now()
+        });
+
+        // Continue with next task
+        await new Promise(resolve => setTimeout(resolve, 3000));
+      }
+    }
+
+    // Check why we exited the loop
+    if (taskCount >= this.maxTasks) {
+      this.onStatusUpdate(tabId, '⚠️ Maximum tasks reached, autonomous mode stopping...');
+    } else if (this.isStopped) {
+      this.onStatusUpdate(tabId, '🛑 Autonomous mode stopped by user');
+    } else if (currentProgress >= 100) {
+      this.onStatusUpdate(tabId, '🎉 100% completion reached!');
+      this.onCompleteUpdate(tabId, true);
+    }
+
+    this.stopAutonomousMode();
+
+    return {
+      success: true,
+      progress: currentProgress,
+      completed: currentProgress >= 100,
+      taskCount: taskCount,
+      errorLog: this.errorLog
+    };
+  }
+
+  /**
+   * Send an autonomous command to an IDE
+   * @param {string} command - The command to send
+   * @param {string} ide - The IDE to send to
+   * @param {string} tabId - The tab ID for tracking
+   * @returns {Promise<Object>} Result of the command execution
+   */
+  async sendAutonomousCommand(command, ide, tabId) {
+    this.logger.log(`🤖 Sending autonomous command: ${command.substring(0, 100)}...`);
+
+    try {
+      // Check for quota warnings before sending command
+      const quotaCheck = await this.checkQuotaAndSwitch(ide);
+
+      if (quotaCheck.switched) {
+        this.logger.log('🤖 Switched from', ide, 'to', quotaCheck.newIde);
+        this.onStatusUpdate(tabId, `🤖 Switched to ${quotaCheck.newIde} due to quota warning`);
+
+        // Send the command to the new IDE instead
+        return await this.sendAutonomousCommand(command, quotaCheck.newIde, tabId);
+      } else if (quotaCheck.error) {
+        this.logger.log('🤖 ⚠️ Quota check failed:', quotaCheck.error);
+        // Continue with sending command even if quota check failed
+      } else {
+        this.logger.log('🤖 ✅ No quota warnings detected, proceeding with command');
+      }
+
+      // Add auto-sent message to chat display
+      this.onMessageUpdate(tabId, {
+        role: 'auto',
+        text: command,
+        timestamp: Date.now()
+      });
+
+      // Send the command using chat manager
+      const sendResult = await this.chatManager.sendMessage(command, ide, tabId);
+
+      if (sendResult && sendResult.success) {
+        this.logger.log('✅ Command sent successfully');
+
+        // Wait for response completion
+        const responseResult = await this.chatManager.detectResponseCompletion(ide, '');
+
+        if (responseResult.completed) {
+          this.logger.log('✅ Response completed successfully');
+
+          // If we're at 100%, don't send another command
+          if (responseResult.progress === 100) {
+            this.logger.log('🎉 100% completion reached - stopping autonomous mode');
+            return { success: true, progress: 100, completed: true };
+          }
+
+          return { success: true, progress: responseResult.progress || 0 };
+        } else {
+          this.logger.log('⚠️ Response detection failed or incomplete');
+          return { success: false, reason: 'response_incomplete' };
+        }
+      } else {
+        this.logger.log('❌ Failed to send command:', sendResult?.error);
+        return { success: false, error: sendResult?.error };
+      }
+    } catch (error) {
+      this.logger.log('❌ Error in autonomous command:', error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Check quota and switch to available IDE if needed
+   * @param {string} ide - The IDE to check
+   * @returns {Promise<Object>} Quota check result
+   */
+  async checkQuotaAndSwitch(ide) {
+    try {
+      this.logger.log(`🔍 Checking quota for ${ide}...`);
+
+      const quotaResult = await this.quotaDetector.detectQuotaWarning(ide);
+
+      if (quotaResult.hasQuotaWarning) {
+        this.logger.log(`❌ Quota warning detected in ${ide}:`, quotaResult.note);
+
+        // Get available IDEs without quota warnings
+        const availableIdes = await this.quotaDetector.getAvailableIdes(['vscode', 'cursor', 'windsurf']);
+
+        // Remove the current IDE from available options
+        const otherIdes = availableIdes.filter(availableIde => availableIde !== ide);
+
+        if (otherIdes.length > 0) {
+          const newIde = otherIdes[0]; // Use the first available IDE
+          this.logger.log(`🔄 Switching from ${ide} to ${newIde} due to quota warning`);
+
+          return {
+            switched: true,
+            newIde: newIde,
+            reason: 'quota_warning',
+            originalIde: ide
+          };
+        } else {
+          this.logger.log('❌ No available IDEs found, cannot switch');
+          return {
+            switched: false,
+            error: 'No available IDEs without quota warnings'
+          };
+        }
+      } else {
+        this.logger.log(`✅ No quota warnings detected in ${ide}`);
+        return {
+          switched: false,
+          ide: ide
+        };
+      }
+    } catch (error) {
+      this.logger.log(`❌ Error checking quota for ${ide}:`, error.message);
+      return {
+        switched: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Stop autonomous mode
+   */
+  stopAutonomousMode() {
+    this.isAutonomousMode = false;
+    this.isStopped = true;
+    this.chatManager.stop();
+    this.logger.log('🛑 Autonomous mode stopped');
+  }
+
+  /**
+   * Pause autonomous mode
+   */
+  pauseAutonomousMode() {
+    this.isPaused = true;
+    this.chatManager.pause();
+    this.logger.log('⏸️ Autonomous mode paused');
+  }
+
+  /**
+   * Resume autonomous mode
+   */
+  resumeAutonomousMode() {
+    this.isPaused = false;
+    this.chatManager.resume();
+    this.logger.log('▶️ Autonomous mode resumed');
+  }
+
+  /**
+   * Get current autonomous mode state
+   * @returns {Object} Current state
+   */
+  getState() {
+    return {
+      isAutonomousMode: this.isAutonomousMode,
+      isPaused: this.isPaused,
+      isStopped: this.isStopped,
+      currentProgress: this.currentProgress,
+      taskCount: this.taskCount,
+      maxTasks: this.maxTasks,
+      completedFeatures: this.completedFeatures,
+      errorLog: this.errorLog
+    };
+  }
+
+  /**
+   * Set electron API for Electron environment
+   * @param {Object} electronAPI - The electron API object
+   */
+  setElectronAPI(electronAPI) {
+    this.electronAPI = electronAPI;
+    this.chatManager.setElectronAPI(electronAPI);
+  }
+
+  /**
+   * Set callback functions
+   * @param {Object} callbacks - Object containing callback functions
+   */
+  setCallbacks(callbacks) {
+    if (callbacks.onStatusUpdate) {
+      this.onStatusUpdate = callbacks.onStatusUpdate;
+    }
+    if (callbacks.onProgressUpdate) {
+      this.onProgressUpdate = callbacks.onProgressUpdate;
+    }
+    if (callbacks.onMessageUpdate) {
+      this.onMessageUpdate = callbacks.onMessageUpdate;
+    }
+    if (callbacks.onErrorUpdate) {
+      this.onErrorUpdate = callbacks.onErrorUpdate;
+    }
+    if (callbacks.onCompleteUpdate) {
+      this.onCompleteUpdate = callbacks.onCompleteUpdate;
+    }
+
+    // Update chat manager callbacks
+    this.chatManager.setCallbacks({
+      onMessageUpdate: this.onMessageUpdate,
+      onStatusUpdate: this.onStatusUpdate,
+      onProgressUpdate: this.onProgressUpdate
+    });
+  }
+}

package/src/chat-management/chat-manager.cjs

@@ -0,0 +1,71 @@
+// @vibecodingmachine/core - Chat Manager (CommonJS) - Stub
+// Handles chat message management, polling, and response detection
+
+class ChatManager {
+  constructor(options = {}) {
+    this.logger = options.logger || console;
+    this.electronAPI = options.electronAPI || null;
+    this.onMessageUpdate = options.onMessageUpdate || (() => {});
+    this.onStatusUpdate = options.onStatusUpdate || (() => {});
+    this.onProgressUpdate = options.onProgressUpdate || (() => {});
+  }
+
+  async sendMessage(message, ide, tabId) {
+    this.logger.log('sendMessage stub called with:', { message: message.substring(0, 50) + '...', ide, tabId });
+    return {
+      success: true,
+      method: 'stub',
+      message: 'Message sent via stub'
+    };
+  }
+
+  startPolling(ide, tabId) {
+    this.logger.log('startPolling stub for:', ide, tabId);
+  }
+
+  stopPolling() {
+    this.logger.log('stopPolling stub');
+  }
+
+  pause() {
+    this.logger.log('pause stub');
+  }
+
+  resume() {
+    this.logger.log('resume stub');
+  }
+
+  stop() {
+    this.logger.log('stop stub');
+  }
+
+  reset() {
+    this.logger.log('reset stub');
+  }
+
+  getState() {
+    return {
+      isPolling: false,
+      isPaused: false,
+      isStopped: false
+    };
+  }
+
+  setElectronAPI(electronAPI) {
+    this.electronAPI = electronAPI;
+  }
+
+  setCallbacks(callbacks) {
+    if (callbacks.onMessageUpdate) {
+      this.onMessageUpdate = callbacks.onMessageUpdate;
+    }
+    if (callbacks.onStatusUpdate) {
+      this.onStatusUpdate = callbacks.onStatusUpdate;
+    }
+    if (callbacks.onProgressUpdate) {
+      this.onProgressUpdate = callbacks.onProgressUpdate;
+    }
+  }
+}
+
+module.exports = { ChatManager };