vibecodingmachine-core 1.0.0

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

@@ -0,0 +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;
+    }
+  }
+}

package/src/ide-integration/__tests__/applescript-manager-thread-closure.test.js

@@ -0,0 +1,227 @@
+/**
+ * Jest tests for AppleScript Manager thread closure functionality
+ * Tests the ability to close previous chat threads when starting new ones
+ */
+
+import { AppleScriptManager } from '../applescript-manager.js';
+import { execSync } from 'child_process';
+
+// Mock child_process
+jest.mock('child_process', () => ({
+  execSync: jest.fn()
+}));Windsurf: Open Chat
+
+
+
+
+
+// Mock fs
+jest.mock('fs', () => ({
+  writeFileSync: jest.fn(),
+  unlinkSync: jest.fn()
+}));
+
+// Mock os
+jest.mock('os', () => ({
+  tmpdir: () => '/tmp'
+}));
+
+describe('AppleScriptManager - Thread Closure', () => {
+  let appleScriptManager;
+  let mockExecSync;
+
+  beforeEach(() => {
+    appleScriptManager = new AppleScriptManager();
+    mockExecSync = execSync;
+    mockExecSync.mockClear();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('closePreviousChatThread', () => {
+    it('should close previous chat thread in Cursor', async () => {
+      // Mock successful execution
+      mockExecSync.mockReturnValue('Previous chat thread closed');
+
+      const result = await appleScriptManager.closePreviousChatThread('cursor');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Previous chat thread closed');
+      expect(result.method).toBe('applescript');
+      expect(mockExecSync).toHaveBeenCalled();
+    });
+
+    it('should close previous chat thread in VS Code', async () => {
+      // Mock successful execution
+      mockExecSync.mockReturnValue('Previous chat thread closed');
+
+      const result = await appleScriptManager.closePreviousChatThread('vscode');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Previous chat thread closed');
+      expect(result.method).toBe('applescript');
+      expect(mockExecSync).toHaveBeenCalled();
+    });
+
+    it('should close previous chat thread in Windsurf', async () => {
+      // Mock successful execution
+      mockExecSync.mockReturnValue('Previous chat thread closed');
+
+      const result = await appleScriptManager.closePreviousChatThread('windsurf');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Previous chat thread closed');
+      expect(result.method).toBe('applescript');
+      expect(mockExecSync).toHaveBeenCalled();
+    });
+
+    it('should handle errors gracefully when closing threads', async () => {
+      // Mock execution error
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Failed to close thread');
+      });
+
+      const result = await appleScriptManager.closePreviousChatThread('cursor');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Failed to close thread');
+      expect(result.method).toBe('applescript');
+    });
+
+    it('should return error for unsupported IDE', async () => {
+      const result = await appleScriptManager.closePreviousChatThread('unsupported');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Unsupported IDE');
+      expect(mockExecSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('sendTextWithThreadClosure', () => {
+    it('should close previous thread before sending new message to Cursor', async () => {
+      // Mock successful executions
+      mockExecSync
+        .mockReturnValueOnce('Previous chat thread closed')
+        .mockReturnValueOnce('Message sent to Cursor: Test message')
+        .mockReturnValueOnce('Message sent to Cursor: Test message');
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Test message');
+      expect(mockExecSync).toHaveBeenCalledTimes(3); // Once for close, twice for send (sendText calls execSync twice)
+    });
+
+    it('should close previous thread before sending new message to VS Code', async () => {
+      // Mock successful executions
+      mockExecSync
+        .mockReturnValueOnce('Previous chat thread closed')
+        .mockImplementationOnce(() => {
+          // Simulate successful AppleScript execution for text sending
+          return 'Message sent via AppleScript to VS Code GitHub Copilot Chat';
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'vscode');
+
+      expect(result.success).toBe(true); // VS Code is now supported by AppleScript manager
+      expect(result.method).toBe('applescript');
+      expect(result.threadClosure).toContain('Previous thread closed');
+      expect(mockExecSync).toHaveBeenCalledTimes(2); // Once for thread closure, once for sending
+    });
+
+    it('should close previous thread before sending new message to Windsurf', async () => {
+      // Mock successful executions
+      mockExecSync
+        .mockReturnValueOnce('Previous chat thread closed')
+        .mockImplementationOnce(() => {
+          throw new Error('AppleScript failed');
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'windsurf');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Test message');
+      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once for thread closure
+    });
+
+    it('should handle thread closure failure gracefully', async () => {
+      // Mock thread closure failure but successful message send
+      mockExecSync
+        .mockImplementationOnce(() => {
+          throw new Error('Failed to close thread');
+        })
+        .mockImplementationOnce(() => {
+          throw new Error('AppleScript failed');
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Test message');
+      expect(result.warning).toContain('Failed to close previous thread');
+      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
+    });
+
+    it('should handle both thread closure and message send failures', async () => {
+      // Mock both failures
+      mockExecSync
+        .mockImplementationOnce(() => {
+          throw new Error('Failed to close thread');
+        })
+        .mockImplementationOnce(() => {
+          throw new Error('AppleScript failed');
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
+
+      expect(result.success).toBe(true); // Should still succeed due to simulated fallback
+      expect(result.message).toContain('Test message');
+      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
+    });
+
+    it('should validate input parameters', async () => {
+      const result = await appleScriptManager.sendTextWithThreadClosure('', 'cursor');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid text');
+      expect(mockExecSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('AppleScript Content Validation', () => {
+    it('should generate correct AppleScript for Cursor thread closure', async () => {
+      mockExecSync.mockReturnValue('Success');
+
+      await appleScriptManager.closePreviousChatThread('cursor');
+
+      const callArgs = mockExecSync.mock.calls[0][0];
+      expect(callArgs).toContain('osascript');
+      // The script content is written to a temp file, so we check the osascript call
+      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
+    });
+
+    it('should generate correct AppleScript for VS Code thread closure', async () => {
+      mockExecSync.mockReturnValue('Success');
+
+      await appleScriptManager.closePreviousChatThread('vscode');
+
+      const callArgs = mockExecSync.mock.calls[0][0];
+      expect(callArgs).toContain('osascript');
+      // The script content is written to a temp file, so we check the osascript call
+      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
+    });
+
+    it('should generate correct AppleScript for Windsurf thread closure', async () => {
+      mockExecSync.mockReturnValue('Success');
+
+      await appleScriptManager.closePreviousChatThread('windsurf');
+
+      const callArgs = mockExecSync.mock.calls[0][0];
+      expect(callArgs).toContain('osascript');
+      // The script content is written to a temp file, so we check the osascript call
+      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
+    });
+  });
+});