@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/utils/PerformanceMonitor.js

@@ -0,0 +1,347 @@
+/**
+ * Comprehensive Performance Monitoring System
+ * Tracks search times, memory usage, cache performance, and system metrics
+ */
+import { logger } from './logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+export class PerformanceMonitor {
+    static instance = null;
+    searchMetrics = [];
+    slowQueries = [];
+    memorySnapshots = [];
+    cacheMetrics = new Map();
+    // Configuration
+    maxMetricsHistory = 1000;
+    slowQueryThreshold = 100; // ms
+    memorySnapshotInterval = 30000; // 30 seconds
+    maxSlowQueries = 100;
+    // Timers and intervals
+    memoryMonitorInterval;
+    isMonitoring = false;
+    constructor() {
+        this.startMemoryMonitoring();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new PerformanceMonitor();
+        }
+        return this.instance;
+    }
+    /**
+     * Start performance monitoring
+     */
+    startMonitoring() {
+        if (this.isMonitoring) {
+            return;
+        }
+        this.isMonitoring = true;
+        this.startMemoryMonitoring();
+        logger.info('Performance monitoring started', {
+            slowQueryThreshold: this.slowQueryThreshold,
+            maxMetricsHistory: this.maxMetricsHistory
+        });
+    }
+    /**
+     * Stop performance monitoring
+     */
+    stopMonitoring() {
+        this.isMonitoring = false;
+        if (this.memoryMonitorInterval) {
+            clearInterval(this.memoryMonitorInterval);
+            this.memoryMonitorInterval = undefined;
+        }
+        logger.info('Performance monitoring stopped');
+    }
+    /**
+     * Record search performance metrics
+     */
+    recordSearch(metrics) {
+        if (!this.isMonitoring) {
+            return;
+        }
+        // Normalize query string to prevent Unicode-based attacks
+        const validationResult = UnicodeValidator.normalize(metrics.query);
+        const normalizedMetrics = {
+            ...metrics,
+            query: validationResult.normalizedContent
+        };
+        this.searchMetrics.push(normalizedMetrics);
+        // Check if it's a slow query (use normalized metrics)
+        if (normalizedMetrics.duration > this.slowQueryThreshold) {
+            this.recordSlowQuery({
+                query: normalizedMetrics.query,
+                duration: normalizedMetrics.duration,
+                threshold: this.slowQueryThreshold,
+                sources: normalizedMetrics.sources,
+                resultCount: normalizedMetrics.resultCount,
+                memoryUsage: normalizedMetrics.memoryAfter,
+                timestamp: normalizedMetrics.timestamp
+            });
+        }
+        // Trim history if needed
+        if (this.searchMetrics.length > this.maxMetricsHistory) {
+            this.searchMetrics = this.searchMetrics.slice(-this.maxMetricsHistory);
+        }
+        // Log significant performance events (use normalized metrics)
+        if (normalizedMetrics.duration > this.slowQueryThreshold * 2) {
+            logger.warn('Very slow search detected', {
+                query: normalizedMetrics.query.substring(0, 50),
+                duration: normalizedMetrics.duration,
+                resultCount: normalizedMetrics.resultCount,
+                sources: normalizedMetrics.sources
+            });
+        }
+    }
+    /**
+     * Record cache performance metrics
+     */
+    recordCachePerformance(cacheName, stats) {
+        if (!this.isMonitoring) {
+            return;
+        }
+        // Normalize cache name to prevent Unicode-based attacks
+        const validationResult = UnicodeValidator.normalize(cacheName);
+        const normalizedCacheName = validationResult.normalizedContent;
+        this.cacheMetrics.set(normalizedCacheName, stats);
+        // Log cache performance warnings (use normalized cache name)
+        if (stats.hitRate < 0.5) {
+            logger.warn('Low cache hit rate detected', {
+                cache: normalizedCacheName,
+                hitRate: stats.hitRate,
+                totalOperations: stats.totalHits + stats.totalMisses
+            });
+        }
+    }
+    /**
+     * Get comprehensive performance metrics
+     */
+    getMetrics() {
+        return {
+            searchTimes: this.searchMetrics.map(m => m.duration),
+            memoryUsage: this.memorySnapshots.slice(-100), // Last 100 snapshots
+            cacheStats: this.aggregateCacheStats(),
+            systemStats: this.getSystemStats(),
+            timestamp: new Date()
+        };
+    }
+    /**
+     * Get search performance statistics
+     */
+    getSearchStats() {
+        if (this.searchMetrics.length === 0) {
+            return {
+                totalSearches: 0,
+                averageTime: 0,
+                medianTime: 0,
+                p95Time: 0,
+                p99Time: 0,
+                slowQueries: 0,
+                cacheHitRate: 0
+            };
+        }
+        const times = this.searchMetrics.map(m => m.duration).sort((a, b) => a - b);
+        const cacheHits = this.searchMetrics.filter(m => m.cacheHit).length;
+        return {
+            totalSearches: this.searchMetrics.length,
+            averageTime: times.reduce((sum, time) => sum + time, 0) / times.length,
+            medianTime: times[Math.floor(times.length / 2)],
+            p95Time: times[Math.floor(times.length * 0.95)],
+            p99Time: times[Math.floor(times.length * 0.99)],
+            slowQueries: this.slowQueries.length,
+            cacheHitRate: cacheHits / this.searchMetrics.length
+        };
+    }
+    /**
+     * Get memory usage statistics
+     */
+    getMemoryStats() {
+        if (this.memorySnapshots.length === 0) {
+            const current = this.takeMemorySnapshot();
+            return {
+                currentUsage: current,
+                peakUsage: current,
+                averageUsage: current,
+                growthRate: 0
+            };
+        }
+        const current = this.memorySnapshots[this.memorySnapshots.length - 1];
+        const peak = this.memorySnapshots.reduce((max, snapshot) => snapshot.heapUsed > max.heapUsed ? snapshot : max);
+        const totalHeap = this.memorySnapshots.reduce((sum, snapshot) => sum + snapshot.heapUsed, 0);
+        const totalRss = this.memorySnapshots.reduce((sum, snapshot) => sum + snapshot.rss, 0);
+        const average = {
+            heapUsed: totalHeap / this.memorySnapshots.length,
+            heapTotal: this.memorySnapshots.reduce((sum, s) => sum + s.heapTotal, 0) / this.memorySnapshots.length,
+            rss: totalRss / this.memorySnapshots.length,
+            external: this.memorySnapshots.reduce((sum, s) => sum + s.external, 0) / this.memorySnapshots.length,
+            timestamp: new Date()
+        };
+        // Calculate growth rate (MB per minute)
+        let growthRate = 0;
+        if (this.memorySnapshots.length > 1) {
+            const oldest = this.memorySnapshots[0];
+            const timeDiff = (current.timestamp.getTime() - oldest.timestamp.getTime()) / 60000; // minutes
+            const memoryDiff = (current.heapUsed - oldest.heapUsed) / (1024 * 1024); // MB
+            growthRate = timeDiff > 0 ? memoryDiff / timeDiff : 0;
+        }
+        return {
+            currentUsage: current,
+            peakUsage: peak,
+            averageUsage: average,
+            growthRate
+        };
+    }
+    /**
+     * Get slow queries with analysis
+     */
+    getSlowQueries(limit = 10) {
+        return this.slowQueries
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, limit);
+    }
+    /**
+     * Analyze performance trends
+     */
+    analyzeTrends() {
+        const recommendations = [];
+        // Analyze search performance trend
+        let performanceTrend = 'stable';
+        if (this.searchMetrics.length > 10) {
+            const recent = this.searchMetrics.slice(-10).map(m => m.duration);
+            const older = this.searchMetrics.slice(-20, -10).map(m => m.duration);
+            if (recent.length > 0 && older.length > 0) {
+                const recentAvg = recent.reduce((sum, t) => sum + t, 0) / recent.length;
+                const olderAvg = older.reduce((sum, t) => sum + t, 0) / older.length;
+                if (recentAvg > olderAvg * 1.2) {
+                    performanceTrend = 'degrading';
+                    recommendations.push('Search performance is degrading. Consider cache optimization or index rebuilding.');
+                }
+                else if (recentAvg < olderAvg * 0.8) {
+                    performanceTrend = 'improving';
+                }
+            }
+        }
+        // Analyze memory trend
+        const memoryStats = this.getMemoryStats();
+        let memoryTrend = 'stable';
+        if (memoryStats.growthRate > 1) { // Growing by more than 1MB/minute
+            memoryTrend = 'growing';
+            recommendations.push('Memory usage is growing rapidly. Consider cache cleanup or memory limits.');
+        }
+        else if (memoryStats.growthRate < -1) {
+            memoryTrend = 'shrinking';
+        }
+        // Cache performance recommendations
+        const cacheStats = this.aggregateCacheStats();
+        if (cacheStats.hitRate < 0.6) {
+            recommendations.push('Cache hit rate is low. Consider adjusting cache size or TTL settings.');
+        }
+        // Slow query recommendations
+        if (this.slowQueries.length > 10) {
+            recommendations.push('Multiple slow queries detected. Consider query optimization or increased caching.');
+        }
+        return {
+            performanceTrend,
+            memoryTrend,
+            recommendations
+        };
+    }
+    /**
+     * Reset all performance metrics
+     */
+    reset() {
+        this.searchMetrics = [];
+        this.slowQueries = [];
+        this.memorySnapshots = [];
+        this.cacheMetrics.clear();
+        logger.info('Performance metrics reset');
+    }
+    /**
+     * Export metrics for external analysis
+     */
+    exportMetrics() {
+        const data = {
+            searchMetrics: this.searchMetrics,
+            slowQueries: this.slowQueries,
+            memorySnapshots: this.memorySnapshots,
+            cacheMetrics: Object.fromEntries(this.cacheMetrics),
+            exportTimestamp: new Date().toISOString()
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    // Private methods
+    recordSlowQuery(query) {
+        this.slowQueries.push(query);
+        // Trim slow queries history
+        if (this.slowQueries.length > this.maxSlowQueries) {
+            this.slowQueries = this.slowQueries.slice(-this.maxSlowQueries);
+        }
+    }
+    startMemoryMonitoring() {
+        if (this.memoryMonitorInterval) {
+            clearInterval(this.memoryMonitorInterval);
+        }
+        this.memoryMonitorInterval = setInterval(() => {
+            if (this.isMonitoring) {
+                const snapshot = this.takeMemorySnapshot();
+                this.memorySnapshots.push(snapshot);
+                // Trim memory snapshots (keep last 200)
+                if (this.memorySnapshots.length > 200) {
+                    this.memorySnapshots = this.memorySnapshots.slice(-200);
+                }
+            }
+        }, this.memorySnapshotInterval);
+    }
+    takeMemorySnapshot() {
+        const memUsage = process.memoryUsage();
+        return {
+            heapUsed: memUsage.heapUsed,
+            heapTotal: memUsage.heapTotal,
+            rss: memUsage.rss,
+            external: memUsage.external,
+            timestamp: new Date()
+        };
+    }
+    aggregateCacheStats() {
+        if (this.cacheMetrics.size === 0) {
+            return {
+                hitRate: 0,
+                avgHitTime: 0,
+                avgMissTime: 0,
+                totalHits: 0,
+                totalMisses: 0,
+                evictions: 0
+            };
+        }
+        let totalHits = 0;
+        let totalMisses = 0;
+        let totalEvictions = 0;
+        let weightedHitTime = 0;
+        let weightedMissTime = 0;
+        for (const stats of this.cacheMetrics.values()) {
+            totalHits += stats.totalHits;
+            totalMisses += stats.totalMisses;
+            totalEvictions += stats.evictions;
+            weightedHitTime += stats.avgHitTime * stats.totalHits;
+            weightedMissTime += stats.avgMissTime * stats.totalMisses;
+        }
+        return {
+            hitRate: totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0,
+            avgHitTime: totalHits > 0 ? weightedHitTime / totalHits : 0,
+            avgMissTime: totalMisses > 0 ? weightedMissTime / totalMisses : 0,
+            totalHits,
+            totalMisses,
+            evictions: totalEvictions
+        };
+    }
+    getSystemStats() {
+        const os = require('os');
+        return {
+            cpuUsage: process.cpuUsage().user / 1000000, // Convert to seconds
+            loadAverage: os.loadavg(),
+            freeMemory: os.freemem(),
+            totalMemory: os.totalmem(),
+            uptime: process.uptime()
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PerformanceMonitor.js","sourceRoot":"","sources":["../../src/utils/PerformanceMonitor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive Performance Monitoring System\n * Tracks search times, memory usage, cache performance, and system metrics\n */\n\nimport { logger } from './logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\nexport interface PerformanceMetrics {\n  searchTimes: number[];\n  memoryUsage: MemoryUsage[];\n  cacheStats: CachePerformance;\n  systemStats: SystemStats;\n  timestamp: Date;\n}\n\nexport interface MemoryUsage {\n  heapUsed: number;\n  heapTotal: number;\n  rss: number;\n  external: number;\n  timestamp: Date;\n}\n\nexport interface CachePerformance {\n  hitRate: number;\n  avgHitTime: number;\n  avgMissTime: number;\n  totalHits: number;\n  totalMisses: number;\n  evictions: number;\n}\n\nexport interface SystemStats {\n  cpuUsage: number;\n  loadAverage: number[];\n  freeMemory: number;\n  totalMemory: number;\n  uptime: number;\n}\n\nexport interface SearchMetrics {\n  query: string;\n  duration: number;\n  resultCount: number;\n  sources: string[];\n  cacheHit: boolean;\n  memoryBefore: number;\n  memoryAfter: number;\n  timestamp: Date;\n}\n\nexport interface SlowQuery {\n  query: string;\n  duration: number;\n  threshold: number;\n  sources: string[];\n  resultCount: number;\n  memoryUsage: number;\n  timestamp: Date;\n}\n\nexport class PerformanceMonitor {\n  private static instance: PerformanceMonitor | null = null;\n\n  private searchMetrics: SearchMetrics[] = [];\n  private slowQueries: SlowQuery[] = [];\n  private memorySnapshots: MemoryUsage[] = [];\n  private cacheMetrics: Map<string, CachePerformance> = new Map();\n\n  // Configuration\n  private readonly maxMetricsHistory = 1000;\n  private readonly slowQueryThreshold = 100; // ms\n  private readonly memorySnapshotInterval = 30000; // 30 seconds\n  private readonly maxSlowQueries = 100;\n\n  // Timers and intervals\n  private memoryMonitorInterval?: NodeJS.Timeout;\n  private isMonitoring = false;\n\n  private constructor() {\n    this.startMemoryMonitoring();\n  }\n\n  public static getInstance(): PerformanceMonitor {\n    if (!this.instance) {\n      this.instance = new PerformanceMonitor();\n    }\n    return this.instance;\n  }\n\n  /**\n   * Start performance monitoring\n   */\n  startMonitoring(): void {\n    if (this.isMonitoring) {\n      return;\n    }\n\n    this.isMonitoring = true;\n    this.startMemoryMonitoring();\n    \n    logger.info('Performance monitoring started', {\n      slowQueryThreshold: this.slowQueryThreshold,\n      maxMetricsHistory: this.maxMetricsHistory\n    });\n  }\n\n  /**\n   * Stop performance monitoring\n   */\n  stopMonitoring(): void {\n    this.isMonitoring = false;\n    \n    if (this.memoryMonitorInterval) {\n      clearInterval(this.memoryMonitorInterval);\n      this.memoryMonitorInterval = undefined;\n    }\n\n    logger.info('Performance monitoring stopped');\n  }\n\n  /**\n   * Record search performance metrics\n   */\n  recordSearch(metrics: SearchMetrics): void {\n    if (!this.isMonitoring) {\n      return;\n    }\n\n    // Normalize query string to prevent Unicode-based attacks\n    const validationResult = UnicodeValidator.normalize(metrics.query);\n    const normalizedMetrics = {\n      ...metrics,\n      query: validationResult.normalizedContent\n    };\n\n    this.searchMetrics.push(normalizedMetrics);\n\n    // Check if it's a slow query (use normalized metrics)\n    if (normalizedMetrics.duration > this.slowQueryThreshold) {\n      this.recordSlowQuery({\n        query: normalizedMetrics.query,\n        duration: normalizedMetrics.duration,\n        threshold: this.slowQueryThreshold,\n        sources: normalizedMetrics.sources,\n        resultCount: normalizedMetrics.resultCount,\n        memoryUsage: normalizedMetrics.memoryAfter,\n        timestamp: normalizedMetrics.timestamp\n      });\n    }\n\n    // Trim history if needed\n    if (this.searchMetrics.length > this.maxMetricsHistory) {\n      this.searchMetrics = this.searchMetrics.slice(-this.maxMetricsHistory);\n    }\n\n    // Log significant performance events (use normalized metrics)\n    if (normalizedMetrics.duration > this.slowQueryThreshold * 2) {\n      logger.warn('Very slow search detected', {\n        query: normalizedMetrics.query.substring(0, 50),\n        duration: normalizedMetrics.duration,\n        resultCount: normalizedMetrics.resultCount,\n        sources: normalizedMetrics.sources\n      });\n    }\n  }\n\n  /**\n   * Record cache performance metrics\n   */\n  recordCachePerformance(cacheName: string, stats: CachePerformance): void {\n    if (!this.isMonitoring) {\n      return;\n    }\n\n    // Normalize cache name to prevent Unicode-based attacks\n    const validationResult = UnicodeValidator.normalize(cacheName);\n    const normalizedCacheName = validationResult.normalizedContent;\n\n    this.cacheMetrics.set(normalizedCacheName, stats);\n\n    // Log cache performance warnings (use normalized cache name)\n    if (stats.hitRate < 0.5) {\n      logger.warn('Low cache hit rate detected', {\n        cache: normalizedCacheName,\n        hitRate: stats.hitRate,\n        totalOperations: stats.totalHits + stats.totalMisses\n      });\n    }\n  }\n\n  /**\n   * Get comprehensive performance metrics\n   */\n  getMetrics(): PerformanceMetrics {\n    return {\n      searchTimes: this.searchMetrics.map(m => m.duration),\n      memoryUsage: this.memorySnapshots.slice(-100), // Last 100 snapshots\n      cacheStats: this.aggregateCacheStats(),\n      systemStats: this.getSystemStats(),\n      timestamp: new Date()\n    };\n  }\n\n  /**\n   * Get search performance statistics\n   */\n  getSearchStats(): {\n    totalSearches: number;\n    averageTime: number;\n    medianTime: number;\n    p95Time: number;\n    p99Time: number;\n    slowQueries: number;\n    cacheHitRate: number;\n  } {\n    if (this.searchMetrics.length === 0) {\n      return {\n        totalSearches: 0,\n        averageTime: 0,\n        medianTime: 0,\n        p95Time: 0,\n        p99Time: 0,\n        slowQueries: 0,\n        cacheHitRate: 0\n      };\n    }\n\n    const times = this.searchMetrics.map(m => m.duration).sort((a, b) => a - b);\n    const cacheHits = this.searchMetrics.filter(m => m.cacheHit).length;\n\n    return {\n      totalSearches: this.searchMetrics.length,\n      averageTime: times.reduce((sum, time) => sum + time, 0) / times.length,\n      medianTime: times[Math.floor(times.length / 2)],\n      p95Time: times[Math.floor(times.length * 0.95)],\n      p99Time: times[Math.floor(times.length * 0.99)],\n      slowQueries: this.slowQueries.length,\n      cacheHitRate: cacheHits / this.searchMetrics.length\n    };\n  }\n\n  /**\n   * Get memory usage statistics\n   */\n  getMemoryStats(): {\n    currentUsage: MemoryUsage;\n    peakUsage: MemoryUsage;\n    averageUsage: MemoryUsage;\n    growthRate: number; // MB per minute\n  } {\n    if (this.memorySnapshots.length === 0) {\n      const current = this.takeMemorySnapshot();\n      return {\n        currentUsage: current,\n        peakUsage: current,\n        averageUsage: current,\n        growthRate: 0\n      };\n    }\n\n    const current = this.memorySnapshots[this.memorySnapshots.length - 1];\n    const peak = this.memorySnapshots.reduce((max, snapshot) => \n      snapshot.heapUsed > max.heapUsed ? snapshot : max\n    );\n\n    const totalHeap = this.memorySnapshots.reduce((sum, snapshot) => sum + snapshot.heapUsed, 0);\n    const totalRss = this.memorySnapshots.reduce((sum, snapshot) => sum + snapshot.rss, 0);\n    const average: MemoryUsage = {\n      heapUsed: totalHeap / this.memorySnapshots.length,\n      heapTotal: this.memorySnapshots.reduce((sum, s) => sum + s.heapTotal, 0) / this.memorySnapshots.length,\n      rss: totalRss / this.memorySnapshots.length,\n      external: this.memorySnapshots.reduce((sum, s) => sum + s.external, 0) / this.memorySnapshots.length,\n      timestamp: new Date()\n    };\n\n    // Calculate growth rate (MB per minute)\n    let growthRate = 0;\n    if (this.memorySnapshots.length > 1) {\n      const oldest = this.memorySnapshots[0];\n      const timeDiff = (current.timestamp.getTime() - oldest.timestamp.getTime()) / 60000; // minutes\n      const memoryDiff = (current.heapUsed - oldest.heapUsed) / (1024 * 1024); // MB\n      growthRate = timeDiff > 0 ? memoryDiff / timeDiff : 0;\n    }\n\n    return {\n      currentUsage: current,\n      peakUsage: peak,\n      averageUsage: average,\n      growthRate\n    };\n  }\n\n  /**\n   * Get slow queries with analysis\n   */\n  getSlowQueries(limit: number = 10): SlowQuery[] {\n    return this.slowQueries\n      .sort((a, b) => b.duration - a.duration)\n      .slice(0, limit);\n  }\n\n  /**\n   * Analyze performance trends\n   */\n  analyzeTrends(): {\n    performanceTrend: 'improving' | 'degrading' | 'stable';\n    memoryTrend: 'growing' | 'shrinking' | 'stable';\n    recommendations: string[];\n  } {\n    const recommendations: string[] = [];\n    \n    // Analyze search performance trend\n    let performanceTrend: 'improving' | 'degrading' | 'stable' = 'stable';\n    if (this.searchMetrics.length > 10) {\n      const recent = this.searchMetrics.slice(-10).map(m => m.duration);\n      const older = this.searchMetrics.slice(-20, -10).map(m => m.duration);\n      \n      if (recent.length > 0 && older.length > 0) {\n        const recentAvg = recent.reduce((sum, t) => sum + t, 0) / recent.length;\n        const olderAvg = older.reduce((sum, t) => sum + t, 0) / older.length;\n        \n        if (recentAvg > olderAvg * 1.2) {\n          performanceTrend = 'degrading';\n          recommendations.push('Search performance is degrading. Consider cache optimization or index rebuilding.');\n        } else if (recentAvg < olderAvg * 0.8) {\n          performanceTrend = 'improving';\n        }\n      }\n    }\n\n    // Analyze memory trend\n    const memoryStats = this.getMemoryStats();\n    let memoryTrend: 'growing' | 'shrinking' | 'stable' = 'stable';\n    \n    if (memoryStats.growthRate > 1) { // Growing by more than 1MB/minute\n      memoryTrend = 'growing';\n      recommendations.push('Memory usage is growing rapidly. Consider cache cleanup or memory limits.');\n    } else if (memoryStats.growthRate < -1) {\n      memoryTrend = 'shrinking';\n    }\n\n    // Cache performance recommendations\n    const cacheStats = this.aggregateCacheStats();\n    if (cacheStats.hitRate < 0.6) {\n      recommendations.push('Cache hit rate is low. Consider adjusting cache size or TTL settings.');\n    }\n\n    // Slow query recommendations\n    if (this.slowQueries.length > 10) {\n      recommendations.push('Multiple slow queries detected. Consider query optimization or increased caching.');\n    }\n\n    return {\n      performanceTrend,\n      memoryTrend,\n      recommendations\n    };\n  }\n\n  /**\n   * Reset all performance metrics\n   */\n  reset(): void {\n    this.searchMetrics = [];\n    this.slowQueries = [];\n    this.memorySnapshots = [];\n    this.cacheMetrics.clear();\n    \n    logger.info('Performance metrics reset');\n  }\n\n  /**\n   * Export metrics for external analysis\n   */\n  exportMetrics(): string {\n    const data = {\n      searchMetrics: this.searchMetrics,\n      slowQueries: this.slowQueries,\n      memorySnapshots: this.memorySnapshots,\n      cacheMetrics: Object.fromEntries(this.cacheMetrics),\n      exportTimestamp: new Date().toISOString()\n    };\n\n    return JSON.stringify(data, null, 2);\n  }\n\n  // Private methods\n\n  private recordSlowQuery(query: SlowQuery): void {\n    this.slowQueries.push(query);\n\n    // Trim slow queries history\n    if (this.slowQueries.length > this.maxSlowQueries) {\n      this.slowQueries = this.slowQueries.slice(-this.maxSlowQueries);\n    }\n  }\n\n  private startMemoryMonitoring(): void {\n    if (this.memoryMonitorInterval) {\n      clearInterval(this.memoryMonitorInterval);\n    }\n\n    this.memoryMonitorInterval = setInterval(() => {\n      if (this.isMonitoring) {\n        const snapshot = this.takeMemorySnapshot();\n        this.memorySnapshots.push(snapshot);\n\n        // Trim memory snapshots (keep last 200)\n        if (this.memorySnapshots.length > 200) {\n          this.memorySnapshots = this.memorySnapshots.slice(-200);\n        }\n      }\n    }, this.memorySnapshotInterval);\n  }\n\n  private takeMemorySnapshot(): MemoryUsage {\n    const memUsage = process.memoryUsage();\n    return {\n      heapUsed: memUsage.heapUsed,\n      heapTotal: memUsage.heapTotal,\n      rss: memUsage.rss,\n      external: memUsage.external,\n      timestamp: new Date()\n    };\n  }\n\n  private aggregateCacheStats(): CachePerformance {\n    if (this.cacheMetrics.size === 0) {\n      return {\n        hitRate: 0,\n        avgHitTime: 0,\n        avgMissTime: 0,\n        totalHits: 0,\n        totalMisses: 0,\n        evictions: 0\n      };\n    }\n\n    let totalHits = 0;\n    let totalMisses = 0;\n    let totalEvictions = 0;\n    let weightedHitTime = 0;\n    let weightedMissTime = 0;\n\n    for (const stats of this.cacheMetrics.values()) {\n      totalHits += stats.totalHits;\n      totalMisses += stats.totalMisses;\n      totalEvictions += stats.evictions;\n      weightedHitTime += stats.avgHitTime * stats.totalHits;\n      weightedMissTime += stats.avgMissTime * stats.totalMisses;\n    }\n\n    return {\n      hitRate: totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0,\n      avgHitTime: totalHits > 0 ? weightedHitTime / totalHits : 0,\n      avgMissTime: totalMisses > 0 ? weightedMissTime / totalMisses : 0,\n      totalHits,\n      totalMisses,\n      evictions: totalEvictions\n    };\n  }\n\n  private getSystemStats(): SystemStats {\n    const os = require('os');\n    \n    return {\n      cpuUsage: process.cpuUsage().user / 1000000, // Convert to seconds\n      loadAverage: os.loadavg(),\n      freeMemory: os.freemem(),\n      totalMemory: os.totalmem(),\n      uptime: process.uptime()\n    };\n  }\n}"]}

package/dist/utils/RateLimiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimiter.d.ts","sourceRoot":"","sources":["../../src/utils/RateLimiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,MAAM,EAAE,iBAAiB;IAsBrC;;;OAGG;IACH,UAAU,IAAI,eAAe;IA0C7B;;;OAGG;IACH,YAAY,IAAI,IAAI;IAUpB;;OAEG;IACH,SAAS,IAAI,eAAe;IAW5B;;;OAGG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,QAAQ,IAAI,MAAM;CAKnB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B;;OAEG;IACH,MAAM,CAAC,mBAAmB,IAAI,WAAW;IAQzC;;;OAGG;IACH,MAAM,CAAC,wBAAwB,IAAI,WAAW;IAQ9C;;;OAGG;IACH,MAAM,CAAC,mBAAmB,IAAI,WAAW;CAO1C"}

package/dist/utils/RateLimiter.js

@@ -0,0 +1,172 @@
+/**
+ * RateLimiter - Implements rate limiting for API calls to prevent abuse
+ *
+ * Features:
+ * - Token bucket algorithm for flexible rate limiting
+ * - Configurable limits per time window
+ * - Memory-efficient implementation
+ * - Thread-safe for concurrent requests
+ */
+export class RateLimiter {
+    tokens;
+    lastRefill;
+    lastRequest;
+    maxTokens;
+    refillRate;
+    minDelay;
+    constructor(config) {
+        if (config.maxRequests <= 0) {
+            throw new Error('maxRequests must be positive');
+        }
+        if (config.windowMs <= 0) {
+            throw new Error('windowMs must be positive');
+        }
+        this.maxTokens = config.maxRequests;
+        this.tokens = this.maxTokens;
+        this.refillRate = this.maxTokens / config.windowMs;
+        // Validate refill rate to prevent division by zero
+        if (this.refillRate <= 0 || !isFinite(this.refillRate)) {
+            throw new Error('Invalid configuration: refill rate must be positive and finite');
+        }
+        this.lastRefill = Date.now();
+        this.lastRequest = 0;
+        this.minDelay = config.minDelayMs || 0;
+    }
+    /**
+     * Check if a request is allowed under the rate limit
+     * @returns Status object indicating if request is allowed
+     */
+    checkLimit() {
+        const now = Date.now();
+        // Refill tokens based on time elapsed
+        this.refillTokens(now);
+        // Check minimum delay between requests
+        if (this.minDelay > 0 && this.lastRequest > 0) {
+            const timeSinceLastRequest = now - this.lastRequest;
+            if (timeSinceLastRequest < this.minDelay) {
+                const retryAfterMs = this.minDelay - timeSinceLastRequest;
+                return {
+                    allowed: false,
+                    retryAfterMs,
+                    remainingTokens: Math.floor(this.tokens),
+                    resetTime: new Date(now + retryAfterMs)
+                };
+            }
+        }
+        // Check if we have tokens available
+        if (this.tokens < 1) {
+            // Calculate when the next token will be available
+            const tokensNeeded = 1 - this.tokens;
+            const msUntilNextToken = tokensNeeded / this.refillRate;
+            return {
+                allowed: false,
+                retryAfterMs: Math.ceil(msUntilNextToken),
+                remainingTokens: 0,
+                resetTime: new Date(now + msUntilNextToken)
+            };
+        }
+        // Request is allowed
+        return {
+            allowed: true,
+            remainingTokens: Math.floor(this.tokens),
+            resetTime: this.getResetTime()
+        };
+    }
+    /**
+     * Consume a token for an allowed request
+     * Should be called after checkLimit() returns allowed: true
+     */
+    consumeToken() {
+        const now = Date.now();
+        this.refillTokens(now);
+        if (this.tokens >= 1) {
+            this.tokens -= 1;
+            this.lastRequest = now;
+        }
+    }
+    /**
+     * Get current rate limit status without consuming a token
+     */
+    getStatus() {
+        const now = Date.now();
+        this.refillTokens(now);
+        return {
+            allowed: this.tokens >= 1,
+            remainingTokens: Math.floor(this.tokens),
+            resetTime: this.getResetTime()
+        };
+    }
+    /**
+     * Reset the rate limiter to full capacity
+     * Useful for testing or manual intervention
+     */
+    reset() {
+        this.tokens = this.maxTokens;
+        this.lastRefill = Date.now();
+        this.lastRequest = 0;
+    }
+    /**
+     * Refill tokens based on time elapsed
+     */
+    refillTokens(now) {
+        const timeSinceLastRefill = now - this.lastRefill;
+        const tokensToAdd = timeSinceLastRefill * this.refillRate;
+        this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+        this.lastRefill = now;
+    }
+    /**
+     * Calculate when the rate limit window will reset
+     */
+    getResetTime() {
+        const now = Date.now();
+        const tokensToFull = this.maxTokens - this.tokens;
+        const msUntilFull = tokensToFull / this.refillRate;
+        return new Date(now + msUntilFull);
+    }
+    /**
+     * Get human-readable rate limit information
+     */
+    toString() {
+        const status = this.getStatus();
+        return `RateLimit: ${status.remainingTokens}/${this.maxTokens} tokens, ` +
+            `resets at ${status.resetTime.toISOString()}`;
+    }
+}
+/**
+ * Factory function to create common rate limiters
+ */
+export class RateLimiterFactory {
+    /**
+     * GitHub API rate limiter (60 requests per hour for unauthenticated)
+     */
+    static createGitHubLimiter() {
+        return new RateLimiter({
+            maxRequests: 60,
+            windowMs: 60 * 60 * 1000, // 1 hour
+            minDelayMs: 1000 // 1 second minimum between requests
+        });
+    }
+    /**
+     * Conservative rate limiter for update checks
+     * Allows 10 checks per hour with 30 second minimum delay
+     */
+    static createUpdateCheckLimiter() {
+        return new RateLimiter({
+            maxRequests: 10,
+            windowMs: 60 * 60 * 1000, // 1 hour
+            minDelayMs: 30 * 1000 // 30 seconds between checks
+        });
+    }
+    /**
+     * Strict rate limiter for sensitive operations
+     * Allows 5 requests per hour with 1 minute minimum delay
+     */
+    static createStrictLimiter() {
+        return new RateLimiter({
+            maxRequests: 5,
+            windowMs: 60 * 60 * 1000, // 1 hour
+            minDelayMs: 60 * 1000 // 1 minute between requests
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RateLimiter.js","sourceRoot":"","sources":["../../src/utils/RateLimiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAeH,MAAM,OAAO,WAAW;IACd,MAAM,CAAS;IACf,UAAU,CAAS;IACnB,WAAW,CAAS;IACX,SAAS,CAAS;IAClB,UAAU,CAAS;IACnB,QAAQ,CAAS;IAElC,YAAY,MAAyB;QACnC,IAAI,MAAM,CAAC,WAAW,IAAI,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC;QACpC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC;QAEnD,mDAAmD;QACnD,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACvD,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;QACpF,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACH,UAAU;QACR,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,sCAAsC;QACtC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAEvB,uCAAuC;QACvC,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,IAAI,CAAC,WAAW,GAAG,CAAC,EAAE,CAAC;YAC9C,MAAM,oBAAoB,GAAG,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;YACpD,IAAI,oBAAoB,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACzC,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,GAAG,oBAAoB,CAAC;gBAC1D,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,YAAY;oBACZ,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;oBACxC,SAAS,EAAE,IAAI,IAAI,CAAC,GAAG,GAAG,YAAY,CAAC;iBACxC,CAAC;YACJ,CAAC;QACH,CAAC;QAED,oCAAoC;QACpC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,kDAAkD;YAClD,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;YACrC,MAAM,gBAAgB,GAAG,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC;YAExD,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC;gBACzC,eAAe,EAAE,CAAC;gBAClB,SAAS,EAAE,IAAI,IAAI,CAAC,GAAG,GAAG,gBAAgB,CAAC;aAC5C,CAAC;QACJ,CAAC;QAED,qBAAqB;QACrB,OAAO;YACL,OAAO,EAAE,IAAI;YACb,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;YACxC,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE;SAC/B,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,YAAY;QACV,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAEvB,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YACrB,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;YACjB,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;QACzB,CAAC;IACH,CAAC;IAED;;OAEG;IACH,SAAS;QACP,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAEvB,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,MAAM,IAAI,CAAC;YACzB,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;YACxC,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE;SAC/B,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;IACvB,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,GAAW;QAC9B,MAAM,mBAAmB,GAAG,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC;QAClD,MAAM,WAAW,GAAG,mBAAmB,GAAG,IAAI,CAAC,UAAU,CAAC;QAE1D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;IACxB,CAAC;IAED;;OAEG;IACK,YAAY;QAClB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC;QAClD,MAAM,WAAW,GAAG,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC;QACnD,OAAO,IAAI,IAAI,CAAC,GAAG,GAAG,WAAW,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,OAAO,cAAc,MAAM,CAAC,eAAe,IAAI,IAAI,CAAC,SAAS,WAAW;YACjE,aAAa,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE,CAAC;IACvD,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,kBAAkB;IAC7B;;OAEG;IACH,MAAM,CAAC,mBAAmB;QACxB,OAAO,IAAI,WAAW,CAAC;YACrB,WAAW,EAAE,EAAE;YACf,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,SAAS;YACnC,UAAU,EAAE,IAAI,CAAC,oCAAoC;SACtD,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,wBAAwB;QAC7B,OAAO,IAAI,WAAW,CAAC;YACrB,WAAW,EAAE,EAAE;YACf,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,SAAS;YACnC,UAAU,EAAE,EAAE,GAAG,IAAI,CAAC,4BAA4B;SACnD,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,mBAAmB;QACxB,OAAO,IAAI,WAAW,CAAC;YACrB,WAAW,EAAE,CAAC;YACd,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,SAAS;YACnC,UAAU,EAAE,EAAE,GAAG,IAAI,CAAC,4BAA4B;SACnD,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["/**\n * RateLimiter - Implements rate limiting for API calls to prevent abuse\n * \n * Features:\n * - Token bucket algorithm for flexible rate limiting\n * - Configurable limits per time window\n * - Memory-efficient implementation\n * - Thread-safe for concurrent requests\n */\n\nexport interface RateLimiterConfig {\n  maxRequests: number;      // Maximum requests allowed\n  windowMs: number;         // Time window in milliseconds\n  minDelayMs?: number;      // Minimum delay between requests (optional)\n}\n\nexport interface RateLimitStatus {\n  allowed: boolean;\n  retryAfterMs?: number;\n  remainingTokens: number;\n  resetTime: Date;\n}\n\nexport class RateLimiter {\n  private tokens: number;\n  private lastRefill: number;\n  private lastRequest: number;\n  private readonly maxTokens: number;\n  private readonly refillRate: number;\n  private readonly minDelay: number;\n\n  constructor(config: RateLimiterConfig) {\n    if (config.maxRequests <= 0) {\n      throw new Error('maxRequests must be positive');\n    }\n    if (config.windowMs <= 0) {\n      throw new Error('windowMs must be positive');\n    }\n\n    this.maxTokens = config.maxRequests;\n    this.tokens = this.maxTokens;\n    this.refillRate = this.maxTokens / config.windowMs;\n    \n    // Validate refill rate to prevent division by zero\n    if (this.refillRate <= 0 || !isFinite(this.refillRate)) {\n      throw new Error('Invalid configuration: refill rate must be positive and finite');\n    }\n    \n    this.lastRefill = Date.now();\n    this.lastRequest = 0;\n    this.minDelay = config.minDelayMs || 0;\n  }\n\n  /**\n   * Check if a request is allowed under the rate limit\n   * @returns Status object indicating if request is allowed\n   */\n  checkLimit(): RateLimitStatus {\n    const now = Date.now();\n    \n    // Refill tokens based on time elapsed\n    this.refillTokens(now);\n\n    // Check minimum delay between requests\n    if (this.minDelay > 0 && this.lastRequest > 0) {\n      const timeSinceLastRequest = now - this.lastRequest;\n      if (timeSinceLastRequest < this.minDelay) {\n        const retryAfterMs = this.minDelay - timeSinceLastRequest;\n        return {\n          allowed: false,\n          retryAfterMs,\n          remainingTokens: Math.floor(this.tokens),\n          resetTime: new Date(now + retryAfterMs)\n        };\n      }\n    }\n\n    // Check if we have tokens available\n    if (this.tokens < 1) {\n      // Calculate when the next token will be available\n      const tokensNeeded = 1 - this.tokens;\n      const msUntilNextToken = tokensNeeded / this.refillRate;\n      \n      return {\n        allowed: false,\n        retryAfterMs: Math.ceil(msUntilNextToken),\n        remainingTokens: 0,\n        resetTime: new Date(now + msUntilNextToken)\n      };\n    }\n\n    // Request is allowed\n    return {\n      allowed: true,\n      remainingTokens: Math.floor(this.tokens),\n      resetTime: this.getResetTime()\n    };\n  }\n\n  /**\n   * Consume a token for an allowed request\n   * Should be called after checkLimit() returns allowed: true\n   */\n  consumeToken(): void {\n    const now = Date.now();\n    this.refillTokens(now);\n    \n    if (this.tokens >= 1) {\n      this.tokens -= 1;\n      this.lastRequest = now;\n    }\n  }\n\n  /**\n   * Get current rate limit status without consuming a token\n   */\n  getStatus(): RateLimitStatus {\n    const now = Date.now();\n    this.refillTokens(now);\n\n    return {\n      allowed: this.tokens >= 1,\n      remainingTokens: Math.floor(this.tokens),\n      resetTime: this.getResetTime()\n    };\n  }\n\n  /**\n   * Reset the rate limiter to full capacity\n   * Useful for testing or manual intervention\n   */\n  reset(): void {\n    this.tokens = this.maxTokens;\n    this.lastRefill = Date.now();\n    this.lastRequest = 0;\n  }\n\n  /**\n   * Refill tokens based on time elapsed\n   */\n  private refillTokens(now: number): void {\n    const timeSinceLastRefill = now - this.lastRefill;\n    const tokensToAdd = timeSinceLastRefill * this.refillRate;\n    \n    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);\n    this.lastRefill = now;\n  }\n\n  /**\n   * Calculate when the rate limit window will reset\n   */\n  private getResetTime(): Date {\n    const now = Date.now();\n    const tokensToFull = this.maxTokens - this.tokens;\n    const msUntilFull = tokensToFull / this.refillRate;\n    return new Date(now + msUntilFull);\n  }\n\n  /**\n   * Get human-readable rate limit information\n   */\n  toString(): string {\n    const status = this.getStatus();\n    return `RateLimit: ${status.remainingTokens}/${this.maxTokens} tokens, ` +\n           `resets at ${status.resetTime.toISOString()}`;\n  }\n}\n\n/**\n * Factory function to create common rate limiters\n */\nexport class RateLimiterFactory {\n  /**\n   * GitHub API rate limiter (60 requests per hour for unauthenticated)\n   */\n  static createGitHubLimiter(): RateLimiter {\n    return new RateLimiter({\n      maxRequests: 60,\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 1000 // 1 second minimum between requests\n    });\n  }\n\n  /**\n   * Conservative rate limiter for update checks\n   * Allows 10 checks per hour with 30 second minimum delay\n   */\n  static createUpdateCheckLimiter(): RateLimiter {\n    return new RateLimiter({\n      maxRequests: 10,\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 30 * 1000 // 30 seconds between checks\n    });\n  }\n\n  /**\n   * Strict rate limiter for sensitive operations\n   * Allows 5 requests per hour with 1 minute minimum delay\n   */\n  static createStrictLimiter(): RateLimiter {\n    return new RateLimiter({\n      maxRequests: 5,\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 60 * 1000 // 1 minute between requests\n    });\n  }\n}"]}