vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

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

@@ -0,0 +1,439 @@
+/**
+ * Auto Mode Utilities
+ * 
+ * Shared utility functions for auto mode operations
+ */
+
+const chalk = require('chalk');
+const stringWidth = require('string-width');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Get timestamp for logging
+ */
+function getTimestamp() {
+  const now = new Date();
+  return now.toLocaleTimeString('en-US', {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  });
+}
+
+/**
+ * Get a human-friendly timestamp for log prefixes that includes date, time, and timezone
+ * Example: "2025-01-02 3:45 PM MST"
+ */
+function getLogTimestamp(date = new Date()) {
+  const datePart = date.toISOString().split('T')[0]; // YYYY-MM-DD
+  const timePart = date.toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    timeZoneName: 'short'
+  });
+  
+  return `${datePart} ${timePart}`;
+}
+
+/**
+ * Translate workflow stage names
+ */
+function translateStage(stage) {
+  const stageMap = {
+    'PREPARE': 'workflow.stage.prepare',
+    'REPRODUCE': 'workflow.stage.reproduce',
+    'ACT': 'workflow.stage.act',
+    'CLEAN UP': 'workflow.stage.cleanup',
+    'VERIFY': 'workflow.stage.verify',
+    'DONE': 'workflow.stage.done'
+  };
+  
+  return stageMap[stage] || stage;
+}
+
+/**
+ * Strip ANSI escape codes from a string
+ */
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B\[[0-9;]*[mGKH]/g, '');
+}
+
+/**
+ * Get visual width of a string accounting for ANSI codes, emojis, and wide characters
+ * Uses string-width library for accurate Unicode width calculation
+ */
+function getVisualWidth(str) {
+  return stringWidth(str);
+}
+
+/**
+ * Pad string to visual width accounting for emojis, ANSI codes, and wide characters
+ */
+function padToVisualWidth(str, targetWidth) {
+  const visualWidth = getVisualWidth(str);
+  const paddingNeeded = targetWidth - visualWidth;
+  if (paddingNeeded <= 0) {
+    return str;
+  }
+  return str + ' '.repeat(paddingNeeded);
+}
+
+/**
+ * Check if message indicates rate limiting
+ */
+function isRateLimitMessage(text) {
+  if (!text) return false;
+  const lower = text.toLowerCase();
+  return lower.includes('rate limit') ||
+         lower.includes('too many requests') ||
+         lower.includes('limit reached');
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Safely log to console with EPIPE protection
+ */
+function safeLog(...args) {
+  try {
+    // Check if stdout is still writable before attempting to log
+    if (process.stdout && !process.stdout.destroyed) {
+      console.log(...args);
+    }
+  } catch (error) {
+    // Ignore EPIPE errors - common when piping output
+    if (error.code !== 'EPIPE') {
+      // For other errors, try writing to stderr
+      try {
+        if (process.stderr && !process.stderr.destroyed) {
+          console.error(...args);
+        }
+      } catch (stderrError) {
+        // If both fail, silently ignore
+      }
+    }
+  }
+}
+
+/**
+ * Update requirements status in file
+ */
+async function updateRequirementsStatus(repoPath, status) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return;
+    }
+
+    let content = await fs.readFile(reqPath, 'utf8');
+    
+    // Find and update status line
+    const statusLineRegex = /^## Current Status:.*$/m;
+    const newStatusLine = `## Current Status: ${status}`;
+    
+    if (statusLineRegex.test(content)) {
+      content = content.replace(statusLineRegex, newStatusLine);
+    } else {
+      // Add status line after first line if not found
+      const lines = content.split('\n');
+      lines.splice(1, 0, newStatusLine);
+      content = lines.join('\n');
+    }
+    
+    await fs.writeFile(reqPath, content, 'utf8');
+  } catch (error) {
+    console.error('Error updating requirements status:', error.message);
+  }
+}
+
+/**
+ * Get current requirement from REQUIREMENTS file
+ */
+async function getCurrentRequirement(repoPath) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return null;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    // Look for current status section
+    let currentSection = null;
+    let currentRequirement = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.startsWith('## Current Status:')) {
+        currentSection = 'current';
+        continue;
+      }
+      
+      if (line.startsWith('##') && currentSection === 'current') {
+        break;
+      }
+      
+      if (currentSection === 'current' && line.startsWith('###')) {
+        currentRequirement = line.replace(/^###\s*/, '').trim();
+        break;
+      }
+    }
+    
+    return currentRequirement;
+  } catch (error) {
+    console.error('Error getting current requirement:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Count total TODO requirements
+ */
+async function countTodoRequirements(repoPath) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return 0;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    let inTodoSection = false;
+    let count = 0;
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      if (trimmed === '## TODO') {
+        inTodoSection = true;
+        continue;
+      }
+      
+      if (trimmed.startsWith('##') && inTodoSection) {
+        break;
+      }
+      
+      if (inTodoSection && trimmed.startsWith('###')) {
+        count++;
+      }
+    }
+    
+    return count;
+  } catch (error) {
+    console.error('Error counting TODO requirements:', error.message);
+    return 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;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    // Find the requirement by its title
+    const normalizedRequirement = requirementText.trim();
+    const snippet = normalizedRequirement.substring(0, 80);
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+    let inTodoSection = false;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.trim() === '## TODO') {
+        inTodoSection = true;
+        continue;
+      }
+      
+      if (line.trim().startsWith('##') && inTodoSection) {
+        break;
+      }
+      
+      if (inTodoSection && line.trim().startsWith('###')) {
+        const title = line.replace(/^###\s*/, '').trim();
+        if (title.includes(snippet) || title === normalizedRequirement) {
+          requirementStartIndex = i;
+          
+          // Find end of requirement
+          for (let j = i + 1; j < lines.length; j++) {
+            if (lines[j].trim().startsWith('###') || lines[j].trim().startsWith('##')) {
+              requirementEndIndex = j;
+              break;
+            }
+          }
+          
+          if (requirementEndIndex === -1) {
+            requirementEndIndex = lines.length;
+          }
+          
+          break;
+        }
+      }
+    }
+    
+    if (requirementStartIndex === -1) {
+      console.warn('Requirement not found in TODO section:', requirementText);
+      return;
+    }
+    
+    // Extract the requirement block
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    
+    // Remove from TODO
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+    
+    // Find TO VERIFY BY HUMAN section and add requirement
+    let verifyIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim() === '## TO VERIFY BY HUMAN') {
+        verifyIndex = i + 1;
+        break;
+      }
+    }
+    
+    if (verifyIndex === -1) {
+      // Create section if it doesn't exist
+      lines.push('## TO VERIFY BY HUMAN');
+      verifyIndex = lines.length;
+    }
+    
+    // Insert requirement
+    lines.splice(verifyIndex, 0, ...requirementBlock);
+    
+    // Write back to file
+    await fs.writeFile(reqPath, lines.join('\n'), 'utf8');
+    
+    console.log(chalk.green(`Moved requirement to verify: ${requirementText}`));
+  } catch (error) {
+    console.error('Error moving requirement to verify:', error.message);
+  }
+}
+
+/**
+ * Move requirement to recycled section
+ */
+async function moveRequirementToRecycle(repoPath, requirementText) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    // Find and remove requirement from current section
+    const normalizedRequirement = requirementText.trim();
+    const snippet = normalizedRequirement.substring(0, 80);
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+    let inCurrentSection = false;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.trim().startsWith('## Current Status:')) {
+        inCurrentSection = true;
+        continue;
+      }
+      
+      if (line.trim().startsWith('##') && inCurrentSection) {
+        break;
+      }
+      
+      if (inCurrentSection && line.trim().startsWith('###')) {
+        const title = line.replace(/^###\s*/, '').trim();
+        if (title.includes(snippet) || title === normalizedRequirement) {
+          requirementStartIndex = i;
+          
+          // Find end of requirement
+          for (let j = i + 1; j < lines.length; j++) {
+            if (lines[j].trim().startsWith('###') || lines[j].trim().startsWith('##')) {
+              requirementEndIndex = j;
+              break;
+            }
+          }
+          
+          if (requirementEndIndex === -1) {
+            requirementEndIndex = lines.length;
+          }
+          
+          break;
+        }
+      }
+    }
+    
+    if (requirementStartIndex === -1) {
+      console.warn('Requirement not found in current section:', requirementText);
+      return;
+    }
+    
+    // Extract the requirement block
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    
+    // Remove from current section
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+    
+    // Find RECYCLED section and add requirement
+    let recycleIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim() === '## RECYCLED') {
+        recycleIndex = i + 1;
+        break;
+      }
+    }
+    
+    if (recycleIndex === -1) {
+      // Create section if it doesn't exist
+      lines.push('## RECYCLED');
+      recycleIndex = lines.length;
+    }
+    
+    // Add timestamp and requirement
+    const timestamp = new Date().toISOString();
+    lines.splice(recycleIndex, 0, `### ${requirementText}`, `*Recycled: ${timestamp}*`);
+    
+    // Write back to file
+    await fs.writeFile(reqPath, lines.join('\n'), 'utf8');
+    
+    console.log(chalk.yellow(`Recycled requirement: ${requirementText}`));
+  } catch (error) {
+    console.error('Error recycling requirement:', error.message);
+  }
+}
+
+module.exports = {
+  getTimestamp,
+  getLogTimestamp,
+  translateStage,
+  stripAnsi,
+  getVisualWidth,
+  padToVisualWidth,
+  isRateLimitMessage,
+  sleep,
+  safeLog,
+  updateRequirementsStatus,
+  getCurrentRequirement,
+  countTodoRequirements,
+  moveRequirementToVerify,
+  moveRequirementToRecycle
+};

package/src/commands/auto-direct/file-operations.js

@@ -0,0 +1,110 @@
+/**
+ * File operations for auto-direct mode
+ * Handles file searching, parsing LLM responses, and applying changes
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { t } = require('vibecodingmachine-core');
+
+/**
+ * Parse CREATE and FILE/SEARCH/REPLACE blocks from LLM response
+ */
+function parseSearchReplaceBlocks(response) {
+  const changes = [];
+
+  // Match CREATE: path CONTENT: ``` content ``` format for new files
+  const createRegex = /CREATE:\s*(.+?)\nCONTENT:\s*```(?:[a-z]*)\n([\s\S]+?)```/g;
+
+  let match;
+  while ((match = createRegex.exec(response)) !== null) {
+    let filePath = match[1].trim();
+    const content = match[2];
+
+    // Clean up file path - remove "---" prefix if present
+    filePath = filePath.replace(/^---\s*/, '').trim();
+
+    changes.push({
+      type: 'create',
+      file: filePath,
+      content: content
+    });
+  }
+
+  // Match FILE: path SEARCH: ``` old ``` REPLACE: ``` new ``` format for modifications
+  const blockRegex = /FILE:\s*(.+?)\nSEARCH:\s*```(?:[a-z]*)\n([\s\S]+?)```\s*REPLACE:\s*```(?:[a-z]*)\n([\s\S]+?)```/g;
+
+  while ((match = blockRegex.exec(response)) !== null) {
+    let filePath = match[1].trim();
+    const searchText = match[2];
+    const replaceText = match[3];
+
+    // Clean up file path - remove "---" prefix if present
+    filePath = filePath.replace(/^---\s*/, '').trim();
+
+    changes.push({
+      type: 'modify',
+      file: filePath,
+      search: searchText,
+      replace: replaceText
+    });
+  }
+
+  return changes;
+}
+
+/**
+ * Normalize whitespace for comparison
+ */
+function normalizeWhitespace(str) {
+  return str.replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Extract key identifiers from code (variable names, function names, strings)
+ */
+function extractIdentifiers(code) {
+  const identifiers = new Set();
+
+  // Extract quoted strings
+  const stringMatches = code.match(/'([^']+)'|"([^"]+)"/g);
+  if (stringMatches) {
+    stringMatches.forEach(match => {
+      const str = match.slice(1, -1);
+      if (str.length > 3) {
+        identifiers.add(str);
+      }
+    });
+  }
+
+  // Extract variable/function names
+  const nameMatches = code.match(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[:=]/g);
+  if (nameMatches) {
+    nameMatches.forEach(match => {
+      const name = match.replace(/[:=].*$/, '').trim();
+      if (name.length > 2) {
+        identifiers.add(name);
+      }
+    });
+  }
+
+  return Array.from(identifiers);
+}
+
+/**
+ * Extract structural pattern from code
+ */
+function extractPattern(code) {
+  let pattern = code.replace(/'[^']+'|"[^"]+"/g, '"..."');
+  pattern = pattern.replace(/\b\d+\b/g, 'N');
+  pattern = normalizeWhitespace(pattern);
+  return pattern;
+}
+
+module.exports = {
+  parseSearchReplaceBlocks,
+  normalizeWhitespace,
+  extractIdentifiers,
+  extractPattern
+};

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

@@ -3,7 +3,7 @@
  * Extracted from auto-direct.js to reduce file size
  */
 
-const { getAutoConfig } = require('../../utils/config');
+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');

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

@@ -3,7 +3,7 @@
  * Extracted from auto-direct.js to reduce file size
  */
 
-const { getAutoConfig } = require('../../utils/config');
+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');

package/src/commands/auto-direct/status-display.js

@@ -4,7 +4,7 @@
  */
 
 const chalk = require('chalk');
-const { getAutoConfig, getStages, DEFAULT_STAGES } = require('../../utils/config');
+const { getAutoConfig, getStages, DEFAULT_STAGES } = require('../../../utils/config');
 
 // Configured stages (will be loaded from config)
 let configuredStages = DEFAULT_STAGES;

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

@@ -1,32 +1,34 @@
 /**
- * Utility functions for auto-direct command
- * Extracted from auto-direct.js to reduce file size
+ * Utility functions for auto-direct mode
  */
 
 const chalk = require('chalk');
 const stringWidth = require('string-width');
+const { t } = require('vibecodingmachine-core');
 
 /**
- * Get timestamp for logging
+ * Get timestamp in MST
  */
 function getTimestamp() {
   const now = new Date();
   return now.toLocaleTimeString('en-US', {
     hour: '2-digit',
     minute: '2-digit',
-    second: '2-digit'
-  });
+    hour12: false,
+    timeZone: 'America/Denver'
+  }) + ' MST';
 }
 
 /**
- * Get a human-friendly timestamp for log prefixes that includes date, time, and timezone
- * Example: "2025-01-02 3:45 PM MST"
+ * Get a human-friendly timestamp for log prefixes
  */
 function getLogTimestamp(date = new Date()) {
-  const datePart = date.toISOString().split('T')[0]; // YYYY-MM-DD
+  const datePart = date.toISOString().split('T')[0];
   const timePart = date.toLocaleTimeString('en-US', {
     hour: 'numeric',
     minute: '2-digit',
+    hour12: true,
+    timeZone: 'America/Denver',
     timeZoneName: 'short'
   });
   return `${datePart} ${timePart}`;
@@ -39,32 +41,34 @@ function translateStage(stage) {
   const stageMap = {
     'PREPARE': 'workflow.stage.prepare',
     'REPRODUCE': 'workflow.stage.reproduce',
+    'CREATE UNIT TEST': 'workflow.stage.create.unit.test',
     'ACT': 'workflow.stage.act',
-    'CLEAN UP': 'workflow.stage.cleanup',
+    'CLEAN UP': 'workflow.stage.clean.up',
     'VERIFY': 'workflow.stage.verify',
+    'RUN UNIT TESTS': 'workflow.stage.run.unit.tests',
     'DONE': 'workflow.stage.done'
   };
-  return stageMap[stage] || stage;
+
+  const key = stageMap[stage];
+  return key ? t(key) : stage;
 }
 
 /**
  * Strip ANSI escape codes from a string
  */
 function stripAnsi(str) {
-  // eslint-disable-next-line no-control-regex
   return str.replace(/\x1B\[[0-9;]*[mGKH]/g, '');
 }
 
 /**
- * Get visual width of a string accounting for ANSI codes, emojis, and wide characters
- * Uses string-width library for accurate Unicode width calculation
+ * Get visual width accounting for ANSI, emojis, wide characters
  */
 function getVisualWidth(str) {
   return stringWidth(str);
 }
 
 /**
- * Pad string to visual width accounting for emojis, ANSI codes, and wide characters
+ * Pad string to visual width
  */
 function padToVisualWidth(str, targetWidth) {
   const visualWidth = getVisualWidth(str);
@@ -82,13 +86,15 @@ function isRateLimitMessage(text) {
   if (!text) return false;
   const lower = text.toLowerCase();
   return lower.includes('rate limit') ||
-         lower.includes('rate limited') ||
-         lower.includes('too many requests') ||
-         lower.includes('limit reached');
+    lower.includes('too many requests') ||
+    lower.includes('429') ||
+    lower.includes('weekly limit') ||
+    lower.includes('daily limit') ||
+    lower.includes('limit reached');
 }
 
 /**
- * Sleep for specified milliseconds
+ * Sleep helper
  */
 function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));