vibecodingmachine-core 2025.12.1-534 → 2025.12.6-1702

package/src/utils/requirements-parser.js

@@ -0,0 +1,310 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Parse requirements file and extract all sections
+ * This matches the CLI's parsing logic to ensure consistency
+ * @param {string} content - The requirements file content
+ * @returns {Object} Parsed requirements with sections: requirements, completed, needInformation, changelog, verified
+ */
+function parseRequirementsFile(content) {
+  const lines = content.split('\n');
+  const requirements = [];
+  const completed = [];
+  const needInformation = [];
+  const changelog = [];
+  const verified = [];
+
+  let currentSection = '';
+  let inSection = false;
+
+  // Section detection patterns (matching CLI logic)
+  const sectionPatterns = {
+    todo: ['⏳ Requirements not yet completed', 'Requirements not yet completed'],
+    verify: [
+      '🔍 TO VERIFY BY HUMAN',
+      'TO VERIFY BY HUMAN',
+      '🔍 TO VERIFY',
+      'TO VERIFY',
+      '✅ TO 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',
+      'Verified by AI screenshot'
+    ],
+    verified: ['📝 VERIFIED', 'VERIFIED'],
+    changelog: ['CHANGELOG'],
+    needInformation: ['❓ Requirements needing', 'Requirements needing', 'needing manual feedback', 'needing information']
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Check for section headers (## but not ###)
+    if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+      // Determine which section we're entering
+      if (sectionPatterns.todo.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'todo';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.verify.some(pattern => {
+        const matches = trimmed.includes(pattern);
+        // Make sure it's not a VERIFIED section (without TO VERIFY)
+        if (matches && !trimmed.includes('📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
+          return true;
+        }
+        return false;
+      })) {
+        currentSection = 'verify';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.verified.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'verified';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.changelog.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'changelog';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.needInformation.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'needInformation';
+        inSection = true;
+        continue;
+      } else {
+        // Different section header - exit current section
+        if (inSection) {
+          // Check if we're leaving TO VERIFY section
+          if (currentSection === 'verify') {
+            const isTodoSection = trimmed.includes('⏳ Requirements not yet completed') || trimmed.includes('Requirements not yet completed');
+            const isVerifiedSection = trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED');
+            const isRecycledSection = trimmed === '## ♻️ RECYCLED' || trimmed.startsWith('## ♻️ RECYCLED') ||
+              trimmed === '## 📦 RECYCLED' || trimmed.startsWith('## 📦 RECYCLED');
+            const isClarificationSection = trimmed.includes('## ❓ Requirements needing') || trimmed.includes('❓ Requirements needing');
+            
+            if (isVerifiedSection || isTodoSection || isRecycledSection || isClarificationSection) {
+              inSection = false;
+              currentSection = '';
+            }
+            // Otherwise continue - might be REJECTED or CHANGELOG which are not section boundaries for TO VERIFY
+          } else {
+            inSection = false;
+            currentSection = '';
+          }
+        }
+        continue;
+      }
+    }
+
+    // Parse requirements in new format (### header)
+    if (inSection && trimmed.startsWith('###')) {
+      const title = trimmed.replace(/^###\s*/, '').trim();
+
+      // Skip malformed requirements (title is just a package name, empty, or too short)
+      const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
+      if (!title || title.length === 0 || packageNames.includes(title.toLowerCase())) {
+        continue;
+      }
+
+      const details = [];
+      let package = null;
+      let options = null;
+      let optionsType = null;
+
+      // Read package, description, and options
+      for (let j = i + 1; j < lines.length; j++) {
+        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:')) {
+          package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+        } 
+        // Check for OPTIONS line (for need information requirements)
+        else if (nextLine.startsWith('OPTIONS:')) {
+          optionsType = 'checkbox'; // default
+          const optionsText = nextLine.replace(/^OPTIONS:\s*/, '').trim();
+          // Parse options (could be checkbox or radio)
+          if (optionsText.includes('|')) {
+            options = optionsText.split('|').map(opt => opt.trim()).filter(opt => opt);
+          } else {
+            options = [optionsText];
+          }
+        }
+        // Description line (include all lines including empty ones to preserve formatting)
+        else if (nextLine !== undefined) {
+          details.push(nextLine);
+        }
+      }
+
+      const requirement = {
+        title,
+        description: details.join('\n'),
+        package,
+        options,
+        optionsType,
+        lineIndex: i
+      };
+
+      // Add to appropriate array based on current section
+      if (currentSection === 'todo') {
+        requirements.push(requirement);
+      } else if (currentSection === 'verify') {
+        completed.push(requirement);
+      } else if (currentSection === 'needInformation') {
+        needInformation.push(requirement);
+      } else if (currentSection === 'changelog') {
+        changelog.push(requirement);
+      } else if (currentSection === 'verified') {
+        verified.push(requirement);
+      }
+    }
+
+    // Also support old format (lines starting with -) for backwards compatibility
+    if (inSection && trimmed.startsWith('- ') && !trimmed.startsWith('###')) {
+      const requirementText = trimmed.substring(2).trim();
+      if (requirementText) {
+        // Extract date if present (format: "2025-12-25 2:35 PM MDT - " or "2025-10-03: ")
+        const dateTimeMatch = requirementText.match(/^(\d{4}-\d{2}-\d{2})(?:\s+\d{1,2}:\d{2}\s+[AP]M(?:\s+[A-Z]{2,5})?)?\s*[-:]\s*/);
+        const date = dateTimeMatch ? dateTimeMatch[1] : null;
+        const title = dateTimeMatch ? requirementText.substring(dateTimeMatch[0].length).trim() : requirementText;
+
+        const requirement = {
+          title: title.length > 100 ? title.substring(0, 100) + '...' : title,
+          description: title,
+          date: date
+        };
+
+        if (currentSection === 'todo') {
+          requirements.push(requirement);
+        } else if (currentSection === 'verify' || currentSection === 'completed') {
+          completed.push(requirement);
+        } else if (currentSection === 'changelog') {
+          changelog.push(requirement);
+        }
+      }
+    }
+  }
+
+  // Remove duplicates based on title (keep first occurrence)
+  const seenTitles = new Set();
+  const uniqueRequirements = [];
+  for (const req of requirements) {
+    const normalizedTitle = req.title.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+    if (!seenTitles.has(normalizedTitle)) {
+      seenTitles.add(normalizedTitle);
+      uniqueRequirements.push(req);
+    }
+  }
+
+  return {
+    requirements: uniqueRequirements,
+    completed,
+    needInformation,
+    changelog,
+    verified
+  };
+}
+
+/**
+ * Load verified requirements from CHANGELOG.md
+ * @param {string} repoPath - Path to repository root
+ * @returns {Promise<Array>} Array of verified requirement titles
+ */
+async function loadVerifiedFromChangelog(repoPath) {
+  try {
+    const changelogPath = path.join(repoPath, 'CHANGELOG.md');
+    if (!await fs.pathExists(changelogPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(changelogPath, 'utf8');
+    const lines = content.split('\n');
+    const requirements = [];
+    let inVerifiedSection = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Check for Verified Requirements section
+      if (trimmed.includes('## Verified Requirements')) {
+        inVerifiedSection = true;
+        continue;
+      }
+
+      // Exit section if we hit another ## header
+      if (inVerifiedSection && trimmed.startsWith('##') && !trimmed.includes('Verified Requirements')) {
+        break;
+      }
+
+      // Only collect items from within the Verified Requirements section
+      if (inVerifiedSection && trimmed.startsWith('- ') && trimmed.length > 10) {
+        const title = trimmed.substring(2).trim();
+        // Extract date if present (format: "Title (2025-12-05)")
+        const dateMatch = title.match(/^(.+?)\s*\((\d{4}-\d{2}-\d{2})\)$/);
+        const cleanTitle = dateMatch ? dateMatch[1].trim() : title;
+        const date = dateMatch ? dateMatch[2] : null;
+
+        requirements.push({
+          title: cleanTitle,
+          description: cleanTitle,
+          date: date
+        });
+      }
+    }
+
+    return requirements;
+  } catch (error) {
+    // If CHANGELOG.md doesn't exist or can't be read, return empty array
+    return [];
+  }
+}
+
+/**
+ * Load and parse requirements from file
+ * @param {string} reqPath - Path to requirements file
+ * @param {string} repoPath - Optional path to repository root (for loading CHANGELOG.md)
+ * @returns {Promise<Object>} Parsed requirements
+ */
+async function loadRequirementsFromFile(reqPath, repoPath = null) {
+  try {
+    const parsed = {
+      requirements: [],
+      completed: [],
+      needInformation: [],
+      changelog: [],
+      verified: []
+    };
+
+    if (await fs.pathExists(reqPath)) {
+      const content = await fs.readFile(reqPath, 'utf8');
+      const fileParsed = parseRequirementsFile(content);
+      Object.assign(parsed, fileParsed);
+    }
+
+    // Also load verified from CHANGELOG.md if repoPath is provided
+    if (repoPath) {
+      const verifiedFromChangelog = await loadVerifiedFromChangelog(repoPath);
+      // Merge with verified from requirements file (CHANGELOG.md takes precedence)
+      if (verifiedFromChangelog.length > 0) {
+        parsed.verified = verifiedFromChangelog;
+      }
+    }
+
+    return parsed;
+  } catch (error) {
+    throw new Error(`Failed to load requirements from file: ${error.message}`);
+  }
+}
+
+module.exports = {
+  parseRequirementsFile,
+  loadRequirementsFromFile,
+  loadVerifiedFromChangelog
+};
+
+
+