@dollhousemcp/mcp-server 1.5.2 → 1.6.0

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"}

package/dist/cache/LRUCache.js

@@ -0,0 +1,299 @@
+/**
+ * High-performance LRU Cache with memory monitoring and automatic cleanup
+ * Optimized for large-scale indexing operations with configurable memory limits
+ */
+export class LRUCache {
+    maxSize;
+    maxMemoryBytes;
+    ttlMs;
+    onEviction;
+    cache = new Map();
+    head = null;
+    tail = null;
+    currentMemoryBytes = 0;
+    // Performance counters
+    hitCount = 0;
+    missCount = 0;
+    evictionCount = 0;
+    constructor(options) {
+        this.maxSize = options.maxSize;
+        this.maxMemoryBytes = (options.maxMemoryMB || 50) * 1024 * 1024; // Convert MB to bytes
+        this.ttlMs = options.ttlMs || 0; // 0 means no TTL
+        this.onEviction = options.onEviction;
+    }
+    /**
+     * Get value from cache with automatic cleanup
+     */
+    get(key) {
+        const node = this.cache.get(key);
+        if (!node) {
+            this.missCount++;
+            return null;
+        }
+        // Check TTL if enabled
+        if (this.ttlMs > 0 && Date.now() - node.timestamp > this.ttlMs) {
+            this.delete(key);
+            this.missCount++;
+            return null;
+        }
+        // Move to front (most recently used)
+        this.moveToFront(node);
+        this.hitCount++;
+        return node.value;
+    }
+    /**
+     * Set value in cache with automatic eviction
+     */
+    set(key, value) {
+        const existingNode = this.cache.get(key);
+        if (existingNode) {
+            // Update existing node
+            const oldSize = existingNode.size;
+            existingNode.value = value;
+            existingNode.timestamp = Date.now();
+            existingNode.size = this.estimateSize(value);
+            this.currentMemoryBytes += existingNode.size - oldSize;
+            this.moveToFront(existingNode);
+        }
+        else {
+            // Create new node
+            const newNode = {
+                key,
+                value,
+                prev: null,
+                next: null,
+                timestamp: Date.now(),
+                size: this.estimateSize(value)
+            };
+            this.cache.set(key, newNode);
+            this.currentMemoryBytes += newNode.size;
+            this.addToFront(newNode);
+        }
+        // Evict if necessary
+        this.evictIfNecessary();
+    }
+    /**
+     * Delete specific key from cache
+     */
+    delete(key) {
+        const node = this.cache.get(key);
+        if (!node) {
+            return false;
+        }
+        this.removeNode(node);
+        this.cache.delete(key);
+        this.currentMemoryBytes -= node.size;
+        if (this.onEviction) {
+            this.onEviction(key, node.value);
+        }
+        return true;
+    }
+    /**
+     * Check if key exists in cache
+     */
+    has(key) {
+        const node = this.cache.get(key);
+        if (!node) {
+            return false;
+        }
+        // Check TTL
+        if (this.ttlMs > 0 && Date.now() - node.timestamp > this.ttlMs) {
+            this.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Clear all entries from cache
+     */
+    clear() {
+        if (this.onEviction) {
+            for (const [key, node] of this.cache) {
+                this.onEviction(key, node.value);
+            }
+        }
+        this.cache.clear();
+        this.head = null;
+        this.tail = null;
+        this.currentMemoryBytes = 0;
+        this.evictionCount += this.cache.size;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            hitCount: this.hitCount,
+            missCount: this.missCount,
+            evictionCount: this.evictionCount,
+            memoryUsageMB: this.currentMemoryBytes / (1024 * 1024),
+            hitRate: this.hitCount + this.missCount > 0 ? this.hitCount / (this.hitCount + this.missCount) : 0
+        };
+    }
+    /**
+     * Get all keys in access order (most recent first)
+     */
+    keys() {
+        const keys = [];
+        let current = this.head;
+        while (current) {
+            keys.push(current.key);
+            current = current.next;
+        }
+        return keys;
+    }
+    /**
+     * Get current memory usage in MB
+     */
+    getMemoryUsageMB() {
+        return this.currentMemoryBytes / (1024 * 1024);
+    }
+    /**
+     * Manually trigger cleanup of expired entries
+     */
+    cleanup() {
+        if (this.ttlMs <= 0) {
+            return 0;
+        }
+        const now = Date.now();
+        const keysToDelete = [];
+        for (const [key, node] of this.cache) {
+            if (now - node.timestamp > this.ttlMs) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.delete(key);
+        }
+        return keysToDelete.length;
+    }
+    // Private methods
+    moveToFront(node) {
+        if (node === this.head) {
+            return; // Already at front
+        }
+        // Remove from current position
+        this.removeNode(node);
+        // Add to front
+        this.addToFront(node);
+    }
+    addToFront(node) {
+        node.prev = null;
+        node.next = this.head;
+        if (this.head) {
+            this.head.prev = node;
+        }
+        this.head = node;
+        if (!this.tail) {
+            this.tail = node;
+        }
+    }
+    removeNode(node) {
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+    }
+    evictIfNecessary() {
+        // Evict by size
+        while (this.cache.size > this.maxSize) {
+            this.evictLeastRecentlyUsed();
+        }
+        // Evict by memory
+        while (this.currentMemoryBytes > this.maxMemoryBytes && this.tail) {
+            this.evictLeastRecentlyUsed();
+        }
+        // Cleanup expired entries if TTL is enabled
+        if (this.ttlMs > 0 && Math.random() < 0.1) { // 10% chance to trigger cleanup
+            this.cleanup();
+        }
+    }
+    evictLeastRecentlyUsed() {
+        if (!this.tail) {
+            return;
+        }
+        const evicted = this.tail;
+        this.removeNode(evicted);
+        this.cache.delete(evicted.key);
+        this.currentMemoryBytes -= evicted.size;
+        this.evictionCount++;
+        if (this.onEviction) {
+            this.onEviction(evicted.key, evicted.value);
+        }
+    }
+    estimateSize(value) {
+        try {
+            // Simple estimation - can be improved with more sophisticated sizing
+            if (value === null || value === undefined) {
+                return 8; // Basic pointer size
+            }
+            if (typeof value === 'string') {
+                return value.length * 2; // UTF-16 characters
+            }
+            if (typeof value === 'number' || typeof value === 'boolean') {
+                return 8;
+            }
+            if (Array.isArray(value)) {
+                return value.reduce((acc, item) => acc + this.estimateSize(item), 32); // Array overhead
+            }
+            if (typeof value === 'object') {
+                // Rough estimation for objects
+                const jsonStr = JSON.stringify(value);
+                return jsonStr.length * 2 + 64; // String size + object overhead
+            }
+            return 64; // Default size for unknown types
+        }
+        catch {
+            return 64; // Fallback size
+        }
+    }
+}
+/**
+ * Factory for creating optimized LRU caches for different use cases
+ */
+export class CacheFactory {
+    /**
+     * Create cache optimized for search results
+     */
+    static createSearchResultCache(options) {
+        return new LRUCache({
+            maxSize: 100,
+            maxMemoryMB: 10,
+            ttlMs: 5 * 60 * 1000, // 5 minutes
+            ...options
+        });
+    }
+    /**
+     * Create cache optimized for index data
+     */
+    static createIndexCache(options) {
+        return new LRUCache({
+            maxSize: 50,
+            maxMemoryMB: 25,
+            ttlMs: 15 * 60 * 1000, // 15 minutes
+            ...options
+        });
+    }
+    /**
+     * Create cache optimized for API responses
+     */
+    static createAPICache(options) {
+        return new LRUCache({
+            maxSize: 200,
+            maxMemoryMB: 5,
+            ttlMs: 10 * 60 * 1000, // 10 minutes
+            ...options
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LRUCache.js","sourceRoot":"","sources":["../../src/cache/LRUCache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * High-performance LRU Cache with memory monitoring and automatic cleanup\n * Optimized for large-scale indexing operations with configurable memory limits\n */\n\nimport { logger } from '../utils/logger.js';\n\nexport interface LRUCacheOptions {\n  maxSize: number;\n  maxMemoryMB?: number;\n  ttlMs?: number;\n  onEviction?: (key: string, value: any) => void;\n}\n\nexport interface CacheStats {\n  size: number;\n  maxSize: number;\n  hitCount: number;\n  missCount: number;\n  evictionCount: number;\n  memoryUsageMB: number;\n  hitRate: number;\n}\n\ninterface CacheNode<T> {\n  key: string;\n  value: T;\n  prev: CacheNode<T> | null;\n  next: CacheNode<T> | null;\n  timestamp: number;\n  size: number; // Estimated size in bytes\n}\n\nexport class LRUCache<T> {\n  private readonly maxSize: number;\n  private readonly maxMemoryBytes: number;\n  private readonly ttlMs: number;\n  private readonly onEviction?: (key: string, value: T) => void;\n\n  private cache = new Map<string, CacheNode<T>>();\n  private head: CacheNode<T> | null = null;\n  private tail: CacheNode<T> | null = null;\n  private currentMemoryBytes = 0;\n\n  // Performance counters\n  private hitCount = 0;\n  private missCount = 0;\n  private evictionCount = 0;\n\n  constructor(options: LRUCacheOptions) {\n    this.maxSize = options.maxSize;\n    this.maxMemoryBytes = (options.maxMemoryMB || 50) * 1024 * 1024; // Convert MB to bytes\n    this.ttlMs = options.ttlMs || 0; // 0 means no TTL\n    this.onEviction = options.onEviction;\n  }\n\n  /**\n   * Get value from cache with automatic cleanup\n   */\n  get(key: string): T | null {\n    const node = this.cache.get(key);\n    \n    if (!node) {\n      this.missCount++;\n      return null;\n    }\n\n    // Check TTL if enabled\n    if (this.ttlMs > 0 && Date.now() - node.timestamp > this.ttlMs) {\n      this.delete(key);\n      this.missCount++;\n      return null;\n    }\n\n    // Move to front (most recently used)\n    this.moveToFront(node);\n    this.hitCount++;\n    return node.value;\n  }\n\n  /**\n   * Set value in cache with automatic eviction\n   */\n  set(key: string, value: T): void {\n    const existingNode = this.cache.get(key);\n    \n    if (existingNode) {\n      // Update existing node\n      const oldSize = existingNode.size;\n      existingNode.value = value;\n      existingNode.timestamp = Date.now();\n      existingNode.size = this.estimateSize(value);\n      \n      this.currentMemoryBytes += existingNode.size - oldSize;\n      this.moveToFront(existingNode);\n    } else {\n      // Create new node\n      const newNode: CacheNode<T> = {\n        key,\n        value,\n        prev: null,\n        next: null,\n        timestamp: Date.now(),\n        size: this.estimateSize(value)\n      };\n\n      this.cache.set(key, newNode);\n      this.currentMemoryBytes += newNode.size;\n      this.addToFront(newNode);\n    }\n\n    // Evict if necessary\n    this.evictIfNecessary();\n  }\n\n  /**\n   * Delete specific key from cache\n   */\n  delete(key: string): boolean {\n    const node = this.cache.get(key);\n    if (!node) {\n      return false;\n    }\n\n    this.removeNode(node);\n    this.cache.delete(key);\n    this.currentMemoryBytes -= node.size;\n\n    if (this.onEviction) {\n      this.onEviction(key, node.value);\n    }\n\n    return true;\n  }\n\n  /**\n   * Check if key exists in cache\n   */\n  has(key: string): boolean {\n    const node = this.cache.get(key);\n    if (!node) {\n      return false;\n    }\n\n    // Check TTL\n    if (this.ttlMs > 0 && Date.now() - node.timestamp > this.ttlMs) {\n      this.delete(key);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Clear all entries from cache\n   */\n  clear(): void {\n    if (this.onEviction) {\n      for (const [key, node] of this.cache) {\n        this.onEviction(key, node.value);\n      }\n    }\n\n    this.cache.clear();\n    this.head = null;\n    this.tail = null;\n    this.currentMemoryBytes = 0;\n    this.evictionCount += this.cache.size;\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getStats(): CacheStats {\n    return {\n      size: this.cache.size,\n      maxSize: this.maxSize,\n      hitCount: this.hitCount,\n      missCount: this.missCount,\n      evictionCount: this.evictionCount,\n      memoryUsageMB: this.currentMemoryBytes / (1024 * 1024),\n      hitRate: this.hitCount + this.missCount > 0 ? this.hitCount / (this.hitCount + this.missCount) : 0\n    };\n  }\n\n  /**\n   * Get all keys in access order (most recent first)\n   */\n  keys(): string[] {\n    const keys: string[] = [];\n    let current = this.head;\n    \n    while (current) {\n      keys.push(current.key);\n      current = current.next;\n    }\n    \n    return keys;\n  }\n\n  /**\n   * Get current memory usage in MB\n   */\n  getMemoryUsageMB(): number {\n    return this.currentMemoryBytes / (1024 * 1024);\n  }\n\n  /**\n   * Manually trigger cleanup of expired entries\n   */\n  cleanup(): number {\n    if (this.ttlMs <= 0) {\n      return 0;\n    }\n\n    const now = Date.now();\n    const keysToDelete: string[] = [];\n\n    for (const [key, node] of this.cache) {\n      if (now - node.timestamp > this.ttlMs) {\n        keysToDelete.push(key);\n      }\n    }\n\n    for (const key of keysToDelete) {\n      this.delete(key);\n    }\n\n    return keysToDelete.length;\n  }\n\n  // Private methods\n\n  private moveToFront(node: CacheNode<T>): void {\n    if (node === this.head) {\n      return; // Already at front\n    }\n\n    // Remove from current position\n    this.removeNode(node);\n    \n    // Add to front\n    this.addToFront(node);\n  }\n\n  private addToFront(node: CacheNode<T>): void {\n    node.prev = null;\n    node.next = this.head;\n\n    if (this.head) {\n      this.head.prev = node;\n    }\n    \n    this.head = node;\n\n    if (!this.tail) {\n      this.tail = node;\n    }\n  }\n\n  private removeNode(node: CacheNode<T>): void {\n    if (node.prev) {\n      node.prev.next = node.next;\n    } else {\n      this.head = node.next;\n    }\n\n    if (node.next) {\n      node.next.prev = node.prev;\n    } else {\n      this.tail = node.prev;\n    }\n  }\n\n  private evictIfNecessary(): void {\n    // Evict by size\n    while (this.cache.size > this.maxSize) {\n      this.evictLeastRecentlyUsed();\n    }\n\n    // Evict by memory\n    while (this.currentMemoryBytes > this.maxMemoryBytes && this.tail) {\n      this.evictLeastRecentlyUsed();\n    }\n\n    // Cleanup expired entries if TTL is enabled\n    if (this.ttlMs > 0 && Math.random() < 0.1) { // 10% chance to trigger cleanup\n      this.cleanup();\n    }\n  }\n\n  private evictLeastRecentlyUsed(): void {\n    if (!this.tail) {\n      return;\n    }\n\n    const evicted = this.tail;\n    this.removeNode(evicted);\n    this.cache.delete(evicted.key);\n    this.currentMemoryBytes -= evicted.size;\n    this.evictionCount++;\n\n    if (this.onEviction) {\n      this.onEviction(evicted.key, evicted.value);\n    }\n  }\n\n  private estimateSize(value: T): number {\n    try {\n      // Simple estimation - can be improved with more sophisticated sizing\n      if (value === null || value === undefined) {\n        return 8; // Basic pointer size\n      }\n\n      if (typeof value === 'string') {\n        return value.length * 2; // UTF-16 characters\n      }\n\n      if (typeof value === 'number' || typeof value === 'boolean') {\n        return 8;\n      }\n\n      if (Array.isArray(value)) {\n        return value.reduce((acc, item) => acc + this.estimateSize(item), 32); // Array overhead\n      }\n\n      if (typeof value === 'object') {\n        // Rough estimation for objects\n        const jsonStr = JSON.stringify(value);\n        return jsonStr.length * 2 + 64; // String size + object overhead\n      }\n\n      return 64; // Default size for unknown types\n    } catch {\n      return 64; // Fallback size\n    }\n  }\n}\n\n/**\n * Factory for creating optimized LRU caches for different use cases\n */\nexport class CacheFactory {\n  /**\n   * Create cache optimized for search results\n   */\n  static createSearchResultCache<T>(options?: Partial<LRUCacheOptions>): LRUCache<T> {\n    return new LRUCache<T>({\n      maxSize: 100,\n      maxMemoryMB: 10,\n      ttlMs: 5 * 60 * 1000, // 5 minutes\n      ...options\n    });\n  }\n\n  /**\n   * Create cache optimized for index data\n   */\n  static createIndexCache<T>(options?: Partial<LRUCacheOptions>): LRUCache<T> {\n    return new LRUCache<T>({\n      maxSize: 50,\n      maxMemoryMB: 25,\n      ttlMs: 15 * 60 * 1000, // 15 minutes\n      ...options\n    });\n  }\n\n  /**\n   * Create cache optimized for API responses\n   */\n  static createAPICache<T>(options?: Partial<LRUCacheOptions>): LRUCache<T> {\n    return new LRUCache<T>({\n      maxSize: 200,\n      maxMemoryMB: 5,\n      ttlMs: 10 * 60 * 1000, // 10 minutes\n      ...options\n    });\n  }\n}"]}

package/dist/cache/index.d.ts

@@ -3,4 +3,5 @@
  */
 export * from './APICache.js';
 export * from './CollectionCache.js';
+export * from './CollectionIndexCache.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC"}

package/dist/cache/index.js

@@ -3,4 +3,5 @@
  */
 export * from './APICache.js';
 export * from './CollectionCache.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2FjaGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDYWNoZSBtb2R1bGUgZXhwb3J0c1xuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vQVBJQ2FjaGUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9Db2xsZWN0aW9uQ2FjaGUuanMnOyJdfQ==
+export * from './CollectionIndexCache.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2FjaGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENhY2hlIG1vZHVsZSBleHBvcnRzXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9BUElDYWNoZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rpb25DYWNoZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rpb25JbmRleENhY2hlLmpzJzsiXX0=

package/dist/collection/CollectionBrowser.d.ts

@@ -3,13 +3,16 @@
  */
 import { GitHubClient } from './GitHubClient.js';
 import { CollectionCache } from '../cache/CollectionCache.js';
+import { CollectionIndexManager } from './CollectionIndexManager.js';
 export declare class CollectionBrowser {
     private githubClient;
     private collectionCache;
+    private indexManager;
     private baseUrl;
-    constructor(githubClient: GitHubClient, collectionCache?: CollectionCache);
+    constructor(githubClient: GitHubClient, collectionCache?: CollectionCache, indexManager?: CollectionIndexManager);
     /**
      * Browse collection content by section and type
+     * Uses CollectionIndexManager for fast browsing with background refresh
      * Falls back to cached data when GitHub API is not available or not authenticated
      * @param section - Top level section: library, showcase, or catalog
      * @param type - Optional content type within the library section (personas, skills, etc.)
@@ -19,6 +22,23 @@ export declare class CollectionBrowser {
         categories: any[];
         sections?: any[];
     }>;
+    /**
+     * Browse collection using the fast collection index
+     * Returns null if index is not available or browsing fails
+     */
+    private browseFromIndex;
+    /**
+     * Get unique content types from collection index
+     */
+    private getContentTypesFromIndex;
+    /**
+     * Get items from collection index by section and type
+     */
+    private getItemsFromIndex;
+    /**
+     * Convert index entries to GitHub API format for compatibility
+     */
+    private convertIndexItemsToGitHubFormat;
     /**
      * Browse collection from cached data
      */

package/dist/collection/CollectionBrowser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CollectionBrowser.d.ts","sourceRoot":"","sources":["../../src/collection/CollectionBrowser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAkB,MAAM,6BAA6B,CAAC;AAI9E,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,eAAe;IAKzE;;;;;OAKG;IACG,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IAqDvH;;OAEG;YACW,eAAe;IAwC7B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAgBhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAWvC;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAiF7H"}
+{"version":3,"file":"CollectionBrowser.d.ts","sourceRoot":"","sources":["../../src/collection/CollectionBrowser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAkB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AA+BrE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,eAAe,EAAE,YAAY,CAAC,EAAE,sBAAsB;IAMhH;;;;;;OAMG;IACG,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IA+DvH;;;OAGG;YACW,eAAe;IAiC7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAiBhC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiBzB;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAWvC;;OAEG;YACW,eAAe;IAwC7B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAqBhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAWvC;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CA6E7H"}