vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/utils/requirements-navigator/tree-builder.js

@@ -0,0 +1,105 @@
+const { t, getRequirementsPath } = require('vibecodingmachine-core');
+const { countRequirements } = require('../status-helpers');
+
+/**
+ * Builds tree structure for requirements navigator
+ */
+async function buildTreeStructure(tree) {
+  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 } = stats || {
+      todoCount: 0, toVerifyCount: 0, verifiedCount: 0, total: 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' });
+        });
+      }
+    }
+  }
+}
+
+module.exports = {
+  buildTreeStructure
+};

package/src/utils/requirements-navigator/tree-renderer.js

@@ -0,0 +1,50 @@
+const chalk = require('chalk');
+
+/**
+ * Renders the tree UI to console
+ */
+function renderTree(tree, startIdx, endIdx) {
+  // 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)));
+  }
+}
+
+/**
+ * Calculates window for scrolling
+ */
+function calculateScrollWindow(tree, 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);
+    }
+  }
+
+  return { startIdx, endIdx };
+}
+
+module.exports = {
+  renderTree,
+  calculateScrollWindow
+};