vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/current-requirement-operations.js

@@ -0,0 +1,472 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { getRequirementsPath } = require('./repo-helpers.cjs');
+const { logger } = require('./logger.cjs');
+const { DEFAULT_INSTRUCTION_TEXT } = require('./requirement-file-management');
+const { getProjectRequirementStats } = require('./requirement-statistics');
+
+/**
+ * Current requirement management operations
+ */
+
+// 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
+
+/**
+ * Get current requirement being worked on
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<string>} Current requirement text
+ */
+async function getCurrentRequirement(repoPath) {
+  try {
+    const rPath = repoPath || process.cwd();
+    // Get the requirements file path (create if doesn't exist)
+    const { getOrCreateRequirementsFilePath } = require('./requirement-file-management');
+    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;
+  }
+}
+
+/**
+ * Check if the current requirement status is DONE
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<boolean>} True if 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;
+  }
+}
+
+/**
+ * Move to next requirement
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<Object>} Result with success status and next requirement info
+ */
+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' };
+    }
+
+    // Get auto mode config to check skipDisabled setting
+    let skipDisabled = false;
+    try {
+      const { getAutoConfig } = require('../../../cli/src/utils/config');
+      const autoConfig = await getAutoConfig();
+      skipDisabled = autoConfig.skipDisabled || false;
+    } catch (error) {
+      // If CLI config is not available, default to false
+      logger.log('⚠️ Could not get auto config, using skipDisabled = false');
+    }
+
+    // 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 non-disabled 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('- ')) {
+        const requirementText = lines[i].substring(2).trim();
+        
+        // Check if requirement is disabled (starts with 'DISABLED:')
+        const isDisabled = requirementText.startsWith('DISABLED:');
+        
+        // Skip disabled requirements if skipDisabled is enabled
+        if (skipDisabled && isDisabled) {
+          logger.log(`⏭️  Skipping disabled requirement: ${requirementText}`);
+          continue;
+        }
+        
+        nextRequirement = requirementText;
+        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('- ')) {
+        const requirementText = line.substring(2).trim();
+        const isDisabled = requirementText.startsWith('DISABLED:');
+        
+        // Don't count disabled requirements if skipDisabled is enabled
+        if (!skipDisabled || !isDisabled) {
+          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) {
+        const requirementText = line.substring(2).trim();
+        if (requirementText === nextRequirement) {
+          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;
+  }
+}
+
+/**
+ * Get current requirement name only (without "Working on:" prefix)
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<string|null>} Current requirement name or null
+ */
+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;
+  }
+}
+
+module.exports = {
+  getCurrentRequirement,
+  isCurrentRequirementDone,
+  moveToNextRequirement,
+  getCurrentRequirementName
+};