vibecodingmachine-cli 2026.2.26-1752 → 2026.3.9-1621

package/src/commands/auto-direct-refactored.js

@@ -0,0 +1,413 @@
+/**
+ * Refactored Auto Mode Direct Implementation
+ * 
+ * Splits monolithic auto-direct.js into modular components
+ */
+
+// Import modular components
+const {
+  getTimestamp,
+  getLogTimestamp,
+  translateStage,
+  stripAnsi,
+  getVisualWidth,
+  padToVisualWidth,
+  isRateLimitMessage,
+  sleep,
+  safeLog,
+  updateRequirementsStatus,
+  getCurrentRequirement,
+  countTodoRequirements,
+  moveRequirementToVerify,
+  moveRequirementToRecycle
+} = require('./auto-direct/auto-utils');
+
+const {
+  ensureClineInstalled,
+  getAllAvailableProviders,
+  getProviderConfig,
+  handleProviderFailure,
+  handleProviderSuccess,
+  shouldSkipProvider,
+  getProviderHealth,
+  getAllProvidersHealth,
+  resetProviderHealth,
+  sharedProviderManager,
+  sharedHealthTracker
+} = require('./auto-direct/auto-provider-manager');
+
+const {
+  printStatusCard,
+  printWorkflowStages,
+  printProviderInfo,
+  printRateLimitWarning,
+  printError,
+  printSuccess,
+  printWarning,
+  printInfo,
+  printDebug,
+  createSpinner,
+  printFileChangeSummary,
+  printIterationSummary,
+  printTiming,
+  clearLine,
+  setConfiguredStages,
+  currentStatusMode
+} = require('./auto-direct/auto-status-display');
+
+// Import remaining dependencies
+const chalk = require('chalk');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const { DirectLLMManager, AppleScriptManager } = vibecodingmachineCore;
+const { detectLocale, setLocale } = vibecodingmachineCore;
+const { getRepoPath, getEffectiveRepoPath, getAutoConfig, setAutoConfig, getStages, DEFAULT_STAGES } = require('../utils/config');
+const { getRequirementsPath, readRequirements } = vibecodingmachineCore;
+const fs = require('fs-extra');
+const path = require('path');
+const { spawn } = require('child_process');
+const chokidar = require('chokidar');
+const { getProviderPreferences, saveProviderPreferences } = require('../utils/provider-registry');
+const { createKeyboardHandler } = require('../utils/keyboard-handler');
+const logger = require('../utils/logger');
+
+// Initialize locale detection for auto mode
+const detectedLocale = detectLocale();
+setLocale(detectedLocale);
+
+// Constants and state
+const CLI_ENTRY_POINT = path.join(__dirname, '../../bin/vibecodingmachine.js');
+let keyboardHandler = null;
+
+// Set configured stages for status display
+setConfiguredStages(getStages());
+
+/**
+ * Main auto mode function - refactored to use modular components
+ */
+async function runAutoMode(options = {}) {
+  const startTime = Date.now();
+  
+  try {
+    printInfo('🚀 Starting Auto Mode...');
+    
+    // Initialize repository
+    const repoPath = await getEffectiveRepoPath();
+    if (!repoPath) {
+      throw new Error('No repository configured. Run "app init" first.');
+    }
+    
+    // Get current requirement
+    const currentRequirement = await getCurrentRequirement(repoPath);
+    if (!currentRequirement) {
+      throw new Error('No current requirement found. Use "app req next" to set one.');
+    }
+    
+    printSuccess(`Working on: ${currentRequirement}`);
+    
+    // Initialize provider
+    const providerConfig = await getProviderConfig();
+    if (providerConfig.action === 'wait') {
+      printRateLimitWarning('providers', providerConfig.waitTime);
+      await sleep(providerConfig.waitTime);
+      // Retry getting provider config
+      const retryConfig = await getProviderConfig();
+      if (retryConfig.action === 'wait') {
+        throw new Error('All providers are rate limited. Please try again later.');
+      }
+    }
+    
+    printProviderInfo(providerConfig.provider, providerConfig.config);
+    
+    // Initialize LLM manager
+    const llmManager = new DirectLLMManager(providerConfig.config);
+    
+    // Set up keyboard handler
+    keyboardHandler = createKeyboardHandler({
+      onExit: () => {
+        printInfo('🛑 Auto mode stopped by user');
+        process.exit(0);
+      },
+      onPause: () => {
+        printInfo('⏸️  Auto mode paused');
+      },
+      onResume: () => {
+        printInfo('▶️  Auto mode resumed');
+      }
+    });
+    
+    // Main auto mode loop
+    await runAutoModeLoop(llmManager, providerConfig, currentRequirement, options);
+    
+    const endTime = Date.now();
+    printTiming(startTime, endTime);
+    printSuccess('🎉 Auto mode completed successfully!');
+    
+  } catch (error) {
+    printError(error, 'Auto Mode');
+    process.exit(1);
+  } finally {
+    if (keyboardHandler) {
+      keyboardHandler.cleanup();
+    }
+  }
+}
+
+/**
+ * Main auto mode execution loop
+ */
+async function runAutoModeLoop(llmManager, providerConfig, currentRequirement, options) {
+  const stages = getStages();
+  let currentStage = 'PREPARE';
+  let iteration = 1;
+  const maxIterations = options.maxIterations || 5;
+  
+  while (iteration <= maxIterations) {
+    printIterationSummary(iteration, maxIterations, currentRequirement, currentStage);
+    printStatusCard(currentRequirement, currentStage);
+    printWorkflowStages(currentStage);
+    
+    try {
+      // Execute current stage
+      await executeStage(llmManager, providerConfig, currentStage, currentRequirement, options);
+      
+      // Move to next stage
+      const currentIndex = stages.indexOf(currentStage);
+      if (currentIndex < stages.length - 1) {
+        currentStage = stages[currentIndex + 1];
+      } else {
+        // Completed all stages
+        await moveRequirementToVerify(await getRepoPath(), currentRequirement);
+        printSuccess('✅ All stages completed! Requirement moved to verification.');
+        break;
+      }
+      
+    } catch (error) {
+      handleProviderFailure(providerConfig.provider, error);
+      
+      if (shouldSkipProvider(providerConfig.provider)) {
+        printWarning(`Provider ${providerConfig.provider} is temporarily unavailable. Switching...`);
+        
+        // Try to get alternative provider
+        const newProviderConfig = await getProviderConfig(providerConfig.provider);
+        if (newProviderConfig.action === 'wait') {
+          printRateLimitWarning('alternative providers', newProviderConfig.waitTime);
+          await sleep(newProviderConfig.waitTime);
+          continue;
+        }
+        
+        providerConfig = newProviderConfig;
+        llmManager = new DirectLLMManager(providerConfig.config);
+        printProviderInfo(providerConfig.provider, providerConfig.config);
+      }
+      
+      // Retry current stage
+      printWarning(`Retrying stage ${currentStage}...`);
+      await sleep(5000);
+      continue;
+    }
+    
+    iteration++;
+  }
+  
+  if (iteration > maxIterations) {
+    printWarning(`Maximum iterations (${maxIterations}) reached. Moving requirement to recycle.`);
+    await moveRequirementToRecycle(await getRepoPath(), currentRequirement);
+  }
+}
+
+/**
+ * Execute a specific workflow stage
+ */
+async function executeStage(llmManager, providerConfig, stage, requirement, options) {
+  const repoPath = await getRepoPath();
+  
+  // Update status
+  await updateRequirementsStatus(repoPath, stage);
+  
+  switch (stage) {
+    case 'PREPARE':
+      await executePrepareStage(llmManager, requirement, options);
+      break;
+      
+    case 'REPRODUCE':
+      await executeReproduceStage(llmManager, requirement, options);
+      break;
+      
+    case 'ACT':
+      await executeActStage(llmManager, requirement, options);
+      break;
+      
+    case 'CLEAN UP':
+      await executeCleanupStage(llmManager, requirement, options);
+      break;
+      
+    case 'VERIFY':
+      await executeVerifyStage(llmManager, requirement, options);
+      break;
+      
+    default:
+      throw new Error(`Unknown stage: ${stage}`);
+  }
+  
+  handleProviderSuccess(providerConfig.provider);
+}
+
+/**
+ * Execute PREPARE stage
+ */
+async function executePrepareStage(llmManager, requirement, options) {
+  printInfo('🔧 Preparing environment...');
+  
+  const prompt = `
+You are in PREPARE stage for the requirement: "${requirement}"
+
+Please:
+1. Analyze the current codebase structure
+2. Identify files that need to be modified
+3. Prepare a plan for implementation
+4. Check for any dependencies or prerequisites
+
+Provide a detailed preparation plan.
+`;
+
+  const response = await llmManager.generateResponse(prompt);
+  printSuccess('✅ Preparation completed');
+  printDebug(`Preparation response: ${response.substring(0, 200)}...`);
+}
+
+/**
+ * Execute REPRODUCE stage
+ */
+async function executeReproduceStage(llmManager, requirement, options) {
+  printInfo('🔄 Reproducing current state...');
+  
+  const prompt = `
+You are in REPRODUCE stage for the requirement: "${requirement}"
+
+Please:
+1. Understand the current implementation
+2. Reproduce any existing behavior
+3. Identify what needs to be changed
+4. Document the current state
+
+Provide a reproduction analysis.
+`;
+
+  const response = await llmManager.generateResponse(prompt);
+  printSuccess('✅ Reproduction completed');
+  printDebug(`Reproduction response: ${response.substring(0, 200)}...`);
+}
+
+/**
+ * Execute ACT stage
+ */
+async function executeActStage(llmManager, requirement, options) {
+  printInfo('⚡ Implementing changes...');
+  
+  const prompt = `
+You are in ACT stage for the requirement: "${requirement}"
+
+Please:
+1. Implement the required changes
+2. Modify files as needed
+3. Ensure code quality and consistency
+4. Follow best practices
+
+Provide the implementation details.
+`;
+
+  const response = await llmManager.generateResponse(prompt);
+  printSuccess('✅ Implementation completed');
+  printDebug(`Implementation response: ${response.substring(0, 200)}...`);
+}
+
+/**
+ * Execute CLEAN UP stage
+ */
+async function executeCleanupStage(llmManager, requirement, options) {
+  printInfo('🧹 Cleaning up...');
+  
+  const prompt = `
+You are in CLEAN UP stage for the requirement: "${requirement}"
+
+Please:
+1. Review and clean up the code
+2. Remove any unused code or comments
+3. Ensure proper formatting
+4. Update documentation
+
+Provide cleanup details.
+`;
+
+  const response = await llmManager.generateResponse(prompt);
+  printSuccess('✅ Cleanup completed');
+  printDebug(`Cleanup response: ${response.substring(0, 200)}...`);
+}
+
+/**
+ * Execute VERIFY stage
+ */
+async function executeVerifyStage(llmManager, requirement, options) {
+  printInfo('✅ Verifying implementation...');
+  
+  const prompt = `
+You are in VERIFY stage for the requirement: "${requirement}"
+
+Please:
+1. Verify the implementation meets requirements
+2. Test the changes
+3. Check for any issues or edge cases
+4. Confirm everything is working correctly
+
+Provide verification results.
+`;
+
+  const response = await llmManager.generateResponse(prompt);
+  printSuccess('✅ Verification completed');
+  printDebug(`Verification response: ${response.substring(0, 200)}...`);
+}
+
+// Export the main function and utilities
+module.exports = {
+  runAutoMode,
+  // Export utilities for backward compatibility
+  getTimestamp,
+  getLogTimestamp,
+  translateStage,
+  stripAnsi,
+  getVisualWidth,
+  padToVisualWidth,
+  isRateLimitMessage,
+  sleep,
+  safeLog,
+  updateRequirementsStatus,
+  getCurrentRequirement,
+  countTodoRequirements,
+  moveRequirementToVerify,
+  moveRequirementToRecycle,
+  ensureClineInstalled,
+  getAllAvailableProviders,
+  getProviderConfig,
+  handleProviderFailure,
+  handleProviderSuccess,
+  shouldSkipProvider,
+  getProviderHealth,
+  getAllProvidersHealth,
+  resetProviderHealth,
+  printStatusCard,
+  printWorkflowStages,
+  printProviderInfo,
+  printRateLimitWarning,
+  printError,
+  printSuccess,
+  printWarning,
+  printInfo,
+  printDebug,
+  createSpinner,
+  printFileChangeSummary,
+  printIterationSummary,
+  printTiming,
+  clearLine,
+  sharedProviderManager,
+  sharedHealthTracker
+};