vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

package/src/commands/auto-direct/ide-fallback-runner.js

@@ -0,0 +1,226 @@
+/**
+ * IDE Fallback Runner - Direct IDE Iteration Handler
+ *
+ * Extracted from iteration-handlers.js for constitutional compliance (<555 lines per file)
+ * Handles IDE fallback iterations (no context gathering, direct IDE spawn).
+ */
+
+const chalk = require('chalk');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const { TimeoutCalculator, t } = vibecodingmachineCore;
+
+// Import auto mode utilities
+const { handleAntigravityRateLimit } = require('../../utils/antigravity-js-handler');
+const { handleKiroRateLimit } = require('../../utils/kiro-js-handler');
+const { handleClineRateLimit } = require('../../utils/cline-js-handler');
+
+// Import modular functions
+const {
+  updateRequirementsStatus,
+  moveRequirementToVerify
+} = require('./requirement-manager');
+
+const {
+  printStatusCard
+} = require('./status-display');
+
+// Import split module functions
+const { waitForIdeCompletion } = require('./ide-completion-waiter');
+const { runIdeProviderIteration } = require('./ide-provider-runner');
+
+// Shared variables set by parent module
+let sharedProviderManager = null;
+let sharedHealthTracker = null;
+
+/**
+ * Initialize module with shared instances
+ */
+function initialize(deps) {
+  sharedProviderManager = deps.providerManager;
+  sharedHealthTracker = deps.healthTracker;
+}
+
+/**
+ * Run an IDE fallback iteration (no context gathering, direct IDE spawn)
+ * @param {Object} requirement - Requirement object
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ * @param {Object} providerManager - Provider manager instance
+ * @param {Object} llm - DirectLLMManager instance
+ * @param {number} startTime - Start time timestamp
+ * @returns {Promise<{success: boolean, error?: string, shouldRetry?: boolean}>}
+ */
+async function runIdeFallbackIteration(requirement, providerConfig, repoPath, providerManager, llm, startTime) {
+  // Update console and requirements file with PREPARE status
+  printStatusCard(requirement.text, 'PREPARE', 'active');
+  await updateRequirementsStatus(repoPath, 'PREPARE');
+  console.log(chalk.gray(`${t('auto.direct.ide.skipping.context')}\n`));
+
+  // Update console and requirements file with ACT status
+  printStatusCard(requirement.text, 'ACT', 'active');
+  await updateRequirementsStatus(repoPath, 'ACT');
+  const ideResult = await runIdeProviderIteration(providerConfig, repoPath);
+
+  if (!ideResult.success) {
+    if (ideResult.antigravityRateLimited) {
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+      const switchResult = await handleAntigravityRateLimit();
+      if (switchResult && switchResult.modelSwitched) {
+        return { success: false, error: `Antigravity switched to ${switchResult.nextModel}, retrying.`, shouldRetry: true };
+      }
+      return { success: false, error: 'Antigravity rate limit reached, retrying with next provider.', shouldRetry: true };
+    }
+
+    // CRITICAL: Mark provider as unavailable for ANY error so acquireProviderConfig() will skip it
+    // EXCEPT for web-based IDEs where the error is platform/browser related
+    const error = ideResult.output || ideResult.error || 'IDE provider failed';
+    const isWebBasedIDE = providerConfig.provider === 'replit';
+    const isPlatformError = error.includes('xdg-open') || error.includes('command not found') || error.includes('Unable to find application');
+
+    if (!isWebBasedIDE || !isPlatformError) {
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, error);
+    } else {
+      // For web-based IDEs with platform errors, don't mark as rate limited
+      // Just log the error and let the system try the next provider
+      console.log(chalk.yellow(`⚠  Web-based IDE ${providerConfig.provider} failed due to platform issue: ${error}`));
+    }
+
+    return { success: false, error: ideResult.error || 'IDE provider failed' };
+  }
+
+  console.log(chalk.green(`✓ ${t('auto.direct.ide.prompt.sent')}`));
+
+  // Calculate adaptive timeout based on IDE's historical performance
+  const ideType = providerConfig.provider || providerConfig.ide;
+  const healthMetrics = sharedHealthTracker.getHealthMetrics(ideType);
+  let adaptiveTimeoutMs = 30 * 60 * 1000; // Default 30 minutes
+
+  if (healthMetrics && healthMetrics.responseTimes.length > 0) {
+    // Use adaptive timeout calculation if we have historical data
+    const stats = TimeoutCalculator.calculateTimeout(healthMetrics.responseTimes, {
+      defaultTimeout: 30 * 60 * 1000,
+      minTimeout: 5 * 60 * 1000, // 5 minutes minimum
+      maxTimeout: 60 * 60 * 1000, // 60 minutes maximum
+      bufferPercentage: 0.5 // 50% buffer
+    });
+    adaptiveTimeoutMs = stats.timeout;
+    console.log(chalk.gray(`   Using adaptive timeout: ${Math.floor(adaptiveTimeoutMs / 60000)} minutes (based on ${healthMetrics.responseTimes.length} historical response times)`));
+  } else {
+    console.log(chalk.gray(`   Using default timeout: ${Math.floor(adaptiveTimeoutMs / 60000)} minutes (no historical data for ${ideType})`));
+  }
+
+  // Wait for IDE agent to complete the work (IDE will update status to DONE itself)
+  const ideCompletionStartTime = Date.now();
+  const completionResult = await waitForIdeCompletion(repoPath, requirement.text, ideType, adaptiveTimeoutMs);
+  const ideResponseTime = Date.now() - ideCompletionStartTime;
+
+  // Track IDE health metrics based on completion result
+  if (completionResult.success) {
+    // Record success with response time
+    await sharedHealthTracker.recordSuccess(ideType, ideResponseTime, {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+      continuationPromptsDetected: 0, // Will be updated when continuation detection is implemented
+    });
+  } else if (completionResult.rateLimited) {
+    // Record quota event (does NOT increment success/failure counters per FR-008)
+    await sharedHealthTracker.recordQuota(ideType, completionResult.matchedLine || 'Quota limit detected', {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+    });
+  } else if (completionResult.reason === 'timeout') {
+    // Record failure due to timeout
+    await sharedHealthTracker.recordFailure(ideType, 'Timeout exceeded', {
+      timeoutUsed: adaptiveTimeoutMs, // Use the adaptive timeout that was actually used
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+    });
+  } else {
+    // Record other failure
+    await sharedHealthTracker.recordFailure(ideType, completionResult.error || 'Unknown error', {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+    });
+  }
+
+  if (!completionResult.success) {
+    // Special-case behavior for Antigravity CLI installs (they have special handling)
+    if (completionResult.antigravityRateLimited) {
+      console.log(chalk.yellow(`⚠  ${t('auto.direct.provider.quota.exhausted', { provider: 'Antigravity' })}\n`));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+
+      const switchResult = await handleAntigravityRateLimit();
+      if (switchResult && switchResult.modelSwitched) {
+        return { success: false, error: `Antigravity switched to ${switchResult.nextModel}, retrying.`, shouldRetry: true };
+      }
+
+      return { success: false, error: 'Antigravity quota limit', shouldRetry: true };
+    }
+
+    // Special-case behavior for Kiro IDE (they have special handling)
+    if (completionResult.kiroRateLimited) {
+      console.log(chalk.yellow(`⚠  ${t('auto.direct.provider.quota.exhausted', { provider: 'AWS Kiro' })}\n`));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+
+      const switchResult = await handleKiroRateLimit();
+      if (switchResult && switchResult.success) {
+        return { success: false, error: `AWS Kiro switched to ${switchResult.nextProvider}, retrying.`, shouldRetry: true };
+      }
+
+      return { success: false, error: 'AWS Kiro quota limit', shouldRetry: true };
+    }
+
+    // Special-case behavior for Cline IDE
+    if (completionResult.clineRateLimited) {
+      console.log(chalk.yellow(`⚠  ${t('auto.direct.provider.quota.exhausted', { provider: 'Cline' })}\n`));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+
+      const switchResult = await handleClineRateLimit();
+      if (switchResult && switchResult.success) {
+        return { success: false, error: `Cline switched to ${switchResult.nextProvider}, retrying.`, shouldRetry: true };
+      }
+
+      return { success: false, error: 'Cline quota limit', shouldRetry: true };
+    }
+
+    // Generic rate-limited behavior: if the completion detected a rate-limited message in REQUIREMENTS,
+    // mark the provider as rate-limited and retry with the next available provider.
+    if (completionResult.rateLimited) {
+      console.log(chalk.yellow(`⚠  Provider ${providerConfig.provider} reported quota/exhaustion: ${completionResult.matchedLine || ''}\n`));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, completionResult.matchedLine || 'Quota limit detected');
+      return { success: false, error: 'Provider quota limit', shouldRetry: true };
+    }
+
+    const errorMsg = completionResult.reason === 'timeout'
+      ? 'IDE agent timed out'
+      : 'IDE agent failed to complete';
+    providerManager.markRateLimited(providerConfig.provider, providerConfig.model, errorMsg);
+
+    // Automatically retry with next IDE on timeout (T024: automatic IDE switching)
+    if (completionResult.reason === 'timeout') {
+      console.log(chalk.yellow(`⏱ Timeout detected - switching to next available IDE\n`));
+      return { success: false, error: errorMsg, shouldRetry: true };
+    }
+
+    return { success: false, error: errorMsg };
+  }
+
+  printStatusCard(requirement.text, 'VERIFY', 'active');
+  console.log(chalk.green(`✓ ${t('auto.direct.provider.completed')}\n`));
+
+  printStatusCard(requirement.text, 'DONE', 'active');
+  const duration = Date.now() - startTime;
+  providerManager.recordPerformance(providerConfig.provider, providerConfig.model, duration);
+
+  const moved = await moveRequirementToVerify(repoPath, requirement.text);
+  if (moved) {
+    console.log(chalk.green(`✓ ${t('auto.direct.status.verification.pending')}`));
+  }
+
+  console.log();
+  console.log(chalk.gray(' '.repeat(80)));
+  console.log();
+
+  return { success: true, changes: [] };
+}
+
+module.exports = {
+  initialize,
+  runIdeFallbackIteration
+};

package/src/commands/auto-direct/ide-provider-runner.js

@@ -0,0 +1,103 @@
+/**
+ * IDE Provider Runner - IDE Provider Iteration Spawning
+ *
+ * Extracted from iteration-handlers.js for constitutional compliance (<555 lines per file)
+ * Handles spawning of IDE provider iterations via auto:start subprocess.
+ */
+
+const chalk = require('chalk');
+const { spawn } = require('child_process');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const { t } = vibecodingmachineCore;
+
+// Import auto mode utilities
+const { checkAntigravityRateLimit } = require('../../utils/antigravity-js-handler');
+const { checkKiroRateLimit } = require('../../utils/kiro-js-handler');
+const { checkClineRateLimit } = require('../../utils/cline-js-handler');
+
+// Import modular functions
+const { isRateLimitMessage } = require('./utils');
+
+// Shared variables set by parent module
+let CLI_ENTRY_POINT = null;
+
+/**
+ * Initialize module with shared instances
+ */
+function initialize(deps) {
+  CLI_ENTRY_POINT = deps.cliEntryPoint;
+}
+
+/**
+ * Run an IDE provider iteration by spawning auto:start subprocess
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{success: boolean, error?: string, output?: string, rateLimited?: boolean}>}
+ */
+async function runIdeProviderIteration(providerConfig, repoPath) {
+  return new Promise((resolve) => {
+    console.log(chalk.cyan(`🚀 ${t('auto.direct.provider.launching', { provider: providerConfig.displayName })}\n`));
+
+    const args = [CLI_ENTRY_POINT, 'auto:start', '--ide', providerConfig.ide || providerConfig.provider, '--max-chats', String(providerConfig.maxChats || 1)];
+    if (providerConfig.model) {
+      args.push('--ide-model', String(providerConfig.model));
+    }
+    // Pass extension information for VS Code extensions
+    if (providerConfig.extension) {
+      args.push('--extension', String(providerConfig.extension));
+    }
+    const child = spawn(process.execPath, args, {
+      cwd: repoPath,
+      env: process.env,
+      stdio: ['inherit', 'pipe', 'pipe']
+    });
+
+    let combinedOutput = '';
+
+    child.stdout.on('data', (data) => {
+      const text = data.toString();
+      combinedOutput += text;
+      process.stdout.write(text);
+    });
+
+    child.stderr.on('data', (data) => {
+      const text = data.toString();
+      combinedOutput += text;
+      process.stderr.write(text);
+    });
+
+    child.on('error', (error) => {
+      resolve({
+        success: false,
+        error: `Failed to start ${providerConfig.displayName}: ${error.message}`,
+        output: combinedOutput
+      });
+    });
+
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve({ success: true, output: combinedOutput });
+      } else {
+        const message = `${providerConfig.displayName} exited with code ${code}`;
+        const antigravityRateLimit = checkAntigravityRateLimit(combinedOutput);
+        const kiroRateLimit = checkKiroRateLimit(combinedOutput);
+        const clineRateLimit = checkClineRateLimit(combinedOutput);
+
+        resolve({
+          success: false,
+          error: combinedOutput ? `${message}\n${combinedOutput}` : message,
+          output: combinedOutput,
+          rateLimited: isRateLimitMessage(combinedOutput) || antigravityRateLimit.isRateLimited || kiroRateLimit.isRateLimited || clineRateLimit.isRateLimited,
+          antigravityRateLimited: antigravityRateLimit.isRateLimited,
+          kiroRateLimited: kiroRateLimit.isRateLimited,
+          clineRateLimited: clineRateLimit.isRateLimited
+        });
+      }
+    });
+  });
+}
+
+module.exports = {
+  initialize,
+  runIdeProviderIteration
+};

package/src/commands/auto-direct/iteration-handlers.js

@@ -0,0 +1,189 @@
+/**
+ * Iteration Handlers - IDE Provider Interaction Management
+ *
+ * This module contains functions for managing IDE provider iterations in autonomous mode.
+ * It handles IDE provider spawning, completion monitoring, fallback iteration logic,
+ * spec-based iterations, and the main iteration workflow.
+ *
+ * IMPORTANT: These functions require access to parent module functions:
+ * - countSpecCheckboxes() - Count done/total checkboxes in spec tasks.md
+ * - storedStatusTitle, storedStatus - Global status tracking variables
+ * - sharedProviderManager - Shared ProviderManager instance for rate limit tracking
+ * - sharedHealthTracker - Shared IDEHealthTracker instance for health monitoring
+ * - CLI_ENTRY_POINT - Path to CLI entry point for spawning child processes
+ *
+ * @module iteration-handlers
+ */
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { spawn } = require('child_process');
+const chokidar = require('chokidar');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const {
+  DirectLLMManager,
+  AppleScriptManager,
+  QuotaDetector,
+  TimeoutCalculator,
+  t,
+  getRequirementsPath
+} = vibecodingmachineCore;
+
+// Import auto mode utilities
+const { getAutoConfig } = require('../../utils/config');
+const { checkAntigravityRateLimit, handleAntigravityRateLimit } = require('../../utils/antigravity-js-handler');
+const { checkKiroRateLimit, handleKiroRateLimit } = require('../../utils/kiro-js-handler');
+const { checkClineRateLimit, handleClineRateLimit } = require('../../utils/cline-js-handler');
+const { stopAutoMode } = require('../../utils/auto-mode');
+
+// Import modular functions from auto-direct/ subdirectory
+const {
+  getLogTimestamp,
+  isRateLimitMessage,
+  safeLog
+} = require('./utils');
+
+const {
+  updateRequirementsStatus,
+  moveRequirementToVerify
+} = require('./requirement-manager');
+
+const {
+  parseSearchReplaceBlocks,
+  applyFileChange
+} = require('./code-processor');
+
+const {
+  findRelevantFiles,
+  readFileSnippets
+} = require('./file-scanner');
+
+const {
+  printStatusCard
+} = require('./status-display');
+
+// Import split module functions
+const { waitForIdeCompletion: waitForIdeCompletionImpl } = require('./ide-completion-waiter');
+const { runIteration: runIterationImpl, initialize: initializeIterationRunner } = require('./iteration-runner');
+
+// Import extracted module functions
+const { ensureClineInstalled: ensureClineInstalledImpl } = require('./cline-installer');
+const { runIdeProviderIteration: runIdeProviderIterationImpl, initialize: initializeIdeProviderRunner } = require('./ide-provider-runner');
+const { runIdeFallbackIteration: runIdeFallbackIterationImpl, initialize: initializeIdeFallbackRunner } = require('./ide-fallback-runner');
+const { runSpecIdeIteration: runSpecIdeIterationImpl, initialize: initializeSpecIdeRunner } = require('./spec-ide-runner');
+
+// These will be set by the parent module (auto-direct.js)
+let sharedProviderManager = null;
+let sharedHealthTracker = null;
+let CLI_ENTRY_POINT = null;
+let storedStatusTitle = null;
+let storedStatus = 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
+ * @param {string} deps.cliEntryPoint - Path to CLI entry point
+ * @param {Object} deps.statusVars - Object containing storedStatusTitle and storedStatus references
+ */
+function initialize(deps) {
+  sharedProviderManager = deps.providerManager;
+  sharedHealthTracker = deps.healthTracker;
+  CLI_ENTRY_POINT = deps.cliEntryPoint;
+  storedStatusTitle = deps.statusVars.storedStatusTitle;
+  storedStatus = deps.statusVars.storedStatus;
+
+  // Initialize imported modules
+  require('./ide-completion-waiter').initialize(deps);
+  initializeIdeProviderRunner(deps);
+  initializeIdeFallbackRunner(deps);
+  initializeSpecIdeRunner(deps);
+  initializeIterationRunner({ ...deps, runIdeFallbackIteration });
+}
+
+/**
+ * Auto-install Cline CLI if not available
+ * Wrapper function that delegates to the implementation in cline-installer.js
+ * @param {boolean} forceInstall - Force installation even if already available
+ * @returns {Promise<boolean>} - Returns true if Cline CLI is available after installation
+ */
+async function ensureClineInstalled(forceInstall = false) {
+  return ensureClineInstalledImpl(forceInstall);
+}
+
+/**
+ * Run an IDE provider iteration by spawning auto:start subprocess
+ * Wrapper function that delegates to the implementation in ide-provider-runner.js
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{success: boolean, error?: string, output?: string, rateLimited?: boolean}>}
+ */
+async function runIdeProviderIteration(providerConfig, repoPath) {
+  return runIdeProviderIterationImpl(providerConfig, repoPath);
+}
+
+
+/**
+ * Wait for IDE agent to complete work by monitoring requirements file
+ * Wrapper function that delegates to the implementation in ide-completion-waiter.js
+ * @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) {
+  return waitForIdeCompletionImpl(repoPath, requirementText, ideType, timeoutMs);
+}
+
+/**
+ * Run an IDE fallback iteration (no context gathering, direct IDE spawn)
+ * Wrapper function that delegates to the implementation in ide-fallback-runner.js
+ * @param {Object} requirement - Requirement object
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ * @param {Object} providerManager - Provider manager instance
+ * @param {Object} llm - DirectLLMManager instance
+ * @param {number} startTime - Start time timestamp
+ * @returns {Promise<{success: boolean, error?: string, shouldRetry?: boolean}>}
+ */
+async function runIdeFallbackIteration(requirement, providerConfig, repoPath, providerManager, llm, startTime) {
+  return runIdeFallbackIterationImpl(requirement, providerConfig, repoPath, providerManager, llm, startTime);
+}
+
+/**
+ * Run a spec iteration using an IDE provider (AppleScript).
+ * Wrapper function that delegates to the implementation in spec-ide-runner.js
+ * @param {Object} spec        - Spec object with .path, .directory, .hasTasks, .hasPlan, .hasPlanPrompt
+ * @param {string} taskText    - Text of the NEXT unchecked task (for display)
+ * @param {string} taskLine    - Full line from tasks.md (used if this is a continuation)
+ * @param {Object} providerConfig - Provider config with .provider/.ide and .displayName
+ * @param {Function} countSpecCheckboxes - Function to count checkboxes in spec tasks.md
+ * @returns {Promise<{success: boolean, error?: string, shouldRetry?: boolean}>}
+ */
+async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig, countSpecCheckboxes) {
+  return runSpecIdeIterationImpl(spec, taskText, taskLine, providerConfig, countSpecCheckboxes);
+}
+
+/**
+ * Run one iteration of autonomous mode with full workflow
+ * Wrapper function that delegates to the implementation in iteration-runner.js
+ * @param {Object} requirement - Requirement object
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{success: boolean, changes?: Array, error?: string}>}
+ */
+async function runIteration(requirement, providerConfig, repoPath) {
+  return runIterationImpl(requirement, providerConfig, repoPath);
+}
+module.exports = {
+  initialize,
+  ensureClineInstalled,
+  runIdeProviderIteration,
+  waitForIdeCompletion,
+  runIdeFallbackIteration,
+  runSpecIdeIteration,
+  runIteration
+};