vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

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

@@ -2,718 +2,439 @@
  * TRUI Requirements Tree Navigator
  *
  * Shows expandable sections using showQuickMenu with letter shortcuts.
- * Sections: TODO SPECIFICATIONS, Verified, To Verify, TODO REQUIREMENTS
+ * Sections: VERIFIED → TO VERIFY → TODO (correct order)
  * 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;
-  }
-};
+const { showQuickMenu } = require('./trui-quick-menu');
+const { debugLogger } = require('./trui-debug');
+const { hasClarificationResponse } = require('./trui-clarifications');
+const inquirer = require('inquirer');
 
 /**
-
-/**
- * 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
+ * Get status icon for requirement status
  */
-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`);
+function getStatusIcon(status) {
+  switch (status) {
+    case 'verified': return '🎉';
+    case 'to-verify': return '✅';
+    case 'todo': return '⏳';
+    default: return '❓';
   }
-
-  // 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.
+ * Create progress bar with colors
  */
-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: [] };
-  }
+function createProgressBar(percentage) {
+  const filled = Math.round(percentage / 10);
+  const empty = 10 - filled;
+  return chalk.green('█'.repeat(filled)) + chalk.gray('█'.repeat(empty));
 }
 
-// Keep loadSection exported for backwards compat with other modules
-async function loadSection(sectionKey) {
-  const sections = await loadAllSections();
-  return sections[sectionKey] || [];
-}
+/**
+ * Load requirements data via RUI resolver
+ */
+async function loadRequirementsData(navigation) {
+  try {
+    const result = navigation.resolver.resolve('list requirements');
+    if (!result.success) return null;
 
-// ─── Menu building ────────────────────────────────────────────────────────────
+    const commandResult = await result.command.execute();
+    if (!commandResult.success || !commandResult.data) return null;
 
-function getStatusIcon(status) {
-  switch (status) {
-    case 'completed': return '✅';
-    case 'in-progress': return '🔄';
-    case 'todo': return '📋';
-    default: return '❓';
+    return commandResult.data;
+  } catch (err) {
+    debugLogger.error('Error loading requirements data', { error: err.message });
+    return null;
   }
 }
 
 /**
- * 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
+ * Build section items with counts and percentages
  */
-async function buildTreeItems(sections, expanded, expandedSpecs, specUserStories) {
+function buildSectionItems(sections, expandedSections = {}) {
   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;
+  const total = sections.verified.length + sections['to-verify'].length + sections.todo.length;
   
-  // 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);
-  }
+  // VERIFIED section
+  const verifiedExpanded = expandedSections.verified || false;
+  const verifiedIcon = verifiedExpanded ? '▼' : '▶';
+  const verifiedPct = total > 0 ? Math.round((sections.verified.length / total) * 100) : 0;
+  items.push({
+    type: 'action',
+    name: `${verifiedIcon} ${getStatusIcon('verified')} VERIFIED (${sections.verified.length}) ${verifiedPct}%`,
+    value: 'section:verified'
+  });
+
+  // TO VERIFY section
+  const toVerifyExpanded = expandedSections['to-verify'] || false;
+  const toVerifyIcon = toVerifyExpanded ? '▼' : '▶';
+  const toVerifyPct = total > 0 ? Math.round((sections['to-verify'].length / total) * 100) : 0;
+  items.push({
+    type: 'action',
+    name: `${toVerifyIcon} ${getStatusIcon('to-verify')} TO VERIFY (${sections['to-verify'].length}) ${toVerifyPct}%`,
+    value: 'section:to-verify'
+  });
+
+  // TODO section
+  const todoExpanded = expandedSections.todo || false;
+  const todoIcon = todoExpanded ? '▼' : '▶';
+  const todoPct = total > 0 ? Math.round((sections.todo.length / total) * 100) : 0;
+  items.push({
+    type: 'action',
+    name: `${todoIcon} ${getStatusIcon('todo')} TODO (${sections.todo.length}) ${todoPct}%`,
+    value: 'section:todo'
+  });
 
   return items;
 }
 
-// ─── Main navigator ───────────────────────────────────────────────────────────
+/**
+ * Build requirement items for an expanded section
+ */
+function buildRequirementItems(requirements, sectionKey) {
+  return requirements.map((req, index) => {
+    const hasClarification = hasClarificationResponse(req);
+    const clarificationIcon = hasClarification ? ' 💬' : '';
+    
+    return {
+      type: 'sub-item',
+      name: `    ${req.title || req.name || 'Untitled'}${clarificationIcon}`,
+      value: `requirement:${sectionKey}:${index}`
+    };
+  });
+}
 
-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');
+/**
+ * Show requirements tree navigator
+ */
+async function showRequirementsTree(navigation, expandedSections = {}) {
+  debugLogger.info('showRequirementsTree called', { expandedSections });
 
-  // 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 data = await loadRequirementsData(navigation);
+  if (!data || !data.sections) {
+    console.log(chalk.yellow('No requirements data available'));
+    return;
   }
 
-  const printHeader = () => {
-    console.clear();
-    process.stdout.write(chalk.bold.cyan('📋 Requirements\n\n'));
-  };
-
-  printHeader();
+  const { sections } = data;
 
   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;
+    // Build menu items
+    const items = [];
+    
+    // Add section headers
+    const sectionItems = buildSectionItems(sections, expandedSections);
+    items.push(...sectionItems);
+
+    // Add expanded section requirements
+    for (const [sectionKey, isExpanded] of Object.entries(expandedSections)) {
+      if (isExpanded && sections[sectionKey]) {
+        items.push({ type: 'separator', name: chalk.gray(`  ── ${sectionKey.toUpperCase()} ──`), value: 'separator' });
+        const reqItems = buildRequirementItems(sections[sectionKey], sectionKey);
+        items.push(...reqItems);
       }
+    }
 
-      // → 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
+    // Add blank separator and actions
+    items.push({ type: 'blank', name: '', value: 'blank' });
+    items.push({ type: 'action', name: '[🔍 Search Requirements]', value: 'search' });
+    items.push({ type: 'action', name: '[🔽 Filter Requirements]', value: 'filter' });
+    items.push({ type: 'action', name: '[+ Add Requirement]', value: 'add-requirement' });
+
+    // Show menu with extra keys for section expansion/collapse and requirement navigation
+    const result = await showQuickMenu(items, 0, {
+      extraKeys: (str, key, selectedIndex, context) => {
+        // Handle section expansion/collapse
+        if (key.name === 'return' || key.name === 'right') {
+          const currentItem = items[selectedIndex];
+          if (currentItem && currentItem.value && currentItem.value.startsWith('section:')) {
+            const sectionKey = currentItem.value.substring(8);
+            expandedSections[sectionKey] = !expandedSections[sectionKey];
+            return true; // Signal handled
           }
         }
-        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;
-            }
+        // Handle requirement actions
+        if (key.name === 'return' || key.name === 'right') {
+          const currentItem = items[selectedIndex];
+          if (currentItem && currentItem.value && currentItem.value.startsWith('requirement:')) {
+            const [, sectionKey, indexStr] = currentItem.value.split(':');
+            const index = parseInt(indexStr, 10);
+            context.resolveWith(`requirement-action:${sectionKey}:${index}`);
+            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}`);
+        // Handle move up/down (u/d keys)
+        if ((str === 'u' || str === 'U') && currentItem && currentItem.value && currentItem.value.startsWith('requirement:')) {
+          const [, sectionKey, indexStr] = currentItem.value.split(':');
+          const index = parseInt(indexStr, 10);
+          context.resolveWith(`requirement-move-up:${sectionKey}:${index}`);
           return true;
         }
-        if (item && item.value && item.value.startsWith('spec:')) {
-          resolveWith(`toggle-disabled-spec:${selectedIndex}`);
+
+        if ((str === 'd' || str === 'D') && currentItem && currentItem.value && currentItem.value.startsWith('requirement:')) {
+          const [, sectionKey, indexStr] = currentItem.value.split(':');
+          const index = parseInt(indexStr, 10);
+          context.resolveWith(`requirement-move-down:${sectionKey}:${index}`);
           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}`);
+        // Handle new requirement (n key)
+        if (str === 'n' || str === 'N') {
+          context.resolveWith('add-requirement');
           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;
+        return false;
+      },
+      hintText: 'Enter/right=expand/action  u/d=move  n=new  ←=back'
+    });
 
-    if (value === 'add-req') {
-      try { await addRequirementFlow(); } catch (_) {}
-      sections = await loadAllSections();
-      printHeader();
+    // Handle actions
+    if (result.value === 'add-requirement') {
+      const { addRequirementFlow } = require('./trui-req-actions');
+      await addRequirementFlow(navigation);
       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();
+    if (result.value.startsWith('section:')) {
+      // Section toggle handled by extraKeys
       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();
+    if (result.value.startsWith('requirement-action:')) {
+      const { handleRequirementSelection } = require('./trui-req-actions');
+      const [, sectionKey, indexStr] = result.value.split(':');
+      const index = parseInt(indexStr, 10);
+      await handleRequirementSelection(index, sections[sectionKey], navigation);
       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 (_) {}
+    if (result.value.startsWith('requirement-move-up:')) {
+      const { handleRequirementMove } = require('./trui-req-actions');
+      const [, sectionKey, indexStr] = result.value.split(':');
+      const index = parseInt(indexStr, 10);
+      const changed = await handleRequirementMove(index, sections[sectionKey], 'up');
+      if (changed) {
+        // Reload data to get updated order
+        const newData = await loadRequirementsData(navigation);
+        if (newData && newData.sections) {
+          Object.assign(sections, newData.sections);
+        }
       }
-      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 (_) {}
+    if (result.value.startsWith('requirement-move-down:')) {
+      const { handleRequirementMove } = require('./trui-req-actions');
+      const [, sectionKey, indexStr] = result.value.split(':');
+      const index = parseInt(indexStr, 10);
+      const changed = await handleRequirementMove(index, sections[sectionKey], 'down');
+      if (changed) {
+        // Reload data to get updated order
+        const newData = await loadRequirementsData(navigation);
+        if (newData && newData.sections) {
+          Object.assign(sections, newData.sections);
         }
       }
-      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();
+    if (result.value === 'search') {
+      await searchRequirements(sections, navigation);
       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();
-      }
+    if (result.value === 'filter') {
+      await filterRequirements(sections, navigation);
       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;
+    if (result.value === '__cancel__') {
+      break;
     }
+  }
+}
 
-    // 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;
-    }
+/**
+ * Search requirements across all sections
+ */
+async function searchRequirements(sections, navigation) {
+  console.clear();
+  console.log(chalk.bold.cyan('🔍 Search Requirements\n'));
+  console.log(chalk.gray('Search across all requirement sections\n'));
 
-    // 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 (_) {}
+  try {
+    const { query } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'query',
+        message: 'Enter search term:',
+        validate: input => input.trim().length > 0 || 'Search term cannot be empty'
       }
-      printHeader();
-      continue;
+    ]);
+
+    if (!query) return;
+
+    // Search across all sections
+    const allRequirements = [];
+    Object.entries(sections).forEach(([sectionKey, sectionReqs]) => {
+      sectionReqs.forEach((req, index) => {
+        allRequirements.push({
+          ...req,
+          section: sectionKey,
+          index,
+          displaySection: sectionKey.toUpperCase()
+        });
+      });
+    });
+
+    // Filter requirements based on search query
+    const searchLower = query.toLowerCase();
+    const matches = allRequirements.filter(req => {
+      const title = (req.title || req.name || '').toLowerCase();
+      const content = (req.content || req.description || '').toLowerCase();
+      return title.includes(searchLower) || content.includes(searchLower);
+    });
+
+    if (matches.length === 0) {
+      console.log(chalk.yellow(`\nNo requirements found matching "${query}"`));
+      await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+      return;
     }
 
-    // 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;
+    // Display search results
+    console.log(chalk.green(`\nFound ${matches.length} requirement(s) matching "${query}":\n`));
+    
+    const result = await showQuickMenu(
+      matches.map((req, index) => ({
+        type: 'search-result',
+        name: `${getStatusIcon(req.status)} ${req.title || req.name} (${req.displaySection})`,
+        value: `search-result:${index}`
+      })),
+      0
+    );
+
+    if (result.value && result.value.startsWith('search-result:')) {
+      const index = parseInt(result.value.substring(13), 10);
+      const selectedReq = matches[index];
+      
+      // Show requirement actions for search result
+      const { handleRequirementSelection } = require('./trui-req-actions');
+      await handleRequirementSelection(selectedReq.index, sections[selectedReq.section], navigation);
     }
 
-    // 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 (_) {}
+  } catch (error) {
+    debugLogger.error('Error in search', { error: error.message });
+    console.log(chalk.red('Search error: ' + error.message));
+  }
+}
+
+/**
+ * Filter requirements by status or section
+ */
+async function filterRequirements(sections, navigation) {
+  console.clear();
+  console.log(chalk.bold.cyan('🔽 Filter Requirements\n'));
+  console.log(chalk.gray('Filter requirements by status or section\n'));
+
+  try {
+    const { filterType, filterValue } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'filterType',
+        message: 'Filter by:',
+        choices: [
+          { name: 'Status (TODO/TO VERIFY/VERIFIED)', value: 'status' },
+          { name: 'Section', value: 'section' },
+          { name: 'Clear All Filters', value: 'clear' }
+        ]
+      },
+      {
+        type: 'list',
+        name: 'filterValue',
+        message: 'Select filter value:',
+        when: (answers) => answers.filterType !== 'clear',
+        choices: (answers) => {
+          if (answers.filterType === 'status') {
+            return [
+              { name: 'TODO items only', value: 'todo' },
+              { name: 'TO VERIFY items only', value: 'to-verify' },
+              { name: 'VERIFIED items only', value: 'verified' }
+            ];
+          } else if (answers.filterType === 'section') {
+            return Object.keys(sections).map(key => ({
+              name: `${key.toUpperCase()} (${sections[key].length} items)`,
+              value: key
+            }));
+          }
+          return [];
         }
       }
-      printHeader();
-      continue;
+    ]);
+
+    if (filterType === 'clear') {
+      console.log(chalk.green('\n✓ All filters cleared'));
+      await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+      return;
+    }
+
+    // Apply filter and show filtered results
+    let filteredReqs = [];
+    let filterDescription = '';
+
+    if (filterType === 'status' && filterValue) {
+      filteredReqs = sections[filterValue] || [];
+      filterDescription = `Status: ${filterValue.toUpperCase()}`;
+    } else if (filterType === 'section' && filterValue) {
+      filteredReqs = sections[filterValue] || [];
+      filterDescription = `Section: ${filterValue.toUpperCase()}`;
+    }
+
+    if (filteredReqs.length === 0) {
+      console.log(chalk.yellow(`\nNo requirements found for filter: ${filterDescription}`));
+      await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+      return;
     }
+
+    // Display filtered results
+    console.log(chalk.green(`\nShowing ${filteredReqs.length} requirement(s) - ${filterDescription}\n`));
+    
+    const result = await showQuickMenu(
+      filteredReqs.map((req, index) => ({
+        type: 'filtered-result',
+        name: `${getStatusIcon(req.status)} ${req.title || req.name}`,
+        value: `filtered-result:${filterType}:${filterValue}:${index}`
+      })),
+      0
+    );
+
+    if (result.value && result.value.startsWith('filtered-result:')) {
+      const [, type, value, indexStr] = result.value.split(':');
+      const index = parseInt(indexStr, 10);
+      const selectedReq = filteredReqs[index];
+      
+      // Show requirement actions for filtered result
+      const { handleRequirementSelection } = require('./trui-req-actions');
+      const sectionKey = type === 'status' ? value : filterValue;
+      await handleRequirementSelection(selectedReq.index, sections[sectionKey], navigation);
+    }
+
+  } catch (error) {
+    debugLogger.error('Error in filter', { error: error.message });
+    console.log(chalk.red('Filter error: ' + error.message));
   }
 }
 
-module.exports = { showRequirementsTree, loadSection, loadAllSections, buildTreeItems };
+module.exports = {
+  showRequirementsTree,
+  loadRequirementsData,
+  buildSectionItems,
+  buildRequirementItems,
+  searchRequirements,
+  filterRequirements
+};