vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/commands/auto-execution.js

@@ -0,0 +1,342 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+const { logIDEMessage, runContinueCLIAutoMode, t, IDEHealthTracker } = require('vibecodingmachine-core');
+const { getRepoPath, getAutoConfig, setAutoConfig, getStages } = require('../utils/config');
+const { checkAutoModeStatus, startAutoMode, stopAutoMode, updateAutoModeStatus } = require('../utils/auto-mode');
+const logger = require('../utils/logger');
+const { createKeyboardHandler } = require('../utils/keyboard-handler');
+const { getProviderDefinitions, getProviderPreferences } = require('../utils/provider-registry');
+
+// Import our modular components
+const { getAvailableProviders } = require('./auto-provider-management');
+const { 
+  isRequirementDone, 
+  moveRequirementBackToTodo, 
+  moveRequirementToFeedback, 
+  moveCompletedRequirement,
+  getCurrentRequirementDetails,
+  getRequirementCounts
+} = require('./auto-requirement-management');
+const { getTimestamp, printStatusCard, updateRequirementsStatus } = require('./auto-status-helpers');
+
+const PROVIDER_DEFINITIONS = getProviderDefinitions();
+const PROVIDER_DEFINITION_MAP = new Map(PROVIDER_DEFINITIONS.map(def => [def.id, def]));
+const { handleAutoStart: handleDirectAutoStart } = require('./auto-direct');
+
+/**
+ * Auto Execution Logic Module for Auto Command
+ * Handles the main auto-mode execution flow
+ */
+
+/**
+ * Start auto mode execution
+ * @param {Object} options - Command options
+ */
+async function start(options) {
+  // First Run Check
+  try {
+    const { checkFirstRun } = require('../utils/first-run');
+    await checkFirstRun();
+  } catch (e) {
+    // Continue if check fails
+  }
+
+  // STRICT AUTH CHECK
+  const auth = require('../utils/auth');
+  const isAuth = await auth.isAuthenticated();
+  if (!isAuth) {
+    console.log(chalk.red('❌ Authentication required. Please run: vcm auth'));
+    process.exit(1);
+  }
+
+  const repoPath = getRepoPath();
+  const config = getAutoConfig(repoPath);
+  const stages = getStages(repoPath);
+
+  // Validate config
+  if (!config || !config.providers || config.providers.length === 0) {
+    console.log(chalk.red('❌ No providers configured. Please run: vcm auto:config'));
+    process.exit(1);
+  }
+
+  // Check if auto mode is already running
+  const autoStatus = checkAutoModeStatus(repoPath);
+  if (autoStatus.isRunning) {
+    console.log(chalk.yellow('⚠️  Auto mode is already running'));
+    console.log(chalk.gray(`  Started: ${autoStatus.startTime}`));
+    console.log(chalk.gray(`  PID: ${autoStatus.pid}`));
+    console.log(chalk.gray('  To stop: vcm auto:stop'));
+    return;
+  }
+
+  console.log(chalk.blue('🚀 Starting Vibe Coding Machine Auto Mode...\n'));
+
+  // Display configuration
+  console.log(chalk.cyan('Configuration:'));
+  console.log(chalk.gray('  Repository:'), chalk.white(repoPath));
+  console.log(chalk.gray('  Providers:'), chalk.white(config.providers.map(p => p.provider).join(', ')));
+  console.log(chalk.gray('  Max chats:'), chalk.white(config.maxChats || 'unlimited'));
+  console.log(chalk.gray('  Never stop:'), chalk.white(config.neverStop ? 'yes' : 'no'));
+  console.log();
+
+  // Start auto mode
+  try {
+    await startAutoMode(repoPath, {
+      providers: config.providers,
+      maxChats: config.maxChats,
+      neverStop: config.neverStop
+    });
+
+    // Main auto mode loop
+    await runAutoModeLoop(repoPath, config, stages);
+
+  } catch (error) {
+    console.error(chalk.red('Error starting auto mode:'), error.message);
+    await stopAutoMode(repoPath);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main auto mode execution loop
+ * @param {string} repoPath - Repository path
+ * @param {Object} config - Auto configuration
+ * @param {Object} stages - Stages configuration
+ */
+async function runAutoModeLoop(repoPath, config, stages) {
+  let chatCount = 0;
+  const maxChats = config.maxChats;
+  const neverStop = config.neverStop;
+
+  // Create keyboard handler for graceful shutdown
+  const keyboardHandler = createKeyboardHandler({
+    onExit: async () => {
+      console.log(chalk.yellow('\n🛑 Stopping auto mode...'));
+      await stopAutoMode(repoPath);
+      process.exit(0);
+    }
+  });
+
+  keyboardHandler.start();
+
+  console.log(chalk.green('✅ Auto mode started successfully'));
+  console.log(chalk.gray(`  To stop: Press `) + chalk.white.bold('x') + chalk.gray(' or ') + chalk.white.bold('Ctrl+C') + chalk.gray(', or run \'vcm auto:stop\''));
+  console.log();
+
+  // Main execution loop
+  while ((neverStop || (maxChats && chatCount < maxChats))) {
+    try {
+      // Get current requirement details
+      const { title: currentTitle, status: currentStatus } = await getCurrentRequirementDetails(repoPath);
+      
+      // Display status card
+      printStatusCard(currentTitle, currentStatus);
+
+      // Check if requirement is done
+      const requirementStatus = await isRequirementDone(repoPath);
+      if (requirementStatus.isDone && requirementStatus.actuallyComplete) {
+        console.log(chalk.green(`✅ Requirement completed: ${currentTitle}`));
+        
+        // Move to next requirement
+        await moveToNextRequirement(repoPath);
+        chatCount++;
+        continue;
+      }
+
+      // Execute current stage
+      const stageResult = await executeCurrentStage(repoPath, currentStatus, currentTitle);
+      if (!stageResult.success) {
+        console.error(chalk.red('Stage execution failed:'), stageResult.error);
+        break;
+      }
+
+      chatCount++;
+
+      // Check if we should continue
+      if (!neverStop && maxChats && chatCount >= maxChats) {
+        console.log(chalk.yellow(`🏁 Reached maximum chat limit (${maxChats})`));
+        break;
+      }
+
+      // Wait before next iteration
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+    } catch (error) {
+      console.error(chalk.red('Error in auto mode loop:'), error.message);
+      break;
+    }
+  }
+
+  // Cleanup
+  keyboardHandler.stop();
+  await stopAutoMode(repoPath);
+  console.log(chalk.green('\n🏁 Auto mode stopped'));
+}
+
+/**
+ * Execute the current stage based on status
+ * @param {string} repoPath - Repository path
+ * @param {string} currentStatus - Current status
+ * @param {string} currentTitle - Current requirement title
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function executeCurrentStage(repoPath, currentStatus, currentTitle) {
+  try {
+    switch (currentStatus) {
+      case 'PREPARE':
+        return await executePrepareStage(repoPath, currentTitle);
+      case 'CREATE':
+        return await executeCreateStage(repoPath, currentTitle);
+      case 'CLEAN_UP':
+        return await executeCleanUpStage(repoPath, currentTitle);
+      case 'VERIFY':
+        return await executeVerifyStage(repoPath, currentTitle);
+      case 'NOT_WORKING':
+        return await executeNotWorkingStage(repoPath, currentTitle);
+      default:
+        return { success: false, error: `Unknown status: ${currentStatus}` };
+    }
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Execute PREPARE stage
+ * @param {string} repoPath - Repository path
+ * @param {string} currentTitle - Current requirement title
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function executePrepareStage(repoPath, currentTitle) {
+  console.log(chalk.cyan(`\n[${getTimestamp()}] 🔨 PREPARE: ${currentTitle}`));
+  
+  // Update status to CREATE
+  const updateResult = await updateRequirementsStatus(repoPath, 'CREATE', `Starting implementation of: ${currentTitle}`);
+  if (!updateResult.success) {
+    return updateResult;
+  }
+
+  console.log(chalk.green('✅ Preparation complete'));
+  return { success: true };
+}
+
+/**
+ * Execute CREATE stage
+ * @param {string} repoPath - Repository path
+ * @param {string} currentTitle - Current requirement title
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function executeCreateStage(repoPath, currentTitle) {
+  console.log(chalk.cyan(`\n[${getTimestamp()}] 🛠️ CREATE: ${currentTitle}`));
+  
+  // This would integrate with the AI provider to implement the requirement
+  // For now, we'll simulate the implementation
+  console.log(chalk.blue('🤖 Implementing requirement...'));
+  
+  // Simulate work
+  await new Promise(resolve => setTimeout(resolve, 3000));
+  
+  // Update status to CLEAN_UP
+  const updateResult = await updateRequirementsStatus(repoPath, 'CLEAN_UP', `Implementation complete for: ${currentTitle}`);
+  if (!updateResult.success) {
+    return updateResult;
+  }
+
+  console.log(chalk.green('✅ Implementation complete'));
+  return { success: true };
+}
+
+/**
+ * Execute CLEAN_UP stage
+ * @param {string} repoPath - Repository path
+ * @param {string} currentTitle - Current requirement title
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function executeCleanUpStage(repoPath, currentTitle) {
+  console.log(chalk.cyan(`\n[${getTimestamp()}] 🧹 CLEAN_UP: ${currentTitle}`));
+  
+  // Run linting, cleanup, etc.
+  console.log(chalk.blue('🧹 Running code cleanup...'));
+  
+  // Simulate cleanup work
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  // Update status to VERIFY
+  const updateResult = await updateRequirementsStatus(repoPath, 'VERIFY', `Cleanup complete for: ${currentTitle}`);
+  if (!updateResult.success) {
+    return updateResult;
+  }
+
+  console.log(chalk.green('✅ Cleanup complete'));
+  return { success: true };
+}
+
+/**
+ * Execute VERIFY stage
+ * @param {string} repoPath - Repository path
+ * @param {string} currentTitle - Current requirement title
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function executeVerifyStage(repoPath, currentTitle) {
+  console.log(chalk.cyan(`\n[${getTimestamp()}] ✅ VERIFY: ${currentTitle}`));
+  
+  // Run tests, verification, etc.
+  console.log(chalk.blue('🔍 Running verification...'));
+  
+  // Simulate verification work
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  // Update status to DONE
+  const updateResult = await updateRequirementsStatus(repoPath, 'DONE', `Verification complete for: ${currentTitle}`);
+  if (!updateResult.success) {
+    return updateResult;
+  }
+
+  console.log(chalk.green('✅ Verification complete'));
+  return { success: true };
+}
+
+/**
+ * Execute NOT_WORKING stage
+ * @param {string} repoPath - Repository path
+ * @param {string} currentTitle - Current requirement title
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function executeNotWorkingStage(repoPath, currentTitle) {
+  console.log(chalk.red(`\n[${getTimestamp()}] ❌ NOT_WORKING: ${currentTitle}`));
+  
+  // Move requirement to feedback section
+  const moveResult = await moveRequirementToFeedback(
+    repoPath, 
+    currentTitle, 
+    'Requirement marked as not working during auto mode execution'
+  );
+  
+  if (!moveResult.success) {
+    return moveResult;
+  }
+
+  console.log(chalk.yellow('📝 Requirement moved to feedback section'));
+  return { success: true };
+}
+
+/**
+ * Move to the next requirement
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function moveToNextRequirement(repoPath) {
+  // This would handle the logic to move to the next requirement
+  // For now, we'll just log that we're moving to the next requirement
+  console.log(chalk.blue('🔄 Moving to next requirement...'));
+  return { success: true };
+}
+
+module.exports = {
+  start,
+  executeCurrentStage,
+  runAutoModeLoop
+};

package/src/commands/auto-provider-management.js

@@ -0,0 +1,102 @@
+const chalk = require('chalk');
+const { getProviderDefinitions } = require('../utils/provider-registry');
+
+/**
+ * Provider Management Module for Auto Command
+ * Handles LLM provider operations and quota management
+ */
+
+/**
+ * Get available LLM providers from config and environment variables
+ * @param {Object} savedConfig - Config object from getAutoConfig()
+ * @returns {Array<{provider: string, model: string, apiKey?: string}>}
+ */
+function getAvailableProviders(savedConfig) {
+  const AutoModeBusinessLogic = require('vibecodingmachine-core/src/auto-mode/AutoModeBusinessLogic');
+  const autoModeLogic = new AutoModeBusinessLogic();
+  return autoModeLogic.getAvailableProviders(savedConfig);
+}
+
+/**
+ * List all available agents with their quota status
+ */
+async function listAgents() {
+  const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
+  const providerManager = new ProviderManager();
+
+  console.log(chalk.blue('\n📋 Available IDE Agents and Quota Status:\n'));
+
+  const formatTimeAmPm = (date) => {
+    const hours24 = date.getHours();
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const ampm = hours24 >= 12 ? 'pm' : 'am';
+    const hours12 = (hours24 % 12) || 12;
+    return `${hours12}:${minutes} ${ampm}`;
+  };
+
+  const { formatResetsAtLabel } = require('../utils/date-formatter');
+
+  // Get all provider definitions
+  const providers = getProviderDefinitions();
+
+  // Check each provider's quota status
+  for (const provider of providers) {
+    const hasSubAgents = Array.isArray(provider.subAgents) && provider.subAgents.length > 0;
+    const rateLimitInfo = hasSubAgents ? { isRateLimited: false } : providerManager.getRateLimitInfo(provider.id);
+
+    let statusIcon = '✅';
+    let statusText = chalk.green('Available');
+    let quotaInfo = '';
+
+    if (rateLimitInfo.isRateLimited) {
+      statusIcon = '⚠️';
+      statusText = chalk.yellow('Quota Limit');
+
+      if (rateLimitInfo.resetTime) {
+        const label = formatResetsAtLabel(rateLimitInfo.resetTime);
+        quotaInfo = label ? chalk.gray(` (${label})`) : '';
+      }
+
+      if (rateLimitInfo.reason) {
+        quotaInfo += chalk.gray(` - ${rateLimitInfo.reason}`);
+      }
+    }
+
+    console.log(`${statusIcon} ${chalk.cyan(provider.name)} ${statusText}${quotaInfo}`);
+    if (provider.description) {
+      console.log(`   ${chalk.gray(provider.description)}`);
+    }
+
+    // If provider has sub-agents, show them under the provider row
+    if (hasSubAgents) {
+      for (const sub of provider.subAgents) {
+        const subInfo = providerManager.getRateLimitInfo(provider.id, sub.model);
+
+        let subStatusIcon = '✅';
+        let subStatusText = chalk.green('Available');
+        let subQuotaInfo = '';
+
+        if (subInfo.isRateLimited) {
+          subStatusIcon = '⚠️';
+          subStatusText = chalk.yellow('Quota Limit');
+          if (subInfo.resetTime) {
+            const label = formatResetsAtLabel(subInfo.resetTime);
+            subQuotaInfo = label ? chalk.gray(` (${label})`) : '';
+          }
+          if (subInfo.reason) {
+            subQuotaInfo += chalk.gray(` - ${subInfo.reason}`);
+          }
+        }
+
+        console.log(`   ${subStatusIcon} ${chalk.cyan(sub.name)} ${subStatusText}${subQuotaInfo}`);
+      }
+    }
+  }
+
+  console.log(chalk.gray('\n💡 Tip: Auto mode will automatically skip quota-limited agents\n'));
+}
+
+module.exports = {
+  getAvailableProviders,
+  listAgents
+};

package/src/commands/auto-requirement-management.js

@@ -0,0 +1,161 @@
+/**
+ * Requirement Management Module for Auto Command
+ * Handles requirement operations and status tracking
+ */
+
+/**
+ * Check if current requirement is DONE and actually completed
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{isDone: boolean, actuallyComplete: boolean, reason?: string}>}
+ */
+async function isRequirementDone(repoPath) {
+  const AutoModeBusinessLogic = require('vibecodingmachine-core/src/auto-mode/AutoModeBusinessLogic');
+  const autoModeLogic = new AutoModeBusinessLogic();
+  return autoModeLogic.isRequirementDone(repoPath);
+}
+
+/**
+ * Move a requirement from Verified back to Requirements not yet completed
+ * @param {string} repoPath - Repository path
+ * @param {string} requirementText - The requirement text to move back
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function moveRequirementBackToTodo(repoPath, requirementText) {
+  const AutoModeBusinessLogic = require('vibecodingmachine-core/src/auto-mode/AutoModeBusinessLogic');
+  const autoModeLogic = new AutoModeBusinessLogic();
+  return autoModeLogic.moveRequirementBackToTodo(repoPath, requirementText);
+}
+
+/**
+ * Move a requirement from TODO to "Requirements needing manual feedback" section
+ * @param {string} repoPath - Repository path
+ * @param {string} requirementText - The requirement text to move
+ * @param {string} questions - Clarifying questions to add
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function moveRequirementToFeedback(repoPath, requirementText, questions, findings = null) {
+  const AutoModeBusinessLogic = require('vibecodingmachine-core/src/auto-mode/AutoModeBusinessLogic');
+  const autoModeLogic = new AutoModeBusinessLogic();
+  return autoModeLogic.moveRequirementToFeedback(repoPath, requirementText, questions, findings);
+}
+
+/**
+ * Move completed requirement from TODO to TO VERIFY section (for human verification)
+ * @param {string} repoPath - Repository path
+ * @param {string} completedRequirement - The completed requirement text
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function moveCompletedRequirement(repoPath, completedRequirement) {
+  const AutoModeBusinessLogic = require('vibecodingmachine-core/src/auto-mode/AutoModeBusinessLogic');
+  const autoModeLogic = new AutoModeBusinessLogic();
+  return autoModeLogic.moveCompletedRequirement(repoPath, completedRequirement);
+}
+
+/**
+ * Get current requirement details from REQUIREMENTS file
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{title: string, status: string}>}
+ */
+async function getCurrentRequirementDetails(repoPath) {
+  const { getRequirementsPath } = require('vibecodingmachine-core');
+  const fs = require('fs-extra');
+  const reqPath = await getRequirementsPath(repoPath);
+
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    // Find the "🔨 Current In Progress Requirement" section
+    let currentSectionIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes('🔨 Current In Progress Requirement')) {
+        currentSectionIndex = i;
+        break;
+      }
+    }
+
+    if (currentSectionIndex === -1) {
+      return { title: 'No current requirement found', status: 'UNKNOWN' };
+    }
+
+    // Look for the next requirement after the section header
+    for (let i = currentSectionIndex + 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith('- ')) {
+        const title = line.substring(2).trim();
+        
+        // Look for status in the next few lines
+        let status = 'UNKNOWN';
+        for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
+          if (lines[j].includes('🚦 Current Status')) {
+            const statusMatch = lines[j].match(/\[([A-Z_]+)\]/);
+            if (statusMatch) {
+              status = statusMatch[1];
+            }
+            break;
+          }
+        }
+        
+        return { title, status };
+      }
+    }
+
+    return { title: 'No current requirement found', status: 'UNKNOWN' };
+  } catch (error) {
+    console.error('Error reading requirements file:', error);
+    return { title: 'Error reading requirements', status: 'ERROR' };
+  }
+}
+
+/**
+ * Count requirements in each section
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{todo: number, inProgress: number, verified: number, feedback: number}>}
+ */
+async function getRequirementCounts(repoPath) {
+  const { getRequirementsPath, getVibeCodingMachineDir } = require('vibecodingmachine-core');
+  const fs = require('fs-extra');
+  const reqPath = await getRequirementsPath(repoPath);
+
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    const counts = {
+      todo: 0,
+      inProgress: 0,
+      verified: 0,
+      feedback: 0
+    };
+
+    let currentSection = '';
+
+    for (const line of lines) {
+      if (line.includes('Requirements not yet completed')) {
+        currentSection = 'todo';
+      } else if (line.includes('🔨 Current In Progress Requirement')) {
+        currentSection = 'inProgress';
+      } else if (line.includes('Verified by AI screenshot')) {
+        currentSection = 'verified';
+      } else if (line.includes('Requirements needing manual feedback')) {
+        currentSection = 'feedback';
+      } else if (line.trim().startsWith('- ') && currentSection) {
+        counts[currentSection]++;
+      }
+    }
+
+    return counts;
+  } catch (error) {
+    console.error('Error counting requirements:', error);
+    return { todo: 0, inProgress: 0, verified: 0, feedback: 0 };
+  }
+}
+
+module.exports = {
+  isRequirementDone,
+  moveRequirementBackToTodo,
+  moveRequirementToFeedback,
+  moveCompletedRequirement,
+  getCurrentRequirementDetails,
+  getRequirementCounts
+};