vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/utils/trui-req-tree-old.js

@@ -0,0 +1,719 @@
+/**
+ * TRUI Requirements Tree Navigator
+ *
+ * Shows expandable sections using showQuickMenu with letter shortcuts.
+ * Sections: TODO SPECIFICATIONS, Verified, To Verify, TODO REQUIREMENTS
+ * Each section is collapsible; requirements shown as sub-items when expanded.
+ */
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+// CLI state management functions
+const getStateFilePath = () => path.join(os.homedir(), '.vibecodingmachine-cli-states.json');
+
+const saveCliStates = async (expanded, expandedSpecs) => {
+  try {
+    const states = {
+      expanded: expanded,
+      expandedSpecs: Array.from(expandedSpecs)
+    };
+    await fs.writeFile(getStateFilePath(), JSON.stringify(states, null, 2));
+    console.log('💾 Saved CLI list states');
+  } catch (error) {
+    console.error('❌ Error saving CLI states:', error.message);
+  }
+};
+
+const loadCliStates = async () => {
+  try {
+    const stateFile = getStateFilePath();
+    if (await fs.pathExists(stateFile)) {
+      const content = await fs.readFile(stateFile, 'utf8');
+      const states = JSON.parse(content);
+      console.log('📂 Loaded CLI list states');
+      return {
+        expanded: states.expanded || { specifications: false, verified: false, verify: false, todo: false, recycled: false },
+        expandedSpecs: new Set(states.expandedSpecs || [])
+      };
+    }
+    console.log('📂 No saved CLI states found, using defaults (all closed)');
+    return null;
+  } catch (error) {
+    console.error('❌ Error loading CLI states:', error.message);
+    return null;
+  }
+};
+
+/**
+
+/**
+ * Create progress bar string with green/orange gradient based on completion percentage
+ * @param {number} percentage - Completion percentage (0-100)
+ * @param {number} done - Number of completed tasks
+ * @param {number} total - Total number of tasks
+ * @returns {string} Progress bar with colors
+ */
+function createProgressBar(percentage, done, total) {
+  if (total === 0) return chalk.gray(' TODO');
+
+  const isComplete = percentage === 100;
+  if (isComplete) {
+    return chalk.bgGreen.black(` ${percentage}%, ${done}/${total} tasks complete`);
+  }
+
+  // For partial progress, split the text background based on actual percentage
+  const progressText = `${percentage}%, ${done}/${total} tasks complete`;
+  const textLength = progressText.length;
+  const splitPoint = Math.floor((percentage / 100) * textLength);
+
+  const firstHalf = progressText.substring(0, splitPoint);
+  const secondHalf = progressText.substring(splitPoint);
+
+  // Apply green background to percentage portion, orange to remaining
+  const greenHalf = chalk.bgGreen.black(firstHalf);
+  const orangeHalf = chalk.bgHex('#f59e0b').black(secondHalf);
+
+  return ` ${greenHalf}${orangeHalf}`;
+}
+
+// ─── Data loading (ported from old interactive.js) ───────────────────────────
+
+/**
+ * Load all requirement sections using parseRequirementsFile from core.
+ *
+ * Section mapping (matches old interactive.js behaviour):
+ *   verified (🎉) ← parsed.verified  (## ✅ Verified by AI screenshot)
+ *   verify   (✅) ← parsed.completed (## 📝 VERIFIED — fully human-verified)
+ *   todo     (⏳) ← parsed.requirements (## ⏳ Requirements not yet completed)
+ *
+ * Each item is a string; we normalise to { title } objects for the tree.
+ */
+async function loadAllSections() {
+  try {
+    const { getRequirementsPath, parseRequirementsFile } = require('vibecodingmachine-core');
+    const { getRepoPath } = require('./config');
+    const repoPath = await getRepoPath();
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return { verified: [], verify: [], todo: [], recycled: [] };
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const parsed = parseRequirementsFile(content);
+
+    const toItems = arr =>
+      (arr || [])
+        .filter(r => r && (typeof r === 'string' ? r.trim() : r.title))
+        .map(r => typeof r === 'string' ? { title: r.trim() } : r);
+
+    return {
+      verified: toItems(parsed.verified),    // AI-screenshot verified items
+      verify:   toItems(parsed.completed),   // fully human-verified items
+      todo:     toItems(parsed.requirements), // not yet completed
+      recycled: toItems(parsed.recycled),
+    };
+  } catch (_) {
+    return { verified: [], verify: [], todo: [], recycled: [] };
+  }
+}
+
+// Keep loadSection exported for backwards compat with other modules
+async function loadSection(sectionKey) {
+  const sections = await loadAllSections();
+  return sections[sectionKey] || [];
+}
+
+// ─── Menu building ────────────────────────────────────────────────────────────
+
+function getStatusIcon(status) {
+  switch (status) {
+    case 'completed': return '✅';
+    case 'in-progress': return '🔄';
+    case 'todo': return '📋';
+    default: return '❓';
+  }
+}
+
+/**
+ * Build showQuickMenu items for the requirements tree
+ * @param {Object} sections - requirements sections
+ * @param {Object} expanded - which sections are expanded
+ * @param {Set} [expandedSpecs] - set of expanded spec indices
+ * @param {Map} [specUserStories] - cache of specIdx -> story title strings
+ */
+async function buildTreeItems(sections, expanded, expandedSpecs, specUserStories) {
+  const items = [];
+  const total = sections.verified.length + sections.verify.length + sections.todo.length;
+  const pct = n => total > 0 ? Math.round((n / total) * 100) : 0;
+
+  const addSection = (key, icon, label, reqs) => {
+    const count = reqs.length;
+    const isOpen = expanded[key];
+    const arrow = isOpen ? '▾' : '▸';
+    const percentage = total > 0 ? pct(count) : 0;
+    
+    // Use createProgressBar for consistent colored progress bars
+    const progressStr = total > 0 ? ' ' + createProgressBar(percentage, count, total) : ` (${count})`;
+    
+    items.push({
+      type: isOpen ? 'header' : 'action',
+      name: `${arrow} ${icon} ${label}${progressStr}`,
+      value: `section:${key}`,
+    });
+    if (expanded[key]) {
+      if (count === 0) {
+        items.push({ type: 'info', name: '    (empty)', value: `empty:${key}` });
+      } else {
+        reqs.forEach((req, idx) => {
+          const title = req.title || req;
+          const isDisabled = typeof title === 'string' && title.startsWith('DISABLED: ');
+          const displayTitle = isDisabled
+            ? chalk.gray(`⊘ ${title.slice('DISABLED: '.length)}`)
+            : title;
+          items.push({
+            type: 'action',
+            name: `    ${displayTitle}`,
+            value: `req:${key}:${idx}`,
+          });
+        });
+      }
+    }
+  };
+
+  // TODO SPECIFICATIONS first
+  try {
+    const { getSpecsList } = require('./trui-specifications');
+    const specs = await getSpecsList();
+    const specsCount = specs.length;
+    
+    // Calculate overall specs progress
+    let specsTotalTasks = 0;
+    let specsDoneTasks = 0;
+    specs.forEach(spec => {
+      if (spec.taskTotal > 0) {
+        specsTotalTasks += spec.taskTotal;
+        specsDoneTasks += spec.taskDone;
+      }
+    });
+    const specsPct = specsTotalTasks > 0 ? Math.round((specsDoneTasks / specsTotalTasks) * 100) : 0;
+    
+    const specsOpen = expanded.specifications;
+    const specsArrow = specsOpen ? '▾' : '▸';
+    
+    // Use createProgressBar for consistent colored progress bars
+    const specsProgressStr = specsTotalTasks > 0 ? ' ' + createProgressBar(specsPct, specsDoneTasks, specsTotalTasks) : '';
+    
+    items.push({
+      type: specsOpen ? 'header' : 'action',
+      name: `${specsArrow} 📋 TODO Specifications${specsProgressStr}`,
+      value: 'section:specifications',
+    });
+    if (specsOpen) {
+      if (specsCount === 0) {
+        items.push({ type: 'info', name: '    (no specifications found)', value: 'empty:specifications' });
+      } else {
+        specs.forEach((spec, idx) => {
+          let progressStr = '';
+          if (spec.taskTotal > 0) {
+            progressStr = ' ' + createProgressBar(spec.pct, spec.taskDone, spec.taskTotal);
+          }
+          const isSpecExpanded = expandedSpecs && expandedSpecs.has(idx);
+          const specArrow = isSpecExpanded ? '▾' : '▸';
+          const isDisabled = spec.disabled || spec.id.startsWith('DISABLED-');
+          const displayId = isDisabled ? spec.id.slice('DISABLED-'.length) : spec.id;
+          const specLabel = isDisabled ? chalk.gray(`⊘ ${displayId}`) : displayId;
+          // Spec items always keep their letter so the user can navigate to and collapse them
+          items.push({
+            type: 'action',
+            name: `    ${specArrow} ${specLabel}${progressStr}`,
+            value: `spec:${idx}`,
+          });
+          if (isSpecExpanded) {
+            const phases = (specUserStories && specUserStories.get(idx)) || [];
+            if (phases.length === 0) {
+              items.push({ type: 'info', name: '        (no phases found)', value: `spec-phase-empty:${idx}` });
+            } else {
+              phases.forEach((phase, pIdx) => {
+                const phaseTitle = typeof phase === 'string' ? phase : phase.title;
+                let phaseProgress = '';
+                if (phase && typeof phase === 'object' && phase.total > 0) {
+                  phaseProgress = chalk.gray(` ${phase.pct}%, ${phase.done}/${phase.total}`);
+                }
+                items.push({
+                  type: 'info',
+                  name: `        ${chalk.gray(phaseTitle)}${phaseProgress}`,
+                  value: `spec-phase:${idx}:${pIdx}`,
+                });
+              });
+            }
+          }
+        });
+      }
+    }
+  } catch (_) {
+    items.push({ type: 'header', name: '▸ 📋 TODO SPECIFICATIONS', value: 'section:specifications' });
+  }
+
+  addSection('verified', '🎉', 'Verified', sections.verified);
+  addSection('verify', '✅', 'To Verify', sections.verify);
+  
+  // Calculate requirements progress
+  let reqsTotalTasks = 0;
+  let reqsDoneTasks = 0;
+  if (sections.todo && sections.todo.length > 0) {
+    sections.todo.forEach(req => {
+      if (req.total > 0) {
+        reqsTotalTasks += req.total;
+        reqsDoneTasks += req.done;
+      }
+    });
+  }
+  const reqsPct = reqsTotalTasks > 0 ? Math.round((reqsDoneTasks / reqsTotalTasks) * 100) : 0;
+  
+  // Use createProgressBar for consistent colored progress bars
+  const reqsProgressStr = reqsTotalTasks > 0 ? ' ' + createProgressBar(reqsPct, reqsDoneTasks, reqsTotalTasks) : '';
+  
+  const reqsTitle = reqsTotalTasks > 0
+    ? `TODO Requirements${reqsProgressStr}`
+    : 'TODO Requirements';
+  
+  addSection('todo', '⏳', reqsTitle, sections.todo);
+
+  if (sections.recycled && sections.recycled.length > 0) {
+    addSection('recycled', '♻️', 'RECYCLED', sections.recycled);
+  }
+
+  return items;
+}
+
+// ─── Main navigator ───────────────────────────────────────────────────────────
+
+async function showRequirementsTree() {
+  const { showQuickMenu } = require('./trui-quick-menu');
+  const { showRequirementActions, addRequirementFlow, _moveRequirement, _deleteRequirement } = require('./trui-req-actions');
+  const { getOrCreateRequirementsFilePath, getRequirementsPath } = require('vibecodingmachine-core');
+  const { getRepoPath } = require('./config');
+
+  // Toggle all items functionality
+  const extraKeys = (str, key, selectedIndex, context) => {
+    if (str === '*' || str === '8') {
+      context.resolveWith({ value: 'toggle-all', selectedIndex });
+      return true;
+    }
+    return false;
+  };
+
+  // Resolve requirements file path exactly like loadAllSections does (getRequirementsPath,
+  // NOT getOrCreate) so reads and writes always go to the same file regardless of
+  // whether it lives inside the repo or in a sibling directory.
+  const repoPath = await getRepoPath();
+  const getReqPath = async () => {
+    // Mirror loadAllSections: call getRequirementsPath with repoPath (even null) first
+    const p = await getRequirementsPath(repoPath);
+    if (p && await fs.pathExists(p)) return p;
+    // File doesn't exist yet — create it (first-time use).
+    // Use effectiveRepoPath (git root) so .vibecodingmachine is never created inside
+    // a sub-package directory when repoPath is null.
+    const { getEffectiveRepoPath } = require('./config');
+    const effectiveRepoPath = await getEffectiveRepoPath();
+    return getOrCreateRequirementsFilePath(effectiveRepoPath);
+  };
+
+  const expanded = { specifications: false, verified: false, verify: false, todo: false, recycled: false };
+  const expandedSpecs = new Set();   // indices of expanded spec items
+  const specPhases = new Map();      // specIdx -> string[]
+  let sections = await loadAllSections();
+  let lastIndex = 0;
+
+  // Load saved states from file
+  const savedStates = await loadCliStates();
+  if (savedStates) {
+    Object.assign(expanded, savedStates.expanded);
+    savedStates.expandedSpecs.forEach(idx => expandedSpecs.add(idx));
+  }
+
+  const printHeader = () => {
+    console.clear();
+    process.stdout.write(chalk.bold.cyan('📋 Requirements\n\n'));
+  };
+
+  printHeader();
+
+  while (true) {
+    const items = await buildTreeItems(sections, expanded, expandedSpecs, specPhases);
+    const hintText = '[→ expand  ← collapse/back  < move item down  > move item up  - delete  + add  Space toggle]';
+
+    const extraKeys = (str, key, selectedIndex, { resolveWith }) => {
+      const keyName = key && key.name;
+
+      // = or + → add requirement (works anywhere)
+      if (str === '=' || str === '+') {
+        resolveWith('add-req');
+        return true;
+      }
+
+      // → right arrow: expand sections and specs (non-toggling — only opens, never closes)
+      if (keyName === 'right') {
+        const item = items[selectedIndex];
+        if (item && item.value) {
+          if (item.value.startsWith('section:')) {
+            const sectionKey = item.value.slice('section:'.length);
+            if (!expanded[sectionKey]) {
+              resolveWith(`expand-section:${sectionKey}`);
+            }
+            return true; // consume even if already expanded
+          }
+          if (item.value.startsWith('spec:')) {
+            const specIdx = parseInt(item.value.split(':')[1], 10);
+            if (!expandedSpecs.has(specIdx)) {
+              resolveWith(`expand-spec:${specIdx}`);
+            }
+            return true; // consume even if already expanded
+          }
+        }
+        return false; // let right arrow act as Enter for other items
+      }
+
+      // ← left arrow: collapse expanded sections/specs; otherwise pass through (→ back)
+      if (keyName === 'left') {
+        const item = items[selectedIndex];
+        if (item && item.value) {
+          // On a collapsed section header → go back (fall through)
+          if (item.value.startsWith('section:')) {
+            const sectionKey = item.value.slice('section:'.length);
+            if (expanded[sectionKey]) {
+              resolveWith(`collapse-section:${sectionKey}`);
+              return true;
+            }
+          }
+          // On a spec item inside expanded SPECIFICATIONS section
+          if (item.value.startsWith('spec:')) {
+            const specIdx = parseInt(item.value.split(':')[1], 10);
+            if (expandedSpecs.has(specIdx)) {
+              // Spec is expanded (showing phases) → collapse phases first
+              resolveWith(`collapse-spec:${specIdx}`);
+              return true;
+            }
+            // Spec not expanded → collapse parent SPECIFICATIONS section
+            if (expanded.specifications) {
+              resolveWith('collapse-section:specifications');
+              return true;
+            }
+          }
+          // On a req item → collapse its parent section
+          if (item.value.startsWith('req:')) {
+            const sectionKey = item.value.split(':')[1];
+            if (expanded[sectionKey]) {
+              resolveWith(`collapse-section:${sectionKey}`);
+              return true;
+            }
+          }
+        }
+        return false; // not on a sub-item → default cancel (go back)
+      }
+
+      // Space → toggle req or spec enabled/disabled
+      if (str === ' ' || keyName === 'space') {
+        const item = items[selectedIndex];
+        if (item && item.value && item.value.startsWith('req:')) {
+          resolveWith(`toggle-disabled:${selectedIndex}`);
+          return true;
+        }
+        if (item && item.value && item.value.startsWith('spec:')) {
+          resolveWith(`toggle-disabled-spec:${selectedIndex}`);
+          return true;
+        }
+        return true; // consume silently on other items
+      }
+
+      // , or < → move requirement down
+      // . or > → move requirement up
+      // - or _ or Delete key → delete requirement
+      const isDown   = str === ',' || str === '<' || keyName === ',' || keyName === '<';
+      const isUp     = str === '.' || str === '>' || keyName === '.' || keyName === '>';
+      const isDelete = str === '-' || str === '_' || keyName === '-' || keyName === '_' ||
+                       (key && (key.name === 'delete' || key.name === 'backspace'));
+      if (isDown || isUp || isDelete) {
+        const item = items[selectedIndex];
+        if (item && item.value && item.value.startsWith('req:')) {
+          const action = isDown ? ',' : isUp ? '.' : '-';
+          resolveWith(`jkd:${action}:${selectedIndex}`);
+          return true;
+        }
+        return true; // consume the key even when not on a req (no-op, avoids confusion)
+      }
+
+      return false;
+    };
+
+    const result = await showQuickMenu(items, lastIndex, { extraKeys, hintText });
+    lastIndex = result.selectedIndex;
+    const value = result.value;
+
+    if (value === '__cancel__' || value === 'exit') break;
+
+    if (value === 'add-req') {
+      try { await addRequirementFlow(); } catch (_) {}
+      sections = await loadAllSections();
+      printHeader();
+      continue;
+    }
+
+    // Handle Space: toggle requirement enabled/disabled
+    if (value.startsWith('toggle-disabled:')) {
+      const itemIdx = parseInt(value.split(':')[1], 10);
+      const item = items[itemIdx];
+      if (item && item.value && item.value.startsWith('req:')) {
+        const reqParts = item.value.split(':');
+        const sectionKey = reqParts[1];
+        const reqIdx = parseInt(reqParts[2], 10);
+        const req = sections[sectionKey] && sections[sectionKey][reqIdx];
+        if (req) {
+          try {
+            const reqPath = await getReqPath();
+            const content = await fs.readFile(reqPath, 'utf8');
+            const title = req.title;
+            let newContent;
+            if (title.startsWith('DISABLED: ')) {
+              // Enable: remove DISABLED: prefix
+              const cleanTitle = title.slice('DISABLED: '.length);
+              const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+              newContent = content.replace(new RegExp(`^(###\\s*)${escaped}\\s*$`, 'm'), `$1${cleanTitle}`);
+            } else {
+              // Disable: add DISABLED: prefix
+              const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+              newContent = content.replace(new RegExp(`^(###\\s*)${escaped}\\s*$`, 'm'), `$1DISABLED: ${title}`);
+            }
+            if (newContent !== content) {
+              await fs.writeFile(reqPath, newContent, 'utf8');
+              sections = await loadAllSections();
+            }
+          } catch (_) {}
+        }
+      }
+      printHeader();
+      continue;
+    }
+
+    // Handle */8: toggle all items
+    if (value === 'toggle-all') {
+      try {
+        const reqPath = await getReqPath();
+        let content = await fs.readFile(reqPath, 'utf8');
+        let hasChanges = false;
+        
+        // Toggle all requirements
+        if (sections.todo && sections.todo.length > 0) {
+          sections.todo.forEach(req => {
+            const title = req.title;
+            if (!title.startsWith('DISABLED: ')) {
+              // Disable all
+              const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+              content = content.replace(new RegExp(`^(###\\s*)${escaped}\\s*$`, 'm'), `$1DISABLED: ${title}`);
+              hasChanges = true;
+            }
+          });
+        }
+        
+        // Toggle all specifications
+        const { getSpecsList } = require('./trui-specifications');
+        const specs = await getSpecsList();
+        for (const spec of specs) {
+          if (spec.taskTotal > 0) {
+            const specDir = spec.path || path.join(await getRepoPath(), 'specs', spec.directory);
+            const tasksMdPath = path.join(specDir, 'tasks.md');
+            if (await fs.pathExists(tasksMdPath)) {
+              let specContent = await fs.readFile(tasksMdPath, 'utf8');
+              const specTitle = spec.title || spec.directory;
+              if (!specContent.includes('DISABLED:')) {
+                // Disable spec
+                specContent = `DISABLED: ${specTitle}\n${specContent}`;
+                hasChanges = true;
+              } else {
+                // Enable spec
+                specContent = specContent.replace(/^DISABLED: .+\n/, '');
+                hasChanges = true;
+              }
+              if (hasChanges) {
+                await fs.writeFile(tasksMdPath, specContent, 'utf8');
+              }
+            }
+          }
+        }
+        
+        if (hasChanges) {
+          sections = await loadAllSections();
+        }
+      } catch (_) {}
+      printHeader();
+      continue;
+    }
+
+    // Handle Space: toggle spec enabled/disabled (rename directory DISABLED- prefix)
+    if (value.startsWith('toggle-disabled-spec:')) {
+      const itemIdx = parseInt(value.split(':')[1], 10);
+      const item = items[itemIdx];
+      if (item && item.value && item.value.startsWith('spec:')) {
+        const specIdx = parseInt(item.value.split(':')[1], 10);
+        try {
+          const { getSpecsList } = require('./trui-specifications');
+          const specs = await getSpecsList();
+          const spec = specs[specIdx];
+          if (spec && spec.path) {
+            const parentDir = path.dirname(spec.path);
+            const dirName = path.basename(spec.path);
+            const newDirName = dirName.startsWith('DISABLED-')
+              ? dirName.slice('DISABLED-'.length)
+              : 'DISABLED-' + dirName;
+            await fs.rename(spec.path, path.join(parentDir, newDirName));
+            // Clear spec caches — indices may shift after rename changes sort order
+            expandedSpecs.clear();
+            specPhases.clear();
+          }
+        } catch (_) {}
+      }
+      printHeader();
+      continue;
+    }
+
+    // Handle j/k/d inline shortcuts
+    if (value.startsWith('jkd:')) {
+      const parts = value.split(':');
+      const action = parts[1];
+      const itemIdx = parseInt(parts[2], 10);
+      const item = items[itemIdx];
+      if (item && item.value && item.value.startsWith('req:')) {
+        const reqParts = item.value.split(':');
+        const sectionKey = reqParts[1];
+        const reqIdx = parseInt(reqParts[2], 10);
+        const req = sections[sectionKey] && sections[sectionKey][reqIdx];
+        if (req) {
+          try {
+            const reqPath = await getReqPath();
+            if (action === ',') {
+              const moved = await _moveRequirement(reqPath, req.title, sectionKey, 'down');
+              if (moved) { sections = await loadAllSections(); lastIndex = Math.min(lastIndex + 1, items.length - 1); }
+            } else if (action === '.') {
+              const moved = await _moveRequirement(reqPath, req.title, sectionKey, 'up');
+              if (moved) { sections = await loadAllSections(); lastIndex = Math.max(lastIndex - 1, 0); }
+            } else if (action === '-') {
+              console.clear();
+              const deleted = await _deleteRequirement(reqPath, req.title);
+              if (deleted) { sections = await loadAllSections(); lastIndex = Math.max(lastIndex - 1, 0); }
+            }
+          } catch (_) {}
+        }
+      }
+      printHeader();
+      continue;
+    }
+
+    // Enter on section header → toggle; cursor auto-advances on open, returns to header on close
+    if (value.startsWith('section:')) {
+      const key = value.slice('section:'.length);
+      expanded[key] = !expanded[key];
+      await saveCliStates(expanded, expandedSpecs);
+      if (!expanded[key]) {
+        // Closing: position cursor back on header
+        const newItems = await buildTreeItems(sections, expanded, expandedSpecs, specPhases);
+        const headerIdx = newItems.findIndex(item => item.value === `section:${key}`);
+        if (headerIdx !== -1) lastIndex = headerIdx;
+      }
+      printHeader();
+      continue;
+    }
+
+    if (value.startsWith('req:')) {
+      const parts = value.split(':');
+      const sectionKey = parts[1];
+      const idx = parseInt(parts[2], 10);
+      const req = sections[sectionKey] && sections[sectionKey][idx];
+      if (req) {
+        console.clear();
+        try {
+          const changed = await showRequirementActions(req, sectionKey);
+          if (changed) sections = await loadAllSections();
+        } catch (_) {}
+        printHeader();
+      }
+      continue;
+    }
+
+    // Expand section (right arrow)
+    if (value.startsWith('expand-section:')) {
+      const key = value.slice('expand-section:'.length);
+      expanded[key] = true;
+      await saveCliStates(expanded, expandedSpecs);
+      printHeader();
+      continue;
+    }
+
+    // Collapse section — position cursor back on the section header
+    if (value.startsWith('collapse-section:')) {
+      const key = value.slice('collapse-section:'.length);
+      expanded[key] = false;
+      await saveCliStates(expanded, expandedSpecs);
+      // Rebuild to find the now-selectable (action) section header position
+      const newItems = await buildTreeItems(sections, expanded, expandedSpecs, specPhases);
+      const headerIdx = newItems.findIndex(item => item.value === `section:${key}`);
+      if (headerIdx !== -1) lastIndex = headerIdx;
+      printHeader();
+      continue;
+    }
+
+    // Expand spec phases (right arrow on spec item) — specIdx is the spec array index
+    if (value.startsWith('expand-spec:')) {
+      const specIdx = parseInt(value.split(':')[1], 10);
+      expandedSpecs.add(specIdx);
+      await saveCliStates(expanded, expandedSpecs);
+      if (!specPhases.has(specIdx)) {
+        try {
+          const { getSpecsList, extractPhases } = require('./trui-specifications');
+          const specs = await getSpecsList();
+          const spec = specs[specIdx];
+          if (spec && spec.path) specPhases.set(specIdx, extractPhases(spec.path));
+        } catch (_) {}
+      }
+      printHeader();
+      continue;
+    }
+
+    // Collapse spec phases — position cursor back on the spec item
+    if (value.startsWith('collapse-spec:')) {
+      const specIdx = parseInt(value.split(':')[1], 10);
+      expandedSpecs.delete(specIdx);
+      await saveCliStates(expanded, expandedSpecs);
+      // Rebuild to find the now-selectable spec item position
+      const newItems = await buildTreeItems(sections, expanded, expandedSpecs, specPhases);
+      const specItemIdx = newItems.findIndex(item => item.value === `spec:${specIdx}`);
+      if (specItemIdx !== -1) lastIndex = specItemIdx;
+      printHeader();
+      continue;
+    }
+
+    // Enter on spec item → toggle expansion
+    if (value.startsWith('spec:')) {
+      const specIdx = parseInt(value.split(':')[1], 10);
+      if (expandedSpecs.has(specIdx)) {
+        expandedSpecs.delete(specIdx);
+      } else {
+        expandedSpecs.add(specIdx);
+        if (!specPhases.has(specIdx)) {
+          try {
+            const { getSpecsList, extractPhases } = require('./trui-specifications');
+            const specs = await getSpecsList();
+            const spec = specs[specIdx];
+            if (spec && spec.path) specPhases.set(specIdx, extractPhases(spec.path));
+          } catch (_) {}
+        }
+      }
+      printHeader();
+      continue;
+    }
+  }
+}
+
+module.exports = { showRequirementsTree, loadSection, loadAllSections, buildTreeItems };