vibecodingmachine-core 1.0.0

package/src/ide-integration/applescript-utils.js

@@ -0,0 +1,306 @@
+/**
+ * Shared AppleScript utilities for IDE integration
+ * Consolidates common AppleScript patterns to follow DRY principles
+ */
+
+class AppleScriptUtils {
+  constructor() {
+    this.logger = console;
+  }
+
+  /**
+   * Generate AppleScript for focusing AI panel with multiple fallback strategies
+   * @param {string} text - The text to send to the AI panel
+   * @param {string} ide - The IDE name (e.g., 'cursor')
+   * @returns {string} Complete AppleScript code
+   */
+  generateAIPanelFocusScript(text, ide = 'cursor') {
+    const escapedText = text.replace(/"/g, '\\"');
+
+    return `
+tell application "System Events"
+  tell process "${ide}"
+    -- Check if the process is running before attempting to interact
+    try
+      set frontmost to true
+      delay 1
+
+      -- PRE-CHECK: Ensure we're not in an editor
+      try
+        -- Press Escape to ensure we're not in any input mode
+        key code 53 -- Escape
+        delay 0.5
+      on error
+        -- Continue if escape fails
+      end try
+
+      ${this.generateFocusStrategies(escapedText)}
+    on error
+      -- Process not running or not accessible
+      error "Process '${ide}' is not running or not accessible. VibeCodingMachine does not open IDEs - please open ${ide} manually first."
+    end try
+  end tell
+end tell`;
+  }
+
+  /**
+   * Generate multiple focus strategies with fallbacks
+   * @param {string} escapedText - The escaped text to send
+   * @returns {string} AppleScript focus strategies
+   */
+  generateFocusStrategies(escapedText) {
+    return `
+    -- STRATEGY 1: Direct AI Panel Focus via Keyboard Shortcut (Cmd+L) - Primary
+    try
+      -- Use Cmd+L to focus AI panel (faster and more reliable)
+      key code 37 using {command down} -- Cmd+L
+      delay 1.5
+
+      -- Open new chat session with Cmd+T to prevent crashes
+      key code 17 using {command down} -- Cmd+T
+      delay 2.5
+
+      -- Skip clearing text to avoid selecting file content
+      -- The chat input should be empty when opening new chat session
+
+      -- Wait additional time for chat input field to be fully ready
+      delay 1.0
+
+      -- Type the message
+      keystroke "${escapedText}"
+      delay 1.5
+
+      -- Send with Cmd+Enter (standard for chat interfaces)
+      key code 36 using {command down}
+      delay 0.5
+
+      -- Fallback: Press Enter to ensure submission
+      key code 36
+      delay 0.5
+
+      -- Additional fallback: Press Enter again to be absolutely sure
+      key code 36
+      delay 1.0
+
+      return "Message sent via AppleScript to AI Panel using Cmd+L shortcut with new chat session (Cmd+T)"
+    on error
+      -- STRATEGY 2: Command Palette Approach (Fallback 1) - NO AI PANEL TOGGLE
+      try
+        -- Step 1: Open Command Palette (Cmd+Shift+P)
+        key code 35 using {command down, shift down} -- Cmd+Shift+P
+        delay 0.8
+
+        -- Step 2: Type "View: Focus into Secondary Side Bar" to focus AI panel
+        keystroke "View: Focus into Secondary Side Bar"
+        delay 0.8
+
+        -- Step 3: Press Enter to focus AI Panel
+        key code 36 -- Enter
+        delay 2.0
+
+        -- Step 4: Open new chat session with Cmd+T to prevent crashes
+        key code 17 using {command down} -- Cmd+T
+        delay 2.5
+
+        -- Step 5: Skip clearing text to avoid selecting file content
+        -- The chat input should be empty when opening new chat session
+
+        -- Step 6: Wait additional time for chat input field to be fully ready
+        delay 1.0
+
+        -- Step 7: Type the message
+        keystroke "${escapedText}"
+        delay 1.5
+
+        -- Step 8: Send with Cmd+Enter (standard for chat interfaces)
+        key code 36 using {command down}
+        delay 0.5
+
+        -- Fallback: Press Enter to ensure submission
+        key code 36
+        delay 0.5
+
+        -- Additional fallback: Press Enter again to be absolutely sure
+        key code 36
+        delay 1.0
+
+        return "Message sent via AppleScript to AI Panel using command palette fallback with new chat session (Cmd+T)"
+      on error
+        -- STRATEGY 3: Direct Element Targeting (Last Resort)
+        try
+          -- Look for AI panel elements and click them
+          set aiPanelFound to false
+
+          -- Try to find text fields that might be chat inputs
+          set allTextFields to text field of window 1
+          repeat with textField in allTextFields
+            try
+              -- Click on the text field (likely chat input)
+              click textField
+              delay 0.5
+
+              -- Open new chat session with Cmd+T to prevent crashes
+              key code 17 using {command down} -- Cmd+T
+              delay 2.5
+
+              -- Skip clearing text to avoid selecting file content
+              -- The chat input should be empty when opening new chat session
+
+              -- Wait additional time for chat input field to be fully ready
+              delay 1.0
+
+              -- Type the message
+              keystroke "${escapedText}"
+              delay 1.5
+
+              -- Send with Cmd+Enter
+              key code 36 using {command down}
+              delay 0.5
+
+              -- Fallback: Press Enter to ensure submission
+              key code 36
+              delay 0.5
+
+              -- Additional fallback: Press Enter again to be absolutely sure
+              key code 36
+              delay 1.0
+
+              set aiPanelFound to true
+              exit repeat
+            on error
+              -- Continue to next text field
+            end try
+          end repeat
+
+          if aiPanelFound then
+            return "Message sent via AppleScript to AI Panel using direct element targeting"
+          end if
+        on error
+          -- STRATEGY 4: Emergency fallback - ensure we're not in editor
+          try
+            -- First escape any terminal focus
+            key code 53 -- Escape key
+            delay 1
+
+            -- Click in editor area to escape terminal
+            do shell script "/usr/local/bin/cliclick c:400,300"
+            delay 1
+
+            -- Try Tab navigation to find chat input
+            repeat 3 times
+              key code 48 -- Tab key
+              delay 0.5
+            end repeat
+
+            -- Open new chat session with Cmd+T to prevent crashes
+            key code 17 using {command down} -- Cmd+T
+            delay 2.5
+
+            -- Wait additional time for chat input field to be fully ready
+            delay 1.0
+
+            -- Type the message
+            keystroke "${escapedText}"
+            delay 1.5
+
+            -- Send with Cmd+Enter
+            key code 36 using {command down}
+            delay 0.5
+
+            -- Fallback: Press Enter to ensure submission
+            key code 36
+            delay 0.5
+
+            -- Additional fallback: Press Enter again to be absolutely sure
+            key code 36
+            delay 1.0
+
+            return "Message sent via AppleScript to AI Panel using emergency fallback with new chat session (Cmd+T)"
+          on error
+            return "ERROR: All AI panel focus strategies failed"
+          end try
+        end try
+      end try
+    end try`;
+  }
+
+  /**
+   * Generate Windows PowerShell script for AI panel focus
+   * @param {string} text - The text to send to the AI panel
+   * @returns {string} Complete PowerShell script
+   */
+  generateWindowsAIPanelScript(text) {
+    const escapedText = text.replace(/"/g, '""');
+
+    return `
+# Windows AI Panel Focus Script - Consolidated
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+# Function to find Cursor window
+function Find-CursorWindow {
+    $processes = Get-Process | Where-Object { $_.ProcessName -like "*cursor*" -or $_.MainWindowTitle -like "*cursor*" }
+    foreach ($proc in $processes) {
+        if ($proc.MainWindowHandle -ne [IntPtr]::Zero) {
+            return $proc
+        }
+    }
+    return $null
+}
+
+# Function to focus AI Panel and send text
+function Send-ToAIPanel {
+    param($windowHandle, $text)
+
+    # Focus the Cursor window
+    [Microsoft.VisualBasic.Interaction]::AppActivate($windowHandle)
+    Start-Sleep -Milliseconds 500
+
+    # Step 1: Try Cmd+L equivalent (Ctrl+L on Windows) to focus AI panel
+    [System.Windows.Forms.SendKeys]::SendWait("^l")
+    Start-Sleep -Milliseconds 1500
+
+    # Step 2: Open new chat session with Ctrl+T to prevent crashes
+    [System.Windows.Forms.SendKeys]::SendWait("^t")
+    Start-Sleep -Milliseconds 1000
+
+    # Step 3: Clear any existing text in the chat input (Ctrl+A, Delete)
+    [System.Windows.Forms.SendKeys]::SendWait("^a")
+    Start-Sleep -Milliseconds 200
+    [System.Windows.Forms.SendKeys]::SendWait("{DELETE}")
+    Start-Sleep -Milliseconds 200
+
+    # Step 4: Type the message
+    [System.Windows.Forms.SendKeys]::SendWait("$text")
+    Start-Sleep -Milliseconds 500
+
+    # Step 5: Send with Ctrl+Enter (standard for chat interfaces)
+    [System.Windows.Forms.SendKeys]::SendWait("^{ENTER}")
+    Start-Sleep -Milliseconds 1000
+}
+
+try {
+    # Find Cursor window
+    $cursorProcess = Find-CursorWindow
+    if ($cursorProcess -eq $null) {
+        Write-Output "ERROR: Cursor window not found"
+        exit 1
+    }
+
+    Write-Output "Found Cursor process: $($cursorProcess.ProcessName) (PID: $($cursorProcess.Id))"
+
+    # Send the text to AI Panel
+    Send-ToAIPanel -windowHandle $cursorProcess.MainWindowHandle -text "${escapedText}"
+
+    Write-Output "SUCCESS: Message sent to Cursor AI Panel using Ctrl+L shortcut with new chat session (Ctrl+T)"
+    exit 0
+
+} catch {
+    Write-Output "ERROR: $($_.Exception.Message)"
+    exit 1
+}`;
+  }
+}
+
+module.exports = AppleScriptUtils;
+

package/src/ide-integration/cdp-manager.cjs

@@ -0,0 +1,221 @@
+// @vibecodingmachine/core - CDP Manager (CommonJS)
+// Handles Chrome DevTools Protocol interactions with IDEs
+
+const CDP = require('chrome-remote-interface');
+
+/**
+ * CDP Manager for IDE interactions
+ * Handles Chrome DevTools Protocol-based text sending for IDEs like VS Code and Cursor
+ */
+class CDPManager {
+  constructor() {
+    this.logger = console;
+  }
+
+  /**
+   * Timeout utility function
+   * @param {number} ms - Timeout in milliseconds
+   * @param {Promise} promise - Promise to timeout
+   * @returns {Promise} Promise with timeout
+   */
+  timeout(ms, promise) {
+    return Promise.race([
+      promise,
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms)
+      )
+    ]);
+  }
+
+  /**
+   * Send text to an IDE via CDP
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name ('vscode', 'cursor')
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendText(text, ide) {
+    if (typeof text !== 'string') {
+      return {
+        success: false,
+        error: `Invalid text type: ${typeof text}. Expected string.`,
+        debug: { textType: typeof text, textValue: text }
+      };
+    }
+
+    const ideName = ide === 'cursor' ? 'Cursor' : ide === 'vscode' ? 'VS Code' : 'Unknown IDE';
+    const port = ide === 'cursor' ? 9225 : 9222;
+
+    this.logger.log(`🔍 sendText: Starting debug session`);
+    this.logger.log(`📋 IDE: ${ideName} (${ide})`);
+    this.logger.log(`🔌 Port: ${port}`);
+    this.logger.log(`💬 Text: "${text.substring(0, 100)}${text.length > 100 ? '...' : ''}"`);
+
+    try {
+      // For VS Code, use the working approach from commit 6235f46b
+      if (ide === 'vscode') {
+        return await this.sendTextToVSCode(text);
+      }
+
+      // For other IDEs, use basic CDP approach
+      return await this.sendTextBasic(text, ide);
+    } catch (error) {
+      this.logger.error('CDP error:', error);
+      return {
+        success: false,
+        error: `CDP error: ${error.message}`,
+        debug: { ide, port, textLength: text.length }
+      };
+    }
+  }
+
+  /**
+   * Send text to VS Code using the working approach
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object
+   */
+  async sendTextToVSCode(text) {
+    try {
+      const targets = await CDP.List({ port: 9222 });
+      if (!targets || targets.length === 0) {
+        return { success: false, error: 'Could not find VS Code. Make sure VS Code is running with --remote-debugging-port=9222' };
+      }
+
+      const workbench = targets.find(t => t.url && t.url.includes('workbench')) || targets[0];
+      if (!workbench) return { success: false, error: 'No VS Code workbench target found.' };
+
+      this.logger.log(`Found ${targets.length} targets, using workbench: ${workbench.title}`);
+      const client = await CDP({ port: 9222, target: workbench });
+      const { Runtime, Input, Page, DOM } = client;
+      await Runtime.enable();
+      await DOM.enable();
+      if (Page && Page.bringToFront) { try { await Page.bringToFront(); } catch (_) {} }
+
+      // Use clipboard approach to avoid focus issues
+      const clipboardText = String(text).slice(0, 4000);
+      this.logger.log('Copying text to clipboard:', clipboardText);
+
+      // Try to paste the text after a short delay
+      setTimeout(async () => {
+        try {
+          const isDarwin = process.platform === 'darwin';
+          const pasteMods = isDarwin ? 4 /* Meta */ : 2 /* Ctrl */;
+          await Input.dispatchKeyEvent({ type: 'keyDown', key: 'v', text: 'v', modifiers: pasteMods });
+          await Input.dispatchKeyEvent({ type: 'keyUp', key: 'v', text: 'v', modifiers: pasteMods });
+          this.logger.log('Pasted text via Cmd+V');
+        } catch (e) {
+          this.logger.log('Paste failed:', e.message);
+        }
+      }, 200);
+
+      // Also try typing the text character by character
+      setTimeout(async () => {
+        try {
+          this.logger.log('Starting character-by-character typing...');
+          for (let i = 0; i < clipboardText.length; i++) {
+            const char = clipboardText[i];
+            await Input.dispatchKeyEvent({ type: 'keyDown', key: char, text: char });
+            await Input.dispatchKeyEvent({ type: 'keyUp', key: char, text: char });
+            await new Promise(resolve => setTimeout(resolve, 20));
+          }
+          this.logger.log('Finished character-by-character typing');
+
+          // Try multiple submission methods
+          setTimeout(async () => {
+            try {
+              this.logger.log('Attempting to submit message...');
+
+              // Method 1: Press Enter
+              await Input.dispatchKeyEvent({ type: 'keyDown', key: 'Enter' });
+              await Input.dispatchKeyEvent({ type: 'keyUp', key: 'Enter' });
+              await new Promise(resolve => setTimeout(resolve, 100));
+
+              // Method 2: Try Cmd+Enter
+              const isDarwin = process.platform === 'darwin';
+              const enterMods = isDarwin ? 4 /* Meta */ : 2 /* Ctrl */;
+              await Input.dispatchKeyEvent({ type: 'keyDown', key: 'Enter', text: 'Enter', modifiers: enterMods });
+              await Input.dispatchKeyEvent({ type: 'keyUp', key: 'Enter', text: 'Enter', modifiers: enterMods });
+
+            } catch (e) {
+              this.logger.log('Submission failed:', e.message);
+            }
+          }, 300);
+
+        } catch (e) {
+          this.logger.log('Character typing failed:', e.message);
+        }
+      }, 500);
+
+      this.logger.log(`Successfully sent message to VS Code via CDP`);
+      return {
+        success: true,
+        method: 'cdp-clipboard',
+        message: `Message sent to VS Code: ${text}`,
+        note: 'Message sent via CDP with clipboard approach'
+      };
+
+    } catch (error) {
+      this.logger.error('VS Code CDP error:', error);
+      return { success: false, error: `VS Code CDP error: ${error.message}` };
+    }
+  }
+
+  /**
+   * Send text using basic CDP approach
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result object
+   */
+  async sendTextBasic(text, ide) {
+    const textToSend = String(text).slice(0, 4000);
+    const port = ide === 'cursor' ? 9225 : 9222;
+
+    try {
+      const targets = await this.timeout(5000, CDP.List({ port }));
+      if (!targets || targets.length === 0) {
+        return { success: false, error: `Could not find ${ide}. Make sure ${ide} is running with --remote-debugging-port=${port}` };
+      }
+
+      const workbench = targets.find(t => t.url && t.url.includes('workbench')) || targets[0];
+      if (!workbench) return { success: false, error: `No ${ide} workbench target found.` };
+
+      const client = await this.timeout(10000, CDP({ port, target: workbench }));
+      const { Runtime, Input, Page } = client;
+
+      await this.timeout(5000, Runtime.enable());
+      await this.timeout(5000, Page.enable());
+
+      if (Page && Page.bringToFront) {
+        try {
+          await this.timeout(3000, Page.bringToFront());
+        } catch (error) {
+          this.logger.log(`Bring to front failed: ${error.message}`);
+        }
+      }
+
+      // Type the text character by character
+      for (let i = 0; i < textToSend.length; i++) {
+        const char = textToSend[i];
+        await Input.dispatchKeyEvent({ type: 'keyDown', key: char, text: char });
+        await Input.dispatchKeyEvent({ type: 'keyUp', key: char, text: char });
+        await new Promise(resolve => setTimeout(resolve, 20));
+      }
+
+      // Press Enter to submit
+      await Input.dispatchKeyEvent({ type: 'keyDown', key: 'Enter' });
+      await Input.dispatchKeyEvent({ type: 'keyUp', key: 'Enter' });
+
+      return {
+        success: true,
+        method: 'cdp-basic',
+        message: `Message sent to ${ide}: ${text}`,
+        note: 'Message sent via basic CDP approach'
+      };
+
+    } catch (error) {
+      this.logger.error(`${ide} CDP error:`, error);
+      return { success: false, error: `${ide} CDP error: ${error.message}` };
+    }
+  }
+}
+
+module.exports = { CDPManager };