vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/commands/auto-direct/file-scanner.js

@@ -0,0 +1,266 @@
+/**
+ * File scanning functions for auto-direct command
+ * Extracted from auto-direct.js to reduce file size
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Find relevant files based on requirement
+ */
+async function findRelevantFiles(requirement, repoPath) {
+  const relevantFiles = [];
+
+  try {
+    // Common file patterns to search for
+    const patterns = [
+      '**/*.js',
+      '**/*.jsx',
+      '**/*.ts',
+      '**/*.tsx',
+      '**/*.json',
+      '**/*.md',
+      '**/*.yml',
+      '**/*.yaml'
+    ];
+
+    // Keywords to look for in requirement
+    const keywords = extractKeywords(requirement);
+
+    // Search for files containing keywords
+    for (const pattern of patterns) {
+      const files = await glob(pattern, { cwd: repoPath, ignore: ['**/node_modules/**', '**/.git/**'] });
+      
+      for (const file of files) {
+        const fullPath = path.join(repoPath, file);
+        
+        // Skip if not a file
+        if (!await fs.pathExists(fullPath) || !await fs.stat(fullPath).then(stat => stat.isFile())) {
+          continue;
+        }
+
+        // Check if file contains relevant keywords
+        const isRelevant = await isFileRelevant(fullPath, keywords);
+        if (isRelevant) {
+          relevantFiles.push(file);
+        }
+      }
+    }
+
+    // Remove duplicates and sort by relevance
+    const uniqueFiles = [...new Set(relevantFiles)];
+    return uniqueFiles.slice(0, 20); // Limit to top 20 files
+    
+  } catch (error) {
+    console.error('Error finding relevant files:', error.message);
+    return [];
+  }
+}
+
+/**
+ * Read file snippets to give LLM context
+ */
+async function readFileSnippets(files, repoPath, requirement) {
+  const snippets = [];
+
+  for (const file of files) {
+    try {
+      const fullPath = path.join(repoPath, file);
+      
+      if (!await fs.pathExists(fullPath)) {
+        continue;
+      }
+
+      const content = await fs.readFile(fullPath, 'utf8');
+      const lines = content.split('\n');
+
+      // For large files, find relevant sections
+      let startLine = 0;
+      let endLine = lines.length;
+
+      if (lines.length > 100) {
+        // Try to find relevant sections based on requirement keywords
+        const keywords = extractKeywords(requirement);
+        const relevantSections = findRelevantSections(lines, keywords);
+        
+        if (relevantSections.length > 0) {
+          // Use the most relevant section
+          const section = relevantSections[0];
+          startLine = Math.max(0, section.start - 10); // Add context
+          endLine = Math.min(lines.length, section.end + 10);
+        } else {
+          // Fall back to beginning of file
+          endLine = 50;
+        }
+      }
+
+      const snippet = lines.slice(startLine, endLine).join('\n');
+      
+      snippets.push({
+        file,
+        content: snippet,
+        startLine: startLine + 1,
+        endLine: endLine,
+        totalLines: lines.length
+      });
+
+    } catch (error) {
+      console.warn(`Warning: Could not read file ${file}:`, error.message);
+    }
+  }
+
+  return snippets;
+}
+
+/**
+ * Extract keywords from requirement text
+ */
+function extractKeywords(requirement) {
+  // Simple keyword extraction - look for technical terms
+  const technicalTerms = [
+    'function', 'class', 'component', 'module', 'package', 'file',
+    'test', 'spec', 'config', 'build', 'deploy', 'api', 'endpoint',
+    'database', 'model', 'view', 'controller', 'service', 'utility',
+    'helper', 'constant', 'variable', 'method', 'property', 'interface'
+  ];
+
+  const words = requirement.toLowerCase().split(/\s+/);
+  const keywords = new Set();
+
+  // Add technical terms found in requirement
+  words.forEach(word => {
+    if (technicalTerms.includes(word) || word.length > 5) {
+      keywords.add(word);
+    }
+  });
+
+  // Look for file extensions and patterns
+  const filePatterns = requirement.match(/\b\w+\.(js|jsx|ts|tsx|json|md|yml|yaml)\b/g);
+  if (filePatterns) {
+    filePatterns.forEach(pattern => keywords.add(pattern));
+  }
+
+  // Look for specific file names in quotes
+  const quotedFiles = requirement.match(/['"`]([^'"`]+\.(js|jsx|ts|tsx|json|md|yml|yaml))['"`]/g);
+  if (quotedFiles) {
+    quotedFiles.forEach(file => keywords.add(file.replace(/['"`]/g, '')));
+  }
+
+  return Array.from(keywords);
+}
+
+/**
+ * Check if file contains relevant keywords
+ */
+async function isFileRelevant(filePath, keywords) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    const lowerContent = content.toLowerCase();
+    
+    // Check if any keywords are present in the file
+    return keywords.some(keyword => 
+      lowerContent.includes(keyword.toLowerCase())
+    );
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Find relevant sections in file based on keywords
+ */
+function findRelevantSections(lines, keywords) {
+  const sections = [];
+  
+  keywords.forEach(keyword => {
+    const lowerKeyword = keyword.toLowerCase();
+    
+    lines.forEach((line, index) => {
+      if (line.toLowerCase().includes(lowerKeyword)) {
+        // Found a keyword, create a section around it
+        const start = Math.max(0, index - 5);
+        const end = Math.min(lines.length, index + 15);
+        
+        sections.push({
+          keyword,
+          start,
+          end,
+          line: index + 1,
+          content: line.trim()
+        });
+      }
+    });
+  });
+
+  // Sort by keyword relevance (prefer function/class definitions)
+  sections.sort((a, b) => {
+    const aScore = calculateRelevanceScore(a.content);
+    const bScore = calculateRelevanceScore(b.content);
+    return bScore - aScore;
+  });
+
+  return sections;
+}
+
+/**
+ * Calculate relevance score for a line
+ */
+function calculateRelevanceScore(line) {
+  let score = 0;
+  
+  // Higher score for function/class definitions
+  if (line.includes('function ') || line.includes('class ') || line.includes('const ')) {
+    score += 10;
+  }
+  
+  // Higher score for exports
+  if (line.includes('module.exports') || line.includes('export ')) {
+    score += 8;
+  }
+  
+  // Higher score for imports/requires
+  if (line.includes('require(') || line.includes('import ')) {
+    score += 5;
+  }
+  
+  // Higher score for comments
+  if (line.includes('//') || line.includes('*') || line.includes('/*')) {
+    score += 3;
+  }
+  
+  return score;
+}
+
+/**
+ * Simple glob implementation (or you can use the 'glob' package)
+ */
+async function glob(pattern, options = {}) {
+  const { cwd = process.cwd(), ignore = [] } = options;
+  const { promisify } = require('util');
+  const { exec } = require('child_process');
+  
+  try {
+    const { stdout } = await promisify(exec)(`find . -name "${pattern.replace('**/', '*')}"`, { cwd });
+    let files = stdout.trim().split('\n').filter(file => file);
+    
+    // Apply ignore patterns
+    ignore.forEach(ignorePattern => {
+      files = files.filter(file => !file.includes(ignorePattern.replace('**/', '')));
+    });
+    
+    return files;
+  } catch (error) {
+    return [];
+  }
+}
+
+module.exports = {
+  findRelevantFiles,
+  readFileSnippets,
+  extractKeywords,
+  isFileRelevant,
+  findRelevantSections,
+  calculateRelevanceScore
+};

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

@@ -0,0 +1,178 @@
+/**
+ * Provider configuration functions for auto-direct command
+ * Extracted from auto-direct.js to reduce file size
+ */
+
+const { getAutoConfig } = require('../../utils/config');
+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');
+
+// CRITICAL: Shared ProviderManager instance to track rate limits across all function calls
+const sharedProviderManager = new ProviderManager();
+
+/**
+ * Get all available provider configurations
+ */
+async function getAllAvailableProviders() {
+  const config = await getAutoConfig();
+  const prefs = await getProviderPreferences();
+
+  const providers = [];
+  const skipped = [];
+
+  // Check each provider in config
+  for (const [providerName, providerConfig] of Object.entries(config.providers || {})) {
+    // Skip if provider is disabled in preferences
+    if (prefs.disabled?.includes(providerName)) {
+      skipped.push(providerName);
+      continue;
+    }
+
+    // Check if provider is properly configured
+    const definition = getProviderDefinition(providerName);
+    if (!definition) {
+      skipped.push(providerName);
+      continue;
+    }
+
+    // Check required credentials
+    let hasCredentials = true;
+    if (definition.credentials) {
+      for (const cred of definition.credentials) {
+        if (!providerConfig[cred]) {
+          hasCredentials = false;
+          break;
+        }
+      }
+    }
+
+    if (hasCredentials) {
+      providers.push({
+        name: providerName,
+        displayName: definition.displayName || providerName,
+        config: providerConfig,
+        definition
+      });
+    } else {
+      skipped.push(providerName);
+    }
+  }
+
+  return { providers, skipped };
+}
+
+/**
+ * Get provider configuration with automatic failover
+ */
+async function getProviderConfig(excludeProvider = null) {
+  const config = await 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 providers available. Check your configuration.');
+  }
+
+  // Sort providers by reliability (health score)
+  const sortedProviders = availableProviders.sort((a, b) => {
+    const aHealth = providerManager.getHealthScore(a.name);
+    const bHealth = providerManager.getHealthScore(b.name);
+    return bHealth - aHealth; // Higher health score first
+  });
+
+  // Try providers in order of reliability
+  for (const provider of sortedProviders) {
+    // Check rate limits for specific providers
+    if (provider.name === 'antigravity') {
+      const isRateLimited = checkAntigravityRateLimit();
+      if (isRateLimited) {
+        console.warn(`⚠️  ${provider.displayName} is rate limited, trying next provider`);
+        handleAntigravityRateLimit();
+        continue;
+      }
+    } else if (provider.name === 'kiro') {
+      const isRateLimited = checkKiroRateLimit();
+      if (isRateLimited) {
+        console.warn(`⚠️  ${provider.displayName} is rate limited, trying next provider`);
+        handleKiroRateLimit();
+        continue;
+      }
+    } else if (provider.name === 'cline') {
+      const isRateLimited = checkClineRateLimit();
+      if (isRateLimited) {
+        console.warn(`⚠️  ${provider.displayName} is rate limited, trying next provider`);
+        handleClineRateLimit();
+        continue;
+      }
+    }
+
+    return {
+      provider: provider.name,
+      displayName: provider.displayName,
+      config: provider.config,
+      definition: provider.definition
+    };
+  }
+
+  throw new Error('All providers are rate limited or unavailable');
+}
+
+/**
+ * Acquire provider configuration with enhanced failover and model selection
+ */
+async function acquireProviderConfig(excludeProvider = null, excludeModel = null, forcedProvider = null) {
+  // If a specific provider is forced, bypass normal selection
+  if (forcedProvider) {
+    const { providers } = await getAllAvailableProviders();
+    const provider = providers.find(p => p.name === forcedProvider);
+    
+    if (!provider) {
+      throw new Error(`Forced provider "${forcedProvider}" not available`);
+    }
+
+    return {
+      provider: provider.name,
+      displayName: provider.displayName,
+      config: provider.config,
+      definition: provider.definition,
+      model: provider.config.model || provider.definition.defaultModel
+    };
+  }
+
+  const config = await getProviderConfig(excludeProvider);
+  
+  // Model selection logic
+  let selectedModel = config.config.model;
+  
+  // Exclude specific model if requested
+  if (excludeModel && selectedModel === excludeModel) {
+    // Try alternative models
+    const alternativeModels = config.definition.models || [];
+    const availableModel = alternativeModels.find(m => m !== excludeModel && m !== selectedModel);
+    
+    if (availableModel) {
+      selectedModel = availableModel;
+    } else {
+      // If no alternative model, try next provider
+      return acquireProviderConfig(config.provider, excludeModel, null);
+    }
+  }
+
+  return {
+    ...config,
+    model: selectedModel
+  };
+}
+
+module.exports = {
+  getAllAvailableProviders,
+  getProviderConfig,
+  acquireProviderConfig,
+  sharedProviderManager
+};

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

@@ -0,0 +1,219 @@
+/**
+ * Provider management functions for auto-direct command
+ * Extracted from auto-direct.js to reduce file size
+ */
+
+const { getAutoConfig } = require('../../utils/config');
+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 } = require('vibecodingmachine-core');
+
+// CRITICAL: Shared ProviderManager instance to track rate limits across all function calls
+const sharedProviderManager = new ProviderManager();
+
+/**
+ * Get all available provider configurations
+ */
+async function getAllAvailableProviders() {
+  const config = await getAutoConfig();
+  const prefs = await getProviderPreferences();
+
+  const providers = [];
+  const skipped = [];
+
+  // Check each configured provider
+  for (const [providerName, providerConfig] of Object.entries(config.providers || {})) {
+    if (!providerConfig.enabled) {
+      skipped.push(`${providerName} (disabled)`);
+      continue;
+    }
+
+    // Check rate limits for specific providers
+    let isRateLimited = false;
+    let rateLimitReason = '';
+
+    if (providerName === 'antigravity') {
+      const rateLimitCheck = await checkAntigravityRateLimit();
+      if (rateLimitCheck.isLimited) {
+        isRateLimited = true;
+        rateLimitReason = rateLimitCheck.reason;
+      }
+    } else if (providerName === 'kiro') {
+      const rateLimitCheck = await checkKiroRateLimit();
+      if (rateLimitCheck.isLimited) {
+        isRateLimited = true;
+        rateLimitReason = rateLimitCheck.reason;
+      }
+    } else if (providerName === 'cline') {
+      const rateLimitCheck = await checkClineRateLimit();
+      if (rateLimitCheck.isLimited) {
+        isRateLimited = true;
+        rateLimitReason = rateLimitCheck.reason;
+      }
+    }
+
+    if (isRateLimited) {
+      skipped.push(`${providerName} (${rateLimitReason})`);
+      continue;
+    }
+
+    // Get provider definition for display name
+    const providerDef = getProviderDefinition(providerName);
+    const displayName = providerDef?.displayName || providerName;
+
+    providers.push({
+      name: providerName,
+      displayName,
+      config: providerConfig,
+      models: providerConfig.models || []
+    });
+  }
+
+  return { providers, skipped };
+}
+
+/**
+ * Get provider configuration with automatic failover
+ */
+async function getProviderConfig(excludeProvider = null) {
+  const config = await 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) {
+    return {
+      success: false,
+      error: `No available providers. Skipped: ${skipped.join(', ')}`
+    };
+  }
+
+  // Try providers in order
+  for (const provider of availableProviders) {
+    try {
+      // Check if provider is rate limited through ProviderManager
+      const rateLimitStatus = providerManager.getRateLimitStatus(provider.name);
+      if (rateLimitStatus.isLimited) {
+        continue;
+      }
+
+      // Select first available model
+      const availableModels = provider.models.filter(m => m.enabled);
+      if (availableModels.length === 0) {
+        continue;
+      }
+
+      const selectedModel = availableModels[0];
+
+      return {
+        success: true,
+        provider: provider.name,
+        ide: provider.name,
+        displayName: provider.displayName,
+        model: selectedModel.name,
+        config: {
+          ...provider.config,
+          model: selectedModel
+        }
+      };
+    } catch (error) {
+      console.warn(`Failed to configure provider ${provider.name}:`, error.message);
+      continue;
+    }
+  }
+
+  return {
+    success: false,
+    error: `All providers failed. Skipped: ${skipped.join(', ')}`
+  };
+}
+
+/**
+ * Acquire provider configuration with enhanced error handling
+ */
+async function acquireProviderConfig(excludeProvider = null, excludeModel = null, forcedProvider = null) {
+  // If a specific provider is forced, bypass normal selection
+  if (forcedProvider) {
+    // Special handling for Cline CLI - auto-install if not available
+    if (forcedProvider === 'cline') {
+      await ensureClineInstalled(true);
+    }
+
+    const config = await getAutoConfig();
+    const providerConfig = config.providers[forcedProvider];
+    
+    if (!providerConfig || !providerConfig.enabled) {
+      return {
+        success: false,
+        error: `Forced provider ${forcedProvider} is not available or disabled`
+      };
+    }
+
+    const availableModels = providerConfig.models.filter(m => 
+      m.enabled && m.name !== excludeModel
+    );
+
+    if (availableModels.length === 0) {
+      return {
+        success: false,
+        error: `No available models for provider ${forcedProvider}`
+      };
+    }
+
+    return {
+      success: true,
+      provider: forcedProvider,
+      ide: forcedProvider,
+      displayName: getProviderDefinition(forcedProvider)?.displayName || forcedProvider,
+      model: availableModels[0].name,
+      config: {
+        ...providerConfig,
+        model: availableModels[0]
+      }
+    };
+  }
+
+  // Normal provider selection logic
+  return await getProviderConfig(excludeProvider);
+}
+
+/**
+ * Ensure Cline CLI is installed and available
+ */
+async function ensureClineInstalled(forceInstall = false) {
+  const llm = new DirectLLMManager();
+  
+  try {
+    const isAvailable = await llm.checkClineAvailability();
+    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;
+  }
+}
+
+module.exports = {
+  getAllAvailableProviders,
+  getProviderConfig,
+  acquireProviderConfig,
+  ensureClineInstalled,
+  sharedProviderManager
+};