@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/utils/ErrorHandler.js

@@ -0,0 +1,201 @@
+/**
+ * Centralized error handling utilities for consistent error processing
+ * Preserves stack traces and provides user-friendly messages
+ */
+import { logger } from './logger.js';
+/**
+ * Error categories for better error handling
+ */
+export var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["USER_ERROR"] = "USER_ERROR";
+    ErrorCategory["SYSTEM_ERROR"] = "SYSTEM_ERROR";
+    ErrorCategory["NETWORK_ERROR"] = "NETWORK_ERROR";
+    ErrorCategory["AUTH_ERROR"] = "AUTH_ERROR";
+    ErrorCategory["VALIDATION_ERROR"] = "VALIDATION_ERROR"; // Validation failures
+})(ErrorCategory || (ErrorCategory = {}));
+/**
+ * Custom error class with additional context
+ */
+export class ApplicationError extends Error {
+    category;
+    code;
+    details;
+    originalError;
+    constructor(message, category = ErrorCategory.SYSTEM_ERROR, code, details, originalError) {
+        super(message);
+        this.name = 'ApplicationError';
+        this.category = category;
+        this.code = code;
+        this.details = details;
+        this.originalError = originalError;
+        // Maintain proper stack trace with truncation to prevent memory issues
+        if (originalError?.stack) {
+            const truncatedOriginalStack = ErrorHandler.truncateStack(originalError.stack);
+            this.stack = `${this.stack}\nCaused by: ${truncatedOriginalStack}`;
+        }
+    }
+}
+/**
+ * Utility class for consistent error handling
+ */
+export class ErrorHandler {
+    /**
+     * Maximum stack trace depth to prevent memory issues
+     */
+    static MAX_STACK_DEPTH = 10;
+    /**
+     * Maximum length for stack trace strings
+     */
+    static MAX_STACK_LENGTH = 5000;
+    /**
+     * Truncate stack trace to prevent memory issues
+     */
+    static truncateStack(stack) {
+        if (!stack)
+            return undefined;
+        // Limit total length
+        if (stack.length > this.MAX_STACK_LENGTH) {
+            stack = stack.substring(0, this.MAX_STACK_LENGTH) + '\n... (truncated)';
+        }
+        // Limit number of stack frames
+        const lines = stack.split('\n');
+        if (lines.length > this.MAX_STACK_DEPTH) {
+            return lines.slice(0, this.MAX_STACK_DEPTH).join('\n') + '\n... (truncated)';
+        }
+        return stack;
+    }
+    /**
+     * Extract error information while preserving context
+     */
+    static extractErrorInfo(error) {
+        // Handle ApplicationError
+        if (error instanceof ApplicationError) {
+            return {
+                message: error.message,
+                category: error.category,
+                code: error.code,
+                details: error.details,
+                stack: this.truncateStack(error.stack),
+                originalError: error.originalError
+            };
+        }
+        // Handle standard Error
+        if (error instanceof Error) {
+            return {
+                message: error.message,
+                category: ErrorCategory.SYSTEM_ERROR,
+                stack: this.truncateStack(error.stack),
+                originalError: error
+            };
+        }
+        // Handle string errors
+        if (typeof error === 'string') {
+            return {
+                message: error,
+                category: ErrorCategory.SYSTEM_ERROR
+            };
+        }
+        // Handle unknown errors
+        return {
+            message: 'An unknown error occurred',
+            category: ErrorCategory.SYSTEM_ERROR,
+            details: error
+        };
+    }
+    /**
+     * Get user-friendly error message
+     */
+    static getUserMessage(error) {
+        const errorInfo = this.extractErrorInfo(error);
+        // Provide user-friendly messages based on category
+        switch (errorInfo.category) {
+            case ErrorCategory.AUTH_ERROR:
+                return `Authentication error: ${errorInfo.message}`;
+            case ErrorCategory.VALIDATION_ERROR:
+                return `Validation error: ${errorInfo.message}`;
+            case ErrorCategory.NETWORK_ERROR:
+                return `Network error: ${errorInfo.message}. Please check your connection and try again.`;
+            case ErrorCategory.USER_ERROR:
+                return errorInfo.message; // User errors should already be user-friendly
+            default:
+                // For system errors, provide a generic message
+                return 'An unexpected error occurred. Please try again later.';
+        }
+    }
+    /**
+     * Log error with appropriate level and context
+     */
+    static logError(context, error, additionalInfo) {
+        const errorInfo = this.extractErrorInfo(error);
+        const logData = {
+            context,
+            category: errorInfo.category,
+            code: errorInfo.code,
+            message: errorInfo.message,
+            ...additionalInfo
+        };
+        // Log based on category
+        switch (errorInfo.category) {
+            case ErrorCategory.USER_ERROR:
+            case ErrorCategory.VALIDATION_ERROR:
+                logger.warn(`${context}: ${errorInfo.message}`, logData);
+                break;
+            case ErrorCategory.AUTH_ERROR:
+                logger.warn(`${context}: Authentication error`, logData);
+                break;
+            case ErrorCategory.NETWORK_ERROR:
+                logger.error(`${context}: Network error`, {
+                    ...logData,
+                    stack: errorInfo.stack
+                });
+                break;
+            default:
+                logger.error(`${context}: System error`, {
+                    ...logData,
+                    stack: errorInfo.stack,
+                    details: errorInfo.details
+                });
+        }
+        // Log stack trace in debug mode for all errors (already truncated)
+        if (errorInfo.stack) {
+            logger.debug(`${context} - Stack trace:`, { stack: errorInfo.stack });
+        }
+    }
+    /**
+     * Create an error with context preservation
+     */
+    static createError(message, category = ErrorCategory.SYSTEM_ERROR, code, originalError) {
+        const original = originalError instanceof Error ? originalError : undefined;
+        return new ApplicationError(message, category, code, undefined, original);
+    }
+    /**
+     * Wrap an error with additional context
+     */
+    static wrapError(error, context, category) {
+        const errorInfo = this.extractErrorInfo(error);
+        return new ApplicationError(`${context}: ${errorInfo.message}`, category || errorInfo.category, errorInfo.code, errorInfo.details, errorInfo.originalError);
+    }
+    /**
+     * Check if error is of a specific category
+     */
+    static isErrorCategory(error, category) {
+        const errorInfo = this.extractErrorInfo(error);
+        return errorInfo.category === category;
+    }
+    /**
+     * Format error for API response
+     */
+    static formatForResponse(error) {
+        const errorInfo = this.extractErrorInfo(error);
+        const userMessage = this.getUserMessage(error);
+        return {
+            success: false,
+            message: userMessage,
+            error: errorInfo.code || errorInfo.category,
+            // Only include details in development
+            details: process.env.NODE_ENV === 'development' ? errorInfo.details : undefined
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ErrorHandler.js","sourceRoot":"","sources":["../../src/utils/ErrorHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Centralized error handling utilities for consistent error processing\n * Preserves stack traces and provides user-friendly messages\n */\n\nimport { logger } from './logger.js';\n\n/**\n * Error categories for better error handling\n */\nexport enum ErrorCategory {\n  USER_ERROR = 'USER_ERROR',        // User input issues\n  SYSTEM_ERROR = 'SYSTEM_ERROR',    // Internal system failures\n  NETWORK_ERROR = 'NETWORK_ERROR',  // API/network issues\n  AUTH_ERROR = 'AUTH_ERROR',        // Authentication/authorization\n  VALIDATION_ERROR = 'VALIDATION_ERROR' // Validation failures\n}\n\n/**\n * Structured error information\n */\nexport interface ErrorInfo {\n  message: string;\n  category: ErrorCategory;\n  code?: string;\n  details?: Record<string, unknown>;\n  stack?: string;\n  originalError?: Error;\n}\n\n/**\n * Custom error class with additional context\n */\nexport class ApplicationError extends Error {\n  public readonly category: ErrorCategory;\n  public readonly code?: string;\n  public readonly details?: Record<string, unknown>;\n  public readonly originalError?: Error;\n\n  constructor(\n    message: string,\n    category: ErrorCategory = ErrorCategory.SYSTEM_ERROR,\n    code?: string,\n    details?: Record<string, unknown>,\n    originalError?: Error\n  ) {\n    super(message);\n    this.name = 'ApplicationError';\n    this.category = category;\n    this.code = code;\n    this.details = details;\n    this.originalError = originalError;\n\n    // Maintain proper stack trace with truncation to prevent memory issues\n    if (originalError?.stack) {\n      const truncatedOriginalStack = ErrorHandler.truncateStack(originalError.stack);\n      this.stack = `${this.stack}\\nCaused by: ${truncatedOriginalStack}`;\n    }\n  }\n}\n\n/**\n * Utility class for consistent error handling\n */\nexport class ErrorHandler {\n  /**\n   * Maximum stack trace depth to prevent memory issues\n   */\n  private static readonly MAX_STACK_DEPTH = 10;\n  \n  /**\n   * Maximum length for stack trace strings\n   */\n  private static readonly MAX_STACK_LENGTH = 5000;\n  \n  /**\n   * Truncate stack trace to prevent memory issues\n   */\n  public static truncateStack(stack?: string): string | undefined {\n    if (!stack) return undefined;\n    \n    // Limit total length\n    if (stack.length > this.MAX_STACK_LENGTH) {\n      stack = stack.substring(0, this.MAX_STACK_LENGTH) + '\\n... (truncated)';\n    }\n    \n    // Limit number of stack frames\n    const lines = stack.split('\\n');\n    if (lines.length > this.MAX_STACK_DEPTH) {\n      return lines.slice(0, this.MAX_STACK_DEPTH).join('\\n') + '\\n... (truncated)';\n    }\n    \n    return stack;\n  }\n  \n  /**\n   * Extract error information while preserving context\n   */\n  static extractErrorInfo(error: unknown): ErrorInfo {\n    // Handle ApplicationError\n    if (error instanceof ApplicationError) {\n      return {\n        message: error.message,\n        category: error.category,\n        code: error.code,\n        details: error.details,\n        stack: this.truncateStack(error.stack),\n        originalError: error.originalError\n      };\n    }\n\n    // Handle standard Error\n    if (error instanceof Error) {\n      return {\n        message: error.message,\n        category: ErrorCategory.SYSTEM_ERROR,\n        stack: this.truncateStack(error.stack),\n        originalError: error\n      };\n    }\n\n    // Handle string errors\n    if (typeof error === 'string') {\n      return {\n        message: error,\n        category: ErrorCategory.SYSTEM_ERROR\n      };\n    }\n\n    // Handle unknown errors\n    return {\n      message: 'An unknown error occurred',\n      category: ErrorCategory.SYSTEM_ERROR,\n      details: error as Record<string, unknown> | undefined\n    };\n  }\n\n  /**\n   * Get user-friendly error message\n   */\n  static getUserMessage(error: unknown): string {\n    const errorInfo = this.extractErrorInfo(error);\n    \n    // Provide user-friendly messages based on category\n    switch (errorInfo.category) {\n      case ErrorCategory.AUTH_ERROR:\n        return `Authentication error: ${errorInfo.message}`;\n      case ErrorCategory.VALIDATION_ERROR:\n        return `Validation error: ${errorInfo.message}`;\n      case ErrorCategory.NETWORK_ERROR:\n        return `Network error: ${errorInfo.message}. Please check your connection and try again.`;\n      case ErrorCategory.USER_ERROR:\n        return errorInfo.message; // User errors should already be user-friendly\n      default:\n        // For system errors, provide a generic message\n        return 'An unexpected error occurred. Please try again later.';\n    }\n  }\n\n  /**\n   * Log error with appropriate level and context\n   */\n  static logError(\n    context: string,\n    error: unknown,\n    additionalInfo?: Record<string, unknown>\n  ): void {\n    const errorInfo = this.extractErrorInfo(error);\n    \n    const logData = {\n      context,\n      category: errorInfo.category,\n      code: errorInfo.code,\n      message: errorInfo.message,\n      ...additionalInfo\n    };\n\n    // Log based on category\n    switch (errorInfo.category) {\n      case ErrorCategory.USER_ERROR:\n      case ErrorCategory.VALIDATION_ERROR:\n        logger.warn(`${context}: ${errorInfo.message}`, logData);\n        break;\n      case ErrorCategory.AUTH_ERROR:\n        logger.warn(`${context}: Authentication error`, logData);\n        break;\n      case ErrorCategory.NETWORK_ERROR:\n        logger.error(`${context}: Network error`, {\n          ...logData,\n          stack: errorInfo.stack\n        });\n        break;\n      default:\n        logger.error(`${context}: System error`, {\n          ...logData,\n          stack: errorInfo.stack,\n          details: errorInfo.details\n        });\n    }\n\n    // Log stack trace in debug mode for all errors (already truncated)\n    if (errorInfo.stack) {\n      logger.debug(`${context} - Stack trace:`, { stack: errorInfo.stack });\n    }\n  }\n\n  /**\n   * Create an error with context preservation\n   */\n  static createError(\n    message: string,\n    category: ErrorCategory = ErrorCategory.SYSTEM_ERROR,\n    code?: string,\n    originalError?: unknown\n  ): ApplicationError {\n    const original = originalError instanceof Error ? originalError : undefined;\n    return new ApplicationError(message, category, code, undefined, original);\n  }\n\n  /**\n   * Wrap an error with additional context\n   */\n  static wrapError(\n    error: unknown,\n    context: string,\n    category?: ErrorCategory\n  ): ApplicationError {\n    const errorInfo = this.extractErrorInfo(error);\n    return new ApplicationError(\n      `${context}: ${errorInfo.message}`,\n      category || errorInfo.category,\n      errorInfo.code,\n      errorInfo.details,\n      errorInfo.originalError\n    );\n  }\n\n  /**\n   * Check if error is of a specific category\n   */\n  static isErrorCategory(error: unknown, category: ErrorCategory): boolean {\n    const errorInfo = this.extractErrorInfo(error);\n    return errorInfo.category === category;\n  }\n\n  /**\n   * Format error for API response\n   */\n  static formatForResponse(error: unknown): {\n    success: false;\n    message: string;\n    error: string;\n    details?: Record<string, unknown>;\n  } {\n    const errorInfo = this.extractErrorInfo(error);\n    const userMessage = this.getUserMessage(error);\n    \n    return {\n      success: false,\n      message: userMessage,\n      error: errorInfo.code || errorInfo.category,\n      // Only include details in development\n      details: process.env.NODE_ENV === 'development' ? errorInfo.details : undefined\n    };\n  }\n}"]}

package/dist/utils/FileDiscoveryUtil.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Utility class for efficient file discovery operations
+ * Provides optimized file search with caching and security
+ *
+ * IMPLEMENTATION (PR #503 - PR #496 Recommendation):
+ * 1. PERFORMANCE: Single readdir operation instead of multiple file checks
+ * 2. PERFORMANCE: 5-second cache TTL for repeated searches
+ * 3. SECURITY: Unicode normalization for all search inputs
+ * 4. MEMORY: Efficient cache management with 100 entry limit
+ *
+ * This addresses the PR #496 review recommendation to extract file discovery
+ * logic to a reusable utility class for better performance and maintainability.
+ */
+export interface FileSearchOptions {
+    extensions?: string[];
+    partialMatch?: boolean;
+    maxResults?: number;
+    cacheResults?: boolean;
+}
+export declare class FileDiscoveryUtil {
+    private static readonly CACHE_TTL;
+    private static cache;
+    /**
+     * Find files in a directory with optimized search
+     * Uses single readdir operation and filters results
+     */
+    static findFiles(directory: string, searchName: string, options?: FileSearchOptions): Promise<string[]>;
+    /**
+     * Build search patterns for different file extensions
+     */
+    private static buildSearchPatterns;
+    /**
+     * Check if filename matches pattern
+     */
+    private static matchesPattern;
+    /**
+     * Get cached results if still valid
+     */
+    private static getCached;
+    /**
+     * Cache results with timestamp
+     */
+    private static setCached;
+    /**
+     * Clear the cache
+     */
+    static clearCache(): void;
+    /**
+     * Find a single file (convenience method)
+     */
+    static findFile(directory: string, searchName: string, options?: FileSearchOptions): Promise<string | null>;
+}
+//# sourceMappingURL=FileDiscoveryUtil.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileDiscoveryUtil.d.ts","sourceRoot":"","sources":["../../src/utils/FileDiscoveryUtil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAOD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAQ;IACzC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAiC;IAErD;;;OAGG;WACU,SAAS,CACpB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,MAAM,EAAE,CAAC;IAkFpB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoBlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAO7B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAaxB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAiBxB;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,IAAI;IAKzB;;OAEG;WACU,QAAQ,CACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAO1B"}

package/dist/utils/FileDiscoveryUtil.js

@@ -0,0 +1,169 @@
+/**
+ * Utility class for efficient file discovery operations
+ * Provides optimized file search with caching and security
+ *
+ * IMPLEMENTATION (PR #503 - PR #496 Recommendation):
+ * 1. PERFORMANCE: Single readdir operation instead of multiple file checks
+ * 2. PERFORMANCE: 5-second cache TTL for repeated searches
+ * 3. SECURITY: Unicode normalization for all search inputs
+ * 4. MEMORY: Efficient cache management with 100 entry limit
+ *
+ * This addresses the PR #496 review recommendation to extract file discovery
+ * logic to a reusable utility class for better performance and maintainability.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from './logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+export class FileDiscoveryUtil {
+    static CACHE_TTL = 5000; // 5 seconds cache TTL
+    static cache = new Map();
+    /**
+     * Find files in a directory with optimized search
+     * Uses single readdir operation and filters results
+     */
+    static async findFiles(directory, searchName, options = {}) {
+        const { extensions = ['.json', '.yaml', '.yml', '.md'], partialMatch = true, maxResults = 10, cacheResults = true } = options;
+        // Normalize search name for security
+        const normalizedSearch = UnicodeValidator.normalize(searchName);
+        if (!normalizedSearch.isValid) {
+            logger.warn('Invalid Unicode in search name', {
+                issues: normalizedSearch.detectedIssues
+            });
+            return [];
+        }
+        const safeName = normalizedSearch.normalizedContent.toLowerCase();
+        // Check cache if enabled
+        const cacheKey = `${directory}:${safeName}:${JSON.stringify(options)}`;
+        if (cacheResults) {
+            const cached = this.getCached(cacheKey);
+            if (cached) {
+                logger.debug('File search cache hit', { directory, searchName });
+                return cached;
+            }
+        }
+        try {
+            // Single readdir operation for efficiency
+            const files = await fs.readdir(directory);
+            // Build search patterns
+            const searchPatterns = this.buildSearchPatterns(safeName, extensions);
+            // Filter files efficiently
+            const matches = [];
+            for (const file of files) {
+                const fileLower = file.toLowerCase();
+                // Check each pattern
+                for (const pattern of searchPatterns) {
+                    if (this.matchesPattern(fileLower, pattern, partialMatch)) {
+                        const fullPath = path.join(directory, file);
+                        matches.push(fullPath);
+                        if (matches.length >= maxResults) {
+                            break;
+                        }
+                    }
+                }
+                if (matches.length >= maxResults) {
+                    break;
+                }
+            }
+            // Cache results if enabled
+            if (cacheResults && matches.length > 0) {
+                this.setCached(cacheKey, matches);
+            }
+            // Log file discovery for monitoring
+            if (matches.length > 0) {
+                logger.debug('Files discovered', {
+                    directory,
+                    searchName,
+                    count: matches.length
+                });
+            }
+            return matches;
+        }
+        catch (error) {
+            logger.error('File discovery failed', {
+                directory,
+                searchName,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return [];
+        }
+    }
+    /**
+     * Build search patterns for different file extensions
+     */
+    static buildSearchPatterns(baseName, extensions) {
+        const patterns = [baseName];
+        // Add extension variations
+        for (const ext of extensions) {
+            patterns.push(`${baseName}${ext}`);
+        }
+        // Add common variations
+        const nameWithoutExtension = baseName.replace(/\.[^.]+$/, '');
+        if (nameWithoutExtension !== baseName) {
+            patterns.push(nameWithoutExtension);
+            for (const ext of extensions) {
+                patterns.push(`${nameWithoutExtension}${ext}`);
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Check if filename matches pattern
+     */
+    static matchesPattern(filename, pattern, partialMatch) {
+        if (partialMatch) {
+            return filename.includes(pattern);
+        }
+        return filename === pattern;
+    }
+    /**
+     * Get cached results if still valid
+     */
+    static getCached(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        const age = Date.now() - entry.timestamp;
+        if (age > this.CACHE_TTL) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.files;
+    }
+    /**
+     * Cache results with timestamp
+     */
+    static setCached(key, files) {
+        // Limit cache size to prevent memory issues
+        if (this.cache.size > 100) {
+            // Remove oldest entries
+            const entries = Array.from(this.cache.entries());
+            entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+            for (let i = 0; i < 50; i++) {
+                this.cache.delete(entries[i][0]);
+            }
+        }
+        this.cache.set(key, {
+            files,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Clear the cache
+     */
+    static clearCache() {
+        this.cache.clear();
+        logger.debug('File discovery cache cleared');
+    }
+    /**
+     * Find a single file (convenience method)
+     */
+    static async findFile(directory, searchName, options) {
+        const files = await this.findFiles(directory, searchName, {
+            ...options,
+            maxResults: 1
+        });
+        return files.length > 0 ? files[0] : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileDiscoveryUtil.js","sourceRoot":"","sources":["../../src/utils/FileDiscoveryUtil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAe9E,MAAM,OAAO,iBAAiB;IACpB,MAAM,CAAU,SAAS,GAAG,IAAI,CAAC,CAAC,sBAAsB;IACxD,MAAM,CAAC,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;IAErD;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,SAAS,CACpB,SAAiB,EACjB,UAAkB,EAClB,UAA6B,EAAE;QAE/B,MAAM,EACJ,UAAU,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAC9C,YAAY,GAAG,IAAI,EACnB,UAAU,GAAG,EAAE,EACf,YAAY,GAAG,IAAI,EACpB,GAAG,OAAO,CAAC;QAEZ,qCAAqC;QACrC,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;YAC9B,MAAM,CAAC,IAAI,CAAC,gCAAgC,EAAE;gBAC5C,MAAM,EAAE,gBAAgB,CAAC,cAAc;aACxC,CAAC,CAAC;YACH,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;QAElE,yBAAyB;QACzB,MAAM,QAAQ,GAAG,GAAG,SAAS,IAAI,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;QACvE,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACxC,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,CAAC,KAAK,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;gBACjE,OAAO,MAAM,CAAC;YAChB,CAAC;QACH,CAAC;QAED,IAAI,CAAC;YACH,0CAA0C;YAC1C,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAE1C,wBAAwB;YACxB,MAAM,cAAc,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAEtE,2BAA2B;YAC3B,MAAM,OAAO,GAAa,EAAE,CAAC;YAC7B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;gBAErC,qBAAqB;gBACrB,KAAK,MAAM,OAAO,IAAI,cAAc,EAAE,CAAC;oBACrC,IAAI,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,CAAC,EAAE,CAAC;wBAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;wBAC5C,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;wBAEvB,IAAI,OAAO,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;4BACjC,MAAM;wBACR,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,IAAI,OAAO,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;oBACjC,MAAM;gBACR,CAAC;YACH,CAAC;YAED,2BAA2B;YAC3B,IAAI,YAAY,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YACpC,CAAC;YAED,oCAAoC;YACpC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,MAAM,CAAC,KAAK,CAAC,kBAAkB,EAAE;oBAC/B,SAAS;oBACT,UAAU;oBACV,KAAK,EAAE,OAAO,CAAC,MAAM;iBACtB,CAAC,CAAC;YACL,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,uBAAuB,EAAE;gBACpC,SAAS;gBACT,UAAU;gBACV,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;aAC9D,CAAC,CAAC;YACH,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,mBAAmB,CAAC,QAAgB,EAAE,UAAoB;QACvE,MAAM,QAAQ,GAAa,CAAC,QAAQ,CAAC,CAAC;QAEtC,2BAA2B;QAC3B,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC7B,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,GAAG,GAAG,EAAE,CAAC,CAAC;QACrC,CAAC;QAED,wBAAwB;QACxB,MAAM,oBAAoB,GAAG,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QAC9D,IAAI,oBAAoB,KAAK,QAAQ,EAAE,CAAC;YACtC,QAAQ,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;YACpC,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC7B,QAAQ,CAAC,IAAI,CAAC,GAAG,oBAAoB,GAAG,GAAG,EAAE,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,cAAc,CAAC,QAAgB,EAAE,OAAe,EAAE,YAAqB;QACpF,IAAI,YAAY,EAAE,CAAC;YACjB,OAAO,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QACD,OAAO,QAAQ,KAAK,OAAO,CAAC;IAC9B,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,SAAS,CAAC,GAAW;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC;QAExB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS,CAAC;QACzC,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC,KAAK,CAAC;IACrB,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,SAAS,CAAC,GAAW,EAAE,KAAe;QACnD,4CAA4C;QAC5C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,EAAE,CAAC;YAC1B,wBAAwB;YACxB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACjD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;YAClB,KAAK;YACL,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACtB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU;QACf,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,MAAM,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,QAAQ,CACnB,SAAiB,EACjB,UAAkB,EAClB,OAA2B;QAE3B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,UAAU,EAAE;YACxD,GAAG,OAAO;YACV,UAAU,EAAE,CAAC;SACd,CAAC,CAAC;QACH,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5C,CAAC","sourcesContent":["/**\n * Utility class for efficient file discovery operations\n * Provides optimized file search with caching and security\n * \n * IMPLEMENTATION (PR #503 - PR #496 Recommendation):\n * 1. PERFORMANCE: Single readdir operation instead of multiple file checks\n * 2. PERFORMANCE: 5-second cache TTL for repeated searches\n * 3. SECURITY: Unicode normalization for all search inputs\n * 4. MEMORY: Efficient cache management with 100 entry limit\n * \n * This addresses the PR #496 review recommendation to extract file discovery\n * logic to a reusable utility class for better performance and maintainability.\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from './logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport interface FileSearchOptions {\n  extensions?: string[];\n  partialMatch?: boolean;\n  maxResults?: number;\n  cacheResults?: boolean;\n}\n\ninterface CacheEntry {\n  files: string[];\n  timestamp: number;\n}\n\nexport class FileDiscoveryUtil {\n  private static readonly CACHE_TTL = 5000; // 5 seconds cache TTL\n  private static cache = new Map<string, CacheEntry>();\n  \n  /**\n   * Find files in a directory with optimized search\n   * Uses single readdir operation and filters results\n   */\n  static async findFiles(\n    directory: string,\n    searchName: string,\n    options: FileSearchOptions = {}\n  ): Promise<string[]> {\n    const {\n      extensions = ['.json', '.yaml', '.yml', '.md'],\n      partialMatch = true,\n      maxResults = 10,\n      cacheResults = true\n    } = options;\n    \n    // Normalize search name for security\n    const normalizedSearch = UnicodeValidator.normalize(searchName);\n    if (!normalizedSearch.isValid) {\n      logger.warn('Invalid Unicode in search name', {\n        issues: normalizedSearch.detectedIssues\n      });\n      return [];\n    }\n    const safeName = normalizedSearch.normalizedContent.toLowerCase();\n    \n    // Check cache if enabled\n    const cacheKey = `${directory}:${safeName}:${JSON.stringify(options)}`;\n    if (cacheResults) {\n      const cached = this.getCached(cacheKey);\n      if (cached) {\n        logger.debug('File search cache hit', { directory, searchName });\n        return cached;\n      }\n    }\n    \n    try {\n      // Single readdir operation for efficiency\n      const files = await fs.readdir(directory);\n      \n      // Build search patterns\n      const searchPatterns = this.buildSearchPatterns(safeName, extensions);\n      \n      // Filter files efficiently\n      const matches: string[] = [];\n      for (const file of files) {\n        const fileLower = file.toLowerCase();\n        \n        // Check each pattern\n        for (const pattern of searchPatterns) {\n          if (this.matchesPattern(fileLower, pattern, partialMatch)) {\n            const fullPath = path.join(directory, file);\n            matches.push(fullPath);\n            \n            if (matches.length >= maxResults) {\n              break;\n            }\n          }\n        }\n        \n        if (matches.length >= maxResults) {\n          break;\n        }\n      }\n      \n      // Cache results if enabled\n      if (cacheResults && matches.length > 0) {\n        this.setCached(cacheKey, matches);\n      }\n      \n      // Log file discovery for monitoring\n      if (matches.length > 0) {\n        logger.debug('Files discovered', {\n          directory,\n          searchName,\n          count: matches.length\n        });\n      }\n      \n      return matches;\n    } catch (error) {\n      logger.error('File discovery failed', {\n        directory,\n        searchName,\n        error: error instanceof Error ? error.message : String(error)\n      });\n      return [];\n    }\n  }\n  \n  /**\n   * Build search patterns for different file extensions\n   */\n  private static buildSearchPatterns(baseName: string, extensions: string[]): string[] {\n    const patterns: string[] = [baseName];\n    \n    // Add extension variations\n    for (const ext of extensions) {\n      patterns.push(`${baseName}${ext}`);\n    }\n    \n    // Add common variations\n    const nameWithoutExtension = baseName.replace(/\\.[^.]+$/, '');\n    if (nameWithoutExtension !== baseName) {\n      patterns.push(nameWithoutExtension);\n      for (const ext of extensions) {\n        patterns.push(`${nameWithoutExtension}${ext}`);\n      }\n    }\n    \n    return patterns;\n  }\n  \n  /**\n   * Check if filename matches pattern\n   */\n  private static matchesPattern(filename: string, pattern: string, partialMatch: boolean): boolean {\n    if (partialMatch) {\n      return filename.includes(pattern);\n    }\n    return filename === pattern;\n  }\n  \n  /**\n   * Get cached results if still valid\n   */\n  private static getCached(key: string): string[] | null {\n    const entry = this.cache.get(key);\n    if (!entry) return null;\n    \n    const age = Date.now() - entry.timestamp;\n    if (age > this.CACHE_TTL) {\n      this.cache.delete(key);\n      return null;\n    }\n    \n    return entry.files;\n  }\n  \n  /**\n   * Cache results with timestamp\n   */\n  private static setCached(key: string, files: string[]): void {\n    // Limit cache size to prevent memory issues\n    if (this.cache.size > 100) {\n      // Remove oldest entries\n      const entries = Array.from(this.cache.entries());\n      entries.sort((a, b) => a[1].timestamp - b[1].timestamp);\n      for (let i = 0; i < 50; i++) {\n        this.cache.delete(entries[i][0]);\n      }\n    }\n    \n    this.cache.set(key, {\n      files,\n      timestamp: Date.now()\n    });\n  }\n  \n  /**\n   * Clear the cache\n   */\n  static clearCache(): void {\n    this.cache.clear();\n    logger.debug('File discovery cache cleared');\n  }\n  \n  /**\n   * Find a single file (convenience method)\n   */\n  static async findFile(\n    directory: string,\n    searchName: string,\n    options?: FileSearchOptions\n  ): Promise<string | null> {\n    const files = await this.findFiles(directory, searchName, {\n      ...options,\n      maxResults: 1\n    });\n    return files.length > 0 ? files[0] : null;\n  }\n}"]}

package/dist/utils/GitHubRateLimiter.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 { RateLimitStatus } from './RateLimiter.js';
+export interface GitHubRateLimitInfo {
+    limit: number;
+    remaining: number;
+    reset: Date;
+    used: number;
+}
+export interface GitHubApiRequest {
+    id: string;
+    operation: string;
+    priority: 'high' | 'normal' | 'low';
+    timestamp: number;
+    resolve: (value: any) => void;
+    reject: (error: any) => void;
+}
+export interface GitHubRateStatus extends RateLimitStatus {
+    queueLength: number;
+    currentLimit: number;
+    rateLimitInfo?: GitHubRateLimitInfo;
+}
+export declare class GitHubRateLimiter {
+    private rateLimiter;
+    private requestQueue;
+    private processing;
+    private lastRateLimitInfo?;
+    private isAuthenticated;
+    constructor();
+    /**
+     * Update rate limits based on current authentication status
+     */
+    private updateLimitsForAuthStatus;
+    /**
+     * Setup periodic check for rate limit status
+     */
+    private setupPeriodicStatusCheck;
+    /**
+     * 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
+     */
+    queueRequest<T>(operation: string, apiCall: () => Promise<T>, priority?: 'high' | 'normal' | 'low'): Promise<T>;
+    /**
+     * Add request to queue with priority ordering
+     */
+    private addToQueue;
+    /**
+     * Process the request queue
+     */
+    private processQueue;
+    /**
+     * Get current rate limit status
+     */
+    getStatus(): GitHubRateStatus;
+    /**
+     * Check if an error is a GitHub rate limit error
+     */
+    private isGitHubRateLimitError;
+    /**
+     * Handle GitHub rate limit error response
+     */
+    private handleGitHubRateLimit;
+    /**
+     * Log API usage for monitoring and diagnostics
+     */
+    private logApiUsage;
+    /**
+     * Clear the request queue (for testing or emergency situations)
+     */
+    clearQueue(): void;
+    /**
+     * Reset the rate limiter (for testing)
+     */
+    reset(): void;
+}
+export declare const githubRateLimiter: GitHubRateLimiter;
+//# sourceMappingURL=GitHubRateLimiter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubRateLimiter.d.ts","sourceRoot":"","sources":["../../src/utils/GitHubRateLimiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAkC,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOnF,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,IAAI,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC9B,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,mBAAmB,CAAC;CACrC;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,iBAAiB,CAAC,CAAsB;IAChD,OAAO,CAAC,eAAe,CAAS;;IAQhC;;OAEG;YACW,yBAAyB;IA2CvC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAShC;;;;;;OAMG;IACG,YAAY,CAAC,CAAC,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,QAAQ,GAAE,MAAM,GAAG,QAAQ,GAAG,KAAgB,GAC7C,OAAO,CAAC,CAAC,CAAC;IAwDb;;OAEG;IACH,OAAO,CAAC,UAAU;IAuBlB;;OAEG;YACW,YAAY;IA0C1B;;OAEG;IACH,SAAS,IAAI,gBAAgB;IAa7B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAM9B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA6C7B;;OAEG;IACH,OAAO,CAAC,WAAW;IA8BnB;;OAEG;IACH,UAAU,IAAI,IAAI;IAalB;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd;AAGD,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}