vibecodingmachine-core 2025.12.1-534 → 2025.12.22-2230

package/src/utils/requirement-helpers.js

@@ -1,6 +1,11 @@
 const fs = require('fs-extra');
 const path = require('path');
+const os = require('os');
 const { getRequirementsPath } = require('./repo-helpers.cjs');
+const { logger } = require('./logger.cjs');
+
+// 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.)
@@ -61,67 +66,87 @@ async function promoteToVerified(reqPath, requirementTitle) {
   try {
     const content = await fs.readFile(reqPath, 'utf-8');
     const lines = content.split('\n');
-    const updatedLines = [];
     let inVerifySection = false;
-    let verifyCount = 0;
-    let requirementToMove = null;
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+    const normalizedTitle = requirementTitle.trim();
 
-    for (const line of lines) {
-      if (line.includes('## ✅ Verified by AI screenshot')) {
+    // Find the requirement in TO VERIFY section (new ### format)
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check if we're entering TO VERIFY section (multiple variants)
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###') &&
+        (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot'))) {
         inVerifySection = true;
-        updatedLines.push(line);
         continue;
       }
 
-      if (inVerifySection && line.startsWith('## ')) {
+      // Check if we're leaving TO VERIFY section
+      if (inVerifySection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
         inVerifySection = false;
-        updatedLines.push(line);
-        continue;
       }
 
-      if (inVerifySection && line.startsWith('- ')) {
-        const reqText = parseRequirementLine(line);
-        if (reqText === requirementTitle || reqText.includes(requirementTitle)) {
-          requirementToMove = reqText;
-          verifyCount++;
-          continue;
+      // Look for requirement in TO VERIFY section (### header format)
+      if (inVerifySection && 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;
+          }
+          break;
         }
-        verifyCount++;
       }
+    }
 
-      updatedLines.push(line);
+    if (requirementStartIndex === -1) {
+      return false;
     }
 
-    if (requirementToMove) {
-      // CHANGELOG.md should be at repository root, not in .vibecodingmachine directory
-      const allnightDir = path.dirname(reqPath); // .vibecodingmachine directory
-      const repoRoot = path.dirname(allnightDir); // repository root (one level up)
-      const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
-      const timestamp = new Date().toISOString().split('T')[0];
-      const changelogEntry = `- ${requirementToMove} (${timestamp})`;
+    // Extract requirement block
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    const extractedTitle = lines[requirementStartIndex].replace(/^###\s*/, '').trim();
 
-      let changelogContent = '';
-      if (await fs.pathExists(changelogPath)) {
-        changelogContent = await fs.readFile(changelogPath, 'utf-8');
-      } else {
-        changelogContent = '# Changelog\n\n## Verified Requirements\n\n';
-      }
+    // Remove requirement from TO VERIFY section
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
 
-      if (changelogContent.includes('## Verified Requirements')) {
-        changelogContent = changelogContent.replace(
-          '## Verified Requirements\n',
-          `## Verified Requirements\n${changelogEntry}\n`
-        );
-      } else {
-        changelogContent += `\n## Verified Requirements\n${changelogEntry}\n`;
-      }
+    // Add to CHANGELOG.md
+    const allnightDir = path.dirname(reqPath);
+    const repoRoot = path.dirname(allnightDir);
+    const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
+    const timestamp = new Date().toISOString().split('T')[0];
+    const changelogEntry = `- ${extractedTitle} (${timestamp})`;
 
-      await fs.writeFile(changelogPath, changelogContent);
-      await fs.writeFile(reqPath, updatedLines.join('\n'));
-      return true;
+    let changelogContent = '';
+    if (await fs.pathExists(changelogPath)) {
+      changelogContent = await fs.readFile(changelogPath, 'utf-8');
+    } else {
+      changelogContent = '# Changelog\n\n## Verified Requirements\n\n';
     }
 
-    return false;
+    if (changelogContent.includes('## Verified Requirements')) {
+      changelogContent = changelogContent.replace(
+        '## Verified Requirements\n',
+        `## Verified Requirements\n${changelogEntry}\n`
+      );
+    } else {
+      changelogContent += `\n## Verified Requirements\n${changelogEntry}\n`;
+    }
+
+    await fs.writeFile(changelogPath, changelogContent);
+    await fs.writeFile(reqPath, lines.join('\n'));
+    return true;
   } catch (error) {
     throw new Error(`Failed to promote requirement to verified: ${error.message}`);
   }
@@ -155,12 +180,12 @@ async function demoteFromVerifiedToTodo(reqPath, requirementTitle) {
         // Extract title part (before timestamp in parentheses)
         const titleMatch = lineText.match(/^(.+?)\s*\([\d-]+\)$/);
         const lineTitle = titleMatch ? titleMatch[1] : lineText;
-        
+
         // Check if this line matches the requirement title
         // Handle both cases: requirementTitle might include timestamp or not
         const reqTitleMatch = requirementTitle.match(/^(.+?)\s*\([\d-]+\)$/);
         const reqTitleOnly = reqTitleMatch ? reqTitleMatch[1] : requirementTitle;
-        
+
         if (lineTitle === reqTitleOnly || lineTitle.includes(reqTitleOnly) || reqTitleOnly.includes(lineTitle)) {
           requirementToMove = lineTitle;
           continue;
@@ -182,7 +207,7 @@ async function demoteFromVerifiedToTodo(reqPath, requirementTitle) {
 
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      
+
       if (line.includes('## ⏳ Requirements not yet completed')) {
         foundTodoSection = true;
         updatedLines.push(line);
@@ -217,24 +242,24 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
   try {
     const content = await fs.readFile(reqPath, 'utf-8');
     const lines = content.split('\n');
-    
+
     // Find the requirement block (### header format)
     let requirementStartIndex = -1;
     let requirementEndIndex = -1;
     let inTodoSection = false;
-    
+
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i].trim();
-      
+
       if (line.includes('## ⏳ Requirements not yet completed')) {
         inTodoSection = true;
         continue;
       }
-      
+
       if (inTodoSection && line.startsWith('##') && !line.startsWith('###')) {
         break;
       }
-      
+
       if (inTodoSection && line.startsWith('###')) {
         const title = line.replace(/^###\s*/, '').trim();
         if (title && (title === requirementTitle || title.includes(requirementTitle) || requirementTitle.includes(title))) {
@@ -254,20 +279,20 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
         }
       }
     }
-    
+
     if (requirementStartIndex === -1) {
       return false;
     }
-    
+
     // Extract the requirement block
     const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
-    
+
     // Remove the requirement from its current location
     const updatedLines = [
       ...lines.slice(0, requirementStartIndex),
       ...lines.slice(requirementEndIndex)
     ];
-    
+
     // Find or create TO VERIFY section
     const verifySectionVariants = [
       '## 🔍 TO VERIFY BY HUMAN',
@@ -276,7 +301,7 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
       '## ✅ TO VERIFY',
       '## ✅ Verified by AI screenshot'
     ];
-    
+
     let verifyIndex = -1;
     for (let i = 0; i < updatedLines.length; i++) {
       if (verifySectionVariants.some(variant => updatedLines[i].includes(variant))) {
@@ -284,7 +309,7 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
         break;
       }
     }
-    
+
     if (verifyIndex === -1) {
       // Create TO VERIFY section before CHANGELOG or at end
       const changelogIndex = updatedLines.findIndex(line => line.includes('## CHANGELOG'));
@@ -292,7 +317,7 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
       updatedLines.splice(insertIndex, 0, '', '## 🔍 TO VERIFY BY HUMAN', '');
       verifyIndex = insertIndex + 1;
     }
-    
+
     // Insert requirement block after section header
     let insertIndex = verifyIndex + 1;
     while (insertIndex < updatedLines.length && updatedLines[insertIndex].trim() === '') {
@@ -303,7 +328,7 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
     if (insertIndex + requirementBlock.length < updatedLines.length && updatedLines[insertIndex + requirementBlock.length].trim() !== '') {
       updatedLines.splice(insertIndex + requirementBlock.length, 0, '');
     }
-    
+
     await fs.writeFile(reqPath, updatedLines.join('\n'));
     return true;
   } catch (error) {
@@ -315,43 +340,74 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
  * Move requirement from TO VERIFY back to TODO section
  * @param {string} reqPath - Path to REQUIREMENTS file
  * @param {string} requirementTitle - Title of requirement to move
+ * @param {string} explanation - Optional explanation of what went wrong
  * @returns {Promise<boolean>} Success status
  */
-async function demoteVerifyToTodo(reqPath, requirementTitle) {
+async function demoteVerifyToTodo(reqPath, requirementTitle, explanation = '') {
   try {
     const content = await fs.readFile(reqPath, 'utf-8');
     const lines = content.split('\n');
-    
-    // Find the requirement block in TO VERIFY section (### header format)
-    let requirementStartIndex = -1;
-    let requirementEndIndex = -1;
+
+    // Find ALL matching requirements in TO VERIFY section and remove them
+    // We'll collect all requirement blocks to remove, then process them
+    const requirementsToRemove = [];
     let inVerifySection = false;
-    
+
     const verifySectionVariants = [
       '## 🔍 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'
     ];
-    
+
+    // First pass: find all matching requirements in TO VERIFY section
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      if (verifySectionVariants.some(variant => line.includes(variant))) {
-        inVerifySection = true;
-        continue;
-      }
-      
-      if (inVerifySection && line.startsWith('##') && !line.startsWith('###')) {
-        break;
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check if this is a TO VERIFY section header
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+        const isToVerifyHeader = verifySectionVariants.some(variant => {
+          return trimmed === variant || trimmed.startsWith(variant) ||
+            (trimmed.includes('Verified by AI screenshot') && trimmed.includes('Needs Human to Verify'));
+        });
+
+        if (isToVerifyHeader) {
+          // Make sure it's not a VERIFIED section (without TO VERIFY)
+          if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
+            inVerifySection = true;
+            continue;
+          }
+        } else if (inVerifySection) {
+          // Check if we're leaving TO VERIFY section (hit a different section)
+          if (trimmed.includes('⏳ Requirements not yet completed') ||
+            trimmed.includes('## 📝 VERIFIED') ||
+            trimmed.includes('## ♻️ RECYCLED') ||
+            trimmed.includes('## 📦 RECYCLED') ||
+            trimmed.includes('## ❓ Requirements needing')) {
+            // We've left the TO VERIFY section
+            inVerifySection = false;
+          }
+        }
       }
-      
-      if (inVerifySection && line.startsWith('###')) {
-        const title = line.replace(/^###\s*/, '').trim();
-        if (title && (title === requirementTitle || title.includes(requirementTitle) || requirementTitle.includes(title))) {
-          requirementStartIndex = i;
+
+      // Look for requirement in TO VERIFY section
+      if (inVerifySection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+        // Normalize titles for matching (handle TRY AGAIN prefixes)
+        const normalizedTitle = title.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+        const normalizedRequirementTitle = requirementTitle.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+
+        if (title && (title === requirementTitle ||
+          normalizedTitle === normalizedRequirementTitle ||
+          title.includes(requirementTitle) ||
+          requirementTitle.includes(title) ||
+          normalizedTitle.includes(normalizedRequirementTitle) ||
+          normalizedRequirementTitle.includes(normalizedTitle))) {
           // Find the end of this requirement (next ### or ## header)
+          let requirementEndIndex = lines.length;
           for (let j = i + 1; j < lines.length; j++) {
             const nextLine = lines[j].trim();
             if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
@@ -359,32 +415,50 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
               break;
             }
           }
-          if (requirementEndIndex === -1) {
-            requirementEndIndex = lines.length;
-          }
-          break;
+
+          // Store this requirement to remove (we'll use the first one for moving to TODO)
+          requirementsToRemove.push({
+            start: i,
+            end: requirementEndIndex,
+            block: lines.slice(i, requirementEndIndex)
+          });
         }
       }
     }
-    
-    if (requirementStartIndex === -1) {
+
+    if (requirementsToRemove.length === 0) {
       return false;
     }
-    
-    // Extract the requirement block
-    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
-    
+
+    // Use the first matching requirement for moving to TODO (with TRY AGAIN prefix)
+    const firstRequirement = requirementsToRemove[0];
+    const requirementBlock = [...firstRequirement.block];
+
     // Update title with TRY AGAIN prefix
     const originalTitle = requirementBlock[0].replace(/^###\s*/, '').trim();
     const titleWithPrefix = addTryAgainPrefix(originalTitle);
     requirementBlock[0] = `### ${titleWithPrefix}`;
-    
-    // Remove the requirement from its current location
-    const updatedLines = [
-      ...lines.slice(0, requirementStartIndex),
-      ...lines.slice(requirementEndIndex)
-    ];
-    
+
+    // Add explanation to the requirement description if provided
+    if (explanation && explanation.trim()) {
+      // Find where to insert the explanation (after the title, before any existing content)
+      // Insert after first line (title) with a blank line and "What went wrong:" section
+      const explanationLines = [
+        '',
+        '**What went wrong (from previous attempt):**',
+        explanation.trim(),
+        ''
+      ];
+      requirementBlock.splice(1, 0, ...explanationLines);
+    }
+
+    // Remove ALL matching requirements from TO VERIFY section (work backwards to preserve indices)
+    const updatedLines = [...lines];
+    for (let i = requirementsToRemove.length - 1; i >= 0; i--) {
+      const req = requirementsToRemove[i];
+      updatedLines.splice(req.start, req.end - req.start);
+    }
+
     // Find or create TODO section
     let todoIndex = -1;
     for (let i = 0; i < updatedLines.length; i++) {
@@ -393,7 +467,7 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
         break;
       }
     }
-    
+
     if (todoIndex === -1) {
       // Create TODO section at the top (after initial headers)
       const firstSectionIndex = updatedLines.findIndex(line => line.startsWith('##') && !line.startsWith('###'));
@@ -401,7 +475,7 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
       updatedLines.splice(insertIndex, 0, '## ⏳ Requirements not yet completed', '');
       todoIndex = insertIndex;
     }
-    
+
     // Insert requirement block after section header
     let insertIndex = todoIndex + 1;
     while (insertIndex < updatedLines.length && updatedLines[insertIndex].trim() === '') {
@@ -412,7 +486,7 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
     if (insertIndex + requirementBlock.length < updatedLines.length && updatedLines[insertIndex + requirementBlock.length].trim() !== '') {
       updatedLines.splice(insertIndex + requirementBlock.length, 0, '');
     }
-    
+
     await fs.writeFile(reqPath, updatedLines.join('\n'));
     return true;
   } catch (error) {
@@ -420,6 +494,125 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
   }
 }
 
+/**
+ * Load verified requirements from CHANGELOG.md
+ * @param {string} repoPath - Repository root path
+ * @returns {Promise<string[]>} List 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();
+
+      // Collect items starting with "- " as verified requirements
+      if (trimmed.startsWith('- ') && trimmed.length > 5) {
+        let reqText = trimmed.substring(2);
+        // Extract title part (before timestamp in parentheses if present)
+        const titleMatch = reqText.match(/^(.+?)\s*\([\d-]+\)$/);
+        if (titleMatch) {
+          reqText = titleMatch[1];
+        }
+        requirements.push(reqText.trim());
+      }
+    }
+
+    return requirements;
+  } catch (error) {
+    logger.error('❌ Error loading verified requirements from CHANGELOG.md:', error);
+    return [];
+  }
+}
+
+/**
+ * Get unified project requirement statistics (TODO, TO VERIFY, VERIFIED)
+ * @param {string} repoPath - Repository root path
+ * @returns {Promise<Object>} Statistics with counts and formatted percentages
+ */
+async function getProjectRequirementStats(repoPath) {
+  try {
+    const hostname = os.hostname();
+    const { getRequirementsPath } = require('./repo-helpers.cjs');
+    const reqPath = await getRequirementsPath(repoPath, hostname);
+
+    let todoCount = 0;
+    let toVerifyCount = 0;
+    let verifiedCount = 0;
+
+    if (reqPath && await fs.pathExists(reqPath)) {
+      const content = await fs.readFile(reqPath, 'utf8');
+      const lines = content.split('\n');
+      let currentSection = '';
+
+      const verifySectionVariants = [
+        '🔍 TO VERIFY BY HUMAN',
+        'TO VERIFY BY HUMAN',
+        '🔍 TO VERIFY',
+        'TO VERIFY',
+        '✅ Verified by AI screenshot',
+        'Verified by AI screenshot'
+      ];
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        if (trimmed.startsWith('###')) {
+          if (currentSection) {
+            const requirementText = trimmed.replace(/^###\s*/, '').trim();
+            if (requirementText) {
+              if (currentSection === 'todo') todoCount++;
+              else if (currentSection === 'toverify') toVerifyCount++;
+            }
+          }
+        } else if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+          if (trimmed.includes('⏳ Requirements not yet completed') ||
+            trimmed.includes('Requirements not yet completed')) {
+            currentSection = 'todo';
+          } else if (verifySectionVariants.some(v => trimmed.includes(v))) {
+            currentSection = 'toverify';
+          } else {
+            currentSection = '';
+          }
+        }
+      }
+    }
+
+    // Load verified counts from CHANGELOG.md
+    const verifiedReqs = await loadVerifiedFromChangelog(repoPath);
+    verifiedCount = verifiedReqs.length;
+
+    const total = todoCount + toVerifyCount + verifiedCount;
+    const todoPercent = total > 0 ? Math.round((todoCount / total) * 100) : 0;
+    const toVerifyPercent = total > 0 ? Math.round((toVerifyCount / total) * 100) : 0;
+    const verifiedPercent = total > 0 ? Math.round((verifiedCount / total) * 100) : 0;
+
+    return {
+      todoCount,
+      toVerifyCount,
+      verifiedCount,
+      total,
+      todoPercent,
+      toVerifyPercent,
+      verifiedPercent,
+      todoLabel: `TODO (${todoCount} - ${todoPercent}%)`,
+      toVerifyLabel: `TO VERIFY (${toVerifyCount} - ${toVerifyPercent}%)`,
+      verifiedLabel: `VERIFIED (${verifiedCount} - ${verifiedPercent}%)`
+    };
+  } catch (error) {
+    logger.error('❌ Error getting project requirement stats:', error);
+    return null;
+  }
+}
+
 module.exports = {
   getOrdinalSuffix,
   addTryAgainPrefix,
@@ -427,6 +620,578 @@ module.exports = {
   promoteToVerified,
   demoteFromVerifiedToTodo,
   promoteTodoToVerify,
-  demoteVerifyToTodo
+  demoteVerifyToTodo,
+  // New shared functions
+  getCurrentRequirement,
+  getCurrentRequirementName,
+  getCurrentRequirementProgress,
+  isCurrentRequirementDone,
+  moveToNextRequirement,
+  createDefaultRequirementsFile,
+  getOrCreateRequirementsFilePath,
+  loadVerifiedFromChangelog,
+  getProjectRequirementStats,
+  DEFAULT_INSTRUCTION_TEXT
 };
 
+// --- Ported Functions from Electron App ---
+
+// Function to create a default requirements file
+function createDefaultRequirementsFile(repoPath) {
+  try {
+    const hostname = os.hostname();
+    // Use the core logic to find the .vibecodingmachine directory
+    // Note: This logic assumes we want to create it INSIDE the repo if it doesn't exist?
+    // Electron app logic was: path.join(repoPath, '.vibecodingmachine')
+    // We'll stick to that for creation.
+    const vibecodingmachineDir = path.join(repoPath, '.vibecodingmachine');
+
+    // Ensure .vibecodingmachine directory exists
+    if (!fs.existsSync(vibecodingmachineDir)) {
+      fs.mkdirSync(vibecodingmachineDir, { recursive: true });
+      logger.log('📁 Created .vibecodingmachine directory');
+    }
+
+    // Create hostname-specific requirements file
+    const requirementsFilePath = path.join(vibecodingmachineDir, `REQUIREMENTS-${hostname}.md`);
+
+    const defaultContent = `# 🌙 VibeCodingMachine – Requirements File
+
+This is a Markdown (.md) file.
+
+You should not need to modify this file, as VibeCodingMachine will modify it for you, but you can add requirements and move them around either here directly, or via AI.
+
+This file contains the requirements to complete the project. Each item in a list is a self contained requirement that should be able to stand on its own, and not require reference to other requirements. Each requirement starts in the section of requirements to complete, then it moved to the section with the current requirement being worked on. VibeCodingMachine will then, after implementing the requirement, move it to the completed requirements list in the CHANGELOG.md file, or to the section in this file for requirements that need attention. These will be available for you to review. They should have options to choose, and you decide which option to take, and VibeCodingMachine will work on that again the next time it is run.
+
+## RESPONSE FROM LAST CHAT
+
+### ONE LINE STATUS: READY
+
+### ONE LINE SUMMARY: New requirements file created
+
+### MULTILINE DETAILS: (1-20 lines max)
+
+**REQUIREMENT:**
+- Initial setup complete
+
+**ALL PHASES COMPLETED:**
+- ✅ Requirements file created
+- ✅ Ready for new requirements
+
+## 🔨 Current In Progress Requirement
+
+*No current requirement in progress*
+
+## 📋 Requirements to Complete
+
+*No requirements to complete*
+
+## ⚠️ Requirements That Need Attention
+
+*No requirements need attention*
+
+## ✅ Completed Requirements
+
+*No completed requirements yet*
+
+---
+
+*This file was automatically created by VibeCodingMachine*
+`;
+
+    fs.writeFileSync(requirementsFilePath, defaultContent, 'utf8');
+    logger.log(`📄 Created default requirements file: ${requirementsFilePath}`);
+
+    return requirementsFilePath;
+  } catch (error) {
+    logger.error('❌ Error creating default requirements file:', error);
+    throw error;
+  }
+}
+
+// Function to get or create requirements file path
+async function getOrCreateRequirementsFilePath(repoPath) {
+  try {
+    const hostname = os.hostname();
+
+    // Use shared logic to find existing path first
+    let requirementsFilePath = await getRequirementsPath(repoPath, hostname);
+
+    if (requirementsFilePath && await fs.pathExists(requirementsFilePath)) {
+      return requirementsFilePath;
+    } else {
+      // Create a new hostname-specific requirements file
+      // We default to creating it inside the repo under .vibecodingmachine
+      requirementsFilePath = path.join(repoPath, '.vibecodingmachine', `REQUIREMENTS-${hostname}.md`);
+
+      const fs = require('fs-extra');
+      const defaultRequirementsContent = `# 🌙 VibeCodingMachine – Requirements File
+
+This is a Markdown (.md) file.
+
+You should not need to modify this file, as VibeCodingMachine will modify it for you, but you can add requirements and move them around either here directly, or via AI.
+
+This file contains the requirements to complete the project.  Each item in a list is a self contained requirement that should be able to stand on its own, and not require reference to other requirements.  Each requirement starts in the section of requirements to complete, then it moved to the section with the current requirement being worked on.  VibeCodingMachine will then, after implementing the requirement, move it to the completed requirements list in the CHANGELOG.md file, or to the section in this file for requirements that need attention.  These will be available for you to review.  They should have options to choose, and you decide which option to take, and VibeCodingMachine will work on that again the next time it is run.
+
+## RESPONSE FROM LAST CHAT
+
+### ONE LINE STATUS: 
+
+### ONE LINE SUMMARY: 
+
+### MULTILINE DETAILS: (1-20 lines max)
+
+## 🔨 Current In Progress Requirement
+
+- 
+
+## 🚦 Current Status
+
+PREPARE
+
+## ⏳ Requirements not yet completed
+
+- 
+
+## ✅ Verified by AI screenshot
+
+`;
+      fs.ensureDirSync(path.join(repoPath, '.vibecodingmachine'));
+      fs.writeFileSync(requirementsFilePath, defaultRequirementsContent, 'utf8');
+    }
+
+    return requirementsFilePath;
+  } catch (error) {
+    logger.error('❌ Error getting or creating requirements file path:', error);
+    throw error;
+  }
+}
+
+// Function to get current requirement being worked on
+async function getCurrentRequirement(repoPath) {
+  try {
+    const rPath = repoPath || process.cwd();
+    // Get the requirements file path (create if doesn't exist)
+    const requirementsFilePath = await getOrCreateRequirementsFilePath(rPath);
+
+    // Read the requirements file content
+    const content = await fs.readFile(requirementsFilePath, 'utf8');
+    const lines = content.split('\n');
+
+    // Look for the current in progress requirement
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes('## 🔨 Current In Progress Requirement')) {
+        // Look for the next requirement line
+        for (let j = i + 1; j < lines.length; j++) {
+          if (lines[j].trim().startsWith('- ')) {
+            let requirementText = lines[j].substring(2).trim();
+
+            // Extract the requirement title (remove FAILED prefix if present)
+            if (requirementText.startsWith('FAILED ')) {
+              const failedMatch = requirementText.match(/^FAILED \d+ TIMES?: (.+)$/);
+              if (failedMatch) {
+                requirementText = failedMatch[1];
+              }
+            }
+
+            // Extract just the title part (before the colon)
+            const colonIndex = requirementText.indexOf(':');
+            if (colonIndex !== -1) {
+              requirementText = requirementText.substring(0, colonIndex).trim();
+            }
+
+            // Remove markdown formatting
+            requirementText = requirementText.replace(/\*\*/g, '');
+
+            return `Working on: ${requirementText}`;
+          }
+        }
+        break;
+      }
+    }
+
+    return DEFAULT_INSTRUCTION_TEXT;
+  } catch (error) {
+    logger.error('❌ Error getting current requirement:', error);
+    return DEFAULT_INSTRUCTION_TEXT;
+  }
+}
+
+// Function to check if the current requirement status is DONE
+async function isCurrentRequirementDone(repoPath) {
+  try {
+    const rPath = repoPath || process.cwd();
+    const hostname = os.hostname();
+
+    // Use shared logic to find the file
+    const requirementsFilePath = await getRequirementsPath(rPath, hostname);
+
+    if (!requirementsFilePath || !(await fs.pathExists(requirementsFilePath))) {
+      return false;
+    }
+
+    // Read the requirements file content
+    const content = await fs.readFile(requirementsFilePath, 'utf8');
+    const lines = content.split('\n');
+
+    // First pass: check if "Current Status" section contains DONE
+    let inStatusSection = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      if (line.includes('## 🚦 Current Status')) {
+        inStatusSection = true;
+        continue;
+      }
+
+      // If we're in the status section
+      if (inStatusSection) {
+        // Hit another section header, exit
+        if (line.startsWith('##')) {
+          break;
+        }
+
+        // Check if this line contains DONE (case-insensitive, exact word match)
+        if (line) {
+          const upperLine = line.toUpperCase();
+          // Match DONE as a standalone word or at the start of the line
+          if (upperLine === 'DONE' || upperLine.startsWith('DONE:') || upperLine.startsWith('DONE ')) {
+            logger.log('✅ DONE status detected in Current Status section:', line);
+            return true;
+          }
+        }
+      }
+    }
+
+    // Second pass: check if "Current In Progress Requirement" section is empty
+    let inCurrentSection = false;
+    let foundRequirement = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      if (line.includes('## 🔨 Current In Progress Requirement')) {
+        inCurrentSection = true;
+        continue;
+      }
+
+      // If we're in the current section and hit another section header, exit
+      if (inCurrentSection && line.startsWith('##')) {
+        // If section was empty (no requirement found), it's done
+        if (!foundRequirement) {
+          logger.log('✅ Current requirement section is empty - considering as done');
+          return true;
+        }
+        break;
+      }
+
+      // Track if we found a requirement in the current section
+      if (inCurrentSection && line.startsWith('- ')) {
+        foundRequirement = true;
+      }
+    }
+
+    // If we found a requirement but no DONE status, it's not done yet
+    if (foundRequirement) {
+      logger.log('❌ Found requirement but status is not DONE');
+      return false;
+    }
+
+    // Default: not done
+    return false;
+  } catch (error) {
+    logger.error('❌ Error checking requirement status:', error);
+    return false;
+  }
+}
+
+// Shared function to move to next requirement (used by both IPC and auto mode)
+let isMovingToNextRequirement = false; // Prevent duplicate calls
+let lastMoveTime = 0; // Track when last move happened
+
+async function moveToNextRequirement(repoPath) {
+  const now = Date.now();
+  const rPath = repoPath || process.cwd();
+
+  // Prevent duplicate calls within 5 seconds
+  if (isMovingToNextRequirement || (now - lastMoveTime < 5000)) {
+    logger.log('⚠️ moveToNextRequirement already in progress or called too recently, skipping duplicate call');
+    return { success: false, error: 'Already moving to next requirement or called too recently' };
+  }
+
+  isMovingToNextRequirement = true;
+  lastMoveTime = now;
+
+  try {
+    logger.log('🔄 Moving to next requirement');
+
+    const hostname = os.hostname();
+    // Use shared logic
+    const requirementsFilePath = await getRequirementsPath(rPath, hostname);
+
+    if (!requirementsFilePath || !(await fs.pathExists(requirementsFilePath))) {
+      return { success: false, error: 'Requirements file not found' };
+    }
+
+    // Read current content
+    const content = await fs.readFile(requirementsFilePath, 'utf8');
+    const lines = content.split('\n');
+
+    // Extract current requirement and remove from "Current In Progress"
+    let currentRequirement = null;
+    let inCurrentSection = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes('## 🔨 Current In Progress Requirement')) {
+        inCurrentSection = true;
+        continue;
+      }
+      if (inCurrentSection && lines[i].trim().startsWith('- ')) {
+        currentRequirement = lines[i].substring(2).trim();
+        break;
+      }
+      if (inCurrentSection && lines[i].trim().startsWith('##')) {
+        break;
+      }
+    }
+
+    // Get first requirement from "Requirements not yet completed"
+    let nextRequirement = null;
+    let inNotYetCompleted = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes('## ⏳ Requirements not yet completed')) {
+        inNotYetCompleted = true;
+        continue;
+      }
+      if (inNotYetCompleted && lines[i].trim().startsWith('- ')) {
+        nextRequirement = lines[i].substring(2).trim();
+        break;
+      }
+      if (inNotYetCompleted && lines[i].trim().startsWith('##')) {
+        break;
+      }
+    }
+
+    if (!nextRequirement) {
+      return { success: false, error: 'No more requirements to process' };
+    }
+
+    // Count requirements in "not yet completed" (before moving)
+    let totalRequirementsNotYetCompleted = 0;
+    inNotYetCompleted = false;
+    for (const line of lines) {
+      if (line.includes('## ⏳ Requirements not yet completed')) {
+        inNotYetCompleted = true;
+        continue;
+      }
+      if (inNotYetCompleted && line.trim().startsWith('##')) {
+        break;
+      }
+      if (inNotYetCompleted && line.trim().startsWith('- ')) {
+        totalRequirementsNotYetCompleted++;
+      }
+    }
+
+    // Count completed requirements in "Verified by AI" section
+    let completedCount = 0;
+    let inVerifiedSection = false;
+    for (const line of lines) {
+      if (line.includes('## ✅ Verified by AI screenshot')) {
+        inVerifiedSection = true;
+        continue;
+      }
+      if (inVerifiedSection && line.trim().startsWith('##')) {
+        break;
+      }
+      if (inVerifiedSection && line.trim().startsWith('- ')) {
+        completedCount++;
+      }
+    }
+
+    // Update the file: move current to "Verified by AI", move next to "Current In Progress"
+    const updatedLines = [];
+    inCurrentSection = false;
+    inNotYetCompleted = false;
+    inVerifiedSection = false;
+    let addedCurrentToVerified = false;
+    let addedNextToCurrent = false;
+    let removedNextFromNotYetCompleted = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Handle "Current In Progress Requirement" section
+      if (line.includes('## 🔨 Current In Progress Requirement')) {
+        inCurrentSection = true;
+        updatedLines.push(line);
+        updatedLines.push('');
+        updatedLines.push(`- ${nextRequirement}`);
+        updatedLines.push('');
+        addedNextToCurrent = true;
+        continue;
+      }
+
+      // Skip old current requirement and any text in the current section
+      if (inCurrentSection && !line.trim().startsWith('##')) {
+        // Skip lines until we hit the next section header
+        continue;
+      }
+      if (inCurrentSection && line.trim().startsWith('##')) {
+        inCurrentSection = false;
+        // Don't continue - we want to process this section header
+      }
+
+      // Handle "Current Status" section
+      if (line.includes('## 🚦 Current Status')) {
+        updatedLines.push(line);
+        updatedLines.push('');
+        updatedLines.push('PREPARE');
+        updatedLines.push('');
+
+        // Skip all old status lines until we hit the next section
+        let j = i + 1;
+        while (j < lines.length && !lines[j].trim().startsWith('##')) {
+          j++;
+        }
+        i = j - 1; // Set i to the line before the next section (loop will increment)
+        continue;
+      }
+
+      // Handle "Requirements not yet completed" section
+      if (line.includes('## ⏳ Requirements not yet completed')) {
+        inNotYetCompleted = true;
+        updatedLines.push(line);
+        continue;
+      }
+
+      // Remove the next requirement from "not yet completed"
+      if (inNotYetCompleted && line.trim().startsWith('- ') && !removedNextFromNotYetCompleted) {
+        inNotYetCompleted = false;
+        removedNextFromNotYetCompleted = true;
+        continue; // Skip this line
+      }
+
+      // Handle "Verified by AI" section
+      if (line.includes('## ✅ Verified by AI screenshot')) {
+        inNotYetCompleted = false;
+        if (currentRequirement && !addedCurrentToVerified) {
+          // Check if this requirement is already in the verified section
+          const requirementAlreadyExists = updatedLines.some(existingLine =>
+            existingLine.includes(currentRequirement) && existingLine.trim().startsWith('- ')
+          );
+
+          if (!requirementAlreadyExists) {
+            updatedLines.push(line);
+            updatedLines.push('');
+            // Don't add date prefix - just add the requirement as-is to avoid nesting
+            updatedLines.push(`- ${currentRequirement}`);
+            updatedLines.push('');
+            addedCurrentToVerified = true;
+            continue;
+          } else {
+            logger.log(`⚠️ Requirement "${currentRequirement}" already exists in verified section, skipping duplicate`);
+            addedCurrentToVerified = true;
+          }
+        }
+        updatedLines.push(line);
+        continue;
+      }
+
+      updatedLines.push(line);
+    }
+
+    // Write updated content
+    await fs.writeFile(requirementsFilePath, updatedLines.join('\n'), 'utf8');
+
+    // Calculate current number:
+    // - We just completed 1 requirement (moved to "Verified by AI")
+    // - completedCount already includes previously completed requirements
+    // - So current number = completedCount + 1 (the one we just completed) + 1 (the new current one)
+    // - Which simplifies to: completedCount + 2
+    const currentNumber = completedCount + 2; // +1 for the one we just completed, +1 for the new current one we're starting
+
+    // Total requirements = completedCount + 1 (current) + totalRequirementsNotYetCompleted
+    const totalRequirements = completedCount + 1 + totalRequirementsNotYetCompleted;
+
+    logger.log(`✅ Moved to next requirement: ${nextRequirement}`);
+    logger.log(`📊 Progress: ${currentNumber}/${totalRequirements} (completed: ${completedCount + 1}, remaining: ${totalRequirementsNotYetCompleted - 1})`);
+    logger.log(`📝 Moved to requirement: ${nextRequirement}`);
+
+    return {
+      success: true,
+      nextRequirement: nextRequirement,
+      currentNumber: currentNumber,
+      totalRemaining: totalRequirementsNotYetCompleted - 1
+    };
+  } catch (error) {
+    logger.error('❌ Error moving to next requirement:', error);
+    return { success: false, error: error.message };
+  } finally {
+    // Always reset the flag, even if there was an error
+    isMovingToNextRequirement = false;
+  }
+}
+
+// Function to get current requirement progress numbers
+async function getCurrentRequirementProgress(repoPath) {
+  try {
+    const stats = await getProjectRequirementStats(repoPath);
+    if (!stats) {
+      return { currentNumber: 1, totalRequirements: 1 };
+    }
+
+    // currentNumber = verified + toVerify + 1 (the one we're on)
+    const currentNumber = stats.verifiedCount + stats.toVerifyCount + 1;
+    const totalRequirements = stats.total;
+
+    // Ensure currentNumber doesn't exceed total
+    const sanitizedCurrent = Math.min(currentNumber, totalRequirements || 1);
+
+    return { currentNumber: sanitizedCurrent, totalRequirements: totalRequirements || 1 };
+  } catch (error) {
+    logger.error('❌ Error getting current requirement progress:', error);
+    return { currentNumber: 1, totalRequirements: 1 };
+  }
+}
+
+// Function to get current requirement name only (without "Working on:" prefix)
+async function getCurrentRequirementName(repoPath) {
+  try {
+    const rPath = repoPath || process.cwd();
+    const hostname = os.hostname();
+
+    const requirementsFilePath = await getRequirementsPath(rPath, hostname);
+
+    if (!requirementsFilePath || !(await fs.pathExists(requirementsFilePath))) {
+      return null;
+    }
+
+    // Read the requirements file content
+    const content = await fs.readFile(requirementsFilePath, 'utf8');
+    const lines = content.split('\n');
+
+    // Look for the current in progress requirement
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes('## 🔨 Current In Progress Requirement')) {
+        // Look for the next requirement line
+        for (let j = i + 1; j < lines.length; j++) {
+          if (lines[j].trim().startsWith('- ')) {
+            let requirementText = lines[j].substring(2).trim();
+
+            // Remove markdown formatting (bold **)
+            requirementText = requirementText.replace(/\*\*/g, '');
+
+            // Return the full requirement text without any prefix
+            return requirementText;
+          }
+        }
+        break;
+      }
+    }
+
+    return null;
+  } catch (error) {
+    logger.error('❌ Error getting current requirement name:', error);
+    return null;
+  }
+}
+
+