vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

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

@@ -0,0 +1,376 @@
+/**
+ * TRUI Provider Manager
+ *
+ * Advanced provider management with health metrics, quota checking, IDE detection
+ * Enable/disable providers and re-order them.
+ */
+
+const chalk = require('chalk');
+const { showQuickMenu } = require('./trui-quick-menu');
+const { debugLogger } = require('./trui-debug');
+const { getProviderHealth, formatHealthDisplay } = require('./trui-provider-health');
+const { getKiroIntegrationStatus } = require('./trui-kiro-integration');
+
+/**
+ * Get provider status icon
+ */
+function getStatusIcon(enabled) {
+  return enabled ? '🟢' : '🔴';
+}
+
+/**
+ * Load providers data via RUI resolver with health checks
+ */
+async function loadProvidersData(navigation) {
+  try {
+    const result = navigation.resolver.resolve('list providers');
+    if (!result.success) return null;
+
+    const commandResult = await result.command.execute();
+    if (!commandResult.success || !commandResult.data) return null;
+
+    const providers = commandResult.data;
+    
+    // Enhance providers with health information
+    for (const provider of providers) {
+      try {
+        provider.health = await getProviderHealth(provider);
+      } catch (error) {
+        debugLogger.error('Error getting provider health', { 
+          provider: provider.id, 
+          error: error.message 
+        });
+        provider.health = { status: 'error', errors: [error.message] };
+      }
+    }
+
+    return providers;
+  } catch (err) {
+    debugLogger.error('Error loading providers data', { error: err.message });
+    return null;
+  }
+}
+
+/**
+ * Build provider choice items with enhanced health and quota info
+ */
+function buildProviderChoices(providers, preferences = {}) {
+  if (!providers || !providers.length) {
+    return [{ name: chalk.gray('  (no providers found)'), value: 'noop' }];
+  }
+
+  return providers.map((provider, index) => {
+    const isEnabled = preferences.enabled && preferences.enabled[provider.id] !== false;
+    const status = isEnabled ? chalk.green('ENABLED') : chalk.red('DISABLED');
+    const icon = getStatusIcon(isEnabled);
+    
+    // Enhanced health information
+    let healthInfo = '';
+    if (provider.health) {
+      const healthIcon = provider.health.status === 'healthy' ? '🟢' :
+                        provider.health.status === 'degraded' ? '🟡' :
+                        provider.health.status === 'unhealthy' ? '🔴' :
+                        provider.health.status === 'error' ? '❌' : '⚪';
+      healthInfo = ` ${healthIcon}`;
+      
+      if (provider.health.responseTime) {
+        const timeColor = provider.health.responseTime < 1000 ? chalk.green :
+                         provider.health.responseTime < 3000 ? chalk.yellow : chalk.red;
+        healthInfo += ` ${timeColor(provider.health.responseTime + 'ms')}`;
+      }
+    }
+
+    // Enhanced quota information
+    let quotaInfo = '';
+    if (provider.health && provider.health.quota) {
+      const quota = provider.health.quota;
+      const percentage = Math.round((quota.used / quota.limit) * 100);
+      const color = percentage >= 90 ? chalk.red : percentage >= 75 ? chalk.yellow : chalk.green;
+      quotaInfo = ` ${color(quota.used + '/' + quota.limit)}`;
+    }
+
+    // Enhanced IDE detection
+    let ideInfo = '';
+    if (provider.health && provider.health.ideDetection) {
+      const ideCount = Object.values(provider.health.ideDetection)
+        .filter(ide => ide.installed).length;
+      if (ideCount > 0) {
+        ideInfo = ` 💻${ideCount}`;
+      }
+    }
+
+    const displayName = provider.name || provider.type || provider.id || 'Unknown';
+    const details = [status, healthInfo, quotaInfo, ideInfo].filter(Boolean).join(' ');
+    
+    return {
+      type: 'provider',
+      name: `${icon} ${displayName}${details ? ' - ' + details : ''}`,
+      value: `provider:${index}`
+    };
+  });
+}
+
+/**
+ * Show provider manager with full functionality
+ */
+async function showProviderManager(navigation) {
+  debugLogger.info('showProviderManager called');
+
+  const data = await loadProvidersData(navigation);
+  if (!data || !data.providers) {
+    console.log(chalk.yellow('No providers data available'));
+    return;
+  }
+
+  const { providers, preferences } = data;
+
+  while (true) {
+    // Build menu items
+    const items = buildProviderChoices(providers, preferences);
+    
+    // Add actions
+    items.push({ type: 'blank', name: '', value: 'blank' });
+    items.push({ type: 'action', name: '[Test All Providers]', value: 'test-all' });
+    items.push({ type: 'action', name: '[Refresh Health Status]', value: 'refresh-health' });
+    items.push({ type: 'action', name: '[Kiro Integration]', value: 'kiro-status' });
+    items.push({ type: 'action', name: 'Exit', value: 'exit' });
+
+    // Show menu with extra keys for provider actions
+    const result = await showQuickMenu(items, 0, {
+      extraKeys: (str, key, selectedIndex, context) => {
+        const currentItem = items[selectedIndex];
+        
+        // Handle enable/disable with e/d keys
+        if ((str === 'e' || str === 'E') && currentItem && currentItem.value && currentItem.value.startsWith('provider:')) {
+          const providerIndex = parseInt(currentItem.value.substring(9), 10);
+          context.resolveWith(`provider-enable:${providerIndex}`);
+          return true;
+        }
+
+        if ((str === 'd' || str === 'D') && currentItem && currentItem.value && currentItem.value.startsWith('provider:')) {
+          const providerIndex = parseInt(currentItem.value.substring(9), 10);
+          context.resolveWith(`provider-disable:${providerIndex}`);
+          return true;
+        }
+
+        // Handle re-ordering with arrow keys when on provider
+        if ((key.name === 'up' || key.name === 'down') && currentItem && currentItem.value && currentItem.value.startsWith('provider:')) {
+          const providerIndex = parseInt(currentItem.value.substring(9), 10);
+          
+          if (key.name === 'up' && providerIndex > 0) {
+            context.resolveWith(`provider-move-up:${providerIndex}`);
+            return true;
+          }
+          
+          if (key.name === 'down' && providerIndex < providers.length - 1) {
+            context.resolveWith(`provider-move-down:${providerIndex}`);
+            return true;
+          }
+        }
+
+        return false;
+      },
+      hintText: 'e/d=enable/disable  ↑↓=re-order  Enter=details  ←=back'
+    });
+
+    // Handle actions
+    if (result.value === 'test-all') {
+      await testAllProviders(providers);
+      continue;
+    }
+
+    if (result.value === 'refresh-health') {
+      await refreshProviderHealth(providers, navigation);
+      continue;
+    }
+
+    if (result.value === 'kiro-status') {
+      await showKiroIntegrationStatus();
+      continue;
+    }
+
+    if (result.value.startsWith('provider-enable:')) {
+      const providerIndex = parseInt(result.value.substring(16), 10);
+      await toggleProvider(providers[providerIndex], true, navigation);
+      continue;
+    }
+
+    if (result.value.startsWith('provider-disable:')) {
+      const providerIndex = parseInt(result.value.substring(17), 10);
+      await toggleProvider(providers[providerIndex], false, navigation);
+      continue;
+    }
+
+    if (result.value.startsWith('provider-move-up:')) {
+      const providerIndex = parseInt(result.value.substring(18), 10);
+      await moveProvider(providers, providerIndex, 'up', navigation);
+      continue;
+    }
+
+    if (result.value.startsWith('provider-move-down:')) {
+      const providerIndex = parseInt(result.value.substring(20), 10);
+      await moveProvider(providers, providerIndex, 'down', navigation);
+      continue;
+    }
+
+    if (result.value === '__cancel__') {
+      break;
+    }
+  }
+}
+
+/**
+ * Toggle provider enabled/disabled status
+ */
+async function toggleProvider(provider, enabled, navigation) {
+  try {
+    const result = navigation.resolver.resolve('update provider', {
+      providerId: provider.id,
+      enabled
+    });
+    
+    if (result.success) {
+      await result.command.execute();
+      console.log(chalk.green(`\n✓ ${provider.name || provider.id} ${enabled ? 'enabled' : 'disabled'}`));
+    }
+  } catch (err) {
+    console.log(chalk.red(`Error toggling provider: ${err.message}`));
+  }
+}
+
+/**
+ * Move provider up/down in order
+ */
+async function moveProvider(providers, index, direction, navigation) {
+  if (direction === 'up' && index > 0) {
+    // Swap with previous
+    const temp = providers[index - 1];
+    providers[index - 1] = providers[index];
+    providers[index] = temp;
+  } else if (direction === 'down' && index < providers.length - 1) {
+    // Swap with next
+    const temp = providers[index + 1];
+    providers[index + 1] = providers[index];
+    providers[index] = temp;
+  }
+
+  try {
+    // Save new order
+    const newOrder = providers.map(p => p.id);
+    const result = navigation.resolver.resolve('update provider-order', { order: newOrder });
+    
+    if (result.success) {
+      await result.command.execute();
+      console.log(chalk.green('\n✓ Provider order updated'));
+    }
+  } catch (err) {
+    console.log(chalk.red(`Error updating provider order: ${err.message}`));
+  }
+}
+
+/**
+ * Test connectivity of all providers
+ */
+async function testAllProviders(providers) {
+  console.log(chalk.cyan('\n🔍 Testing all providers...\n'));
+  
+  for (const provider of providers) {
+    console.log(chalk.gray(`Testing ${provider.name || provider.id}...`));
+    
+    try {
+      const result = await fetch(`https://api.openai.com/v1/models`, {
+        timeout: 5000,
+        headers: provider.apiKey ? { 'Authorization': `Bearer ${provider.apiKey}` } : {}
+      });
+      
+      if (result.ok) {
+        console.log(chalk.green(`  ✓ ${provider.name || provider.id} - Connected`));
+      } else {
+        console.log(chalk.red(`  ✗ ${provider.name || provider.id} - Failed (${result.status})`));
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ✗ ${provider.name || provider.id} - Error (${err.message})`));
+    }
+  }
+  
+  console.log(chalk.gray('\nPress Enter to continue...'));
+  await new Promise(resolve => {
+    process.stdin.once('data', resolve);
+  });
+}
+
+/**
+ * Refresh provider health status
+ */
+async function refreshProviderHealth(providers, navigation) {
+  console.log(chalk.cyan('\n🔄 Refreshing provider health...\n'));
+  
+  for (const provider of providers) {
+    try {
+      // Test basic connectivity
+      const result = await fetch(`https://api.openai.com/v1/models`, {
+        timeout: 3000,
+        headers: provider.apiKey ? { 'Authorization': `Bearer ${provider.apiKey}` } : {}
+      });
+      
+      if (result.ok) {
+        console.log(chalk.green(`  ✓ ${provider.name || provider.id} - Healthy`));
+      } else {
+        console.log(chalk.yellow(`  ⚠ ${provider.name || provider.id} - Limited (${result.status})`));
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ✗ ${provider.name || provider.id} - Unreachable`));
+    }
+  }
+  
+  console.log(chalk.gray('\nPress Enter to continue...'));
+  await new Promise(resolve => {
+    process.stdin.once('data', resolve);
+  });
+}
+
+/**
+ * Show Kiro integration status
+ */
+async function showKiroIntegrationStatus() {
+  console.clear();
+  console.log(chalk.bold.cyan('🔗 Kiro Integration Status\n'));
+  
+  try {
+    const kiroStatus = await getKiroIntegrationStatus();
+    
+    console.log(`Status: ${kiroStatus.installed ? chalk.green('Installed') : chalk.red('Not Installed')}`);
+    
+    if (kiroStatus.version) {
+      console.log(`Version: ${chalk.white(kiroStatus.version)}`);
+    }
+    
+    console.log(`Configured: ${kiroStatus.configured ? chalk.green('Yes') : chalk.yellow('No')}`);
+    
+    if (kiroStatus.config) {
+      console.log(`Project: ${chalk.white(kiroStatus.config.project)}`);
+      console.log(`Provider: ${chalk.white(kiroStatus.config.provider)}`);
+      console.log(`Auto-mode: ${kiroStatus.config.autoMode ? chalk.green('Enabled') : chalk.red('Disabled')}`);
+    }
+    
+    if (!kiroStatus.installed) {
+      console.log(chalk.yellow('\n💡 Kiro integration enhances provider management with advanced features.'));
+      console.log(chalk.gray('Visit https://github.com/kiro-dev/kiro to install.'));
+    }
+    
+  } catch (error) {
+    console.log(chalk.red('Error checking Kiro status: ' + error.message));
+  }
+  
+  console.log(chalk.gray('\nPress Enter to continue...'));
+  await new Promise(resolve => {
+    process.stdin.once('data', resolve);
+  });
+}
+
+module.exports = {
+  showProviderManager,
+  loadProvidersData,
+  buildProviderChoices,
+  showKiroIntegrationStatus
+};

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

@@ -55,7 +55,7 @@ function getVisualLineCount(text) {
  * Determine whether an item can receive keyboard focus
  */
 function isSelectable(item) {
-  return item.type !== 'blank' && item.type !== 'info';
+  return item.type !== 'blank' && item.type !== 'info' && item.type !== 'separator';
 }
 
 /**
@@ -88,6 +88,27 @@ function renderMenu(items, selectedIndex, hintText) {
       return;
     }
 
+    // 'separator' type: gray text header, not selectable
+    if (item.type === 'separator') {
+      output = chalk.gray(`  ${item.name}`);
+      process.stdout.write(output + '\n');
+      linesPrinted += getVisualLineCount(`  ${item.name}`);
+      return;
+    }
+
+    // 'sub-item' type: selectable sub-items with arrow navigation, no letter shortcuts
+    if (item.type === 'sub-item') {
+      const raw = `${isSelected ? '❯ ' : '  '}${item.name}`;
+      if (isSelected) {
+        output = chalk.cyan(`❯ ${item.name}`);
+      } else {
+        output = `  ${item.name}`;
+      }
+      process.stdout.write(output + '\n');
+      linesPrinted += getVisualLineCount(raw);
+      return;
+    }
+
     // 'header' type: no letter, but IS selectable (focusable with ↑↓, Enter returns value)
     if (item.type === 'header') {
       const raw = `${isSelected ? '❯ ' : '  '}${item.name}`;
@@ -194,6 +215,9 @@ function showQuickMenu(items, initialSelectedIndex = 0, options = {}) {
           // Move cursor back up to start of menu and clear downward
           readline.moveCursor(process.stdout, 0, -lastLinesPrinted);
           readline.clearScreenDown(process.stdout);
+        } else {
+          // On first render, clear from current position down to ensure clean start
+          readline.clearScreenDown(process.stdout);
         }
         lastLinesPrinted = renderMenu(items, selectedIndex, hintText);
         isFirstRender = false;