@dollhousemcp/mcp-server 1.5.1 → 1.5.2

package/dist/collection/CollectionBrowser.js

@@ -1,47 +1,159 @@
 /**
  * Browse collection content from GitHub
  */
+import { CollectionCache } from '../cache/CollectionCache.js';
+import { CollectionSeeder } from './CollectionSeeder.js';
+import { logger } from '../utils/logger.js';
 export class CollectionBrowser {
     githubClient;
+    collectionCache;
     baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
-    constructor(githubClient) {
+    constructor(githubClient, collectionCache) {
         this.githubClient = githubClient;
+        this.collectionCache = collectionCache || new CollectionCache();
     }
     /**
      * Browse collection content by section and type
+     * 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 GitHub API first
+            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) {
+                const contentTypes = data.filter((item) => item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles', 'memories'].includes(item.name));
+                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);
+        }
+    }
+    /**
+     * 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 };
         }
-        // In the library section, we have content type directories
+        const seedData = CollectionSeeder.getSeedData();
         if (section === 'library' && !type) {
-            const contentTypes = data.filter((item) => item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles', 'memories'].includes(item.name));
+            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') {
+                types.add(pathParts[1]);
+            }
+        });
+        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
@@ -117,4 +229,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":"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","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 { logger } from '../utils/logger.js';\n\nexport class CollectionBrowser {\n  private githubClient: GitHubClient;\n  private collectionCache: CollectionCache;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient, collectionCache?: CollectionCache) {\n    this.githubClient = githubClient;\n    this.collectionCache = collectionCache || new CollectionCache();\n  }\n  \n  /**\n   * Browse collection content by section and type\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 GitHub API first\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        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    } 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 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        types.add(pathParts[1]);\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',\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}"]}

package/dist/collection/CollectionSearch.d.ts

@@ -2,14 +2,33 @@
  * Search for content in the collection
  */
 import { GitHubClient } from './GitHubClient.js';
+import { CollectionCache } from '../cache/CollectionCache.js';
 export declare class CollectionSearch {
     private githubClient;
+    private collectionCache;
     private searchBaseUrl;
-    constructor(githubClient: GitHubClient);
+    constructor(githubClient: GitHubClient, collectionCache?: CollectionCache);
     /**
      * Search collection for content matching query
+     * Falls back to cached data when GitHub API is not available or not authenticated
      */
     searchCollection(query: string): Promise<any[]>;
+    /**
+     * Search cached collection items
+     */
+    private searchFromCache;
+    /**
+     * Search seed data for matching items with fuzzy matching
+     */
+    private searchSeedData;
+    /**
+     * Convert cache items to GitHub API format for consistent response structure
+     */
+    private convertCacheItemsToGitHubFormat;
+    /**
+     * Update cache with fresh data from GitHub API items
+     */
+    private updateCacheFromGitHubItems;
     /**
      * Format search results
      */

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

@@ -1 +1 @@
-{"version":3,"file":"CollectionSearch.d.ts","sourceRoot":"","sources":["../../src/collection/CollectionSearch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAwC;gBAEjD,YAAY,EAAE,YAAY;IAItC;;OAEG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAYrD;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAiCxF"}
+{"version":3,"file":"CollectionSearch.d.ts","sourceRoot":"","sources":["../../src/collection/CollectionSearch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAkB,MAAM,6BAA6B,CAAC;AAK9E,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,aAAa,CAAwC;gBAEjD,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,eAAe;IAKzE;;;OAGG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAgCrD;;OAEG;YACW,eAAe;IA+B7B;;OAEG;IACH,OAAO,CAAC,cAAc;IActB;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAcvC;;OAEG;YACW,0BAA0B;IAiBxC;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAiCxF"}

package/dist/collection/CollectionSearch.js

@@ -1,22 +1,126 @@
 /**
  * Search for content in the collection
  */
+import { CollectionCache } from '../cache/CollectionCache.js';
+import { CollectionSeeder } from './CollectionSeeder.js';
+import { logger } from '../utils/logger.js';
+import { normalizeSearchTerm, validateSearchQuery } from '../utils/searchUtils.js';
 export class CollectionSearch {
     githubClient;
+    collectionCache;
     searchBaseUrl = 'https://api.github.com/search/code';
-    constructor(githubClient) {
+    constructor(githubClient, collectionCache) {
         this.githubClient = githubClient;
+        this.collectionCache = collectionCache || new CollectionCache();
     }
     /**
      * Search collection for content matching query
+     * Falls back to cached data when GitHub API is not available or not authenticated
      */
     async searchCollection(query) {
-        const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;
-        const data = await this.githubClient.fetchFromGitHub(searchUrl);
-        if (!data.items) {
+        // Validate search query for security
+        try {
+            validateSearchQuery(query, 1000);
+        }
+        catch (error) {
+            logger.warn(`Invalid search query: ${error}`);
+            return [];
+        }
+        try {
+            // First, try GitHub API search if authenticated
+            const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;
+            const data = await this.githubClient.fetchFromGitHub(searchUrl, false); // Don't require auth for search
+            if (data.items && Array.isArray(data.items)) {
+                logger.debug(`Found ${data.items.length} items via GitHub API search`);
+                // Update cache with fresh data from API
+                await this.updateCacheFromGitHubItems(data.items);
+                return data.items;
+            }
             return [];
         }
-        return data.items;
+        catch (error) {
+            logger.debug(`GitHub API search failed, falling back to cache: ${error}`);
+            // Fallback to cached search
+            return this.searchFromCache(query);
+        }
+    }
+    /**
+     * Search cached collection items
+     */
+    async searchFromCache(query) {
+        try {
+            // Try to load from cache first
+            const cachedItems = await this.collectionCache.searchCache(query);
+            if (cachedItems.length > 0) {
+                logger.debug(`Found ${cachedItems.length} items from cache`);
+                return this.convertCacheItemsToGitHubFormat(cachedItems);
+            }
+            // If cache is empty or no results, use seed data
+            const seedItems = this.searchSeedData(query);
+            if (seedItems.length > 0) {
+                logger.debug(`Found ${seedItems.length} items from seed data`);
+                // Save seed data to cache for future use
+                await this.collectionCache.saveCache(CollectionSeeder.getSeedData());
+                return this.convertCacheItemsToGitHubFormat(seedItems);
+            }
+            logger.debug('No items found in cache or seed data');
+            return [];
+        }
+        catch (error) {
+            logger.error(`Cache search failed: ${error}`);
+            // Last resort: search seed data without cache
+            const seedItems = this.searchSeedData(query);
+            logger.debug(`Fallback to seed data found ${seedItems.length} items`);
+            return this.convertCacheItemsToGitHubFormat(seedItems);
+        }
+    }
+    /**
+     * Search seed data for matching items with fuzzy matching
+     */
+    searchSeedData(query) {
+        const seedData = CollectionSeeder.getSeedData();
+        const normalizedQuery = normalizeSearchTerm(query);
+        return seedData.filter(item => {
+            const normalizedName = normalizeSearchTerm(item.name);
+            const normalizedPath = normalizeSearchTerm(item.path);
+            return normalizedName.includes(normalizedQuery) ||
+                normalizedPath.includes(normalizedQuery);
+        });
+    }
+    /**
+     * Convert cache items to GitHub API format for consistent response structure
+     */
+    convertCacheItemsToGitHubFormat(cacheItems) {
+        return cacheItems.map(item => ({
+            name: item.name,
+            path: item.path,
+            sha: item.sha,
+            url: `https://api.github.com/repos/DollhouseMCP/collection/contents/${item.path}`,
+            html_url: `https://github.com/DollhouseMCP/collection/blob/main/${item.path}`,
+            repository: {
+                name: 'collection',
+                full_name: 'DollhouseMCP/collection'
+            }
+        }));
+    }
+    /**
+     * Update cache with fresh data from GitHub API items
+     */
+    async updateCacheFromGitHubItems(githubItems) {
+        try {
+            const cacheItems = githubItems.map(item => ({
+                name: item.name,
+                path: item.path,
+                sha: item.sha,
+                last_modified: new Date().toISOString()
+            }));
+            await this.collectionCache.saveCache(cacheItems);
+            logger.debug(`Updated cache with ${cacheItems.length} items from GitHub API`);
+        }
+        catch (error) {
+            logger.debug(`Failed to update cache: ${error}`);
+            // Don't throw - cache update failures shouldn't break functionality
+        }
     }
     /**
      * Format search results
@@ -45,4 +149,4 @@ export class CollectionSearch {
         return textParts.join('');
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionSearch.js","sourceRoot":"","sources":["../../src/collection/CollectionSearch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Search for content in the collection\n */\n\nimport { GitHubClient } from './GitHubClient.js';\nimport { CollectionCache, CollectionItem } from '../cache/CollectionCache.js';\nimport { CollectionSeeder } from './CollectionSeeder.js';\nimport { logger } from '../utils/logger.js';\nimport { normalizeSearchTerm, validateSearchQuery } from '../utils/searchUtils.js';\n\nexport class CollectionSearch {\n  private githubClient: GitHubClient;\n  private collectionCache: CollectionCache;\n  private searchBaseUrl = 'https://api.github.com/search/code';\n  \n  constructor(githubClient: GitHubClient, collectionCache?: CollectionCache) {\n    this.githubClient = githubClient;\n    this.collectionCache = collectionCache || new CollectionCache();\n  }\n  \n  /**\n   * Search collection for content matching query\n   * Falls back to cached data when GitHub API is not available or not authenticated\n   */\n  async searchCollection(query: string): Promise<any[]> {\n    // Validate search query for security\n    try {\n      validateSearchQuery(query, 1000);\n    } catch (error) {\n      logger.warn(`Invalid search query: ${error}`);\n      return [];\n    }\n    \n    try {\n      // First, try GitHub API search if authenticated\n      const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;\n      const data = await this.githubClient.fetchFromGitHub(searchUrl, false); // Don't require auth for search\n      \n      if (data.items && Array.isArray(data.items)) {\n        logger.debug(`Found ${data.items.length} items via GitHub API search`);\n        \n        // Update cache with fresh data from API\n        await this.updateCacheFromGitHubItems(data.items);\n        \n        return data.items;\n      }\n      \n      return [];\n    } catch (error) {\n      logger.debug(`GitHub API search failed, falling back to cache: ${error}`);\n      \n      // Fallback to cached search\n      return this.searchFromCache(query);\n    }\n  }\n  \n  /**\n   * Search cached collection items\n   */\n  private async searchFromCache(query: string): Promise<any[]> {\n    try {\n      // Try to load from cache first\n      const cachedItems = await this.collectionCache.searchCache(query);\n      \n      if (cachedItems.length > 0) {\n        logger.debug(`Found ${cachedItems.length} items from cache`);\n        return this.convertCacheItemsToGitHubFormat(cachedItems);\n      }\n      \n      // If cache is empty or no results, use seed data\n      const seedItems = this.searchSeedData(query);\n      if (seedItems.length > 0) {\n        logger.debug(`Found ${seedItems.length} items from seed data`);\n        // Save seed data to cache for future use\n        await this.collectionCache.saveCache(CollectionSeeder.getSeedData());\n        return this.convertCacheItemsToGitHubFormat(seedItems);\n      }\n      \n      logger.debug('No items found in cache or seed data');\n      return [];\n    } catch (error) {\n      logger.error(`Cache search failed: ${error}`);\n      \n      // Last resort: search seed data without cache\n      const seedItems = this.searchSeedData(query);\n      logger.debug(`Fallback to seed data found ${seedItems.length} items`);\n      return this.convertCacheItemsToGitHubFormat(seedItems);\n    }\n  }\n  \n  /**\n   * Search seed data for matching items with fuzzy matching\n   */\n  private searchSeedData(query: string): CollectionItem[] {\n    const seedData = CollectionSeeder.getSeedData();\n    const normalizedQuery = normalizeSearchTerm(query);\n    \n    return seedData.filter(item => {\n      const normalizedName = normalizeSearchTerm(item.name);\n      const normalizedPath = normalizeSearchTerm(item.path);\n      \n      return normalizedName.includes(normalizedQuery) || \n             normalizedPath.includes(normalizedQuery);\n    });\n  }\n  \n  \n  /**\n   * Convert cache items to GitHub API format for consistent response structure\n   */\n  private convertCacheItemsToGitHubFormat(cacheItems: CollectionItem[]): any[] {\n    return cacheItems.map(item => ({\n      name: item.name,\n      path: item.path,\n      sha: item.sha,\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      repository: {\n        name: 'collection',\n        full_name: 'DollhouseMCP/collection'\n      }\n    }));\n  }\n  \n  /**\n   * Update cache with fresh data from GitHub API items\n   */\n  private async updateCacheFromGitHubItems(githubItems: any[]): Promise<void> {\n    try {\n      const cacheItems: CollectionItem[] = githubItems.map(item => ({\n        name: item.name,\n        path: item.path,\n        sha: item.sha,\n        last_modified: new Date().toISOString()\n      }));\n      \n      await this.collectionCache.saveCache(cacheItems);\n      logger.debug(`Updated cache with ${cacheItems.length} items from GitHub API`);\n    } catch (error) {\n      logger.debug(`Failed to update cache: ${error}`);\n      // Don't throw - cache update failures shouldn't break functionality\n    }\n  }\n  \n  /**\n   * Format search results\n   */\n  formatSearchResults(items: any[], query: string, personaIndicator: string = ''): string {\n    if (items.length === 0) {\n      return `${personaIndicator}🔍 No content found for query: \"${query}\"`;\n    }\n    \n    const textParts = [`${personaIndicator}🔍 **Search Results for \"${query}\"** (${items.length} found)\\n\\n`];\n    \n    items.forEach((item: any) => {\n      // Extract content type from path (library/personas/creative/writer.md -> personas)\n      const pathParts = item.path.split('/');\n      const contentType = pathParts[1] || 'content';\n      \n      const contentIcons: { [key: string]: string } = {\n        'personas': '🎭',\n        'skills': '🛠️',\n        'agents': '🤖',\n        'prompts': '💬',\n        'templates': '📄',\n        'tools': '🔧',\n        'ensembles': '🎼'\n      };\n      const icon = contentIcons[contentType] || '📄';\n      \n      textParts.push(\n        `   ${icon} **${item.name.replace('.md', '')}**\\n`,\n        `      📂 Path: ${item.path}\\n`,\n        `      📥 Install: \\`install_content \"${item.path}\"\\`\\n`,\n        `      👁️ Details: \\`get_collection_content \"${item.path}\"\\`\\n\\n`\n      );\n    });\n    \n    return textParts.join('');\n  }\n}"]}

package/dist/collection/CollectionSeeder.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Collection seeder for anonymous/offline browsing
+ * Provides basic collection data that doesn't require GitHub authentication
+ */
+import { CollectionItem } from '../cache/CollectionCache.js';
+/**
+ * Basic collection data that can be used without GitHub API access
+ * This provides a minimal set of well-known collection items
+ */
+export declare class CollectionSeeder {
+    private static cachedSeedData;
+    /**
+     * Get seed data for the collection cache
+     * This includes popular/essential items that are commonly requested
+     * Data is cached as a static property to avoid recreation on every call
+     */
+    static getSeedData(): CollectionItem[];
+    /**
+     * Get collection statistics from seed data
+     */
+    static getSeedStats(): {
+        total: number;
+        byType: {
+            [k: string]: number;
+        };
+    };
+    /**
+     * Check if an item is available in seed data
+     */
+    static isItemInSeedData(path: string): boolean;
+    /**
+     * Get seed item by path
+     */
+    static getSeedItem(path: string): CollectionItem | undefined;
+}
+//# sourceMappingURL=CollectionSeeder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionSeeder.d.ts","sourceRoot":"","sources":["../../src/collection/CollectionSeeder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D;;;GAGG;AACH,qBAAa,gBAAgB;IAE3B,OAAO,CAAC,MAAM,CAAC,cAAc,CAAiC;IAE9D;;;;OAIG;IACH,MAAM,CAAC,WAAW,IAAI,cAAc,EAAE;IA8LtC;;OAEG;IACH,MAAM,CAAC,YAAY;;;;;;IAiBnB;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9C;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;CAG7D"}