vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1835

package/src/commands/auto-direct/provider-manager.js

@@ -3,13 +3,16 @@
  * Extracted from auto-direct.js to reduce file size
  */
 
-const { getAutoConfig } = require('../../../utils/config');
+const chalk = require('chalk');
+const { getAutoConfig } = require('../../utils/config');
 const { getProviderPreferences, getProviderDefinition, saveProviderPreferences } = require('../../utils/provider-registry');
 const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
 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 { DirectLLMManager } = require('vibecodingmachine-core');
+const { DirectLLMManager, t } = require('vibecodingmachine-core');
+const { sleep } = require('./utils');
+const { printStatusCard } = require('./status-display');
 
 // CRITICAL: Shared ProviderManager instance to track rate limits across all function calls
 const sharedProviderManager = new ProviderManager();
@@ -146,7 +149,7 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
 
     const config = await getAutoConfig();
     const providerConfig = config.providers[forcedProvider];
-    
+
     if (!providerConfig || !providerConfig.enabled) {
       return {
         success: false,
@@ -154,7 +157,7 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
       };
     }
 
-    const availableModels = providerConfig.models.filter(m => 
+    const availableModels = providerConfig.models.filter(m =>
       m.enabled && m.name !== excludeModel
     );
 
@@ -187,7 +190,7 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
  */
 async function ensureClineInstalled(forceInstall = false) {
   const llm = new DirectLLMManager();
-  
+
   try {
     const isAvailable = await llm.checkClineAvailability();
     if (isAvailable && !forceInstall) {
@@ -196,7 +199,7 @@ async function ensureClineInstalled(forceInstall = false) {
 
     console.log('Installing Cline CLI...');
     const installResult = await llm.installCline();
-    
+
     if (installResult.success) {
       console.log('✅ Cline CLI installed successfully');
       return true;
@@ -210,10 +213,133 @@ async function ensureClineInstalled(forceInstall = false) {
   }
 }
 
+/**
+ * Handle rate limit scenarios with agent switching and waiting
+ */
+async function handleRateLimitWithAgentSwitching(selection, currentTitle, currentStatus) {
+  console.log(chalk.yellow(`\n⚠️  ${t('auto.direct.provider.all.rate.limited')}`));
+
+  // Notify GUI about waiting mode if available
+  try {
+    // Try to send status to GUI via IPC if running in Electron context
+    if (process.versions && process.versions.electron) {
+      const { ipcRenderer } = require('electron');
+      if (ipcRenderer) {
+        ipcRenderer.send('requirements-progress', {
+          stage: currentStatus,
+          requirement: currentTitle,
+          mode: 'waiting',
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+  } catch (e) {
+    // Ignore if not in Electron context
+  }
+
+  // Check if we have any providers that will be available soon
+  if (selection.nextResetTime && selection.nextResetMs) {
+    const waitMinutes = Math.max(1, Math.ceil(selection.nextResetMs / 60000));
+
+    console.log(chalk.yellow(`🔄 All enabled providers are currently rate limited.`));
+
+    if (selection.nextProvider && selection.nextResetTime) {
+      const resetTime = new Date(selection.nextResetTime).toLocaleTimeString();
+      const resetDate = new Date(selection.nextResetTime).toLocaleDateString();
+      console.log(chalk.yellow(`   Waiting for the next available agent (${selection.nextProvider.displayName}) to reset rate limit at ${resetTime} MST on ${resetDate}`));
+    } else {
+      console.log(chalk.yellow(`   Waiting for rate limits to reset...`));
+    }
+
+    // Update status card to waiting mode
+    printStatusCard(currentTitle, currentStatus, 'waiting');
+
+    // Note: CLI cannot directly send IPC events to Electron app
+    // The Electron app's emitAutoModeProgress function will handle rate limit detection
+
+    // Check for any provider becoming available within the next minute
+    const nearFutureProviders = selection.providers?.filter(p => {
+      if (!p.rateLimitResetTime) return false;
+      const resetMs = new Date(p.rateLimitResetTime).getTime() - Date.now();
+      return resetMs > 0 && resetMs <= 60000; // Within 1 minute
+    });
+
+    if (nearFutureProviders && nearFutureProviders.length > 0) {
+      const nextProvider = nearFutureProviders[0];
+      const nextResetMs = new Date(nextProvider.rateLimitResetTime).getTime() - Date.now();
+      const nextWaitMinutes = Math.max(1, Math.ceil(nextResetMs / 60000));
+      const resetTime = new Date(nextProvider.rateLimitResetTime).toLocaleTimeString();
+      const resetDate = new Date(nextProvider.rateLimitResetTime).toLocaleDateString();
+
+      console.log(chalk.cyan(`⏱️  ${nextProvider.displayName} will be available at ${resetTime} on ${resetDate}`));
+      console.log(chalk.gray(`   Waiting for ${nextProvider.displayName} to become available...\n`));
+
+      // Wait for the next available provider (max 1 minute chunks)
+      const waitChunks = Math.ceil(Math.min(nextResetMs, 60000) / 10000);
+      for (let i = 0; i < waitChunks; i++) {
+        await sleep(10000);
+        // Re-check provider status in case rate limits reset early
+        const freshSelection = await getProviderConfig();
+        if (freshSelection.status === 'ok') {
+          console.log(chalk.green(`✅ ${nextProvider.displayName} is now available!\n`));
+
+          // Notify GUI about returning to active mode
+          try {
+            if (process.versions && process.versions.electron) {
+              const { ipcRenderer } = require('electron');
+              if (ipcRenderer) {
+                ipcRenderer.send('requirements-progress', {
+                  stage: currentStatus,
+                  requirement: currentTitle,
+                  mode: 'active',
+                  timestamp: new Date().toISOString()
+                });
+              }
+            }
+          } catch (e) {
+            // Ignore if not in Electron context
+          }
+
+          return freshSelection;
+        }
+      }
+    } else {
+      // No providers available soon, wait for the next reset
+      console.log(chalk.gray(`   DEBUG: selection = ${JSON.stringify(selection, null, 2)}\n`));
+      if (selection.nextProvider && selection.nextResetTime) {
+        const resetTime = new Date(selection.nextResetTime).toLocaleTimeString();
+        const resetDate = new Date(selection.nextResetTime).toLocaleDateString();
+        console.log(chalk.gray(`   Waiting for ${selection.nextProvider.displayName} to reset at ${resetTime} MST on ${resetDate}...\n`));
+      } else {
+        console.log(chalk.gray(`   Waiting for rate limits to reset...\n`));
+      }
+      await sleep(Math.min(selection.nextResetMs, 60000));
+    }
+  } else {
+    // No reset time info, wait default 1 minute
+    const nextAvailableProvider = selection.providers?.find(p => p.rateLimitResetTime && p.rateLimitResetTime > Date.now());
+    if (nextAvailableProvider) {
+      const resetTime = new Date(nextAvailableProvider.rateLimitResetTime).toLocaleTimeString();
+      const resetDate = new Date(nextAvailableProvider.rateLimitResetTime).toLocaleDateString();
+      console.log(chalk.gray(`   Waiting for ${nextAvailableProvider.displayName} to reset at ${resetTime} MST on ${resetDate}...\n`));
+
+      // Note: CLI cannot directly send IPC events to Electron app
+      // The Electron app's emitAutoModeProgress function will handle rate limit detection
+    } else {
+      console.log(chalk.gray(`   Waiting for rate limits to reset...\n`));
+    }
+    printStatusCard(currentTitle, currentStatus, 'waiting');
+    await sleep(60000);
+  }
+
+  return null; // Signal to retry provider selection
+}
+
 module.exports = {
   getAllAvailableProviders,
   getProviderConfig,
   acquireProviderConfig,
   ensureClineInstalled,
+  handleRateLimitWithAgentSwitching,
   sharedProviderManager
 };

package/src/commands/auto-direct/requirement-manager.js

@@ -1,15 +1,30 @@
 /**
- * Requirement management functions for auto-direct command
- * Extracted from auto-direct.js to reduce file size
+ * Requirement Management Functions
+ * Extracted from auto-direct.js for better modularity
+ * Handles all operations related to requirements file management
  */
 
 const fs = require('fs-extra');
 const path = require('path');
-const { getRequirementsPath, readRequirements } = require('vibecodingmachine-core');
 const chalk = require('chalk');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const { t } = require('vibecodingmachine-core');
+const { getStages, DEFAULT_STAGES } = require('../../utils/config');
+const { moveRequirementToVerify, moveRequirementToRecycle } = require('./requirement-mover');
+
+// Configured stages (will be loaded in handleAutoStart)
+let configuredStages = DEFAULT_STAGES;
 
 /**
- * Update requirements file status
+ * Set configured stages for status updates
+ * @param {Array} stages - Array of stage names
+ */
+function setConfiguredStages(stages) {
+  configuredStages = stages;
+}
+
+/**
+ * Update status section in requirements file
  * @param {string} repoPath - Repository path
  * @param {string} status - Status to set (PREPARE, ACT, CLEAN UP, VERIFY, DONE)
  */
@@ -20,24 +35,59 @@ async function updateRequirementsStatus(repoPath, status) {
       return;
     }
 
-    let content = await fs.readFile(reqPath, 'utf8');
-    
-    // Find and replace the status section
-    const statusSectionRegex = /## 🚦 Current Status\s*\n\s*\n(.+?)(?=\n##|\n$)/s;
-    const match = content.match(statusSectionRegex);
-    
-    if (match) {
-      content = content.replace(statusSectionRegex, `## 🚦 Current Status\n\n${status}`);
+    const content = await fs.readFile(reqPath, 'utf-8');
+    const lines = content.split('\n');
+    let inStatusSection = false;
+    let statusLineIndex = -1;
+
+    // Find the status section and the line with the status
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.includes('🚦 Current Status')) {
+        inStatusSection = true;
+        continue;
+      }
+
+      if (inStatusSection && line.startsWith('##') && !line.startsWith('###')) {
+        // End of status section, status line not found
+        break;
+      }
+
+      // Check against configured stages
+      if (inStatusSection && configuredStages.includes(line.trim())) {
+        statusLineIndex = i;
+        break;
+      }
+    }
+
+    // Update or add the status line
+    if (statusLineIndex >= 0) {
+      // Replace existing status
+      lines[statusLineIndex] = status;
+    } else if (inStatusSection) {
+      // Add status after the section header
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes('🚦 Current Status')) {
+          lines.splice(i + 1, 0, status);
+          break;
+        }
+      }
     } else {
-      // If no status section found, add it after the first line
-      const lines = content.split('\n');
-      lines.splice(1, 0, '', '## 🚦 Current Status', '', status);
-      content = lines.join('\n');
+      // Status section doesn't exist - find the requirement and add it
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith('### ') && !lines[i].includes('🚦 Current Status')) {
+          // Found a requirement header, add status section after it
+          lines.splice(i + 1, 0, '', '#### 🚦 Current Status', status);
+          break;
+        }
+      }
     }
-    
-    await fs.writeFile(reqPath, content);
+
+    await fs.writeFile(reqPath, lines.join('\n'));
   } catch (error) {
-    console.error('Error updating requirements status:', error.message);
+    // Silently fail - don't break execution if status update fails
+    console.error(chalk.gray(`   ${t('auto.direct.status.update.warning')} ${error.message}`));
   }
 }
 
@@ -52,15 +102,78 @@ async function getCurrentRequirement(repoPath) {
     }
 
     const content = await fs.readFile(reqPath, 'utf8');
-    const currentSection = content.match(/## 🔨 Current In Progress Requirement\s*\n([\s\S]*?)(?=\n## |\n$)/);
-    
-    if (currentSection) {
-      return currentSection[1].trim();
+
+    // Always skip DISABLED: requirements (user can toggle via TRUI Space key)
+
+    // Extract first TODO requirement (new header format)
+    const lines = content.split('\n');
+    let inTodoSection = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // Check if we're in the TODO section
+      if (line.includes('## ⏳ Requirements not yet completed') ||
+        line.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
+
+      // If we hit another section header, stop looking
+      if (inTodoSection && line.startsWith('##') && !line.startsWith('###')) {
+        break;
+      }
+
+      // If we're in TODO section and find a requirement header (###)
+      if (inTodoSection && line.startsWith('###')) {
+        const title = line.replace(/^###\s*/, '').trim();
+        // Skip empty titles
+        if (title && title.length > 0) {
+          // Always skip DISABLED: requirements
+          if (title.startsWith('DISABLED:')) {
+            continue;
+          }
+
+          // Read package and description (optional)
+          let pkg = null;
+          let description = '';
+          let j = i + 1;
+
+          // Read next few lines for package and description
+          while (j < lines.length && j < i + 20) {
+            const nextLine = lines[j].trim();
+            // Stop if we hit another requirement or section
+            if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+              break;
+            }
+            // Check for PACKAGE line
+            if (nextLine.startsWith('PACKAGE:')) {
+              pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+            } else if (nextLine && !nextLine.startsWith('PACKAGE:')) {
+              // Description line (not empty, not package)
+              if (description) {
+                description += '\n' + nextLine;
+              } else {
+                description = nextLine;
+              }
+            }
+            j++;
+          }
+
+          return {
+            text: title,
+            fullLine: lines[i],
+            package: pkg,
+            description: description,
+            disabled: false
+          };
+        }
+      }
     }
-    
+
     return null;
-  } catch (error) {
-    console.error('Error getting current requirement:', error.message);
+  } catch (err) {
+    console.error(t('auto.direct.requirement.read.error'), err.message);
     return null;
   }
 }
@@ -76,94 +189,46 @@ async function countTodoRequirements(repoPath) {
     }
 
     const content = await fs.readFile(reqPath, 'utf8');
-    const todoSection = content.match(/## Requirements not yet completed\s*\n([\s\S]*?)(?=\n## |\n$)/);
-    
-    if (todoSection) {
-      const todoItems = todoSection[1].match(/^- \[ \]/g);
-      return todoItems ? todoItems.length : 0;
-    }
-    
-    return 0;
-  } catch (error) {
-    console.error('Error counting TODO requirements:', error.message);
-    return 0;
-  }
-}
+    const lines = content.split('\n');
+    let inTodoSection = false;
+    let count = 0;
 
-/**
- * Move requirement from TODO to TO VERIFY BY HUMAN
- */
-async function moveRequirementToVerify(repoPath, requirementText) {
-  try {
-    const reqPath = await getRequirementsPath(repoPath);
-    if (!reqPath || !await fs.pathExists(reqPath)) {
-      return;
-    }
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
 
-    let content = await fs.readFile(reqPath, 'utf8');
-    
-    // Remove from TODO section
-    const todoSection = content.match(/## Requirements not yet completed\s*\n([\s\S]*?)(?=\n## |\n$)/);
-    if (todoSection) {
-      const updatedTodo = todoSection[1].replace(new RegExp(`- \\[ \\] ${escapeRegExp(requirementText)}`, 'g'), '');
-      content = content.replace(todoSection[0], `## Requirements not yet completed\n${updatedTodo}`);
-    }
-    
-    // Add to verify section
-    const verifySection = content.match(/## Verified by AI screenshot\. Needs Human to Verify and move to CHANGELOG\s*\n([\s\S]*?)(?=\n## |\n$)/);
-    if (verifySection) {
-      const newVerifyItem = `- [ ] ${requirementText}`;
-      const updatedVerify = verifySection[1] + '\n' + newVerifyItem;
-      content = content.replace(verifySection[0], `## Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG\n${updatedVerify}`);
-    }
-    
-    await fs.writeFile(reqPath, content);
-  } catch (error) {
-    console.error('Error moving requirement to verify:', error.message);
-  }
-}
+      // Check if we're in the TODO section
+      if (line.includes('## ⏳ Requirements not yet completed') ||
+        line.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
 
-/**
- * Move requirement to recycled section
- */
-async function moveRequirementToRecycle(repoPath, requirementText) {
-  try {
-    const reqPath = await getRequirementsPath(repoPath);
-    if (!reqPath || !await fs.pathExists(reqPath)) {
-      return;
-    }
+      // If we hit another section header, stop looking
+      if (inTodoSection && line.startsWith('##') && !line.startsWith('###')) {
+        break;
+      }
 
-    let content = await fs.readFile(reqPath, 'utf8');
-    
-    // Remove from TODO section
-    const todoSection = content.match(/## Requirements not yet completed\s*\n([\s\S]*?)(?=\n## |\n$)/);
-    if (todoSection) {
-      const updatedTodo = todoSection[1].replace(new RegExp(`- \\[ \\] ${escapeRegExp(requirementText)}`, 'g'), '');
-      content = content.replace(todoSection[0], `## Requirements not yet completed\n${updatedTodo}`);
-    }
-    
-    // Add to recycled section
-    const recycledSection = content.match(/## Recycled Requirements \(do not work on\)\s*\n([\s\S]*?)(?=\n## |\n$)/);
-    if (recycledSection) {
-      const newRecycledItem = `- [ ] ${requirementText}`;
-      const updatedRecycled = recycledSection[1] + '\n' + newRecycledItem;
-      content = content.replace(recycledSection[0], `## Recycled Requirements (do not work on)\n${updatedRecycled}`);
+      // If we're in TODO section and find a requirement header (###)
+      if (inTodoSection && line.startsWith('###')) {
+        const title = line.replace(/^###\s*/, '').trim();
+        // Only count non-empty titles
+        if (title && title.length > 0) {
+          count++;
+        }
+      }
     }
-    
-    await fs.writeFile(reqPath, content);
-  } catch (error) {
-    console.error('Error moving requirement to recycle:', error.message);
+
+    return count;
+  } catch (err) {
+    console.error(t('auto.direct.requirement.count.error'), err.message);
+    return 0;
   }
 }
 
-/**
- * Escape special characters for regex
- */
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
+// moveRequirementToVerify and moveRequirementToRecycle are imported from requirement-mover.js
 
 module.exports = {
+  setConfiguredStages,
   updateRequirementsStatus,
   getCurrentRequirement,
   countTodoRequirements,