vibecodingmachine-core 2026.3.9-907 → 2026.3.10-1548

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

@@ -1,595 +1,595 @@
-/**
- * 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();
-  }
-
-  clearRateLimit(provider, model) {
-    if (!provider) return false;
-    const key = `${provider}:${model || provider}`;
-    if (this.rateLimits[key]) {
-      delete this.rateLimits[key];
-      this.saveRateLimits();
-      return true;
-    }
-    return false;
-  }
-
-  clearProviderRateLimits(provider) {
-    if (!provider) return 0;
-    const providerPrefix = `${provider}:`;
-    let cleared = 0;
-    for (const key of Object.keys(this.rateLimits)) {
-      if (key.startsWith(providerPrefix)) {
-        delete this.rateLimits[key];
-        cleared += 1;
-      }
-    }
-    if (cleared > 0) {
-      this.saveRateLimits();
-    }
-    return cleared;
-  }
-
-  /**
-   * 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) {
-    // Gemini / Google AI style: "You can resume using this model at 1/12/2026, 4:07:27 PM"
-    // Also seen as: "resume using this model at <date>, <time>"
-    const resumeAtMatch = errorMessage.match(/resume\s+(?:using\s+this\s+model\s+)?at\s+(\d{1,2}\/\d{1,2}\/\d{4})\s*,?\s*(\d{1,2}:\d{2}(?::\d{2})?)\s*(am|pm)/i);
-    if (resumeAtMatch) {
-      try {
-        const datePart = resumeAtMatch[1];
-        const timePart = resumeAtMatch[2];
-        const meridiem = resumeAtMatch[3];
-        const parsed = new Date(`${datePart}, ${timePart} ${meridiem.toUpperCase()}`);
-        if (!Number.isNaN(parsed.getTime())) {
-          const ms = parsed.getTime() - Date.now();
-          return ms > 0 ? ms : 0;
-        }
-      } catch (_) { }
-    }
-
-    // Check for "resets [Month] [Day] at [Time]" format (e.g. "Spending cap reached resets Jan 17 at 12pm")
-    const dateMatch = errorMessage.match(/resets\s+([a-zA-Z]+)\s+(\d{1,2})\s+at\s+(\d{1,2}(?::\d{2})?)\s*(am|pm)?/i);
-    if (dateMatch) {
-      try {
-        const monthStr = dateMatch[1]; // Jan, February, etc.
-        const day = parseInt(dateMatch[2]);
-        const timeStr = dateMatch[3];
-        const meridiem = dateMatch[4] ? dateMatch[4].toLowerCase() : null;
-
-        // Parse time
-        let [hours, minutes] = timeStr.split(':').map(n => parseInt(n));
-        if (!minutes || Number.isNaN(minutes)) minutes = 0;
-
-        if (meridiem === 'pm' && hours !== 12) hours += 12;
-        if (meridiem === 'am' && hours === 12) hours = 0;
-
-        // Parse month
-        const months = {
-          jan: 0, january: 0,
-          feb: 1, february: 1,
-          mar: 2, march: 2,
-          apr: 3, april: 3,
-          may: 4,
-          jun: 5, june: 5,
-          jul: 6, july: 6,
-          aug: 7, august: 7,
-          sep: 8, sept: 8, september: 8,
-          oct: 9, october: 9,
-          nov: 10, november: 10,
-          dec: 11, december: 11
-        };
-
-        const monthIndex = months[monthStr.toLowerCase().substring(0, 3)] ?? months[monthStr.toLowerCase()];
-
-        if (monthIndex !== undefined) {
-          const currentYear = new Date().getFullYear();
-          let parsed = new Date(currentYear, monthIndex, day, hours, minutes);
-          const now = Date.now();
-
-          // Logic to handle year crossing (reset in Jan, currently Dec)
-          if (parsed.getTime() < now) {
-            if (!Number.isNaN(parsed.getTime())) {
-              if (parsed.getTime() < now) {
-                const nextYearDate = new Date(parsed);
-                nextYearDate.setFullYear(nextYearDate.getFullYear() + 1);
-                if (nextYearDate.getTime() > now) {
-                  parsed = nextYearDate;
-                }
-              }
-            }
-          }
-
-          const ms = parsed.getTime() - now;
-          return ms > 0 ? ms : 0;
-        }
-      } catch (_) { }
-    }
-
-    // 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) {
-    // Normalize model: if model is missing/undefined, assume it's the provider name.
-    model = model || provider;
-
-    let duration = this.parseRateLimitDuration(errorMessage);
-    if (duration === null || duration === undefined) {
-      console.warn(`Could not parse rate limit duration from: ${errorMessage}`);
-      // Don't guess the duration - just mark as rate limited without a specific reset time
-      duration = null;
-    }
-
-    const resetTime = duration ? Date.now() + duration : null;
-    const key = `${provider}:${model}`;
-
-    this.rateLimits[key] = {
-      provider,
-      model,
-      resetTime,
-      resetDate: resetTime ? new Date(resetTime).toISOString() : null,
-      reason: errorMessage,
-      markedAt: new Date().toISOString()
-    };
-
-    this.saveRateLimits();
-
-    if (resetTime) {
-      const chalk = require('chalk');
-      const resetMinutes = Math.ceil(duration / 60000);
-      const resetDateTime = new Date(resetTime);
-      const timeString = resetDateTime.toLocaleTimeString('en-US', { 
-        timeZone: 'America/Denver', 
-        hour: 'numeric', 
-        minute: '2-digit',
-        hour12: true 
-      });
-      const dateString = resetDateTime.toLocaleDateString('en-US', { 
-        timeZone: 'America/Denver',
-        weekday: 'short',
-        month: 'short',
-        day: 'numeric'
-      });
-      console.log(chalk.yellow(`📊 Provider ${provider}/${model} rate limited until ${timeString} MST on ${dateString} (~${resetMinutes}m)`));
-    } else {
-      const chalk = require('chalk');
-      console.log(chalk.yellow(`📊 Provider ${provider}/${model} rate limited (reset time unknown)`));
-    }
-  }
-
-  /**
-   * Check if a provider is currently rate limited
-   * @param {string} provider - Provider name
-   * @param {string} model - Model name (optional, will check all models if not provided)
-   * @returns {boolean}
-   */
-  isRateLimited(provider, model) {
-    if (!model) {
-      // Check if ANY model for this provider is rate limited
-      const providerPrefix = `${provider}:`;
-      for (const key in this.rateLimits) {
-        if (key.startsWith(providerPrefix)) {
-          const limit = this.rateLimits[key];
-          if (limit && Date.now() < limit.resetTime) {
-            return true;
-          }
-        }
-      }
-      return false;
-    }
-
-    const key = `${provider}:${model}`;
-    const limit = this.rateLimits[key];
-
-    if (limit) {
-      // 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;
-    }
-
-    // Fall back to any provider-level entries (handles older or model-agnostic keys)
-    const providerPrefix = `${provider}:`;
-    for (const k in this.rateLimits) {
-      if (k.startsWith(providerPrefix)) {
-        const l = this.rateLimits[k];
-        if (l && Date.now() < l.resetTime) return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Get rate limit information for a provider
-   * @param {string} provider - Provider name
-   * @param {string} model - Model name (optional)
-   * @returns {Object} - {isRateLimited: boolean, resetTime: number, reason: string}
-   */
-  getRateLimitInfo(provider, model) {
-    // If model not specified, check all models for this provider
-    if (!model) {
-      const providerPrefix = `${provider}:`;
-      let earliestReset = null;
-      let reason = null;
-
-      for (const key in this.rateLimits) {
-        if (key.startsWith(providerPrefix)) {
-          const limit = this.rateLimits[key];
-          if (limit && Date.now() < limit.resetTime) {
-            if (!earliestReset || limit.resetTime < earliestReset) {
-              earliestReset = limit.resetTime;
-              reason = limit.reason;
-            }
-          }
-        }
-      }
-
-      if (earliestReset) {
-        return {
-          isRateLimited: true,
-          resetTime: earliestReset,
-          reason: reason
-        };
-      }
-    } else {
-      const key = `${provider}:${model}`;
-      const limit = this.rateLimits[key];
-
-      if (limit && Date.now() < limit.resetTime) {
-        return {
-          isRateLimited: true,
-          resetTime: limit.resetTime,
-          reason: limit.reason
-        };
-      }
-
-      // Fallback: check other keys for this provider and return earliest reset
-      const providerPrefix = `${provider}:`;
-      let earliestReset = null;
-      let reason = null;
-
-      for (const k in this.rateLimits) {
-        if (k.startsWith(providerPrefix)) {
-          const l = this.rateLimits[k];
-          if (l && Date.now() < l.resetTime) {
-            if (!earliestReset || l.resetTime < earliestReset) {
-              earliestReset = l.resetTime;
-              reason = l.reason;
-            }
-          }
-        }
-      }
-
-      if (earliestReset) {
-        return {
-          isRateLimited: true,
-          resetTime: earliestReset,
-          reason
-        };
-      }
-    }
-
-    return {
-      isRateLimited: false,
-      resetTime: null,
-      reason: null
-    };
-  }
-
-  /**
-   * 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 && Date.now() < limit.resetTime) {
-      const remaining = limit.resetTime - Date.now();
-      return remaining > 0 ? remaining : null;
-    }
-
-    // Fallback: check other keys for this provider (handles legacy or model-agnostic entries)
-    const providerPrefix = `${provider}:`;
-    let earliest = null;
-    for (const k in this.rateLimits) {
-      if (k.startsWith(providerPrefix)) {
-        const l = this.rateLimits[k];
-        if (l && Date.now() < l.resetTime) {
-          if (!earliest || l.resetTime < earliest) earliest = l.resetTime;
-        }
-      }
-    }
-
-    if (!earliest) return null;
-    const remaining = earliest - 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();
+  }
+
+  clearRateLimit(provider, model) {
+    if (!provider) return false;
+    const key = `${provider}:${model || provider}`;
+    if (this.rateLimits[key]) {
+      delete this.rateLimits[key];
+      this.saveRateLimits();
+      return true;
+    }
+    return false;
+  }
+
+  clearProviderRateLimits(provider) {
+    if (!provider) return 0;
+    const providerPrefix = `${provider}:`;
+    let cleared = 0;
+    for (const key of Object.keys(this.rateLimits)) {
+      if (key.startsWith(providerPrefix)) {
+        delete this.rateLimits[key];
+        cleared += 1;
+      }
+    }
+    if (cleared > 0) {
+      this.saveRateLimits();
+    }
+    return cleared;
+  }
+
+  /**
+   * 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) {
+    // Gemini / Google AI style: "You can resume using this model at 1/12/2026, 4:07:27 PM"
+    // Also seen as: "resume using this model at <date>, <time>"
+    const resumeAtMatch = errorMessage.match(/resume\s+(?:using\s+this\s+model\s+)?at\s+(\d{1,2}\/\d{1,2}\/\d{4})\s*,?\s*(\d{1,2}:\d{2}(?::\d{2})?)\s*(am|pm)/i);
+    if (resumeAtMatch) {
+      try {
+        const datePart = resumeAtMatch[1];
+        const timePart = resumeAtMatch[2];
+        const meridiem = resumeAtMatch[3];
+        const parsed = new Date(`${datePart}, ${timePart} ${meridiem.toUpperCase()}`);
+        if (!Number.isNaN(parsed.getTime())) {
+          const ms = parsed.getTime() - Date.now();
+          return ms > 0 ? ms : 0;
+        }
+      } catch (_) { }
+    }
+
+    // Check for "resets [Month] [Day] at [Time]" format (e.g. "Spending cap reached resets Jan 17 at 12pm")
+    const dateMatch = errorMessage.match(/resets\s+([a-zA-Z]+)\s+(\d{1,2})\s+at\s+(\d{1,2}(?::\d{2})?)\s*(am|pm)?/i);
+    if (dateMatch) {
+      try {
+        const monthStr = dateMatch[1]; // Jan, February, etc.
+        const day = parseInt(dateMatch[2]);
+        const timeStr = dateMatch[3];
+        const meridiem = dateMatch[4] ? dateMatch[4].toLowerCase() : null;
+
+        // Parse time
+        let [hours, minutes] = timeStr.split(':').map(n => parseInt(n));
+        if (!minutes || Number.isNaN(minutes)) minutes = 0;
+
+        if (meridiem === 'pm' && hours !== 12) hours += 12;
+        if (meridiem === 'am' && hours === 12) hours = 0;
+
+        // Parse month
+        const months = {
+          jan: 0, january: 0,
+          feb: 1, february: 1,
+          mar: 2, march: 2,
+          apr: 3, april: 3,
+          may: 4,
+          jun: 5, june: 5,
+          jul: 6, july: 6,
+          aug: 7, august: 7,
+          sep: 8, sept: 8, september: 8,
+          oct: 9, october: 9,
+          nov: 10, november: 10,
+          dec: 11, december: 11
+        };
+
+        const monthIndex = months[monthStr.toLowerCase().substring(0, 3)] ?? months[monthStr.toLowerCase()];
+
+        if (monthIndex !== undefined) {
+          const currentYear = new Date().getFullYear();
+          let parsed = new Date(currentYear, monthIndex, day, hours, minutes);
+          const now = Date.now();
+
+          // Logic to handle year crossing (reset in Jan, currently Dec)
+          if (parsed.getTime() < now) {
+            if (!Number.isNaN(parsed.getTime())) {
+              if (parsed.getTime() < now) {
+                const nextYearDate = new Date(parsed);
+                nextYearDate.setFullYear(nextYearDate.getFullYear() + 1);
+                if (nextYearDate.getTime() > now) {
+                  parsed = nextYearDate;
+                }
+              }
+            }
+          }
+
+          const ms = parsed.getTime() - now;
+          return ms > 0 ? ms : 0;
+        }
+      } catch (_) { }
+    }
+
+    // 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) {
+    // Normalize model: if model is missing/undefined, assume it's the provider name.
+    model = model || provider;
+
+    let duration = this.parseRateLimitDuration(errorMessage);
+    if (duration === null || duration === undefined) {
+      console.warn(`Could not parse rate limit duration from: ${errorMessage}`);
+      // Don't guess the duration - just mark as rate limited without a specific reset time
+      duration = null;
+    }
+
+    const resetTime = duration ? Date.now() + duration : null;
+    const key = `${provider}:${model}`;
+
+    this.rateLimits[key] = {
+      provider,
+      model,
+      resetTime,
+      resetDate: resetTime ? new Date(resetTime).toISOString() : null,
+      reason: errorMessage,
+      markedAt: new Date().toISOString()
+    };
+
+    this.saveRateLimits();
+
+    if (resetTime) {
+      const chalk = require('chalk');
+      const resetMinutes = Math.ceil(duration / 60000);
+      const resetDateTime = new Date(resetTime);
+      const timeString = resetDateTime.toLocaleTimeString('en-US', { 
+        timeZone: 'America/Denver', 
+        hour: 'numeric', 
+        minute: '2-digit',
+        hour12: true 
+      });
+      const dateString = resetDateTime.toLocaleDateString('en-US', { 
+        timeZone: 'America/Denver',
+        weekday: 'short',
+        month: 'short',
+        day: 'numeric'
+      });
+      console.log(chalk.yellow(`📊 Provider ${provider}/${model} rate limited until ${timeString} MST on ${dateString} (~${resetMinutes}m)`));
+    } else {
+      const chalk = require('chalk');
+      console.log(chalk.yellow(`📊 Provider ${provider}/${model} rate limited (reset time unknown)`));
+    }
+  }
+
+  /**
+   * Check if a provider is currently rate limited
+   * @param {string} provider - Provider name
+   * @param {string} model - Model name (optional, will check all models if not provided)
+   * @returns {boolean}
+   */
+  isRateLimited(provider, model) {
+    if (!model) {
+      // Check if ANY model for this provider is rate limited
+      const providerPrefix = `${provider}:`;
+      for (const key in this.rateLimits) {
+        if (key.startsWith(providerPrefix)) {
+          const limit = this.rateLimits[key];
+          if (limit && Date.now() < limit.resetTime) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    const key = `${provider}:${model}`;
+    const limit = this.rateLimits[key];
+
+    if (limit) {
+      // 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;
+    }
+
+    // Fall back to any provider-level entries (handles older or model-agnostic keys)
+    const providerPrefix = `${provider}:`;
+    for (const k in this.rateLimits) {
+      if (k.startsWith(providerPrefix)) {
+        const l = this.rateLimits[k];
+        if (l && Date.now() < l.resetTime) return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get rate limit information for a provider
+   * @param {string} provider - Provider name
+   * @param {string} model - Model name (optional)
+   * @returns {Object} - {isRateLimited: boolean, resetTime: number, reason: string}
+   */
+  getRateLimitInfo(provider, model) {
+    // If model not specified, check all models for this provider
+    if (!model) {
+      const providerPrefix = `${provider}:`;
+      let earliestReset = null;
+      let reason = null;
+
+      for (const key in this.rateLimits) {
+        if (key.startsWith(providerPrefix)) {
+          const limit = this.rateLimits[key];
+          if (limit && Date.now() < limit.resetTime) {
+            if (!earliestReset || limit.resetTime < earliestReset) {
+              earliestReset = limit.resetTime;
+              reason = limit.reason;
+            }
+          }
+        }
+      }
+
+      if (earliestReset) {
+        return {
+          isRateLimited: true,
+          resetTime: earliestReset,
+          reason: reason
+        };
+      }
+    } else {
+      const key = `${provider}:${model}`;
+      const limit = this.rateLimits[key];
+
+      if (limit && Date.now() < limit.resetTime) {
+        return {
+          isRateLimited: true,
+          resetTime: limit.resetTime,
+          reason: limit.reason
+        };
+      }
+
+      // Fallback: check other keys for this provider and return earliest reset
+      const providerPrefix = `${provider}:`;
+      let earliestReset = null;
+      let reason = null;
+
+      for (const k in this.rateLimits) {
+        if (k.startsWith(providerPrefix)) {
+          const l = this.rateLimits[k];
+          if (l && Date.now() < l.resetTime) {
+            if (!earliestReset || l.resetTime < earliestReset) {
+              earliestReset = l.resetTime;
+              reason = l.reason;
+            }
+          }
+        }
+      }
+
+      if (earliestReset) {
+        return {
+          isRateLimited: true,
+          resetTime: earliestReset,
+          reason
+        };
+      }
+    }
+
+    return {
+      isRateLimited: false,
+      resetTime: null,
+      reason: null
+    };
+  }
+
+  /**
+   * 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 && Date.now() < limit.resetTime) {
+      const remaining = limit.resetTime - Date.now();
+      return remaining > 0 ? remaining : null;
+    }
+
+    // Fallback: check other keys for this provider (handles legacy or model-agnostic entries)
+    const providerPrefix = `${provider}:`;
+    let earliest = null;
+    for (const k in this.rateLimits) {
+      if (k.startsWith(providerPrefix)) {
+        const l = this.rateLimits[k];
+        if (l && Date.now() < l.resetTime) {
+          if (!earliest || l.resetTime < earliest) earliest = l.resetTime;
+        }
+      }
+    }
+
+    if (!earliest) return null;
+    const remaining = earliest - 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;