@dollhousemcp/mcp-server 1.5.1 → 1.6.0

package/dist/collection/CollectionSearch.js

@@ -1,22 +1,218 @@
 /**
  * Search for content in the collection
  */
+import { CollectionCache } from '../cache/CollectionCache.js';
+import { CollectionIndexCache } from '../cache/CollectionIndexCache.js';
+import { CollectionSeeder } from './CollectionSeeder.js';
+import { logger } from '../utils/logger.js';
+import { normalizeSearchTerm, validateSearchQuery, isSearchMatch, debugNormalization } from '../utils/searchUtils.js';
+import { ErrorHandler } from '../utils/ErrorHandler.js';
 export class CollectionSearch {
     githubClient;
+    collectionCache;
+    indexCache;
     searchBaseUrl = 'https://api.github.com/search/code';
-    constructor(githubClient) {
+    constructor(githubClient, collectionCache) {
         this.githubClient = githubClient;
+        this.collectionCache = collectionCache || new CollectionCache();
+        this.indexCache = new CollectionIndexCache(githubClient);
+    }
+    /**
+     * Enhanced search using collection index with pagination and filtering
+     * Falls back to API search and cache when index is unavailable
+     */
+    async searchCollectionWithOptions(query, options = {}) {
+        const startTime = Date.now();
+        logger.debug(`CollectionSearch.searchCollectionWithOptions called with query: "${query}"`, options);
+        // Validate search query for security
+        try {
+            validateSearchQuery(query, 1000);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Search query validation failed:', { query, error: errorMessage });
+            ErrorHandler.logError('CollectionSearch.searchWithOptions.validateQuery', error, { query });
+            return this.createEmptySearchResults(query, options);
+        }
+        try {
+            // Try index-based search first
+            const indexResults = await this.searchFromIndex(query, options);
+            const searchTime = Date.now() - startTime;
+            logger.debug(`Index search completed in ${searchTime}ms with ${indexResults.items.length} results`);
+            return { ...indexResults, searchTime };
+        }
+        catch (error) {
+            logger.debug('Index search failed, falling back to legacy search:', error);
+            // Fallback to legacy search
+            const legacyResults = await this.searchCollection(query);
+            const searchTime = Date.now() - startTime;
+            // Convert legacy results to new format
+            return this.convertLegacyResults(legacyResults, query, options, searchTime);
+        }
     }
     /**
      * 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) {
+        logger.debug(`CollectionSearch.searchCollection called with query: "${query}"`);
+        // Validate search query for security
+        try {
+            validateSearchQuery(query, 1000);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Search query validation failed:', { query, error: errorMessage });
+            ErrorHandler.logError('CollectionSearch.search.validateQuery', error, { query });
+            return [];
+        }
+        try {
+            // First, try GitHub API search if authenticated
+            const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;
+            logger.debug(`Attempting GitHub API search with URL: ${searchUrl}`);
+            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;
+            }
+            logger.debug('GitHub API search returned no items, falling back to cache');
             return [];
         }
-        return data.items;
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`GitHub API search failed: ${errorMessage}. Falling back to cached search.`);
+            ErrorHandler.logError('CollectionSearch.search.githubApi', error, { query });
+            // Fallback to cached search
+            return this.searchFromCache(query);
+        }
+    }
+    /**
+     * Search cached collection items
+     */
+    async searchFromCache(query) {
+        logger.debug(`Searching cache for query: "${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);
+            }
+            logger.debug('Cache search returned no results, trying seed data');
+            // 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
+                try {
+                    await this.collectionCache.saveCache(CollectionSeeder.getSeedData());
+                    logger.debug('Saved seed data to cache');
+                }
+                catch (cacheError) {
+                    const cacheErrorMessage = cacheError instanceof Error ? cacheError.message : String(cacheError);
+                    logger.debug(`Failed to save seed data to cache: ${cacheErrorMessage}`);
+                }
+                return this.convertCacheItemsToGitHubFormat(seedItems);
+            }
+            logger.debug('No items found in cache or seed data');
+            return [];
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`Cache search failed: ${errorMessage}`);
+            ErrorHandler.logError('CollectionSearch.search.cache', error, { query });
+            // 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 normDebug = debugNormalization(query);
+        logger.debug(`Searching seed data - Original: "${normDebug.original}", Normalized: "${normDebug.normalized}", Partial: "${normDebug.partialMatch}"`);
+        logger.debug(`Searching against ${seedData.length} seed items`);
+        const matches = seedData.filter(item => {
+            // Use the improved matching function that tries multiple strategies
+            const nameMatches = isSearchMatch(query, item.name);
+            const pathMatches = isSearchMatch(query, item.path);
+            const isMatch = nameMatches || pathMatches;
+            if (isMatch) {
+                logger.debug(`✓ Match found: ${item.name} (${item.path}) matches query "${query}"`);
+            }
+            return isMatch;
+        });
+        // If no matches found, let's debug what we have
+        if (matches.length === 0) {
+            logger.debug('No matches found. Available seed data:');
+            seedData.slice(0, 10).forEach(item => {
+                logger.debug(`  - ${item.name} (${item.path})`);
+            });
+            if (seedData.length > 10) {
+                logger.debug(`  ... and ${seedData.length - 10} more items`);
+            }
+        }
+        logger.debug(`Found ${matches.length} matches in seed data`);
+        return matches;
+    }
+    /**
+     * Fuzzy matching algorithm for partial string matches
+     */
+    fuzzyMatch(term, target) {
+        // Simple fuzzy matching: check if all characters of term appear in order in target
+        if (term.length === 0)
+            return true;
+        if (target.length === 0)
+            return false;
+        let termIndex = 0;
+        let targetIndex = 0;
+        while (termIndex < term.length && targetIndex < target.length) {
+            if (term[termIndex] === target[targetIndex]) {
+                termIndex++;
+            }
+            targetIndex++;
+        }
+        return termIndex === term.length;
+    }
+    /**
+     * 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) {
+            ErrorHandler.logError('CollectionSearch.updateCacheInBackground', error);
+            // Don't throw - cache update failures shouldn't break functionality
+        }
     }
     /**
      * Format search results
@@ -44,5 +240,238 @@ export class CollectionSearch {
         });
         return textParts.join('');
     }
+    /**
+     * Search from collection index with full featured search and pagination
+     */
+    async searchFromIndex(query, options) {
+        const index = await this.indexCache.getIndex();
+        const allEntries = this.flattenIndexEntries(index);
+        // Filter by element type if specified
+        let filteredEntries = allEntries;
+        if (options.elementType) {
+            filteredEntries = allEntries.filter(entry => entry.type === options.elementType);
+        }
+        // Filter by category if specified
+        if (options.category) {
+            filteredEntries = filteredEntries.filter(entry => entry.category === options.category);
+        }
+        // Search matching
+        const matchedEntries = this.performIndexSearch(query, filteredEntries);
+        // Sort results
+        const sortedEntries = this.sortSearchResults(matchedEntries, options.sortBy || 'relevance', query);
+        // Apply pagination
+        const page = options.page || 1;
+        const pageSize = options.pageSize || 25;
+        const startIndex = (page - 1) * pageSize;
+        const endIndex = startIndex + pageSize;
+        const paginatedEntries = sortedEntries.slice(startIndex, endIndex);
+        return {
+            items: paginatedEntries,
+            total: sortedEntries.length,
+            page,
+            pageSize,
+            hasMore: endIndex < sortedEntries.length,
+            query,
+            searchTime: 0 // Will be set by caller
+        };
+    }
+    /**
+     * Flatten index entries from all categories into a single array
+     */
+    flattenIndexEntries(index) {
+        const entries = [];
+        for (const [elementType, typeEntries] of Object.entries(index.index)) {
+            entries.push(...typeEntries);
+        }
+        return entries;
+    }
+    /**
+     * Perform search matching on index entries
+     */
+    performIndexSearch(query, entries) {
+        const normalizedQuery = normalizeSearchTerm(query);
+        const queryWords = normalizedQuery.split(/\s+/).filter(word => word.length > 0);
+        return entries.filter(entry => {
+            // Search in multiple fields
+            const searchableText = [
+                entry.name,
+                entry.description,
+                entry.path,
+                ...entry.tags
+            ].join(' ').toLowerCase();
+            // Use existing search utilities for consistency
+            const nameMatch = isSearchMatch(query, entry.name);
+            const descMatch = isSearchMatch(query, entry.description);
+            const pathMatch = isSearchMatch(query, entry.path);
+            const tagMatch = entry.tags.some(tag => isSearchMatch(query, tag));
+            return nameMatch || descMatch || pathMatch || tagMatch;
+        });
+    }
+    /**
+     * Sort search results by relevance, name, or date
+     */
+    sortSearchResults(entries, sortBy, query) {
+        const sorted = [...entries];
+        switch (sortBy) {
+            case 'name':
+                sorted.sort((a, b) => a.name.localeCompare(b.name));
+                break;
+            case 'date':
+                sorted.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+                break;
+            case 'relevance':
+            default:
+                // Calculate relevance scores
+                sorted.sort((a, b) => {
+                    const scoreA = this.calculateRelevanceScore(query, a);
+                    const scoreB = this.calculateRelevanceScore(query, b);
+                    return scoreB - scoreA;
+                });
+                break;
+        }
+        return sorted;
+    }
+    /**
+     * Calculate relevance score for search results
+     */
+    calculateRelevanceScore(query, entry) {
+        const normalizedQuery = normalizeSearchTerm(query);
+        let score = 0;
+        // Exact name match gets highest score
+        if (normalizeSearchTerm(entry.name).includes(normalizedQuery)) {
+            score += 100;
+        }
+        // Description match
+        if (normalizeSearchTerm(entry.description).includes(normalizedQuery)) {
+            score += 50;
+        }
+        // Tag matches
+        const matchingTags = entry.tags.filter(tag => normalizeSearchTerm(tag).includes(normalizedQuery));
+        score += matchingTags.length * 25;
+        // Path match (lower priority)
+        if (normalizeSearchTerm(entry.path).includes(normalizedQuery)) {
+            score += 10;
+        }
+        // Bonus for recent content
+        const daysSinceCreated = (Date.now() - new Date(entry.created).getTime()) / (1000 * 60 * 60 * 24);
+        if (daysSinceCreated < 30) {
+            score += 5;
+        }
+        return score;
+    }
+    /**
+     * Convert legacy search results to new SearchResults format
+     */
+    convertLegacyResults(legacyResults, query, options, searchTime) {
+        // Convert GitHub API format to IndexEntry format
+        const entries = legacyResults.map(item => ({
+            path: item.path,
+            type: this.extractTypeFromPath(item.path),
+            name: item.name?.replace('.md', '') || 'Unknown',
+            description: 'No description available',
+            version: '1.0.0',
+            author: 'Unknown',
+            tags: [],
+            sha: item.sha || '',
+            category: this.extractCategoryFromPath(item.path),
+            created: new Date().toISOString(),
+            license: 'Unknown'
+        }));
+        // Apply pagination
+        const page = options.page || 1;
+        const pageSize = options.pageSize || 25;
+        const startIndex = (page - 1) * pageSize;
+        const endIndex = startIndex + pageSize;
+        const paginatedEntries = entries.slice(startIndex, endIndex);
+        return {
+            items: paginatedEntries,
+            total: entries.length,
+            page,
+            pageSize,
+            hasMore: endIndex < entries.length,
+            query,
+            searchTime
+        };
+    }
+    /**
+     * Extract element type from file path
+     */
+    extractTypeFromPath(path) {
+        const parts = path.split('/');
+        if (parts.length >= 2 && parts[0] === 'library') {
+            return parts[1];
+        }
+        return 'unknown';
+    }
+    /**
+     * Extract category from file path
+     */
+    extractCategoryFromPath(path) {
+        const parts = path.split('/');
+        if (parts.length >= 3 && parts[0] === 'library') {
+            return parts[2];
+        }
+        return 'uncategorized';
+    }
+    /**
+     * Create empty search results for error cases
+     */
+    createEmptySearchResults(query, options) {
+        return {
+            items: [],
+            total: 0,
+            page: options.page || 1,
+            pageSize: options.pageSize || 25,
+            hasMore: false,
+            query,
+            searchTime: 0
+        };
+    }
+    /**
+     * Enhanced format for search results with pagination info
+     */
+    formatSearchResultsWithPagination(results, personaIndicator = '') {
+        if (results.total === 0) {
+            return `${personaIndicator}🔍 No content found for query: "${results.query}"`;
+        }
+        const startItem = (results.page - 1) * results.pageSize + 1;
+        const endItem = Math.min(results.page * results.pageSize, results.total);
+        const textParts = [
+            `${personaIndicator}🔍 **Search Results for "${results.query}"**\n`,
+            `📊 Showing ${startItem}-${endItem} of ${results.total} results (Page ${results.page})\n`,
+            `⚡ Search time: ${results.searchTime}ms\n\n`
+        ];
+        results.items.forEach((item) => {
+            const contentIcons = {
+                'personas': '🎭',
+                'skills': '🛠️',
+                'agents': '🤖',
+                'prompts': '💬',
+                'templates': '📄',
+                'tools': '🔧',
+                'ensembles': '🎼',
+                'memories': '🧠'
+            };
+            const icon = contentIcons[item.type] || '📄';
+            textParts.push(`   ${icon} **${item.name}** (${item.type})\n`, `      📝 ${item.description}\n`, `      🏷️ Tags: ${item.tags.join(', ')}\n`, `      📂 Path: ${item.path}\n`, `      📥 Install: \`install_content "${item.path}"\`\n`, `      👁️ Details: \`get_collection_content "${item.path}"\`\n\n`);
+        });
+        // Add pagination info
+        if (results.hasMore) {
+            const nextPage = results.page + 1;
+            textParts.push(`📄 More results available. Use page ${nextPage} to see next ${results.pageSize} items.\n`);
+        }
+        return textParts.join('');
+    }
+    /**
+     * Get cache statistics for debugging
+     */
+    async getCacheStats() {
+        const indexStats = this.indexCache.getCacheStats();
+        const cacheStats = await this.collectionCache.getCacheStats();
+        return {
+            index: indexStats,
+            collection: cacheStats
+        };
+    }
 }
-//# 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 { CollectionIndexCache } from '../cache/CollectionIndexCache.js';\nimport { CollectionSeeder } from './CollectionSeeder.js';\nimport { logger } from '../utils/logger.js';\nimport { normalizeSearchTerm, validateSearchQuery, isSearchMatch, debugNormalization } from '../utils/searchUtils.js';\nimport { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';\nimport { IndexEntry, SearchResults, SearchOptions, CollectionIndex } from '../types/collection.js';\n\nexport class CollectionSearch {\n  private githubClient: GitHubClient;\n  private collectionCache: CollectionCache;\n  private indexCache: CollectionIndexCache;\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    this.indexCache = new CollectionIndexCache(githubClient);\n  }\n  \n  /**\n   * Enhanced search using collection index with pagination and filtering\n   * Falls back to API search and cache when index is unavailable\n   */\n  async searchCollectionWithOptions(query: string, options: SearchOptions = {}): Promise<SearchResults> {\n    const startTime = Date.now();\n    logger.debug(`CollectionSearch.searchCollectionWithOptions called with query: \"${query}\"`, options);\n    \n    // Validate search query for security\n    try {\n      validateSearchQuery(query, 1000);\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      logger.error('Search query validation failed:', { query, error: errorMessage });\n      ErrorHandler.logError('CollectionSearch.searchWithOptions.validateQuery', error, { query });\n      return this.createEmptySearchResults(query, options);\n    }\n    \n    try {\n      // Try index-based search first\n      const indexResults = await this.searchFromIndex(query, options);\n      const searchTime = Date.now() - startTime;\n      \n      logger.debug(`Index search completed in ${searchTime}ms with ${indexResults.items.length} results`);\n      return { ...indexResults, searchTime };\n    } catch (error) {\n      logger.debug('Index search failed, falling back to legacy search:', error);\n      \n      // Fallback to legacy search\n      const legacyResults = await this.searchCollection(query);\n      const searchTime = Date.now() - startTime;\n      \n      // Convert legacy results to new format\n      return this.convertLegacyResults(legacyResults, query, options, searchTime);\n    }\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    logger.debug(`CollectionSearch.searchCollection called with query: \"${query}\"`);\n    \n    // Validate search query for security\n    try {\n      validateSearchQuery(query, 1000);\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      logger.error('Search query validation failed:', { query, error: errorMessage });\n      ErrorHandler.logError('CollectionSearch.search.validateQuery', error, { query });\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      logger.debug(`Attempting GitHub API search with URL: ${searchUrl}`);\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      logger.debug('GitHub API search returned no items, falling back to cache');\n      return [];\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      logger.debug(`GitHub API search failed: ${errorMessage}. Falling back to cached search.`);\n      ErrorHandler.logError('CollectionSearch.search.githubApi', error, { query });\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    logger.debug(`Searching cache for query: \"${query}\"`);\n    \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      logger.debug('Cache search returned no results, trying seed data');\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        try {\n          await this.collectionCache.saveCache(CollectionSeeder.getSeedData());\n          logger.debug('Saved seed data to cache');\n        } catch (cacheError) {\n          const cacheErrorMessage = cacheError instanceof Error ? cacheError.message : String(cacheError);\n          logger.debug(`Failed to save seed data to cache: ${cacheErrorMessage}`);\n        }\n        return this.convertCacheItemsToGitHubFormat(seedItems);\n      }\n      \n      logger.debug('No items found in cache or seed data');\n      return [];\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      logger.debug(`Cache search failed: ${errorMessage}`);\n      ErrorHandler.logError('CollectionSearch.search.cache', error, { query });\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 normDebug = debugNormalization(query);\n    logger.debug(`Searching seed data - Original: \"${normDebug.original}\", Normalized: \"${normDebug.normalized}\", Partial: \"${normDebug.partialMatch}\"`);\n    logger.debug(`Searching against ${seedData.length} seed items`);\n    \n    const matches = seedData.filter(item => {\n      // Use the improved matching function that tries multiple strategies\n      const nameMatches = isSearchMatch(query, item.name);\n      const pathMatches = isSearchMatch(query, item.path);\n      \n      const isMatch = nameMatches || pathMatches;\n      \n      if (isMatch) {\n        logger.debug(`✓ Match found: ${item.name} (${item.path}) matches query \"${query}\"`);\n      }\n      \n      return isMatch;\n    });\n    \n    // If no matches found, let's debug what we have\n    if (matches.length === 0) {\n      logger.debug('No matches found. Available seed data:');\n      seedData.slice(0, 10).forEach(item => {\n        logger.debug(`  - ${item.name} (${item.path})`);\n      });\n      if (seedData.length > 10) {\n        logger.debug(`  ... and ${seedData.length - 10} more items`);\n      }\n    }\n    \n    logger.debug(`Found ${matches.length} matches in seed data`);\n    return matches;\n  }\n  \n  /**\n   * Fuzzy matching algorithm for partial string matches\n   */\n  private fuzzyMatch(term: string, target: string): boolean {\n    // Simple fuzzy matching: check if all characters of term appear in order in target\n    if (term.length === 0) return true;\n    if (target.length === 0) return false;\n    \n    let termIndex = 0;\n    let targetIndex = 0;\n    \n    while (termIndex < term.length && targetIndex < target.length) {\n      if (term[termIndex] === target[targetIndex]) {\n        termIndex++;\n      }\n      targetIndex++;\n    }\n    \n    return termIndex === term.length;\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      ErrorHandler.logError('CollectionSearch.updateCacheInBackground', 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\n  /**\n   * Search from collection index with full featured search and pagination\n   */\n  private async searchFromIndex(query: string, options: SearchOptions): Promise<SearchResults> {\n    const index = await this.indexCache.getIndex();\n    const allEntries = this.flattenIndexEntries(index);\n    \n    // Filter by element type if specified\n    let filteredEntries = allEntries;\n    if (options.elementType) {\n      filteredEntries = allEntries.filter(entry => entry.type === options.elementType);\n    }\n    \n    // Filter by category if specified\n    if (options.category) {\n      filteredEntries = filteredEntries.filter(entry => entry.category === options.category);\n    }\n    \n    // Search matching\n    const matchedEntries = this.performIndexSearch(query, filteredEntries);\n    \n    // Sort results\n    const sortedEntries = this.sortSearchResults(matchedEntries, options.sortBy || 'relevance', query);\n    \n    // Apply pagination\n    const page = options.page || 1;\n    const pageSize = options.pageSize || 25;\n    const startIndex = (page - 1) * pageSize;\n    const endIndex = startIndex + pageSize;\n    const paginatedEntries = sortedEntries.slice(startIndex, endIndex);\n    \n    return {\n      items: paginatedEntries,\n      total: sortedEntries.length,\n      page,\n      pageSize,\n      hasMore: endIndex < sortedEntries.length,\n      query,\n      searchTime: 0 // Will be set by caller\n    };\n  }\n\n  /**\n   * Flatten index entries from all categories into a single array\n   */\n  private flattenIndexEntries(index: CollectionIndex): IndexEntry[] {\n    const entries: IndexEntry[] = [];\n    \n    for (const [elementType, typeEntries] of Object.entries(index.index)) {\n      entries.push(...typeEntries);\n    }\n    \n    return entries;\n  }\n\n  /**\n   * Perform search matching on index entries\n   */\n  private performIndexSearch(query: string, entries: IndexEntry[]): IndexEntry[] {\n    const normalizedQuery = normalizeSearchTerm(query);\n    const queryWords = normalizedQuery.split(/\\s+/).filter(word => word.length > 0);\n    \n    return entries.filter(entry => {\n      // Search in multiple fields\n      const searchableText = [\n        entry.name,\n        entry.description,\n        entry.path,\n        ...entry.tags\n      ].join(' ').toLowerCase();\n      \n      // Use existing search utilities for consistency\n      const nameMatch = isSearchMatch(query, entry.name);\n      const descMatch = isSearchMatch(query, entry.description);\n      const pathMatch = isSearchMatch(query, entry.path);\n      const tagMatch = entry.tags.some(tag => isSearchMatch(query, tag));\n      \n      return nameMatch || descMatch || pathMatch || tagMatch;\n    });\n  }\n\n  /**\n   * Sort search results by relevance, name, or date\n   */\n  private sortSearchResults(entries: IndexEntry[], sortBy: 'relevance' | 'name' | 'date', query: string): IndexEntry[] {\n    const sorted = [...entries];\n    \n    switch (sortBy) {\n      case 'name':\n        sorted.sort((a, b) => a.name.localeCompare(b.name));\n        break;\n      case 'date':\n        sorted.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());\n        break;\n      case 'relevance':\n      default:\n        // Calculate relevance scores\n        sorted.sort((a, b) => {\n          const scoreA = this.calculateRelevanceScore(query, a);\n          const scoreB = this.calculateRelevanceScore(query, b);\n          return scoreB - scoreA;\n        });\n        break;\n    }\n    \n    return sorted;\n  }\n\n  /**\n   * Calculate relevance score for search results\n   */\n  private calculateRelevanceScore(query: string, entry: IndexEntry): number {\n    const normalizedQuery = normalizeSearchTerm(query);\n    let score = 0;\n    \n    // Exact name match gets highest score\n    if (normalizeSearchTerm(entry.name).includes(normalizedQuery)) {\n      score += 100;\n    }\n    \n    // Description match\n    if (normalizeSearchTerm(entry.description).includes(normalizedQuery)) {\n      score += 50;\n    }\n    \n    // Tag matches\n    const matchingTags = entry.tags.filter(tag => \n      normalizeSearchTerm(tag).includes(normalizedQuery)\n    );\n    score += matchingTags.length * 25;\n    \n    // Path match (lower priority)\n    if (normalizeSearchTerm(entry.path).includes(normalizedQuery)) {\n      score += 10;\n    }\n    \n    // Bonus for recent content\n    const daysSinceCreated = (Date.now() - new Date(entry.created).getTime()) / (1000 * 60 * 60 * 24);\n    if (daysSinceCreated < 30) {\n      score += 5;\n    }\n    \n    return score;\n  }\n\n  /**\n   * Convert legacy search results to new SearchResults format\n   */\n  private convertLegacyResults(legacyResults: any[], query: string, options: SearchOptions, searchTime: number): SearchResults {\n    // Convert GitHub API format to IndexEntry format\n    const entries: IndexEntry[] = legacyResults.map(item => ({\n      path: item.path,\n      type: this.extractTypeFromPath(item.path),\n      name: item.name?.replace('.md', '') || 'Unknown',\n      description: 'No description available',\n      version: '1.0.0',\n      author: 'Unknown',\n      tags: [],\n      sha: item.sha || '',\n      category: this.extractCategoryFromPath(item.path),\n      created: new Date().toISOString(),\n      license: 'Unknown'\n    }));\n    \n    // Apply pagination\n    const page = options.page || 1;\n    const pageSize = options.pageSize || 25;\n    const startIndex = (page - 1) * pageSize;\n    const endIndex = startIndex + pageSize;\n    const paginatedEntries = entries.slice(startIndex, endIndex);\n    \n    return {\n      items: paginatedEntries,\n      total: entries.length,\n      page,\n      pageSize,\n      hasMore: endIndex < entries.length,\n      query,\n      searchTime\n    };\n  }\n\n  /**\n   * Extract element type from file path\n   */\n  private extractTypeFromPath(path: string): string {\n    const parts = path.split('/');\n    if (parts.length >= 2 && parts[0] === 'library') {\n      return parts[1];\n    }\n    return 'unknown';\n  }\n\n  /**\n   * Extract category from file path\n   */\n  private extractCategoryFromPath(path: string): string {\n    const parts = path.split('/');\n    if (parts.length >= 3 && parts[0] === 'library') {\n      return parts[2];\n    }\n    return 'uncategorized';\n  }\n\n  /**\n   * Create empty search results for error cases\n   */\n  private createEmptySearchResults(query: string, options: SearchOptions): SearchResults {\n    return {\n      items: [],\n      total: 0,\n      page: options.page || 1,\n      pageSize: options.pageSize || 25,\n      hasMore: false,\n      query,\n      searchTime: 0\n    };\n  }\n\n  /**\n   * Enhanced format for search results with pagination info\n   */\n  formatSearchResultsWithPagination(results: SearchResults, personaIndicator: string = ''): string {\n    if (results.total === 0) {\n      return `${personaIndicator}🔍 No content found for query: \"${results.query}\"`;\n    }\n    \n    const startItem = (results.page - 1) * results.pageSize + 1;\n    const endItem = Math.min(results.page * results.pageSize, results.total);\n    \n    const textParts = [\n      `${personaIndicator}🔍 **Search Results for \"${results.query}\"**\\n`,\n      `📊 Showing ${startItem}-${endItem} of ${results.total} results (Page ${results.page})\\n`,\n      `⚡ Search time: ${results.searchTime}ms\\n\\n`\n    ];\n    \n    results.items.forEach((item: IndexEntry) => {\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[item.type] || '📄';\n      \n      textParts.push(\n        `   ${icon} **${item.name}** (${item.type})\\n`,\n        `      📝 ${item.description}\\n`,\n        `      🏷️ Tags: ${item.tags.join(', ')}\\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    // Add pagination info\n    if (results.hasMore) {\n      const nextPage = results.page + 1;\n      textParts.push(`📄 More results available. Use page ${nextPage} to see next ${results.pageSize} items.\\n`);\n    }\n    \n    return textParts.join('');\n  }\n\n  /**\n   * Get cache statistics for debugging\n   */\n  async getCacheStats(): Promise<any> {\n    const indexStats = this.indexCache.getCacheStats();\n    const cacheStats = await this.collectionCache.getCacheStats();\n    \n    return {\n      index: indexStats,\n      collection: cacheStats\n    };\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;IAoOtC;;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"}