vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/utils/trui-navigation.js

@@ -1,257 +1,91 @@
 /**
- * TRUI Navigation — Main Menu
+ * TRUI Navigation — Main Menu (Refactored)
  *
  * Renders the status-rich main menu using showQuickMenu (raw keypress).
  * Status/settings lines shown in gray at top; action items in white below.
- * Dispatches to: Requirements tree, Provider manager, Settings, Spec creation.
+ * Uses inline accordion expansion for sections.
  * Now using RUI pattern for consistent command structure.
+ * Refactored to meet 555-line limit by extracting modules.
  */
 
 const chalk = require('chalk');
 const { showQuickMenu } = require('./trui-quick-menu');
-const { initializeWindsurfIntegration, getWindsurfStatus } = require('./trui-windsurf');
-const { debugLogger } = require('./trui-debug');
+const { debugLogger, perfMonitor, stateTracker } = require('./trui-debug');
 const RUITRUIAdapter = require('./rui-trui-adapter');
 
-/**
- * Build main-menu items array with live status at top
- */
-async function buildMainMenuItems() {
-  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
-  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 (_) {}
-
-  items.push({ type: 'blank', name: '', value: 'blank' });
+// Import extracted modules
+const { 
+  buildMainMenuItems 
+} = require('./trui-main-menu');
 
-  // Action items
-  items.push({ type: 'action', name: '📋 Requirements', value: 'requirements' });
-  items.push({ type: 'action', name: '🤖 Agents / Providers', value: 'agents' });
-  items.push({ type: 'action', name: '⚙️  Settings', value: 'settings' });
-  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;
-}
+const { 
+  handleMainMenuSelection,
+  setupMainMenuExtraKeys
+} = require('./trui-main-handlers');
 
 /**
- * TRUINavigation — main menu loop
+ * TRUI Navigation System
  */
 class TRUINavigation {
   constructor() {
-    this._lastIndex = 0;
-    this.ruiAdapter = new RUITRUIAdapter();
+    this.resolver = new RUITRUIAdapter();
+    this.expandedSections = {};
+    debugLogger.info('TRUINavigation initialized');
   }
 
+  /**
+   * Start the TRUI navigation system
+   */
   async start() {
-    const { showWelcomeScreen } = require('./welcome-screen-extracted');
-
-    console.clear();
-    try { await showWelcomeScreen(); } catch (_) {}
-
-    // Initialize Windsurf integration with error handling
+    perfMonitor.start('TRUINavigation.start');
+    stateTracker.push('TRUINavigation.start');
+    
+    debugLogger.info('Starting TRUI navigation');
+    
     try {
-      initializeWindsurfIntegration();
+      await this._showMainMenu();
     } catch (error) {
-      console.log(chalk.yellow('⚠ Windsurf integration disabled: ' + error.message));
+      debugLogger.error('TRUI navigation error', { error: error.message });
+      console.log(chalk.red('Navigation error: ' + error.message));
+      await this._pause();
+    } finally {
+      perfMonitor.end('TRUINavigation.start');
+      stateTracker.pop();
     }
-
-    await this._loop();
   }
 
-  async _loop() {
-    const {
-      showRequirementsTree,
-    } = require('./trui-req-tree');
-    const { showProviderManagerMenu } = require('./provider-manager');
-    const { showSettings } = require('./trui-nav-settings');
-    const { addRequirementFlow } = require('./trui-req-actions');
-    const { addSpecificationFlow } = require('./trui-nav-specifications');
-    const { sendContinueToWindsurf } = require('./trui-windsurf');
-    const { showFeedbackSubmission } = require('./trui-feedback');
-    const { showSpecificationsList } = require('./trui-specifications');
+  /**
+   * Show main menu loop
+   */
+  async _showMainMenu() {
+    perfMonitor.start('TRUINavigation.loop');
+    stateTracker.push('TRUINavigation.loop');
 
     while (true) {
       try {
-        const items = await buildMainMenuItems();
-
-        // Extra keys handler for ! and 1 commands
-        const extraKeys = (str, key, selectedIndex, context) => {
-          if (str === '!' || str === '1') {
-            // Run agents check command
-            context.resolveWith('agents-check');
-            return true;
-          }
-          return false;
-        };
-
-        const result = await showQuickMenu(items, this._lastIndex, extraKeys);
-        this._lastIndex = result.selectedIndex;
-        const action = result.value;
-
-        if (action === '__cancel__' || action === 'exit') {
+        // Build menu items
+        const items = await buildMainMenuItems(this.expandedSections);
+        
+        // Setup extra keyboard handlers
+        const extraKeys = setupMainMenuExtraKeys(items);
+
+        // Show menu
+        const result = await showQuickMenu(items, 0, { extraKeys });
+        
+        // Handle selection
+        const handlerResult = await handleMainMenuSelection(
+          result, 
+          this.expandedSections, 
+          this
+        );
+
+        if (handlerResult.shouldExit) {
           await this._confirmExit();
-          continue;
+          break;
         }
 
-        // 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 === 'requirements' || action === 'setting:requirements') {
-            try { await showRequirementsTree(); } catch (err) { console.log(chalk.red('Requirements error: ' + err.message)); await this._pause(); }
-            console.clear();
-            continue;
-          }
-
-          if (action === 'agents') {
-            try { await showProviderManagerMenu(); } catch (err) { console.log(chalk.red('Agents error: ' + err.message)); await this._pause(); }
-            console.clear();
-            continue;
-          }
-
-          if (action === 'agents-check') {
-            try {
-              const agentsCheckModule = require('../commands/agents-check');
-              console.clear();
-              console.log(chalk.bold.cyan('🔍 Checking agents...\n'));
-              await agentsCheckModule();
-              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') {
-            try { await addRequirementFlow(); } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); }
-            console.clear();
-            continue;
-          }
-
-          if (action === 'add-spec') {
-            try { await addSpecificationFlow(); } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); }
-            console.clear();
-            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 — 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;
+        if (!handlerResult.shouldContinue) {
+          break;
         }
 
       } catch (error) {
@@ -261,8 +95,14 @@ class TRUINavigation {
         continue;
       }
     }
+    
+    perfMonitor.end('TRUINavigation.loop');
+    stateTracker.pop();
   }
 
+  /**
+   * Confirm exit with keyboard handling
+   */
   async _confirmExit() {
     console.clear();
     console.log(chalk.yellow('\nExit Vibe Coding Machine? (Y/n/x)\n'));
@@ -314,18 +154,20 @@ class TRUINavigation {
     });
   }
 
+  /**
+   * Pause for user input
+   */
   async _pause() {
     const inquirer = require('inquirer');
     await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
   }
 
+  /**
+   * Prompt user 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();
+module.exports = { TRUINavigation };

package/src/utils/trui-provider-health.js

@@ -0,0 +1,274 @@
+/**
+ * TRUI Provider Health Module
+ *
+ * Monitors provider health metrics, quota information, and IDE detection.
+ */
+
+const chalk = require('chalk');
+const { debugLogger } = require('./trui-debug');
+
+/**
+ * Get provider health metrics
+ */
+async function getProviderHealth(provider) {
+  debugLogger.info('Getting provider health', { provider });
+
+  try {
+    const health = {
+      provider: provider.name || provider.id,
+      status: 'unknown',
+      lastCheck: new Date().toISOString(),
+      responseTime: null,
+      quota: null,
+      ideDetection: null,
+      errors: []
+    };
+
+    // Check basic connectivity
+    const startTime = Date.now();
+    try {
+      // Simulate health check - replace with actual provider ping
+      await checkProviderConnectivity(provider);
+      health.status = 'healthy';
+      health.responseTime = Date.now() - startTime;
+    } catch (error) {
+      health.status = 'unhealthy';
+      health.errors.push(error.message);
+      health.responseTime = Date.now() - startTime;
+    }
+
+    // Get quota information if available
+    health.quota = await getProviderQuota(provider);
+
+    // Check IDE integration
+    health.ideDetection = await checkIDEIntegration(provider);
+
+    debugLogger.info('Provider health retrieved', { 
+      provider: health.provider, 
+      status: health.status 
+    });
+
+    return health;
+  } catch (error) {
+    debugLogger.error('Error getting provider health', { error: error.message });
+    return {
+      provider: provider.name || provider.id,
+      status: 'error',
+      lastCheck: new Date().toISOString(),
+      errors: [error.message]
+    };
+  }
+}
+
+/**
+ * Check provider connectivity
+ */
+async function checkProviderConnectivity(provider) {
+  // Simulate connectivity check
+  // In real implementation, this would ping the provider API
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      if (Math.random() > 0.1) { // 90% success rate
+        resolve();
+      } else {
+        reject(new Error('Connection timeout'));
+      }
+    }, Math.random() * 1000 + 500); // 500-1500ms delay
+  });
+}
+
+/**
+ * Get provider quota information
+ */
+async function getProviderQuota(provider) {
+  // Simulate quota check
+  // In real implementation, this would query provider API
+  const quotas = {
+    'claude': { used: 45, limit: 100, resetTime: '2024-01-01T00:00:00Z' },
+    'gpt': { used: 120, limit: 500, resetTime: '2024-01-01T00:00:00Z' },
+    'cline': { used: 23, limit: 50, resetTime: '2024-01-01T00:00:00Z' }
+  };
+
+  return quotas[provider.id] || { used: 0, limit: 0, resetTime: null };
+}
+
+/**
+ * Check IDE integration for provider
+ */
+async function checkIDEIntegration(provider) {
+  const detections = {
+    'vscode': await checkVSCodeExtension(provider),
+    'cursor': await checkCursorIntegration(provider),
+    'windsurf': await checkWindsurfIntegration(provider)
+  };
+
+  return detections;
+}
+
+/**
+ * Check VS Code extension for provider
+ */
+async function checkVSCodeExtension(provider) {
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    const vscodeDir = path.join(os.homedir(), '.vscode', 'extensions');
+    if (!fs.existsSync(vscodeDir)) {
+      return { installed: false, reason: 'VS Code not found' };
+    }
+
+    const extensions = fs.readdirSync(vscodeDir);
+    const providerExtensions = {
+      'claude': ['ms-vscode.cpptools', 'ms-vscode.python'],
+      'gpt': ['github.copilot'],
+      'cline': ['saoudrizwan.claude-dev']
+    };
+
+    const relevantExtensions = extensions.filter(ext => 
+      (providerExtensions[provider.id] || []).some(prefix => ext.startsWith(prefix))
+    );
+
+    return {
+      installed: relevantExtensions.length > 0,
+      extensions: relevantExtensions,
+      count: relevantExtensions.length
+    };
+  } catch (error) {
+    return { installed: false, reason: error.message };
+  }
+}
+
+/**
+ * Check Cursor integration for provider
+ */
+async function checkCursorIntegration(provider) {
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    const cursorDir = path.join(os.homedir(), '.cursor');
+    const hasCursor = fs.existsSync(cursorDir);
+    
+    return {
+      installed: hasCursor,
+      path: hasCursor ? cursorDir : null
+    };
+  } catch (error) {
+    return { installed: false, reason: error.message };
+  }
+}
+
+/**
+ * Check Windsurf integration for provider
+ */
+async function checkWindsurfIntegration(provider) {
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    const windsurfDir = path.join(os.homedir(), '.windsurf');
+    const hasWindsurf = fs.existsSync(windsurfDir);
+    
+    return {
+      installed: hasWindsurf,
+      path: hasWindsurf ? windsurfDir : null
+    };
+  } catch (error) {
+    return { installed: false, reason: error.message };
+  }
+}
+
+/**
+ * Get health status icon
+ */
+function getHealthIcon(status) {
+  switch (status) {
+    case 'healthy': return '🟢';
+    case 'unhealthy': return '🔴';
+    case 'degraded': return '🟡';
+    case 'unknown': return '⚪';
+    case 'error': return '❌';
+    default: return '❓';
+  }
+}
+
+/**
+ * Get quota percentage
+ */
+function getQuotaPercentage(quota) {
+  if (!quota || quota.limit === 0) return 0;
+  return Math.round((quota.used / quota.limit) * 100);
+}
+
+/**
+ * Get quota color based on usage
+ */
+function getQuotaColor(percentage) {
+  if (percentage >= 90) return chalk.red;
+  if (percentage >= 75) return chalk.yellow;
+  return chalk.green;
+}
+
+/**
+ * Format health display for provider
+ */
+function formatHealthDisplay(health) {
+  const lines = [];
+  
+  // Status
+  lines.push(`${getHealthIcon(health.status)} ${health.provider} - ${health.status}`);
+  
+  // Response time
+  if (health.responseTime !== null) {
+    const timeColor = health.responseTime < 1000 ? chalk.green : 
+                     health.responseTime < 3000 ? chalk.yellow : chalk.red;
+    lines.push(`  Response Time: ${timeColor(health.responseTime + 'ms')}`);
+  }
+  
+  // Quota information
+  if (health.quota && health.quota.limit > 0) {
+    const percentage = getQuotaPercentage(health.quota);
+    const color = getQuotaColor(percentage);
+    lines.push(`  Quota: ${color(health.quota.used + '/' + health.quota.limit + ' (' + percentage + '%)')}`);
+  }
+  
+  // IDE detection
+  if (health.ideDetection) {
+    const ideCount = Object.values(health.ideDetection).filter(ide => ide.installed).length;
+    lines.push(`  IDE Integration: ${ideCount} IDE(s) detected`);
+    
+    Object.entries(health.ideDetection).forEach(([ide, detection]) => {
+      if (detection.installed) {
+        lines.push(`    ${ide}: ✅`);
+      }
+    });
+  }
+  
+  // Errors
+  if (health.errors && health.errors.length > 0) {
+    lines.push(`  Errors: ${chalk.red(health.errors.length)} error(s)`);
+    health.errors.forEach(error => {
+      lines.push(`    ${chalk.red('•')} ${error}`);
+    });
+  }
+  
+  return lines;
+}
+
+module.exports = {
+  getProviderHealth,
+  checkProviderConnectivity,
+  getProviderQuota,
+  checkIDEIntegration,
+  checkVSCodeExtension,
+  checkCursorIntegration,
+  checkWindsurfIntegration,
+  getHealthIcon,
+  getQuotaPercentage,
+  getQuotaColor,
+  formatHealthDisplay
+};