vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,373 @@
+// @vibecodingmachine/core - Windows IDE Manager
+// Windows-specific IDE operations using PowerShell automation
+
+/**
+ * Windows IDE Manager for PowerShell-based interactions
+ * Handles all Windows-specific IDE operations
+ */
+class WindowsIDEManager {
+  constructor(windowsManager) {
+    this.logger = console;
+    this.windowsManager = windowsManager;
+  }
+
+  /**
+   * Open IDE on Windows using PowerShell automation
+   * @param {string} ide - The IDE name
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openIDE(ide, repoPath = null) {
+    const ideLower = (ide || '').toLowerCase();
+
+    switch (ideLower) {
+      case 'cursor':
+        return await this.openCursor(repoPath);
+      case 'vscode':
+        return await this.openVSCode(repoPath);
+      case 'windsurf':
+        return await this.openWindsurf(repoPath);
+      default:
+        return {
+          success: false,
+          error: `Windows automation not implemented for IDE: ${ide}`,
+          method: 'windows-automation'
+        };
+    }
+  }
+
+  /**
+   * 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) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        method: 'windows-automation'
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Opening Cursor with repository: ${repoPath || 'default'}`);
+
+      // Try native Windows API approach first, then fallback to basic PowerShell
+      let result = await this.windowsManager.openCursorNative(repoPath);
+      if (!result.success) {
+        this.logger.log('🔧 Windows: Native approach failed, trying basic PowerShell...');
+        result = await this.windowsManager.openCursor(repoPath);
+      }
+      return result;
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error opening Cursor:`, error.message);
+      return {
+        success: false,
+        error: `Windows automation error: ${error.message}`,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Open VS Code IDE on Windows
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openVSCode(repoPath = null) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        method: 'windows-automation'
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Opening VS Code with repository: ${repoPath || 'default'}`);
+      return await this.windowsManager.openVSCode(repoPath);
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error opening VS Code:`, error.message);
+      return {
+        success: false,
+        error: `Windows automation error: ${error.message}`,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Open Windsurf IDE on Windows
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openWindsurf(repoPath = null) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        method: 'windows-automation'
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Opening Windsurf with repository: ${repoPath || 'default'}`);
+      return await this.windowsManager.openWindsurf(repoPath);
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error opening Windsurf:`, error.message);
+      return {
+        success: false,
+        error: `Windows automation error: ${error.message}`,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Send text to IDE on Windows using PowerShell automation
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name
+   * @param {string} repoPath - The repository path (optional, used for Claude)
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendText(text, ide, repoPath = null) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        method: 'windows-automation'
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Sending text to ${ide}...`);
+
+      switch (ide.toLowerCase()) {
+        case 'cursor':
+          // Try native Windows API approach first, then fallback to basic PowerShell
+          let result = await this.windowsManager.sendTextToCursorNative(text);
+          if (!result.success) {
+            this.logger.log('🔧 Windows: Native approach failed, trying basic PowerShell...');
+            result = await this.windowsManager.sendTextToCursor(text);
+          }
+          return result;
+
+        case 'vscode':
+        case 'windsurf':
+          // For now, use same approach as Cursor for other IDEs
+          return await this.windowsManager.sendTextToCursor(text);
+
+        default:
+          return {
+            success: false,
+            error: `Windows automation not implemented for IDE: ${ide}`,
+            method: 'windows-automation'
+          };
+      }
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error sending text to ${ide}:`, error.message);
+      return {
+        success: false,
+        error: `Windows automation error: ${error.message}`,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Check IDE status on Windows
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async checkIDEStatus(ide) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        running: false
+      };
+    }
+
+    try {
+      switch (ide.toLowerCase()) {
+        case 'cursor':
+          return await this.windowsManager.checkCursorStatus();
+        case 'vscode':
+          return await this.windowsManager.checkVSCodeStatus();
+        case 'windsurf':
+          return await this.windowsManager.checkWindsurfStatus();
+        default:
+          return {
+            success: false,
+            error: `Windows automation not implemented for IDE: ${ide}`,
+            running: false
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to check IDE status: ${error.message}`,
+        running: false
+      };
+    }
+  }
+
+  /**
+   * Read chat response from IDE on Windows
+   * @param {string} ide - The IDE name
+   * @returns {Promise<string>} The chat response text
+   */
+  async readChatResponse(ide) {
+    if (!this.windowsManager) {
+      return 'Error: Windows automation manager not available';
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Reading chat response from ${ide}...`);
+      return await this.windowsManager.readChatResponse(ide);
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error reading response from ${ide}:`, error.message);
+      return 'Error: Could not read response via Windows automation';
+    }
+  }
+
+  /**
+   * Close previous chat thread in IDE on Windows
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async closePreviousChatThread(ide) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        method: 'windows-automation'
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Closing previous chat thread in ${ide}...`);
+      return await this.windowsManager.closePreviousChatThread(ide);
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error closing chat thread in ${ide}:`, error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Send text with thread closure on Windows
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendTextWithThreadClosure(text, ide) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        method: 'windows-automation'
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Sending text with thread closure to ${ide}...`);
+
+      // First, try to close previous chat thread
+      const closeResult = await this.closePreviousChatThread(ide);
+
+      // Wait a moment for thread closure to complete
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      // Then send new message
+      const sendResult = await this.sendText(text, ide);
+
+      // Combine results
+      if (sendResult.success) {
+        return {
+          success: true,
+          message: sendResult.message,
+          method: sendResult.method,
+          threadClosure: closeResult.success ? 'Previous thread closed' : 'Thread closure failed',
+          warning: !closeResult.success ? `Failed to close previous thread: ${closeResult.error}` : undefined
+        };
+      } else {
+        return {
+          success: false,
+          error: sendResult.error,
+          method: sendResult.method,
+          threadClosure: closeResult.success ? 'Previous thread closed' : 'Thread closure failed'
+        };
+      }
+    } catch (error) {
+      this.logger.error(`❌ Windows: Failed to send text with thread closure to ${ide}:`, error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Check for continuation buttons on Windows
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result with continuation detected and button info
+   */
+  async checkForContinuationButtons(ide) {
+    if (!this.windowsManager) {
+      return {
+        continuationDetected: false,
+        error: 'Windows automation manager not available',
+        buttons: [],
+        texts: []
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Checking for continuation buttons in ${ide}...`);
+      return await this.windowsManager.checkForContinuationButtons(ide);
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error checking continuation buttons in ${ide}:`, error.message);
+      return {
+        continuationDetected: false,
+        error: error.message,
+        buttons: [],
+        texts: []
+      };
+    }
+  }
+
+  /**
+   * Click continuation button on Windows
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result of operation
+   */
+  async clickContinuationButton(ide) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        clicked: false
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Clicking continuation button in ${ide}...`);
+      return await this.windowsManager.clickContinuationButton(ide);
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error clicking continuation button in ${ide}:`, error.message);
+      return {
+        success: false,
+        clicked: false,
+        error: error.message
+      };
+    }
+  }
+}
+
+module.exports = WindowsIDEManager;

package/src/index.cjs

@@ -1,8 +1,8 @@
 // @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 CDPManager = require('./ide-integration/cdp-manager.cjs');
+const AppleScriptManager = require('./ide-integration/applescript-manager.cjs');
 const AppleScriptUtils = require('./ide-integration/applescript-utils.js');
 const WindowsAutomationManager = require('./ide-integration/windows-automation-manager.js');
 const { QuotaDetector } = require('./ide-integration/quota-detector.cjs');
@@ -31,6 +31,7 @@ const EnableAgentCommand = require('./commands/enable-agent');
 const DisableAgentCommand = require('./commands/disable-agent');
 const HelpCommand = require('./commands/help');
 const requirementHelpers = require('./utils/requirement-helpers.js');
+const currentRequirementManager = require('./utils/current-requirement-manager.js');
 const requirementsParser = require('./utils/requirements-parser.js');
 const requirementNumbering = require('./requirement-numbering.js');
 const specificationHelpers = require('./utils/specification-helpers.js');
@@ -53,8 +54,20 @@ const { IDEHealthTracker, MAX_RESPONSE_TIMES, CONSECUTIVE_FAILURE_THRESHOLD } =
 // Health Tracking (User Story 2)
 const { HealthReporter } = require('./health-tracking/health-reporter.js');
 
+// Timeout Management (User Story 3)
+const { TimeoutCalculator } = require('./timeout-management/timeout-calculator.js');
+const { TimeoutConfigManager } = require('./timeout-management/timeout-config-manager.js');
+const { ResponseTimeTracker } = require('./timeout-management/response-time-tracker.js');
+
+// Requirement Management (User Story 5)
+const { RequirementFileParser } = require('./requirement-management/requirement-file-parser.js');
+const { DefaultRequirementManager } = require('./requirement-management/default-requirement-manager.js');
+
 // Provider Registry
 const providerRegistry = require('./provider-registry.js');
+const ProviderManager = require('./ide-integration/provider-manager.cjs');
+const AutoModeBusinessLogic = require('./auto-mode/AutoModeBusinessLogic.js');
+const { getCurrentRequirementName } = require('./utils/current-requirement-manager.js');
 
 module.exports = {
   CDPManager,
@@ -77,6 +90,7 @@ module.exports = {
   ...configHelpers,
   ...auditLogger,
   ...requirementHelpers,
+  ...currentRequirementManager,
   ...requirementsParser,
   ...requirementNumbering,
   ...specificationHelpers,
@@ -110,5 +124,13 @@ module.exports = {
   MAX_RESPONSE_TIMES,
   CONSECUTIVE_FAILURE_THRESHOLD,
   HealthReporter,
-  ...providerRegistry
+  TimeoutCalculator,
+  TimeoutConfigManager,
+  ResponseTimeTracker,
+  RequirementFileParser,
+  DefaultRequirementManager,
+  ProviderManager,
+  AutoModeBusinessLogic,
+  getCurrentRequirementName,
+  providerRegistry
 };

package/src/index.js

@@ -1,6 +1,7 @@
 // @vibecodingmachine/core - Main entry point
 // This file exports all the core functionality
 
+import { AppleScriptManager } from './ide-integration/applescript-manager.js';
 export { CDPManager } from './ide-integration/cdp-manager.js';
 export { AppleScriptManager } from './ide-integration/applescript-manager.js';
 export { QuotaDetector } from './ide-integration/quota-detector.js';
@@ -41,7 +42,7 @@ export {
 };
 
 // Compliance
-const CompliancePrompt = require('./compliance/compliance-prompt.js');
+import CompliancePrompt from './compliance/compliance-prompt.js';
 export { CompliancePrompt };
 
 // UI Components
@@ -71,5 +72,18 @@ export { IDEHealthTracker, MAX_RESPONSE_TIMES, CONSECUTIVE_FAILURE_THRESHOLD } f
 // Health Tracking (User Story 2)
 export { HealthReporter } from './health-tracking/health-reporter.js';
 
+// Timeout Management (User Story 3)
+export { TimeoutCalculator } from './timeout-management/timeout-calculator.js';
+export { TimeoutConfigManager } from './timeout-management/timeout-config-manager.js';
+export { ResponseTimeTracker } from './timeout-management/response-time-tracker.js';
+
+// Requirement Management (User Story 5)
+import { RequirementFileParser } from './requirement-management/requirement-file-parser.js';
+export { RequirementFileParser } from './requirement-management/requirement-file-parser.js';
+export { DefaultRequirementManager } from './requirement-management/default-requirement-manager.js';
+
 // Provider Registry
 export * from './provider-registry.js';
+
+// Current Requirement Management
+export { getCurrentRequirementName } from './utils/current-requirement-manager.js';

package/src/llm/direct-llm-manager.cjs

@@ -34,14 +34,15 @@ class DirectLLMManager {
     if (!this.providerManager) return;
 
     // Check for rate limit indicators
-    const isRateLimit = errorMessage.includes('rate limit') ||
+    const isRateLimit = (errorMessage.includes('rate limit') ||
       errorMessage.includes('Rate limit') ||
       errorMessage.includes('too many requests') ||
       errorMessage.includes('429') ||
       errorMessage.includes('quota') ||
       errorMessage.includes('Weekly limit reached') ||
       errorMessage.includes('Daily limit reached') ||
-      errorMessage.includes('limit reached');
+      errorMessage.includes('limit reached')) &&
+      !errorMessage.startsWith('Quota limit reached'); // Don't re-mark our own internal exceeded messages
 
     if (isRateLimit) {
       this.providerManager.markRateLimited(provider, model, errorMessage);
@@ -547,6 +548,90 @@ class DirectLLMManager {
     });
   }
 
+  /**
+   * Call the OpenCode CLI with a prompt via -p flag
+   */
+  async callOpenCode(model, prompt, options = {}) {
+    const { onChunk, onComplete, onError } = options;
+    const { spawn } = require('child_process');
+    const path = require('path');
+    const os = require('os');
+
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      let errorOutput = '';
+
+      // Resolve opencode binary — check well-known path first
+      let cmd = 'opencode';
+      const knownPath = path.join(os.homedir(), '.opencode', 'bin', 'opencode');
+      try {
+        require('fs').accessSync(knownPath, require('fs').constants.X_OK);
+        cmd = knownPath;
+      } catch {
+        // fall back to PATH lookup
+      }
+
+      const opencode = spawn(cmd, ['-p', prompt], {
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+
+      opencode.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        fullResponse += chunk;
+        if (onChunk) onChunk(chunk);
+      });
+
+      opencode.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      opencode.on('close', (code) => {
+        if (code === 0) {
+          if (onComplete) onComplete(fullResponse);
+          resolve({ success: true, response: fullResponse });
+        } else {
+          const error = `OpenCode CLI exited with code ${code}: ${errorOutput}`;
+          if (onError) onError(error);
+          this.detectAndSaveRateLimit('opencode', 'opencode-cli', errorOutput);
+          resolve({ success: false, error });
+        }
+      });
+
+      opencode.on('error', (err) => {
+        const error = `Failed to start OpenCode CLI: ${err.message}`;
+        if (onError) onError(error);
+        resolve({ success: false, error });
+      });
+    });
+  }
+
+  /**
+   * Check if OpenCode CLI is available
+   * @returns {Promise<boolean>}
+   */
+  async isOpenCodeAvailable() {
+    const { spawn } = require('child_process');
+    const path = require('path');
+    const os = require('os');
+
+    // Try well-known path first, then fall back to PATH
+    let cmd = 'opencode';
+    const knownPath = path.join(os.homedir(), '.opencode', 'bin', 'opencode');
+    try {
+      require('fs').accessSync(knownPath, require('fs').constants.X_OK);
+      cmd = knownPath;
+    } catch {
+      // fall back to PATH lookup
+    }
+
+    return new Promise((resolve) => {
+      const proc = spawn(cmd, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('close', (code) => resolve(code === 0));
+      proc.on('error', () => resolve(false));
+      setTimeout(() => { proc.kill(); resolve(false); }, 5000);
+    });
+  }
+
   /**
    * Call any LLM provider
    * @param {Object} config - Provider configuration
@@ -598,6 +683,9 @@ class DirectLLMManager {
         case 'cline':
           result = await this.callCline(currentModel, prompt, options);
           break;
+        case 'opencode':
+          result = await this.callOpenCode(currentModel, prompt, options);
+          break;
         default:
           return { success: false, error: `Unknown provider: ${provider}` };
       }