@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/utils/GitHubRateLimiter.js

@@ -0,0 +1,315 @@
+/**
+ * GitHubRateLimiter - Specialized rate limiter for GitHub API calls
+ *
+ * Features:
+ * - Respects GitHub's authenticated (5000/hour) and unauthenticated (60/hour) limits
+ * - Client-side queuing when approaching limits
+ * - Request prioritization for critical operations
+ * - Comprehensive logging for quota management
+ * - Early termination when exact matches are found
+ */
+import { RateLimiter } from './RateLimiter.js';
+import { GITHUB_API_RATE_LIMITS } from '../config/portfolio-constants.js';
+import { TokenManager } from '../security/tokenManager.js';
+import { logger } from './logger.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+export class GitHubRateLimiter {
+    rateLimiter;
+    requestQueue = [];
+    processing = false;
+    lastRateLimitInfo;
+    isAuthenticated = false;
+    constructor() {
+        // Initialize with conservative limits - will update based on auth status
+        this.updateLimitsForAuthStatus();
+        this.setupPeriodicStatusCheck();
+    }
+    /**
+     * Update rate limits based on current authentication status
+     */
+    async updateLimitsForAuthStatus() {
+        try {
+            const token = await TokenManager.getGitHubTokenAsync();
+            const newIsAuthenticated = !!token;
+            // Only recreate rate limiter if auth status changed
+            if (newIsAuthenticated !== this.isAuthenticated) {
+                this.isAuthenticated = newIsAuthenticated;
+                const limit = this.isAuthenticated
+                    ? GITHUB_API_RATE_LIMITS.AUTHENTICATED_LIMIT
+                    : GITHUB_API_RATE_LIMITS.UNAUTHENTICATED_LIMIT;
+                // Apply buffer to stay below actual limits
+                const bufferedLimit = Math.floor(limit * GITHUB_API_RATE_LIMITS.BUFFER_PERCENTAGE);
+                const config = {
+                    maxRequests: bufferedLimit,
+                    windowMs: GITHUB_API_RATE_LIMITS.WINDOW_MS,
+                    minDelayMs: GITHUB_API_RATE_LIMITS.MIN_DELAY_MS
+                };
+                this.rateLimiter = new RateLimiter(config);
+                logger.info('GitHub rate limiter updated', {
+                    authenticated: this.isAuthenticated,
+                    limit: bufferedLimit,
+                    originalLimit: limit,
+                    bufferPercentage: GITHUB_API_RATE_LIMITS.BUFFER_PERCENTAGE
+                });
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to check authentication status for rate limiting', { error });
+            // Fall back to unauthenticated limits
+            this.isAuthenticated = false;
+            this.rateLimiter = new RateLimiter({
+                maxRequests: Math.floor(GITHUB_API_RATE_LIMITS.UNAUTHENTICATED_LIMIT * GITHUB_API_RATE_LIMITS.BUFFER_PERCENTAGE),
+                windowMs: GITHUB_API_RATE_LIMITS.WINDOW_MS,
+                minDelayMs: GITHUB_API_RATE_LIMITS.MIN_DELAY_MS
+            });
+        }
+    }
+    /**
+     * Setup periodic check for rate limit status
+     */
+    setupPeriodicStatusCheck() {
+        // Check auth status every 5 minutes
+        setInterval(() => {
+            this.updateLimitsForAuthStatus().catch(error => {
+                logger.warn('Periodic auth status check failed', { error });
+            });
+        }, 5 * 60 * 1000);
+    }
+    /**
+     * Queue a GitHub API request with rate limiting
+     * @param operation Description of the operation
+     * @param apiCall Function that makes the actual API call
+     * @param priority Request priority (high, normal, low)
+     * @returns Promise that resolves with the API response
+     */
+    async queueRequest(operation, apiCall, priority = 'normal') {
+        // SECURITY FIX (DMCP-SEC-004): Normalize Unicode in operation name to prevent injection attacks
+        const normalizedOperation = UnicodeValidator.normalize(operation);
+        if (!normalizedOperation.isValid) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'UNICODE_VALIDATION_ERROR',
+                severity: 'MEDIUM',
+                source: 'GitHubRateLimiter.queueRequest',
+                details: `Invalid Unicode in operation name: ${normalizedOperation.detectedIssues?.[0] || 'unknown error'}`
+            });
+            // Use a safe fallback for the operation name
+            operation = 'github-api-request';
+        }
+        else {
+            operation = normalizedOperation.normalizedContent;
+        }
+        const requestId = `${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        return new Promise((resolve, reject) => {
+            const request = {
+                id: requestId,
+                operation,
+                priority,
+                timestamp: Date.now(),
+                resolve: async (value) => {
+                    try {
+                        logger.debug('Executing GitHub API request', {
+                            operation,
+                            requestId,
+                            queueWaitTime: Date.now() - request.timestamp
+                        });
+                        const result = await apiCall();
+                        resolve(result);
+                        // Log successful API usage for quota tracking
+                        this.logApiUsage(operation, 'success');
+                    }
+                    catch (error) {
+                        // Check if this is a rate limit error from GitHub
+                        if (this.isGitHubRateLimitError(error)) {
+                            this.handleGitHubRateLimit(error);
+                        }
+                        reject(error);
+                        this.logApiUsage(operation, 'error', error);
+                    }
+                },
+                reject
+            };
+            // Add to queue with priority ordering
+            this.addToQueue(request);
+            this.processQueue();
+        });
+    }
+    /**
+     * Add request to queue with priority ordering
+     */
+    addToQueue(request) {
+        // Insert based on priority: high > normal > low
+        // Within same priority, maintain FIFO order
+        const priorityOrder = { high: 0, normal: 1, low: 2 };
+        let insertIndex = this.requestQueue.length;
+        for (let i = 0; i < this.requestQueue.length; i++) {
+            if (priorityOrder[request.priority] < priorityOrder[this.requestQueue[i].priority]) {
+                insertIndex = i;
+                break;
+            }
+        }
+        this.requestQueue.splice(insertIndex, 0, request);
+        logger.debug('GitHub API request queued', {
+            operation: request.operation,
+            priority: request.priority,
+            queuePosition: insertIndex,
+            totalQueued: this.requestQueue.length
+        });
+    }
+    /**
+     * Process the request queue
+     */
+    async processQueue() {
+        if (this.processing || this.requestQueue.length === 0) {
+            return;
+        }
+        this.processing = true;
+        try {
+            while (this.requestQueue.length > 0) {
+                // Update auth status periodically
+                if (Math.random() < 0.1) { // 10% chance
+                    await this.updateLimitsForAuthStatus();
+                }
+                const rateLimitStatus = this.rateLimiter.checkLimit();
+                if (!rateLimitStatus.allowed) {
+                    // Log rate limit wait
+                    logger.info('GitHub API rate limit reached, waiting', {
+                        retryAfterMs: rateLimitStatus.retryAfterMs,
+                        remainingTokens: rateLimitStatus.remainingTokens,
+                        queueLength: this.requestQueue.length,
+                        resetTime: rateLimitStatus.resetTime
+                    });
+                    // Wait for the specified time
+                    await new Promise(resolve => setTimeout(resolve, rateLimitStatus.retryAfterMs || 1000));
+                    continue;
+                }
+                // Process the next request
+                const request = this.requestQueue.shift();
+                this.rateLimiter.consumeToken();
+                // Execute the request
+                request.resolve(null); // This will trigger the actual API call
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    /**
+     * Get current rate limit status
+     */
+    getStatus() {
+        const baseStatus = this.rateLimiter.getStatus();
+        return {
+            ...baseStatus,
+            queueLength: this.requestQueue.length,
+            currentLimit: this.isAuthenticated
+                ? GITHUB_API_RATE_LIMITS.AUTHENTICATED_LIMIT
+                : GITHUB_API_RATE_LIMITS.UNAUTHENTICATED_LIMIT,
+            rateLimitInfo: this.lastRateLimitInfo
+        };
+    }
+    /**
+     * Check if an error is a GitHub rate limit error
+     */
+    isGitHubRateLimitError(error) {
+        return error?.status === 429 ||
+            error?.response?.status === 429 ||
+            (typeof error?.message === 'string' && error.message.toLowerCase().includes('rate limit'));
+    }
+    /**
+     * Handle GitHub rate limit error response
+     */
+    handleGitHubRateLimit(error) {
+        let resetTime;
+        let remainingRequests = 0;
+        // Parse rate limit headers if available
+        if (error?.response?.headers) {
+            const headers = error.response.headers;
+            const resetTimestamp = parseInt(headers['x-ratelimit-reset'] || '0');
+            const remaining = parseInt(headers['x-ratelimit-remaining'] || '0');
+            const limit = parseInt(headers['x-ratelimit-limit'] || '0');
+            if (resetTimestamp > 0) {
+                resetTime = new Date(resetTimestamp * 1000);
+            }
+            this.lastRateLimitInfo = {
+                limit,
+                remaining,
+                reset: resetTime || new Date(Date.now() + 60 * 60 * 1000), // Default to 1 hour
+                used: limit - remaining
+            };
+            remainingRequests = remaining;
+        }
+        logger.warn('GitHub API rate limit hit from server', {
+            remaining: remainingRequests,
+            resetTime,
+            queueLength: this.requestQueue.length,
+            errorMessage: error?.message
+        });
+        // Log as a security event for monitoring
+        SecurityMonitor.logSecurityEvent({
+            type: 'RATE_LIMIT_EXCEEDED',
+            severity: 'MEDIUM',
+            source: 'GitHubRateLimiter.handleGitHubRateLimit',
+            details: `GitHub API rate limit exceeded. Remaining: ${remainingRequests}, Queue: ${this.requestQueue.length}`,
+            metadata: {
+                rateLimitInfo: this.lastRateLimitInfo,
+                authenticated: this.isAuthenticated
+            }
+        });
+    }
+    /**
+     * Log API usage for monitoring and diagnostics
+     */
+    logApiUsage(operation, result, error) {
+        const status = this.getStatus();
+        logger.debug('GitHub API usage logged', {
+            operation,
+            result,
+            remainingTokens: status.remainingTokens,
+            queueLength: status.queueLength,
+            authenticated: this.isAuthenticated,
+            error: error?.message
+        });
+        // Log warning if getting close to rate limits
+        if (status.remainingTokens < 100 && this.isAuthenticated) {
+            logger.warn('Approaching GitHub API rate limit', {
+                operation,
+                remainingTokens: status.remainingTokens,
+                currentLimit: status.currentLimit,
+                recommendation: 'Consider reducing API usage frequency'
+            });
+        }
+        else if (status.remainingTokens < 10 && !this.isAuthenticated) {
+            logger.warn('Approaching GitHub API rate limit (unauthenticated)', {
+                operation,
+                remainingTokens: status.remainingTokens,
+                currentLimit: status.currentLimit,
+                recommendation: 'Consider authenticating for higher rate limits'
+            });
+        }
+    }
+    /**
+     * Clear the request queue (for testing or emergency situations)
+     */
+    clearQueue() {
+        const clearedCount = this.requestQueue.length;
+        // Reject all pending requests
+        this.requestQueue.forEach(request => {
+            request.reject(new Error('Request queue cleared'));
+        });
+        this.requestQueue = [];
+        logger.info('GitHub API request queue cleared', { clearedCount });
+    }
+    /**
+     * Reset the rate limiter (for testing)
+     */
+    reset() {
+        this.rateLimiter.reset();
+        this.clearQueue();
+        this.processing = false;
+        logger.info('GitHub rate limiter reset');
+    }
+}
+// Singleton instance for global use
+export const githubRateLimiter = new GitHubRateLimiter();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GitHubRateLimiter.js","sourceRoot":"","sources":["../../src/utils/GitHubRateLimiter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GitHubRateLimiter - Specialized rate limiter for GitHub API calls\n * \n * Features:\n * - Respects GitHub's authenticated (5000/hour) and unauthenticated (60/hour) limits\n * - Client-side queuing when approaching limits\n * - Request prioritization for critical operations\n * - Comprehensive logging for quota management\n * - Early termination when exact matches are found\n */\n\nimport { RateLimiter, RateLimiterConfig, RateLimitStatus } from './RateLimiter.js';\nimport { GITHUB_API_RATE_LIMITS } from '../config/portfolio-constants.js';\nimport { TokenManager } from '../security/tokenManager.js';\nimport { logger } from './logger.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\nexport interface GitHubRateLimitInfo {\n  limit: number;\n  remaining: number;\n  reset: Date;\n  used: number;\n}\n\nexport interface GitHubApiRequest {\n  id: string;\n  operation: string;\n  priority: 'high' | 'normal' | 'low';\n  timestamp: number;\n  resolve: (value: any) => void;\n  reject: (error: any) => void;\n}\n\nexport interface GitHubRateStatus extends RateLimitStatus {\n  queueLength: number;\n  currentLimit: number;\n  rateLimitInfo?: GitHubRateLimitInfo;\n}\n\nexport class GitHubRateLimiter {\n  private rateLimiter!: RateLimiter;\n  private requestQueue: GitHubApiRequest[] = [];\n  private processing = false;\n  private lastRateLimitInfo?: GitHubRateLimitInfo;\n  private isAuthenticated = false;\n\n  constructor() {\n    // Initialize with conservative limits - will update based on auth status\n    this.updateLimitsForAuthStatus();\n    this.setupPeriodicStatusCheck();\n  }\n\n  /**\n   * Update rate limits based on current authentication status\n   */\n  private async updateLimitsForAuthStatus(): Promise<void> {\n    try {\n      const token = await TokenManager.getGitHubTokenAsync();\n      const newIsAuthenticated = !!token;\n      \n      // Only recreate rate limiter if auth status changed\n      if (newIsAuthenticated !== this.isAuthenticated) {\n        this.isAuthenticated = newIsAuthenticated;\n        \n        const limit = this.isAuthenticated \n          ? GITHUB_API_RATE_LIMITS.AUTHENTICATED_LIMIT \n          : GITHUB_API_RATE_LIMITS.UNAUTHENTICATED_LIMIT;\n          \n        // Apply buffer to stay below actual limits\n        const bufferedLimit = Math.floor(limit * GITHUB_API_RATE_LIMITS.BUFFER_PERCENTAGE);\n        \n        const config: RateLimiterConfig = {\n          maxRequests: bufferedLimit,\n          windowMs: GITHUB_API_RATE_LIMITS.WINDOW_MS,\n          minDelayMs: GITHUB_API_RATE_LIMITS.MIN_DELAY_MS\n        };\n        \n        this.rateLimiter = new RateLimiter(config);\n        \n        logger.info('GitHub rate limiter updated', {\n          authenticated: this.isAuthenticated,\n          limit: bufferedLimit,\n          originalLimit: limit,\n          bufferPercentage: GITHUB_API_RATE_LIMITS.BUFFER_PERCENTAGE\n        });\n      }\n    } catch (error) {\n      logger.warn('Failed to check authentication status for rate limiting', { error });\n      // Fall back to unauthenticated limits\n      this.isAuthenticated = false;\n      this.rateLimiter = new RateLimiter({\n        maxRequests: Math.floor(GITHUB_API_RATE_LIMITS.UNAUTHENTICATED_LIMIT * GITHUB_API_RATE_LIMITS.BUFFER_PERCENTAGE),\n        windowMs: GITHUB_API_RATE_LIMITS.WINDOW_MS,\n        minDelayMs: GITHUB_API_RATE_LIMITS.MIN_DELAY_MS\n      });\n    }\n  }\n\n  /**\n   * Setup periodic check for rate limit status\n   */\n  private setupPeriodicStatusCheck(): void {\n    // Check auth status every 5 minutes\n    setInterval(() => {\n      this.updateLimitsForAuthStatus().catch(error => {\n        logger.warn('Periodic auth status check failed', { error });\n      });\n    }, 5 * 60 * 1000);\n  }\n\n  /**\n   * Queue a GitHub API request with rate limiting\n   * @param operation Description of the operation\n   * @param apiCall Function that makes the actual API call\n   * @param priority Request priority (high, normal, low)\n   * @returns Promise that resolves with the API response\n   */\n  async queueRequest<T>(\n    operation: string,\n    apiCall: () => Promise<T>,\n    priority: 'high' | 'normal' | 'low' = 'normal'\n  ): Promise<T> {\n    // SECURITY FIX (DMCP-SEC-004): Normalize Unicode in operation name to prevent injection attacks\n    const normalizedOperation = UnicodeValidator.normalize(operation);\n    if (!normalizedOperation.isValid) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'UNICODE_VALIDATION_ERROR',\n        severity: 'MEDIUM',\n        source: 'GitHubRateLimiter.queueRequest',\n        details: `Invalid Unicode in operation name: ${normalizedOperation.detectedIssues?.[0] || 'unknown error'}`\n      });\n      // Use a safe fallback for the operation name\n      operation = 'github-api-request';\n    } else {\n      operation = normalizedOperation.normalizedContent;\n    }\n    \n    const requestId = `${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;\n    \n    return new Promise<T>((resolve, reject) => {\n      const request: GitHubApiRequest = {\n        id: requestId,\n        operation,\n        priority,\n        timestamp: Date.now(),\n        resolve: async (value) => {\n          try {\n            logger.debug('Executing GitHub API request', {\n              operation,\n              requestId,\n              queueWaitTime: Date.now() - request.timestamp\n            });\n            \n            const result = await apiCall();\n            resolve(result);\n            \n            // Log successful API usage for quota tracking\n            this.logApiUsage(operation, 'success');\n            \n          } catch (error) {\n            // Check if this is a rate limit error from GitHub\n            if (this.isGitHubRateLimitError(error)) {\n              this.handleGitHubRateLimit(error);\n            }\n            reject(error);\n            this.logApiUsage(operation, 'error', error);\n          }\n        },\n        reject\n      };\n\n      // Add to queue with priority ordering\n      this.addToQueue(request);\n      this.processQueue();\n    });\n  }\n\n  /**\n   * Add request to queue with priority ordering\n   */\n  private addToQueue(request: GitHubApiRequest): void {\n    // Insert based on priority: high > normal > low\n    // Within same priority, maintain FIFO order\n    const priorityOrder = { high: 0, normal: 1, low: 2 };\n    \n    let insertIndex = this.requestQueue.length;\n    for (let i = 0; i < this.requestQueue.length; i++) {\n      if (priorityOrder[request.priority] < priorityOrder[this.requestQueue[i].priority]) {\n        insertIndex = i;\n        break;\n      }\n    }\n    \n    this.requestQueue.splice(insertIndex, 0, request);\n    \n    logger.debug('GitHub API request queued', {\n      operation: request.operation,\n      priority: request.priority,\n      queuePosition: insertIndex,\n      totalQueued: this.requestQueue.length\n    });\n  }\n\n  /**\n   * Process the request queue\n   */\n  private async processQueue(): Promise<void> {\n    if (this.processing || this.requestQueue.length === 0) {\n      return;\n    }\n\n    this.processing = true;\n\n    try {\n      while (this.requestQueue.length > 0) {\n        // Update auth status periodically\n        if (Math.random() < 0.1) { // 10% chance\n          await this.updateLimitsForAuthStatus();\n        }\n\n        const rateLimitStatus = this.rateLimiter.checkLimit();\n        \n        if (!rateLimitStatus.allowed) {\n          // Log rate limit wait\n          logger.info('GitHub API rate limit reached, waiting', {\n            retryAfterMs: rateLimitStatus.retryAfterMs,\n            remainingTokens: rateLimitStatus.remainingTokens,\n            queueLength: this.requestQueue.length,\n            resetTime: rateLimitStatus.resetTime\n          });\n\n          // Wait for the specified time\n          await new Promise(resolve => setTimeout(resolve, rateLimitStatus.retryAfterMs || 1000));\n          continue;\n        }\n\n        // Process the next request\n        const request = this.requestQueue.shift()!;\n        this.rateLimiter.consumeToken();\n\n        // Execute the request\n        request.resolve(null); // This will trigger the actual API call\n      }\n    } finally {\n      this.processing = false;\n    }\n  }\n\n  /**\n   * Get current rate limit status\n   */\n  getStatus(): GitHubRateStatus {\n    const baseStatus = this.rateLimiter.getStatus();\n    \n    return {\n      ...baseStatus,\n      queueLength: this.requestQueue.length,\n      currentLimit: this.isAuthenticated \n        ? GITHUB_API_RATE_LIMITS.AUTHENTICATED_LIMIT \n        : GITHUB_API_RATE_LIMITS.UNAUTHENTICATED_LIMIT,\n      rateLimitInfo: this.lastRateLimitInfo\n    };\n  }\n\n  /**\n   * Check if an error is a GitHub rate limit error\n   */\n  private isGitHubRateLimitError(error: any): boolean {\n    return error?.status === 429 || \n           error?.response?.status === 429 ||\n           (typeof error?.message === 'string' && error.message.toLowerCase().includes('rate limit'));\n  }\n\n  /**\n   * Handle GitHub rate limit error response\n   */\n  private handleGitHubRateLimit(error: any): void {\n    let resetTime: Date | undefined;\n    let remainingRequests = 0;\n    \n    // Parse rate limit headers if available\n    if (error?.response?.headers) {\n      const headers = error.response.headers;\n      const resetTimestamp = parseInt(headers['x-ratelimit-reset'] || '0');\n      const remaining = parseInt(headers['x-ratelimit-remaining'] || '0');\n      const limit = parseInt(headers['x-ratelimit-limit'] || '0');\n      \n      if (resetTimestamp > 0) {\n        resetTime = new Date(resetTimestamp * 1000);\n      }\n      \n      this.lastRateLimitInfo = {\n        limit,\n        remaining,\n        reset: resetTime || new Date(Date.now() + 60 * 60 * 1000), // Default to 1 hour\n        used: limit - remaining\n      };\n      \n      remainingRequests = remaining;\n    }\n\n    logger.warn('GitHub API rate limit hit from server', {\n      remaining: remainingRequests,\n      resetTime,\n      queueLength: this.requestQueue.length,\n      errorMessage: error?.message\n    });\n\n    // Log as a security event for monitoring\n    SecurityMonitor.logSecurityEvent({\n      type: 'RATE_LIMIT_EXCEEDED',\n      severity: 'MEDIUM',\n      source: 'GitHubRateLimiter.handleGitHubRateLimit',\n      details: `GitHub API rate limit exceeded. Remaining: ${remainingRequests}, Queue: ${this.requestQueue.length}`,\n      metadata: {\n        rateLimitInfo: this.lastRateLimitInfo,\n        authenticated: this.isAuthenticated\n      }\n    });\n  }\n\n  /**\n   * Log API usage for monitoring and diagnostics\n   */\n  private logApiUsage(operation: string, result: 'success' | 'error', error?: any): void {\n    const status = this.getStatus();\n    \n    logger.debug('GitHub API usage logged', {\n      operation,\n      result,\n      remainingTokens: status.remainingTokens,\n      queueLength: status.queueLength,\n      authenticated: this.isAuthenticated,\n      error: error?.message\n    });\n\n    // Log warning if getting close to rate limits\n    if (status.remainingTokens < 100 && this.isAuthenticated) {\n      logger.warn('Approaching GitHub API rate limit', {\n        operation,\n        remainingTokens: status.remainingTokens,\n        currentLimit: status.currentLimit,\n        recommendation: 'Consider reducing API usage frequency'\n      });\n    } else if (status.remainingTokens < 10 && !this.isAuthenticated) {\n      logger.warn('Approaching GitHub API rate limit (unauthenticated)', {\n        operation,\n        remainingTokens: status.remainingTokens,\n        currentLimit: status.currentLimit,\n        recommendation: 'Consider authenticating for higher rate limits'\n      });\n    }\n  }\n\n  /**\n   * Clear the request queue (for testing or emergency situations)\n   */\n  clearQueue(): void {\n    const clearedCount = this.requestQueue.length;\n    \n    // Reject all pending requests\n    this.requestQueue.forEach(request => {\n      request.reject(new Error('Request queue cleared'));\n    });\n    \n    this.requestQueue = [];\n    \n    logger.info('GitHub API request queue cleared', { clearedCount });\n  }\n\n  /**\n   * Reset the rate limiter (for testing)\n   */\n  reset(): void {\n    this.rateLimiter.reset();\n    this.clearQueue();\n    this.processing = false;\n    logger.info('GitHub rate limiter reset');\n  }\n}\n\n// Singleton instance for global use\nexport const githubRateLimiter = new GitHubRateLimiter();"]}

package/dist/utils/PerformanceMonitor.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Comprehensive Performance Monitoring System
+ * Tracks search times, memory usage, cache performance, and system metrics
+ */
+export interface PerformanceMetrics {
+    searchTimes: number[];
+    memoryUsage: MemoryUsage[];
+    cacheStats: CachePerformance;
+    systemStats: SystemStats;
+    timestamp: Date;
+}
+export interface MemoryUsage {
+    heapUsed: number;
+    heapTotal: number;
+    rss: number;
+    external: number;
+    timestamp: Date;
+}
+export interface CachePerformance {
+    hitRate: number;
+    avgHitTime: number;
+    avgMissTime: number;
+    totalHits: number;
+    totalMisses: number;
+    evictions: number;
+}
+export interface SystemStats {
+    cpuUsage: number;
+    loadAverage: number[];
+    freeMemory: number;
+    totalMemory: number;
+    uptime: number;
+}
+export interface SearchMetrics {
+    query: string;
+    duration: number;
+    resultCount: number;
+    sources: string[];
+    cacheHit: boolean;
+    memoryBefore: number;
+    memoryAfter: number;
+    timestamp: Date;
+}
+export interface SlowQuery {
+    query: string;
+    duration: number;
+    threshold: number;
+    sources: string[];
+    resultCount: number;
+    memoryUsage: number;
+    timestamp: Date;
+}
+export declare class PerformanceMonitor {
+    private static instance;
+    private searchMetrics;
+    private slowQueries;
+    private memorySnapshots;
+    private cacheMetrics;
+    private readonly maxMetricsHistory;
+    private readonly slowQueryThreshold;
+    private readonly memorySnapshotInterval;
+    private readonly maxSlowQueries;
+    private memoryMonitorInterval?;
+    private isMonitoring;
+    private constructor();
+    static getInstance(): PerformanceMonitor;
+    /**
+     * Start performance monitoring
+     */
+    startMonitoring(): void;
+    /**
+     * Stop performance monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Record search performance metrics
+     */
+    recordSearch(metrics: SearchMetrics): void;
+    /**
+     * Record cache performance metrics
+     */
+    recordCachePerformance(cacheName: string, stats: CachePerformance): void;
+    /**
+     * Get comprehensive performance metrics
+     */
+    getMetrics(): PerformanceMetrics;
+    /**
+     * Get search performance statistics
+     */
+    getSearchStats(): {
+        totalSearches: number;
+        averageTime: number;
+        medianTime: number;
+        p95Time: number;
+        p99Time: number;
+        slowQueries: number;
+        cacheHitRate: number;
+    };
+    /**
+     * Get memory usage statistics
+     */
+    getMemoryStats(): {
+        currentUsage: MemoryUsage;
+        peakUsage: MemoryUsage;
+        averageUsage: MemoryUsage;
+        growthRate: number;
+    };
+    /**
+     * Get slow queries with analysis
+     */
+    getSlowQueries(limit?: number): SlowQuery[];
+    /**
+     * Analyze performance trends
+     */
+    analyzeTrends(): {
+        performanceTrend: 'improving' | 'degrading' | 'stable';
+        memoryTrend: 'growing' | 'shrinking' | 'stable';
+        recommendations: string[];
+    };
+    /**
+     * Reset all performance metrics
+     */
+    reset(): void;
+    /**
+     * Export metrics for external analysis
+     */
+    exportMetrics(): string;
+    private recordSlowQuery;
+    private startMemoryMonitoring;
+    private takeMemorySnapshot;
+    private aggregateCacheStats;
+    private getSystemStats;
+}
+//# sourceMappingURL=PerformanceMonitor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceMonitor.d.ts","sourceRoot":"","sources":["../../src/utils/PerformanceMonitor.ts"],"names":[],"mappings":"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"}