vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/commands/agents/list.js

@@ -5,12 +5,14 @@
  * Follows constitutional requirements: <555 lines, test-first approach.
  */
 
-const AgentConfigManager = require('../../../../../packages/core/src/agents/config/AgentConfigManager');
-const AgentLogger = require('../../../../../packages/core/src/agents/logging/AgentLogger');
-const FileManager = require('../../../../../packages/core/src/agents/storage/FileManager');
-const { AgentStatus } = require('../../../../../packages/core/src/agents/AgentStatus');
-const AgentCommands = require('../../../../../packages/core/src/rui/commands/AgentCommands');
-const AgentResponseFormatter = require('../../../../../packages/core/src/rui/commands/AgentResponseFormatter');
+const { 
+  getProviderDefinitions, 
+  getProviderDisplayName,
+  getDefaultProviderOrder,
+  mergeProviderPreferences 
+} = require('../../utils/provider-registry');
+const { getAutoConfig } = require('../../../utils/config');
+const { checkAllProviders } = require('../../utils/provider-checker');
 
 /**
  * CLI list agents command implementation
@@ -21,28 +23,12 @@ class ListAgentsCommand {
    * @param {Object} options - Command options
    */
   constructor(options = {}) {
-    this.configManager = options.configManager || new AgentConfigManager();
-    this.logger = options.logger || new AgentLogger({
-      fileManager: new FileManager()
-    });
-    this.fileManager = options.fileManager || new FileManager();
-
-    // Initialize RUI components
-    this.agentCommands = new AgentCommands({
-      configManager: this.configManager,
-      logger: this.logger,
-      fileManager: this.fileManager
-    });
-
-    this.responseFormatter = new AgentResponseFormatter({
-      defaultFormat: 'table',
-      includeTimestamp: true,
-      prettyPrint: options.pretty !== false
-    });
+    this.config = getAutoConfig();
+    this.providerPreferences = this.config.providerPreferences || {};
   }
 
   /**
-   * Execute list agents command using RUI pattern
+   * Execute list agents command using provider registry (matches GUI)
    * @param {Object} args - Command arguments
    * @param {Object} options - Command options
    * @returns {Promise<Object>} - Command result
@@ -57,25 +43,45 @@ class ListAgentsCommand {
     } = this.parseArguments(args, options);
 
     try {
-      // Load configuration
-      await this.configManager.load();
-      
-      // Execute using RUI pattern
-      const ruiResult = await this.agentCommands.executeCommand('LIST', 'agents', {
-        includeDisabled,
-        includeStatus
-      });
+      // Get provider definitions (same source as GUI)
+      const definitions = getProviderDefinitions();
+      const prefs = this.providerPreferences;
+      let order = Array.isArray(prefs.order) ? prefs.order.slice() : getDefaultProviderOrder();
+      let enabled = { ...prefs.enabled };
+
+      // Filter agents based on preferences
+      let agents = definitions.map(def => ({
+        id: def.id,
+        name: getProviderDisplayName(def.id),
+        description: def.description || '',
+        type: def.type || 'unknown',
+        enabled: enabled[def.id] !== false,
+        category: def.category || 'unknown',
+        estimatedSpeed: def.estimatedSpeed || 0
+      }));
+
+      // Apply disabled filter
+      if (!includeDisabled) {
+        agents = agents.filter(agent => agent.enabled);
+      }
 
-      // Format response for CLI
-      const formattedResponse = this.responseFormatter.format(ruiResult, 'cli', {
-        format,
-        sortBy,
-        filterStatus
-      });
+      // Add status information if requested
+      if (includeStatus) {
+        const { getProviderCache } = require('../../utils/provider-registry');
+        const savedCache = await getProviderCache();
+        
+        agents = agents.map(agent => ({
+          ...agent,
+          installed: savedCache[agent.id]?.installed || false,
+          status: savedCache[agent.id]?.installed ? 
+            (agent.enabled ? 'ENABLED' : 'DISABLED') : 
+            'NOT_INSTALLED',
+          statusDescription: savedCache[agent.id]?.installed ? 
+            (agent.enabled ? 'Enabled' : 'Disabled') : 
+            'Not installed'
+        }));
+      }
 
-      // Apply additional filtering and sorting
-      let agents = formattedResponse.data?.agents || [];
-      
       // Apply status filter
       if (filterStatus) {
         agents = agents.filter(agent => agent.status === filterStatus);
@@ -88,9 +94,8 @@ class ListAgentsCommand {
       this.outputResults(agents, format, includeStatus);
 
       return {
-        success: ruiResult.success,
+        success: true,
         agents,
-        formatted: formattedResponse,
         count: agents.length,
         message: `Listed ${agents.length} agents`
       };
@@ -179,24 +184,20 @@ class ListAgentsCommand {
   }
 
   /**
-   * Filter agents by status
-   * @param {Array<Object>} agents - Agents to filter
-   * @param {string} status - Status to filter by
-   * @returns {Promise<Array>} - Filtered agents
+   * Get status description
+   * @param {string} status - Status code
+   * @returns {string} - Human-readable description
    */
-  async filterAgentsByStatus(agents, status) {
-    const filteredAgents = [];
-    
-    for (const agent of agents) {
-      const agentStatus = await this.configManager.getAgentStatus(agent.id);
-      const currentStatus = agentStatus ? agentStatus.status : AgentStatus.NOT_INSTALLED;
-      
-      if (currentStatus === status) {
-        filteredAgents.push(agent);
-      }
-    }
-    
-    return filteredAgents;
+  getStatusDescription(status) {
+    const descriptions = {
+      'NOT_INSTALLED': 'Not installed',
+      'ENABLED': 'Enabled',
+      'DISABLED': 'Disabled',
+      'ERROR': 'Error occurred',
+      'RATE_LIMITED': 'Rate limited'
+    };
+
+    return descriptions[status] || 'Unknown';
   }
 
   /**
@@ -222,52 +223,7 @@ class ListAgentsCommand {
     });
   }
 
-  /**
-   * Add status information to agents
-   * @param {Array<Object>} agents - Agents to enhance
-   * @returns {Promise<Array>} - Agents with status info
-   */
-  async addStatusInfo(agents) {
-    const agentsWithStatus = [];
-    
-    for (const agent of agents) {
-      const status = await this.configManager.getAgentStatus(agent.id);
-      
-      agentsWithStatus.push({
-        ...agent,
-        status: status ? status.status : AgentStatus.NOT_INSTALLED,
-        statusDescription: this.getStatusDescription(status ? status.status : AgentStatus.NOT_INSTALLED),
-        lastChecked: status ? status.lastChecked : null,
-        lastVerified: status ? status.lastVerified : null,
-        statusMessage: status ? status.message : '',
-        canInstall: agent.enabled && (!status || status.status === AgentStatus.NOT_INSTALLED),
-        canVerify: agent.enabled && status && [AgentStatus.INSTALLED, AgentStatus.VERIFIED].includes(status.status)
-      });
-    }
-    
-    return agentsWithStatus;
-  }
-
-  /**
-   * Get status description
-   * @param {string} status - Status code
-   * @returns {string} - Human-readable description
-   */
-  getStatusDescription(status) {
-    const descriptions = {
-      [AgentStatus.NOT_INSTALLED]: 'Not installed',
-      [AgentStatus.INSTALLING]: 'Installing...',
-      [AgentStatus.INSTALLED]: 'Installed (not verified)',
-      [AgentStatus.VERIFYING]: 'Verifying...',
-      [AgentStatus.VERIFIED]: 'Verified and ready',
-      [AgentStatus.ERROR]: 'Error occurred',
-      [AgentStatus.RATE_LIMITED]: 'Rate limited',
-      [AgentStatus.DISABLED]: 'Disabled'
-    };
-
-    return descriptions[status] || 'Unknown';
-  }
-
+  
   /**
    * Output results in specified format
    * @param {Array} agents - Agents to output
@@ -393,7 +349,7 @@ class ListAgentsCommand {
    */
   showHelp() {
     console.log('\n=== LIST AGENTS COMMAND ===');
-    console.log('Description: List all configured agents');
+    console.log('Description: List all available agents (providers)');
     console.log('');
     console.log('Usage: app list agents [options]');
     console.log('');
@@ -401,15 +357,15 @@ class ListAgentsCommand {
     console.log('  --all, -a               Include disabled agents');
     console.log('  --no-status             Exclude status information');
     console.log('  --format <format>      Output format: table, json, csv (default: table)');
-    console.log('  --sort <field>         Sort by: name, status, type, priority (default: name)');
-    console.log('  --status <status>       Filter by status (NOT_INSTALLED, INSTALLING, etc.)');
+    console.log('  --sort <field>         Sort by: name, status, type, category (default: name)');
+    console.log('  --status <status>       Filter by status (NOT_INSTALLED, ENABLED, DISABLED, etc.)');
     console.log('');
     console.log('Examples:');
     console.log('  app list agents');
     console.log('  app list agents --all');
     console.log('  app list agents --format json');
     console.log('  app list agents --sort status');
-    console.log('  app list agents --status VERIFIED');
+    console.log('  app list agents --status ENABLED');
   }
 
   /**
@@ -419,14 +375,14 @@ class ListAgentsCommand {
   getCommandInfo() {
     return {
       name: 'list-agents',
-      description: 'List all configured agents',
+      description: 'List all available agents (providers)',
       usage: 'app list agents [options]',
       examples: [
         'app list agents',
         'app list agents --all',
         'app list agents --format json',
         'app list agents --sort status',
-        'app list agents --status VERIFIED'
+        'app list agents --status ENABLED'
       ],
       options: [
         {
@@ -443,11 +399,11 @@ class ListAgentsCommand {
         },
         {
           flag: '--sort <field>',
-          description: 'Sort by: name, status, type, priority (default: name)'
+          description: 'Sort by: name, status, type, category (default: name)'
         },
         {
           flag: '--status <status>',
-          description: 'Filter by status (NOT_INSTALLED, INSTALLING, etc.)'
+          description: 'Filter by status (NOT_INSTALLED, ENABLED, DISABLED, etc.)'
         }
       ]
     };

package/src/commands/agents-check.js

@@ -8,12 +8,24 @@ const { checkAllProviders, formatCheckedAt } = require('../utils/provider-checke
 async function checkAgents(options = {}) {
   const config = await getAutoConfig();
   const definitions = getProviderDefinitions();
-  const providerIds = options.provider
-    ? definitions.filter(d => d.id === options.provider).map(d => d.id)
-    : definitions.map(d => d.id);
+  const { getProviderPreferences } = require('../utils/provider-registry');
+  const prefs = await getProviderPreferences();
+  
+  // Only check enabled providers unless a specific provider is requested
+  let providerIds;
+  if (options.enabledOnly && options.enabledAgents) {
+    // Use the enabled agents from the provider manager context
+    providerIds = definitions.filter(d => options.enabledAgents[d.id] !== false).map(d => d.id);
+  } else if (options.provider) {
+    providerIds = definitions.filter(d => d.id === options.provider).map(d => d.id);
+  } else {
+    // Use global enabled preferences
+    const prefs = await getProviderPreferences();
+    providerIds = definitions.filter(d => prefs.enabled[d.id] !== false).map(d => d.id);
+  }
 
   if (providerIds.length === 0) {
-    console.log(chalk.red(`\n✗ Unknown provider: ${options.provider}\n`));
+    console.log(chalk.red(`\n✗ No enabled agents to check. Enable agents first.\n`));
     return;
   }
 

package/src/commands/analyze-file-sizes.js

@@ -19,7 +19,7 @@ const { StrategyGenerator } = require('@vibecodingmachine/core/src/analysis/stra
 const { PriorityCalculator } = require('@vibecodingmachine/core/src/analysis/priority-calculator');
 const { AnalysisReporter } = require('@vibecodingmachine/core/src/analysis/analysis-reporter');
 const { FileAnalysis } = require('@vibecodingmachine/core/src/models/file-analysis');
-const { FileAnalysisCollection } = require('@vibecodingmachine/core/src/models/file-analysis');
+const { FileAnalysisCollection } = require('@vibecodingmachine/core/src/models/file-analysis-collection');
 
 /**
  * Analyze file sizes command

package/src/commands/auto-direct/auto-provider-manager.js

@@ -0,0 +1,290 @@
+/**
+ * Auto Mode Provider Management
+ * 
+ * Handles LLM provider configuration and management for auto mode
+ */
+
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const { getProviderPreferences, getProviderDefinition, saveProviderPreferences } = require('../../utils/provider-registry');
+const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
+const { checkAntigravityRateLimit, handleAntigravityRateLimit } = require('../../utils/antigravity-js-handler');
+const { checkKiroRateLimit, handleKiroRateLimit } = require('../../utils/kiro-js-handler');
+const { checkClineRateLimit, handleClineRateLimit } = require('../../utils/cline-js-handler');
+const { DirectLLMManager } = vibecodingmachineCore;
+
+// Shared instances to track rate limits and health across all function calls
+const sharedProviderManager = new ProviderManager();
+const sharedHealthTracker = vibecodingmachineCore.IDEHealthTracker;
+
+/**
+ * Auto-install Cline CLI if not available
+ */
+async function ensureClineInstalled(forceInstall = false) {
+  const llm = new DirectLLMManager();
+
+  try {
+    const isAvailable = await llm.isClineAvailable();
+    if (isAvailable && !forceInstall) {
+      return true;
+    }
+
+    console.log('Installing Cline CLI...');
+    const installResult = await llm.installCline();
+    
+    if (installResult.success) {
+      console.log('✓ Cline CLI installed successfully');
+      return true;
+    } else {
+      console.error('✗ Failed to install Cline CLI:', installResult.error);
+      return false;
+    }
+  } catch (error) {
+    console.error('✗ Error installing Cline CLI:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Get all available provider configurations
+ */
+async function getAllAvailableProviders() {
+  const config = await vibecodingmachineCore.getAutoConfig();
+  const prefs = await getProviderPreferences();
+
+  const providers = [];
+  const skipped = [];
+
+  // Check each provider in configuration
+  for (const [providerName, providerConfig] of Object.entries(config.providers || {})) {
+    if (!providerConfig.enabled) {
+      skipped.push({ provider: providerName, reason: 'disabled' });
+      continue;
+    }
+
+    // Check if provider is skipped in preferences
+    if (prefs.skippedProviders && prefs.skippedProviders.includes(providerName)) {
+      skipped.push({ provider: providerName, reason: 'user_skipped' });
+      continue;
+    }
+
+    // Check provider-specific requirements
+    let canUse = true;
+    let reason = null;
+
+    switch (providerName) {
+      case 'anthropic':
+        if (!providerConfig.apiKey) {
+          canUse = false;
+          reason = 'missing_api_key';
+        }
+        break;
+        
+      case 'openai':
+        if (!providerConfig.apiKey) {
+          canUse = false;
+          reason = 'missing_api_key';
+        }
+        break;
+        
+      case 'ollama':
+        if (!providerConfig.baseUrl) {
+          canUse = false;
+          reason = 'missing_base_url';
+        }
+        break;
+        
+      case 'groq':
+        if (!providerConfig.apiKey) {
+          canUse = false;
+          reason = 'missing_api_key';
+        }
+        break;
+        
+      case 'bedrock':
+        if (!providerConfig.region || !providerConfig.accessKeyId) {
+          canUse = false;
+          reason = 'missing_credentials';
+        }
+        break;
+    }
+
+    if (canUse) {
+      providers.push({
+        name: providerName,
+        config: providerConfig,
+        definition: await getProviderDefinition(providerName)
+      });
+    } else {
+      skipped.push({ provider: providerName, reason });
+    }
+  }
+
+  return { providers, skipped };
+}
+
+/**
+ * Get provider configuration with automatic failover
+ */
+async function getProviderConfig(excludeProvider = null) {
+  const config = await vibecodingmachineCore.getAutoConfig();
+  const providerManager = sharedProviderManager; // Use shared instance to persist rate limit state
+  const { providers, skipped } = await getAllAvailableProviders();
+
+  // Filter out excluded provider
+  const availableProviders = providers.filter(p => p.name !== excludeProvider);
+  
+  if (availableProviders.length === 0) {
+    throw new Error('No available providers. Check configuration and API keys.');
+  }
+
+  // Check each provider for rate limits and availability
+  for (const provider of availableProviders) {
+    const providerName = provider.name;
+    
+    // Check provider-specific rate limits
+    let isRateLimited = false;
+    let rateLimitInfo = null;
+    
+    switch (providerName) {
+      case 'antigravity':
+        isRateLimited = checkAntigravityRateLimit(providerManager);
+        if (isRateLimited) {
+          rateLimitInfo = handleAntigravityRateLimit(providerManager);
+        }
+        break;
+        
+      case 'kiro':
+        isRateLimited = checkKiroRateLimit(providerManager);
+        if (isRateLimited) {
+          rateLimitInfo = handleKiroRateLimit(providerManager);
+        }
+        break;
+        
+      case 'cline':
+        isRateLimited = checkClineRateLimit(providerManager);
+        if (isRateLimited) {
+          rateLimitInfo = handleClineRateLimit(providerManager);
+        }
+        break;
+    }
+    
+    if (isRateLimited) {
+      console.warn(`Provider ${providerName} is rate limited:`, rateLimitInfo.message);
+      continue;
+    }
+    
+    // Check IDE health for provider
+    const ideHealth = sharedHealthTracker.getHealth(providerName);
+    if (ideHealth && ideHealth.consecutiveFailures >= 3) {
+      console.warn(`Provider ${providerName} has ${ideHealth.consecutiveFailures} consecutive failures`);
+      continue;
+    }
+    
+    // Return first available provider
+    return {
+      provider: providerName,
+      config: provider.config,
+      definition: provider.definition,
+      manager: providerManager
+    };
+  }
+  
+  // If we get here, all providers are rate limited or unhealthy
+  const rateLimitedProviders = availableProviders.filter(p => {
+    switch (p.name) {
+      case 'antigravity': return checkAntigravityRateLimit(providerManager);
+      case 'kiro': return checkKiroRateLimit(providerManager);
+      case 'cline': return checkClineRateLimit(providerManager);
+      default: return false;
+    }
+  });
+  
+  if (rateLimitedProviders.length > 0) {
+    const waitTime = Math.max(...rateLimitedProviders.map(p => {
+      switch (p.name) {
+        case 'antigravity': return handleAntigravityRateLimit(providerManager).waitTime || 60000;
+        case 'kiro': return handleKiroRateLimit(providerManager).waitTime || 60000;
+        case 'cline': return handleClineRateLimit(providerManager).waitTime || 60000;
+        default: return 60000;
+      }
+    }));
+    
+    return {
+      action: 'wait',
+      waitTime,
+      message: `All providers are rate limited. Waiting ${waitTime/1000}s before retry.`
+    };
+  }
+  
+  throw new Error('All providers are unavailable or unhealthy.');
+}
+
+/**
+ * Handle provider failure and update tracking
+ */
+function handleProviderFailure(providerName, error) {
+  sharedHealthTracker.recordFailure(providerName, error);
+  
+  // Mark provider as temporarily skipped if too many failures
+  const health = sharedHealthTracker.getHealth(providerName);
+  if (health && health.consecutiveFailures >= 3) {
+    console.warn(`Provider ${providerName} marked as temporarily unavailable due to failures`);
+  }
+}
+
+/**
+ * Handle provider success and update tracking
+ */
+function handleProviderSuccess(providerName) {
+  sharedHealthTracker.recordSuccess(providerName);
+}
+
+/**
+ * Check if provider should be skipped due to health issues
+ */
+function shouldSkipProvider(providerName) {
+  const health = sharedHealthTracker.getHealth(providerName);
+  return health && health.consecutiveFailures >= 3;
+}
+
+/**
+ * Get provider health status
+ */
+function getProviderHealth(providerName) {
+  return sharedHealthTracker.getHealth(providerName);
+}
+
+/**
+ * Get all providers health status
+ */
+function getAllProvidersHealth() {
+  return sharedHealthTracker.getAllHealth();
+}
+
+/**
+ * Reset provider health tracking
+ */
+function resetProviderHealth(providerName) {
+  sharedHealthTracker.reset(providerName);
+}
+
+// Listen for consecutive failures to warn user
+sharedHealthTracker.on('consecutive-failures', ({ ideId, count, lastError }) => {
+  console.warn(`⚠️  Provider ${ideId} has ${count} consecutive failures`);
+  console.warn(`   Last error: ${lastError.message}`);
+  console.warn(`   Consider switching providers or checking configuration`);
+});
+
+module.exports = {
+  ensureClineInstalled,
+  getAllAvailableProviders,
+  getProviderConfig,
+  handleProviderFailure,
+  handleProviderSuccess,
+  shouldSkipProvider,
+  getProviderHealth,
+  getAllProvidersHealth,
+  resetProviderHealth,
+  sharedProviderManager,
+  sharedHealthTracker
+};