vibecodingmachine-core 1.0.2 → 2025.11.2-7.1239

package/src/ide-integration/provider-manager.cjs

@@ -1,354 +1,354 @@
-/**
- * Provider Manager - Handles LLM provider rotation and rate limit tracking
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-class ProviderManager {
-  constructor() {
-    this.rateLimitFile = path.join(os.homedir(), '.config', 'allnightai', 'rate-limits.json');
-    this.performanceFile = path.join(os.homedir(), '.config', 'allnightai', 'provider-performance.json');
-    this.rateLimits = this.loadRateLimits();
-    this.performance = this.loadPerformance();
-  }
-
-  /**
-   * Load rate limit tracking data from file
-   * Auto-cleanup expired rate limits
-   */
-  loadRateLimits() {
-    try {
-      if (fs.existsSync(this.rateLimitFile)) {
-        const data = fs.readFileSync(this.rateLimitFile, 'utf8');
-        const limits = JSON.parse(data);
-        
-        // Auto-cleanup expired rate limits
-        const now = Date.now();
-        let cleaned = false;
-        for (const key in limits) {
-          if (limits[key].resetTime && limits[key].resetTime <= now) {
-            delete limits[key];
-            cleaned = true;
-          }
-        }
-        
-        // Save cleaned data if any expired limits were removed
-        if (cleaned) {
-          this.saveRateLimitsInternal(limits);
-        }
-        
-        return limits;
-      }
-    } catch (err) {
-      console.error('Error loading rate limits:', err.message);
-    }
-    return {};
-  }
-  
-  /**
-   * Internal save without reload (to prevent infinite loop during cleanup)
-   */
-  saveRateLimitsInternal(limits) {
-    try {
-      const dir = path.dirname(this.rateLimitFile);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(this.rateLimitFile, JSON.stringify(limits, null, 2));
-    } catch (err) {
-      console.error('Error saving rate limits:', err.message);
-    }
-  }
-
-  /**
-   * Save rate limit tracking data to file
-   */
-  saveRateLimits() {
-    try {
-      const dir = path.dirname(this.rateLimitFile);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(this.rateLimitFile, JSON.stringify(this.rateLimits, null, 2));
-    } catch (err) {
-      console.error('Error saving rate limits:', err.message);
-    }
-  }
-
-  /**
-   * Parse rate limit duration from error message
-   * Examples:
-   *   "Please try again in 15m5.472s" -> 905472 ms
-   *   "Please try again in 13m21.792s" -> 801792 ms
-   *   "Please try again in 1h30m" -> 5400000 ms
-   *   "Session limit reached ∙ resets 12pm" -> ms until 12pm today/tomorrow
-   */
-  parseRateLimitDuration(errorMessage) {
-    // Check for Claude Code session limit format: "Session limit reached ∙ resets 12pm"
-    const sessionMatch = errorMessage.match(/resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
-    if (sessionMatch) {
-      let hour = parseInt(sessionMatch[1]);
-      const minute = sessionMatch[2] ? parseInt(sessionMatch[2]) : 0;
-      const meridiem = sessionMatch[3] ? sessionMatch[3].toLowerCase() : null;
-      
-      // Convert to 24-hour format
-      if (meridiem === 'pm' && hour !== 12) {
-        hour += 12;
-      } else if (meridiem === 'am' && hour === 12) {
-        hour = 0;
-      }
-      
-      // Calculate reset time
-      const now = new Date();
-      const resetTime = new Date(now);
-      resetTime.setHours(hour, minute, 0, 0);
-      
-      // If reset time is in the past, it's tomorrow
-      if (resetTime <= now) {
-        resetTime.setDate(resetTime.getDate() + 1);
-      }
-      
-      return resetTime.getTime() - now.getTime();
-    }
-    
-    // Match patterns like "15m5.472s" or "1h30m" or "45s"
-    const timeMatch = errorMessage.match(/try again in ([\d.]+h)?\s?([\d.]+m)?\s?([\d.]+s)?/i);
-    if (!timeMatch) return null;
-
-    let totalMs = 0;
-
-    // Hours
-    if (timeMatch[1]) {
-      const hours = parseFloat(timeMatch[1].replace('h', ''));
-      totalMs += hours * 60 * 60 * 1000;
-    }
-
-    // Minutes
-    if (timeMatch[2]) {
-      const minutes = parseFloat(timeMatch[2].replace('m', ''));
-      totalMs += minutes * 60 * 1000;
-    }
-
-    // Seconds
-    if (timeMatch[3]) {
-      const seconds = parseFloat(timeMatch[3].replace('s', ''));
-      totalMs += seconds * 1000;
-    }
-
-    return totalMs;
-  }
-
-  /**
-   * Mark a provider as rate limited
-   * @param {string} provider - Provider name (e.g., "groq", "anthropic")
-   * @param {string} model - Model name (e.g., "llama-3.3-70b-versatile")
-   * @param {string} errorMessage - Full error message containing duration
-   */
-  markRateLimited(provider, model, errorMessage) {
-    let duration = this.parseRateLimitDuration(errorMessage);
-    if (!duration) {
-      console.warn(`Could not parse rate limit duration from: ${errorMessage}`);
-      // Default to 15 minutes if we can't parse
-      duration = 15 * 60 * 1000;
-    }
-
-    const resetTime = Date.now() + duration;
-    const key = `${provider}:${model}`;
-
-    this.rateLimits[key] = {
-      provider,
-      model,
-      resetTime,
-      resetDate: new Date(resetTime).toISOString(),
-      markedAt: new Date().toISOString()
-    };
-
-    this.saveRateLimits();
-
-    const chalk = require('chalk');
-    const resetMinutes = Math.ceil(duration / 60000);
-    console.log(chalk.yellow(`📊 Provider ${provider}/${model} rate limited until ${new Date(resetTime).toLocaleTimeString()} (~${resetMinutes}m)`));
-  }
-
-  /**
-   * Check if a provider is currently rate limited
-   * @param {string} provider - Provider name
-   * @param {string} model - Model name
-   * @returns {boolean}
-   */
-  isRateLimited(provider, model) {
-    const key = `${provider}:${model}`;
-    const limit = this.rateLimits[key];
-
-    if (!limit) return false;
-
-    // Check if rate limit has expired
-    if (Date.now() >= limit.resetTime) {
-      // Clean up expired rate limit
-      delete this.rateLimits[key];
-      this.saveRateLimits();
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Get available provider (not rate limited)
-   * @param {Array} providers - Array of {provider, model, apiKey} objects
-   * @returns {Object|null} - Available provider object or null
-   */
-  getAvailableProvider(providers) {
-    for (const providerConfig of providers) {
-      if (!this.isRateLimited(providerConfig.provider, providerConfig.model)) {
-        return providerConfig;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Get time remaining until provider is available again
-   * @param {string} provider
-   * @param {string} model
-   * @returns {number|null} - Milliseconds until reset, or null if not rate limited
-   */
-  getTimeUntilReset(provider, model) {
-    const key = `${provider}:${model}`;
-    const limit = this.rateLimits[key];
-
-    if (!limit) return null;
-
-    const remaining = limit.resetTime - Date.now();
-    return remaining > 0 ? remaining : null;
-  }
-
-  /**
-   * Get status of all providers
-   * @param {Array} providers - Array of provider configs
-   * @returns {Array} - Array of provider status objects
-   */
-  getProviderStatus(providers) {
-    return providers.map(p => {
-      const isLimited = this.isRateLimited(p.provider, p.model);
-      const timeUntilReset = this.getTimeUntilReset(p.provider, p.model);
-
-      return {
-        provider: p.provider,
-        model: p.model,
-        available: !isLimited,
-        rateLimited: isLimited,
-        resetIn: timeUntilReset ? Math.ceil(timeUntilReset / 60000) + 'm' : null
-      };
-    });
-  }
-
-  /**
-   * Clear all rate limits (useful for testing)
-   */
-  clearAllRateLimits() {
-    this.rateLimits = {};
-    this.saveRateLimits();
-  }
-
-  /**
-   * Load performance tracking data
-   */
-  loadPerformance() {
-    try {
-      if (fs.existsSync(this.performanceFile)) {
-        return JSON.parse(fs.readFileSync(this.performanceFile, 'utf8'));
-      }
-    } catch (err) {
-      // Ignore errors
-    }
-    return {};
-  }
-
-  /**
-   * Save performance tracking data
-   */
-  savePerformance() {
-    try {
-      const dir = path.dirname(this.performanceFile);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(this.performanceFile, JSON.stringify(this.performance, null, 2));
-    } catch (err) {
-      // Ignore errors
-    }
-  }
-
-  /**
-   * Record performance metric for a provider
-   * @param {string} provider - Provider name
-   * @param {string} model - Model name
-   * @param {number} durationMs - Duration in milliseconds
-   */
-  recordPerformance(provider, model, durationMs) {
-    const key = `${provider}:${model}`;
-    
-    if (!this.performance[key]) {
-      this.performance[key] = {
-        provider,
-        model,
-        samples: [],
-        avgSpeed: 0
-      };
-    }
-    
-    const perf = this.performance[key];
-    perf.samples.push(durationMs);
-    
-    // Keep only last 10 samples
-    if (perf.samples.length > 10) {
-      perf.samples.shift();
-    }
-    
-    // Calculate average
-    perf.avgSpeed = perf.samples.reduce((a, b) => a + b, 0) / perf.samples.length;
-    perf.lastUsed = Date.now();
-    
-    this.savePerformance();
-  }
-
-  /**
-   * Get fastest available provider from a list
-   * @param {Array} providers - Array of {provider, model, ...} objects
-   * @returns {Object|null} - Fastest available provider or null
-   */
-  getFastestAvailable(providers) {
-    const available = providers.filter(p => !this.isRateLimited(p.provider, p.model));
-    
-    if (available.length === 0) return null;
-    if (available.length === 1) return available[0];
-    
-    // Sort by average speed (fastest first)
-    available.sort((a, b) => {
-      const aKey = `${a.provider}:${a.model}`;
-      const bKey = `${b.provider}:${b.model}`;
-      const aAvg = this.performance[aKey]?.avgSpeed;
-      const bAvg = this.performance[bKey]?.avgSpeed;
-      const aSpeed = (aAvg ?? a.estimatedSpeed ?? Infinity);
-      const bSpeed = (bAvg ?? b.estimatedSpeed ?? Infinity);
-      return aSpeed - bSpeed;
-    });
-    
-    return available[0];
-  }
-
-  /**
-   * Get provider rankings by speed
-   * @returns {Array} - Sorted array of {provider, model, avgSpeed}
-   */
-  getProviderRankings() {
-    return Object.values(this.performance)
-      .filter(p => p.avgSpeed > 0)
-      .sort((a, b) => a.avgSpeed - b.avgSpeed);
-  }
-}
-
-module.exports = ProviderManager;
+/**
+ * Provider Manager - Handles LLM provider rotation and rate limit tracking
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class ProviderManager {
+  constructor() {
+    this.rateLimitFile = path.join(os.homedir(), '.config', 'allnightai', 'rate-limits.json');
+    this.performanceFile = path.join(os.homedir(), '.config', 'allnightai', 'provider-performance.json');
+    this.rateLimits = this.loadRateLimits();
+    this.performance = this.loadPerformance();
+  }
+
+  /**
+   * Load rate limit tracking data from file
+   * Auto-cleanup expired rate limits
+   */
+  loadRateLimits() {
+    try {
+      if (fs.existsSync(this.rateLimitFile)) {
+        const data = fs.readFileSync(this.rateLimitFile, 'utf8');
+        const limits = JSON.parse(data);
+        
+        // Auto-cleanup expired rate limits
+        const now = Date.now();
+        let cleaned = false;
+        for (const key in limits) {
+          if (limits[key].resetTime && limits[key].resetTime <= now) {
+            delete limits[key];
+            cleaned = true;
+          }
+        }
+        
+        // Save cleaned data if any expired limits were removed
+        if (cleaned) {
+          this.saveRateLimitsInternal(limits);
+        }
+        
+        return limits;
+      }
+    } catch (err) {
+      console.error('Error loading rate limits:', err.message);
+    }
+    return {};
+  }
+  
+  /**
+   * Internal save without reload (to prevent infinite loop during cleanup)
+   */
+  saveRateLimitsInternal(limits) {
+    try {
+      const dir = path.dirname(this.rateLimitFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.rateLimitFile, JSON.stringify(limits, null, 2));
+    } catch (err) {
+      console.error('Error saving rate limits:', err.message);
+    }
+  }
+
+  /**
+   * Save rate limit tracking data to file
+   */
+  saveRateLimits() {
+    try {
+      const dir = path.dirname(this.rateLimitFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.rateLimitFile, JSON.stringify(this.rateLimits, null, 2));
+    } catch (err) {
+      console.error('Error saving rate limits:', err.message);
+    }
+  }
+
+  /**
+   * Parse rate limit duration from error message
+   * Examples:
+   *   "Please try again in 15m5.472s" -> 905472 ms
+   *   "Please try again in 13m21.792s" -> 801792 ms
+   *   "Please try again in 1h30m" -> 5400000 ms
+   *   "Session limit reached ∙ resets 12pm" -> ms until 12pm today/tomorrow
+   */
+  parseRateLimitDuration(errorMessage) {
+    // Check for Claude Code session limit format: "Session limit reached ∙ resets 12pm"
+    const sessionMatch = errorMessage.match(/resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+    if (sessionMatch) {
+      let hour = parseInt(sessionMatch[1]);
+      const minute = sessionMatch[2] ? parseInt(sessionMatch[2]) : 0;
+      const meridiem = sessionMatch[3] ? sessionMatch[3].toLowerCase() : null;
+      
+      // Convert to 24-hour format
+      if (meridiem === 'pm' && hour !== 12) {
+        hour += 12;
+      } else if (meridiem === 'am' && hour === 12) {
+        hour = 0;
+      }
+      
+      // Calculate reset time
+      const now = new Date();
+      const resetTime = new Date(now);
+      resetTime.setHours(hour, minute, 0, 0);
+      
+      // If reset time is in the past, it's tomorrow
+      if (resetTime <= now) {
+        resetTime.setDate(resetTime.getDate() + 1);
+      }
+      
+      return resetTime.getTime() - now.getTime();
+    }
+    
+    // Match patterns like "15m5.472s" or "1h30m" or "45s"
+    const timeMatch = errorMessage.match(/try again in ([\d.]+h)?\s?([\d.]+m)?\s?([\d.]+s)?/i);
+    if (!timeMatch) return null;
+
+    let totalMs = 0;
+
+    // Hours
+    if (timeMatch[1]) {
+      const hours = parseFloat(timeMatch[1].replace('h', ''));
+      totalMs += hours * 60 * 60 * 1000;
+    }
+
+    // Minutes
+    if (timeMatch[2]) {
+      const minutes = parseFloat(timeMatch[2].replace('m', ''));
+      totalMs += minutes * 60 * 1000;
+    }
+
+    // Seconds
+    if (timeMatch[3]) {
+      const seconds = parseFloat(timeMatch[3].replace('s', ''));
+      totalMs += seconds * 1000;
+    }
+
+    return totalMs;
+  }
+
+  /**
+   * Mark a provider as rate limited
+   * @param {string} provider - Provider name (e.g., "groq", "anthropic")
+   * @param {string} model - Model name (e.g., "llama-3.3-70b-versatile")
+   * @param {string} errorMessage - Full error message containing duration
+   */
+  markRateLimited(provider, model, errorMessage) {
+    let duration = this.parseRateLimitDuration(errorMessage);
+    if (!duration) {
+      console.warn(`Could not parse rate limit duration from: ${errorMessage}`);
+      // Default to 15 minutes if we can't parse
+      duration = 15 * 60 * 1000;
+    }
+
+    const resetTime = Date.now() + duration;
+    const key = `${provider}:${model}`;
+
+    this.rateLimits[key] = {
+      provider,
+      model,
+      resetTime,
+      resetDate: new Date(resetTime).toISOString(),
+      markedAt: new Date().toISOString()
+    };
+
+    this.saveRateLimits();
+
+    const chalk = require('chalk');
+    const resetMinutes = Math.ceil(duration / 60000);
+    console.log(chalk.yellow(`📊 Provider ${provider}/${model} rate limited until ${new Date(resetTime).toLocaleTimeString()} (~${resetMinutes}m)`));
+  }
+
+  /**
+   * Check if a provider is currently rate limited
+   * @param {string} provider - Provider name
+   * @param {string} model - Model name
+   * @returns {boolean}
+   */
+  isRateLimited(provider, model) {
+    const key = `${provider}:${model}`;
+    const limit = this.rateLimits[key];
+
+    if (!limit) return false;
+
+    // Check if rate limit has expired
+    if (Date.now() >= limit.resetTime) {
+      // Clean up expired rate limit
+      delete this.rateLimits[key];
+      this.saveRateLimits();
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Get available provider (not rate limited)
+   * @param {Array} providers - Array of {provider, model, apiKey} objects
+   * @returns {Object|null} - Available provider object or null
+   */
+  getAvailableProvider(providers) {
+    for (const providerConfig of providers) {
+      if (!this.isRateLimited(providerConfig.provider, providerConfig.model)) {
+        return providerConfig;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get time remaining until provider is available again
+   * @param {string} provider
+   * @param {string} model
+   * @returns {number|null} - Milliseconds until reset, or null if not rate limited
+   */
+  getTimeUntilReset(provider, model) {
+    const key = `${provider}:${model}`;
+    const limit = this.rateLimits[key];
+
+    if (!limit) return null;
+
+    const remaining = limit.resetTime - Date.now();
+    return remaining > 0 ? remaining : null;
+  }
+
+  /**
+   * Get status of all providers
+   * @param {Array} providers - Array of provider configs
+   * @returns {Array} - Array of provider status objects
+   */
+  getProviderStatus(providers) {
+    return providers.map(p => {
+      const isLimited = this.isRateLimited(p.provider, p.model);
+      const timeUntilReset = this.getTimeUntilReset(p.provider, p.model);
+
+      return {
+        provider: p.provider,
+        model: p.model,
+        available: !isLimited,
+        rateLimited: isLimited,
+        resetIn: timeUntilReset ? Math.ceil(timeUntilReset / 60000) + 'm' : null
+      };
+    });
+  }
+
+  /**
+   * Clear all rate limits (useful for testing)
+   */
+  clearAllRateLimits() {
+    this.rateLimits = {};
+    this.saveRateLimits();
+  }
+
+  /**
+   * Load performance tracking data
+   */
+  loadPerformance() {
+    try {
+      if (fs.existsSync(this.performanceFile)) {
+        return JSON.parse(fs.readFileSync(this.performanceFile, 'utf8'));
+      }
+    } catch (err) {
+      // Ignore errors
+    }
+    return {};
+  }
+
+  /**
+   * Save performance tracking data
+   */
+  savePerformance() {
+    try {
+      const dir = path.dirname(this.performanceFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.performanceFile, JSON.stringify(this.performance, null, 2));
+    } catch (err) {
+      // Ignore errors
+    }
+  }
+
+  /**
+   * Record performance metric for a provider
+   * @param {string} provider - Provider name
+   * @param {string} model - Model name
+   * @param {number} durationMs - Duration in milliseconds
+   */
+  recordPerformance(provider, model, durationMs) {
+    const key = `${provider}:${model}`;
+    
+    if (!this.performance[key]) {
+      this.performance[key] = {
+        provider,
+        model,
+        samples: [],
+        avgSpeed: 0
+      };
+    }
+    
+    const perf = this.performance[key];
+    perf.samples.push(durationMs);
+    
+    // Keep only last 10 samples
+    if (perf.samples.length > 10) {
+      perf.samples.shift();
+    }
+    
+    // Calculate average
+    perf.avgSpeed = perf.samples.reduce((a, b) => a + b, 0) / perf.samples.length;
+    perf.lastUsed = Date.now();
+    
+    this.savePerformance();
+  }
+
+  /**
+   * Get fastest available provider from a list
+   * @param {Array} providers - Array of {provider, model, ...} objects
+   * @returns {Object|null} - Fastest available provider or null
+   */
+  getFastestAvailable(providers) {
+    const available = providers.filter(p => !this.isRateLimited(p.provider, p.model));
+    
+    if (available.length === 0) return null;
+    if (available.length === 1) return available[0];
+    
+    // Sort by average speed (fastest first)
+    available.sort((a, b) => {
+      const aKey = `${a.provider}:${a.model}`;
+      const bKey = `${b.provider}:${b.model}`;
+      const aAvg = this.performance[aKey]?.avgSpeed;
+      const bAvg = this.performance[bKey]?.avgSpeed;
+      const aSpeed = (aAvg ?? a.estimatedSpeed ?? Infinity);
+      const bSpeed = (bAvg ?? b.estimatedSpeed ?? Infinity);
+      return aSpeed - bSpeed;
+    });
+    
+    return available[0];
+  }
+
+  /**
+   * Get provider rankings by speed
+   * @returns {Array} - Sorted array of {provider, model, avgSpeed}
+   */
+  getProviderRankings() {
+    return Object.values(this.performance)
+      .filter(p => p.avgSpeed > 0)
+      .sort((a, b) => a.avgSpeed - b.avgSpeed);
+  }
+}
+
+module.exports = ProviderManager;