vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

package/src/commands/auto-direct/ide-completion-waiter.js

@@ -0,0 +1,485 @@
+/**
+ * IDE Completion Waiter - Monitor IDE Agent Work Completion
+ *
+ * This module contains the waitForIdeCompletion function that monitors
+ * the requirements file for completion signals from IDE agents.
+ *
+ * @module ide-completion-waiter
+ */
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const chokidar = require('chokidar');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const {
+  QuotaDetector,
+  AppleScriptManager,
+  getRequirementsPath,
+  t
+} = vibecodingmachineCore;
+
+// These will be set by the parent module (iteration-handlers.js)
+let sharedProviderManager = null;
+let sharedHealthTracker = null;
+
+/**
+ * Initialize module with shared instances from parent
+ * @param {Object} deps - Dependencies object
+ * @param {Object} deps.providerManager - Shared ProviderManager instance
+ * @param {Object} deps.healthTracker - Shared IDEHealthTracker instance
+ */
+function initialize(deps) {
+  sharedProviderManager = deps.providerManager;
+  sharedHealthTracker = deps.healthTracker;
+}
+
+/**
+ * Wait for IDE agent to complete work by monitoring requirements file
+ * @param {string} repoPath - Repository path
+ * @param {string} requirementText - Requirement text to watch for
+ * @param {string} ideType - IDE type (e.g., 'antigravity') for quota limit handling
+ * @param {number} timeoutMs - Timeout in milliseconds (default: 30 minutes)
+ * @returns {Promise<{success: boolean, reason?: string}>}
+ */
+async function waitForIdeCompletion(repoPath, requirementText, ideType = '', timeoutMs = 30 * 60 * 1000) {
+  const reqPath = await getRequirementsPath(repoPath);
+
+  return new Promise(async (resolve) => {
+    let startTime = Date.now();
+    let lastCheckTime = Date.now();
+    let quotaHandled = false;
+    let lastQuotaCheckTime = 0; // Throttle quota checks to every 30 seconds
+    const checkIntervalMs = 2000; // Check every 2 seconds
+    const quotaCheckIntervalMs = 30000; // Check quota every 30 seconds
+
+    console.log(chalk.gray(`\n� ${t('auto.direct.ide.waiting')}`));
+    console.log(chalk.gray(`   ${t('auto.direct.ide.monitoring', { filename: path.basename(reqPath) })}`));
+    console.log(chalk.gray(`   ${t('auto.direct.ide.timeout', { minutes: Math.floor(timeoutMs / 60000) })}\n`));
+
+    const watcher = chokidar.watch(reqPath, {
+      persistent: true,
+      ignoreInitial: false
+    });
+
+    const checkCompletion = async () => {
+      try {
+        const content = await fs.readFile(reqPath, 'utf-8');
+        const lines = content.split('\n');
+
+        // Check 1: Is requirement in "Verified by AI" section?
+        let inVerifiedSection = false;
+        let foundInVerified = false;
+
+        for (const line of lines) {
+          if (line.includes('##  Verified by AI')) {
+            inVerifiedSection = true;
+            continue;
+          }
+
+          if (inVerifiedSection && line.startsWith('##') && !line.startsWith('###')) {
+            inVerifiedSection = false;
+            break;
+          }
+
+          if (inVerifiedSection && line.includes(requirementText)) {
+            foundInVerified = true;
+            break;
+          }
+        }
+
+        if (foundInVerified) {
+          watcher.close();
+          console.log(chalk.green(' IDE agent completed - requirement moved to Verified section\n'));
+          resolve({ success: true });
+          return;
+        }
+
+        // Check 2: Does status section contain "DONE"?
+        let inStatusSection = false;
+        let statusContainsDone = false;
+
+        for (const line of lines) {
+          if (line.includes('=� Current Status')) {
+            inStatusSection = true;
+            if (line.includes('DONE')) {
+              statusContainsDone = true;
+              break;
+            }
+            continue;
+          }
+
+          if (inStatusSection && line.startsWith('##') && !line.startsWith('###')) {
+            inStatusSection = false;
+            break;
+          }
+
+          if (inStatusSection && line.trim() === 'DONE') {
+            statusContainsDone = true;
+            break;
+          }
+        }
+
+        if (statusContainsDone) {
+          watcher.close();
+          console.log(chalk.green(' IDE agent completed - status marked as DONE\n'));
+          resolve({ success: true });
+          return;
+        }
+
+        // Check 3: Detect rate-limit messages written into the REQUIREMENTS file
+        // Examples:
+        //  - "You have reached the quota limit for this model. You can resume using this model at 1/19/2026, 4:07:27 PM."
+        //  - "Please try again in 15m5.472s"
+        //  - "Spending cap reached resets Jan 17 at 12pm"
+        //  - "Usage cap reached. Try again in 15 minutes."
+        //  - "You've reached your monthly chat messages quota" (GitHub Copilot)
+        //  - "Upgrade to Copilot Pro" (GitHub Copilot)
+        //  - "wait for your allowance to renew" (GitHub Copilot)
+        const rateLimitPattern = /(quota limit|you have reached( the)? quota|you can resume using this model at|please try again in|try again in|spending cap reached|usage cap( reached)?|you\'ve hit( the)? usage limit|you\u2019ve hit( the)? usage limit|cap reached|limit exceeded|exceeded (quota|limit)|monthly.*quota|upgrade to.*pro|allowance to renew|chat messages quota)/i;
+        // Avoid matching requirement headings or bullets (these may mention "rate limit" as part of the requirement text)
+        const matchedLine = lines.find(l => rateLimitPattern.test(l) && !l.trim().startsWith('###') && !l.trim().startsWith('-'));
+        if (matchedLine) {
+          // Mark the provider as rate limited (if we can) and signal a rate-limited completion
+          try {
+            if (ideType && sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+              sharedProviderManager.markRateLimited(ideType, undefined, matchedLine);
+            }
+          } catch (e) {
+            // Ignore errors from marking rate-limited
+          }
+
+          watcher.close();
+          console.log(chalk.yellow(`\n�  Rate limit message detected from IDE: ${matchedLine}\n`));
+          // Return a generic rateLimited flag and include the matched line for diagnostics
+          resolve({ success: false, rateLimited: true, providerRateLimited: ideType || undefined, matchedLine });
+          return;
+        }
+
+        // Check 4: Active quota detection (throttled to every 30 seconds)
+        // For Kiro: ONLY AppleScript (CDP doesn't work with webviews)
+        // For others: CDP only
+        const now = Date.now();
+        if (!quotaHandled && ideType && (now - lastQuotaCheckTime >= quotaCheckIntervalMs)) {
+          lastQuotaCheckTime = now;
+
+          try {
+            // For Kiro: ONLY AppleScript detection (CDP doesn't work)
+            if (ideType === 'kiro' || ideType === 'amazon-q') {
+              try {
+                const appleScriptManager = new AppleScriptManager();
+                const screenshotResult = await appleScriptManager.detectQuotaWarning('kiro');
+
+                if (screenshotResult && screenshotResult.hasQuotaWarning) {
+                  quotaHandled = true;
+                  const quotaMessage = screenshotResult.matchedText || screenshotResult.note || 'Kiro quota limit detected via AppleScript';
+
+                  // Mark the provider as rate limited
+                  try {
+                    if (sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+                      sharedProviderManager.markRateLimited(ideType, undefined, quotaMessage);
+                    }
+                  } catch (e) {
+                    // Ignore errors from marking rate-limited
+                  }
+
+                  watcher.close();
+                  console.log(chalk.yellow(`\n�  Quota warning detected via AppleScript for Kiro: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, kiroRateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
+                }
+              } catch (screenshotError) {
+                console.log(chalk.red(`L AppleScript quota detection failed for Kiro: ${screenshotError.message}`));
+              }
+            }
+            // For Antigravity: AppleScript quota detection
+            else if (ideType === 'antigravity') {
+              try {
+                const appleScriptManager = new AppleScriptManager();
+                const antigravityQuotaResult = await appleScriptManager.checkAntigravityQuotaLimit();
+
+                if (antigravityQuotaResult && antigravityQuotaResult.isRateLimited) {
+                  quotaHandled = true;
+                  const quotaMessage = antigravityQuotaResult.message || 'Antigravity quota limit detected via AppleScript';
+
+                  // Mark the provider as rate limited
+                  try {
+                    if (sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+                      sharedProviderManager.markRateLimited(ideType, undefined, quotaMessage);
+                    }
+                  } catch (e) {
+                    // Ignore errors from marking rate-limited
+                  }
+
+                  watcher.close();
+                  console.log(chalk.yellow(`\n�  Quota warning detected via AppleScript for Antigravity: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, antigravityRateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
+                }
+              } catch (appleScriptError) {
+                console.log(chalk.red(`L AppleScript quota detection failed for Antigravity: ${appleScriptError.message}`));
+              }
+            }
+            // For Devin: quota detection
+            else if (ideType === 'devin') {
+              try {
+                const appleScriptManager = new AppleScriptManager();
+                const devinQuotaResult = await appleScriptManager.checkDevinRateLimit?.();
+
+                if (devinQuotaResult && devinQuotaResult.hasQuotaWarning) {
+                  quotaHandled = true;
+                  const quotaMessage = devinQuotaResult.matchedText || 'Devin quota limit detected';
+
+                  // Mark the provider as rate limited
+                  try {
+                    if (sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+                      sharedProviderManager.markRateLimited(ideType, undefined, quotaMessage);
+                    }
+                  } catch (e) {
+                    // Ignore errors from marking rate-limited
+                  }
+
+                  watcher.close();
+                  console.log(chalk.yellow(`\n⚠️  Devin quota warning detected: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, devinRateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
+                }
+              } catch (devinQuotaError) {
+                console.log(chalk.red(`L Quota detection failed for Devin: ${devinQuotaError.message}`));
+              }
+            }
+            // For Cursor: Skip CDP and go directly to AppleScript
+            else if (ideType === 'cursor') {
+              try {
+                const appleScriptManager = new AppleScriptManager();
+                const cursorQuotaResult = await appleScriptManager.checkCursorQuotaLimit();
+
+                if (cursorQuotaResult && cursorQuotaResult.isRateLimited) {
+                  quotaHandled = true;
+                  const quotaMessage = cursorQuotaResult.message || 'Cursor quota limit detected via AppleScript';
+
+                  // Mark the provider as rate limited
+                  try {
+                    if (sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+                      sharedProviderManager.markRateLimited(ideType, undefined, quotaMessage);
+                    }
+                  } catch (e) {
+                    // Ignore errors from marking rate-limited
+                  }
+
+                  watcher.close();
+                  console.log(chalk.yellow(`\n�  Quota warning detected via AppleScript for Cursor: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
+                }
+              } catch (appleScriptError) {
+                console.log(chalk.red(`L AppleScript quota detection failed for Cursor: ${appleScriptError.message}`));
+              }
+            }
+            // For other IDEs: use CDP
+            else if (ideType === 'vscode' || ideType === 'github-copilot' || ideType === 'amazon-q') {
+              const quotaDetector = new QuotaDetector();
+              const ideToCheck = ideType === 'github-copilot' || ideType === 'amazon-q' ? 'vscode' : ideType;
+
+              try {
+                const quotaResult = await quotaDetector.detectQuotaWarning(ideToCheck);
+
+                if (quotaResult && quotaResult.hasQuotaWarning) {
+                  quotaHandled = true;
+                  const quotaMessage = quotaResult.matchedText || 'Quota limit detected in IDE UI';
+
+                  // Check if this might be Kiro quota warning even when ideType is amazon-q
+                  const isKiroPattern = quotaMessage.toLowerCase().includes('out of credits') ||
+                    quotaMessage.toLowerCase().includes('upgrade plan') ||
+                    quotaMessage.toLowerCase().includes('monthly usage limit');
+
+                  // Mark the provider as rate limited
+                  try {
+                    if (sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+                      sharedProviderManager.markRateLimited(ideType, undefined, quotaMessage);
+                    }
+                  } catch (e) {
+                    // Ignore errors from marking rate-limited
+                  }
+
+                  watcher.close();
+                  console.log(chalk.yellow(`\n�  Quota warning detected via CDP in ${ideToCheck} UI: ${quotaMessage.substring(0, 100)}...\n`));
+
+                  // If this looks like Kiro quota, set kiroRateLimited flag too
+                  const resolveObj = {
+                    success: false,
+                    rateLimited: true,
+                    providerRateLimited: ideType,
+                    matchedLine: quotaMessage
+                  };
+
+                  if (ideType === 'amazon-q' && isKiroPattern) {
+                    resolveObj.kiroRateLimited = true;
+                    console.log(chalk.magenta(`=� Detected potential Kiro quota warning despite amazon-q ideType`));
+                  }
+
+                  resolve(resolveObj);
+                  return;
+                }
+              } catch (cdpError) {
+                console.log(chalk.yellow(`� CDP quota detection failed for ${ideToCheck}: ${cdpError.message}`));
+              }
+            }
+          } catch (quotaError) {
+            console.log(chalk.red(`L [DEBUG] Quota detection check failed: ${quotaError.message}`));
+            console.log(chalk.gray(`   Stack: ${quotaError.stack}`));
+          }
+        }
+
+        // Check 5: Continuation detection (check every 2 seconds)
+        const elapsed = Date.now() - startTime;
+        if (elapsed > 30000 && elapsed % 2000 < 2000) { // Start checking after 30 seconds, every 2 seconds
+          try {
+            let continuationDetected = false;
+            let continuationClicked = false;
+
+            // Use CDP for web-based IDEs
+            if (ideType === 'vscode' || ideType === 'cursor' || ideType === 'devin') {
+              const { CDPManager } = require('vibecodingmachine-core');
+              const cdpManager = new CDPManager();
+
+              try {
+                const continuationResult = await cdpManager.checkForContinuation(ideType);
+                if (continuationResult.continuationDetected) {
+                  console.log(chalk.yellow(`= Continuation prompt detected in ${ideType}, clicking button...`));
+                  const clickResult = await cdpManager.clickContinuationButton(ideType);
+                  if (clickResult.success && clickResult.clicked) {
+                    continuationDetected = true;
+                    continuationClicked = true;
+                    console.log(chalk.green(` Continuation button clicked successfully`));
+                  } else {
+                    console.log(chalk.yellow(`�  Failed to click continuation button: ${clickResult.message || 'Unknown error'}`));
+                  }
+                }
+              } catch (cdpError) {
+                console.log(chalk.gray(`   Continuation detection via CDP failed: ${cdpError.message}`));
+              }
+            }
+            // Use AppleScript for desktop IDEs
+            else if (ideType === 'cline' || ideType === 'claude-code') {
+              const { AppleScriptManager } = require('vibecodingmachine-core');
+              const appleScriptManager = new AppleScriptManager();
+
+              try {
+                const continuationResult = await appleScriptManager.checkForContinuation(ideType);
+                if (continuationResult.continuationDetected) {
+                  console.log(chalk.yellow(`= Continuation prompt detected in ${ideType}, clicking button...`));
+                  const clickResult = await appleScriptManager.clickContinuationButton(ideType);
+                  if (clickResult.success && clickResult.clicked) {
+                    continuationDetected = true;
+                    continuationClicked = true;
+                    console.log(chalk.green(` Continuation button clicked successfully`));
+                  } else {
+                    console.log(chalk.yellow(`�  Failed to click continuation button: ${clickResult.error || 'Unknown error'}`));
+                  }
+                }
+              } catch (appleScriptError) {
+                console.log(chalk.gray(`   Continuation detection via AppleScript failed: ${appleScriptError.message}`));
+              }
+            }
+
+            // Record continuation detection in health tracker
+            if (continuationDetected) {
+              try {
+                // Update the interaction record to include continuation detection
+                const currentMetrics = sharedHealthTracker.getHealthMetrics(ideType);
+                if (currentMetrics && currentMetrics.interactions && currentMetrics.interactions.length > 0) {
+                  const lastInteraction = currentMetrics.interactions[currentMetrics.interactions.length - 1];
+                  lastInteraction.continuationPromptsDetected = (lastInteraction.continuationPromptsDetected || 0) + 1;
+                }
+              } catch (trackerError) {
+                console.log(chalk.gray(`   Failed to record continuation detection: ${trackerError.message}`));
+              }
+            }
+          } catch (error) {
+            console.log(chalk.gray(`   Continuation detection error: ${error.message}`));
+          }
+        }
+
+        // Check 6: Timeout
+        if (elapsed >= timeoutMs) {
+          watcher.close();
+          console.log(chalk.yellow(`\n�  Timeout after ${Math.floor(elapsed / 60000)} minutes\n`));
+          resolve({ success: false, reason: 'timeout' });
+          return;
+        }
+
+        // Check 7: Text pattern matching fallback for continuation prompts
+        const fileContent = await fs.readFile(reqPath, 'utf-8');
+        const continuationPatterns = [
+          /continue.*generation/i,
+          /keep.*going/i,
+          /continue.*writing/i,
+          /continue.*coding/i,
+          /proceed/i,
+          /next.*step/i,
+          /continue/i
+        ];
+
+        const hasContinuationPrompt = continuationPatterns.some(pattern => pattern.test(fileContent));
+        if (hasContinuationPrompt && elapsed > 30000) { // Only check for text patterns after 30 seconds
+          console.log(chalk.yellow(`= Continuation prompt detected in text, attempting to continue...`));
+          // This is a fallback - we can't click buttons via text patterns, but we can log it
+          try {
+            const currentMetrics = sharedHealthTracker.getHealthMetrics(ideType);
+            if (currentMetrics && currentMetrics.interactions && currentMetrics.interactions.length > 0) {
+              const lastInteraction = currentMetrics.interactions[currentMetrics.interactions.length - 1];
+              lastInteraction.continuationPromptsDetected = (lastInteraction.continuationPromptsDetected || 0) + 1;
+            }
+          } catch (trackerError) {
+            console.log(chalk.gray(`   Failed to record text continuation detection: ${trackerError.message}`));
+          }
+        }
+        // Check 8: Memory monitoring
+        if (elapsed > 60000 && elapsed % 30000 < 30000) { // Check memory every 30 seconds after 1 minute
+          const memoryUsage = process.memoryUsage();
+          const heapUsedMB = Math.round(memoryUsage.heapUsed / 1024 / 1024);
+          const heapTotalMB = Math.round(memoryUsage.heapTotal / 1024 / 1024);
+          const heapUsedPercent = Math.round((memoryUsage.heapUsed / memoryUsage.heapTotal) * 100);
+
+          if (heapUsedMB > 500) { // Warn at 500MB
+            console.log(chalk.yellow(`�  High memory usage detected: ${heapUsedMB}MB heap (${heapUsedPercent}% of ${heapTotalMB}MB)`));
+            console.log(chalk.gray(`   RSS: ${Math.round(memoryUsage.rss / 1024 / 1024)}MB, External: ${Math.round(memoryUsage.external / 1024 / 1024)}MB`));
+          }
+        }
+
+        // Log progress every 30 seconds
+        if (Date.now() - lastCheckTime >= 30000) {
+          const elapsedMin = Math.floor(elapsed / 60000);
+          const remainingMin = Math.floor((timeoutMs - elapsed) / 60000);
+          console.log(chalk.gray(`   ${t('auto.direct.ide.still.waiting', { elapsed: elapsedMin, remaining: remainingMin })}`));
+          lastCheckTime = Date.now();
+        }
+      } catch (error) {
+        console.error(chalk.red(`Error checking completion: ${error.message}`));
+      }
+    };
+
+    // Check on file changes
+    watcher.on('change', () => {
+      checkCompletion();
+    });
+
+    // Also check periodically in case file watcher misses changes
+    const interval = setInterval(() => {
+      checkCompletion();
+    }, checkIntervalMs);
+
+    // Clean up interval when promise resolves
+    const originalResolve = resolve;
+    resolve = (result) => {
+      clearInterval(interval);
+      originalResolve(result);
+    };
+
+    // Initial check
+    checkCompletion();
+  });
+}
+
+module.exports = { waitForIdeCompletion, initialize };