vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-423

package/src/utils/requirements-navigator.js

@@ -0,0 +1,585 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const readline = require('readline');
+const { t, getRequirementsPath, getVibeCodingMachineDir, checkVibeCodingMachineExists } = require('vibecodingmachine-core');
+const { parseRequirementsFromContent } = require('./requirements-parser');
+const { countRequirements } = require('./status-helpers');
+
+// Import helper functions that will be extracted separately
+// These will need to be imported from requirement-actions.js once created
+const {
+  confirmAndExit,
+  showRequirementActions,
+  showClarificationActions,
+  handleAddRequirement,
+  deleteRequirement,
+  deleteClarification,
+  permanentlyDeleteRequirement,
+  moveRequirementDown,
+  moveRequirementUp,
+  promoteRequirement,
+  demoteRequirement,
+  moveClarificationToTodo,
+  handleFeedbackSubmission
+} = require('./requirement-actions');
+
+/**
+ * Tree-style requirements navigator
+ */
+async function showRequirementsTree() {
+  console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
+  console.log(chalk.gray(t('requirements.navigator.basic.instructions') + '\n'));
+  console.log(chalk.gray('💡 Press F for feedback - Share your thoughts anytime\n'));
+
+  const tree = {
+    expanded: { root: true },
+    selected: 0,
+    items: []
+  };
+
+  // Build tree structure
+  const buildTree = async () => {
+    tree.items = [];
+
+    // Root: Requirements
+    tree.items.push({ level: 0, type: 'root', label: `📋 ${t('requirements.menu.label')}`, key: 'root' });
+
+    if (tree.expanded.root) {
+      tree.items.push({ level: 1, type: 'add', label: '➕ ' + t('requirements.add.new'), key: 'add-one' });
+      tree.items.push({ level: 1, type: 'add', label: '➕ ' + t('requirements.add.multiple'), key: 'add-many' });
+
+      // Use pre-calculated stats and labels from shared logic
+      const stats = await countRequirements();
+      const { todoCount, toVerifyCount, verifiedCount, total, todoLabel, toVerifyLabel, verifiedLabel } = stats || {
+        todoCount: 0, toVerifyCount: 0, verifiedCount: 0, total: 0,
+        todoLabel: '⏳ TODO (0 - 0%)', toVerifyLabel: '✅ TO VERIFY (0 - 0%)', verifiedLabel: '🎉 VERIFIED (0 - 0%)'
+      };
+
+      // Create localized labels
+      const localizedTodoLabel = todoCount > 0 ?
+        `⏳ ${t('requirements.section.todo')} (${todoCount} - ${Math.round((todoCount / total) * 100)}%)` :
+        `⏳ ${t('requirements.section.todo')} (0 - 0%)`;
+
+      const localizedToVerifyLabel = toVerifyCount > 0 ?
+        `✅ ${t('requirements.section.to.verify')} (${toVerifyCount} - ${Math.round((toVerifyCount / total) * 100)}%)` :
+        `✅ ${t('requirements.section.to.verify')} (0 - 0%)`;
+
+      const localizedVerifiedLabel = verifiedCount > 0 ?
+        `🎉 ${t('requirements.section.verified')} (${verifiedCount} - ${Math.round((verifiedCount / total) * 100)}%)` :
+        `🎉 ${t('requirements.section.verified')} (0 - 0%)`;
+
+      const verifiedReqs = tree.verifiedReqs || [];
+      const verifyReqs = tree.verifyReqs || [];
+      const clarificationReqs = tree.clarificationReqs || [];
+      const todoReqs = tree.todoReqs || [];
+      const recycledReqs = tree.recycledReqs || [];
+
+      // Calculate percentages for clarification and recycled sections
+      const clarificationPercent = total > 0 ? Math.round((clarificationReqs.length / total) * 100) : 0;
+      const recycledPercent = total > 0 ? Math.round((recycledReqs.length / total) * 100) : 0;
+
+      // VERIFIED section (first) - only show if has requirements
+      if (verifiedReqs.length > 0 || verifiedCount > 0) {
+        tree.items.push({ level: 1, type: 'section', label: localizedVerifiedLabel, key: 'verified' });
+
+        if (tree.expanded.verified) {
+          verifiedReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'verified', label: req, key: `verified-${idx}` });
+          });
+        }
+      }
+
+      // TO VERIFY section (second) - only show if has requirements
+      if (verifyReqs.length > 0 || toVerifyCount > 0) {
+        tree.items.push({ level: 1, type: 'section', label: localizedToVerifyLabel, key: 'verify', section: '✅ Verified by AI screenshot' });
+
+        if (tree.expanded.verify) {
+          verifyReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `verify-${idx}`, req, sectionKey: 'verify' });
+          });
+        }
+      }
+
+      // NEEDING CLARIFICATION section (third) - only show if has requirements
+      if (clarificationReqs.length > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `❓ NEEDING CLARIFICATION (${clarificationReqs.length} - ${clarificationPercent}%)`, key: 'clarification', section: '❓ Requirements needing manual feedback' });
+
+        if (tree.expanded.clarification) {
+          clarificationReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'clarification', label: req.title, key: `clarification-${idx}`, req, sectionKey: 'clarification' });
+          });
+        }
+      }
+
+      // TODO section (fourth) - only show if has requirements
+      if (todoReqs.length > 0 || todoCount > 0) {
+        tree.items.push({ level: 1, type: 'section', label: localizedTodoLabel, key: 'todo', section: '⏳ Requirements not yet completed' });
+
+        if (tree.expanded.todo) {
+          todoReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `todo-${idx}`, req, sectionKey: 'todo' });
+          });
+        }
+      }
+
+      // RECYCLED section (last) - only show if has requirements
+      if (recycledReqs.length > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `♻️ RECYCLED (${recycledReqs.length} - ${recycledPercent}%)`, key: 'recycled', section: '♻️ Recycled' });
+
+        if (tree.expanded.recycled) {
+          recycledReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'recycled', label: req.title, key: `recycled-${idx}`, req, sectionKey: 'recycled' });
+          });
+        }
+      }
+    }
+  };
+
+  // Load requirements for a section
+  const loadSection = async (sectionKey, sectionTitle) => {
+    const reqPath = await getRequirementsPath();
+
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+
+    // Delegate to reusable parser
+    const allReqs = parseRequirementsFromContent(content, sectionKey, sectionTitle);
+
+    // For TODO section, only show primary heading requirements (those marked from '###' titles)
+    if (sectionKey === 'todo') return allReqs.filter(r => r.source === 'heading');
+
+    return allReqs;
+  };
+
+  // Load VERIFIED requirements from CHANGELOG
+  const loadVerified = async () => {
+    const allnightStatus = await checkVibeCodingMachineExists();
+    let changelogPath;
+
+    if (allnightStatus.insideExists) {
+      const allnightDir = await getVibeCodingMachineDir();
+      changelogPath = path.join(path.dirname(allnightDir), 'CHANGELOG.md');
+    } else if (allnightStatus.siblingExists) {
+      changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+    }
+
+    if (!changelogPath || !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) {
+        requirements.push(trimmed.substring(2));
+      }
+    }
+
+    return requirements;
+  };
+
+  // Load clarification requirements with questions
+  const loadClarification = async () => {
+    const reqPath = await getRequirementsPath();
+
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let inSection = false;
+    const requirements = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check if we're entering the clarification section
+      if (trimmed.includes('❓ Requirements needing manual feedback')) {
+        inSection = true;
+        continue;
+      }
+
+      // Check if we're leaving the section (hit another ## section)
+      if (inSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+        break;
+      }
+
+      // Read requirements in new format (### header)
+      if (inSection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+
+        // Skip empty titles
+        if (!title || title.length === 0) {
+          continue;
+        }
+
+        const details = [];
+        const questions = [];
+        let pkg = null;
+        let findings = null;
+        let currentQuestion = null;
+
+        // Read package, description, and clarifying questions
+        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:')) {
+            pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+          }
+          // Check for AI findings
+          else if (nextLine.startsWith('**AI found in codebase:**')) {
+            // Next line will be the findings
+            continue;
+          }
+          else if (nextLine.startsWith('**What went wrong')) {
+            // Description line
+            details.push(nextLine);
+          }
+          else if (nextLine.startsWith('**Clarifying questions:**')) {
+            // Start of questions section
+            continue;
+          }
+          else if (nextLine.match(/^\d+\./)) {
+            // Save previous question if exists
+            if (currentQuestion) {
+              questions.push(currentQuestion);
+            }
+            // This is a new question
+            currentQuestion = { question: nextLine, response: null };
+          }
+          else if (currentQuestion && nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+            // This might be a response to the current question or description/findings
+            if (!findings && !currentQuestion.response && questions.length === 0 && !nextLine.match(/^\d+\./)) {
+              // This is findings content
+              findings = nextLine;
+            } else if (currentQuestion && !currentQuestion.response) {
+              // This is a response to the current question
+              currentQuestion.response = nextLine;
+            } else {
+              // Description line
+              details.push(nextLine);
+            }
+          }
+          else if (nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+            // Description line
+            details.push(nextLine);
+          }
+        }
+
+        // Save last question if exists
+        if (currentQuestion) {
+          questions.push(currentQuestion);
+        }
+
+        requirements.push({ title, details, pkg, questions, findings, lineIndex: i });
+      }
+    }
+
+    return requirements;
+  };
+
+  // Load all sections upfront to show counts immediately
+  tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+  tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+  tree.clarificationReqs = await loadClarification();
+  tree.verifiedReqs = await loadVerified();
+  tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
+
+  let inTree = true;
+  await buildTree();
+
+  while (inTree) {
+    console.clear();
+    console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
+    console.log(chalk.gray(t('requirements.navigator.instructions') + '\n'));
+
+    // Safety check: ensure tree.selected is within bounds
+    if (tree.items.length === 0) {
+      console.log(chalk.yellow('No items to display.'));
+      console.log(chalk.gray(`\n${t('interactive.press.any.key.return')}`));
+      await new Promise((resolve) => {
+        process.stdin.once('keypress', () => resolve());
+      });
+      inTree = false;
+      continue;
+    }
+
+    if (tree.selected >= tree.items.length) {
+      tree.selected = tree.items.length - 1;
+    }
+
+    if (tree.selected < 0) {
+      tree.selected = 0;
+    }
+
+    // Calculate window for scrolling (show max 20 items at a time)
+    const maxVisible = 20;
+    let startIdx = 0;
+    let endIdx = tree.items.length;
+
+    if (tree.items.length > maxVisible) {
+      // Center the selected item in the window
+      startIdx = Math.max(0, tree.selected - Math.floor(maxVisible / 2));
+      endIdx = Math.min(tree.items.length, startIdx + maxVisible);
+
+      // Adjust if we're near the end
+      if (endIdx - startIdx < maxVisible) {
+        startIdx = Math.max(0, endIdx - maxVisible);
+      }
+    }
+
+    // Show indicator if there are items above
+    if (startIdx > 0) {
+      console.log(chalk.gray(`  ↑ ${startIdx} more above...`));
+    }
+
+    // Display visible tree items
+    for (let idx = startIdx; idx < endIdx; idx++) {
+      const item = tree.items[idx];
+      const indent = '  '.repeat(item.level);
+      const arrow = tree.expanded[item.key] ? '▼' : (item.type === 'section' ? '▶' : ' ');
+      const prefix = item.type === 'section' || item.type === 'root' ? arrow + ' ' : '  ';
+      const selected = idx === tree.selected ? chalk.cyan('❯ ') : '  ';
+
+      // Truncate long labels to fit terminal width (max 120 chars)
+      const maxLabelWidth = 120;
+      let label = item.label;
+      if (label.length > maxLabelWidth) {
+        label = label.substring(0, maxLabelWidth - 3) + '...';
+      }
+
+      console.log(selected + indent + prefix + (idx === tree.selected ? chalk.cyan(label) : chalk.gray(label)));
+    }
+
+    // Show indicator if there are items below
+    if (endIdx < tree.items.length) {
+      console.log(chalk.gray(`  ↓ ${tree.items.length - endIdx} more below...`));
+    }
+
+    console.log();
+
+    // Handle input
+    const key = await new Promise((resolve) => {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+
+      const handler = (str, key) => {
+        process.stdin.removeListener('keypress', handler);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        resolve(key);
+      };
+
+      process.stdin.on('keypress', handler);
+      process.stdin.resume();
+    });
+
+    if (!key) continue;
+
+    // Handle key presses
+    if (key.ctrl && key.name === 'c') {
+      // Ctrl+C always exits immediately
+      process.exit(0);
+    } else if (key.name === 'x' || key.name === 'escape') {
+      // X or ESC key - exit CLI with confirmation
+      await confirmAndExit();
+    } else if (key.name === 'left') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (tree.expanded[current.key]) {
+        // Collapse expanded section
+        tree.expanded[current.key] = false;
+        await buildTree();
+      } else if (current.level > 0) {
+        // Go to parent
+        for (let i = tree.selected - 1; i >= 0; i--) {
+          if (tree.items[i].level < current.level) {
+            tree.selected = i;
+            break;
+          }
+        }
+      } else {
+        // At root level, go back to main menu
+        inTree = false;
+      }
+    } else if (key.name === 'k' || key.name === 'up') {
+      tree.selected = Math.max(0, tree.selected - 1);
+      await buildTree();
+    } else if (key.name === 'j' || key.name === 'down') {
+      tree.selected = Math.min(tree.items.length - 1, tree.selected + 1);
+      await buildTree();
+    } else if (key.name === 'right' || key.name === 'return' || key.name === 'space') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+      if (current.type === 'section') {
+        if (!tree.expanded[current.key]) {
+          tree.expanded[current.key] = true;
+          // Load requirements for this section
+          if (current.key === 'todo') {
+            tree.todoReqs = await loadSection(current.key, current.section);
+          } else if (current.key === 'verify') {
+            tree.verifyReqs = await loadSection(current.key, current.section);
+          } else if (current.key === 'verified') {
+            tree.verifiedReqs = await loadVerified();
+          } else if (current.key === 'recycled') {
+            tree.recycledReqs = await loadSection(current.key, current.section);
+          }
+          await buildTree();
+        } else {
+          tree.expanded[current.key] = false;
+          await buildTree();
+        }
+      } else if (current.type === 'requirement') {
+        // Show requirement actions
+        await showRequirementActions(current.req, current.sectionKey, tree);
+        await buildTree();
+      } else if (current.type === 'clarification') {
+        // Show clarification requirement with questions
+        await showClarificationActions(current.req, tree, loadClarification);
+        await buildTree();
+      } else if (current.type === 'verified') {
+        // Show verified item details (read-only)
+        console.clear();
+        console.log(chalk.bold.green(`\n${current.label}\n`));
+        console.log(chalk.gray('(From CHANGELOG.md - read only)'));
+        console.log(chalk.gray(`\n${t('interactive.press.any.key.back')}`));
+        await new Promise((resolve) => {
+          readline.emitKeypressEvents(process.stdin);
+          if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+          }
+          const handler = (str, key) => {
+            process.stdin.removeListener('keypress', handler);
+            if (process.stdin.isTTY) {
+              process.stdin.setRawMode(false);
+            }
+            resolve();
+          };
+          process.stdin.on('keypress', handler);
+          process.stdin.resume();
+        });
+      } else if (current.type === 'add') {
+        // Handle add requirement
+        await handleAddRequirement(current.key);
+        // Reload TODO section
+        tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+        await buildTree();
+      }
+    } else if (key.name === 'f') {
+      // Feedback button ( megaphone 📣 )
+      await handleFeedbackSubmission();
+      await buildTree();
+    } else if (key.name === 'r') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await deleteRequirement(current.req, current.sectionKey, tree);
+        // Reload the section that the requirement was deleted from
+        if (current.sectionKey === 'todo') {
+          tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+        } else if (current.sectionKey === 'verify') {
+          tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+        }
+        await buildTree();
+      } else if (current.type === 'clarification') {
+        await deleteClarification(current.req, tree);
+        tree.clarificationReqs = await loadClarification();
+        await buildTree();
+      } else if (current.type === 'recycled') {
+        await permanentlyDeleteRequirement(current.req, current.sectionKey, tree);
+        tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
+        await buildTree();
+      }
+    } else if (key.name === 'j') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await moveRequirementDown(current.req, current.sectionKey, tree);
+        await buildTree();
+        // Move selection down to follow the item
+        if (tree.selected < tree.items.length - 1) {
+          tree.selected++;
+        }
+      }
+    } else if (key.name === 'k') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await moveRequirementUp(current.req, current.sectionKey, tree);
+        await buildTree();
+        // Move selection up to follow the item
+        if (tree.selected > 0) {
+          tree.selected--;
+        }
+      }
+    } else if (key.name === 'u') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await promoteRequirement(current.req, current.sectionKey, tree, loadSection, loadVerified);
+        await buildTree();
+      }
+    } else if (key.name === 'd') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'clarification') {
+        // D on clarification item = Move to TODO
+        await moveClarificationToTodo(current.req, tree);
+        tree.clarificationReqs = await loadClarification();
+        tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+        await buildTree();
+      } else if (current.type === 'requirement' || current.type === 'verified') {
+        const sectionKey = current.type === 'verified' ? 'verified' : current.sectionKey;
+        const reqTitle = current.type === 'verified' ? current.label : current.req.title;
+        await demoteRequirement(reqTitle, sectionKey, tree, loadSection, loadVerified);
+        await buildTree();
+      }
+    }
+  }
+
+  process.stdin.pause();
+}
+
+module.exports = {
+  showRequirementsTree
+};