vibecodingmachine-core 1.0.0

package/src/ide-integration/quota-detector.js

@@ -0,0 +1,349 @@
+// @vibecodingmachine/core - Quota Detector
+// Handles quota detection for different IDEs using CDP and AppleScript
+
+import CDP from 'chrome-remote-interface';
+import { AppleScriptManager } from './applescript-manager.js';
+
+/**
+ * Quota Detector for IDE interactions
+ * Detects quota warnings in different IDEs using CDP and AppleScript
+ */
+export class QuotaDetector {
+  constructor() {
+    this.logger = console;
+    this.appleScriptManager = new AppleScriptManager();
+  }
+
+  /**
+   * 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)
+      )
+    ]);
+  }
+
+  /**
+   * Detect quota warnings in an IDE
+   * @param {string} ide - The IDE name ('vscode', 'cursor', 'windsurf')
+   * @returns {Promise<Object>} Quota detection result
+   */
+  async detectQuotaWarning(ide = 'vscode') {
+    this.logger.log(`🔍 Starting quota detection for ${ide}...`);
+
+    // Determine the port based on the IDE
+    const port = ide === 'windsurf' ? 9224 : ide === 'cursor' ? 9225 : 9222;
+    const ideName = ide === 'windsurf' ? 'Windsurf' : ide === 'cursor' ? 'Cursor' : 'VS Code';
+
+    this.logger.log(`🔌 Checking ${ideName} on port ${port}...`);
+
+    // For Windsurf, use AppleScript detection since CDP is not supported
+    if (ide === 'windsurf') {
+      this.logger.log('🔍 Windsurf detected - using AppleScript quota detection');
+      return await this.appleScriptManager.detectQuotaWarning(ide);
+    }
+
+    // For VS Code and Cursor, use CDP detection
+    try {
+      this.logger.log(`🔍 Attempting CDP connection to ${ideName} on port ${port}...`);
+
+      // Try to connect to CDP
+      const targets = await this.timeout(5000, CDP.List({ port }));
+
+      if (!targets || targets.length === 0) {
+        this.logger.log(`❌ No CDP targets found on port ${port}`);
+
+        // For Windsurf, fall back to AppleScript
+        if (ide === 'windsurf') {
+          this.logger.log('🔍 Falling back to enhanced AppleScript quota detection...');
+          return await this.appleScriptManager.detectQuotaWarning(ide);
+        }
+
+        return {
+          hasQuotaWarning: false,
+          error: `Could not find ${ideName}. Make sure ${ideName} is running with --remote-debugging-port=${port}`,
+          note: 'CDP connection failed'
+        };
+      }
+
+      this.logger.log(`✅ Found ${targets.length} CDP targets`);
+
+      // For Cursor, prefer the workspace target over settings
+      let workbench;
+      if (ide === 'cursor') {
+        workbench = targets.find(t => t.title !== 'Cursor Settings' && t.type === 'page') ||
+                    targets.find(t => t.url && t.url.includes('workbench')) ||
+                    targets[0];
+      } else {
+        workbench = targets.find(t => t.url && t.url.includes('workbench')) || targets[0];
+      }
+
+      if (!workbench) {
+        this.logger.log(`❌ No suitable workbench target found`);
+        return {
+          hasQuotaWarning: false,
+          error: `No ${ideName} workbench target found.`,
+          note: 'No workbench target available'
+        };
+      }
+
+      this.logger.log(`✅ Selected workbench: ${workbench.title}`);
+
+      // Connect to CDP
+      const client = await this.timeout(10000, CDP({ port, target: workbench }));
+      const { Runtime, Page } = client;
+
+      await this.timeout(5000, Runtime.enable());
+      if (Page && Page.bringToFront) {
+        try {
+          await this.timeout(3000, Page.bringToFront());
+        } catch (error) {
+          this.logger.log(`⚠️ Bring to front failed: ${error.message}`);
+        }
+      }
+
+      // Execute JavaScript to detect quota warnings
+      const detectionScript = `
+        (() => {
+          console.log('🔍 Starting quota detection in ${ideName}...');
+
+          // Common quota warning patterns
+          const quotaPatterns = [
+            'not enough credits',
+            'upgrade to a paid plan',
+            'switch to swe-1-lite',
+            'quota exceeded',
+            'credits exhausted',
+            'payment required',
+            'out of credits',
+            'insufficient credits',
+            'billing required',
+            'subscription needed'
+          ];
+
+          // Function to check if text contains quota warnings
+          function containsQuotaWarning(text) {
+            if (!text) return false;
+            const lowerText = text.toLowerCase();
+            return quotaPatterns.some(pattern => lowerText.includes(pattern));
+          }
+
+          // Method 1: Check all text content in the document
+          const allText = document.body.innerText || document.body.textContent || '';
+          if (containsQuotaWarning(allText)) {
+            console.log('❌ Quota warning detected in document text');
+            return {
+              hasQuotaWarning: true,
+              method: 'document-text',
+              matchedText: allText.substring(0, 200) + '...'
+            };
+          }
+
+          // Method 2: Check specific elements that might contain quota warnings
+          const quotaElements = [
+            // VS Code specific selectors
+            '.monaco-workbench .part.auxiliarybar',
+            '.monaco-workbench .part.sidebar.right',
+            '.monaco-workbench .chat-view',
+            '.monaco-workbench .chat-input',
+
+            // Cursor specific selectors
+            '.aislash-editor-input',
+            '.aislash-chat-container',
+            '.aislash-panel',
+
+            // Generic selectors
+            '[data-testid*="chat"]',
+            '[aria-label*="chat"]',
+            '[class*="chat"]',
+            '[class*="quota"]',
+            '[class*="credits"]',
+            '[class*="billing"]'
+          ];
+
+          for (const selector of quotaElements) {
+            const elements = document.querySelectorAll(selector);
+            for (const element of elements) {
+              const elementText = element.innerText || element.textContent || '';
+              if (containsQuotaWarning(elementText)) {
+                console.log('❌ Quota warning detected in element:', selector);
+                return {
+                  hasQuotaWarning: true,
+                  method: 'element-specific',
+                  selector: selector,
+                  matchedText: elementText.substring(0, 200) + '...'
+                };
+              }
+            }
+          }
+
+          // Method 3: Check for disabled input fields (common when quota is exceeded)
+          const disabledInputs = document.querySelectorAll('input[disabled], textarea[disabled], [contenteditable="true"][aria-disabled="true"]');
+          if (disabledInputs.length > 0) {
+            console.log('⚠️ Found disabled input fields, checking for quota context...');
+
+            // Check if there are quota-related messages near disabled inputs
+            for (const input of disabledInputs) {
+              const parentText = input.parentElement?.innerText || '';
+              if (containsQuotaWarning(parentText)) {
+                console.log('❌ Quota warning detected near disabled input');
+                return {
+                  hasQuotaWarning: true,
+                  method: 'disabled-input-context',
+                  matchedText: parentText.substring(0, 200) + '...'
+                };
+              }
+            }
+          }
+
+          // Method 4: Check for specific UI elements that indicate quota issues
+          const quotaButtons = document.querySelectorAll('button, a, [role="button"]');
+          for (const button of quotaButtons) {
+            const buttonText = button.innerText || button.textContent || '';
+            if (containsQuotaWarning(buttonText)) {
+              console.log('❌ Quota warning detected in button:', buttonText);
+              return {
+                hasQuotaWarning: true,
+                method: 'button-text',
+                matchedText: buttonText
+              };
+            }
+          }
+
+          // Method 5: Check for error messages or notifications
+          const errorElements = document.querySelectorAll('[class*="error"], [class*="warning"], [class*="notification"], [role="alert"]');
+          for (const error of errorElements) {
+            const errorText = error.innerText || error.textContent || '';
+            if (containsQuotaWarning(errorText)) {
+              console.log('❌ Quota warning detected in error element');
+              return {
+                hasQuotaWarning: true,
+                method: 'error-element',
+                matchedText: errorText.substring(0, 200) + '...'
+              };
+            }
+          }
+
+          console.log('✅ No quota warnings detected');
+          return {
+            hasQuotaWarning: false,
+            method: 'cdp-comprehensive',
+            note: 'No quota warnings found in ${ideName}'
+          };
+        })()
+      `;
+
+      const { result } = await this.timeout(10000, Runtime.evaluate({
+        expression: detectionScript,
+        returnByValue: true
+      }));
+
+      const detectionResult = result.value || result.unserializableValue;
+
+      this.logger.log('🔍 CDP quota detection result:', detectionResult);
+
+      if (detectionResult && detectionResult.hasQuotaWarning) {
+        this.logger.log('❌ Quota warning detected via CDP');
+        return {
+          hasQuotaWarning: true,
+          method: detectionResult.method,
+          note: detectionResult.matchedText || 'Quota warning detected via CDP',
+          debug: detectionResult
+        };
+      }
+
+      this.logger.log('✅ No quota warnings detected via CDP');
+      return {
+        hasQuotaWarning: false,
+        method: 'cdp-comprehensive',
+        note: 'No quota warnings found in ' + ideName,
+        debug: detectionResult
+      };
+
+    } catch (error) {
+      this.logger.log(`❌ CDP quota detection failed: ${error.message}`);
+
+      // For Windsurf, fall back to AppleScript
+      if (ide === 'windsurf') {
+        this.logger.log('🔍 Falling back to AppleScript quota detection...');
+        return await this.appleScriptManager.detectQuotaWarning(ide);
+      }
+
+      return {
+        hasQuotaWarning: false,
+        error: error.message,
+        note: `CDP quota detection failed for ${ideName}`
+      };
+    }
+  }
+
+  /**
+   * Get available IDEs without quota warnings
+   * @param {Array<string>} ides - Array of IDE names to check
+   * @returns {Promise<Array<string>>} Array of available IDE names
+   */
+  async getAvailableIdes(ides = ['vscode', 'cursor', 'windsurf']) {
+    this.logger.log('🔍 Checking available IDEs without quota warnings...');
+
+    const availableIdes = [];
+
+    for (const ide of ides) {
+      try {
+        const quotaResult = await this.detectQuotaWarning(ide);
+
+        if (!quotaResult.hasQuotaWarning) {
+          availableIdes.push(ide);
+          this.logger.log(`✅ ${ide} is available (no quota warnings)`);
+        } else {
+          this.logger.log(`❌ ${ide} has quota warnings: ${quotaResult.note || 'Unknown quota issue'}`);
+        }
+      } catch (error) {
+        this.logger.log(`⚠️ Error checking ${ide}: ${error.message}`);
+        // If we can't check quota, assume the IDE is available
+        availableIdes.push(ide);
+      }
+    }
+
+    this.logger.log(`📋 Available IDEs: ${availableIdes.join(', ')}`);
+    return availableIdes;
+  }
+
+  /**
+   * Test quota detection with a test message
+   * @param {string} ide - The IDE name to test
+   * @returns {Promise<Object>} Test result
+   */
+  async testQuotaDetection(ide) {
+    this.logger.log(`🧪 Testing quota detection for ${ide}...`);
+
+    try {
+      const quotaResult = await this.detectQuotaWarning(ide);
+
+      this.logger.log(`🧪 Quota detection test result for ${ide}:`, quotaResult);
+
+      return {
+        ide,
+        success: true,
+        hasQuotaWarning: quotaResult.hasQuotaWarning,
+        method: quotaResult.method,
+        note: quotaResult.note,
+        debug: quotaResult
+      };
+    } catch (error) {
+      this.logger.log(`❌ Quota detection test failed for ${ide}: ${error.message}`);
+
+      return {
+        ide,
+        success: false,
+        error: error.message,
+        note: `Quota detection test failed for ${ide}`
+      };
+    }
+  }
+}

package/src/ide-integration/windows-automation-manager.js

@@ -0,0 +1,262 @@
+// @vibecodingmachine/core - Windows Automation Manager
+// Handles Windows-specific automation for IDE interactions
+
+const { execSync, spawn } = require('child_process');
+const AppleScriptUtils = require('./applescript-utils');
+const { writeFileSync, unlinkSync } = require('fs');
+const { join } = require('path');
+const { tmpdir } = require('os');
+
+/**
+ * Windows Automation Manager for IDE interactions
+ * Handles Windows-specific automation for IDEs like Cursor using PowerShell and Windows API
+ */
+class WindowsAutomationManager {
+  constructor() {
+    this.logger = console;
+    this.appleScriptUtils = new AppleScriptUtils();
+  }
+
+  /**
+   * Send text to Cursor on Windows using PowerShell automation
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendTextToCursor(text) {
+    try {
+      this.logger.log('🔧 Windows: Sending text to Cursor using PowerShell automation...');
+
+      // Use shared PowerShell script for Cursor automation
+      const powershellScript = this.appleScriptUtils.generateWindowsAIPanelScript(text);
+
+      // Write PowerShell script to temporary file
+      const scriptPath = join(tmpdir(), 'cursor-automation.ps1');
+      writeFileSync(scriptPath, powershellScript, 'utf8');
+
+      try {
+        // Execute PowerShell script
+        const result = execSync(`powershell.exe -ExecutionPolicy Bypass -File "${scriptPath}"`, {
+          encoding: 'utf8',
+          timeout: 10000,
+          stdio: 'pipe'
+        });
+
+        // Clean up script file
+        unlinkSync(scriptPath);
+
+        if (result.includes('SUCCESS')) {
+          this.logger.log('✅ Windows: Successfully sent text to Cursor');
+          return {
+            success: true,
+            message: 'Message sent to Cursor via Windows automation',
+            method: 'windows-automation'
+          };
+        } else {
+          throw new Error(result);
+        }
+      } catch (error) {
+        // Clean up script file on error
+        try { unlinkSync(scriptPath); } catch (_) {}
+        throw error;
+      }
+    } catch (error) {
+      this.logger.error('❌ Windows: Error sending text to Cursor:', error.message);
+      return {
+        success: false,
+        error: `Windows automation error: ${error.message}`,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Alternative method using Windows API via Node.js native module
+   * This is a more robust approach but requires additional dependencies
+   */
+  async sendTextToCursorNative(text) {
+    try {
+      this.logger.log('🔧 Windows: Attempting native Windows API approach...');
+
+      // This would require a native module like 'robotjs' or 'nut-js'
+      // For now, we'll use a simpler approach with PowerShell
+
+      const powershellScript = `
+# Alternative Windows Cursor Automation using Windows API
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public class Win32 {
+    [DllImport("user32.dll")]
+    public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
+
+    [DllImport("user32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+
+    [DllImport("user32.dll")]
+    public static extern bool IsWindowVisible(IntPtr hWnd);
+
+    public const int SW_RESTORE = 9;
+}
+"@
+
+Add-Type -AssemblyName System.Windows.Forms
+
+try {
+    # Find Cursor window by process name
+    $cursorProcesses = Get-Process | Where-Object {
+        $_.ProcessName -like "*cursor*" -and $_.MainWindowHandle -ne [IntPtr]::Zero
+    }
+
+    if ($cursorProcesses.Count -eq 0) {
+        Write-Output "ERROR: No Cursor windows found"
+        exit 1
+    }
+
+    $cursorWindow = $cursorProcesses[0].MainWindowHandle
+    Write-Output "Found Cursor window handle: $cursorWindow"
+
+    # Bring window to foreground
+    [Win32]::ShowWindow($cursorWindow, [Win32]::SW_RESTORE)
+    [Win32]::SetForegroundWindow($cursorWindow)
+    Start-Sleep -Milliseconds 500
+
+    # AI Panel Focus Strategy - same as basic PowerShell approach
+    # Step 1: Open Command Palette (Ctrl+Shift+P on Windows)
+    [System.Windows.Forms.SendKeys]::SendWait("^+p")
+    Start-Sleep -Milliseconds 500
+
+    # Step 2: Type "View: Focus into Secondary Side Bar"
+    [System.Windows.Forms.SendKeys]::SendWait("View: Focus into Secondary Side Bar")
+    Start-Sleep -Milliseconds 500
+
+    # Step 3: Press Enter to focus AI Panel
+    [System.Windows.Forms.SendKeys]::SendWait("{ENTER}")
+    Start-Sleep -Milliseconds 1500
+
+    # Step 4: 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 5: Type the message
+    [System.Windows.Forms.SendKeys]::SendWait("${text.replace(/"/g, '""')}")
+    Start-Sleep -Milliseconds 500
+
+    # Step 6: Send with Ctrl+Enter (standard for chat interfaces)
+    [System.Windows.Forms.SendKeys]::SendWait("^{ENTER}")
+    Start-Sleep -Milliseconds 1000
+
+    Write-Output "SUCCESS: Message sent via Windows API"
+    exit 0
+
+} catch {
+    Write-Output "ERROR: $($_.Exception.Message)"
+    exit 1
+}
+      `;
+
+      const scriptPath = join(tmpdir(), 'cursor-native-automation.ps1');
+      writeFileSync(scriptPath, powershellScript, 'utf8');
+
+      try {
+        const result = execSync(`powershell.exe -ExecutionPolicy Bypass -File "${scriptPath}"`, {
+          encoding: 'utf8',
+          timeout: 10000,
+          stdio: 'pipe'
+        });
+
+        unlinkSync(scriptPath);
+
+        if (result.includes('SUCCESS')) {
+          return {
+            success: true,
+            message: 'Message sent to Cursor via Windows API',
+            method: 'windows-native'
+          };
+        } else {
+          throw new Error(result);
+        }
+      } catch (error) {
+        try { unlinkSync(scriptPath); } catch (_) {}
+        throw error;
+      }
+    } catch (error) {
+      this.logger.error('❌ Windows: Native API error:', error.message);
+      return {
+        success: false,
+        error: `Windows native API error: ${error.message}`,
+        method: 'windows-native'
+      };
+    }
+  }
+
+  /**
+   * Open Cursor IDE on Windows
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openCursor(repoPath = null) {
+    try {
+      this.logger.log('🔧 Windows: Opening Cursor...');
+
+      let command = 'cursor';
+      if (repoPath) {
+        command += ` "${repoPath}"`;
+      }
+
+      // Try to open Cursor
+      execSync(command, { stdio: 'pipe' });
+
+      // Wait for Cursor to start
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      this.logger.log('✅ Windows: Cursor opened successfully');
+      return {
+        success: true,
+        message: repoPath ? `Cursor opened with repository: ${repoPath}` : 'Cursor opened successfully',
+        method: 'windows-command'
+      };
+    } catch (error) {
+      this.logger.error('❌ Windows: Error opening Cursor:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'windows-command'
+      };
+    }
+  }
+
+  /**
+   * Check if Cursor is running on Windows
+   * @returns {Promise<Object>} Result object with status
+   */
+  async isCursorRunning() {
+    try {
+      const result = execSync('tasklist /FI "IMAGENAME eq cursor.exe" /FO CSV', {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      });
+
+      const isRunning = result.includes('cursor.exe');
+      return {
+        success: true,
+        running: isRunning,
+        message: isRunning ? 'Cursor is running' : 'Cursor is not running'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        running: false,
+        error: error.message
+      };
+    }
+  }
+}
+
+module.exports = WindowsAutomationManager;

package/src/index.cjs

@@ -0,0 +1,43 @@
+// @vibecodingmachine/core - Main entry point (CommonJS)
+// This file exports all the core functionality for CommonJS environments
+
+const { CDPManager } = require('./ide-integration/cdp-manager.cjs');
+const { AppleScriptManager } = require('./ide-integration/applescript-manager.cjs');
+const { QuotaDetector } = require('./ide-integration/quota-detector.cjs');
+const { ClineCLIManager } = require('./ide-integration/cline-cli-manager.cjs');
+const { AiderCLIManager } = require('./ide-integration/aider-cli-manager.cjs');
+const ClaudeCodeCLIManager = require('./ide-integration/claude-code-cli-manager.cjs');
+const { runContinueCLICommand, runContinueCLIAutoMode } = require('./ide-integration/continue-cli-manager.js');
+const DirectLLMManager = require('./llm/direct-llm-manager.cjs');
+const { ChatManager } = require('./chat-management/chat-manager.cjs');
+const { FeatureImplementer } = require('./autonomous-mode/feature-implementer.cjs');
+const { logger } = require('./utils/logger.cjs');
+const repoHelpers = require('./utils/repo-helpers.cjs');
+const configHelpers = require('./utils/config-helpers.cjs');
+const auditLogger = require('./utils/audit-logger.cjs');
+const { GCloudAuth } = require('./utils/gcloud-auth.cjs');
+const requirementHelpers = require('./utils/requirement-helpers.js');
+const updateChecker = require('./utils/update-checker.js');
+const electronUpdateChecker = require('./utils/electron-update-checker.js');
+
+module.exports = {
+  CDPManager,
+  AppleScriptManager,
+  QuotaDetector,
+  ClineCLIManager,
+  AiderCLIManager,
+  ClaudeCodeCLIManager,
+  runContinueCLICommand,
+  runContinueCLIAutoMode,
+  DirectLLMManager,
+  ChatManager,
+  FeatureImplementer,
+  logger,
+  GCloudAuth,
+  ...repoHelpers,
+  ...configHelpers,
+  ...auditLogger,
+  ...requirementHelpers,
+  ...updateChecker,
+  ...electronUpdateChecker
+};

package/src/index.js

@@ -0,0 +1,17 @@
+// @vibecodingmachine/core - Main entry point
+// This file exports all the core functionality
+
+export { CDPManager } from './ide-integration/cdp-manager.js';
+export { AppleScriptManager } from './ide-integration/applescript-manager.js';
+export { QuotaDetector } from './ide-integration/quota-detector.js';
+export * from './ide-integration/continue-cli-manager.js';
+export { ChatManager } from './chat-management/chat-manager.js';
+export { FeatureImplementer } from './autonomous-mode/feature-implementer.js';
+export { logger } from './utils/logger.js';
+export * from './utils/repo-helpers.js';
+export * from './utils/config-helpers.js';
+
+// UI Components
+export * from './ui/ButtonComponents.js';
+export * from './ui/StateManager.js';
+export { ChatInterface } from './ui/ChatInterface.js';