vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

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

@@ -0,0 +1,350 @@
+/**
+ * Requirement Moving Functions
+ * Extracted from requirement-manager.js for constitutional compliance
+ * Handles moving requirements between sections (TO VERIFY, Recycled, etc.)
+ */
+
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const { t } = require('vibecodingmachine-core');
+
+/**
+ * Move requirement from TODO to TO VERIFY BY HUMAN section
+ * @param {string} repoPath - Repository path
+ * @param {string} requirementText - Requirement text to move
+ * @returns {Promise<boolean>} - Success status
+ */
+async function moveRequirementToVerify(repoPath, requirementText) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return false;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    // Find the requirement by its title (in ### header format)
+    // Only look in TODO section
+    const normalizedRequirement = requirementText.trim();
+    const snippet = normalizedRequirement.substring(0, 80);
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+    let inTodoSection = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check if we're entering TODO section
+      if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
+
+      // Check if we're leaving TODO section
+      if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
+        inTodoSection = false;
+      }
+
+      // Only look for requirements in TODO section
+      if (inTodoSection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+        if (title) {
+          // Try multiple matching strategies
+          const normalizedTitle = title.trim();
+
+          // Exact match
+          if (normalizedTitle === normalizedRequirement) {
+            requirementStartIndex = i;
+          }
+          // Check if either contains the other (for partial matches)
+          else if (normalizedTitle.includes(normalizedRequirement) || normalizedRequirement.includes(normalizedTitle)) {
+            requirementStartIndex = i;
+          }
+          // Check snippet matches
+          else if (normalizedTitle.includes(snippet) || snippet.includes(normalizedTitle.substring(0, 80))) {
+            requirementStartIndex = i;
+          }
+
+          if (requirementStartIndex !== -1) {
+            // Find the end of this requirement (next ### or ## header)
+            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;
+          }
+        }
+      }
+    }
+
+    if (requirementStartIndex === -1) {
+      console.log(chalk.yellow(`⚠️  ${t('auto.direct.requirement.not.found.todo', { requirement: requirementText.substring(0, 60) + '...' })}`));
+      return false;
+    }
+
+    // Extract the entire requirement block
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+
+    // Remove the requirement from its current location
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+
+    // Check if there are any more requirements in TODO section after removal
+    let hasMoreTodoRequirements = false;
+    inTodoSection = false; // Reset the existing variable
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // Check if we're entering TODO section
+      if (line.startsWith('##') && line.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
+
+      // Check if we're leaving TODO section
+      if (inTodoSection && line.startsWith('##') && !line.startsWith('###') && !line.includes('Requirements not yet completed')) {
+        break;
+      }
+
+      // Check if we found a requirement in TODO section
+      if (inTodoSection && line.startsWith('###')) {
+        const title = line.replace(/^###\s*/, '').trim();
+        if (title) {
+          hasMoreTodoRequirements = true;
+          break;
+        }
+      }
+    }
+
+    // If no more TODO requirements, log message
+    if (!hasMoreTodoRequirements) {
+      console.log(chalk.green(`🎉 ${t('auto.direct.requirement.no.more.todo')}`));
+    }
+
+    // Find or create TO VERIFY BY HUMAN section with conflict resolution
+    // IMPORTANT: Do NOT match VERIFIED sections - only match TO VERIFY sections
+    const verifySectionVariants = [
+      '## 🔍 TO VERIFY BY HUMAN',
+      '## 🔍 TO VERIFY',
+      '## TO VERIFY',
+      '## ✅ TO VERIFY',
+      '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
+      '## 📊 CROSS-COMPUTER REQUIREMENT ASSIGNMENT',
+      '## 🖥️ COMPUTER FOCUS AREA MANAGEMENT',
+      '## 🔍 spec-kit: TO VERIFY BY HUMAN'
+    ];
+
+    let verifyIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check each variant more carefully
+      for (const variant of verifySectionVariants) {
+        const variantTrimmed = variant.trim();
+        // Exact match or line starts with variant
+        if (trimmed === variantTrimmed || trimmed.startsWith(variantTrimmed)) {
+          // Double-check: make sure it's NOT a VERIFIED section (without TO VERIFY)
+          if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) &&
+            (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot') || trimmed.includes('CROSS-COMPUTER REQUIREMENT ASSIGNMENT') || trimmed.includes('COMPUTER FOCUS AREA MANAGEMENT') || trimmed.includes('spec-kit'))) {
+            verifyIndex = i;
+            break;
+          }
+        }
+      }
+      if (verifyIndex !== -1) break;
+    }
+
+    if (verifyIndex === -1) {
+      // Create TO VERIFY section - place it BEFORE VERIFIED section if one exists, otherwise before CHANGELOG
+      const verifiedIndex = lines.findIndex(line => {
+        const trimmed = line.trim();
+        return trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED') ||
+          (trimmed.startsWith('##') && trimmed.includes('VERIFIED') && !trimmed.includes('TO VERIFY'));
+      });
+      const changelogIndex = lines.findIndex(line => line.includes('## CHANGELOG'));
+      const manualFeedbackIndex = lines.findIndex(line => line.trim().startsWith('## ❓'));
+
+      // Prefer: before VERIFIED > before CHANGELOG > before manual feedback > at end
+      let insertionIndex = lines.length;
+      if (verifiedIndex > 0) {
+        insertionIndex = verifiedIndex;
+      } else if (changelogIndex > 0) {
+        insertionIndex = changelogIndex;
+      } else if (manualFeedbackIndex > 0) {
+        insertionIndex = manualFeedbackIndex;
+      }
+
+      const block = [];
+      if (insertionIndex > 0 && lines[insertionIndex - 1].trim() !== '') {
+        block.push('');
+      }
+      block.push('## 🔍 spec-kit: TO VERIFY BY HUMAN', '');
+      lines.splice(insertionIndex, 0, ...block);
+      verifyIndex = lines.findIndex(line => {
+        const trimmed = line.trim();
+        return trimmed === '## 🔍 spec-kit: TO VERIFY BY HUMAN' || trimmed.startsWith('## 🔍 spec-kit: TO VERIFY BY HUMAN');
+      });
+
+      // Safety check: verifyIndex should be valid
+      if (verifyIndex === -1) {
+        console.error(t('auto.direct.verify.section.create.failed'));
+        return false;
+      }
+    }
+
+    // Safety check: verify we're not inserting into a VERIFIED section
+    const verifyLine = lines[verifyIndex] || '';
+    if (verifyLine.includes('## 📝 VERIFIED') || (verifyLine.trim().startsWith('##') && verifyLine.includes('VERIFIED') && !verifyLine.includes('TO VERIFY'))) {
+      console.error('ERROR: Attempted to insert into VERIFIED section instead of TO VERIFY');
+      return false;
+    }
+
+    // Remove any existing duplicate of this requirement in TO VERIFY section
+    // Find the next section header after TO VERIFY
+    let nextSectionIndex = lines.length;
+    for (let i = verifyIndex + 1; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+        nextSectionIndex = i;
+        break;
+      }
+    }
+
+    // Search for duplicate requirement in TO VERIFY section
+    const requirementTitle = requirementBlock[0].trim().replace(/^###\s*/, '').trim();
+    for (let i = verifyIndex + 1; i < nextSectionIndex; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      if (trimmed.startsWith('###')) {
+        const existingTitle = trimmed.replace(/^###\s*/, '').trim();
+
+        // Check if this is a duplicate (exact match or contains/contained by)
+        if (existingTitle === requirementTitle ||
+          existingTitle.includes(requirementTitle) ||
+          requirementTitle.includes(existingTitle)) {
+
+          // Find the end of this existing requirement
+          let existingEndIndex = nextSectionIndex;
+          for (let j = i + 1; j < nextSectionIndex; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine.startsWith('###') || nextLine.startsWith('##')) {
+              existingEndIndex = j;
+              break;
+            }
+          }
+
+          // Remove the duplicate
+          lines.splice(i, existingEndIndex - i);
+
+          // Adjust nextSectionIndex if needed
+          nextSectionIndex -= (existingEndIndex - i);
+          break;
+        }
+      }
+    }
+
+    // Insert requirement block at TOP of TO VERIFY section (right after section header)
+    let insertIndex = verifyIndex + 1;
+
+    // Ensure there's a blank line after the section header
+    if (lines[insertIndex]?.trim() !== '') {
+      lines.splice(insertIndex, 0, '');
+      insertIndex++;
+    }
+
+    // Insert the requirement block
+    lines.splice(insertIndex, 0, ...requirementBlock);
+
+    // Ensure there's a blank line after the requirement block
+    const afterIndex = insertIndex + requirementBlock.length;
+    if (afterIndex < lines.length && lines[afterIndex]?.trim() !== '') {
+      lines.splice(afterIndex, 0, '');
+    }
+
+    // Write the file
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green(`✅ Moved requirement to TO VERIFY BY HUMAN: ${requirementText.substring(0, 80)}...`));
+    return true;
+  } catch (err) {
+    console.error(t('auto.direct.requirement.move.verify.error'), err.message);
+    console.error('⚠️  Requirement may have been lost. Please check the requirements file.');
+    return false;
+  }
+}
+
+/**
+ * Move requirement to recycled section
+ * @param {string} repoPath - Repository path
+ * @param {string} requirementText - Requirement text to recycle
+ * @returns {Promise<boolean>} - Success status
+ */
+async function moveRequirementToRecycle(repoPath, requirementText) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return false;
+    }
+
+    let content = await fs.readFile(reqPath, 'utf8');
+
+    // Find and remove from any section
+    const lines = content.split('\n');
+    let requirementIndex = -1;
+
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(requirementText.substring(0, 50))) {
+        requirementIndex = i;
+        break;
+      }
+    }
+
+    if (requirementIndex === -1) {
+      console.log(chalk.yellow(`⚠️  ${t('auto.direct.requirement.not.found')}`));
+      return false;
+    }
+
+    // Remove from any section
+    const requirementLine = lines[requirementIndex];
+    lines.splice(requirementIndex, 1);
+
+    // Add to Recycled section (after "## ♻️ Recycled")
+    let recycledIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes('## ♻️ Recycled')) {
+        recycledIndex = i; // Move to the line of the header
+        break;
+      }
+    }
+
+    if (recycledIndex === -1) {
+      lines.push('## ♻️ Recycled');
+      recycledIndex = lines.length - 1;
+    }
+
+    // Add timestamp and insert at TOP of Recycled list
+    const timestamp = new Date().toISOString().split('T')[0];
+    lines.splice(recycledIndex + 1, 0, `- ${timestamp}: ${requirementLine.replace(/^- /, '')}`);
+
+    // Save
+    await fs.writeFile(reqPath, lines.join('\n'));
+    return true;
+  } catch (err) {
+    console.error(t('auto.direct.requirement.move.error'), err.message);
+    return false;
+  }
+}
+
+module.exports = {
+  moveRequirementToVerify,
+  moveRequirementToRecycle
+};

package/src/commands/auto-direct/spec-handlers.js

@@ -0,0 +1,155 @@
+/**
+ * Specification Handlers Module
+ *
+ * This module provides functions for managing and processing specifications,
+ * including task counting, task retrieval, and requirement processing.
+ *
+ * Extracted from auto-direct.js to improve modularity and maintainability.
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Count checked and total checkboxes in a spec's tasks.md file.
+ * @param {string} specPath - Path to the spec directory
+ * @returns {{done: number, total: number}} - Checkbox counts
+ */
+function countSpecCheckboxes(specPath) {
+  try {
+    const tasksFile = path.join(specPath, 'tasks.md');
+    if (!fs.existsSync(tasksFile)) return { done: 0, total: 0 };
+    const content = fs.readFileSync(tasksFile, 'utf8');
+    const totalMatches = content.match(/^- \[[ x]\]/gmi) || [];
+    const doneMatches = content.match(/^- \[x\]/gmi) || [];
+    return { done: doneMatches.length, total: totalMatches.length };
+  } catch (_) {
+    return { done: 0, total: 0 };
+  }
+}
+
+/**
+ * Get the next unchecked task line from tasks.md.
+ * Returns { text, line } or null when all done.
+ */
+function getNextSpecTask(specPath) {
+  try {
+    const tasksFile = path.join(specPath, 'tasks.md');
+    if (!fs.existsSync(tasksFile)) return null;
+    const content = fs.readFileSync(tasksFile, 'utf8');
+    for (const line of content.split('\n')) {
+      if (/^- \[ \]/.test(line)) {
+        return { text: line.replace(/^- \[ \]\s*/, '').trim(), line: line.trim() };
+      }
+    }
+    return null;
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Load all enabled specs that have incomplete tasks (or no tasks.md yet).
+ */
+async function loadEnabledIncompleteSpecs(repoPath) {
+  try {
+    const { getAllSpecifications } = require('vibecodingmachine-core');
+    const specs = await getAllSpecifications(repoPath, { skipDisabled: true });
+    return specs.filter(spec => {
+      if (!spec.hasTasks) return true; // No tasks.md = needs planning + implementation
+      const counts = countSpecCheckboxes(spec.path);
+      return counts.total === 0 || counts.done < counts.total;
+    });
+  } catch (err) {
+    console.log(chalk.yellow(`⚠️  Error loading specs: ${err.message}`));
+    return [];
+  }
+}
+
+/**
+ * Process default requirement until completion
+ * @param {RequirementSequencer} sequencer - Requirement sequencer
+ * @param {DefaultRequirementManager} defaultManager - Default requirement manager
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ */
+async function processDefaultRequirement(sequencer, defaultManager, providerConfig, repoPath) {
+  const { getRequirementsPath } = require('vibecodingmachine-core');
+  const requirementsPath = await getRequirementsPath(repoPath);
+  let iterationCount = 0;
+
+  // Import runIteration from parent module - will be injected when called
+  const { runIteration } = require('../auto-direct');
+
+  while (true) {
+    // Check if default requirement should stop
+    const shouldStop = await defaultManager.shouldStop();
+    if (shouldStop) {
+      const status = await defaultManager.getStatus();
+      console.log(chalk.bold.green(`\n✅ Default Requirement Complete`));
+      console.log(chalk.gray(`Status: ${status.completionReason || 'Completed'}\n`));
+      break;
+    }
+
+    // Check if regular requirements were added (should pause default)
+    const currentState = await sequencer.getCurrentState(requirementsPath);
+    if (currentState.hasRegularRequirements) {
+      console.log(chalk.bold.yellow('\n⏸️  Default Requirement Paused'));
+      console.log(chalk.gray('New regular requirements detected, pausing default requirement...\n'));
+      await defaultManager.pause();
+      break;
+    }
+
+    // Get current default requirement status
+    const defaultStatus = await defaultManager.getStatus();
+    iterationCount = defaultStatus.iterationCount + 1;
+
+    console.log(chalk.bold.cyan(`\n${'━'.repeat(80)}`));
+    console.log(chalk.bold.cyan(`  ⭐ DEFAULT REQUIREMENT - Iteration ${iterationCount}/${defaultStatus.maxIterations}`));
+    console.log(chalk.bold.cyan(`  ${defaultStatus.title}`));
+    console.log(chalk.bold.cyan(`${'━'.repeat(80)}\n`));
+
+    // Create a synthetic requirement object for the default requirement
+    const defaultRequirement = {
+      text: defaultStatus.description,
+      number: iterationCount,
+      isDefault: true
+    };
+
+    // Run iteration with default requirement
+    const result = await runIteration(defaultRequirement, providerConfig, repoPath);
+
+    if (result.success) {
+      // Increment iteration count
+      await defaultManager.incrementIteration();
+      console.log(chalk.bold.green(`✅ Default Requirement Iteration ${iterationCount}/${defaultStatus.maxIterations} COMPLETE`));
+
+      // Small delay between iterations
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    } else {
+      // Record failure
+      await defaultManager.recordFailure();
+      console.log(chalk.bold.red(`❌ Default Requirement Iteration ${iterationCount}/${defaultStatus.maxIterations} FAILED`));
+      console.log(chalk.red(`Error: ${result.error}\n`));
+
+      // Check consecutive failures
+      const updatedStatus = await defaultManager.getStatus();
+      if (updatedStatus.consecutiveFailures >= 5) {
+        console.log(chalk.bold.yellow('\n⚠️  Maximum consecutive failures reached'));
+        await defaultManager.markDone('Stopped due to consecutive failures');
+        break;
+      }
+
+      // Delay longer after failure
+      await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+  }
+}
+
+module.exports = {
+  countSpecCheckboxes,
+  getNextSpecTask,
+  loadEnabledIncompleteSpecs,
+  processDefaultRequirement
+};