vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

package/src/commands/auto-direct/auto-start-phases.js

@@ -0,0 +1,493 @@
+/**
+ * Auto Start Phase Handlers
+ *
+ * Extracted from auto-direct.js handleAutoStart function for constitutional compliance
+ * Contains initialization and processing loop logic for autonomous mode
+ */
+
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const { spawn } = require('child_process');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const {
+  AppleScriptManager,
+  t,
+  RequirementFileParser,
+  RequirementSequencer,
+  DefaultRequirementManager,
+  JSONStorage
+} = vibecodingmachineCore;
+
+const { getEffectiveRepoPath, getAutoConfig, setAutoConfig, getStages } = require('../../utils/config');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const { createKeyboardHandler } = require('../../utils/keyboard-handler');
+const { startAutoMode, updateAutoModeStatus } = require('../../utils/auto-mode');
+
+// Import modular functions
+const { isRateLimitMessage } = require('./utils');
+const {
+  updateRequirementsStatus,
+  getCurrentRequirement,
+  countTodoRequirements
+} = require('./requirement-manager');
+const {
+  printStatusCard
+} = require('./status-display');
+const {
+  runIteration,
+  runSpecIdeIteration
+} = require('./iteration-handlers');
+const {
+  countSpecCheckboxes,
+  getNextSpecTask,
+  loadEnabledIncompleteSpecs,
+  processDefaultRequirement
+} = require('./spec-handlers');
+const {
+  acquireProviderConfig
+} = require('./provider-config');
+const {
+  handleSpecPlanning,
+  handleTasksRegeneration
+} = require('./spec-processing');
+
+/**
+ * Initialize auto mode - authentication, config, keyboard handler, repository setup
+ *
+ * @param {Object} options - Command line options
+ * @param {Object} sharedRefs - Shared references for keyboard handler and status
+ * @returns {Promise<Object>} Initialized state object
+ */
+async function initializeAutoMode(options, sharedRefs) {
+  // STRICT AUTH CHECK
+  const auth = require('../../utils/auth');
+  const isAuth = await auth.isAuthenticated();
+  if (!isAuth) {
+    console.log(chalk.cyan('\n🔐 Opening browser for authentication...\n'));
+    try {
+      await auth.login();
+      console.log(chalk.green('\n✓ Authentication successful!\n'));
+    } catch (error) {
+      console.log(chalk.red('\n✗ Authentication failed:'), error.message);
+      process.exit(1);
+    }
+  }
+
+  console.log(chalk.bold.cyan('\n' + t('auto.direct.title') + '\n'));
+  console.log(chalk.gray('═'.repeat(80)));
+  console.log();
+
+  const repoPath = await getEffectiveRepoPath();
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    console.log(chalk.gray(t('auto.direct.config.repo.not.set')));
+    throw new Error('No repository configured');
+  }
+
+  // Create keyboard handler for 'x' key exit
+  sharedRefs.keyboardHandler = createKeyboardHandler({
+    onExit: () => {
+      updateAutoModeStatus(repoPath, { running: false });
+      console.log(chalk.gray('Auto mode stopped'));
+      if (sharedRefs.storedStatusTitle && sharedRefs.storedStatus) {
+        printStatusCard(sharedRefs.storedStatusTitle, sharedRefs.storedStatus, 'stopped');
+      }
+    }
+  });
+
+  // Start keyboard handler
+  sharedRefs.keyboardHandler.start();
+
+  // Ensure keyboard handler is cleaned up on exit
+  const cleanup = () => {
+    if (sharedRefs.keyboardHandler) {
+      sharedRefs.keyboardHandler.stop();
+    }
+  };
+
+  process.on('exit', cleanup);
+  process.on('SIGINT', () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    cleanup();
+    process.exit(0);
+  });
+
+  // Start Auto Mode status tracking
+  const config = await getAutoConfig();
+
+  // Save extension to config if provided
+  if (options.extension) {
+    config.extension = options.extension;
+    await setAutoConfig(config);
+  }
+
+  await startAutoMode(repoPath, { ide: options.ide || config.ide });
+
+  // Load configured stages
+  const configuredStages = await getStages();
+
+  // Initialize requirement monitoring for default requirement management
+  const requirementsPath = await getRequirementsPath(repoPath);
+  const storage = new JSONStorage();
+  const parser = new RequirementFileParser();
+  const defaultManager = new DefaultRequirementManager(storage);
+  const sequencer = new RequirementSequencer(parser, defaultManager);
+
+  // Start monitoring requirements file for changes
+  const stopMonitoring = sequencer.monitorRequirements(requirementsPath, async (changeType, change) => {
+    if (changeType === 'regular-requirements-added') {
+      console.log(chalk.bold.yellow('\n📝 New regular requirements detected'));
+      console.log(chalk.gray('Default requirement will be paused to process regular requirements first\n'));
+    } else if (changeType === 'regular-requirements-completed') {
+      console.log(chalk.bold.green('\n✅ All regular requirements completed'));
+      console.log(chalk.gray('Default requirement will be resumed\n'));
+    }
+  });
+
+  console.log(chalk.white(t('auto.repository')), chalk.cyan(repoPath));
+
+  // Use the agent that was already determined by provider preferences
+  const effectiveAgent = options.ide;
+
+  // Get provider configuration — options.provider forces a specific provider
+  let providerConfig = await acquireProviderConfig(null, null, options.provider || null);
+  if (!providerConfig) {
+    throw new Error('No provider configuration available');
+  }
+
+  console.log(chalk.white('Provider:'), chalk.cyan(providerConfig.displayName));
+
+  // Get max chats
+  const unlimited = !options.maxChats && !config.maxChats && config.neverStop;
+  const maxChats = unlimited ? Number.MAX_SAFE_INTEGER : (options.maxChats || config.maxChats || 1);
+  console.log(chalk.white(`${t('auto.direct.config.max.iterations')}`), unlimited ? chalk.cyan('∞ (never stop)') : chalk.cyan(maxChats));
+
+  // Update initial status
+  await updateAutoModeStatus(repoPath, { chatCount: 0, maxChats: unlimited ? 0 : maxChats });
+  console.log();
+  console.log(chalk.gray('═'.repeat(80)));
+
+  // Calculate initial total for consistent display throughout the session
+  const initialTodoCount = await countTodoRequirements(repoPath);
+  const initialEffectiveMax = unlimited ? initialTodoCount : Math.min(maxChats, initialTodoCount);
+
+  return {
+    repoPath,
+    config,
+    configuredStages,
+    effectiveAgent,
+    providerConfig,
+    unlimited,
+    maxChats,
+    initialTodoCount,
+    initialEffectiveMax,
+    stopMonitoring,
+    sequencer,
+    defaultManager,
+    requirementsPath
+  };
+}
+
+/**
+ * Process incomplete specs loop - iterates through all enabled incomplete specs
+ *
+ * @param {Object} state - Current state object
+ * @returns {Promise<Object>} Result with completedCount and failedCount
+ */
+async function processSpecsLoop(state) {
+  let completedCount = 0;
+  let failedCount = 0;
+
+  const incompleteSpecs = await loadEnabledIncompleteSpecs(state.repoPath);
+  if (incompleteSpecs.length === 0) {
+    return { completedCount, failedCount, specsProcessed: false };
+  }
+
+  console.log(chalk.bold.cyan(`\n📋 Processing ${incompleteSpecs.length} incomplete spec(s) before requirements...\n`));
+
+  for (const spec of incompleteSpecs) {
+    // Initialize IDE attempts tracking for this spec
+    spec.totalIdeAttempts = 0;
+
+    const { done: doneStart, total: totalStart } = countSpecCheckboxes(spec.path);
+    console.log(chalk.bold.magenta(`\n${'━'.repeat(80)}`));
+    console.log(chalk.bold.magenta(`  📋 SPEC: ${spec.directory}  (${spec.title || spec.directory})`));
+    if (totalStart > 0) {
+      const pctStart = Math.round((doneStart / totalStart) * 100);
+      console.log(chalk.bold.magenta(`  Progress: ${doneStart}/${totalStart} tasks (${pctStart}%) complete`));
+    } else {
+      console.log(chalk.bold.magenta('  No tasks.md yet — will plan and implement'));
+    }
+    console.log(chalk.bold.magenta(`${'━'.repeat(80)}\n`));
+
+    let specProviderAttempts = 0;
+    const MAX_SPEC_TASK_ATTEMPTS = 3;
+    let lastSpecTaskText = null;
+    let sameTaskAttempts = 0;
+
+    // If spec has no tasks.md yet, add a special planning task
+    if (!spec.hasTasks) {
+      const planResult = await handleSpecPlanning(spec, state.providerConfig, state.repoPath);
+      if (planResult.success) {
+        completedCount++;
+        spec.hasTasks = fs.existsSync(path.join(spec.path, 'tasks.md'));
+      } else {
+        failedCount++;
+        continue;
+      }
+    }
+
+    // Verify tasks.md has checkbox-format tasks
+    const { done: doneCheck, total: totalCheck } = countSpecCheckboxes(spec.path);
+    if (totalCheck === 0 && spec.hasTasks) {
+      const regenResult = await handleTasksRegeneration(spec, state.providerConfig);
+      if (!regenResult.success) {
+        failedCount++;
+        continue;
+      }
+    }
+
+    // Loop until spec is done or stalled
+    while (true) {
+      const task = getNextSpecTask(spec.path);
+      if (!task) {
+        const { done: doneFinal, total: totalFinal } = countSpecCheckboxes(spec.path);
+        console.log(chalk.bold.green(`\n✅ Spec "${spec.directory}" complete! (${doneFinal}/${totalFinal} tasks)\n`));
+        break;
+      }
+
+      // Detect same task repeated
+      if (task.text === lastSpecTaskText) {
+        sameTaskAttempts++;
+        if (sameTaskAttempts >= MAX_SPEC_TASK_ATTEMPTS) {
+          console.log(chalk.red(`\n✗ Task "${task.text}" not completing after ${MAX_SPEC_TASK_ATTEMPTS} attempts — skipping spec\n`));
+          break;
+        }
+      } else {
+        sameTaskAttempts = 0;
+        lastSpecTaskText = task.text;
+      }
+
+      const { done: doneCurrent, total: totalCurrent } = countSpecCheckboxes(spec.path);
+      const pctCurrent = totalCurrent > 0 ? Math.round((doneCurrent / totalCurrent) * 100) : 0;
+
+      console.log(chalk.cyan(`\n📌 Task ${doneCurrent + 1}/${totalCurrent || '?'}: ${task.text}`));
+      console.log(chalk.gray(`   Spec progress: ${doneCurrent}/${totalCurrent} (${pctCurrent}%)\n`));
+
+      // Route spec tasks differently depending on provider type
+      let result;
+      if (state.providerConfig.type === 'ide') {
+        result = await runSpecIdeIteration(spec, task.text, task.line, state.providerConfig);
+      } else {
+        const specTaskText = [
+          task.text,
+          `[Spec: ${spec.directory} — task ${doneCurrent + 1}/${totalCurrent || '?'}]`,
+          `[After implementing, mark the task done in ${spec.path}/tasks.md:`,
+          `  change: ${task.line}`,
+          `  to:     - [x] ${task.text}]`
+        ].join('\n');
+        const specRequirement = { text: specTaskText, package: null, disabled: false };
+        result = await runIteration(specRequirement, state.providerConfig, state.repoPath);
+      }
+
+      if (result.success) {
+        specProviderAttempts = 0;
+        spec.totalIdeAttempts = 0;
+        completedCount++;
+        const { done, total } = countSpecCheckboxes(spec.path);
+        const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+        console.log(chalk.bold.green(`📊 Spec progress: ${done}/${total} tasks (${pct}%) complete`));
+      } else {
+        const isRateLimitError = isRateLimitMessage(result.error);
+        const isMaxAttemptsExceeded = result.error === 'max_ide_attempts_exceeded';
+        const isNoProgress = result.error === 'no_progress';
+
+        let errorType = 'Error';
+        if (isRateLimitError) errorType = 'Rate limit';
+        else if (isMaxAttemptsExceeded) errorType = 'Max IDE attempts exceeded';
+        else if (isNoProgress) errorType = 'No progress';
+
+        if (result.totalAttempts) {
+          spec.totalIdeAttempts = result.totalAttempts;
+        }
+
+        specProviderAttempts++;
+        failedCount++;
+
+        if (isMaxAttemptsExceeded) {
+          console.log(chalk.red(`\n✗ ${errorType} — auto mode stopped\n`));
+          return { completedCount, failedCount, specsProcessed: true, shouldExit: true };
+        }
+
+        if (specProviderAttempts > MAX_SPEC_TASK_ATTEMPTS) {
+          console.log(chalk.red(`\n✗ Max provider attempts reached — moving to next spec\n`));
+          break;
+        }
+
+        if (isNoProgress) {
+          console.log(chalk.yellow(`⚠️  ${errorType} on ${state.providerConfig.displayName}, switching IDE...`));
+        } else {
+          console.log(chalk.yellow(`⚠️  ${errorType} on spec task, switching provider...`));
+        }
+
+        const newProviderConfig = await acquireProviderConfig(state.providerConfig.provider, state.providerConfig.model);
+        if (newProviderConfig) {
+          state.providerConfig = newProviderConfig;
+          console.log(chalk.green(`✓ Switched to: ${state.providerConfig.displayName}\n`));
+        } else {
+          console.log(chalk.red(`✗ No alternative providers available\n`));
+          break;
+        }
+      }
+    }
+  }
+
+  console.log(chalk.bold.cyan('\n📋 All specs processed. Continuing to requirements...\n'));
+  console.log(chalk.gray('═'.repeat(80)));
+
+  return { completedCount, failedCount, specsProcessed: true };
+}
+
+/**
+ * Process requirements loop - iterates through regular requirements
+ *
+ * @param {Object} state - Current state object
+ * @param {number} completedCount - Number of completed items (from specs phase)
+ * @param {number} failedCount - Number of failed items (from specs phase)
+ * @returns {Promise<Object>} Result with updated counts
+ */
+async function processRequirementsLoop(state, completedCount, failedCount) {
+  let providerAttempts = 0;
+  let lastRequirementText = null;
+  const MAX_PROVIDER_ATTEMPTS = 3;
+
+  for (let i = 0; i < state.maxChats; i++) {
+    const requirement = await getCurrentRequirement(state.repoPath);
+    if (!requirement) {
+      // No regular requirements - check for default requirement
+      const shouldProcessDefault = await state.sequencer.shouldProcessDefault(state.requirementsPath);
+
+      if (shouldProcessDefault) {
+        console.log(chalk.bold.cyan('\n⭐ Default Requirement Mode'));
+        console.log(chalk.gray('All regular requirements completed, processing default requirement...\n'));
+        await processDefaultRequirement(state.sequencer, state.defaultManager, state.providerConfig, state.repoPath);
+      } else {
+        if (completedCount > 0 || failedCount > 0) {
+          console.log(chalk.bold.yellow('\n🎉 All requirements completed!'));
+        } else {
+          console.log(chalk.bold.yellow('\n🎉 No requirements to process.'));
+        }
+        console.log(chalk.gray(`${t('auto.direct.no.more.todo.items')}\n`));
+      }
+      break;
+    }
+
+    // Check if this is a new requirement or retry
+    if (requirement.text !== lastRequirementText) {
+      providerAttempts = 0;
+      lastRequirementText = requirement.text;
+    }
+
+    providerAttempts++;
+
+    // Check if maximum attempts exceeded
+    if (providerAttempts > MAX_PROVIDER_ATTEMPTS) {
+      console.log(chalk.red(`\n✗ Maximum provider attempts (${MAX_PROVIDER_ATTEMPTS}) reached for this requirement`));
+      console.log(chalk.yellow('  All available providers have failed or are rate limited'));
+      console.log(chalk.gray('  Skipping this requirement and moving to next...\n'));
+
+      failedCount++;
+      providerAttempts = 0;
+      lastRequirementText = null;
+      continue;
+    }
+
+    // Calculate current requirement number
+    const currentReqNumber = completedCount + failedCount + 1;
+
+    console.log(chalk.bold.magenta(`\n${'━'.repeat(80)}`));
+    console.log(chalk.bold.magenta(`  ${t('auto.direct.requirement.header', { current: currentReqNumber, total: state.initialEffectiveMax })}`));
+    console.log(chalk.bold.magenta(`${'━'.repeat(80)}\n`));
+
+    await updateAutoModeStatus(state.repoPath, { chatCount: currentReqNumber });
+
+    // Run iteration with full workflow
+    const result = await runIteration(requirement, state.providerConfig, state.repoPath);
+
+    if (result.success) {
+      completedCount++;
+      providerAttempts = 0;
+      lastRequirementText = null;
+      console.log(chalk.bold.green(`✅ Requirement ${currentReqNumber}/${state.initialEffectiveMax} COMPLETE`));
+      console.log(chalk.gray('Moving to next requirement...\n'));
+
+      // Check if restart CLI is enabled
+      if (state.config.restartCLI && i < state.maxChats - 1) {
+        await handleCliRestart(state.maxChats, i);
+      } else if (i < state.maxChats - 1) {
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      }
+    } else {
+      const isRateLimitError = isRateLimitMessage(result.error);
+      const errorType = isRateLimitError ? 'Rate limit' : 'Error';
+      const failedProvider = state.providerConfig.displayName;
+
+      console.log(chalk.yellow(`⚠️  ${errorType} detected, switching to next provider in your list...\n`));
+
+      const newProviderConfig = await acquireProviderConfig(state.providerConfig.provider, state.providerConfig.model);
+      if (newProviderConfig) {
+        state.providerConfig = newProviderConfig;
+        console.log(chalk.yellow(`⚠️  ${failedProvider} hit ${errorType.toLowerCase()}`));
+        console.log(chalk.green(`✓ Switched to: ${state.providerConfig.displayName}\n`));
+        i--;
+        continue;
+      } else {
+        console.log(chalk.red('✗ No alternative providers available\n'));
+      }
+
+      failedCount++;
+      console.log(chalk.bold.red(`❌ Requirement ${currentReqNumber}/${state.initialEffectiveMax} FAILED`));
+      console.log(chalk.red(`Error: ${result.error}\n`));
+      console.log(chalk.yellow('Continuing to next requirement...\n'));
+    }
+  }
+
+  return { completedCount, failedCount };
+}
+
+/**
+ * Handle CLI restart for long-running sessions
+ */
+async function handleCliRestart(maxChats, currentIteration) {
+  const { stopAutoMode } = require('../../utils/auto-mode');
+  console.log(chalk.cyan('🔄 Restarting CLI to pick up latest changes...\n'));
+
+  const remainingIterations = maxChats - (currentIteration + 1);
+  const cliScriptPath = path.join(__dirname, '../../../bin/vibecodingmachine.js');
+  const args = ['auto:direct', '--max-chats', remainingIterations.toString()];
+
+  const child = spawn(process.execPath, [cliScriptPath, ...args], {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: process.env
+  });
+
+  child.on('error', (err) => {
+    console.error(chalk.red(t('auto.direct.config.restart.error')), err.message);
+  });
+
+  child.unref();
+  await new Promise(resolve => setTimeout(resolve, 300));
+  await stopAutoMode('restarting');
+  process.exit(0);
+}
+
+module.exports = {
+  initializeAutoMode,
+  processSpecsLoop,
+  processRequirementsLoop
+};