vibecodingmachine-cli 2026.2.26-1752 → 2026.3.9-1621

package/src/utils/trui-main-handlers.js

@@ -0,0 +1,194 @@
+/**
+ * TRUI Main Menu Handlers
+ *
+ * Extracted from trui-navigation.js to reduce file size
+ */
+
+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');
+
+// Import section modules
+const {
+  handleRequirementSelection,
+  handleRequirementMove,
+} = require('./trui-nav-requirements');
+
+const {
+  handleSettingSelection,
+  showSettings,
+} = require('./trui-nav-settings');
+
+const {
+  handleSpecificationSelection,
+  addSpecificationFlow,
+} = require('./trui-nav-specifications');
+
+const {
+  handleAgentSelection,
+  handleAgentAction,
+  createAgentNavigationHandler,
+} = require('./trui-nav-agents');
+
+/**
+ * Handle main menu selection
+ */
+async function handleMainMenuSelection(result, expandedSections, navigation) {
+  const value = result.value;
+
+  if (value === '__cancel__' || value === 'exit') {
+    return { shouldExit: true };
+  }
+
+  if (value.startsWith('section:')) {
+    const sectionName = value.substring(8);
+    expandedSections[sectionName] = !expandedSections[sectionName];
+    return { shouldContinue: true };
+  }
+
+  // Handle section-specific selections
+  if (value.startsWith('requirements:')) {
+    await handleRequirementSelection(value, navigation);
+    return { shouldContinue: true };
+  }
+
+  if (value.startsWith('settings:')) {
+    await handleSettingSelection(value, navigation);
+    return { shouldContinue: true };
+  }
+
+  if (value.startsWith('specifications:')) {
+    await handleSpecificationSelection(value, navigation);
+    return { shouldContinue: true };
+  }
+
+  if (value.startsWith('agents:')) {
+    await handleAgentSelection(value, navigation);
+    return { shouldContinue: true };
+  }
+
+  // Handle tool selections
+  if (value === 'provider-manager') {
+    await showProviderManagerMenu(navigation);
+    return { shouldContinue: true };
+  }
+
+  if (value === 'windsurf') {
+    await handleWindsurfSelection();
+    return { shouldContinue: true };
+  }
+
+  if (value === 'debug-info') {
+    await showDebugInfo();
+    return { shouldContinue: true };
+  }
+
+  return { shouldContinue: true };
+}
+
+/**
+ * Handle Windsurf selection
+ */
+async function handleWindsurfSelection() {
+  console.clear();
+  console.log(chalk.bold.cyan('🌊 Windsurf Integration\n'));
+  
+  try {
+    await initializeWindsurfIntegration();
+    const status = await getWindsurfStatus();
+    
+    console.log(`Status: ${status.connected ? chalk.green('Connected') : chalk.red('Disconnected')}`);
+    console.log(`Workspace: ${status.workspace || 'None'}`);
+    console.log(`Version: ${status.version || 'Unknown'}`);
+    
+  } catch (error) {
+    console.log(chalk.red('Error: ' + error.message));
+  }
+  
+  console.log(chalk.gray('\nPress Enter to continue...'));
+  await inquirer.prompt([{ type: 'input', name: 'c', message: '' }]);
+}
+
+/**
+ * Show debug information
+ */
+async function showDebugInfo() {
+  console.clear();
+  console.log(chalk.bold.cyan('📊 Debug Information\n'));
+  
+  try {
+    // Show performance stats
+    const perfStats = perfMonitor.getStats();
+    console.log(chalk.yellow('Performance Stats:'));
+    console.log(`  Menu renders: ${perfStats.menuRenders}`);
+    console.log(`  Avg render time: ${perfStats.avgRenderTime.toFixed(2)}ms`);
+    console.log(`  Total render time: ${perfStats.totalRenderTime.toFixed(2)}ms`);
+    
+    // Show state tracking
+    const stateHistory = stateTracker.getHistory();
+    console.log(chalk.yellow('\nState History:'));
+    stateHistory.slice(-5).forEach(entry => {
+      console.log(`  ${entry.timestamp}: ${entry.action} - ${entry.details}`);
+    });
+    
+    // Show debug log status
+    console.log(chalk.yellow('\nDebug Logging:'));
+    console.log(`  Enabled: ${debugLogger.enabled ? 'Yes' : 'No'}`);
+    console.log(`  Log file: ${debugLogger.logFile}`);
+    
+  } catch (error) {
+    console.log(chalk.red('Error getting debug info: ' + error.message));
+  }
+  
+  console.log(chalk.gray('\nPress Enter to continue...'));
+  await inquirer.prompt([{ type: 'input', name: 'c', message: '' }]);
+}
+
+/**
+ * Setup extra keyboard handlers for main menu
+ */
+function setupMainMenuExtraKeys(items) {
+  return (str, key, selectedIndex, context) => {
+    const currentItem = items[selectedIndex];
+    
+    // Handle section expansion with space
+    if (key.name === 'space' && currentItem && currentItem.value && currentItem.value.startsWith('section:')) {
+      const sectionName = currentItem.value.substring(8);
+      context.resolveWith(`section:${sectionName}`);
+      return true;
+    }
+    
+    // Handle quick access keys
+    if (str === 'r' || str === 'R') {
+      context.resolveWith('section:requirements');
+      return true;
+    }
+    
+    if (str === 's' || str === 'S') {
+      context.resolveWith('section:settings');
+      return true;
+    }
+    
+    if (str === 'p' || str === 'P') {
+      context.resolveWith('provider-manager');
+      return true;
+    }
+    
+    if (str === 'q' || str === 'Q') {
+      context.resolveWith('exit');
+      return true;
+    }
+    
+    return false;
+  };
+}
+
+module.exports = {
+  handleMainMenuSelection,
+  handleWindsurfSelection,
+  showDebugInfo,
+  setupMainMenuExtraKeys
+};

package/src/utils/trui-main-menu.js

@@ -0,0 +1,235 @@
+/**
+ * TRUI Main Menu Builders
+ *
+ * Extracted from trui-navigation.js to reduce file size
+ */
+
+const chalk = require('chalk');
+const { showProviderManagerMenu } = require('./provider-manager');
+const { getWindsurfStatus } = require('./trui-windsurf');
+
+// Import section modules
+const {
+  loadRequirementsData,
+  buildRequirementChoices,
+} = require('./trui-nav-requirements');
+
+const {
+  loadSettingsData,
+  buildSettingChoices,
+} = require('./trui-nav-settings');
+
+const {
+  loadSpecificationsData,
+  buildSpecificationChoices,
+} = require('./trui-nav-specifications');
+
+const {
+  loadAgentsData,
+  buildAgentChoices,
+} = require('./trui-nav-agents');
+
+/**
+ * Build main-menu items array with live status at top + inline accordion sections
+ */
+async function buildMainMenuItems(expandedSections) {
+  const items = [];
+
+  // Status section at top
+  const statusItems = await buildStatusSection();
+  items.push(...statusItems);
+
+  // Add blank separator
+  items.push({ type: 'blank', name: '', value: 'blank' });
+
+  // Requirements section (always present)
+  const requirementsData = await loadRequirementsData();
+  const requirementsItems = await buildRequirementsSection(requirementsData, expandedSections);
+  items.push(...requirementsItems);
+
+  // Settings section
+  const settingsData = await loadSettingsData();
+  const settingsItems = buildSettingsSection(settingsData);
+  items.push(...settingsItems);
+
+  // Specifications section
+  const specificationsData = await loadSpecificationsData();
+  const specificationsItems = buildSpecificationsSection(specificationsData, expandedSections);
+  items.push(...specificationsItems);
+
+  // Agents section
+  const agentsData = await loadAgentsData();
+  const agentsItems = buildAgentsSection(agentsData, expandedSections);
+  items.push(...agentsItems);
+
+  // Additional sections
+  items.push({ type: 'separator', name: chalk.gray('  ── Tools ──'), value: 'separator-tools' });
+  items.push({ type: 'action', name: '[🔧 Provider Manager]', value: 'provider-manager' });
+  items.push({ type: 'action', name: '[🌊 Windsurf]', value: 'windsurf' });
+  items.push({ type: 'action', name: '[📊 Debug Info]', value: 'debug-info' });
+  items.push({ type: 'action', name: '[❌ Exit]', value: 'exit' });
+
+  return items;
+}
+
+/**
+ * Build status section with live data
+ */
+async function buildStatusSection() {
+  const items = [];
+  
+  // Auto mode status
+  const autoModeStatus = await getAutoModeStatus();
+  items.push({ 
+    type: 'status', 
+    name: chalk.gray(`Auto-mode: ${autoModeStatus}`), 
+    value: 'status:auto-mode' 
+  });
+
+  // Requirements counts
+  const requirementsData = await loadRequirementsData();
+  if (requirementsData) {
+    const { todo = 0, verify = 0, verified = 0 } = requirementsData.sections || {};
+    const total = todo + verify + verified;
+    const progress = total > 0 ? Math.round((verified / total) * 100) : 0;
+    
+    items.push({ 
+      type: 'status', 
+      name: chalk.gray(`Requirements: ${verified}✓ ${verify}⏳ ${todo}📋 (${progress}%)`), 
+      value: 'status:requirements' 
+    });
+  }
+
+  // Current agent/provider
+  const agentStatus = await getCurrentAgentStatus();
+  if (agentStatus) {
+    items.push({ 
+      type: 'status', 
+      name: chalk.gray(`Agent: ${agentStatus}`), 
+      value: 'status:agent' 
+    });
+  }
+
+  return items;
+}
+
+/**
+ * Build requirements section
+ */
+async function buildRequirementsSection(requirementsData, expandedSections) {
+  const items = [];
+  const isExpanded = expandedSections.requirements || false;
+  const icon = isExpanded ? '▼' : '▶';
+  
+  items.push({
+    type: 'section',
+    name: `${icon} 📋 Requirements`,
+    value: 'section:requirements'
+  });
+
+  if (isExpanded && requirementsData) {
+    const reqChoices = await buildRequirementChoices(requirementsData);
+    items.push(...reqChoices);
+  }
+
+  return items;
+}
+
+/**
+ * Build settings section
+ */
+function buildSettingsSection(settingsData) {
+  const items = [];
+  
+  items.push({
+    type: 'section',
+    name: '⚙️  Settings',
+    value: 'section:settings'
+  });
+
+  const settingChoices = buildSettingChoices(settingsData);
+  items.push(...settingChoices);
+
+  return items;
+}
+
+/**
+ * Build specifications section
+ */
+function buildSpecificationsSection(specificationsData, expandedSections) {
+  const items = [];
+  const isExpanded = expandedSections.specifications || false;
+  const icon = isExpanded ? '▼' : '▶';
+  
+  items.push({
+    type: 'section',
+    name: `${icon} 📄 Specifications`,
+    value: 'section:specifications'
+  });
+
+  if (isExpanded && specificationsData) {
+    const specChoices = buildSpecificationChoices(specificationsData);
+    items.push(...specChoices);
+  }
+
+  return items;
+}
+
+/**
+ * Build agents section
+ */
+function buildAgentsSection(agentsData, expandedSections) {
+  const items = [];
+  const isExpanded = expandedSections.agents || false;
+  const icon = isExpanded ? '▼' : '▶';
+  
+  items.push({
+    type: 'section',
+    name: `${icon} 🤖 Agents`,
+    value: 'section:agents'
+  });
+
+  if (isExpanded && agentsData) {
+    const agentChoices = buildAgentChoices(agentsData);
+    items.push(...agentChoices);
+  }
+
+  return items;
+}
+
+/**
+ * Get auto mode status
+ */
+async function getAutoModeStatus() {
+  try {
+    const { checkAutoModeStatus } = require('./auto-mode');
+    const status = await checkAutoModeStatus();
+    return status.active ? `${status.agent} (${status.chats} chats)` : 'Inactive';
+  } catch (error) {
+    return 'Unknown';
+  }
+}
+
+/**
+ * Get current agent status
+ */
+async function getCurrentAgentStatus() {
+  try {
+    const { getCurrentAIProvider } = require('./interactive/core-ui');
+    const provider = getCurrentAIProvider();
+    return provider ? `${provider.name} (${provider.type})` : 'None';
+  } catch (error) {
+    return 'Unknown';
+  }
+}
+
+module.exports = {
+  buildMainMenuItems,
+  buildStatusSection,
+  buildRequirementsSection,
+  buildSettingsSection,
+  buildSpecificationsSection,
+  buildAgentsSection,
+  getAutoModeStatus,
+  getCurrentAgentStatus
+};

package/src/utils/trui-nav-agents.js

@@ -7,6 +7,9 @@
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 
+// Track expanded agent indices
+const expandedAgents = new Set();
+
 /**
  * Load agents data via the RUI command resolver + provider preferences
  * @param {Object} navigation - TRUINavigation instance
@@ -46,19 +49,49 @@ function buildAgentChoices(data) {
     ];
   }
 
-  return data.agents.map((agent, index) => {
+  const choices = [];
+
+  data.agents.forEach((agent, index) => {
     const isEnabled = data.enabledMap[agent.id] !== false;
     const icon = isEnabled ? '🟢' : '🔴';
     const label = agent.name || agent.type || agent.id || 'Unknown';
-    return {
-      name: `  ${icon} ${chalk.white(label)}`,
+    const isExpanded = expandedAgents.has(index);
+    const expandIcon = isExpanded ? '▼' : '▶';
+
+    choices.push({
+      name: `    ${icon} ${expandIcon} ${chalk.white(label)}`,
       value: `agent:${index}`,
-    };
+    });
+
+    // If expanded, add full details inline
+    if (isExpanded) {
+      const details = [];
+      if (agent.description) {
+        details.push(chalk.gray(`      Description: ${agent.description}`));
+      }
+      if (agent.id) {
+        details.push(chalk.gray(`      ID: ${agent.id}`));
+      }
+      if (agent.type) {
+        details.push(chalk.gray(`      Type: ${agent.type}`));
+      }
+      const status = isEnabled ? chalk.green('ENABLED') : chalk.red('DISABLED');
+      details.push(chalk.gray(`      Status: ${status}`));
+
+      if (details.length > 0) {
+        details.forEach(detail => {
+          const Separator = require('inquirer').Separator;
+          choices.push(new Separator(detail));
+        });
+      }
+    }
   });
+
+  return choices;
 }
 
 /**
- * Handle selection of an agent item — shows an enable/disable sub-prompt
+ * Handle selection of an agent item — toggles inline expand/collapse
  * @param {number} index - Index into data.agents
  * @param {{agents: Array, enabledMap: Object, prefs: Object}} data
  * @param {Object} navigation - TRUINavigation instance
@@ -67,31 +100,64 @@ function buildAgentChoices(data) {
 async function handleAgentSelection(index, data, navigation) {
   if (!data || !data.agents || !data.agents[index]) return false;
 
+  const agent = data.agents[index];
+
+  // Check if currently expanded - if so, collapse and return
+  if (expandedAgents.has(index)) {
+    expandedAgents.delete(index);
+    return true; // Refresh to show collapsed state
+  }
+
+  // First press expands inline
+  expandedAgents.add(index);
+  return true; // Refresh to show expanded state
+}
+
+/**
+ * Handle action menu for an agent (enable/disable)
+ * @param {number} index - Index into data.agents
+ * @param {{agents: Array, enabledMap: Object, prefs: Object}} data
+ * @param {Object} navigation - TRUINavigation instance
+ * @param {string} directAction - Optional direct action: 'enable' or 'disable' (bypasses prompt)
+ * @returns {Promise<boolean>} true if prefs were changed
+ */
+async function handleAgentAction(index, data, navigation, directAction = null) {
+  if (!data || !data.agents || !data.agents[index]) return false;
+
   const agent = data.agents[index];
   const isEnabled = data.enabledMap[agent.id] !== false;
   const label = agent.name || agent.type || agent.id || 'Unknown';
   const statusText = isEnabled ? chalk.green('ENABLED') : chalk.red('DISABLED');
 
-  if (agent.description) {
-    console.log(chalk.gray(`\n  ${label}: ${agent.description}`));
+  // If direct action is provided, use it without prompting
+  let shouldToggle = false;
+  if (directAction) {
+    shouldToggle = (directAction === 'enable' && !isEnabled) || (directAction === 'disable' && isEnabled);
+  } else {
+    // Show prompt for interactive use
+    if (agent.description) {
+      console.log(chalk.gray(`\n  ${label}: ${agent.description}`));
+    }
+
+    const { agentAction } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'agentAction',
+        message: `${label} [${statusText}]`,
+        choices: [
+          {
+            name: isEnabled ? chalk.red('Disable') : chalk.green('Enable'),
+            value: 'toggle',
+          },
+          { name: chalk.gray('Cancel'), value: 'cancel' },
+        ],
+      },
+    ]);
+
+    shouldToggle = agentAction === 'toggle';
   }
 
-  const { agentAction } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'agentAction',
-      message: `${label} [${statusText}]`,
-      choices: [
-        {
-          name: isEnabled ? chalk.red('Disable') : chalk.green('Enable'),
-          value: 'toggle',
-        },
-        { name: chalk.gray('Cancel'), value: 'cancel' },
-      ],
-    },
-  ]);
-
-  if (agentAction !== 'toggle') return false;
+  if (!shouldToggle) return false;
 
   try {
     const { getProviderPreferences, saveProviderPreferences } = require('./provider-registry');
@@ -103,17 +169,104 @@ async function handleAgentSelection(index, data, navigation) {
     const verb = !isEnabled ? 'enable' : 'disable';
     console.log(chalk.green(`\n✓ ${label} ${verb}d`));
     console.log(chalk.gray(`  Equivalent: app agents ${label} ${verb}`));
-    await navigation.promptContinue();
+
+    if (!directAction) {
+      await navigation.promptContinue();
+    }
     return true;
   } catch (err) {
     console.log(chalk.red(`Error: ${err.message}`));
-    await navigation.promptContinue();
+    if (!directAction) {
+      await navigation.promptContinue();
+    }
     return false;
   }
 }
 
+/**
+ * Create extraKeys handler for arrow-key navigation between agent items
+ * Enables arrow-up/arrow-down to navigate between selectable agent items in the list
+ * @param {{agents: Array, enabledMap: Object, prefs: Object}} data
+ * @param {Array} choices - The full choice array (may include separators) from buildAgentChoices
+ * @returns {Function} Handler for showQuickMenu's extraKeys option
+ */
+function createAgentNavigationHandler(data, choices) {
+  return (str, key, selectedIndex, context) => {
+    if (!key) return false;
+    if (key.name !== 'up' && key.name !== 'down') return false;
+
+    if (!data || !data.agents || !Array.isArray(data.agents)) return false;
+    if (!choices || !Array.isArray(choices)) return false;
+
+    // Get the current item's value to extract agent index if it's an agent item
+    const currentChoice = choices[selectedIndex];
+    const currentValue = currentChoice?.value;
+
+    // Only navigate if currently on an agent item (value format: "agent:N")
+    if (!currentValue || !currentValue.startsWith('agent:')) {
+      return false;
+    }
+
+    // Find the next selectable agent index (skipping separators)
+    let nextIndex = selectedIndex;
+    if (key.name === 'up') {
+      nextIndex = selectedIndex - 1;
+      while (nextIndex >= 0 && !isAgentItemSelectable(choices, nextIndex)) {
+        nextIndex--;
+      }
+      if (nextIndex < 0) {
+        // Wrap to bottom - find last selectable agent item
+        nextIndex = choices.length - 1;
+        while (nextIndex >= 0 && !isAgentItemSelectable(choices, nextIndex)) {
+          nextIndex--;
+        }
+      }
+    } else if (key.name === 'down') {
+      nextIndex = selectedIndex + 1;
+      while (nextIndex < choices.length && !isAgentItemSelectable(choices, nextIndex)) {
+        nextIndex++;
+      }
+      if (nextIndex >= choices.length) {
+        // Wrap to top - find first selectable agent item
+        nextIndex = 0;
+        while (nextIndex < choices.length && !isAgentItemSelectable(choices, nextIndex)) {
+          nextIndex++;
+        }
+      }
+    }
+
+    if (nextIndex >= 0 && nextIndex < choices.length && isAgentItemSelectable(choices, nextIndex)) {
+      context.setSelectedIndex(nextIndex);
+      context.display();
+      return true;
+    }
+
+    return false;
+  };
+}
+
+/**
+ * Check if a choice item is selectable (an agent item, not a separator or placeholder)
+ * @param {Array} choices - The full choice array from buildAgentChoices
+ * @param {number} itemIndex - Index in the choices array
+ * @returns {boolean}
+ */
+function isAgentItemSelectable(choices, itemIndex) {
+  if (!choices || !Array.isArray(choices)) return false;
+  if (itemIndex < 0 || itemIndex >= choices.length) return false;
+
+  const choice = choices[itemIndex];
+  // Agent items have a value property that starts with "agent:"
+  // Separators are instances of inquirer.Separator
+  return choice && typeof choice.value === 'string' && choice.value.startsWith('agent:');
+}
+
 module.exports = {
   loadAgentsData,
   buildAgentChoices,
   handleAgentSelection,
+  handleAgentAction,
+  createAgentNavigationHandler,
+  isAgentItemSelectable,
+  expandedAgents,
 };