vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/requirement-helpers/requirement-parser.js

@@ -0,0 +1,326 @@
+/**
+ * Requirement Parser Utilities
+ * Utility functions for parsing and processing requirement text
+ */
+
+// Default instruction text
+const DEFAULT_INSTRUCTION_TEXT = 'Follow INSTRUCTIONS.md from .vibecodingmachine directory. CRITICAL: You MUST work through ALL status stages (PREPARE → ACT → CLEAN UP → VERIFY → DONE) and set the status to DONE in the REQUIREMENTS file before stopping. DO NOT stop working until the "🚦 Current Status" section shows "DONE". The VibeCodingMachine app is running in autonomous mode and depends on you completing the requirement fully.';
+
+/**
+ * Get ordinal suffix for numbers (1st, 2nd, 3rd, 4th, etc.)
+ * @param {number} num - The number
+ * @returns {string} The ordinal suffix
+ */
+function getOrdinalSuffix(num) {
+  const j = num % 10;
+  const k = num % 100;
+  if (j === 1 && k !== 11) {
+    return 'st';
+  }
+  if (j === 2 && k !== 12) {
+    return 'nd';
+  }
+  if (j === 3 && k !== 13) {
+    return 'rd';
+  }
+  return 'th';
+}
+
+/**
+ * Add or increment TRY AGAIN prefix to requirement text
+ * @param {string} requirementText - The requirement text
+ * @returns {string} Requirement text with TRY AGAIN prefix
+ */
+function addTryAgainPrefix(requirementText) {
+  const tryAgainMatch = requirementText.match(/^TRY AGAIN \((\d+)(?:st|nd|rd|th) time\): (.+)$/);
+
+  if (tryAgainMatch) {
+    const currentCount = parseInt(tryAgainMatch[1]);
+    const baseRequirement = tryAgainMatch[2];
+    return `TRY AGAIN (${currentCount + 1}${getOrdinalSuffix(currentCount + 1)} time): ${baseRequirement}`;
+  } else {
+    return `TRY AGAIN (1st time): ${requirementText}`;
+  }
+}
+
+/**
+ * Parse requirement from markdown line
+ * @param {string} line - Markdown line (e.g., "- Requirement text")
+ * @returns {string} Requirement text without markdown prefix
+ */
+function parseRequirementLine(line) {
+  if (line.startsWith('- ')) {
+    return line.substring(2);
+  }
+  return line;
+}
+
+/**
+ * Extract requirement title from line (removes timestamp if present)
+ * @param {string} line - Requirement line
+ * @returns {string} Requirement title without timestamp
+ */
+function extractRequirementTitle(line) {
+  const lineText = parseRequirementLine(line);
+  // Extract title part (before timestamp in parentheses)
+  const titleMatch = lineText.match(/^(.+?)\s*\([\d-]+\)$/);
+  return titleMatch ? titleMatch[1] : lineText;
+}
+
+/**
+ * Check if a line contains a requirement title
+ * @param {string} line - Line to check
+ * @param {string} requirementTitle - Requirement title to match
+ * @returns {boolean} Whether the line contains the requirement title
+ */
+function isRequirementMatch(line, requirementTitle) {
+  const lineTitle = extractRequirementTitle(line);
+  const reqTitleMatch = requirementTitle.match(/^(.+?)\s*\([\d-]+\)$/);
+  const reqTitleOnly = reqTitleMatch ? reqTitleMatch[1] : requirementTitle;
+
+  return lineTitle === reqTitleOnly || 
+         lineTitle.includes(reqTitleOnly) || 
+         reqTitleOnly.includes(lineTitle);
+}
+
+/**
+ * Parse requirement block from lines
+ * @param {string[]} lines - Array of lines
+ * @param {number} startIndex - Start index of requirement block
+ * @returns {Object} Parsed requirement block with title and content
+ */
+function parseRequirementBlock(lines, startIndex) {
+  const title = lines[startIndex].replace(/^###\s*/, '').trim();
+  const content = [];
+  
+  // Find the end of this requirement block
+  let endIndex = lines.length;
+  for (let j = startIndex + 1; j < lines.length; j++) {
+    const nextLine = lines[j].trim();
+    if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+      endIndex = j;
+      break;
+    }
+  }
+  
+  // Extract content (everything between the title and the next header)
+  for (let i = startIndex + 1; i < endIndex; i++) {
+    content.push(lines[i]);
+  }
+  
+  return {
+    title,
+    content: content.join('\n'),
+    startIndex,
+    endIndex
+  };
+}
+
+/**
+ * Find requirement block by title in lines
+ * @param {string[]} lines - Array of lines
+ * @param {string} requirementTitle - Title to search for
+ * @param {string} sectionType - Type of section ('todo', 'verify', 'current')
+ * @returns {Object|null} Requirement block info or null if not found
+ */
+function findRequirementBlock(lines, requirementTitle, sectionType = 'todo') {
+  const normalizedTitle = requirementTitle.trim();
+  let inTargetSection = false;
+  let requirementStartIndex = -1;
+  let requirementEndIndex = -1;
+
+  // Section identifiers
+  const sectionIdentifiers = {
+    todo: ['## ⏳ Requirements not yet completed'],
+    verify: ['## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG', '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG.md'],
+    current: ['## 🔨 Current In Progress Requirement']
+  };
+
+  const targetSectionIds = sectionIdentifiers[sectionType] || [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Check if we're entering the target section
+    if (targetSectionIds.some(id => trimmed.includes(id))) {
+      inTargetSection = true;
+      continue;
+    }
+
+    // Check if we're leaving the target section
+    if (inTargetSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+      if (!targetSectionIds.some(id => trimmed.includes(id))) {
+        break;
+      }
+    }
+
+    // Look for requirement in target section (### header format)
+    if (inTargetSection && trimmed.startsWith('###')) {
+      const title = trimmed.replace(/^###\s*/, '').trim();
+      if (title === normalizedTitle || title.includes(normalizedTitle) || normalizedTitle.includes(title)) {
+        requirementStartIndex = i;
+
+        // Find the end of this requirement block
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+            requirementEndIndex = j;
+            break;
+          }
+        }
+
+        if (requirementEndIndex === -1) {
+          requirementEndIndex = lines.length;
+        }
+
+        return parseRequirementBlock(lines, requirementStartIndex);
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Find all requirement blocks in a section
+ * @param {string[]} lines - Array of lines
+ * @param {string} sectionType - Type of section ('todo', 'verify', 'current')
+ * @returns {Array} Array of requirement blocks
+ */
+function findAllRequirementsInSection(lines, sectionType = 'todo') {
+  const requirements = [];
+  let inTargetSection = false;
+
+  // Section identifiers
+  const sectionIdentifiers = {
+    todo: ['## ⏳ Requirements not yet completed'],
+    verify: ['## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG', '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG.md'],
+    current: ['## 🔨 Current In Progress Requirement']
+  };
+
+  const targetSectionIds = sectionIdentifiers[sectionType] || [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Check if we're entering the target section
+    if (targetSectionIds.some(id => trimmed.includes(id))) {
+      inTargetSection = true;
+      continue;
+    }
+
+    // Check if we're leaving the target section
+    if (inTargetSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+      if (!targetSectionIds.some(id => trimmed.includes(id))) {
+        break;
+      }
+    }
+
+    // Look for requirements in target section
+    if (inTargetSection && trimmed.startsWith('###')) {
+      const requirement = parseRequirementBlock(lines, i);
+      requirements.push(requirement);
+      
+      // Skip to the end of this requirement block
+      i = requirement.endIndex - 1;
+    }
+  }
+
+  return requirements;
+}
+
+/**
+ * Validate requirement format
+ * @param {string} requirementText - Requirement text to validate
+ * @returns {Object} Validation result
+ */
+function validateRequirementFormat(requirementText) {
+  const result = {
+    isValid: true,
+    errors: [],
+    warnings: []
+  };
+
+  if (!requirementText || typeof requirementText !== 'string') {
+    result.isValid = false;
+    result.errors.push('Requirement text must be a non-empty string');
+    return result;
+  }
+
+  const trimmedText = requirementText.trim();
+
+  if (trimmedText.length === 0) {
+    result.isValid = false;
+    result.errors.push('Requirement text cannot be empty');
+    return result;
+  }
+
+  // Check for TRY AGAIN prefix
+  if (trimmedText.startsWith('TRY AGAIN')) {
+    const tryAgainMatch = trimmedText.match(/^TRY AGAIN \((\d+)(?:st|nd|rd|th) time\): (.+)$/);
+    if (!tryAgainMatch) {
+      result.warnings.push('TRY AGAIN prefix format may be incorrect');
+    }
+  }
+
+  // Check length
+  if (trimmedText.length > 500) {
+    result.warnings.push('Requirement text is quite long, consider breaking it down');
+  }
+
+  // Check for common formatting issues
+  if (trimmedText.includes('  ')) {
+    result.warnings.push('Requirement text contains double spaces');
+  }
+
+  return result;
+}
+
+/**
+ * Format requirement for display
+ * @param {string} requirementText - Requirement text
+ * @param {Object} options - Formatting options
+ * @returns {string} Formatted requirement text
+ */
+function formatRequirementForDisplay(requirementText, options = {}) {
+  const {
+    maxLength = 100,
+    showTryAgainCount = true,
+    truncate = true
+  } = options;
+
+  let formatted = requirementText;
+
+  // Extract TRY AGAIN count if needed
+  if (showTryAgainCount) {
+    const tryAgainMatch = formatted.match(/^TRY AGAIN \((\d+)(?:st|nd|rd|th) time\): (.+)$/);
+    if (tryAgainMatch) {
+      const count = tryAgainMatch[1];
+      const baseText = tryAgainMatch[2];
+      formatted = `${baseText} (Attempt ${count})`;
+    }
+  }
+
+  // Truncate if needed
+  if (truncate && formatted.length > maxLength) {
+    formatted = formatted.substring(0, maxLength - 3) + '...';
+  }
+
+  return formatted;
+}
+
+module.exports = {
+  DEFAULT_INSTRUCTION_TEXT,
+  getOrdinalSuffix,
+  addTryAgainPrefix,
+  parseRequirementLine,
+  extractRequirementTitle,
+  isRequirementMatch,
+  parseRequirementBlock,
+  findRequirementBlock,
+  findAllRequirementsInSection,
+  validateRequirementFormat,
+  formatRequirementForDisplay
+};

package/src/utils/requirement-helpers/requirement-status.js

@@ -0,0 +1,320 @@
+const fs = require('fs-extra');
+const { findRequirementBlock } = require('./requirement-parser.js');
+
+/**
+ * Requirement Status Management
+ * Handles reading and updating requirement status information
+ */
+
+/**
+ * Extract current status from requirements content
+ * @param {string} content - Requirements file content
+ * @returns {string} Current status
+ */
+function extractCurrentStatus(content) {
+  if (!content) return '';
+  
+  const lines = content.split('\n');
+  for (const line of lines) {
+    if (line.includes('🚦 Current Status')) {
+      const match = line.match(/\*\*([A-Z_]+)\*\*/);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+  
+  return '';
+}
+
+/**
+ * Update current status in requirements file
+ * @param {string} reqPath - Path to requirements file
+ * @param {string} newStatus - New status value
+ * @returns {Promise<boolean>} Success status
+ */
+async function updateCurrentStatus(reqPath, newStatus) {
+  try {
+    const content = await fs.readFile(reqPath, 'utf-8');
+    const lines = content.split('\n');
+    let statusUpdated = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes('🚦 Current Status')) {
+        // Replace the status value
+        lines[i] = line.replace(/\*\*[A-Z_]+\*\*/, `**${newStatus.toUpperCase()}**`);
+        statusUpdated = true;
+        break;
+      }
+    }
+
+    if (!statusUpdated) {
+      // Add status section if it doesn't exist
+      lines.push('## 🚦 Current Status');
+      lines.push('');
+      lines.push(`**${newStatus.toUpperCase()}**`);
+    }
+
+    await fs.writeFile(reqPath, lines.join('\n'), 'utf-8');
+    console.log(`✅ Updated status to: ${newStatus}`);
+    return true;
+
+  } catch (error) {
+    console.error(`Error updating status: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Get current status from requirements file
+ * @param {string} reqPath - Path to requirements file
+ * @returns {Promise<string>} Current status
+ */
+async function getCurrentStatus(reqPath) {
+  try {
+    const content = await fs.readFile(reqPath, 'utf-8');
+    return extractCurrentStatus(content);
+  } catch (error) {
+    console.error(`Error getting current status: ${error.message}`);
+    return '';
+  }
+}
+
+/**
+ * Check if status is DONE
+ * @param {string} status - Status to check
+ * @returns {boolean} Whether status is DONE
+ */
+function isStatusDone(status) {
+  return status && status.toUpperCase() === 'DONE';
+}
+
+/**
+ * Check if status is in progress (not DONE)
+ * @param {string} status - Status to check
+ * @returns {boolean} Whether status is in progress
+ */
+function isStatusInProgress(status) {
+  return status && !isStatusDone(status);
+}
+
+/**
+ * Get status progression stage
+ * @param {string} status - Current status
+ * @returns {string} Stage name
+ */
+function getStatusStage(status) {
+  if (!status) return 'UNKNOWN';
+  
+  const statusUpper = status.toUpperCase().trim();
+  
+  if (statusUpper === 'PREPARE') return 'PREPARE';
+  if (statusUpper === 'CREATE') return 'CREATE';
+  if (statusUpper === 'CLEAN_UP') return 'CLEAN_UP';
+  if (statusUpper === 'VERIFY') return 'VERIFY';
+  if (statusUpper === 'DONE') return 'DONE';
+  
+  return 'UNKNOWN';
+}
+
+/**
+ * Validate status value
+ * @param {string} status - Status to validate
+ * @returns {Object} Validation result
+ */
+function validateStatus(status) {
+  const validStatuses = ['PREPARE', 'CREATE', 'CLEAN_UP', 'VERIFY', 'DONE'];
+  const result = {
+    isValid: true,
+    errors: [],
+    warnings: []
+  };
+
+  if (!status || typeof status !== 'string') {
+    result.isValid = false;
+    result.errors.push('Status must be a non-empty string');
+    return result;
+  }
+
+  const normalizedStatus = status.toUpperCase().trim();
+
+  if (!validStatuses.includes(normalizedStatus)) {
+    result.isValid = false;
+    result.errors.push(`Invalid status: "${status}". Valid statuses are: ${validStatuses.join(', ')}`);
+  }
+
+  return result;
+}
+
+/**
+ * Get next status in progression
+ * @param {string} currentStatus - Current status
+ * @returns {string|null} Next status or null if current is DONE
+ */
+function getNextStatus(currentStatus) {
+  const progression = ['PREPARE', 'CREATE', 'CLEAN_UP', 'VERIFY', 'DONE'];
+  const currentIndex = progression.indexOf(currentStatus?.toUpperCase());
+  
+  if (currentIndex === -1 || currentIndex === progression.length - 1) {
+    return null;
+  }
+  
+  return progression[currentIndex + 1];
+}
+
+/**
+ * Get previous status in progression
+ * @param {string} currentStatus - Current status
+ * @returns {string|null} Previous status or null if current is first
+ */
+function getPreviousStatus(currentStatus) {
+  const progression = ['PREPARE', 'CREATE', 'CLEAN_UP', 'VERIFY', 'DONE'];
+  const currentIndex = progression.indexOf(currentStatus?.toUpperCase());
+  
+  if (currentIndex <= 0) {
+    return null;
+  }
+  
+  return progression[currentIndex - 1];
+}
+
+/**
+ * Check if status transition is valid
+ * @param {string} fromStatus - Current status
+ * @param {string} toStatus - Target status
+ * @returns {boolean} Whether transition is valid
+ */
+function isValidStatusTransition(fromStatus, toStatus) {
+  const progression = ['PREPARE', 'CREATE', 'CLEAN_UP', 'VERIFY', 'DONE'];
+  
+  const fromIndex = progression.indexOf(fromStatus?.toUpperCase());
+  const toIndex = progression.indexOf(toStatus?.toUpperCase());
+  
+  // Allow going backwards (for corrections) and forward one step
+  return fromIndex !== -1 && toIndex !== -1 && 
+         (toIndex === fromIndex + 1 || toIndex < fromIndex);
+}
+
+/**
+ * Get status change history from content
+ * @param {string} content - Requirements file content
+ * @returns {Array} Array of status changes
+ */
+function getStatusHistory(content) {
+  const history = [];
+  const lines = content.split('\n');
+  let currentSection = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+
+    if (line.includes('## 🚦 Current Status')) {
+      currentSection = 'status';
+      continue;
+    }
+
+    if (currentSection === 'status' && line.includes('**')) {
+      const match = line.match(/\*\*([A-Z_]+)\*\*/);
+      if (match) {
+        history.push({
+          status: match[1],
+          line: i + 1,
+          content: line
+        });
+      }
+    }
+  }
+
+  return history;
+}
+
+/**
+ * Format status for display
+ * @param {string} status - Status to format
+ * @param {Object} options - Formatting options
+ * @returns {string} Formatted status
+ */
+function formatStatusForDisplay(status, options = {}) {
+  const {
+    showEmoji = true,
+    uppercase = true,
+    bold = false
+  } = options;
+
+  let formatted = status || 'UNKNOWN';
+
+  if (uppercase) {
+    formatted = formatted.toUpperCase();
+  }
+
+  if (bold) {
+    formatted = `**${formatted}**`;
+  }
+
+  if (showEmoji) {
+    const emojiMap = {
+      'PREPARE': '🔍',
+      'CREATE': '🔨',
+      'CLEAN_UP': '🧹',
+      'VERIFY': '✅',
+      'DONE': '🎉',
+      'UNKNOWN': '❓'
+    };
+    formatted = `${emojiMap[formatted] || '❓'} ${formatted}`;
+  }
+
+  return formatted;
+}
+
+/**
+ * Get status summary for a requirements file
+ * @param {string} reqPath - Path to requirements file
+ * @returns {Promise<Object>} Status summary
+ */
+async function getStatusSummary(reqPath) {
+  try {
+    const content = await fs.readFile(reqPath, 'utf-8');
+    const currentStatus = extractCurrentStatus(content);
+    const stage = getStatusStage(currentStatus);
+    const isDone = isStatusDone(currentStatus);
+    const nextStatus = getNextStatus(currentStatus);
+    const history = getStatusHistory(content);
+
+    return {
+      current: currentStatus,
+      stage,
+      isDone,
+      nextStatus,
+      history,
+      lastUpdated: new Date().toISOString()
+    };
+  } catch (error) {
+    console.error(`Error getting status summary: ${error.message}`);
+    return {
+      current: '',
+      stage: 'UNKNOWN',
+      isDone: false,
+      nextStatus: null,
+      history: [],
+      lastUpdated: null,
+      error: error.message
+    };
+  }
+}
+
+module.exports = {
+  extractCurrentStatus,
+  updateCurrentStatus,
+  getCurrentStatus,
+  isStatusDone,
+  isStatusInProgress,
+  getStatusStage,
+  validateStatus,
+  getNextStatus,
+  getPreviousStatus,
+  isValidStatusTransition,
+  getStatusHistory,
+  formatStatusForDisplay,
+  getStatusSummary
+};

package/src/utils/requirement-helpers-new.js

@@ -0,0 +1,55 @@
+// Import all refactored modules
+const { getOrdinalSuffix, addTryAgainPrefix, parseRequirementLine } = require('./requirement-text-utils');
+const { 
+  promoteToVerified,
+  demoteFromVerifiedToTodo,
+  promoteTodoToVerify,
+  demoteVerifyToTodo
+} = require('./requirement-movement');
+const { 
+  loadVerifiedFromChangelog,
+  getProjectRequirementStats,
+  getCurrentRequirementProgress
+} = require('./requirement-statistics');
+const { 
+  DEFAULT_INSTRUCTION_TEXT,
+  createDefaultRequirementsFile,
+  getOrCreateRequirementsFilePath
+} = require('./requirement-file-management');
+const { 
+  getCurrentRequirement,
+  isCurrentRequirementDone,
+  moveToNextRequirement,
+  getCurrentRequirementProgress: getCurrentProgress,
+  getCurrentRequirementName
+} = require('./current-requirement-manager');
+
+// Re-export everything for backward compatibility
+module.exports = {
+  // Text utilities
+  getOrdinalSuffix,
+  addTryAgainPrefix,
+  parseRequirementLine,
+  
+  // Movement functions
+  promoteToVerified,
+  demoteFromVerifiedToTodo,
+  promoteTodoToVerify,
+  demoteVerifyToTodo,
+  
+  // Statistics functions
+  loadVerifiedFromChangelog,
+  getProjectRequirementStats,
+  getCurrentRequirementProgress,
+  
+  // File management
+  DEFAULT_INSTRUCTION_TEXT,
+  createDefaultRequirementsFile,
+  getOrCreateRequirementsFilePath,
+  
+  // Current requirement management
+  getCurrentRequirement,
+  isCurrentRequirementDone,
+  moveToNextRequirement,
+  getCurrentRequirementName
+};