vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,172 @@
+/**
+ * Requirement management functions for auto-direct command
+ * Extracted from auto-direct.js to reduce file size
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { getRequirementsPath, readRequirements } = require('vibecodingmachine-core');
+const chalk = require('chalk');
+
+/**
+ * Update requirements file status
+ * @param {string} repoPath - Repository path
+ * @param {string} status - Status to set (PREPARE, ACT, CLEAN UP, VERIFY, DONE)
+ */
+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 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}`);
+    } 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');
+    }
+    
+    await fs.writeFile(reqPath, content);
+  } 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 currentSection = content.match(/## 🔨 Current In Progress Requirement\s*\n([\s\S]*?)(?=\n## |\n$)/);
+    
+    if (currentSection) {
+      return currentSection[1].trim();
+    }
+    
+    return null;
+  } 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 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;
+  }
+}
+
+/**
+ * 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;
+    }
+
+    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);
+  }
+}
+
+/**
+ * Move requirement to recycled section
+ */
+async function moveRequirementToRecycle(repoPath, requirementText) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return;
+    }
+
+    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}`);
+    }
+    
+    await fs.writeFile(reqPath, content);
+  } catch (error) {
+    console.error('Error moving requirement to recycle:', error.message);
+  }
+}
+
+/**
+ * Escape special characters for regex
+ */
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = {
+  updateRequirementsStatus,
+  getCurrentRequirement,
+  countTodoRequirements,
+  moveRequirementToVerify,
+  moveRequirementToRecycle
+};

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

@@ -0,0 +1,91 @@
+/**
+ * Status display functions for auto-direct command
+ * Extracted from auto-direct.js to reduce file size
+ */
+
+const chalk = require('chalk');
+const { getAutoConfig, getStages, DEFAULT_STAGES } = require('../../utils/config');
+
+// Configured stages (will be loaded from config)
+let configuredStages = DEFAULT_STAGES;
+
+/**
+ * Print status card showing current stage
+ * Uses full terminal width
+ * Now uses persistent header that stays at top while output scrolls
+ */
+function printStatusCard(currentTitle, currentStatus) {
+  const stages = configuredStages;
+  const stageMap = {};
+  stages.forEach((s, i) => stageMap[s] = i);
+
+  // Get terminal width
+  const terminalWidth = process.stdout.columns || 80;
+  
+  // Calculate widths
+  const padding = 2;
+  const maxTitleWidth = Math.floor((terminalWidth - padding * 2) * 0.4);
+  const maxStatusWidth = Math.floor((terminalWidth - padding * 2) * 0.6);
+  
+  // Truncate title if too long
+  let displayTitle = currentTitle;
+  if (displayTitle.length > maxTitleWidth) {
+    displayTitle = displayTitle.substring(0, maxTitleWidth - 3) + '...';
+  }
+  
+  // Build status line
+  let statusLine = '';
+  stages.forEach((stage, index) => {
+    const isCurrent = stage === currentStatus;
+    const isCompleted = stageMap[currentStatus] > index;
+    const isPending = stageMap[currentStatus] < index;
+    
+    let stageDisplay = stage;
+    if (stage === 'PREPARE') stageDisplay = '🔍 PREPARE';
+    else if (stage === 'ACT') stageDisplay = '⚡ ACT';
+    else if (stage === 'CLEAN UP') stageDisplay = '🧹 CLEAN UP';
+    else if (stage === 'VERIFY') stageDisplay = '✅ VERIFY';
+    else if (stage === 'DONE') stageDisplay = '🎉 DONE';
+    
+    if (isCurrent) {
+      statusLine += chalk.bgBlue.white(` ${stageDisplay} `);
+    } else if (isCompleted) {
+      statusLine += chalk.bgGreen.black(` ${stageDisplay} `);
+    } else if (isPending) {
+      statusLine += chalk.bgGray.white(` ${stageDisplay} `);
+    }
+    
+    if (index < stages.length - 1) {
+      statusLine += ' ';
+    }
+  });
+  
+  // Build the card
+  const border = '─'.repeat(terminalWidth);
+  const titleLine = displayTitle.padEnd(terminalWidth - padding * 2);
+  const statusLinePadded = statusLine.padEnd(terminalWidth - padding * 2);
+  
+  console.log();
+  console.log(chalk.gray(border));
+  console.log(chalk.gray(`│ ${titleLine} │`));
+  console.log(chalk.gray(`│ ${statusLinePadded} │`));
+  console.log(chalk.gray(border));
+  console.log();
+}
+
+/**
+ * Load configured stages from config
+ */
+async function loadConfiguredStages() {
+  try {
+    configuredStages = await getStages();
+  } catch (error) {
+    console.warn('Warning: Could not load configured stages, using defaults');
+    configuredStages = DEFAULT_STAGES;
+  }
+}
+
+module.exports = {
+  printStatusCard,
+  loadConfiguredStages
+};

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

@@ -0,0 +1,106 @@
+/**
+ * Utility functions for auto-direct command
+ * Extracted from auto-direct.js to reduce file size
+ */
+
+const chalk = require('chalk');
+const stringWidth = require('string-width');
+
+/**
+ * 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('rate limited') ||
+         lower.includes('too many requests') ||
+         lower.includes('limit reached');
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  getTimestamp,
+  getLogTimestamp,
+  translateStage,
+  stripAnsi,
+  getVisualWidth,
+  padToVisualWidth,
+  isRateLimitMessage,
+  sleep
+};