vibecodingmachine-core 1.0.2 → 2025.11.2-7.1302

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

@@ -1,342 +1,342 @@
-// @vibecodingmachine/core - Chat Manager
-// Handles chat message management, polling, and response detection
-
-/**
- * Chat Manager for handling chat interactions
- * Manages message sending, response polling, and state management
- */
-export 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 || (() => {});
-
-    // State
-    this.isPolling = false;
-    this.isPaused = false;
-    this.isStopped = false;
-    this.responseWaiting = false;
-    this.currentProgress = 0;
-    this.pollingTimer = null;
-    this.lastChangeAt = 0;
-  }
-
-  /**
-   * Send a chat message to an IDE
-   * @param {string} message - The message to send
-   * @param {string} ide - The IDE to send to
-   * @param {string} tabId - The tab ID for tracking
-   * @returns {Promise<Object>} Result of the send operation
-   */
-  async sendMessage(message, ide, tabId) {
-    this.logger.log('sendMessage called with:', { message: message.substring(0, 50) + '...', ide, tabId });
-
-    if (!message || !message.trim() || this.isPaused || this.isStopped) {
-      this.logger.log('sendMessage early return - message:', !!message, 'isPaused:', this.isPaused, 'isStopped:', this.isStopped);
-      return {
-        success: false,
-        error: 'Cannot send message - invalid state or empty message'
-      };
-    }
-
-    try {
-      this.onStatusUpdate(tabId, 'Sending message...');
-
-      let result;
-      if (this.electronAPI && this.electronAPI.sendChat) {
-        result = await this.electronAPI.sendChat(message, ide);
-      } else {
-        // Fallback for non-Electron environments
-        result = { success: true, method: 'simulated', message: 'Simulated message sent' };
-      }
-
-      if (result && result.success) {
-        this.logger.log(`Message sent successfully via ${result.method || 'chat'}`);
-        this.onStatusUpdate(tabId, `✅ Message sent successfully via ${result.method || 'chat'}`);
-
-        if (result.method !== 'terminal') {
-          this.startPolling(ide, tabId);
-        }
-
-        return {
-          success: true,
-          method: result.method,
-          message: result.message
-        };
-      } else {
-        this.logger.log('Failed to send message:', result);
-        this.onStatusUpdate(tabId, `❌ Failed to send message: ${result?.error || 'Unknown error'}`);
-
-        return {
-          success: false,
-          error: result?.error || 'Unknown error'
-        };
-      }
-    } catch (error) {
-      this.logger.error('Error sending message:', error);
-      this.onStatusUpdate(tabId, `❌ Error sending message: ${error.message}`);
-
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Start polling for responses from an IDE
-   * @param {string} ide - The IDE to poll
-   * @param {string} tabId - The tab ID for tracking
-   */
-  startPolling(ide, tabId) {
-    if (this.isPolling) {
-      this.logger.log('Polling already in progress');
-      return;
-    }
-
-    this.isPolling = true;
-    this.lastChangeAt = Date.now();
-
-    this.logger.log(`Starting polling for ${ide} (tab: ${tabId})`);
-    this.onStatusUpdate(tabId, 'Polling for response...');
-
-    this.pollingTimer = setInterval(async () => {
-      if (this.isStopped || this.isPaused) {
-        this.stopPolling();
-        return;
-      }
-
-      try {
-        const response = await this.readResponse(ide);
-
-        if (response && response.length > 0) {
-          this.lastChangeAt = Date.now();
-
-          // Check if response is complete
-          const completionResult = await this.detectResponseCompletion(ide, response);
-
-          if (completionResult.completed) {
-            this.logger.log('Response completed, stopping polling');
-            this.onStatusUpdate(tabId, '✅ Response received');
-            this.stopPolling();
-
-            // Update messages with the complete response
-            this.onMessageUpdate(tabId, {
-              role: 'assistant',
-              text: completionResult.response,
-              timestamp: Date.now(),
-              progress: completionResult.progress || 100
-            });
-          }
-        }
-
-        // Stop polling if no change for 30 seconds
-        if (Date.now() - this.lastChangeAt > 30000) {
-          this.logger.log('No response change for 30 seconds, stopping polling');
-          this.onStatusUpdate(tabId, '⏰ Response timeout');
-          this.stopPolling();
-        }
-      } catch (error) {
-        this.logger.error('Error during polling:', error);
-        this.onStatusUpdate(tabId, `❌ Polling error: ${error.message}`);
-        this.stopPolling();
-      }
-    }, 2000); // Poll every 2 seconds
-  }
-
-  /**
-   * Stop polling for responses
-   */
-  stopPolling() {
-    if (this.pollingTimer) {
-      clearInterval(this.pollingTimer);
-      this.pollingTimer = null;
-    }
-    this.isPolling = false;
-    this.responseWaiting = false;
-    this.logger.log('Polling stopped');
-  }
-
-  /**
-   * Read response from an IDE
-   * @param {string} ide - The IDE to read from
-   * @returns {Promise<string>} The response text
-   */
-  async readResponse(ide) {
-    try {
-      if (this.electronAPI && this.electronAPI.readChat) {
-        return await this.electronAPI.readChat(ide);
-      } else {
-        // Fallback for non-Electron environments
-        return 'Simulated response from ' + ide;
-      }
-    } catch (error) {
-      this.logger.error('Error reading response:', error);
-      return '';
-    }
-  }
-
-  /**
-   * Detect if a response is complete
-   * @param {string} ide - The IDE name
-   * @param {string} response - The current response text
-   * @returns {Promise<Object>} Completion detection result
-   */
-  async detectResponseCompletion(ide, response) {
-    if (ide !== 'windsurf') {
-      // For non-Windsurf IDEs, assume response is complete after a delay
-      return { completed: true, response };
-    }
-
-    this.logger.log('🔍 Detecting Windsurf response completion...');
-    this.responseWaiting = true;
-
-    try {
-      const responseText = response.toLowerCase();
-
-      // Check for ongoing status indicators - if these are present, response is NOT complete
-      const hasOngoingStatus = responseText.includes('surfing') ||
-          responseText.includes('navigating') ||
-          responseText.includes('swimming') ||
-          responseText.includes('floating') ||
-          responseText.includes('proposing code') ||
-          responseText.includes('reading file') ||
-          responseText.includes('searching') ||
-          responseText.includes('updating todo list');
-
-      if (hasOngoingStatus) {
-        this.logger.log('⏳ Response still in progress - waiting for completion...');
-        return { completed: false, response };
-      }
-
-      // Check for completion indicators
-      const hasCompletionIndicators = responseText.includes('thumbs up') ||
-          responseText.includes('thumbs down') ||
-          responseText.includes('👍') ||
-          responseText.includes('👎') ||
-          responseText.includes('copy icon') ||
-          responseText.includes('bookmark icon') ||
-          responseText.includes('bar chart icon') ||
-          responseText.includes('view response summary') ||
-          responseText.includes('ask anything (⌘l)') ||
-          responseText.includes('microphone icon') ||
-          responseText.includes('send button') ||
-          responseText.includes('+ chat') ||
-          responseText.includes('+ chat swe-1') ||
-          responseText.includes('paper plane') ||
-          responseText.includes('send icon') ||
-          responseText.includes('chat swe-1') ||
-          responseText.includes('ask anything') ||
-          responseText.includes('⌘l') ||
-          responseText.includes('command+l');
-
-      if (hasCompletionIndicators) {
-        this.logger.log('🎯 Completion indicators found!');
-        this.responseWaiting = false;
-        return { completed: true, response };
-      }
-
-      // Check for percentage in response
-      const percentageMatch = response.match(/(\d+)%/);
-      if (percentageMatch) {
-        const percentage = parseInt(percentageMatch[1]);
-        this.currentProgress = percentage;
-        this.onProgressUpdate(percentage);
-        this.logger.log(`📊 Progress detected: ${percentage}%`);
-
-        if (percentage === 100) {
-          this.logger.log('🎉 100% completion detected!');
-          this.responseWaiting = false;
-          return { completed: true, response, progress: 100 };
-        }
-      }
-
-      // Response is not complete
-      return { completed: false, response };
-
-    } catch (error) {
-      this.logger.error('Error detecting response completion:', error);
-      this.responseWaiting = false;
-      return { completed: false, response, error: error.message };
-    }
-  }
-
-  /**
-   * Pause chat operations
-   */
-  pause() {
-    this.isPaused = true;
-    this.logger.log('Chat operations paused');
-  }
-
-  /**
-   * Resume chat operations
-   */
-  resume() {
-    this.isPaused = false;
-    this.logger.log('Chat operations resumed');
-  }
-
-  /**
-   * Stop chat operations
-   */
-  stop() {
-    this.isStopped = true;
-    this.stopPolling();
-    this.logger.log('Chat operations stopped');
-  }
-
-  /**
-   * Reset chat state
-   */
-  reset() {
-    this.isStopped = false;
-    this.isPaused = false;
-    this.isPolling = false;
-    this.responseWaiting = false;
-    this.currentProgress = 0;
-    this.stopPolling();
-    this.logger.log('Chat state reset');
-  }
-
-  /**
-   * Get current chat state
-   * @returns {Object} Current chat state
-   */
-  getState() {
-    return {
-      isPolling: this.isPolling,
-      isPaused: this.isPaused,
-      isStopped: this.isStopped,
-      responseWaiting: this.responseWaiting,
-      currentProgress: this.currentProgress,
-      lastChangeAt: this.lastChangeAt
-    };
-  }
-
-  /**
-   * Set electron API for Electron environment
-   * @param {Object} electronAPI - The electron API object
-   */
-  setElectronAPI(electronAPI) {
-    this.electronAPI = electronAPI;
-  }
-
-  /**
-   * Set callback functions
-   * @param {Object} callbacks - Object containing callback functions
-   */
-  setCallbacks(callbacks) {
-    if (callbacks.onMessageUpdate) {
-      this.onMessageUpdate = callbacks.onMessageUpdate;
-    }
-    if (callbacks.onStatusUpdate) {
-      this.onStatusUpdate = callbacks.onStatusUpdate;
-    }
-    if (callbacks.onProgressUpdate) {
-      this.onProgressUpdate = callbacks.onProgressUpdate;
-    }
-  }
-}
+// @vibecodingmachine/core - Chat Manager
+// Handles chat message management, polling, and response detection
+
+/**
+ * Chat Manager for handling chat interactions
+ * Manages message sending, response polling, and state management
+ */
+export 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 || (() => {});
+
+    // State
+    this.isPolling = false;
+    this.isPaused = false;
+    this.isStopped = false;
+    this.responseWaiting = false;
+    this.currentProgress = 0;
+    this.pollingTimer = null;
+    this.lastChangeAt = 0;
+  }
+
+  /**
+   * Send a chat message to an IDE
+   * @param {string} message - The message to send
+   * @param {string} ide - The IDE to send to
+   * @param {string} tabId - The tab ID for tracking
+   * @returns {Promise<Object>} Result of the send operation
+   */
+  async sendMessage(message, ide, tabId) {
+    this.logger.log('sendMessage called with:', { message: message.substring(0, 50) + '...', ide, tabId });
+
+    if (!message || !message.trim() || this.isPaused || this.isStopped) {
+      this.logger.log('sendMessage early return - message:', !!message, 'isPaused:', this.isPaused, 'isStopped:', this.isStopped);
+      return {
+        success: false,
+        error: 'Cannot send message - invalid state or empty message'
+      };
+    }
+
+    try {
+      this.onStatusUpdate(tabId, 'Sending message...');
+
+      let result;
+      if (this.electronAPI && this.electronAPI.sendChat) {
+        result = await this.electronAPI.sendChat(message, ide);
+      } else {
+        // Fallback for non-Electron environments
+        result = { success: true, method: 'simulated', message: 'Simulated message sent' };
+      }
+
+      if (result && result.success) {
+        this.logger.log(`Message sent successfully via ${result.method || 'chat'}`);
+        this.onStatusUpdate(tabId, `✅ Message sent successfully via ${result.method || 'chat'}`);
+
+        if (result.method !== 'terminal') {
+          this.startPolling(ide, tabId);
+        }
+
+        return {
+          success: true,
+          method: result.method,
+          message: result.message
+        };
+      } else {
+        this.logger.log('Failed to send message:', result);
+        this.onStatusUpdate(tabId, `❌ Failed to send message: ${result?.error || 'Unknown error'}`);
+
+        return {
+          success: false,
+          error: result?.error || 'Unknown error'
+        };
+      }
+    } catch (error) {
+      this.logger.error('Error sending message:', error);
+      this.onStatusUpdate(tabId, `❌ Error sending message: ${error.message}`);
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Start polling for responses from an IDE
+   * @param {string} ide - The IDE to poll
+   * @param {string} tabId - The tab ID for tracking
+   */
+  startPolling(ide, tabId) {
+    if (this.isPolling) {
+      this.logger.log('Polling already in progress');
+      return;
+    }
+
+    this.isPolling = true;
+    this.lastChangeAt = Date.now();
+
+    this.logger.log(`Starting polling for ${ide} (tab: ${tabId})`);
+    this.onStatusUpdate(tabId, 'Polling for response...');
+
+    this.pollingTimer = setInterval(async () => {
+      if (this.isStopped || this.isPaused) {
+        this.stopPolling();
+        return;
+      }
+
+      try {
+        const response = await this.readResponse(ide);
+
+        if (response && response.length > 0) {
+          this.lastChangeAt = Date.now();
+
+          // Check if response is complete
+          const completionResult = await this.detectResponseCompletion(ide, response);
+
+          if (completionResult.completed) {
+            this.logger.log('Response completed, stopping polling');
+            this.onStatusUpdate(tabId, '✅ Response received');
+            this.stopPolling();
+
+            // Update messages with the complete response
+            this.onMessageUpdate(tabId, {
+              role: 'assistant',
+              text: completionResult.response,
+              timestamp: Date.now(),
+              progress: completionResult.progress || 100
+            });
+          }
+        }
+
+        // Stop polling if no change for 30 seconds
+        if (Date.now() - this.lastChangeAt > 30000) {
+          this.logger.log('No response change for 30 seconds, stopping polling');
+          this.onStatusUpdate(tabId, '⏰ Response timeout');
+          this.stopPolling();
+        }
+      } catch (error) {
+        this.logger.error('Error during polling:', error);
+        this.onStatusUpdate(tabId, `❌ Polling error: ${error.message}`);
+        this.stopPolling();
+      }
+    }, 2000); // Poll every 2 seconds
+  }
+
+  /**
+   * Stop polling for responses
+   */
+  stopPolling() {
+    if (this.pollingTimer) {
+      clearInterval(this.pollingTimer);
+      this.pollingTimer = null;
+    }
+    this.isPolling = false;
+    this.responseWaiting = false;
+    this.logger.log('Polling stopped');
+  }
+
+  /**
+   * Read response from an IDE
+   * @param {string} ide - The IDE to read from
+   * @returns {Promise<string>} The response text
+   */
+  async readResponse(ide) {
+    try {
+      if (this.electronAPI && this.electronAPI.readChat) {
+        return await this.electronAPI.readChat(ide);
+      } else {
+        // Fallback for non-Electron environments
+        return 'Simulated response from ' + ide;
+      }
+    } catch (error) {
+      this.logger.error('Error reading response:', error);
+      return '';
+    }
+  }
+
+  /**
+   * Detect if a response is complete
+   * @param {string} ide - The IDE name
+   * @param {string} response - The current response text
+   * @returns {Promise<Object>} Completion detection result
+   */
+  async detectResponseCompletion(ide, response) {
+    if (ide !== 'windsurf') {
+      // For non-Windsurf IDEs, assume response is complete after a delay
+      return { completed: true, response };
+    }
+
+    this.logger.log('🔍 Detecting Windsurf response completion...');
+    this.responseWaiting = true;
+
+    try {
+      const responseText = response.toLowerCase();
+
+      // Check for ongoing status indicators - if these are present, response is NOT complete
+      const hasOngoingStatus = responseText.includes('surfing') ||
+          responseText.includes('navigating') ||
+          responseText.includes('swimming') ||
+          responseText.includes('floating') ||
+          responseText.includes('proposing code') ||
+          responseText.includes('reading file') ||
+          responseText.includes('searching') ||
+          responseText.includes('updating todo list');
+
+      if (hasOngoingStatus) {
+        this.logger.log('⏳ Response still in progress - waiting for completion...');
+        return { completed: false, response };
+      }
+
+      // Check for completion indicators
+      const hasCompletionIndicators = responseText.includes('thumbs up') ||
+          responseText.includes('thumbs down') ||
+          responseText.includes('👍') ||
+          responseText.includes('👎') ||
+          responseText.includes('copy icon') ||
+          responseText.includes('bookmark icon') ||
+          responseText.includes('bar chart icon') ||
+          responseText.includes('view response summary') ||
+          responseText.includes('ask anything (⌘l)') ||
+          responseText.includes('microphone icon') ||
+          responseText.includes('send button') ||
+          responseText.includes('+ chat') ||
+          responseText.includes('+ chat swe-1') ||
+          responseText.includes('paper plane') ||
+          responseText.includes('send icon') ||
+          responseText.includes('chat swe-1') ||
+          responseText.includes('ask anything') ||
+          responseText.includes('⌘l') ||
+          responseText.includes('command+l');
+
+      if (hasCompletionIndicators) {
+        this.logger.log('🎯 Completion indicators found!');
+        this.responseWaiting = false;
+        return { completed: true, response };
+      }
+
+      // Check for percentage in response
+      const percentageMatch = response.match(/(\d+)%/);
+      if (percentageMatch) {
+        const percentage = parseInt(percentageMatch[1]);
+        this.currentProgress = percentage;
+        this.onProgressUpdate(percentage);
+        this.logger.log(`📊 Progress detected: ${percentage}%`);
+
+        if (percentage === 100) {
+          this.logger.log('🎉 100% completion detected!');
+          this.responseWaiting = false;
+          return { completed: true, response, progress: 100 };
+        }
+      }
+
+      // Response is not complete
+      return { completed: false, response };
+
+    } catch (error) {
+      this.logger.error('Error detecting response completion:', error);
+      this.responseWaiting = false;
+      return { completed: false, response, error: error.message };
+    }
+  }
+
+  /**
+   * Pause chat operations
+   */
+  pause() {
+    this.isPaused = true;
+    this.logger.log('Chat operations paused');
+  }
+
+  /**
+   * Resume chat operations
+   */
+  resume() {
+    this.isPaused = false;
+    this.logger.log('Chat operations resumed');
+  }
+
+  /**
+   * Stop chat operations
+   */
+  stop() {
+    this.isStopped = true;
+    this.stopPolling();
+    this.logger.log('Chat operations stopped');
+  }
+
+  /**
+   * Reset chat state
+   */
+  reset() {
+    this.isStopped = false;
+    this.isPaused = false;
+    this.isPolling = false;
+    this.responseWaiting = false;
+    this.currentProgress = 0;
+    this.stopPolling();
+    this.logger.log('Chat state reset');
+  }
+
+  /**
+   * Get current chat state
+   * @returns {Object} Current chat state
+   */
+  getState() {
+    return {
+      isPolling: this.isPolling,
+      isPaused: this.isPaused,
+      isStopped: this.isStopped,
+      responseWaiting: this.responseWaiting,
+      currentProgress: this.currentProgress,
+      lastChangeAt: this.lastChangeAt
+    };
+  }
+
+  /**
+   * Set electron API for Electron environment
+   * @param {Object} electronAPI - The electron API object
+   */
+  setElectronAPI(electronAPI) {
+    this.electronAPI = electronAPI;
+  }
+
+  /**
+   * Set callback functions
+   * @param {Object} callbacks - Object containing callback functions
+   */
+  setCallbacks(callbacks) {
+    if (callbacks.onMessageUpdate) {
+      this.onMessageUpdate = callbacks.onMessageUpdate;
+    }
+    if (callbacks.onStatusUpdate) {
+      this.onStatusUpdate = callbacks.onStatusUpdate;
+    }
+    if (callbacks.onProgressUpdate) {
+      this.onProgressUpdate = callbacks.onProgressUpdate;
+    }
+  }
+}