@dollhousemcp/mcp-server 1.5.1 → 1.6.0

package/dist/cache/CollectionIndexCache.js

@@ -0,0 +1,349 @@
+/**
+ * Smart cache for collection index with conditional fetching and performance optimization
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { CacheFactory } from './LRUCache.js';
+import { PerformanceMonitor } from '../utils/PerformanceMonitor.js';
+export class CollectionIndexCache {
+    cache = null;
+    TTL = 15 * 60 * 1000; // 15 minutes in milliseconds
+    INDEX_URL = 'https://raw.githubusercontent.com/DollhouseMCP/collection/main/public/collection-index.json';
+    cacheDir;
+    cacheFile;
+    githubClient;
+    performanceMonitor;
+    memoryCache;
+    fetchPromise = null; // Prevent concurrent fetches
+    constructor(githubClient, baseDir = process.cwd()) {
+        this.githubClient = githubClient;
+        this.cacheDir = path.join(baseDir, '.dollhousemcp', 'cache');
+        this.cacheFile = path.join(this.cacheDir, 'collection-index-cache.json');
+        this.performanceMonitor = PerformanceMonitor.getInstance();
+        // Initialize memory cache for frequently accessed data
+        this.memoryCache = CacheFactory.createAPICache({
+            maxSize: 50,
+            maxMemoryMB: 10,
+            ttlMs: 5 * 60 * 1000, // 5 minutes
+            onEviction: (key, value) => {
+                logger.debug('Collection memory cache eviction', { key });
+            }
+        });
+    }
+    /**
+     * Get the collection index with performance optimization and lazy loading
+     */
+    async getIndex(lazyLoad = false) {
+        const startTime = Date.now();
+        const memoryBefore = process.memoryUsage().heapUsed;
+        try {
+            // Check memory cache first for fastest access
+            const memoryCached = this.memoryCache.get('collection-index');
+            if (memoryCached && this.isValid()) {
+                logger.debug('Using memory cached collection index');
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'memory-hit');
+                return memoryCached;
+            }
+            // Check if we have valid disk cached data
+            if (this.isValid()) {
+                logger.debug('Using valid disk cached collection index');
+                const result = this.cache.data;
+                this.memoryCache.set('collection-index', result);
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-hit');
+                return result;
+            }
+            // Prevent concurrent fetches
+            if (this.fetchPromise) {
+                logger.debug('Waiting for ongoing collection index fetch');
+                return await this.fetchPromise;
+            }
+            // Lazy loading: Only fetch if not in lazy mode or absolutely necessary
+            if (lazyLoad && this.cache?.data) {
+                logger.debug('Using stale cache in lazy load mode');
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'lazy-stale');
+                return this.cache.data;
+            }
+            // Create fetch promise to prevent concurrent requests
+            this.fetchPromise = this.fetchFreshWithFallback();
+            try {
+                const result = await this.fetchPromise;
+                this.memoryCache.set('collection-index', result);
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'fresh-fetch');
+                return result;
+            }
+            finally {
+                this.fetchPromise = null;
+            }
+        }
+        catch (error) {
+            logger.error('Failed to get collection index:', error);
+            // Try loading from persistent cache as last resort
+            const persistentCache = await this.loadFromDisk();
+            if (persistentCache) {
+                logger.debug('Using persistent cache as last resort');
+                this.cache = persistentCache;
+                const result = persistentCache.data;
+                this.memoryCache.set('collection-index', result);
+                this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-fallback');
+                return result;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if current cache is valid (within TTL)
+     */
+    isValid() {
+        if (!this.cache) {
+            return false;
+        }
+        const age = Date.now() - this.cache.fetchedAt.getTime();
+        return age < this.TTL;
+    }
+    /**
+     * Fetch fresh index from GitHub with conditional requests
+     */
+    async fetchFresh() {
+        try {
+            // Build headers for conditional request
+            const headers = {
+                'Accept': 'application/json',
+                'User-Agent': 'DollhouseMCP/1.0'
+            };
+            // Add conditional headers if we have cache
+            if (this.cache?.etag) {
+                headers['If-None-Match'] = this.cache.etag;
+            }
+            if (this.cache?.lastModified) {
+                headers['If-Modified-Since'] = this.cache.lastModified;
+            }
+            // Use fetch directly for better control over conditional requests
+            const response = await fetch(this.INDEX_URL, { headers });
+            // 304 Not Modified - use cached data
+            if (response.status === 304) {
+                if (this.cache) {
+                    // Update timestamp to extend cache validity
+                    this.cache.fetchedAt = new Date();
+                    await this.saveToDisk(this.cache);
+                    logger.debug('Collection index not modified - refreshed cache timestamp');
+                    return this.cache.data;
+                }
+            }
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const indexData = await response.json();
+            // Validate the index structure
+            if (!this.validateIndexStructure(indexData)) {
+                throw new Error('Invalid collection index structure received');
+            }
+            // Create new cache entry
+            const newCache = {
+                data: indexData,
+                fetchedAt: new Date(),
+                etag: response.headers.get('etag') || undefined,
+                lastModified: response.headers.get('last-modified') || undefined
+            };
+            this.cache = newCache;
+            // Save to persistent cache in background
+            this.saveToDisk(newCache).catch(error => {
+                logger.debug('Failed to save index cache to disk:', error);
+            });
+            logger.debug(`Fresh collection index fetched with ${indexData.total_elements} elements`);
+            return indexData;
+        }
+        catch (error) {
+            logger.debug('Failed to fetch fresh collection index:', error);
+            return null;
+        }
+    }
+    /**
+     * Validate the structure of a collection index
+     */
+    validateIndexStructure(index) {
+        return (index &&
+            typeof index === 'object' &&
+            typeof index.version === 'string' &&
+            typeof index.generated === 'string' &&
+            typeof index.total_elements === 'number' &&
+            index.index &&
+            typeof index.index === 'object' &&
+            index.metadata &&
+            typeof index.metadata === 'object');
+    }
+    /**
+     * Save cache to persistent storage
+     */
+    async saveToDisk(cache) {
+        try {
+            await this.ensureCacheDir();
+            const cacheData = {
+                ...cache,
+                fetchedAt: cache.fetchedAt.toISOString() // Serialize date
+            };
+            const data = JSON.stringify(cacheData, null, 2);
+            await fs.writeFile(this.cacheFile, data, 'utf8');
+            logger.debug('Collection index cache saved to disk');
+        }
+        catch (error) {
+            logger.debug('Failed to save collection index cache:', error);
+            // Don't throw - cache persistence failures shouldn't break functionality
+        }
+    }
+    /**
+     * Load cache from persistent storage
+     */
+    async loadFromDisk() {
+        try {
+            // Basic security check for path traversal
+            if (this.cacheFile.includes('..') || this.cacheFile.includes('\0')) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'PATH_TRAVERSAL_ATTEMPT',
+                    severity: 'HIGH',
+                    source: 'CollectionIndexCache.loadFromDisk',
+                    details: `Potential path traversal attempt detected: ${this.cacheFile.substring(0, 100)}`
+                });
+                return null;
+            }
+            const data = await fs.readFile(this.cacheFile, 'utf8');
+            const cacheData = JSON.parse(data);
+            return {
+                ...cacheData,
+                fetchedAt: new Date(cacheData.fetchedAt) // Deserialize date
+            };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug('Failed to load collection index cache from disk:', error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Ensure cache directory exists
+     */
+    async ensureCacheDir() {
+        try {
+            await fs.mkdir(this.cacheDir, { recursive: true });
+        }
+        catch (error) {
+            logger.error('Failed to create cache directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear all cache data with performance monitoring
+     */
+    async clearCache() {
+        const startTime = Date.now();
+        this.cache = null;
+        this.memoryCache.clear();
+        // Cancel any ongoing fetch
+        this.fetchPromise = null;
+        try {
+            await fs.unlink(this.cacheFile);
+            logger.debug('Collection index cache cleared from disk');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug('Failed to clear collection index cache:', error);
+            }
+        }
+        logger.debug('Collection cache cleared', {
+            duration: Date.now() - startTime,
+            memoryFreed: this.memoryCache.getMemoryUsageMB()
+        });
+    }
+    /**
+     * Get comprehensive cache statistics for debugging and monitoring
+     */
+    getCacheStats() {
+        if (!this.cache) {
+            return {
+                isValid: false,
+                age: 0,
+                hasCache: false,
+                elements: 0,
+                memoryCache: this.memoryCache.getStats(),
+                performanceMetrics: null
+            };
+        }
+        const age = Date.now() - this.cache.fetchedAt.getTime();
+        return {
+            isValid: this.isValid(),
+            age,
+            hasCache: true,
+            elements: this.cache.data.total_elements,
+            memoryCache: this.memoryCache.getStats(),
+            performanceMetrics: {
+                cacheHitRate: this.calculateCacheHitRate(),
+                averageAccessTime: this.calculateAverageAccessTime()
+            }
+        };
+    }
+    // =====================================================
+    // PRIVATE HELPER METHODS FOR PERFORMANCE
+    // =====================================================
+    /**
+     * Fetch fresh index with comprehensive fallback strategy
+     */
+    async fetchFreshWithFallback() {
+        try {
+            // Try to fetch fresh index
+            const freshIndex = await this.fetchFresh();
+            if (freshIndex) {
+                logger.debug('Collection index fetched successfully');
+                return freshIndex;
+            }
+        }
+        catch (error) {
+            logger.warn('Fresh fetch failed, trying fallback', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        // Fall back to stale cache if available
+        if (this.cache?.data) {
+            logger.debug('Using stale cached collection index as fallback');
+            return this.cache.data;
+        }
+        throw new Error('No collection index available - fresh fetch failed and no cache exists');
+    }
+    /**
+     * Record performance metrics for cache operations
+     */
+    recordPerformanceMetrics(startTime, memoryBefore, operation) {
+        const duration = Date.now() - startTime;
+        const memoryAfter = process.memoryUsage().heapUsed;
+        logger.debug('Collection cache operation completed', {
+            operation,
+            duration,
+            memoryUsageMB: (memoryAfter - memoryBefore) / (1024 * 1024)
+        });
+        // Record cache performance metrics
+        this.performanceMonitor.recordCachePerformance('collectionIndex', {
+            hitRate: operation.includes('hit') ? 1 : 0,
+            avgHitTime: operation.includes('hit') ? duration : 0,
+            avgMissTime: operation.includes('hit') ? 0 : duration,
+            totalHits: operation.includes('hit') ? 1 : 0,
+            totalMisses: operation.includes('hit') ? 0 : 1,
+            evictions: 0
+        });
+    }
+    /**
+     * Calculate cache hit rate (placeholder for future implementation)
+     */
+    calculateCacheHitRate() {
+        // This would be implemented with actual metrics tracking
+        return this.memoryCache.getStats().hitRate;
+    }
+    /**
+     * Calculate average access time (placeholder for future implementation)
+     */
+    calculateAverageAccessTime() {
+        // This would be implemented with actual timing metrics
+        return 5; // Placeholder value
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionIndexCache.js","sourceRoot":"","sources":["../../src/cache/CollectionIndexCache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Smart cache for collection index with conditional fetching and performance optimization\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { CollectionIndex, CachedIndex } from '../types/collection.js';\nimport { logger } from '../utils/logger.js';\nimport { GitHubClient } from '../collection/GitHubClient.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { LRUCache, CacheFactory } from './LRUCache.js';\nimport { PerformanceMonitor } from '../utils/PerformanceMonitor.js';\n\nexport class CollectionIndexCache {\n  private cache: CachedIndex | null = null;\n  private readonly TTL = 15 * 60 * 1000; // 15 minutes in milliseconds\n  private readonly INDEX_URL = 'https://raw.githubusercontent.com/DollhouseMCP/collection/main/public/collection-index.json';\n  private cacheDir: string;\n  private cacheFile: string;\n  private githubClient: GitHubClient;\n  private performanceMonitor: PerformanceMonitor;\n  private memoryCache: LRUCache<any>;\n  private fetchPromise: Promise<CollectionIndex> | null = null; // Prevent concurrent fetches\n  \n  constructor(githubClient: GitHubClient, baseDir: string = process.cwd()) {\n    this.githubClient = githubClient;\n    this.cacheDir = path.join(baseDir, '.dollhousemcp', 'cache');\n    this.cacheFile = path.join(this.cacheDir, 'collection-index-cache.json');\n    this.performanceMonitor = PerformanceMonitor.getInstance();\n    \n    // Initialize memory cache for frequently accessed data\n    this.memoryCache = CacheFactory.createAPICache({\n      maxSize: 50,\n      maxMemoryMB: 10,\n      ttlMs: 5 * 60 * 1000, // 5 minutes\n      onEviction: (key, value) => {\n        logger.debug('Collection memory cache eviction', { key });\n      }\n    });\n  }\n  \n  /**\n   * Get the collection index with performance optimization and lazy loading\n   */\n  async getIndex(lazyLoad: boolean = false): Promise<CollectionIndex> {\n    const startTime = Date.now();\n    const memoryBefore = process.memoryUsage().heapUsed;\n    \n    try {\n      // Check memory cache first for fastest access\n      const memoryCached = this.memoryCache.get('collection-index');\n      if (memoryCached && this.isValid()) {\n        logger.debug('Using memory cached collection index');\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'memory-hit');\n        return memoryCached;\n      }\n      \n      // Check if we have valid disk cached data\n      if (this.isValid()) {\n        logger.debug('Using valid disk cached collection index');\n        const result = this.cache!.data;\n        this.memoryCache.set('collection-index', result);\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-hit');\n        return result;\n      }\n      \n      // Prevent concurrent fetches\n      if (this.fetchPromise) {\n        logger.debug('Waiting for ongoing collection index fetch');\n        return await this.fetchPromise;\n      }\n      \n      // Lazy loading: Only fetch if not in lazy mode or absolutely necessary\n      if (lazyLoad && this.cache?.data) {\n        logger.debug('Using stale cache in lazy load mode');\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'lazy-stale');\n        return this.cache.data;\n      }\n      \n      // Create fetch promise to prevent concurrent requests\n      this.fetchPromise = this.fetchFreshWithFallback();\n      \n      try {\n        const result = await this.fetchPromise;\n        this.memoryCache.set('collection-index', result);\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'fresh-fetch');\n        return result;\n      } finally {\n        this.fetchPromise = null;\n      }\n      \n    } catch (error) {\n      logger.error('Failed to get collection index:', error);\n      \n      // Try loading from persistent cache as last resort\n      const persistentCache = await this.loadFromDisk();\n      if (persistentCache) {\n        logger.debug('Using persistent cache as last resort');\n        this.cache = persistentCache;\n        const result = persistentCache.data;\n        this.memoryCache.set('collection-index', result);\n        this.recordPerformanceMetrics(startTime, memoryBefore, 'disk-fallback');\n        return result;\n      }\n      \n      throw error;\n    }\n  }\n  \n  /**\n   * Check if current cache is valid (within TTL)\n   */\n  private isValid(): boolean {\n    if (!this.cache) {\n      return false;\n    }\n    \n    const age = Date.now() - this.cache.fetchedAt.getTime();\n    return age < this.TTL;\n  }\n  \n  /**\n   * Fetch fresh index from GitHub with conditional requests\n   */\n  private async fetchFresh(): Promise<CollectionIndex | null> {\n    try {\n      // Build headers for conditional request\n      const headers: Record<string, string> = {\n        'Accept': 'application/json',\n        'User-Agent': 'DollhouseMCP/1.0'\n      };\n      \n      // Add conditional headers if we have cache\n      if (this.cache?.etag) {\n        headers['If-None-Match'] = this.cache.etag;\n      }\n      if (this.cache?.lastModified) {\n        headers['If-Modified-Since'] = this.cache.lastModified;\n      }\n      \n      // Use fetch directly for better control over conditional requests\n      const response = await fetch(this.INDEX_URL, { headers });\n      \n      // 304 Not Modified - use cached data\n      if (response.status === 304) {\n        if (this.cache) {\n          // Update timestamp to extend cache validity\n          this.cache.fetchedAt = new Date();\n          await this.saveToDisk(this.cache);\n          logger.debug('Collection index not modified - refreshed cache timestamp');\n          return this.cache.data;\n        }\n      }\n      \n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n      \n      const indexData = await response.json() as CollectionIndex;\n      \n      // Validate the index structure\n      if (!this.validateIndexStructure(indexData)) {\n        throw new Error('Invalid collection index structure received');\n      }\n      \n      // Create new cache entry\n      const newCache: CachedIndex = {\n        data: indexData,\n        fetchedAt: new Date(),\n        etag: response.headers.get('etag') || undefined,\n        lastModified: response.headers.get('last-modified') || undefined\n      };\n      \n      this.cache = newCache;\n      \n      // Save to persistent cache in background\n      this.saveToDisk(newCache).catch(error => {\n        logger.debug('Failed to save index cache to disk:', error);\n      });\n      \n      logger.debug(`Fresh collection index fetched with ${indexData.total_elements} elements`);\n      return indexData;\n      \n    } catch (error) {\n      logger.debug('Failed to fetch fresh collection index:', error);\n      return null;\n    }\n  }\n  \n  /**\n   * Validate the structure of a collection index\n   */\n  private validateIndexStructure(index: any): index is CollectionIndex {\n    return (\n      index &&\n      typeof index === 'object' &&\n      typeof index.version === 'string' &&\n      typeof index.generated === 'string' &&\n      typeof index.total_elements === 'number' &&\n      index.index &&\n      typeof index.index === 'object' &&\n      index.metadata &&\n      typeof index.metadata === 'object'\n    );\n  }\n  \n  /**\n   * Save cache to persistent storage\n   */\n  private async saveToDisk(cache: CachedIndex): Promise<void> {\n    try {\n      await this.ensureCacheDir();\n      \n      const cacheData = {\n        ...cache,\n        fetchedAt: cache.fetchedAt.toISOString() // Serialize date\n      };\n      \n      const data = JSON.stringify(cacheData, null, 2);\n      await fs.writeFile(this.cacheFile, data, 'utf8');\n      \n      logger.debug('Collection index cache saved to disk');\n    } catch (error) {\n      logger.debug('Failed to save collection index cache:', error);\n      // Don't throw - cache persistence failures shouldn't break functionality\n    }\n  }\n  \n  /**\n   * Load cache from persistent storage\n   */\n  private async loadFromDisk(): Promise<CachedIndex | null> {\n    try {\n      // Basic security check for path traversal\n      if (this.cacheFile.includes('..') || this.cacheFile.includes('\\0')) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'PATH_TRAVERSAL_ATTEMPT',\n          severity: 'HIGH',\n          source: 'CollectionIndexCache.loadFromDisk',\n          details: `Potential path traversal attempt detected: ${this.cacheFile.substring(0, 100)}`\n        });\n        return null;\n      }\n      \n      const data = await fs.readFile(this.cacheFile, 'utf8');\n      const cacheData = JSON.parse(data);\n      \n      return {\n        ...cacheData,\n        fetchedAt: new Date(cacheData.fetchedAt) // Deserialize date\n      };\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug('Failed to load collection index cache from disk:', error);\n      }\n      return null;\n    }\n  }\n  \n  /**\n   * Ensure cache directory exists\n   */\n  private async ensureCacheDir(): Promise<void> {\n    try {\n      await fs.mkdir(this.cacheDir, { recursive: true });\n    } catch (error) {\n      logger.error('Failed to create cache directory:', error);\n      throw error;\n    }\n  }\n  \n  /**\n   * Clear all cache data with performance monitoring\n   */\n  async clearCache(): Promise<void> {\n    const startTime = Date.now();\n    \n    this.cache = null;\n    this.memoryCache.clear();\n    \n    // Cancel any ongoing fetch\n    this.fetchPromise = null;\n    \n    try {\n      await fs.unlink(this.cacheFile);\n      logger.debug('Collection index cache cleared from disk');\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug('Failed to clear collection index cache:', error);\n      }\n    }\n    \n    logger.debug('Collection cache cleared', {\n      duration: Date.now() - startTime,\n      memoryFreed: this.memoryCache.getMemoryUsageMB()\n    });\n  }\n  \n  /**\n   * Get comprehensive cache statistics for debugging and monitoring\n   */\n  getCacheStats(): { \n    isValid: boolean; \n    age: number; \n    hasCache: boolean; \n    elements: number;\n    memoryCache: any;\n    performanceMetrics: any;\n  } {\n    if (!this.cache) {\n      return { \n        isValid: false, \n        age: 0, \n        hasCache: false, \n        elements: 0,\n        memoryCache: this.memoryCache.getStats(),\n        performanceMetrics: null\n      };\n    }\n    \n    const age = Date.now() - this.cache.fetchedAt.getTime();\n    return {\n      isValid: this.isValid(),\n      age,\n      hasCache: true,\n      elements: this.cache.data.total_elements,\n      memoryCache: this.memoryCache.getStats(),\n      performanceMetrics: {\n        cacheHitRate: this.calculateCacheHitRate(),\n        averageAccessTime: this.calculateAverageAccessTime()\n      }\n    };\n  }\n  \n  // =====================================================\n  // PRIVATE HELPER METHODS FOR PERFORMANCE\n  // =====================================================\n  \n  /**\n   * Fetch fresh index with comprehensive fallback strategy\n   */\n  private async fetchFreshWithFallback(): Promise<CollectionIndex> {\n    try {\n      // Try to fetch fresh index\n      const freshIndex = await this.fetchFresh();\n      if (freshIndex) {\n        logger.debug('Collection index fetched successfully');\n        return freshIndex;\n      }\n    } catch (error) {\n      logger.warn('Fresh fetch failed, trying fallback', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n    }\n    \n    // Fall back to stale cache if available\n    if (this.cache?.data) {\n      logger.debug('Using stale cached collection index as fallback');\n      return this.cache.data;\n    }\n    \n    throw new Error('No collection index available - fresh fetch failed and no cache exists');\n  }\n  \n  /**\n   * Record performance metrics for cache operations\n   */\n  private recordPerformanceMetrics(startTime: number, memoryBefore: number, operation: string): void {\n    const duration = Date.now() - startTime;\n    const memoryAfter = process.memoryUsage().heapUsed;\n    \n    logger.debug('Collection cache operation completed', {\n      operation,\n      duration,\n      memoryUsageMB: (memoryAfter - memoryBefore) / (1024 * 1024)\n    });\n    \n    // Record cache performance metrics\n    this.performanceMonitor.recordCachePerformance('collectionIndex', {\n      hitRate: operation.includes('hit') ? 1 : 0,\n      avgHitTime: operation.includes('hit') ? duration : 0,\n      avgMissTime: operation.includes('hit') ? 0 : duration,\n      totalHits: operation.includes('hit') ? 1 : 0,\n      totalMisses: operation.includes('hit') ? 0 : 1,\n      evictions: 0\n    });\n  }\n  \n  /**\n   * Calculate cache hit rate (placeholder for future implementation)\n   */\n  private calculateCacheHitRate(): number {\n    // This would be implemented with actual metrics tracking\n    return this.memoryCache.getStats().hitRate;\n  }\n  \n  /**\n   * Calculate average access time (placeholder for future implementation)\n   */\n  private calculateAverageAccessTime(): number {\n    // This would be implemented with actual timing metrics\n    return 5; // Placeholder value\n  }\n}"]}

package/dist/cache/LRUCache.d.ts

@@ -0,0 +1,93 @@
+/**
+ * High-performance LRU Cache with memory monitoring and automatic cleanup
+ * Optimized for large-scale indexing operations with configurable memory limits
+ */
+export interface LRUCacheOptions {
+    maxSize: number;
+    maxMemoryMB?: number;
+    ttlMs?: number;
+    onEviction?: (key: string, value: any) => void;
+}
+export interface CacheStats {
+    size: number;
+    maxSize: number;
+    hitCount: number;
+    missCount: number;
+    evictionCount: number;
+    memoryUsageMB: number;
+    hitRate: number;
+}
+export declare class LRUCache<T> {
+    private readonly maxSize;
+    private readonly maxMemoryBytes;
+    private readonly ttlMs;
+    private readonly onEviction?;
+    private cache;
+    private head;
+    private tail;
+    private currentMemoryBytes;
+    private hitCount;
+    private missCount;
+    private evictionCount;
+    constructor(options: LRUCacheOptions);
+    /**
+     * Get value from cache with automatic cleanup
+     */
+    get(key: string): T | null;
+    /**
+     * Set value in cache with automatic eviction
+     */
+    set(key: string, value: T): void;
+    /**
+     * Delete specific key from cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all entries from cache
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get all keys in access order (most recent first)
+     */
+    keys(): string[];
+    /**
+     * Get current memory usage in MB
+     */
+    getMemoryUsageMB(): number;
+    /**
+     * Manually trigger cleanup of expired entries
+     */
+    cleanup(): number;
+    private moveToFront;
+    private addToFront;
+    private removeNode;
+    private evictIfNecessary;
+    private evictLeastRecentlyUsed;
+    private estimateSize;
+}
+/**
+ * Factory for creating optimized LRU caches for different use cases
+ */
+export declare class CacheFactory {
+    /**
+     * Create cache optimized for search results
+     */
+    static createSearchResultCache<T>(options?: Partial<LRUCacheOptions>): LRUCache<T>;
+    /**
+     * Create cache optimized for index data
+     */
+    static createIndexCache<T>(options?: Partial<LRUCacheOptions>): LRUCache<T>;
+    /**
+     * Create cache optimized for API responses
+     */
+    static createAPICache<T>(options?: Partial<LRUCacheOptions>): LRUCache<T>;
+}
+//# sourceMappingURL=LRUCache.d.ts.map

package/dist/cache/LRUCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LRUCache.d.ts","sourceRoot":"","sources":["../../src/cache/LRUCache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CAChD;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAWD,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAkC;IAE9D,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,kBAAkB,CAAK;IAG/B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,aAAa,CAAK;gBAEd,OAAO,EAAE,eAAe;IAOpC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAqB1B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAgChC;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAiB5B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAezB;;OAEG;IACH,KAAK,IAAI,IAAI;IAcb;;OAEG;IACH,QAAQ,IAAI,UAAU;IAYtB;;OAEG;IACH,IAAI,IAAI,MAAM,EAAE;IAYhB;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;OAEG;IACH,OAAO,IAAI,MAAM;IAuBjB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,sBAAsB;IAgB9B,OAAO,CAAC,YAAY;CA8BrB;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;IASlF;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;IAS3E;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;CAQ1E"}