@dollhousemcp/mcp-server 1.5.1 → 1.6.0

package/dist/collection/CollectionBrowser.js

@@ -1,47 +1,283 @@
 /**
  * Browse collection content from GitHub
  */
+import { CollectionCache } from '../cache/CollectionCache.js';
+import { CollectionSeeder } from './CollectionSeeder.js';
+import { CollectionIndexManager } from './CollectionIndexManager.js';
+import { logger } from '../utils/logger.js';
+import { ElementType } from '../portfolio/types.js';
+// Content types supported by MCP server (Issue #144)
+// Hide: memories, ensembles from MCP queries
+// ⚠️ CRITICAL: When adding new element types, you MUST update this array!
+// Also update validTypes array in src/index.ts
+// See docs/development/ADDING_NEW_ELEMENT_TYPES_CHECKLIST.md for complete guide
+const MCP_SUPPORTED_TYPES = [
+    ElementType.PERSONA, // personas - supported by PersonaTools and ElementTools
+    ElementType.SKILL, // skills - supported by ElementTools
+    ElementType.AGENT, // agents - supported by ElementTools  
+    ElementType.TEMPLATE // templates - supported by ElementTools
+];
+/**
+ * Type guard to safely check if a string is a valid ElementType
+ */
+function isElementType(value) {
+    return Object.values(ElementType).includes(value);
+}
+/**
+ * Type guard to safely check if an ElementType is supported by MCP
+ */
+function isMCPSupportedType(elementType) {
+    return MCP_SUPPORTED_TYPES.includes(elementType);
+}
 export class CollectionBrowser {
     githubClient;
+    collectionCache;
+    indexManager;
     baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
-    constructor(githubClient) {
+    constructor(githubClient, collectionCache, indexManager) {
         this.githubClient = githubClient;
+        this.collectionCache = collectionCache || new CollectionCache();
+        this.indexManager = indexManager || new 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.)
      */
     async browseCollection(section, type) {
-        let url = this.baseUrl;
-        // If no section provided, show top-level sections
-        if (!section) {
-            const data = await this.githubClient.fetchFromGitHub(url);
+        try {
+            // Try using collection index first for faster browsing
+            const indexResult = await this.browseFromIndex(section, type);
+            if (indexResult) {
+                logger.debug('Used collection index for browsing');
+                return indexResult;
+            }
+            // Fallback to GitHub API
+            let url = this.baseUrl;
+            // If no section provided, show top-level sections
+            if (!section) {
+                const data = await this.githubClient.fetchFromGitHub(url, false);
+                if (!Array.isArray(data)) {
+                    throw new Error('Invalid collection response. Expected directory listing.');
+                }
+                // Filter to only show content directories
+                const sections = data.filter((item) => item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name));
+                return { items: [], categories: [], sections };
+            }
+            // Browse within a section
+            url = type
+                ? `${this.baseUrl}/${section}/${type}`
+                : `${this.baseUrl}/${section}`;
+            const data = await this.githubClient.fetchFromGitHub(url, false);
             if (!Array.isArray(data)) {
                 throw new Error('Invalid collection response. Expected directory listing.');
             }
-            // Filter to only show content directories
-            const sections = data.filter((item) => item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name));
-            return { items: [], categories: [], sections };
+            // In the library section, we have content type directories
+            if (section === 'library' && !type) {
+                // Filter to only show MCP-supported content types
+                const contentTypes = data.filter((item) => {
+                    if (item.type !== 'dir')
+                        return false;
+                    const elementType = isElementType(item.name) ? item.name : null;
+                    return elementType && isMCPSupportedType(elementType);
+                });
+                return { items: [], categories: contentTypes };
+            }
+            // For library content types, show files directly (flat structure)
+            const items = data.filter((item) => item.type === 'file' && item.name.endsWith('.md'));
+            // For non-library sections, they might still have subdirectories
+            const categories = section === 'library' ? [] : data.filter((item) => item.type === 'dir');
+            return { items, categories };
         }
-        // Browse within a section
-        url = type
-            ? `${this.baseUrl}/${section}/${type}`
-            : `${this.baseUrl}/${section}`;
-        const data = await this.githubClient.fetchFromGitHub(url);
-        if (!Array.isArray(data)) {
-            throw new Error('Invalid collection response. Expected directory listing.');
+        catch (error) {
+            logger.debug(`GitHub API browse failed, falling back to cache: ${error}`);
+            // Fallback to cached data
+            return this.browseFromCache(section, type);
         }
-        // In the library section, we have content type directories
+    }
+    /**
+     * Browse collection using the fast collection index
+     * Returns null if index is not available or browsing fails
+     */
+    async browseFromIndex(section, type) {
+        try {
+            const index = await this.indexManager.getIndex();
+            // If no section provided, show top-level sections
+            if (!section) {
+                const sections = [
+                    { name: 'library', type: 'dir' },
+                    { name: 'showcase', type: 'dir' },
+                    { name: 'catalog', type: 'dir' }
+                ];
+                return { items: [], categories: [], sections };
+            }
+            // In the library section, we have content type directories
+            if (section === 'library' && !type) {
+                // Get unique content types from index
+                const contentTypes = this.getContentTypesFromIndex(index);
+                return { items: [], categories: contentTypes };
+            }
+            // Get items for specific type or all items in section
+            const items = this.getItemsFromIndex(index, section, type);
+            const formattedItems = this.convertIndexItemsToGitHubFormat(items);
+            return { items: formattedItems, categories: [] };
+        }
+        catch (error) {
+            logger.debug('Failed to browse from collection index', { error: error instanceof Error ? error.message : String(error) });
+            return null;
+        }
+    }
+    /**
+     * Get unique content types from collection index
+     */
+    getContentTypesFromIndex(index) {
+        const types = new Set();
+        // Extract types from index keys and filter for MCP-supported types
+        Object.keys(index.index).forEach(typeName => {
+            const elementType = isElementType(typeName) ? typeName : null;
+            if (elementType && isMCPSupportedType(elementType)) {
+                types.add(typeName);
+            }
+        });
+        return Array.from(types).map(type => ({
+            name: type,
+            type: 'dir'
+        }));
+    }
+    /**
+     * Get items from collection index by section and type
+     */
+    getItemsFromIndex(index, section, type) {
+        // For library section with type, get items from that type
+        if (section === 'library' && type) {
+            return index.index[type] || [];
+        }
+        // For library section without type, return empty (should show categories)
         if (section === 'library' && !type) {
-            const contentTypes = data.filter((item) => item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles', 'memories'].includes(item.name));
+            return [];
+        }
+        // For other sections (showcase, catalog), return all items that match
+        // Note: The current index structure is primarily for library content
+        // Future enhancement: extend index to include showcase/catalog sections
+        return [];
+    }
+    /**
+     * Convert index entries to GitHub API format for compatibility
+     */
+    convertIndexItemsToGitHubFormat(items) {
+        return items.map(item => ({
+            name: item.name.endsWith('.md') ? item.name : `${item.name}.md`,
+            path: item.path,
+            sha: item.sha,
+            type: 'file',
+            url: `https://api.github.com/repos/DollhouseMCP/collection/contents/${item.path}`,
+            html_url: `https://github.com/DollhouseMCP/collection/blob/main/${item.path}`
+        }));
+    }
+    /**
+     * Browse collection from cached data
+     */
+    async browseFromCache(section, type) {
+        try {
+            // If no section provided, show available sections from seed data
+            if (!section) {
+                const sections = [
+                    { name: 'library', type: 'dir' }
+                ];
+                return { items: [], categories: [], sections };
+            }
+            // Get cached or seed data
+            let cachedItems = await this.collectionCache.loadCache();
+            if (!cachedItems || cachedItems.items.length === 0) {
+                // Use seed data if cache is empty
+                const seedData = CollectionSeeder.getSeedData();
+                await this.collectionCache.saveCache(seedData);
+                cachedItems = { items: seedData, timestamp: Date.now() };
+                logger.debug('Using seed data for collection browsing');
+            }
+            // In the library section, we have content type directories
+            if (section === 'library' && !type) {
+                const contentTypes = this.getContentTypesFromItems(cachedItems.items);
+                return { items: [], categories: contentTypes };
+            }
+            // Get items for specific type or all items in section
+            const items = this.filterItemsBySection(cachedItems.items, section, type);
+            const formattedItems = this.convertCacheItemsToGitHubFormat(items);
+            return { items: formattedItems, categories: [] };
+        }
+        catch (error) {
+            logger.error(`Cache browse failed: ${error}`);
+            // Last resort: use seed data directly
+            return this.browseFromSeedData(section, type);
+        }
+    }
+    /**
+     * Browse collection from seed data as last resort
+     */
+    browseFromSeedData(section, type) {
+        if (!section) {
+            const sections = [{ name: 'library', type: 'dir' }];
+            return { items: [], categories: [], sections };
+        }
+        const seedData = CollectionSeeder.getSeedData();
+        if (section === 'library' && !type) {
+            const contentTypes = this.getContentTypesFromItems(seedData);
             return { items: [], categories: contentTypes };
         }
-        // For library content types, show files directly (flat structure)
-        const items = data.filter((item) => item.type === 'file' && item.name.endsWith('.md'));
-        // For non-library sections, they might still have subdirectories
-        const categories = section === 'library' ? [] : data.filter((item) => item.type === 'dir');
-        return { items, categories };
+        const items = this.filterItemsBySection(seedData, section, type);
+        const formattedItems = this.convertCacheItemsToGitHubFormat(items);
+        return { items: formattedItems, categories: [] };
+    }
+    /**
+     * Get unique content types from items
+     */
+    getContentTypesFromItems(items) {
+        const types = new Set();
+        items.forEach(item => {
+            const pathParts = item.path.split('/');
+            if (pathParts.length >= 2 && pathParts[0] === 'library') {
+                // Only include MCP-supported types in cache browsing
+                const typeName = pathParts[1];
+                const elementType = isElementType(typeName) ? typeName : null;
+                if (elementType && isMCPSupportedType(elementType)) {
+                    types.add(typeName);
+                }
+            }
+        });
+        return Array.from(types).map(type => ({
+            name: type,
+            type: 'dir'
+        }));
+    }
+    /**
+     * Filter items by section and type
+     */
+    filterItemsBySection(items, section, type) {
+        return items.filter(item => {
+            const pathParts = item.path.split('/');
+            if (pathParts[0] !== section) {
+                return false;
+            }
+            if (type && pathParts[1] !== type) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Convert cache items to GitHub API format
+     */
+    convertCacheItemsToGitHubFormat(items) {
+        return items.map(item => ({
+            name: item.name,
+            path: item.path,
+            sha: item.sha,
+            type: 'file',
+            url: `https://api.github.com/repos/DollhouseMCP/collection/contents/${item.path}`,
+            html_url: `https://github.com/DollhouseMCP/collection/blob/main/${item.path}`
+        }));
     }
     /**
      * Format collection browse results
@@ -60,7 +296,7 @@ export class CollectionBrowser {
                 const icon = sectionIcons[sec.name] || '📁';
                 const descriptions = {
                     'library': 'Free community content',
-                    'showcase': 'Featured high-quality content',
+                    'showcase': 'Featured high-quality content (coming soon)',
                     'catalog': 'Premium content (coming soon)'
                 };
                 textParts.push(`   ${icon} **${sec.name}** - ${descriptions[sec.name] || 'Content collection'}\n`, `      Browse: \`browse_collection "${sec.name}"\`\n\n`);
@@ -75,9 +311,7 @@ export class CollectionBrowser {
                     'personas': '🎭',
                     'skills': '🛠️',
                     'agents': '🤖',
-                    'prompts': '💬',
                     'templates': '📄',
-                    'tools': '🔧',
                     'ensembles': '🎼',
                     'memories': '🧠'
                 };
@@ -101,9 +335,7 @@ export class CollectionBrowser {
                 'personas': '🎭',
                 'skills': '🛠️',
                 'agents': '🤖',
-                'prompts': '💬',
                 'templates': '📄',
-                'tools': '🔧',
                 'ensembles': '🎼',
                 'memories': '🧠'
             };
@@ -117,4 +349,4 @@ export class CollectionBrowser {
         return textParts.join('');
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionBrowser.js","sourceRoot":"","sources":["../../src/collection/CollectionBrowser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browse collection content from GitHub\n */\n\nimport { GitHubClient } from './GitHubClient.js';\nimport { logger } from '../utils/logger.js';\n\nexport class CollectionBrowser {\n  private githubClient: GitHubClient;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient) {\n    this.githubClient = githubClient;\n  }\n  \n  /**\n   * Browse collection content by section and type\n   * @param section - Top level section: library, showcase, or catalog\n   * @param type - Optional content type within the library section (personas, skills, etc.)\n   */\n  async browseCollection(section?: string, type?: string): Promise<{ items: any[], categories: any[], sections?: any[] }> {\n    let url = this.baseUrl;\n    \n    // If no section provided, show top-level sections\n    if (!section) {\n      const data = await this.githubClient.fetchFromGitHub(url);\n      if (!Array.isArray(data)) {\n        throw new Error('Invalid collection response. Expected directory listing.');\n      }\n      \n      // Filter to only show content directories\n      const sections = data.filter((item: any) => \n        item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name)\n      );\n      \n      return { items: [], categories: [], sections };\n    }\n    \n    // Browse within a section\n    url = type \n      ? `${this.baseUrl}/${section}/${type}` \n      : `${this.baseUrl}/${section}`;\n    \n    const data = await this.githubClient.fetchFromGitHub(url);\n    \n    if (!Array.isArray(data)) {\n      throw new Error('Invalid collection response. Expected directory listing.');\n    }\n    \n    // In the library section, we have content type directories\n    if (section === 'library' && !type) {\n      const contentTypes = data.filter((item: any) => \n        item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles', 'memories'].includes(item.name)\n      );\n      return { items: [], categories: contentTypes };\n    }\n    \n    // For library content types, show files directly (flat structure)\n    const items = data.filter((item: any) => item.type === 'file' && item.name.endsWith('.md'));\n    // For non-library sections, they might still have subdirectories\n    const categories = section === 'library' ? [] : data.filter((item: any) => item.type === 'dir');\n    \n    return { items, categories };\n  }\n  \n  /**\n   * Format collection browse results\n   */\n  formatBrowseResults(items: any[], categories: any[], section?: string, type?: string, personaIndicator: string = ''): string {\n    const textParts = [`${personaIndicator}🏪 **DollhouseMCP Collection**\\n\\n`];\n    \n    // Show top-level sections if no section specified\n    if (!section && categories.length > 0) {\n      textParts.push(`**📚 Collection Sections (${categories.length}):**\\n`);\n      categories.forEach((sec: any) => {\n        const sectionIcons: { [key: string]: string } = {\n          'library': '📖',\n          'showcase': '⭐',\n          'catalog': '💎'\n        };\n        const icon = sectionIcons[sec.name] || '📁';\n        const descriptions: { [key: string]: string } = {\n          'library': 'Free community content',\n          'showcase': 'Featured high-quality content',\n          'catalog': 'Premium content (coming soon)'\n        };\n        textParts.push(\n          `   ${icon} **${sec.name}** - ${descriptions[sec.name] || 'Content collection'}\\n`,\n          `      Browse: \\`browse_collection \"${sec.name}\"\\`\\n\\n`\n        );\n      });\n      return textParts.join('');\n    }\n    \n    // Show content types within library section\n    if (section === 'library' && !type && categories.length > 0) {\n      textParts.push(`**📖 Library Content Types (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const typeIcons: { [key: string]: string } = {\n          'personas': '🎭',\n          'skills': '🛠️',\n          'agents': '🤖',\n          'prompts': '💬',\n          'templates': '📄',\n          'tools': '🔧',\n          'ensembles': '🎼',\n          'memories': '🧠'\n        };\n        const icon = typeIcons[cat.name] || '📁';\n        textParts.push(`   ${icon} **${cat.name}** - Browse: \\`browse_collection \"library\" \"${cat.name}\"\\`\\n`);\n      });\n      textParts.push('\\n');\n    } else if (categories.length > 0) {\n      // Only show category navigation for non-library sections (showcase, catalog)\n      textParts.push(`**📁 Subdirectories in ${section}${type ? `/${type}` : ''} (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const browsePath = type ? `\"${section}\" \"${type}/${cat.name}\"` : `\"${section}\" \"${cat.name}\"`;\n        textParts.push(`   📂 **${cat.name}** - Browse: \\`browse_collection ${browsePath}\\`\\n`);\n      });\n      textParts.push('\\n');\n    }\n    \n    if (items.length > 0) {\n      const contentType = type || 'content';\n      const contentIcons: { [key: string]: string } = {\n        'personas': '🎭',\n        'skills': '🛠️',\n        'agents': '🤖',\n        'prompts': '💬',\n        'templates': '📄',\n        'tools': '🔧',\n        'ensembles': '🎼',\n        'memories': '🧠'\n      };\n      const icon = contentIcons[contentType] || '📄';\n      \n      textParts.push(`**${icon} ${contentType.charAt(0).toUpperCase() + contentType.slice(1)} in ${section}${type ? `/${type}` : ''} (${items.length}):**\\n`);\n      items.forEach((item: any) => {\n        const fullPath = section + (type ? `/${type}` : '') + `/${item.name}`;\n        textParts.push(\n          `   ▫️ **${item.name.replace('.md', '')}**\\n`,\n          `      📥 Install: \\`install_content \"${fullPath}\"\\`\\n`,\n          `      👁️ Details: \\`get_collection_content \"${fullPath}\"\\`\\n\\n`\n        );\n      });\n    }\n    \n    return textParts.join('');\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionBrowser.js","sourceRoot":"","sources":["../../src/collection/CollectionBrowser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,eAAe,EAAkB,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,qDAAqD;AACrD,6CAA6C;AAC7C,0EAA0E;AAC1E,+CAA+C;AAC/C,gFAAgF;AAChF,MAAM,mBAAmB,GAAG;IAC1B,WAAW,CAAC,OAAO,EAAK,wDAAwD;IAChF,WAAW,CAAC,KAAK,EAAO,qCAAqC;IAC7D,WAAW,CAAC,KAAK,EAAO,uCAAuC;IAC/D,WAAW,CAAC,QAAQ,CAAI,wCAAwC;CACjE,CAAC;AAEF;;GAEG;AACH,SAAS,aAAa,CAAC,KAAa;IAClC,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAoB,CAAC,CAAC;AACnE,CAAC;AAED;;GAEG;AACH,SAAS,kBAAkB,CAAC,WAAwB;IAClD,OAAO,mBAAmB,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,OAAO,iBAAiB;IACpB,YAAY,CAAe;IAC3B,eAAe,CAAkB;IACjC,YAAY,CAAyB;IACrC,OAAO,GAAG,+DAA+D,CAAC;IAElF,YAAY,YAA0B,EAAE,eAAiC,EAAE,YAAqC;QAC9G,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,eAAe,GAAG,eAAe,IAAI,IAAI,eAAe,EAAE,CAAC;QAChE,IAAI,CAAC,YAAY,GAAG,YAAY,IAAI,IAAI,sBAAsB,EAAE,CAAC;IACnE,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,gBAAgB,CAAC,OAAgB,EAAE,IAAa;QACpD,IAAI,CAAC;YACH,uDAAuD;YACvD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YAC9D,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;gBACnD,OAAO,WAAW,CAAC;YACrB,CAAC;YAED,yBAAyB;YACzB,IAAI,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC;YAEvB,kDAAkD;YAClD,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBACjE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;oBACzB,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;gBAC9E,CAAC;gBAED,0CAA0C;gBAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,IAAS,EAAE,EAAE,CACzC,IAAI,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAC9E,CAAC;gBAEF,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC;YACjD,CAAC;YAED,0BAA0B;YAC1B,GAAG,GAAG,IAAI;gBACR,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,IAAI,OAAO,IAAI,IAAI,EAAE;gBACtC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,IAAI,OAAO,EAAE,CAAC;YAEjC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAEjE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzB,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;YAC9E,CAAC;YAED,2DAA2D;YAC3D,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,EAAE,CAAC;gBACnC,kDAAkD;gBAClD,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,IAAS,EAAE,EAAE;oBAC7C,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK;wBAAE,OAAO,KAAK,CAAC;oBACtC,MAAM,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAmB,CAAC,CAAC,CAAC,IAAI,CAAC;oBAC/E,OAAO,WAAW,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAAC;gBACxD,CAAC,CAAC,CAAC;gBACH,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;YACjD,CAAC;YAED,kEAAkE;YAClE,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5F,iEAAiE;YACjE,MAAM,UAAU,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC;YAEhG,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,oDAAoD,KAAK,EAAE,CAAC,CAAC;YAE1E,0BAA0B;YAC1B,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,eAAe,CAAC,OAAgB,EAAE,IAAa;QAC3D,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YAEjD,kDAAkD;YAClD,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,QAAQ,GAAG;oBACf,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE;oBAChC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE;oBACjC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE;iBACjC,CAAC;gBACF,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC;YACjD,CAAC;YAED,2DAA2D;YAC3D,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,EAAE,CAAC;gBACnC,sCAAsC;gBACtC,MAAM,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;gBAC1D,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;YACjD,CAAC;YAED,sDAAsD;YACtD,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;YAC3D,MAAM,cAAc,GAAG,IAAI,CAAC,+BAA+B,CAAC,KAAK,CAAC,CAAC;YAEnE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;QAEnD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,wCAAwC,EAAE,EAAE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC1H,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,wBAAwB,CAAC,KAAsB;QACrD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;QAEhC,mEAAmE;QACnE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YAC1C,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAuB,CAAC,CAAC,CAAC,IAAI,CAAC;YAC7E,IAAI,WAAW,IAAI,kBAAkB,CAAC,WAAW,CAAC,EAAE,CAAC;gBACnD,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACtB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACpC,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,KAAK;SACZ,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,KAAsB,EAAE,OAAe,EAAE,IAAa;QAC9E,0DAA0D;QAC1D,IAAI,OAAO,KAAK,SAAS,IAAI,IAAI,EAAE,CAAC;YAClC,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACjC,CAAC;QAED,0EAA0E;QAC1E,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,EAAE,CAAC;YACnC,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,sEAAsE;QACtE,qEAAqE;QACrE,wEAAwE;QACxE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;OAEG;IACK,+BAA+B,CAAC,KAAmB;QACzD,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,KAAK;YAC/D,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,IAAI,EAAE,MAAM;YACZ,GAAG,EAAE,iEAAiE,IAAI,CAAC,IAAI,EAAE;YACjF,QAAQ,EAAE,wDAAwD,IAAI,CAAC,IAAI,EAAE;SAC9E,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe,CAAC,OAAgB,EAAE,IAAa;QAC3D,IAAI,CAAC;YACH,iEAAiE;YACjE,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,QAAQ,GAAG;oBACf,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE;iBACjC,CAAC;gBACF,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC;YACjD,CAAC;YAED,0BAA0B;YAC1B,IAAI,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC;YAEzD,IAAI,CAAC,WAAW,IAAI,WAAW,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACnD,kCAAkC;gBAClC,MAAM,QAAQ,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;gBAChD,MAAM,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;gBAC/C,WAAW,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;gBACzD,MAAM,CAAC,KAAK,CAAC,yCAAyC,CAAC,CAAC;YAC1D,CAAC;YAED,2DAA2D;YAC3D,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,EAAE,CAAC;gBACnC,MAAM,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;gBACtE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;YACjD,CAAC;YAED,sDAAsD;YACtD,MAAM,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;YAC1E,MAAM,cAAc,GAAG,IAAI,CAAC,+BAA+B,CAAC,KAAK,CAAC,CAAC;YAEnE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;QACnD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,wBAAwB,KAAK,EAAE,CAAC,CAAC;YAE9C,sCAAsC;YACtC,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,kBAAkB,CAAC,OAAgB,EAAE,IAAa;QACxD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,QAAQ,GAAG,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YACpD,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC;QACjD,CAAC;QAED,MAAM,QAAQ,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAEhD,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,EAAE,CAAC;YACnC,MAAM,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;YAC7D,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;QACjD,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QACjE,MAAM,cAAc,GAAG,IAAI,CAAC,+BAA+B,CAAC,KAAK,CAAC,CAAC;QAEnE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IACnD,CAAC;IAED;;OAEG;IACK,wBAAwB,CAAC,KAAuB;QACtD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;QAEhC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACnB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACvC,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;gBACxD,qDAAqD;gBACrD,MAAM,QAAQ,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;gBAC9B,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAuB,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC7E,IAAI,WAAW,IAAI,kBAAkB,CAAC,WAAW,CAAC,EAAE,CAAC;oBACnD,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBACtB,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACpC,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,KAAK;SACZ,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACK,oBAAoB,CAAC,KAAuB,EAAE,OAAe,EAAE,IAAa;QAClF,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YACzB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAEvC,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC;gBAC7B,OAAO,KAAK,CAAC;YACf,CAAC;YAED,IAAI,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;gBAClC,OAAO,KAAK,CAAC;YACf,CAAC;YAED,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,+BAA+B,CAAC,KAAuB;QAC7D,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACxB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,IAAI,EAAE,MAAM;YACZ,GAAG,EAAE,iEAAiE,IAAI,CAAC,IAAI,EAAE;YACjF,QAAQ,EAAE,wDAAwD,IAAI,CAAC,IAAI,EAAE;SAC9E,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,KAAY,EAAE,UAAiB,EAAE,OAAgB,EAAE,IAAa,EAAE,mBAA2B,EAAE;QACjH,MAAM,SAAS,GAAG,CAAC,GAAG,gBAAgB,oCAAoC,CAAC,CAAC;QAE5E,kDAAkD;QAClD,IAAI,CAAC,OAAO,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtC,SAAS,CAAC,IAAI,CAAC,6BAA6B,UAAU,CAAC,MAAM,QAAQ,CAAC,CAAC;YACvE,UAAU,CAAC,OAAO,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAC9B,MAAM,YAAY,GAA8B;oBAC9C,SAAS,EAAE,IAAI;oBACf,UAAU,EAAE,GAAG;oBACf,SAAS,EAAE,IAAI;iBAChB,CAAC;gBACF,MAAM,IAAI,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;gBAC5C,MAAM,YAAY,GAA8B;oBAC9C,SAAS,EAAE,wBAAwB;oBACnC,UAAU,EAAE,6CAA6C;oBACzD,SAAS,EAAE,+BAA+B;iBAC3C,CAAC;gBACF,SAAS,CAAC,IAAI,CACZ,MAAM,IAAI,MAAM,GAAG,CAAC,IAAI,QAAQ,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,oBAAoB,IAAI,EAClF,sCAAsC,GAAG,CAAC,IAAI,SAAS,CACxD,CAAC;YACJ,CAAC,CAAC,CAAC;YACH,OAAO,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC5B,CAAC;QAED,4CAA4C;QAC5C,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5D,SAAS,CAAC,IAAI,CAAC,+BAA+B,UAAU,CAAC,MAAM,QAAQ,CAAC,CAAC;YACzE,UAAU,CAAC,OAAO,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAC9B,MAAM,SAAS,GAA8B;oBAC3C,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,KAAK;oBACf,QAAQ,EAAE,IAAI;oBACd,WAAW,EAAE,IAAI;oBACjB,WAAW,EAAE,IAAI;oBACjB,UAAU,EAAE,IAAI;iBACjB,CAAC;gBACF,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;gBACzC,SAAS,CAAC,IAAI,CAAC,MAAM,IAAI,MAAM,GAAG,CAAC,IAAI,+CAA+C,GAAG,CAAC,IAAI,OAAO,CAAC,CAAC;YACzG,CAAC,CAAC,CAAC;YACH,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;aAAM,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjC,6EAA6E;YAC7E,SAAS,CAAC,IAAI,CAAC,0BAA0B,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,MAAM,QAAQ,CAAC,CAAC;YACzG,UAAU,CAAC,OAAO,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAC9B,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,OAAO,MAAM,IAAI,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,OAAO,MAAM,GAAG,CAAC,IAAI,GAAG,CAAC;gBAC9F,SAAS,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,oCAAoC,UAAU,MAAM,CAAC,CAAC;YAC1F,CAAC,CAAC,CAAC;YACH,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,WAAW,GAAG,IAAI,IAAI,SAAS,CAAC;YACtC,MAAM,YAAY,GAA8B;gBAC9C,UAAU,EAAE,IAAI;gBAChB,QAAQ,EAAE,KAAK;gBACf,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,IAAI;gBACjB,WAAW,EAAE,IAAI;gBACjB,UAAU,EAAE,IAAI;aACjB,CAAC;YACF,MAAM,IAAI,GAAG,YAAY,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC;YAE/C,SAAS,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,MAAM,QAAQ,CAAC,CAAC;YACxJ,KAAK,CAAC,OAAO,CAAC,CAAC,IAAS,EAAE,EAAE;gBAC1B,MAAM,QAAQ,GAAG,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACtE,SAAS,CAAC,IAAI,CACZ,WAAW,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,EAC7C,wCAAwC,QAAQ,OAAO,EACvD,gDAAgD,QAAQ,SAAS,CAClE,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;CACF","sourcesContent":["/**\n * Browse collection content from GitHub\n */\n\nimport { GitHubClient } from './GitHubClient.js';\nimport { CollectionCache, CollectionItem } from '../cache/CollectionCache.js';\nimport { CollectionSeeder } from './CollectionSeeder.js';\nimport { CollectionIndexManager } from './CollectionIndexManager.js';\nimport { CollectionIndex, IndexEntry } from '../types/collection.js';\nimport { logger } from '../utils/logger.js';\nimport { ElementType } from '../portfolio/types.js';\n\n// Content types supported by MCP server (Issue #144)\n// Hide: memories, ensembles from MCP queries\n// ⚠️ CRITICAL: When adding new element types, you MUST update this array!\n// Also update validTypes array in src/index.ts\n// See docs/development/ADDING_NEW_ELEMENT_TYPES_CHECKLIST.md for complete guide\nconst MCP_SUPPORTED_TYPES = [\n  ElementType.PERSONA,    // personas - supported by PersonaTools and ElementTools\n  ElementType.SKILL,      // skills - supported by ElementTools\n  ElementType.AGENT,      // agents - supported by ElementTools  \n  ElementType.TEMPLATE    // templates - supported by ElementTools\n];\n\n/**\n * Type guard to safely check if a string is a valid ElementType\n */\nfunction isElementType(value: string): value is ElementType {\n  return Object.values(ElementType).includes(value as ElementType);\n}\n\n/**\n * Type guard to safely check if an ElementType is supported by MCP\n */\nfunction isMCPSupportedType(elementType: ElementType): boolean {\n  return MCP_SUPPORTED_TYPES.includes(elementType);\n}\n\nexport class CollectionBrowser {\n  private githubClient: GitHubClient;\n  private collectionCache: CollectionCache;\n  private indexManager: CollectionIndexManager;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient, collectionCache?: CollectionCache, indexManager?: CollectionIndexManager) {\n    this.githubClient = githubClient;\n    this.collectionCache = collectionCache || new CollectionCache();\n    this.indexManager = indexManager || new CollectionIndexManager();\n  }\n  \n  /**\n   * Browse collection content by section and type\n   * Uses CollectionIndexManager for fast browsing with background refresh\n   * Falls back to cached data when GitHub API is not available or not authenticated\n   * @param section - Top level section: library, showcase, or catalog\n   * @param type - Optional content type within the library section (personas, skills, etc.)\n   */\n  async browseCollection(section?: string, type?: string): Promise<{ items: any[], categories: any[], sections?: any[] }> {\n    try {\n      // Try using collection index first for faster browsing\n      const indexResult = await this.browseFromIndex(section, type);\n      if (indexResult) {\n        logger.debug('Used collection index for browsing');\n        return indexResult;\n      }\n      \n      // Fallback to GitHub API\n      let url = this.baseUrl;\n      \n      // If no section provided, show top-level sections\n      if (!section) {\n        const data = await this.githubClient.fetchFromGitHub(url, false);\n        if (!Array.isArray(data)) {\n          throw new Error('Invalid collection response. Expected directory listing.');\n        }\n        \n        // Filter to only show content directories\n        const sections = data.filter((item: any) => \n          item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name)\n        );\n        \n        return { items: [], categories: [], sections };\n      }\n      \n      // Browse within a section\n      url = type \n        ? `${this.baseUrl}/${section}/${type}` \n        : `${this.baseUrl}/${section}`;\n      \n      const data = await this.githubClient.fetchFromGitHub(url, false);\n      \n      if (!Array.isArray(data)) {\n        throw new Error('Invalid collection response. Expected directory listing.');\n      }\n      \n      // In the library section, we have content type directories\n      if (section === 'library' && !type) {\n        // Filter to only show MCP-supported content types\n        const contentTypes = data.filter((item: any) => {\n          if (item.type !== 'dir') return false;\n          const elementType = isElementType(item.name) ? item.name as ElementType : null;\n          return elementType && isMCPSupportedType(elementType);\n        });\n        return { items: [], categories: contentTypes };\n      }\n      \n      // For library content types, show files directly (flat structure)\n      const items = data.filter((item: any) => item.type === 'file' && item.name.endsWith('.md'));\n      // For non-library sections, they might still have subdirectories\n      const categories = section === 'library' ? [] : data.filter((item: any) => item.type === 'dir');\n      \n      return { items, categories };\n    } catch (error) {\n      logger.debug(`GitHub API browse failed, falling back to cache: ${error}`);\n      \n      // Fallback to cached data\n      return this.browseFromCache(section, type);\n    }\n  }\n  \n  /**\n   * Browse collection using the fast collection index\n   * Returns null if index is not available or browsing fails\n   */\n  private async browseFromIndex(section?: string, type?: string): Promise<{ items: any[], categories: any[], sections?: any[] } | null> {\n    try {\n      const index = await this.indexManager.getIndex();\n      \n      // If no section provided, show top-level sections\n      if (!section) {\n        const sections = [\n          { name: 'library', type: 'dir' },\n          { name: 'showcase', type: 'dir' },\n          { name: 'catalog', type: 'dir' }\n        ];\n        return { items: [], categories: [], sections };\n      }\n      \n      // In the library section, we have content type directories\n      if (section === 'library' && !type) {\n        // Get unique content types from index\n        const contentTypes = this.getContentTypesFromIndex(index);\n        return { items: [], categories: contentTypes };\n      }\n      \n      // Get items for specific type or all items in section\n      const items = this.getItemsFromIndex(index, section, type);\n      const formattedItems = this.convertIndexItemsToGitHubFormat(items);\n      \n      return { items: formattedItems, categories: [] };\n      \n    } catch (error) {\n      logger.debug('Failed to browse from collection index', { error: error instanceof Error ? error.message : String(error) });\n      return null;\n    }\n  }\n  \n  /**\n   * Get unique content types from collection index\n   */\n  private getContentTypesFromIndex(index: CollectionIndex): any[] {\n    const types = new Set<string>();\n    \n    // Extract types from index keys and filter for MCP-supported types\n    Object.keys(index.index).forEach(typeName => {\n      const elementType = isElementType(typeName) ? typeName as ElementType : null;\n      if (elementType && isMCPSupportedType(elementType)) {\n        types.add(typeName);\n      }\n    });\n    \n    return Array.from(types).map(type => ({\n      name: type,\n      type: 'dir'\n    }));\n  }\n  \n  /**\n   * Get items from collection index by section and type\n   */\n  private getItemsFromIndex(index: CollectionIndex, section: string, type?: string): IndexEntry[] {\n    // For library section with type, get items from that type\n    if (section === 'library' && type) {\n      return index.index[type] || [];\n    }\n    \n    // For library section without type, return empty (should show categories)\n    if (section === 'library' && !type) {\n      return [];\n    }\n    \n    // For other sections (showcase, catalog), return all items that match\n    // Note: The current index structure is primarily for library content\n    // Future enhancement: extend index to include showcase/catalog sections\n    return [];\n  }\n  \n  /**\n   * Convert index entries to GitHub API format for compatibility\n   */\n  private convertIndexItemsToGitHubFormat(items: IndexEntry[]): any[] {\n    return items.map(item => ({\n      name: item.name.endsWith('.md') ? item.name : `${item.name}.md`,\n      path: item.path,\n      sha: item.sha,\n      type: 'file',\n      url: `https://api.github.com/repos/DollhouseMCP/collection/contents/${item.path}`,\n      html_url: `https://github.com/DollhouseMCP/collection/blob/main/${item.path}`\n    }));\n  }\n  \n  /**\n   * Browse collection from cached data\n   */\n  private async browseFromCache(section?: string, type?: string): Promise<{ items: any[], categories: any[], sections?: any[] }> {\n    try {\n      // If no section provided, show available sections from seed data\n      if (!section) {\n        const sections = [\n          { name: 'library', type: 'dir' }\n        ];\n        return { items: [], categories: [], sections };\n      }\n      \n      // Get cached or seed data\n      let cachedItems = await this.collectionCache.loadCache();\n      \n      if (!cachedItems || cachedItems.items.length === 0) {\n        // Use seed data if cache is empty\n        const seedData = CollectionSeeder.getSeedData();\n        await this.collectionCache.saveCache(seedData);\n        cachedItems = { items: seedData, timestamp: Date.now() };\n        logger.debug('Using seed data for collection browsing');\n      }\n      \n      // In the library section, we have content type directories\n      if (section === 'library' && !type) {\n        const contentTypes = this.getContentTypesFromItems(cachedItems.items);\n        return { items: [], categories: contentTypes };\n      }\n      \n      // Get items for specific type or all items in section\n      const items = this.filterItemsBySection(cachedItems.items, section, type);\n      const formattedItems = this.convertCacheItemsToGitHubFormat(items);\n      \n      return { items: formattedItems, categories: [] };\n    } catch (error) {\n      logger.error(`Cache browse failed: ${error}`);\n      \n      // Last resort: use seed data directly\n      return this.browseFromSeedData(section, type);\n    }\n  }\n  \n  /**\n   * Browse collection from seed data as last resort\n   */\n  private browseFromSeedData(section?: string, type?: string): { items: any[], categories: any[], sections?: any[] } {\n    if (!section) {\n      const sections = [{ name: 'library', type: 'dir' }];\n      return { items: [], categories: [], sections };\n    }\n    \n    const seedData = CollectionSeeder.getSeedData();\n    \n    if (section === 'library' && !type) {\n      const contentTypes = this.getContentTypesFromItems(seedData);\n      return { items: [], categories: contentTypes };\n    }\n    \n    const items = this.filterItemsBySection(seedData, section, type);\n    const formattedItems = this.convertCacheItemsToGitHubFormat(items);\n    \n    return { items: formattedItems, categories: [] };\n  }\n  \n  /**\n   * Get unique content types from items\n   */\n  private getContentTypesFromItems(items: CollectionItem[]): any[] {\n    const types = new Set<string>();\n    \n    items.forEach(item => {\n      const pathParts = item.path.split('/');\n      if (pathParts.length >= 2 && pathParts[0] === 'library') {\n        // Only include MCP-supported types in cache browsing\n        const typeName = pathParts[1];\n        const elementType = isElementType(typeName) ? typeName as ElementType : null;\n        if (elementType && isMCPSupportedType(elementType)) {\n          types.add(typeName);\n        }\n      }\n    });\n    \n    return Array.from(types).map(type => ({\n      name: type,\n      type: 'dir'\n    }));\n  }\n  \n  /**\n   * Filter items by section and type\n   */\n  private filterItemsBySection(items: CollectionItem[], section: string, type?: string): CollectionItem[] {\n    return items.filter(item => {\n      const pathParts = item.path.split('/');\n      \n      if (pathParts[0] !== section) {\n        return false;\n      }\n      \n      if (type && pathParts[1] !== type) {\n        return false;\n      }\n      \n      return true;\n    });\n  }\n  \n  /**\n   * Convert cache items to GitHub API format\n   */\n  private convertCacheItemsToGitHubFormat(items: CollectionItem[]): any[] {\n    return items.map(item => ({\n      name: item.name,\n      path: item.path,\n      sha: item.sha,\n      type: 'file',\n      url: `https://api.github.com/repos/DollhouseMCP/collection/contents/${item.path}`,\n      html_url: `https://github.com/DollhouseMCP/collection/blob/main/${item.path}`\n    }));\n  }\n  \n  /**\n   * Format collection browse results\n   */\n  formatBrowseResults(items: any[], categories: any[], section?: string, type?: string, personaIndicator: string = ''): string {\n    const textParts = [`${personaIndicator}🏪 **DollhouseMCP Collection**\\n\\n`];\n    \n    // Show top-level sections if no section specified\n    if (!section && categories.length > 0) {\n      textParts.push(`**📚 Collection Sections (${categories.length}):**\\n`);\n      categories.forEach((sec: any) => {\n        const sectionIcons: { [key: string]: string } = {\n          'library': '📖',\n          'showcase': '⭐',\n          'catalog': '💎'\n        };\n        const icon = sectionIcons[sec.name] || '📁';\n        const descriptions: { [key: string]: string } = {\n          'library': 'Free community content',\n          'showcase': 'Featured high-quality content (coming soon)',\n          'catalog': 'Premium content (coming soon)'\n        };\n        textParts.push(\n          `   ${icon} **${sec.name}** - ${descriptions[sec.name] || 'Content collection'}\\n`,\n          `      Browse: \\`browse_collection \"${sec.name}\"\\`\\n\\n`\n        );\n      });\n      return textParts.join('');\n    }\n    \n    // Show content types within library section\n    if (section === 'library' && !type && categories.length > 0) {\n      textParts.push(`**📖 Library Content Types (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const typeIcons: { [key: string]: string } = {\n          'personas': '🎭',\n          'skills': '🛠️',\n          'agents': '🤖',\n          'templates': '📄',\n          'ensembles': '🎼',\n          'memories': '🧠'\n        };\n        const icon = typeIcons[cat.name] || '📁';\n        textParts.push(`   ${icon} **${cat.name}** - Browse: \\`browse_collection \"library\" \"${cat.name}\"\\`\\n`);\n      });\n      textParts.push('\\n');\n    } else if (categories.length > 0) {\n      // Only show category navigation for non-library sections (showcase, catalog)\n      textParts.push(`**📁 Subdirectories in ${section}${type ? `/${type}` : ''} (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const browsePath = type ? `\"${section}\" \"${type}/${cat.name}\"` : `\"${section}\" \"${cat.name}\"`;\n        textParts.push(`   📂 **${cat.name}** - Browse: \\`browse_collection ${browsePath}\\`\\n`);\n      });\n      textParts.push('\\n');\n    }\n    \n    if (items.length > 0) {\n      const contentType = type || 'content';\n      const contentIcons: { [key: string]: string } = {\n        'personas': '🎭',\n        'skills': '🛠️',\n        'agents': '🤖',\n        'templates': '📄',\n        'ensembles': '🎼',\n        'memories': '🧠'\n      };\n      const icon = contentIcons[contentType] || '📄';\n      \n      textParts.push(`**${icon} ${contentType.charAt(0).toUpperCase() + contentType.slice(1)} in ${section}${type ? `/${type}` : ''} (${items.length}):**\\n`);\n      items.forEach((item: any) => {\n        const fullPath = section + (type ? `/${type}` : '') + `/${item.name}`;\n        textParts.push(\n          `   ▫️ **${item.name.replace('.md', '')}**\\n`,\n          `      📥 Install: \\`install_content \"${fullPath}\"\\`\\n`,\n          `      👁️ Details: \\`get_collection_content \"${fullPath}\"\\`\\n\\n`\n        );\n      });\n    }\n    \n    return textParts.join('');\n  }\n}"]}

package/dist/collection/CollectionIndexManager.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Collection Index Manager with Background Refresh and Robust Caching
+ *
+ * This manager implements:
+ * - 1-hour TTL with local file caching
+ * - Background refresh without blocking operations
+ * - Exponential backoff retry logic
+ * - Configurable timeouts via environment variables
+ * - Return stale cache while refreshing in background
+ * - Comprehensive error handling for production use
+ */
+import { CollectionIndex } from '../types/collection';
+export interface CollectionIndexCacheEntry {
+    data: CollectionIndex;
+    timestamp: number;
+    etag?: string;
+    lastModified?: string;
+    version: string;
+    checksum: string;
+}
+export interface CollectionIndexManagerConfig {
+    ttlMs?: number;
+    fetchTimeoutMs?: number;
+    maxRetries?: number;
+    baseRetryDelayMs?: number;
+    maxRetryDelayMs?: number;
+    cacheDir?: string;
+}
+export declare class CollectionIndexManager {
+    private readonly INDEX_URL;
+    private readonly TTL_MS;
+    private readonly FETCH_TIMEOUT_MS;
+    private readonly MAX_RETRIES;
+    private readonly BASE_RETRY_DELAY_MS;
+    private readonly MAX_RETRY_DELAY_MS;
+    private readonly CACHE_FILE;
+    private cachedIndex;
+    private backgroundRefreshPromise;
+    private isRefreshing;
+    private circuitBreakerFailures;
+    private circuitBreakerLastFailure;
+    private readonly CIRCUIT_BREAKER_THRESHOLD;
+    private readonly CIRCUIT_BREAKER_TIMEOUT_MS;
+    private readonly REFRESH_THRESHOLD;
+    private readonly JITTER_FACTOR;
+    private readonly DEFAULT_TTL_MS;
+    private readonly DEFAULT_MAX_RETRIES;
+    private readonly DEFAULT_BASE_RETRY_DELAY_MS;
+    private readonly DEFAULT_MAX_RETRY_DELAY_MS;
+    private readonly DEFAULT_FETCH_TIMEOUT_MS;
+    private readonly CHECKSUM_LENGTH;
+    private readonly JSON_INDENT;
+    constructor(config?: CollectionIndexManagerConfig);
+    /**
+     * Parse fetch timeout from config or environment variable
+     */
+    private parseFetchTimeout;
+    /**
+     * Get collection index with stale-while-revalidate pattern
+     * Returns cached data immediately if available, refreshes in background
+     */
+    getIndex(): Promise<CollectionIndex>;
+    /**
+     * Force refresh the collection index
+     */
+    forceRefresh(): Promise<CollectionIndex>;
+    /**
+     * Check if cache should be refreshed (within TTL but getting close to expiry)
+     */
+    private shouldRefreshCache;
+    /**
+     * Check if cache is expired
+     */
+    private isCacheExpired;
+    /**
+     * Start background refresh without blocking
+     */
+    private startBackgroundRefresh;
+    /**
+     * Perform background refresh
+     */
+    private performBackgroundRefresh;
+    /**
+     * Fetch collection index with retry logic and exponential backoff
+     */
+    private fetchWithRetry;
+    /**
+     * Calculate retry delay with exponential backoff and jitter
+     */
+    private calculateRetryDelay;
+    /**
+     * Add jitter (±25% randomness) to a delay to prevent thundering herd problems
+     */
+    private addJitter;
+    /**
+     * Fetch collection index from GitHub
+     */
+    private fetchCollectionIndex;
+    /**
+     * Validate collection index structure
+     */
+    private validateIndexStructure;
+    /**
+     * Update cache with new data
+     */
+    private updateCache;
+    /**
+     * Calculate checksum for data integrity verification
+     */
+    private calculateChecksum;
+    /**
+     * Load cache from disk
+     */
+    private loadFromDisk;
+    /**
+     * Save cache to disk
+     */
+    private saveToDisk;
+    /**
+     * Circuit breaker logic
+     */
+    private isCircuitBreakerOpen;
+    private recordCircuitBreakerFailure;
+    /**
+     * Utility methods
+     */
+    private sleep;
+    private getErrorMessage;
+    /**
+     * Get cache statistics for monitoring
+     */
+    getCacheStats(): {
+        isValid: boolean;
+        age: number;
+        hasCache: boolean;
+        version?: string;
+        totalElements?: number;
+        isRefreshing: boolean;
+        circuitBreakerFailures: number;
+        circuitBreakerOpen: boolean;
+    };
+    /**
+     * Clear all cache data
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Wait for any ongoing background refresh to complete
+     */
+    waitForBackgroundRefresh(): Promise<void>;
+}
+//# sourceMappingURL=CollectionIndexManager.d.ts.map

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

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