vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/utils/trui-navigation-backup.js

@@ -0,0 +1,603 @@
+/**
+ * TRUI Navigation — Main Menu
+ *
+ * Renders the status-rich main menu using showQuickMenu (raw keypress).
+ * Status/settings lines shown in gray at top; action items in white below.
+ * Uses inline accordion expansion for sections.
+ * Now using RUI pattern for consistent command structure.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { showQuickMenu } = require('./trui-quick-menu');
+const { showProviderManagerMenu } = require('./provider-manager');
+const { initializeWindsurfIntegration, getWindsurfStatus } = require('./trui-windsurf');
+const { debugLogger, perfMonitor, stateTracker } = require('./trui-debug');
+const RUITRUIAdapter = require('./rui-trui-adapter');
+
+// Import section modules
+const {
+  loadRequirementsData,
+  buildRequirementChoices,
+  handleRequirementSelection,
+  handleRequirementMove,
+} = require('./trui-nav-requirements');
+
+const {
+  loadSettingsData,
+  buildSettingChoices,
+  handleSettingSelection,
+  showSettings,
+} = require('./trui-nav-settings');
+
+const {
+  loadSpecificationsData,
+  buildSpecificationChoices,
+  handleSpecificationSelection,
+  addSpecificationFlow,
+} = require('./trui-nav-specifications');
+
+const {
+  loadAgentsData,
+  buildAgentChoices,
+  handleAgentSelection,
+  handleAgentAction,
+  createAgentNavigationHandler,
+} = require('./trui-nav-agents');
+
+/**
+ * Build main-menu items array with live status at top + inline accordion sections
+ * @param {Object} expandedSections - Map of section names to expanded state
+ * @param {Object} navigation - TRUINavigation instance for loading section data
+ */
+async function buildMainMenuItems(expandedSections = {}, navigation = null) {
+  const items = [];
+
+  // Auto Mode status
+  let autoStatus = { running: false };
+  try {
+    const { checkAutoModeStatus } = require('./auto-mode');
+    autoStatus = await checkAutoModeStatus();
+  } catch (_) {}
+
+  items.push({
+    type: 'setting',
+    name: `Auto Mode: ${autoStatus.running ? chalk.green('Running ✓') : chalk.yellow('Stopped ○')}`,
+    value: 'setting:auto',
+  });
+
+  // Requirements summary (only show when requirements section is not expanded)
+  if (!expandedSections.requirements) {
+    try {
+      const { countRequirements } = require('./status-helpers-extracted');
+      const counts = await countRequirements();
+      if (counts) {
+        const total = (counts.todoCount || 0) + (counts.toVerifyCount || 0) + (counts.verifiedCount || 0);
+        const pct = n => total > 0 ? Math.round((n / total) * 100) : 0;
+        items.push({
+          type: 'setting',
+          name: `Requirements: ${chalk.yellow(counts.todoCount + ' todo')}, ${chalk.cyan(counts.toVerifyCount + ' verify')}, ${chalk.green(counts.verifiedCount + ' done')} (${pct(counts.verifiedCount)}% complete)`,
+          value: 'setting:requirements',
+        });
+      }
+    } catch (_) {}
+  }
+
+  // Current agent display with rate-limit warning
+  try {
+    const { getProviderPreferences } = require('./provider-registry');
+    const prefs = await getProviderPreferences();
+    const { getProviderCache } = require('./config');
+    const cache = await getProviderCache();
+    
+    // Find first enabled provider
+    let currentAgent = null;
+    let rateLimitWarning = '';
+    for (const agentId of (prefs.order || [])) {
+      if (prefs.enabled[agentId] !== false) {
+        currentAgent = agentId;
+        const agentCache = cache[agentId];
+        if (agentCache && agentCache.rateLimitRemaining !== undefined) {
+          if (agentCache.rateLimitRemaining < 10) {
+            rateLimitWarning = chalk.red(` (${agentCache.rateLimitRemaining} left)`);
+          } else if (agentCache.rateLimitRemaining < 50) {
+            rateLimitWarning = chalk.yellow(` (${agentCache.rateLimitRemaining} left)`);
+          }
+        }
+        break;
+      }
+    }
+    
+    if (currentAgent) {
+      const { getProviderDisplayName } = require('./provider-registry');
+      const displayName = getProviderDisplayName(currentAgent);
+      items.push({
+        type: 'setting',
+        name: `Agent: ${chalk.cyan(displayName)}${rateLimitWarning}`,
+        value: 'setting:agent',
+      });
+    }
+  } catch (_) {}
+
+  items.push({ type: 'blank', name: '', value: 'blank' });
+
+  // Requirements section with inline accordion
+  const reqExpanded = expandedSections.requirements || false;
+  const reqIcon = reqExpanded ? '▼' : '▶';
+  items.push({ type: 'action', name: `${reqIcon} 📋 Requirements`, value: 'requirements' });
+  if (reqExpanded && navigation) {
+    const reqData = await loadRequirementsData(navigation);
+    const reqChoices = buildRequirementChoices(reqData);
+    reqChoices.forEach(choice => {
+      if (choice instanceof inquirer.Separator) {
+        items.push({ type: 'separator', name: choice.line, value: 'separator' });
+      } else {
+        items.push({ type: 'sub-item', name: choice.name, value: choice.value });
+      }
+    });
+  }
+
+  // Agents section with inline accordion
+  const agentsExpanded = expandedSections.agents || false;
+  const agentsIcon = agentsExpanded ? '▼' : '▶';
+  items.push({ type: 'action', name: `${agentsIcon} 🤖 Agents`, value: 'agents' });
+  if (agentsExpanded && navigation) {
+    const agentsData = await loadAgentsData(navigation);
+    const agentsChoices = buildAgentChoices(agentsData);
+    agentsChoices.forEach(choice => {
+      if (choice instanceof inquirer.Separator) {
+        items.push({ type: 'separator', name: choice.line, value: 'separator' });
+      } else {
+        items.push({ type: 'sub-item', name: choice.name, value: choice.value });
+      }
+    });
+  }
+
+  // Specifications section with inline accordion
+  const specsExpanded = expandedSections.specifications || false;
+  const specsIcon = specsExpanded ? '▼' : '▶';
+  items.push({ type: 'action', name: `${specsIcon} 📐 Specifications`, value: 'specifications' });
+  if (specsExpanded) {
+    const specsData = await loadSpecificationsData();
+    const specsChoices = buildSpecificationChoices(specsData);
+    specsChoices.forEach(choice => {
+      items.push({ type: 'sub-item', name: choice.name, value: choice.value });
+    });
+  }
+
+  // Settings (non-accordion, opens separate view)
+  items.push({ type: 'action', name: '⚙️  Settings', value: 'settings' });
+
+  // Action shortcuts
+  items.push({ type: 'blank', name: '', value: 'blank' });
+  items.push({ type: 'action', name: '[+ Add Requirement]', value: 'add-req' });
+  items.push({ type: 'action', name: '[+ Add Specification]', value: 'add-spec' });
+  items.push({ type: 'action', name: '💬 Send Continue to Windsurf', value: 'continue-windsurf' });
+  items.push({ type: 'action', name: '🔄 Sync Now', value: 'sync' });
+  items.push({ type: 'action', name: 'Exit', value: 'exit' });
+
+  return items;
+}
+
+/**
+ * TRUINavigation — main menu loop
+ */
+class TRUINavigation {
+  constructor() {
+    this._lastIndex = 0;
+    this.ruiAdapter = new RUITRUIAdapter();
+  }
+
+  get resolver() {
+    if (!this.ruiAdapter.resolver) {
+      this.ruiAdapter.initialize();
+    }
+    return this.ruiAdapter.resolver;
+  }
+
+  async start() {
+    perfMonitor.start('TRUINavigation.start');
+    stateTracker.push({ type: 'navigation', phase: 'start' });
+    
+    const { showWelcomeScreen } = require('./welcome-screen-extracted');
+
+    console.clear();
+    try { await showWelcomeScreen(); } catch (_) {}
+
+    // Initialize Windsurf integration with error handling
+    try {
+      initializeWindsurfIntegration();
+    } catch (error) {
+      console.log(chalk.yellow('⚠ Windsurf integration disabled: ' + error.message));
+    }
+
+    await this._loop();
+    
+    perfMonitor.end('TRUINavigation.start');
+    stateTracker.pop();
+  }
+
+  async _loop() {
+    perfMonitor.start('TRUINavigation.loop');
+    stateTracker.push({ type: 'navigation', phase: 'loop' });
+    
+    const { sendContinueToWindsurf } = require('./trui-windsurf');
+
+    // Track expanded sections state
+    const expandedSections = {
+      requirements: false,
+      agents: false,
+      specifications: false,
+    };
+
+    // Track data cache for sections
+    let requirementsData = null;
+    let agentsData = null;
+    let specificationsData = null;
+
+    while (true) {
+      try {
+        const items = await buildMainMenuItems(expandedSections, this);
+
+        // Force screen clear when menu content changes (like when sections expand/collapse)
+        if (process.stdout.isTTY) {
+          console.clear();
+        }
+
+        // Extra keys handler for special commands and agent actions
+        const extraKeys = (str, key, selectedIndex, context) => {
+          if (str === '!' || str === '1') {
+            // Run agents check command
+            context.resolveWith('agents-check');
+            return true;
+          }
+          if (str === 'n' || str === 'N') {
+            // Add requirement shortcut
+            context.resolveWith('add-requirement');
+            return true;
+          }
+
+          // Handle agent enable/disable keys when agents section is expanded
+          if ((str === 'e' || str === 'E' || str === 'd' || str === 'D') && expandedSections.agents && agentsData) {
+            const currentItem = items[selectedIndex];
+            if (currentItem && currentItem.type === 'sub-item' && currentItem.value && currentItem.value.startsWith('agent:')) {
+              const agentIndex = parseInt(currentItem.value.substring(6), 10);
+              const agent = agentsData.agents[agentIndex];
+              if (agent) {
+                const action = str.toLowerCase() === 'e' ? 'enable' : 'disable';
+                context.resolveWith(`agent-${action}:${agentIndex}`);
+                return true;
+              }
+            }
+          }
+
+          // Arrow key navigation for agents
+          if (expandedSections.agents && agentsData && (key.name === 'up' || key.name === 'down')) {
+            const choices = items.filter(item => item.type === 'sub-item' && item.value && item.value.startsWith('agent:'));
+            const agentNavHandler = createAgentNavigationHandler(agentsData, choices);
+            return agentNavHandler(str, key, selectedIndex, context);
+          }
+
+          return false;
+        };
+
+        const result = await showQuickMenu(items, this._lastIndex, extraKeys);
+        this._lastIndex = result.selectedIndex;
+        const action = result.value;
+
+        if (action === '__cancel__' || action === 'exit') {
+          await this._confirmExit();
+          continue;
+        }
+
+        // Handle section accordion toggles
+        if (action === 'requirements') {
+          expandedSections.requirements = !expandedSections.requirements;
+          if (expandedSections.requirements) {
+            requirementsData = await loadRequirementsData(this);
+          }
+          continue;
+        }
+
+        if (action === 'agents') {
+          expandedSections.agents = !expandedSections.agents;
+          if (expandedSections.agents) {
+            agentsData = await loadAgentsData(this);
+          }
+          continue;
+        }
+
+        if (action === 'specifications') {
+          expandedSections.specifications = !expandedSections.specifications;
+          if (expandedSections.specifications) {
+            specificationsData = await loadSpecificationsData();
+          }
+          continue;
+        }
+
+        // Handle requirement sub-item selections
+        if (action.startsWith('req:')) {
+          const reqIndex = parseInt(action.substring(4), 10);
+          const changed = await handleRequirementSelection(reqIndex, requirementsData, this);
+          if (changed) {
+            requirementsData = await loadRequirementsData(this);
+          }
+          console.clear();
+          continue;
+        }
+
+        // Handle requirement move up
+        if (action.startsWith('req-move-up:')) {
+          const reqIndex = parseInt(action.substring(12), 10);
+          const changed = await handleRequirementMove(reqIndex, requirementsData, 'up');
+          if (changed) {
+            requirementsData = await loadRequirementsData(this);
+          }
+          console.clear();
+          continue;
+        }
+
+        // Handle requirement move down
+        if (action.startsWith('req-move-down:')) {
+          const reqIndex = parseInt(action.substring(14), 10);
+          const changed = await handleRequirementMove(reqIndex, requirementsData, 'down');
+          if (changed) {
+            requirementsData = await loadRequirementsData(this);
+          }
+          console.clear();
+          continue;
+        }
+
+        // Handle agent sub-item selections
+        if (action.startsWith('agent:')) {
+          const agentIndex = parseInt(action.substring(6), 10);
+          const changed = await handleAgentSelection(agentIndex, agentsData, this);
+          if (changed) {
+            agentsData = await loadAgentsData(this);
+          }
+          console.clear();
+          continue;
+        }
+
+        // Handle agent enable action
+        if (action.startsWith('agent-enable:')) {
+          const agentIndex = parseInt(action.substring(13), 10);
+          const changed = await handleAgentAction(agentIndex, agentsData, this, 'enable');
+          if (changed) {
+            agentsData = await loadAgentsData(this);
+          }
+          console.clear();
+          continue;
+        }
+
+        // Handle agent disable action
+        if (action.startsWith('agent-disable:')) {
+          const agentIndex = parseInt(action.substring(14), 10);
+          const changed = await handleAgentAction(agentIndex, agentsData, this, 'disable');
+          if (changed) {
+            agentsData = await loadAgentsData(this);
+          }
+          console.clear();
+          continue;
+        }
+
+
+        // Handle specification sub-item selections
+        if (action.startsWith('spec:')) {
+          const specDir = action.substring(5);
+          await handleSpecificationSelection(specDir, specificationsData, this);
+          console.clear();
+          continue;
+        }
+
+        // Dispatch to sub-modules
+        try {
+          if (action === 'setting:auto') {
+            try {
+              const { checkAutoModeStatus, stopAutoMode } = require('./auto-mode');
+              const s = await checkAutoModeStatus();
+              if (s.running) {
+                await stopAutoMode('manual');
+                console.log(chalk.yellow('\n⏹  Auto mode stopped\n'));
+                await this._pause();
+                console.clear();
+              } else {
+                console.log(chalk.bold.cyan('\n▶  Starting Auto Mode...\n'));
+                try {
+                  const { getAutoConfig } = require('./config');
+                  const currentConfig = await getAutoConfig();
+                  // Pick first enabled provider
+                  const { getProviderPreferences } = require('./provider-registry');
+                  const prefs = await getProviderPreferences();
+                  let agentToUse = currentConfig.ide || currentConfig.agent || 'cline';
+                  for (const agentId of (prefs.order || [])) {
+                    if (prefs.enabled[agentId] !== false) { agentToUse = agentId; break; }
+                  }
+                  // Release raw mode before running auto (so Ctrl+C works)
+                  if (process.stdin.isTTY && process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                  }
+                  const options = { ide: agentToUse };
+                  if (currentConfig.neverStop) {
+                    options.neverStop = true;
+                  } else if (currentConfig.maxChats) {
+                    options.maxChats = currentConfig.maxChats;
+                  } else {
+                    options.neverStop = true;
+                  }
+                  const { handleAutoStart } = require('../commands/auto-direct');
+                  await handleAutoStart(options);
+                } catch (startErr) {
+                  if (startErr.message && startErr.message.includes('User force closed')) {
+                    console.log(chalk.yellow('\nCancelled\n'));
+                  } else {
+                    console.log(chalk.red(`\n✗ Error: ${startErr.message}`));
+                    if (startErr.stack) console.log(chalk.gray(startErr.stack.split('\n').slice(0, 8).join('\n')));
+                    console.log(chalk.yellow('\nReturning to menu in 5 seconds...'));
+                    await new Promise(r => setTimeout(r, 5000));
+                  }
+                }
+                await this._pause();
+                console.clear();
+              }
+            } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); console.clear(); }
+            continue;
+          }
+
+          if (action === 'agents-check') {
+            try {
+              const { checkAgents } = require('../commands/agents-check');
+              console.clear();
+              console.log(chalk.bold.cyan('🔍 Checking agents...\n'));
+              await checkAgents();
+              await this._pause();
+            } catch (err) {
+              console.log(chalk.red('Agents check error: ' + err.message));
+              await this._pause();
+            }
+            console.clear();
+            continue;
+          }
+
+          if (action === 'settings') {
+            try { await showSettings(); } catch (err) { console.log(chalk.red('Settings error: ' + err.message)); await this._pause(); }
+            console.clear();
+            continue;
+          }
+
+          if (action === 'add-req' || action === 'add-requirement') {
+            try { await addRequirementFlow(this); } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); }
+            console.clear();
+            // Refresh requirements data if section is expanded
+            if (expandedSections.requirements) {
+              requirementsData = await loadRequirementsData(this);
+            }
+            continue;
+          }
+
+          if (action === 'add-spec') {
+            try { await addSpecificationFlow(this); } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); }
+            console.clear();
+            // Refresh specifications data if section is expanded
+            if (expandedSections.specifications) {
+              specificationsData = await loadSpecificationsData();
+            }
+            continue;
+          }
+
+          if (action === 'continue-windsurf') {
+            try {
+              await sendContinueToWindsurf();
+              console.log(chalk.green('\n✓ Continue message sent to Windsurf Cascade\n'));
+            } catch (err) { console.log(chalk.red('Error: ' + err.message)); }
+            await this._pause();
+            console.clear();
+            continue;
+          }
+
+          if (action === 'sync') {
+            try {
+              const { execSync } = require('child_process');
+              console.log(chalk.cyan('\n🔄 Syncing...\n'));
+              execSync('vcm sync:now', { stdio: 'inherit' });
+            } catch (_) { console.log(chalk.gray('vcm sync:now: command unavailable')); }
+            await this._pause();
+            console.clear();
+            continue;
+          }
+
+          // Unknown action — skip noop/blank/separator
+          if (action === 'noop' || action === 'blank' || action === 'separator') {
+            continue;
+          }
+
+          // Unknown action — show error
+          console.log(chalk.yellow('Unknown action: ' + action));
+          await this._pause();
+          console.clear();
+          continue;
+        } catch (err) {
+          console.log(chalk.red('Action error: ' + err.message));
+          await this._pause();
+          console.clear();
+          continue;
+        }
+
+      } catch (error) {
+        debugLogger.error('Menu loop error', { error: error.message, stack: error.stack });
+        console.log(chalk.red('Menu error: ' + error.message));
+        await this._pause();
+        continue;
+      }
+    }
+    
+    perfMonitor.end('TRUINavigation.loop');
+    stateTracker.pop();
+  }
+
+  async _confirmExit() {
+    console.clear();
+    console.log(chalk.yellow('\nExit Vibe Coding Machine? (Y/n/x)\n'));
+
+    return new Promise((resolve) => {
+      const readline = require('readline');
+
+      // Set up raw keypress handling
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+      }
+
+      const onKeypress = (str, key) => {
+        // Handle left arrow - exit without confirmation
+        if (key && key.name === 'left') {
+          cleanup();
+          console.log(chalk.yellow('\nGoodbye!\n'));
+          process.exit(0);
+          return;
+        }
+
+        // Handle Enter or 'y' or 'Y' or 'x' - confirm exit
+        if (key && (key.name === 'return' || (str && (str === 'y' || str === 'Y' || str === 'x' || str === 'X')))) {
+          cleanup();
+          console.log(chalk.yellow('\nGoodbye!\n'));
+          process.exit(0);
+          return;
+        }
+
+        // Handle 'n' or 'N' or ESC or right arrow - cancel exit
+        if (key && (key.name === 'escape' || key.name === 'right' || (str && (str === 'n' || str === 'N')))) {
+          cleanup();
+          resolve();
+          return;
+        }
+      };
+
+      const cleanup = () => {
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.removeListener('keypress', onKeypress);
+        process.stdin.pause();
+      };
+
+      process.stdin.on('keypress', onKeypress);
+      process.stdin.resume();
+    });
+  }
+
+  async _pause() {
+    const inquirer = require('inquirer');
+    await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+  }
+
+  async promptContinue() {
+    await this._pause();
+  }
+}
+
+module.exports = { TRUINavigation, buildMainMenuItems };
+
+// Export a singleton instance for use by other modules
+const navigationInstance = new TRUINavigation();
+module.exports.promptContinue = () => navigationInstance.promptContinue();