@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/portfolio/UnifiedIndexManager.js

@@ -0,0 +1,1434 @@
+/**
+ * Unified Index Manager - Combines local, GitHub, and collection portfolio indexing
+ *
+ * Features:
+ * - Unified search across local, GitHub, and collection portfolios
+ * - Intelligent result merging and deduplication
+ * - Version conflict detection and resolution
+ * - Performance optimization with parallel indexing
+ * - Advanced fallback strategies for resilient operation
+ * - Comprehensive search capabilities with pagination
+ * - Smart result ranking and duplicate detection
+ */
+import { PortfolioIndexManager } from './PortfolioIndexManager.js';
+import { GitHubPortfolioIndexer } from './GitHubPortfolioIndexer.js';
+import { CollectionIndexCache } from '../cache/CollectionIndexCache.js';
+import { GitHubClient } from '../collection/GitHubClient.js';
+import { APICache } from '../cache/APICache.js';
+import { ElementType } from './types.js';
+import { logger } from '../utils/logger.js';
+import { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';
+import { CacheFactory } from '../cache/LRUCache.js';
+import { PerformanceMonitor } from '../utils/PerformanceMonitor.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+export class UnifiedIndexManager {
+    static instance = null;
+    localIndexManager;
+    githubIndexer;
+    collectionIndexCache;
+    githubClient;
+    // Performance monitoring and caching
+    performanceMonitor;
+    resultCache;
+    indexCache;
+    BATCH_SIZE = 50; // For streaming results
+    MAX_CONCURRENT_SOURCES = 3;
+    constructor() {
+        this.localIndexManager = PortfolioIndexManager.getInstance();
+        this.githubIndexer = GitHubPortfolioIndexer.getInstance();
+        // Initialize GitHubClient with required dependencies
+        const apiCache = new APICache();
+        const rateLimitTracker = new Map();
+        this.githubClient = new GitHubClient(apiCache, rateLimitTracker);
+        this.collectionIndexCache = new CollectionIndexCache(this.githubClient);
+        // Initialize performance monitoring and caching
+        this.performanceMonitor = PerformanceMonitor.getInstance();
+        this.performanceMonitor.startMonitoring();
+        this.resultCache = CacheFactory.createSearchResultCache({
+            maxSize: 200,
+            maxMemoryMB: 15,
+            ttlMs: 5 * 60 * 1000, // 5 minutes
+            onEviction: (key, value) => {
+                logger.debug('Search result cache eviction', { key, resultCount: value.length });
+            }
+        });
+        this.indexCache = CacheFactory.createIndexCache({
+            maxSize: 100,
+            maxMemoryMB: 20,
+            ttlMs: 15 * 60 * 1000, // 15 minutes
+            onEviction: (key, value) => {
+                logger.debug('Index cache eviction', { key });
+            }
+        });
+        logger.debug('UnifiedIndexManager created with performance optimization');
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new UnifiedIndexManager();
+        }
+        return this.instance;
+    }
+    /**
+     * Enhanced search across local, GitHub, and collection portfolios with performance optimization
+     */
+    async search(searchOptions) {
+        const startTime = Date.now();
+        const memoryBefore = process.memoryUsage().heapUsed;
+        const { query, includeLocal = true, includeGitHub = true, includeCollection = false } = searchOptions;
+        // Normalize query to prevent Unicode-based attacks
+        const validationResult = UnicodeValidator.normalize(query);
+        const normalizedQuery = validationResult.normalizedContent;
+        // Use normalized query in all subsequent operations
+        const normalizedSearchOptions = {
+            ...searchOptions,
+            query: normalizedQuery
+        };
+        // SECURITY FIX (DMCP-SEC-006): Add audit logging for security monitoring
+        // Log unified search operations for security audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'PORTFOLIO_FETCH_SUCCESS',
+            severity: 'LOW',
+            source: 'UnifiedIndexManager.search',
+            details: `Unified search performed with query length: ${normalizedQuery.length}, sources: ${JSON.stringify({
+                local: includeLocal,
+                github: includeGitHub,
+                collection: includeCollection
+            })}`
+        });
+        logger.debug('Starting optimized unified portfolio search', normalizedSearchOptions);
+        // Check cache first (use normalized search options)
+        const cacheKey = this.createCacheKey(normalizedSearchOptions);
+        const cached = this.resultCache.get(cacheKey);
+        if (cached) {
+            const duration = Date.now() - startTime;
+            this.recordSearchMetrics({
+                query: normalizedQuery,
+                duration,
+                resultCount: cached.length,
+                sources: this.getEnabledSources(normalizedSearchOptions),
+                cacheHit: true,
+                memoryBefore,
+                memoryAfter: process.memoryUsage().heapUsed,
+                timestamp: new Date()
+            });
+            logger.debug('Using cached search results', { resultCount: cached.length });
+            return cached;
+        }
+        try {
+            // Use streaming search for better performance with large result sets
+            if (normalizedSearchOptions.streamResults) {
+                return await this.streamSearch(normalizedSearchOptions);
+            }
+            // Lazy loading: Only load indices when needed
+            const searchPromises = [];
+            const enabledSources = this.getEnabledSources(normalizedSearchOptions);
+            // Limit concurrent source searches for memory efficiency
+            const concurrentLimit = Math.min(this.MAX_CONCURRENT_SOURCES, enabledSources.length);
+            const sourceBatches = this.batchSources(enabledSources, concurrentLimit);
+            const allResults = [];
+            const sourceCount = { local: 0, github: 0, collection: 0 };
+            // Process sources in batches to control memory usage
+            for (const batch of sourceBatches) {
+                const batchPromises = batch.map(source => this.searchWithFallback(source, normalizedQuery, normalizedSearchOptions));
+                const batchResults = await Promise.allSettled(batchPromises);
+                batchResults.forEach((result, index) => {
+                    const sourceName = batch[index];
+                    if (result.status === 'fulfilled') {
+                        sourceCount[sourceName] += result.value.length;
+                        allResults.push(...result.value);
+                    }
+                    else {
+                        logger.warn(`Search failed for source ${sourceName}`, {
+                            error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+                        });
+                    }
+                });
+                // Memory check between batches
+                const currentMemory = process.memoryUsage().heapUsed / (1024 * 1024);
+                if (currentMemory > 200) { // 200MB threshold
+                    logger.warn('High memory usage during search, triggering cleanup', {
+                        memoryMB: currentMemory
+                    });
+                    this.triggerMemoryCleanup();
+                }
+            }
+            // Apply advanced processing with memory-efficient batching
+            const processedResults = await this.processSearchResultsOptimized(allResults, normalizedSearchOptions);
+            // Apply pagination
+            const paginatedResults = this.applyPagination(processedResults, normalizedSearchOptions);
+            // Cache results with memory limit check
+            if (paginatedResults.length < 1000) { // Don't cache very large result sets
+                this.resultCache.set(cacheKey, paginatedResults);
+            }
+            const duration = Date.now() - startTime;
+            const memoryAfter = process.memoryUsage().heapUsed;
+            this.recordSearchMetrics({
+                query: normalizedQuery,
+                duration,
+                resultCount: paginatedResults.length,
+                sources: enabledSources,
+                cacheHit: false,
+                memoryBefore,
+                memoryAfter,
+                timestamp: new Date()
+            });
+            logger.info('Optimized unified portfolio search completed', {
+                query: normalizedQuery.substring(0, 50),
+                sources: { ...sourceCount, total: allResults.length },
+                finalResults: paginatedResults.length,
+                duration: `${duration}ms`,
+                memoryUsageMB: (memoryAfter - memoryBefore) / (1024 * 1024)
+            });
+            return paginatedResults;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            ErrorHandler.logError('UnifiedIndexManager.search', error, { query: normalizedSearchOptions, duration });
+            throw ErrorHandler.wrapError(error, 'Failed to perform unified portfolio search', ErrorCategory.SYSTEM_ERROR);
+        }
+    }
+    /**
+     * Find element by name across all portfolios
+     */
+    async findByName(name, options = {}) {
+        try {
+            const searchOptions = {
+                query: name,
+                includeLocal: options.includeLocal ?? true,
+                includeGitHub: options.includeGitHub ?? true,
+                includeCollection: options.includeCollection ?? false,
+                pageSize: 1,
+                ...options
+            };
+            const results = await this.search(searchOptions);
+            // Return exact name match first, then best match
+            const exactMatch = results.find(result => result.entry.name.toLowerCase() === name.toLowerCase());
+            return exactMatch?.entry || results[0]?.entry || null;
+        }
+        catch (error) {
+            ErrorHandler.logError('UnifiedIndexManager.findByName', error, { name });
+            return null;
+        }
+    }
+    /**
+     * Get elements by type from all portfolios
+     */
+    async getElementsByType(elementType, options = {}) {
+        try {
+            const searchOptions = {
+                query: '', // Empty query to get all elements
+                elementType,
+                includeLocal: options.includeLocal ?? true,
+                includeGitHub: options.includeGitHub ?? true,
+                includeCollection: options.includeCollection ?? false,
+                pageSize: 1000, // Large page size to get all
+                ...options
+            };
+            const results = await this.getAllElementsByType(elementType, searchOptions);
+            return this.deduplicateEntries(results.map(r => r.entry));
+        }
+        catch (error) {
+            ErrorHandler.logError('UnifiedIndexManager.getElementsByType', error, { elementType });
+            return [];
+        }
+    }
+    /**
+     * Check for duplicates across all sources
+     */
+    async checkDuplicates(name) {
+        try {
+            const searchOptions = {
+                query: name,
+                includeLocal: true,
+                includeGitHub: true,
+                includeCollection: true,
+                pageSize: 100
+            };
+            const results = await this.search(searchOptions);
+            const duplicateMap = new Map();
+            for (const result of results) {
+                const key = `${result.entry.elementType}:${result.entry.name.toLowerCase()}`;
+                if (!duplicateMap.has(key)) {
+                    duplicateMap.set(key, {
+                        name: result.entry.name,
+                        elementType: result.entry.elementType,
+                        sources: [],
+                        hasVersionConflict: false
+                    });
+                }
+                const duplicate = duplicateMap.get(key);
+                duplicate.sources.push({
+                    source: result.source,
+                    version: result.entry.version,
+                    lastModified: result.entry.lastModified,
+                    path: this.getPathFromEntry(result.entry)
+                });
+            }
+            // Filter to only items with multiple sources and check version conflicts
+            const actualDuplicates = Array.from(duplicateMap.values())
+                .filter(item => item.sources.length > 1)
+                .map(item => {
+                const versionConflict = this.detectVersionConflict(item.sources);
+                return {
+                    ...item,
+                    hasVersionConflict: !!versionConflict,
+                    versionConflict
+                };
+            });
+            return actualDuplicates;
+        }
+        catch (error) {
+            ErrorHandler.logError('UnifiedIndexManager.checkDuplicates', error, { name });
+            return [];
+        }
+    }
+    /**
+     * Get version comparison across all sources
+     */
+    async getVersionComparison(name) {
+        try {
+            const duplicates = await this.checkDuplicates(name);
+            if (duplicates.length === 0) {
+                return null;
+            }
+            const duplicate = duplicates[0];
+            const versions = {};
+            // Build version info
+            for (const source of duplicate.sources) {
+                if (source.source === 'local') {
+                    versions.local = {
+                        version: source.version || 'unknown',
+                        lastModified: source.lastModified,
+                        path: source.path || 'unknown'
+                    };
+                }
+                else if (source.source === 'github') {
+                    versions.github = {
+                        version: source.version || 'unknown',
+                        lastModified: source.lastModified,
+                        path: source.path || 'unknown'
+                    };
+                }
+                else if (source.source === 'collection') {
+                    versions.collection = {
+                        version: source.version || 'unknown',
+                        lastModified: source.lastModified,
+                        path: source.path || 'unknown'
+                    };
+                }
+            }
+            // Determine recommendation
+            const recommendation = this.determineVersionRecommendation(versions);
+            return {
+                name: duplicate.name,
+                elementType: duplicate.elementType,
+                versions,
+                recommended: recommendation,
+                updateAvailable: recommendation.source !== 'local' && !!versions.local,
+                updateFrom: recommendation.source !== 'local' ? recommendation.source : undefined
+            };
+        }
+        catch (error) {
+            ErrorHandler.logError('UnifiedIndexManager.getVersionComparison', error, { name });
+            return null;
+        }
+    }
+    /**
+     * Get comprehensive statistics across all sources
+     */
+    async getStats() {
+        try {
+            const [localStats, githubStats, collectionStats] = await Promise.allSettled([
+                this.getLocalStats(),
+                this.getGitHubStats(),
+                this.getCollectionStats()
+            ]);
+            const local = localStats.status === 'fulfilled' ? localStats.value : {
+                totalElements: 0,
+                elementsByType: {},
+                lastBuilt: null,
+                isStale: true
+            };
+            const github = githubStats.status === 'fulfilled' ? githubStats.value : {
+                totalElements: 0,
+                elementsByType: {},
+                lastFetched: null,
+                isStale: true
+            };
+            const collection = collectionStats.status === 'fulfilled' ? collectionStats.value : {
+                totalElements: 0,
+                elementsByType: {},
+                lastFetched: null,
+                isStale: true
+            };
+            // Calculate combined statistics
+            const totalElements = local.totalElements + github.totalElements + collection.totalElements;
+            const duplicatesCount = await this.calculateDuplicatesCount();
+            const uniqueElements = totalElements - duplicatesCount;
+            return {
+                local,
+                github,
+                collection,
+                combined: {
+                    totalElements,
+                    uniqueElements,
+                    duplicates: duplicatesCount
+                },
+                performance: {
+                    averageSearchTime: this.getPerformanceStats().searchStats.averageTime || 0,
+                    cacheHitRate: this.getPerformanceStats().searchStats.cacheHitRate || 0,
+                    lastOptimized: null
+                }
+            };
+        }
+        catch (error) {
+            ErrorHandler.logError('UnifiedIndexManager.getStats', error);
+            throw error;
+        }
+    }
+    /**
+     * Invalidate caches after user actions with performance monitoring
+     */
+    invalidateAfterAction(action) {
+        logger.info('Invalidating unified portfolio caches after user action', { action });
+        // Clear result and index caches
+        this.resultCache.clear();
+        this.indexCache.clear();
+        // Invalidate local cache
+        this.localIndexManager.rebuildIndex().catch(error => {
+            logger.warn('Failed to rebuild local index after action', {
+                action,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        });
+        // Invalidate GitHub cache
+        this.githubIndexer.invalidateAfterAction(action);
+        // Invalidate collection cache
+        this.collectionIndexCache.clearCache().catch(error => {
+            logger.warn('Failed to clear collection cache after action', {
+                action,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        });
+        // Trigger garbage collection if memory usage is high
+        this.triggerMemoryCleanup();
+    }
+    /**
+     * Force rebuild of all indexes with performance optimization
+     */
+    async rebuildAll() {
+        const startTime = Date.now();
+        logger.info('Rebuilding all portfolio indexes with optimization...');
+        try {
+            // Clear all caches
+            this.resultCache.clear();
+            this.indexCache.clear();
+            // Reset performance counters
+            this.performanceMonitor.reset();
+            // Rebuild in parallel with memory monitoring
+            const rebuildPromises = [
+                this.localIndexManager.rebuildIndex(),
+                this.githubIndexer.clearCache(),
+                this.collectionIndexCache.clearCache()
+            ];
+            await Promise.all(rebuildPromises);
+            // Trigger cleanup
+            this.triggerMemoryCleanup();
+            const duration = Date.now() - startTime;
+            logger.info('All portfolio indexes rebuilt successfully', {
+                duration: `${duration}ms`,
+                memoryUsageMB: process.memoryUsage().heapUsed / (1024 * 1024)
+            });
+        }
+        catch (error) {
+            ErrorHandler.logError('UnifiedIndexManager.rebuildAll', error);
+            throw error;
+        }
+    }
+    // =====================================================
+    // PRIVATE HELPER METHODS
+    // =====================================================
+    /**
+     * Search with fallback strategies for resilient operation
+     */
+    async searchWithFallback(source, query, options) {
+        const startTime = Date.now();
+        try {
+            let results = [];
+            switch (source) {
+                case 'local':
+                    results = await this.searchLocal(query, options);
+                    break;
+                case 'github':
+                    results = await this.searchGitHub(query, options);
+                    break;
+                case 'collection':
+                    results = await this.searchCollection(query, options);
+                    break;
+            }
+            logger.debug(`${source} search completed in ${Date.now() - startTime}ms with ${results.length} results`);
+            return results;
+        }
+        catch (error) {
+            logger.debug(`${source} search failed, attempting fallback`, {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // Fallback strategies
+            return await this.handleSearchFallback(source, query, options, error);
+        }
+    }
+    /**
+     * Handle search fallback strategies
+     */
+    async handleSearchFallback(source, query, options, originalError) {
+        try {
+            switch (source) {
+                case 'local':
+                    // Try to use stale local index
+                    logger.debug('Attempting to use stale local index');
+                    return await this.searchLocalStale(query, options);
+                case 'github':
+                    // Try cached GitHub data
+                    logger.debug('Attempting to use cached GitHub data');
+                    return await this.searchGitHubCached(query, options);
+                case 'collection':
+                    // Try cached collection data
+                    logger.debug('Attempting to use cached collection data');
+                    return await this.searchCollectionCached(query, options);
+                default:
+                    return [];
+            }
+        }
+        catch (fallbackError) {
+            logger.warn(`All fallback strategies failed for ${source}`, {
+                originalError: originalError instanceof Error ? originalError.message : String(originalError),
+                fallbackError: fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+            });
+            return [];
+        }
+    }
+    /**
+     * Search local portfolio
+     */
+    async searchLocal(query, options) {
+        const localOptions = this.convertToLocalOptions(options);
+        const results = await this.localIndexManager.search(query, localOptions);
+        return results.map(result => ({
+            source: 'local',
+            entry: this.convertLocalEntry(result.entry),
+            matchType: result.matchType,
+            score: result.score,
+            version: result.entry.metadata.version
+        }));
+    }
+    /**
+     * Search local with stale data fallback
+     */
+    async searchLocalStale(query, options) {
+        try {
+            // Try to get any local data, even stale
+            const localOptions = this.convertToLocalOptions(options);
+            const results = await this.localIndexManager.search(query, localOptions);
+            return results.map(result => ({
+                source: 'local',
+                entry: this.convertLocalEntry(result.entry),
+                matchType: result.matchType,
+                score: result.score * 0.8, // Reduce score for stale data
+                version: result.entry.metadata.version
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Search GitHub portfolio
+     */
+    async searchGitHub(query, options) {
+        try {
+            const githubIndex = await this.githubIndexer.getIndex();
+            const results = [];
+            const queryLower = query.toLowerCase();
+            const queryTokens = queryLower.split(/\s+/).filter(token => token.length > 0);
+            if (queryTokens.length === 0 && query.trim() !== '') {
+                return results;
+            }
+            // Search across all GitHub elements
+            for (const [elementType, entries] of githubIndex.elements) {
+                // Filter by element type if specified
+                if (options.elementType && elementType !== options.elementType) {
+                    continue;
+                }
+                for (const entry of entries) {
+                    const score = this.calculateGitHubMatchScore(entry, queryTokens, query);
+                    if (score > 0 || query.trim() === '') {
+                        results.push({
+                            source: 'github',
+                            entry: this.convertGitHubEntry(entry),
+                            matchType: this.determineMatchType(entry, queryTokens),
+                            score: query.trim() === '' ? 1 : score, // Default score for empty query
+                            version: entry.version
+                        });
+                    }
+                }
+            }
+            return results.sort((a, b) => b.score - a.score);
+        }
+        catch (error) {
+            logger.debug('GitHub search failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error; // Re-throw to trigger fallback
+        }
+    }
+    /**
+     * Search GitHub with cached data fallback
+     */
+    async searchGitHubCached(query, options) {
+        try {
+            // Try to use stale GitHub data
+            const cacheStats = this.githubIndexer.getCacheStats();
+            if (!cacheStats.isStale) {
+                return await this.searchGitHub(query, options);
+            }
+            // Use stale data with reduced scores
+            const results = await this.searchGitHub(query, options);
+            return results.map(result => ({
+                ...result,
+                score: result.score * 0.7 // Reduce score for stale data
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Search collection portfolio
+     */
+    async searchCollection(query, options) {
+        try {
+            const collectionIndex = await this.collectionIndexCache.getIndex();
+            const results = [];
+            const queryLower = query.toLowerCase();
+            const queryTokens = queryLower.split(/\s+/).filter(token => token.length > 0);
+            if (queryTokens.length === 0 && query.trim() !== '') {
+                return results;
+            }
+            // Search across all collection elements
+            for (const [elementType, entries] of Object.entries(collectionIndex.index)) {
+                // Filter by element type if specified
+                if (options.elementType && elementType !== options.elementType.toString()) {
+                    continue;
+                }
+                for (const entry of entries) {
+                    const score = this.calculateCollectionMatchScore(entry, queryTokens, query);
+                    if (score > 0 || query.trim() === '') {
+                        results.push({
+                            source: 'collection',
+                            entry: this.convertCollectionEntry(entry, elementType),
+                            matchType: this.determineCollectionMatchType(entry, queryTokens),
+                            score: query.trim() === '' ? 1 : score, // Default score for empty query
+                            version: entry.version
+                        });
+                    }
+                }
+            }
+            return results.sort((a, b) => b.score - a.score);
+        }
+        catch (error) {
+            logger.debug('Collection search failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error; // Re-throw to trigger fallback
+        }
+    }
+    /**
+     * Search collection with cached data fallback
+     */
+    async searchCollectionCached(query, options) {
+        try {
+            // Try to use stale collection data
+            const cacheStats = this.collectionIndexCache.getCacheStats();
+            if (cacheStats.isValid) {
+                return await this.searchCollection(query, options);
+            }
+            // Use stale data with reduced scores
+            const results = await this.searchCollection(query, options);
+            return results.map(result => ({
+                ...result,
+                score: result.score * 0.6 // Reduce score for stale collection data
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Process search results with advanced features
+     */
+    async processSearchResults(results, options) {
+        // Apply smart ranking
+        const rankedResults = this.applySmartRanking(results, options);
+        // Detect duplicates and version conflicts
+        const processedResults = await this.detectDuplicatesAndConflicts(rankedResults);
+        // Apply sorting
+        const sortedResults = this.applySorting(processedResults, options.sortBy || 'relevance', options.query);
+        return sortedResults;
+    }
+    /**
+     * Apply smart result ranking
+     */
+    applySmartRanking(results, options) {
+        return results.map(result => {
+            let adjustedScore = result.score;
+            // No location-based scoring - score should be based on relevance only
+            // Source location doesn't affect the intrinsic value of an element
+            // Consider version freshness (newer versions get small bonus)
+            if (result.version && result.version !== 'unknown') {
+                const versionParts = result.version.split('.');
+                if (versionParts.length >= 2) {
+                    const major = parseInt(versionParts[0]) || 0;
+                    const minor = parseInt(versionParts[1]) || 0;
+                    adjustedScore += (major * 0.1) + (minor * 0.01);
+                }
+            }
+            // Boost exact matches
+            if (result.entry.name.toLowerCase() === options.query.toLowerCase()) {
+                adjustedScore *= 2.0;
+            }
+            return {
+                ...result,
+                score: adjustedScore
+            };
+        });
+    }
+    /**
+     * Detect duplicates and version conflicts
+     */
+    async detectDuplicatesAndConflicts(results) {
+        const nameMap = new Map();
+        // Group by name and element type
+        for (const result of results) {
+            const key = `${result.entry.elementType}:${result.entry.name.toLowerCase()}`;
+            if (!nameMap.has(key)) {
+                nameMap.set(key, []);
+            }
+            nameMap.get(key).push(result);
+        }
+        const processedResults = [];
+        // Process each group
+        for (const [key, groupResults] of nameMap) {
+            if (groupResults.length === 1) {
+                // No duplicates
+                processedResults.push(groupResults[0]);
+            }
+            else {
+                // Has duplicates - detect version conflicts
+                const versionConflict = this.detectVersionConflictFromResults(groupResults);
+                // Mark all results as duplicates and add conflict info
+                for (const result of groupResults) {
+                    processedResults.push({
+                        ...result,
+                        isDuplicate: true,
+                        versionConflict
+                    });
+                }
+            }
+        }
+        return processedResults;
+    }
+    /**
+     * Apply pagination to results
+     */
+    applyPagination(results, options) {
+        const page = options.page || 1;
+        const pageSize = options.pageSize || 20;
+        const startIndex = (page - 1) * pageSize;
+        const endIndex = startIndex + pageSize;
+        return results.slice(startIndex, endIndex);
+    }
+    /**
+     * Apply sorting to results
+     */
+    applySorting(results, sortBy, query) {
+        const sorted = [...results];
+        switch (sortBy) {
+            case 'name':
+                sorted.sort((a, b) => a.entry.name.localeCompare(b.entry.name));
+                break;
+            case 'source':
+                sorted.sort((a, b) => {
+                    const sourceOrder = { 'local': 0, 'github': 1, 'collection': 2 };
+                    return sourceOrder[a.source] - sourceOrder[b.source];
+                });
+                break;
+            case 'version':
+                sorted.sort((a, b) => this.compareVersions(b.version || '0', a.version || '0'));
+                break;
+            case 'relevance':
+            default:
+                sorted.sort((a, b) => b.score - a.score);
+                break;
+        }
+        return sorted;
+    }
+    /**
+     * Calculate match score for GitHub entries
+     */
+    calculateGitHubMatchScore(entry, queryTokens, query) {
+        if (queryTokens.length === 0)
+            return 1; // Default score for empty query
+        let score = 0;
+        const name = entry.name.toLowerCase();
+        const description = (entry.description || '').toLowerCase();
+        const path = (entry.path || '').toLowerCase();
+        // Check name matches
+        for (const token of queryTokens) {
+            if (name.includes(token)) {
+                score += name === token ? 10 : (name.startsWith(token) ? 5 : 2);
+            }
+            if (description.includes(token)) {
+                score += 3;
+            }
+            if (path.includes(token)) {
+                score += 1;
+            }
+        }
+        // Exact query match bonus
+        if (name.includes(query.toLowerCase())) {
+            score += query.length > 3 ? 15 : 10;
+        }
+        return score;
+    }
+    /**
+     * Calculate match score for collection entries
+     */
+    calculateCollectionMatchScore(entry, queryTokens, query) {
+        if (queryTokens.length === 0)
+            return 1; // Default score for empty query
+        let score = 0;
+        const name = entry.name.toLowerCase();
+        const description = (entry.description || '').toLowerCase();
+        const path = (entry.path || '').toLowerCase();
+        const tags = entry.tags.map(tag => tag.toLowerCase()).join(' ');
+        // Check matches across all fields
+        for (const token of queryTokens) {
+            if (name.includes(token)) {
+                score += name === token ? 10 : (name.startsWith(token) ? 5 : 2);
+            }
+            if (description.includes(token)) {
+                score += 3;
+            }
+            if (path.includes(token)) {
+                score += 1;
+            }
+            if (tags.includes(token)) {
+                score += 4;
+            }
+        }
+        // Exact query match bonus
+        if (name.includes(query.toLowerCase())) {
+            score += query.length > 3 ? 15 : 10;
+        }
+        return score;
+    }
+    /**
+     * Get all elements by type across sources
+     */
+    async getAllElementsByType(elementType, options) {
+        const promises = [];
+        if (options.includeLocal) {
+            promises.push(this.getLocalElementsByType(elementType));
+        }
+        if (options.includeGitHub) {
+            promises.push(this.getGitHubElementsByType(elementType));
+        }
+        if (options.includeCollection) {
+            promises.push(this.getCollectionElementsByType(elementType));
+        }
+        const results = await Promise.allSettled(promises);
+        const allResults = [];
+        results.forEach(result => {
+            if (result.status === 'fulfilled') {
+                allResults.push(...result.value);
+            }
+        });
+        return allResults;
+    }
+    /**
+     * Get local elements by type
+     */
+    async getLocalElementsByType(elementType) {
+        try {
+            const elements = await this.localIndexManager.getElementsByType(elementType);
+            return elements.map(entry => ({
+                source: 'local',
+                entry: this.convertLocalEntry(entry),
+                matchType: 'type',
+                score: 1,
+                version: entry.metadata.version
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get GitHub elements by type
+     */
+    async getGitHubElementsByType(elementType) {
+        try {
+            const githubIndex = await this.githubIndexer.getIndex();
+            const entries = githubIndex.elements.get(elementType) || [];
+            return entries.map(entry => ({
+                source: 'github',
+                entry: this.convertGitHubEntry(entry),
+                matchType: 'type',
+                score: 1,
+                version: entry.version
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get collection elements by type
+     */
+    async getCollectionElementsByType(elementType) {
+        try {
+            const collectionIndex = await this.collectionIndexCache.getIndex();
+            const entries = collectionIndex.index[elementType.toString()] || [];
+            return entries.map(entry => ({
+                source: 'collection',
+                entry: this.convertCollectionEntry(entry, elementType.toString()),
+                matchType: 'type',
+                score: 1,
+                version: entry.version
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get local portfolio statistics
+     */
+    async getLocalStats() {
+        return await this.localIndexManager.getStats();
+    }
+    /**
+     * Get GitHub portfolio statistics
+     */
+    async getGitHubStats() {
+        const cacheStats = this.githubIndexer.getCacheStats();
+        const githubIndex = await this.githubIndexer.getIndex();
+        const elementsByType = {};
+        for (const elementType of Object.values(ElementType)) {
+            elementsByType[elementType] = (githubIndex.elements.get(elementType) || []).length;
+        }
+        return {
+            totalElements: githubIndex.totalElements,
+            elementsByType,
+            lastFetched: cacheStats.lastFetch,
+            isStale: cacheStats.isStale,
+            username: githubIndex.username,
+            repository: githubIndex.repository
+        };
+    }
+    /**
+     * Get collection portfolio statistics
+     */
+    async getCollectionStats() {
+        const cacheStats = this.collectionIndexCache.getCacheStats();
+        const collectionIndex = await this.collectionIndexCache.getIndex();
+        const elementsByType = {};
+        for (const [elementType, entries] of Object.entries(collectionIndex.index)) {
+            elementsByType[elementType] = entries.length;
+        }
+        return {
+            totalElements: collectionIndex.total_elements,
+            elementsByType,
+            lastFetched: cacheStats.hasCache ? new Date(Date.now() - cacheStats.age) : null,
+            isStale: !cacheStats.isValid,
+            version: collectionIndex.version
+        };
+    }
+    /**
+     * Calculate duplicates count across all sources
+     */
+    async calculateDuplicatesCount() {
+        try {
+            // This is a placeholder - actual implementation would need optimization
+            // For now, return 0 to avoid the expensive operation during stats calculation
+            return 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Convert local index entry to unified format
+     */
+    convertLocalEntry(entry) {
+        return {
+            name: entry.metadata.name,
+            description: entry.metadata.description,
+            version: entry.metadata.version,
+            author: entry.metadata.author,
+            elementType: entry.elementType,
+            lastModified: entry.lastModified,
+            source: 'local',
+            localFilePath: entry.filePath,
+            filename: entry.filename,
+            tags: entry.metadata.tags,
+            keywords: entry.metadata.keywords,
+            triggers: entry.metadata.triggers,
+            category: entry.metadata.category
+        };
+    }
+    /**
+     * Convert GitHub index entry to unified format
+     */
+    convertGitHubEntry(entry) {
+        return {
+            name: entry.name,
+            description: entry.description,
+            version: entry.version,
+            author: entry.author,
+            elementType: entry.elementType,
+            lastModified: entry.lastModified,
+            source: 'github',
+            githubPath: entry.path,
+            githubSha: entry.sha,
+            githubHtmlUrl: entry.htmlUrl,
+            githubDownloadUrl: entry.downloadUrl,
+            githubSize: entry.size
+        };
+    }
+    /**
+     * Convert collection index entry to unified format
+     */
+    convertCollectionEntry(entry, elementType) {
+        return {
+            name: entry.name,
+            description: entry.description,
+            version: entry.version,
+            author: entry.author,
+            elementType: this.mapStringToElementType(elementType),
+            lastModified: new Date(entry.created),
+            source: 'collection',
+            collectionPath: entry.path,
+            collectionSha: entry.sha,
+            collectionTags: entry.tags,
+            collectionCategory: entry.category,
+            collectionLicense: entry.license
+        };
+    }
+    /**
+     * Map string to ElementType enum
+     */
+    mapStringToElementType(elementType) {
+        // Handle mapping from collection element types to our ElementType enum
+        switch (elementType.toLowerCase()) {
+            case 'personas':
+                return ElementType.PERSONA;
+            case 'skills':
+                return ElementType.SKILL;
+            case 'agents':
+                return ElementType.AGENT;
+            case 'prompts':
+            case 'templates':
+                return ElementType.TEMPLATE; // Map prompts and templates to TEMPLATE
+            case 'tools':
+                return ElementType.SKILL; // Map tools to SKILL as fallback
+            case 'ensembles':
+                return ElementType.ENSEMBLE;
+            case 'memories':
+                return ElementType.MEMORY;
+            default:
+                return ElementType.SKILL; // Default fallback
+        }
+    }
+    /**
+     * Convert unified search options to local search options
+     */
+    convertToLocalOptions(options) {
+        return {
+            elementType: options.elementType,
+            maxResults: options.pageSize || 20
+        };
+    }
+    /**
+     * Determine match type for GitHub entries
+     */
+    determineMatchType(entry, queryTokens) {
+        const name = entry.name.toLowerCase();
+        const description = (entry.description || '').toLowerCase();
+        // Check what matched
+        for (const token of queryTokens) {
+            if (name.includes(token)) {
+                return name === token ? 'exact_name' : 'name';
+            }
+            if (description.includes(token)) {
+                return 'description';
+            }
+        }
+        return 'content';
+    }
+    /**
+     * Determine match type for collection entries
+     */
+    determineCollectionMatchType(entry, queryTokens) {
+        const name = entry.name.toLowerCase();
+        const description = (entry.description || '').toLowerCase();
+        const tags = entry.tags.map(tag => tag.toLowerCase()).join(' ');
+        // Check what matched
+        for (const token of queryTokens) {
+            if (name.includes(token)) {
+                return name === token ? 'exact_name' : 'name';
+            }
+            if (description.includes(token)) {
+                return 'description';
+            }
+            if (tags.includes(token)) {
+                return 'tag';
+            }
+        }
+        return 'content';
+    }
+    /**
+     * Get path from unified entry
+     */
+    getPathFromEntry(entry) {
+        switch (entry.source) {
+            case 'local':
+                return entry.localFilePath || entry.filename || 'unknown';
+            case 'github':
+                return entry.githubPath || 'unknown';
+            case 'collection':
+                return entry.collectionPath || 'unknown';
+            default:
+                return 'unknown';
+        }
+    }
+    /**
+     * Detect version conflict from sources
+     */
+    detectVersionConflict(sources) {
+        const versions = new Map();
+        for (const source of sources) {
+            if (source.version && source.version !== 'unknown') {
+                versions.set(source.version, source.source);
+            }
+        }
+        if (versions.size <= 1) {
+            return undefined; // No conflict if all versions are the same or missing
+        }
+        // Build version conflict info
+        const versionConflict = {
+            recommended: 'local',
+            reason: 'Multiple versions detected'
+        };
+        for (const source of sources) {
+            if (source.version) {
+                versionConflict[source.source] = source.version;
+            }
+        }
+        // Determine recommendation
+        const recommendation = this.determineVersionRecommendationFromSources(sources);
+        versionConflict.recommended = recommendation.source;
+        versionConflict.reason = recommendation.reason;
+        return versionConflict;
+    }
+    /**
+     * Detect version conflict from search results
+     */
+    detectVersionConflictFromResults(results) {
+        const sources = results.map(result => ({
+            source: result.source,
+            version: result.version,
+            lastModified: result.entry.lastModified,
+            path: this.getPathFromEntry(result.entry)
+        }));
+        return this.detectVersionConflict(sources);
+    }
+    /**
+     * Determine version recommendation from version info
+     */
+    determineVersionRecommendation(versions) {
+        // Prefer local if available and not too old
+        if (versions.local) {
+            const localAge = Date.now() - versions.local.lastModified.getTime();
+            const sevenDays = 7 * 24 * 60 * 60 * 1000;
+            if (localAge < sevenDays) {
+                return { source: 'local', reason: 'Local version is recent and authoritative' };
+            }
+        }
+        // Compare versions if available
+        const versionEntries = Object.entries(versions).filter(([_, info]) => info?.version);
+        if (versionEntries.length > 1) {
+            // Find highest version
+            let highest = {
+                source: 'local',
+                version: '0.0.0'
+            };
+            for (const [source, info] of versionEntries) {
+                if (info && this.compareVersions(info.version, highest.version) > 0) {
+                    highest = {
+                        source: source,
+                        version: info.version
+                    };
+                }
+            }
+            return { source: highest.source, reason: `Highest version (${highest.version})` };
+        }
+        // Fallback to most recent
+        let mostRecent = {
+            source: 'local',
+            date: new Date(0)
+        };
+        for (const [source, info] of Object.entries(versions)) {
+            if (info && info.lastModified > mostRecent.date) {
+                mostRecent = {
+                    source: source,
+                    date: info.lastModified
+                };
+            }
+        }
+        return { source: mostRecent.source, reason: 'Most recently modified' };
+    }
+    /**
+     * Determine version recommendation from sources
+     */
+    determineVersionRecommendationFromSources(sources) {
+        // Convert sources to versions format
+        const versions = {};
+        for (const source of sources) {
+            if (source.source === 'local') {
+                versions.local = {
+                    version: source.version || 'unknown',
+                    lastModified: source.lastModified,
+                    path: source.path || 'unknown'
+                };
+            }
+            else if (source.source === 'github') {
+                versions.github = {
+                    version: source.version || 'unknown',
+                    lastModified: source.lastModified,
+                    path: source.path || 'unknown'
+                };
+            }
+            else if (source.source === 'collection') {
+                versions.collection = {
+                    version: source.version || 'unknown',
+                    lastModified: source.lastModified,
+                    path: source.path || 'unknown'
+                };
+            }
+        }
+        return this.determineVersionRecommendation(versions);
+    }
+    /**
+     * Compare semantic versions
+     */
+    compareVersions(a, b) {
+        const parseVersion = (version) => {
+            const parts = version.split('.').map(part => parseInt(part) || 0);
+            return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
+        };
+        const [aMajor, aMinor, aPatch] = parseVersion(a);
+        const [bMajor, bMinor, bPatch] = parseVersion(b);
+        if (aMajor !== bMajor)
+            return aMajor - bMajor;
+        if (aMinor !== bMinor)
+            return aMinor - bMinor;
+        return aPatch - bPatch;
+    }
+    /**
+     * Remove duplicate results based on name and type
+     */
+    deduplicateResults(results) {
+        const seen = new Set();
+        const deduplicated = [];
+        for (const result of results) {
+            const key = `${result.entry.elementType}:${result.entry.name.toLowerCase()}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                deduplicated.push(result);
+            }
+        }
+        return deduplicated;
+    }
+    /**
+     * Remove duplicate entries based on name and type
+     */
+    deduplicateEntries(entries) {
+        const seen = new Set();
+        const deduplicated = [];
+        for (const entry of entries) {
+            const key = `${entry.elementType}:${entry.name.toLowerCase()}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                deduplicated.push(entry);
+            }
+        }
+        return deduplicated;
+    }
+    // =====================================================
+    // PERFORMANCE MONITORING AND OPTIMIZATION
+    // =====================================================
+    /**
+     * Stream search results for better performance with large datasets
+     */
+    async streamSearch(options) {
+        const { query, cursor, maxResults = 1000 } = options;
+        const startTime = Date.now();
+        logger.debug('Starting streaming search', { query: query.substring(0, 50), cursor, maxResults });
+        const results = [];
+        const sources = this.getEnabledSources(options);
+        // Process sources in sequence for memory efficiency
+        for (const source of sources) {
+            if (results.length >= maxResults) {
+                break;
+            }
+            try {
+                const sourceResults = await this.searchWithFallback(source, query, {
+                    ...options,
+                    pageSize: Math.min(this.BATCH_SIZE, maxResults - results.length)
+                });
+                results.push(...sourceResults);
+                // Add cursor information for pagination
+                sourceResults.forEach((result, index) => {
+                    result.cursor = this.generateCursor(source, index);
+                });
+            }
+            catch (error) {
+                logger.warn(`Streaming search failed for source ${source}`, {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        logger.debug('Streaming search completed', {
+            resultCount: results.length,
+            duration: `${Date.now() - startTime}ms`
+        });
+        return results;
+    }
+    /**
+     * Process search results with memory-efficient batching
+     */
+    async processSearchResultsOptimized(results, options) {
+        if (results.length === 0) {
+            return results;
+        }
+        // Process in batches to avoid memory spikes with large result sets
+        const batchSize = Math.min(this.BATCH_SIZE, results.length);
+        const processedResults = [];
+        for (let i = 0; i < results.length; i += batchSize) {
+            const batch = results.slice(i, i + batchSize);
+            // Apply smart ranking
+            const rankedBatch = this.applySmartRanking(batch, options);
+            // Detect duplicates and conflicts
+            const processedBatch = await this.detectDuplicatesAndConflicts(rankedBatch);
+            processedResults.push(...processedBatch);
+            // Yield control to prevent blocking
+            if (i % (batchSize * 4) === 0) {
+                await new Promise(resolve => setImmediate(resolve));
+            }
+        }
+        // Apply final sorting
+        return this.applySorting(processedResults, options.sortBy || 'relevance', options.query);
+    }
+    /**
+     * Get enabled search sources
+     */
+    getEnabledSources(options) {
+        const sources = [];
+        if (options.includeLocal !== false)
+            sources.push('local');
+        if (options.includeGitHub !== false)
+            sources.push('github');
+        if (options.includeCollection === true)
+            sources.push('collection');
+        return sources;
+    }
+    /**
+     * Batch sources for concurrent processing
+     */
+    batchSources(sources, batchSize) {
+        const batches = [];
+        for (let i = 0; i < sources.length; i += batchSize) {
+            batches.push(sources.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+    /**
+     * Generate cursor for pagination
+     */
+    generateCursor(source, index) {
+        const timestamp = Date.now();
+        return Buffer.from(`${source}:${index}:${timestamp}`).toString('base64');
+    }
+    /**
+     * Trigger memory cleanup when usage is high
+     */
+    triggerMemoryCleanup() {
+        // Force cache cleanup
+        this.resultCache.cleanup();
+        this.indexCache.cleanup();
+        // Suggest garbage collection
+        if (global.gc) {
+            global.gc();
+            logger.debug('Triggered garbage collection');
+        }
+    }
+    /**
+     * Record search performance metrics
+     */
+    recordSearchMetrics(metrics) {
+        this.performanceMonitor.recordSearch(metrics);
+        // Update cache performance metrics
+        const cacheStats = this.resultCache.getStats();
+        this.performanceMonitor.recordCachePerformance('searchResults', {
+            hitRate: cacheStats.hitRate,
+            avgHitTime: 1, // Placeholder
+            avgMissTime: 5, // Placeholder
+            totalHits: cacheStats.hitCount,
+            totalMisses: cacheStats.missCount,
+            evictions: cacheStats.evictionCount
+        });
+    }
+    /**
+     * Create cache key for search options
+     */
+    createCacheKey(options) {
+        return JSON.stringify({
+            query: options.query,
+            includeLocal: options.includeLocal,
+            includeGitHub: options.includeGitHub,
+            includeCollection: options.includeCollection,
+            elementType: options.elementType,
+            page: options.page,
+            pageSize: options.pageSize,
+            sortBy: options.sortBy,
+            lazyLoad: options.lazyLoad
+        });
+    }
+    /**
+     * Get performance statistics
+     */
+    getPerformanceStats() {
+        return {
+            searchStats: this.performanceMonitor.getSearchStats(),
+            memoryStats: this.performanceMonitor.getMemoryStats(),
+            cacheStats: {
+                searchResults: this.resultCache.getStats(),
+                indexCache: this.indexCache.getStats()
+            },
+            trends: this.performanceMonitor.analyzeTrends()
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UnifiedIndexManager.js","sourceRoot":"","sources":["../../src/portfolio/UnifiedIndexManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Index Manager - Combines local, GitHub, and collection portfolio indexing\n * \n * Features:\n * - Unified search across local, GitHub, and collection portfolios\n * - Intelligent result merging and deduplication\n * - Version conflict detection and resolution\n * - Performance optimization with parallel indexing\n * - Advanced fallback strategies for resilient operation\n * - Comprehensive search capabilities with pagination\n * - Smart result ranking and duplicate detection\n */\n\nimport { PortfolioIndexManager, IndexEntry, SearchResult, SearchOptions } from './PortfolioIndexManager.js';\nimport { GitHubPortfolioIndexer, GitHubIndexEntry, GitHubPortfolioIndex } from './GitHubPortfolioIndexer.js';\nimport { CollectionIndexCache } from '../cache/CollectionIndexCache.js';\nimport { GitHubClient } from '../collection/GitHubClient.js';\nimport { APICache } from '../cache/APICache.js';\nimport { ElementType } from './types.js';\nimport { logger } from '../utils/logger.js';\nimport { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';\nimport { LRUCache, CacheFactory } from '../cache/LRUCache.js';\nimport { PerformanceMonitor, SearchMetrics } from '../utils/PerformanceMonitor.js';\nimport { IndexEntry as CollectionIndexEntry, CollectionIndex } from '../types/collection.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport interface UnifiedSearchOptions {\n  query: string;\n  includeLocal?: boolean;     // default true\n  includeGitHub?: boolean;    // default true\n  includeCollection?: boolean; // default false\n  elementType?: ElementType;\n  page?: number;\n  pageSize?: number;\n  sortBy?: 'relevance' | 'source' | 'name' | 'version';\n  streamResults?: boolean; // Enable result streaming\n  cursor?: string; // For pagination cursor\n  maxResults?: number; // Hard limit on results\n  lazyLoad?: boolean; // Enable lazy loading\n}\n\nexport interface VersionConflict {\n  local?: string;\n  github?: string;\n  collection?: string;\n  recommended: 'local' | 'github' | 'collection';\n  reason: string;\n}\n\nexport interface DuplicateInfo {\n  name: string;\n  elementType: ElementType;\n  sources: Array<{\n    source: 'local' | 'github' | 'collection';\n    version?: string;\n    lastModified: Date;\n    path?: string;\n  }>;\n  hasVersionConflict: boolean;\n  versionConflict?: VersionConflict;\n}\n\nexport interface VersionInfo {\n  name: string;\n  elementType: ElementType;\n  versions: {\n    local?: { version: string; lastModified: Date; path: string };\n    github?: { version: string; lastModified: Date; path: string };\n    collection?: { version: string; lastModified: Date; path: string };\n  };\n  recommended: {\n    source: 'local' | 'github' | 'collection';\n    reason: string;\n  };\n  updateAvailable: boolean;\n  updateFrom?: 'local' | 'github' | 'collection';\n}\n\nexport interface UnifiedIndexEntry {\n  // Common properties\n  name: string;\n  description?: string;\n  version?: string;\n  author?: string;\n  elementType: ElementType;\n  lastModified: Date;\n  \n  // Source information\n  source: 'local' | 'github' | 'collection';\n  \n  // Local properties (when source === 'local')\n  localFilePath?: string;\n  filename?: string;\n  tags?: string[];\n  keywords?: string[];\n  triggers?: string[];\n  category?: string;\n  \n  // GitHub properties (when source === 'github')\n  githubPath?: string;\n  githubSha?: string;\n  githubHtmlUrl?: string;\n  githubDownloadUrl?: string;\n  githubSize?: number;\n  \n  // Collection properties (when source === 'collection')\n  collectionPath?: string;\n  collectionSha?: string;\n  collectionTags?: string[];\n  collectionCategory?: string;\n  collectionLicense?: string;\n}\n\nexport interface UnifiedSearchResult {\n  source: 'local' | 'github' | 'collection';\n  entry: UnifiedIndexEntry;\n  matchType: string;\n  score: number;\n  version?: string;\n  isDuplicate?: boolean;\n  versionConflict?: VersionConflict;\n  cursor?: string; // For streaming pagination\n}\n\nexport interface StreamedSearchResult {\n  results: UnifiedSearchResult[];\n  hasMore: boolean;\n  nextCursor?: string;\n  totalEstimate?: number;\n  processingTimeMs: number;\n}\n\nexport interface UnifiedIndexStats {\n  local: {\n    totalElements: number;\n    elementsByType: Record<ElementType, number>;\n    lastBuilt: Date | null;\n    isStale: boolean;\n  };\n  github: {\n    totalElements: number;\n    elementsByType: Record<ElementType, number>;\n    lastFetched: Date | null;\n    isStale: boolean;\n    username?: string;\n    repository?: string;\n  };\n  collection: {\n    totalElements: number;\n    elementsByType: Record<string, number>;\n    lastFetched: Date | null;\n    isStale: boolean;\n    version?: string;\n  };\n  combined: {\n    totalElements: number;\n    uniqueElements: number;\n    duplicates: number;\n  };\n  performance: {\n    averageSearchTime: number;\n    cacheHitRate: number;\n    lastOptimized: Date | null;\n  };\n}\n\nexport class UnifiedIndexManager {\n  private static instance: UnifiedIndexManager | null = null;\n  \n  private localIndexManager: PortfolioIndexManager;\n  private githubIndexer: GitHubPortfolioIndexer;\n  private collectionIndexCache: CollectionIndexCache;\n  private githubClient: GitHubClient;\n  \n  // Performance monitoring and caching\n  private performanceMonitor: PerformanceMonitor;\n  private resultCache: LRUCache<UnifiedSearchResult[]>;\n  private indexCache: LRUCache<any>;\n  private readonly BATCH_SIZE = 50; // For streaming results\n  private readonly MAX_CONCURRENT_SOURCES = 3;\n  \n  private constructor() {\n    this.localIndexManager = PortfolioIndexManager.getInstance();\n    this.githubIndexer = GitHubPortfolioIndexer.getInstance();\n    \n    // Initialize GitHubClient with required dependencies\n    const apiCache = new APICache();\n    const rateLimitTracker = new Map<string, number[]>();\n    this.githubClient = new GitHubClient(apiCache, rateLimitTracker);\n    this.collectionIndexCache = new CollectionIndexCache(this.githubClient);\n    \n    // Initialize performance monitoring and caching\n    this.performanceMonitor = PerformanceMonitor.getInstance();\n    this.performanceMonitor.startMonitoring();\n    \n    this.resultCache = CacheFactory.createSearchResultCache({\n      maxSize: 200,\n      maxMemoryMB: 15,\n      ttlMs: 5 * 60 * 1000, // 5 minutes\n      onEviction: (key, value) => {\n        logger.debug('Search result cache eviction', { key, resultCount: value.length });\n      }\n    });\n    \n    this.indexCache = CacheFactory.createIndexCache({\n      maxSize: 100,\n      maxMemoryMB: 20,\n      ttlMs: 15 * 60 * 1000, // 15 minutes\n      onEviction: (key, value) => {\n        logger.debug('Index cache eviction', { key });\n      }\n    });\n    \n    logger.debug('UnifiedIndexManager created with performance optimization');\n  }\n\n  public static getInstance(): UnifiedIndexManager {\n    if (!this.instance) {\n      this.instance = new UnifiedIndexManager();\n    }\n    return this.instance;\n  }\n\n  /**\n   * Enhanced search across local, GitHub, and collection portfolios with performance optimization\n   */\n  public async search(searchOptions: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    const startTime = Date.now();\n    const memoryBefore = process.memoryUsage().heapUsed;\n    const { query, includeLocal = true, includeGitHub = true, includeCollection = false } = searchOptions;\n    \n    // Normalize query to prevent Unicode-based attacks\n    const validationResult = UnicodeValidator.normalize(query);\n    const normalizedQuery = validationResult.normalizedContent;\n    \n    // Use normalized query in all subsequent operations\n    const normalizedSearchOptions = {\n      ...searchOptions,\n      query: normalizedQuery\n    };\n    \n    // SECURITY FIX (DMCP-SEC-006): Add audit logging for security monitoring\n    // Log unified search operations for security audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'PORTFOLIO_FETCH_SUCCESS',\n      severity: 'LOW',\n      source: 'UnifiedIndexManager.search',\n      details: `Unified search performed with query length: ${normalizedQuery.length}, sources: ${JSON.stringify({\n        local: includeLocal,\n        github: includeGitHub,\n        collection: includeCollection\n      })}`\n    });\n    \n    logger.debug('Starting optimized unified portfolio search', normalizedSearchOptions);\n    \n    // Check cache first (use normalized search options)\n    const cacheKey = this.createCacheKey(normalizedSearchOptions);\n    const cached = this.resultCache.get(cacheKey);\n    if (cached) {\n      const duration = Date.now() - startTime;\n      this.recordSearchMetrics({\n        query: normalizedQuery,\n        duration,\n        resultCount: cached.length,\n        sources: this.getEnabledSources(normalizedSearchOptions),\n        cacheHit: true,\n        memoryBefore,\n        memoryAfter: process.memoryUsage().heapUsed,\n        timestamp: new Date()\n      });\n      logger.debug('Using cached search results', { resultCount: cached.length });\n      return cached;\n    }\n    \n    try {\n      // Use streaming search for better performance with large result sets\n      if (normalizedSearchOptions.streamResults) {\n        return await this.streamSearch(normalizedSearchOptions);\n      }\n      \n      // Lazy loading: Only load indices when needed\n      const searchPromises: Promise<UnifiedSearchResult[]>[] = [];\n      const enabledSources = this.getEnabledSources(normalizedSearchOptions);\n      \n      // Limit concurrent source searches for memory efficiency\n      const concurrentLimit = Math.min(this.MAX_CONCURRENT_SOURCES, enabledSources.length);\n      const sourceBatches = this.batchSources(enabledSources, concurrentLimit);\n      \n      const allResults: UnifiedSearchResult[] = [];\n      const sourceCount = { local: 0, github: 0, collection: 0 };\n      \n      // Process sources in batches to control memory usage\n      for (const batch of sourceBatches) {\n        const batchPromises = batch.map(source => \n          this.searchWithFallback(source as 'local' | 'github' | 'collection', normalizedQuery, normalizedSearchOptions)\n        );\n        \n        const batchResults = await Promise.allSettled(batchPromises);\n        \n        batchResults.forEach((result, index) => {\n          const sourceName = batch[index] as 'local' | 'github' | 'collection';\n          if (result.status === 'fulfilled') {\n            sourceCount[sourceName] += result.value.length;\n            allResults.push(...result.value);\n          } else {\n            logger.warn(`Search failed for source ${sourceName}`, {\n              error: result.reason instanceof Error ? result.reason.message : String(result.reason)\n            });\n          }\n        });\n        \n        // Memory check between batches\n        const currentMemory = process.memoryUsage().heapUsed / (1024 * 1024);\n        if (currentMemory > 200) { // 200MB threshold\n          logger.warn('High memory usage during search, triggering cleanup', {\n            memoryMB: currentMemory\n          });\n          this.triggerMemoryCleanup();\n        }\n      }\n      \n      // Apply advanced processing with memory-efficient batching\n      const processedResults = await this.processSearchResultsOptimized(allResults, normalizedSearchOptions);\n      \n      // Apply pagination\n      const paginatedResults = this.applyPagination(processedResults, normalizedSearchOptions);\n      \n      // Cache results with memory limit check\n      if (paginatedResults.length < 1000) { // Don't cache very large result sets\n        this.resultCache.set(cacheKey, paginatedResults);\n      }\n      \n      const duration = Date.now() - startTime;\n      const memoryAfter = process.memoryUsage().heapUsed;\n      \n      this.recordSearchMetrics({\n        query: normalizedQuery,\n        duration,\n        resultCount: paginatedResults.length,\n        sources: enabledSources,\n        cacheHit: false,\n        memoryBefore,\n        memoryAfter,\n        timestamp: new Date()\n      });\n      \n      logger.info('Optimized unified portfolio search completed', {\n        query: normalizedQuery.substring(0, 50),\n        sources: { ...sourceCount, total: allResults.length },\n        finalResults: paginatedResults.length,\n        duration: `${duration}ms`,\n        memoryUsageMB: (memoryAfter - memoryBefore) / (1024 * 1024)\n      });\n      \n      return paginatedResults;\n      \n    } catch (error) {\n      const duration = Date.now() - startTime;\n      ErrorHandler.logError('UnifiedIndexManager.search', error, { query: normalizedSearchOptions, duration });\n      throw ErrorHandler.wrapError(error, 'Failed to perform unified portfolio search', ErrorCategory.SYSTEM_ERROR);\n    }\n  }\n\n  /**\n   * Find element by name across all portfolios\n   */\n  public async findByName(name: string, options: Partial<UnifiedSearchOptions> = {}): Promise<UnifiedIndexEntry | null> {\n    try {\n      const searchOptions: UnifiedSearchOptions = {\n        query: name,\n        includeLocal: options.includeLocal ?? true,\n        includeGitHub: options.includeGitHub ?? true,\n        includeCollection: options.includeCollection ?? false,\n        pageSize: 1,\n        ...options\n      };\n      \n      const results = await this.search(searchOptions);\n      \n      // Return exact name match first, then best match\n      const exactMatch = results.find(result => \n        result.entry.name.toLowerCase() === name.toLowerCase()\n      );\n      \n      return exactMatch?.entry || results[0]?.entry || null;\n      \n    } catch (error) {\n      ErrorHandler.logError('UnifiedIndexManager.findByName', error, { name });\n      return null;\n    }\n  }\n\n  /**\n   * Get elements by type from all portfolios\n   */\n  public async getElementsByType(elementType: ElementType, options: Partial<UnifiedSearchOptions> = {}): Promise<UnifiedIndexEntry[]> {\n    try {\n      const searchOptions: UnifiedSearchOptions = {\n        query: '', // Empty query to get all elements\n        elementType,\n        includeLocal: options.includeLocal ?? true,\n        includeGitHub: options.includeGitHub ?? true,\n        includeCollection: options.includeCollection ?? false,\n        pageSize: 1000, // Large page size to get all\n        ...options\n      };\n      \n      const results = await this.getAllElementsByType(elementType, searchOptions);\n      \n      return this.deduplicateEntries(results.map(r => r.entry));\n      \n    } catch (error) {\n      ErrorHandler.logError('UnifiedIndexManager.getElementsByType', error, { elementType });\n      return [];\n    }\n  }\n  \n  /**\n   * Check for duplicates across all sources\n   */\n  public async checkDuplicates(name: string): Promise<DuplicateInfo[]> {\n    try {\n      const searchOptions: UnifiedSearchOptions = {\n        query: name,\n        includeLocal: true,\n        includeGitHub: true,\n        includeCollection: true,\n        pageSize: 100\n      };\n      \n      const results = await this.search(searchOptions);\n      const duplicateMap = new Map<string, DuplicateInfo>();\n      \n      for (const result of results) {\n        const key = `${result.entry.elementType}:${result.entry.name.toLowerCase()}`;\n        \n        if (!duplicateMap.has(key)) {\n          duplicateMap.set(key, {\n            name: result.entry.name,\n            elementType: result.entry.elementType,\n            sources: [],\n            hasVersionConflict: false\n          });\n        }\n        \n        const duplicate = duplicateMap.get(key)!;\n        duplicate.sources.push({\n          source: result.source,\n          version: result.entry.version,\n          lastModified: result.entry.lastModified,\n          path: this.getPathFromEntry(result.entry)\n        });\n      }\n      \n      // Filter to only items with multiple sources and check version conflicts\n      const actualDuplicates = Array.from(duplicateMap.values())\n        .filter(item => item.sources.length > 1)\n        .map(item => {\n          const versionConflict = this.detectVersionConflict(item.sources);\n          return {\n            ...item,\n            hasVersionConflict: !!versionConflict,\n            versionConflict\n          };\n        });\n      \n      return actualDuplicates;\n      \n    } catch (error) {\n      ErrorHandler.logError('UnifiedIndexManager.checkDuplicates', error, { name });\n      return [];\n    }\n  }\n  \n  /**\n   * Get version comparison across all sources\n   */\n  public async getVersionComparison(name: string): Promise<VersionInfo | null> {\n    try {\n      const duplicates = await this.checkDuplicates(name);\n      \n      if (duplicates.length === 0) {\n        return null;\n      }\n      \n      const duplicate = duplicates[0];\n      const versions: VersionInfo['versions'] = {};\n      \n      // Build version info\n      for (const source of duplicate.sources) {\n        if (source.source === 'local') {\n          versions.local = {\n            version: source.version || 'unknown',\n            lastModified: source.lastModified,\n            path: source.path || 'unknown'\n          };\n        } else if (source.source === 'github') {\n          versions.github = {\n            version: source.version || 'unknown',\n            lastModified: source.lastModified,\n            path: source.path || 'unknown'\n          };\n        } else if (source.source === 'collection') {\n          versions.collection = {\n            version: source.version || 'unknown',\n            lastModified: source.lastModified,\n            path: source.path || 'unknown'\n          };\n        }\n      }\n      \n      // Determine recommendation\n      const recommendation = this.determineVersionRecommendation(versions);\n      \n      return {\n        name: duplicate.name,\n        elementType: duplicate.elementType,\n        versions,\n        recommended: recommendation,\n        updateAvailable: recommendation.source !== 'local' && !!versions.local,\n        updateFrom: recommendation.source !== 'local' ? recommendation.source : undefined\n      };\n      \n    } catch (error) {\n      ErrorHandler.logError('UnifiedIndexManager.getVersionComparison', error, { name });\n      return null;\n    }\n  }\n\n  /**\n   * Get comprehensive statistics across all sources\n   */\n  public async getStats(): Promise<UnifiedIndexStats> {\n    try {\n      const [localStats, githubStats, collectionStats] = await Promise.allSettled([\n        this.getLocalStats(),\n        this.getGitHubStats(),\n        this.getCollectionStats()\n      ]);\n      \n      const local = localStats.status === 'fulfilled' ? localStats.value : {\n        totalElements: 0,\n        elementsByType: {} as Record<ElementType, number>,\n        lastBuilt: null,\n        isStale: true\n      };\n      \n      const github = githubStats.status === 'fulfilled' ? githubStats.value : {\n        totalElements: 0,\n        elementsByType: {} as Record<ElementType, number>,\n        lastFetched: null,\n        isStale: true\n      };\n      \n      const collection = collectionStats.status === 'fulfilled' ? collectionStats.value : {\n        totalElements: 0,\n        elementsByType: {} as Record<string, number>,\n        lastFetched: null,\n        isStale: true\n      };\n      \n      // Calculate combined statistics\n      const totalElements = local.totalElements + github.totalElements + collection.totalElements;\n      const duplicatesCount = await this.calculateDuplicatesCount();\n      const uniqueElements = totalElements - duplicatesCount;\n      \n      return {\n        local,\n        github,\n        collection,\n        combined: {\n          totalElements,\n          uniqueElements,\n          duplicates: duplicatesCount\n        },\n        performance: {\n          averageSearchTime: this.getPerformanceStats().searchStats.averageTime || 0,\n          cacheHitRate: this.getPerformanceStats().searchStats.cacheHitRate || 0,\n          lastOptimized: null\n        }\n      };\n      \n    } catch (error) {\n      ErrorHandler.logError('UnifiedIndexManager.getStats', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Invalidate caches after user actions with performance monitoring\n   */\n  public invalidateAfterAction(action: string): void {\n    logger.info('Invalidating unified portfolio caches after user action', { action });\n    \n    // Clear result and index caches\n    this.resultCache.clear();\n    this.indexCache.clear();\n    \n    // Invalidate local cache\n    this.localIndexManager.rebuildIndex().catch(error => {\n      logger.warn('Failed to rebuild local index after action', {\n        action,\n        error: error instanceof Error ? error.message : String(error)\n      });\n    });\n    \n    // Invalidate GitHub cache\n    this.githubIndexer.invalidateAfterAction(action);\n    \n    // Invalidate collection cache\n    this.collectionIndexCache.clearCache().catch(error => {\n      logger.warn('Failed to clear collection cache after action', {\n        action,\n        error: error instanceof Error ? error.message : String(error)\n      });\n    });\n    \n    // Trigger garbage collection if memory usage is high\n    this.triggerMemoryCleanup();\n  }\n\n  /**\n   * Force rebuild of all indexes with performance optimization\n   */\n  public async rebuildAll(): Promise<void> {\n    const startTime = Date.now();\n    logger.info('Rebuilding all portfolio indexes with optimization...');\n    \n    try {\n      // Clear all caches\n      this.resultCache.clear();\n      this.indexCache.clear();\n      \n      // Reset performance counters\n      this.performanceMonitor.reset();\n      \n      // Rebuild in parallel with memory monitoring\n      const rebuildPromises = [\n        this.localIndexManager.rebuildIndex(),\n        this.githubIndexer.clearCache(),\n        this.collectionIndexCache.clearCache()\n      ];\n      \n      await Promise.all(rebuildPromises);\n      \n      // Trigger cleanup\n      this.triggerMemoryCleanup();\n      \n      const duration = Date.now() - startTime;\n      logger.info('All portfolio indexes rebuilt successfully', {\n        duration: `${duration}ms`,\n        memoryUsageMB: process.memoryUsage().heapUsed / (1024 * 1024)\n      });\n    } catch (error) {\n      ErrorHandler.logError('UnifiedIndexManager.rebuildAll', error);\n      throw error;\n    }\n  }\n\n  // =====================================================\n  // PRIVATE HELPER METHODS\n  // =====================================================\n  \n  /**\n   * Search with fallback strategies for resilient operation\n   */\n  private async searchWithFallback(source: 'local' | 'github' | 'collection', query: string, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    const startTime = Date.now();\n    \n    try {\n      let results: UnifiedSearchResult[] = [];\n      \n      switch (source) {\n        case 'local':\n          results = await this.searchLocal(query, options);\n          break;\n        case 'github':\n          results = await this.searchGitHub(query, options);\n          break;\n        case 'collection':\n          results = await this.searchCollection(query, options);\n          break;\n      }\n      \n      logger.debug(`${source} search completed in ${Date.now() - startTime}ms with ${results.length} results`);\n      return results;\n      \n    } catch (error) {\n      logger.debug(`${source} search failed, attempting fallback`, {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      \n      // Fallback strategies\n      return await this.handleSearchFallback(source, query, options, error);\n    }\n  }\n  \n  /**\n   * Handle search fallback strategies\n   */\n  private async handleSearchFallback(source: 'local' | 'github' | 'collection', query: string, options: UnifiedSearchOptions, originalError: any): Promise<UnifiedSearchResult[]> {\n    try {\n      switch (source) {\n        case 'local':\n          // Try to use stale local index\n          logger.debug('Attempting to use stale local index');\n          return await this.searchLocalStale(query, options);\n          \n        case 'github':\n          // Try cached GitHub data\n          logger.debug('Attempting to use cached GitHub data');\n          return await this.searchGitHubCached(query, options);\n          \n        case 'collection':\n          // Try cached collection data\n          logger.debug('Attempting to use cached collection data');\n          return await this.searchCollectionCached(query, options);\n          \n        default:\n          return [];\n      }\n    } catch (fallbackError) {\n      logger.warn(`All fallback strategies failed for ${source}`, {\n        originalError: originalError instanceof Error ? originalError.message : String(originalError),\n        fallbackError: fallbackError instanceof Error ? fallbackError.message : String(fallbackError)\n      });\n      return [];\n    }\n  }\n  \n  /**\n   * Search local portfolio\n   */\n  private async searchLocal(query: string, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    const localOptions = this.convertToLocalOptions(options);\n    const results = await this.localIndexManager.search(query, localOptions);\n    \n    return results.map(result => ({\n      source: 'local' as const,\n      entry: this.convertLocalEntry(result.entry),\n      matchType: result.matchType,\n      score: result.score,\n      version: result.entry.metadata.version\n    }));\n  }\n  \n  /**\n   * Search local with stale data fallback\n   */\n  private async searchLocalStale(query: string, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    try {\n      // Try to get any local data, even stale\n      const localOptions = this.convertToLocalOptions(options);\n      const results = await this.localIndexManager.search(query, localOptions);\n      \n      return results.map(result => ({\n        source: 'local' as const,\n        entry: this.convertLocalEntry(result.entry),\n        matchType: result.matchType,\n        score: result.score * 0.8, // Reduce score for stale data\n        version: result.entry.metadata.version\n      }));\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Search GitHub portfolio\n   */\n  private async searchGitHub(query: string, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    try {\n      const githubIndex = await this.githubIndexer.getIndex();\n      const results: UnifiedSearchResult[] = [];\n      \n      const queryLower = query.toLowerCase();\n      const queryTokens = queryLower.split(/\\s+/).filter(token => token.length > 0);\n      \n      if (queryTokens.length === 0 && query.trim() !== '') {\n        return results;\n      }\n      \n      // Search across all GitHub elements\n      for (const [elementType, entries] of githubIndex.elements) {\n        // Filter by element type if specified\n        if (options.elementType && elementType !== options.elementType) {\n          continue;\n        }\n        \n        for (const entry of entries) {\n          const score = this.calculateGitHubMatchScore(entry, queryTokens, query);\n          if (score > 0 || query.trim() === '') {\n            results.push({\n              source: 'github' as const,\n              entry: this.convertGitHubEntry(entry),\n              matchType: this.determineMatchType(entry, queryTokens),\n              score: query.trim() === '' ? 1 : score, // Default score for empty query\n              version: entry.version\n            });\n          }\n        }\n      }\n      \n      return results.sort((a, b) => b.score - a.score);\n      \n    } catch (error) {\n      logger.debug('GitHub search failed', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      throw error; // Re-throw to trigger fallback\n    }\n  }\n  \n  /**\n   * Search GitHub with cached data fallback\n   */\n  private async searchGitHubCached(query: string, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    try {\n      // Try to use stale GitHub data\n      const cacheStats = this.githubIndexer.getCacheStats();\n      if (!cacheStats.isStale) {\n        return await this.searchGitHub(query, options);\n      }\n      \n      // Use stale data with reduced scores\n      const results = await this.searchGitHub(query, options);\n      return results.map(result => ({\n        ...result,\n        score: result.score * 0.7 // Reduce score for stale data\n      }));\n      \n    } catch {\n      return [];\n    }\n  }\n  \n  /**\n   * Search collection portfolio\n   */\n  private async searchCollection(query: string, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    try {\n      const collectionIndex = await this.collectionIndexCache.getIndex();\n      const results: UnifiedSearchResult[] = [];\n      \n      const queryLower = query.toLowerCase();\n      const queryTokens = queryLower.split(/\\s+/).filter(token => token.length > 0);\n      \n      if (queryTokens.length === 0 && query.trim() !== '') {\n        return results;\n      }\n      \n      // Search across all collection elements\n      for (const [elementType, entries] of Object.entries(collectionIndex.index)) {\n        // Filter by element type if specified\n        if (options.elementType && elementType !== options.elementType.toString()) {\n          continue;\n        }\n        \n        for (const entry of entries) {\n          const score = this.calculateCollectionMatchScore(entry, queryTokens, query);\n          if (score > 0 || query.trim() === '') {\n            results.push({\n              source: 'collection' as const,\n              entry: this.convertCollectionEntry(entry, elementType),\n              matchType: this.determineCollectionMatchType(entry, queryTokens),\n              score: query.trim() === '' ? 1 : score, // Default score for empty query\n              version: entry.version\n            });\n          }\n        }\n      }\n      \n      return results.sort((a, b) => b.score - a.score);\n      \n    } catch (error) {\n      logger.debug('Collection search failed', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      throw error; // Re-throw to trigger fallback\n    }\n  }\n  \n  /**\n   * Search collection with cached data fallback\n   */\n  private async searchCollectionCached(query: string, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    try {\n      // Try to use stale collection data\n      const cacheStats = this.collectionIndexCache.getCacheStats();\n      if (cacheStats.isValid) {\n        return await this.searchCollection(query, options);\n      }\n      \n      // Use stale data with reduced scores\n      const results = await this.searchCollection(query, options);\n      return results.map(result => ({\n        ...result,\n        score: result.score * 0.6 // Reduce score for stale collection data\n      }));\n      \n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Process search results with advanced features\n   */\n  private async processSearchResults(results: UnifiedSearchResult[], options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    // Apply smart ranking\n    const rankedResults = this.applySmartRanking(results, options);\n    \n    // Detect duplicates and version conflicts\n    const processedResults = await this.detectDuplicatesAndConflicts(rankedResults);\n    \n    // Apply sorting\n    const sortedResults = this.applySorting(processedResults, options.sortBy || 'relevance', options.query);\n    \n    return sortedResults;\n  }\n  \n  /**\n   * Apply smart result ranking\n   */\n  private applySmartRanking(results: UnifiedSearchResult[], options: UnifiedSearchOptions): UnifiedSearchResult[] {\n    return results.map(result => {\n      let adjustedScore = result.score;\n      \n      // No location-based scoring - score should be based on relevance only\n      // Source location doesn't affect the intrinsic value of an element\n      \n      // Consider version freshness (newer versions get small bonus)\n      if (result.version && result.version !== 'unknown') {\n        const versionParts = result.version.split('.');\n        if (versionParts.length >= 2) {\n          const major = parseInt(versionParts[0]) || 0;\n          const minor = parseInt(versionParts[1]) || 0;\n          adjustedScore += (major * 0.1) + (minor * 0.01);\n        }\n      }\n      \n      // Boost exact matches\n      if (result.entry.name.toLowerCase() === options.query.toLowerCase()) {\n        adjustedScore *= 2.0;\n      }\n      \n      return {\n        ...result,\n        score: adjustedScore\n      };\n    });\n  }\n  \n  /**\n   * Detect duplicates and version conflicts\n   */\n  private async detectDuplicatesAndConflicts(results: UnifiedSearchResult[]): Promise<UnifiedSearchResult[]> {\n    const nameMap = new Map<string, UnifiedSearchResult[]>();\n    \n    // Group by name and element type\n    for (const result of results) {\n      const key = `${result.entry.elementType}:${result.entry.name.toLowerCase()}`;\n      if (!nameMap.has(key)) {\n        nameMap.set(key, []);\n      }\n      nameMap.get(key)!.push(result);\n    }\n    \n    const processedResults: UnifiedSearchResult[] = [];\n    \n    // Process each group\n    for (const [key, groupResults] of nameMap) {\n      if (groupResults.length === 1) {\n        // No duplicates\n        processedResults.push(groupResults[0]);\n      } else {\n        // Has duplicates - detect version conflicts\n        const versionConflict = this.detectVersionConflictFromResults(groupResults);\n        \n        // Mark all results as duplicates and add conflict info\n        for (const result of groupResults) {\n          processedResults.push({\n            ...result,\n            isDuplicate: true,\n            versionConflict\n          });\n        }\n      }\n    }\n    \n    return processedResults;\n  }\n  \n  /**\n   * Apply pagination to results\n   */\n  private applyPagination(results: UnifiedSearchResult[], options: UnifiedSearchOptions): UnifiedSearchResult[] {\n    const page = options.page || 1;\n    const pageSize = options.pageSize || 20;\n    const startIndex = (page - 1) * pageSize;\n    const endIndex = startIndex + pageSize;\n    \n    return results.slice(startIndex, endIndex);\n  }\n  \n  /**\n   * Apply sorting to results\n   */\n  private applySorting(results: UnifiedSearchResult[], sortBy: 'relevance' | 'source' | 'name' | 'version', query: string): UnifiedSearchResult[] {\n    const sorted = [...results];\n    \n    switch (sortBy) {\n      case 'name':\n        sorted.sort((a, b) => a.entry.name.localeCompare(b.entry.name));\n        break;\n      case 'source':\n        sorted.sort((a, b) => {\n          const sourceOrder = { 'local': 0, 'github': 1, 'collection': 2 };\n          return sourceOrder[a.source] - sourceOrder[b.source];\n        });\n        break;\n      case 'version':\n        sorted.sort((a, b) => this.compareVersions(b.version || '0', a.version || '0'));\n        break;\n      case 'relevance':\n      default:\n        sorted.sort((a, b) => b.score - a.score);\n        break;\n    }\n    \n    return sorted;\n  }\n  \n  /**\n   * Calculate match score for GitHub entries\n   */\n  private calculateGitHubMatchScore(entry: GitHubIndexEntry, queryTokens: string[], query: string): number {\n    if (queryTokens.length === 0) return 1; // Default score for empty query\n    \n    let score = 0;\n    \n    const name = entry.name.toLowerCase();\n    const description = (entry.description || '').toLowerCase();\n    const path = (entry.path || '').toLowerCase();\n    \n    // Check name matches\n    for (const token of queryTokens) {\n      if (name.includes(token)) {\n        score += name === token ? 10 : (name.startsWith(token) ? 5 : 2);\n      }\n      if (description.includes(token)) {\n        score += 3;\n      }\n      if (path.includes(token)) {\n        score += 1;\n      }\n    }\n    \n    // Exact query match bonus\n    if (name.includes(query.toLowerCase())) {\n      score += query.length > 3 ? 15 : 10;\n    }\n    \n    return score;\n  }\n  \n  /**\n   * Calculate match score for collection entries\n   */\n  private calculateCollectionMatchScore(entry: CollectionIndexEntry, queryTokens: string[], query: string): number {\n    if (queryTokens.length === 0) return 1; // Default score for empty query\n    \n    let score = 0;\n    \n    const name = entry.name.toLowerCase();\n    const description = (entry.description || '').toLowerCase();\n    const path = (entry.path || '').toLowerCase();\n    const tags = entry.tags.map(tag => tag.toLowerCase()).join(' ');\n    \n    // Check matches across all fields\n    for (const token of queryTokens) {\n      if (name.includes(token)) {\n        score += name === token ? 10 : (name.startsWith(token) ? 5 : 2);\n      }\n      if (description.includes(token)) {\n        score += 3;\n      }\n      if (path.includes(token)) {\n        score += 1;\n      }\n      if (tags.includes(token)) {\n        score += 4;\n      }\n    }\n    \n    // Exact query match bonus\n    if (name.includes(query.toLowerCase())) {\n      score += query.length > 3 ? 15 : 10;\n    }\n    \n    return score;\n  }\n\n  /**\n   * Get all elements by type across sources\n   */\n  private async getAllElementsByType(elementType: ElementType, options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    const promises: Promise<UnifiedSearchResult[]>[] = [];\n    \n    if (options.includeLocal) {\n      promises.push(this.getLocalElementsByType(elementType));\n    }\n    if (options.includeGitHub) {\n      promises.push(this.getGitHubElementsByType(elementType));\n    }\n    if (options.includeCollection) {\n      promises.push(this.getCollectionElementsByType(elementType));\n    }\n    \n    const results = await Promise.allSettled(promises);\n    const allResults: UnifiedSearchResult[] = [];\n    \n    results.forEach(result => {\n      if (result.status === 'fulfilled') {\n        allResults.push(...result.value);\n      }\n    });\n    \n    return allResults;\n  }\n  \n  /**\n   * Get local elements by type\n   */\n  private async getLocalElementsByType(elementType: ElementType): Promise<UnifiedSearchResult[]> {\n    try {\n      const elements = await this.localIndexManager.getElementsByType(elementType);\n      return elements.map(entry => ({\n        source: 'local' as const,\n        entry: this.convertLocalEntry(entry),\n        matchType: 'type',\n        score: 1,\n        version: entry.metadata.version\n      }));\n    } catch {\n      return [];\n    }\n  }\n  \n  /**\n   * Get GitHub elements by type\n   */\n  private async getGitHubElementsByType(elementType: ElementType): Promise<UnifiedSearchResult[]> {\n    try {\n      const githubIndex = await this.githubIndexer.getIndex();\n      const entries = githubIndex.elements.get(elementType) || [];\n      \n      return entries.map(entry => ({\n        source: 'github' as const,\n        entry: this.convertGitHubEntry(entry),\n        matchType: 'type',\n        score: 1,\n        version: entry.version\n      }));\n    } catch {\n      return [];\n    }\n  }\n  \n  /**\n   * Get collection elements by type\n   */\n  private async getCollectionElementsByType(elementType: ElementType): Promise<UnifiedSearchResult[]> {\n    try {\n      const collectionIndex = await this.collectionIndexCache.getIndex();\n      const entries = collectionIndex.index[elementType.toString()] || [];\n      \n      return entries.map(entry => ({\n        source: 'collection' as const,\n        entry: this.convertCollectionEntry(entry, elementType.toString()),\n        matchType: 'type',\n        score: 1,\n        version: entry.version\n      }));\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Get local portfolio statistics\n   */\n  private async getLocalStats(): Promise<UnifiedIndexStats['local']> {\n    return await this.localIndexManager.getStats();\n  }\n  \n  /**\n   * Get GitHub portfolio statistics\n   */\n  private async getGitHubStats(): Promise<UnifiedIndexStats['github']> {\n    const cacheStats = this.githubIndexer.getCacheStats();\n    const githubIndex = await this.githubIndexer.getIndex();\n    \n    const elementsByType: Record<ElementType, number> = {} as Record<ElementType, number>;\n    for (const elementType of Object.values(ElementType)) {\n      elementsByType[elementType] = (githubIndex.elements.get(elementType) || []).length;\n    }\n    \n    return {\n      totalElements: githubIndex.totalElements,\n      elementsByType,\n      lastFetched: cacheStats.lastFetch,\n      isStale: cacheStats.isStale,\n      username: githubIndex.username,\n      repository: githubIndex.repository\n    };\n  }\n  \n  /**\n   * Get collection portfolio statistics\n   */\n  private async getCollectionStats(): Promise<UnifiedIndexStats['collection']> {\n    const cacheStats = this.collectionIndexCache.getCacheStats();\n    const collectionIndex = await this.collectionIndexCache.getIndex();\n    \n    const elementsByType: Record<string, number> = {};\n    for (const [elementType, entries] of Object.entries(collectionIndex.index)) {\n      elementsByType[elementType] = entries.length;\n    }\n    \n    return {\n      totalElements: collectionIndex.total_elements,\n      elementsByType,\n      lastFetched: cacheStats.hasCache ? new Date(Date.now() - cacheStats.age) : null,\n      isStale: !cacheStats.isValid,\n      version: collectionIndex.version\n    };\n  }\n  \n  /**\n   * Calculate duplicates count across all sources\n   */\n  private async calculateDuplicatesCount(): Promise<number> {\n    try {\n      // This is a placeholder - actual implementation would need optimization\n      // For now, return 0 to avoid the expensive operation during stats calculation\n      return 0;\n    } catch {\n      return 0;\n    }\n  }\n\n  /**\n   * Convert local index entry to unified format\n   */\n  private convertLocalEntry(entry: IndexEntry): UnifiedIndexEntry {\n    return {\n      name: entry.metadata.name,\n      description: entry.metadata.description,\n      version: entry.metadata.version,\n      author: entry.metadata.author,\n      elementType: entry.elementType,\n      lastModified: entry.lastModified,\n      source: 'local',\n      localFilePath: entry.filePath,\n      filename: entry.filename,\n      tags: entry.metadata.tags,\n      keywords: entry.metadata.keywords,\n      triggers: entry.metadata.triggers,\n      category: entry.metadata.category\n    };\n  }\n\n  /**\n   * Convert GitHub index entry to unified format\n   */\n  private convertGitHubEntry(entry: GitHubIndexEntry): UnifiedIndexEntry {\n    return {\n      name: entry.name,\n      description: entry.description,\n      version: entry.version,\n      author: entry.author,\n      elementType: entry.elementType,\n      lastModified: entry.lastModified,\n      source: 'github',\n      githubPath: entry.path,\n      githubSha: entry.sha,\n      githubHtmlUrl: entry.htmlUrl,\n      githubDownloadUrl: entry.downloadUrl,\n      githubSize: entry.size\n    };\n  }\n  \n  /**\n   * Convert collection index entry to unified format\n   */\n  private convertCollectionEntry(entry: CollectionIndexEntry, elementType: string): UnifiedIndexEntry {\n    return {\n      name: entry.name,\n      description: entry.description,\n      version: entry.version,\n      author: entry.author,\n      elementType: this.mapStringToElementType(elementType),\n      lastModified: new Date(entry.created),\n      source: 'collection',\n      collectionPath: entry.path,\n      collectionSha: entry.sha,\n      collectionTags: entry.tags,\n      collectionCategory: entry.category,\n      collectionLicense: entry.license\n    };\n  }\n  \n  /**\n   * Map string to ElementType enum\n   */\n  private mapStringToElementType(elementType: string): ElementType {\n    // Handle mapping from collection element types to our ElementType enum\n    switch (elementType.toLowerCase()) {\n      case 'personas':\n        return ElementType.PERSONA;\n      case 'skills':\n        return ElementType.SKILL;\n      case 'agents':\n        return ElementType.AGENT;\n      case 'prompts':\n      case 'templates':\n        return ElementType.TEMPLATE; // Map prompts and templates to TEMPLATE\n      case 'tools':\n        return ElementType.SKILL; // Map tools to SKILL as fallback\n      case 'ensembles':\n        return ElementType.ENSEMBLE;\n      case 'memories':\n        return ElementType.MEMORY;\n      default:\n        return ElementType.SKILL; // Default fallback\n    }\n  }\n  \n  /**\n   * Convert unified search options to local search options\n   */\n  private convertToLocalOptions(options: UnifiedSearchOptions): SearchOptions {\n    return {\n      elementType: options.elementType,\n      maxResults: options.pageSize || 20\n    };\n  }\n  \n  /**\n   * Determine match type for GitHub entries\n   */\n  private determineMatchType(entry: GitHubIndexEntry, queryTokens: string[]): string {\n    const name = entry.name.toLowerCase();\n    const description = (entry.description || '').toLowerCase();\n    \n    // Check what matched\n    for (const token of queryTokens) {\n      if (name.includes(token)) {\n        return name === token ? 'exact_name' : 'name';\n      }\n      if (description.includes(token)) {\n        return 'description';\n      }\n    }\n    \n    return 'content';\n  }\n  \n  /**\n   * Determine match type for collection entries\n   */\n  private determineCollectionMatchType(entry: CollectionIndexEntry, queryTokens: string[]): string {\n    const name = entry.name.toLowerCase();\n    const description = (entry.description || '').toLowerCase();\n    const tags = entry.tags.map(tag => tag.toLowerCase()).join(' ');\n    \n    // Check what matched\n    for (const token of queryTokens) {\n      if (name.includes(token)) {\n        return name === token ? 'exact_name' : 'name';\n      }\n      if (description.includes(token)) {\n        return 'description';\n      }\n      if (tags.includes(token)) {\n        return 'tag';\n      }\n    }\n    \n    return 'content';\n  }\n  \n  /**\n   * Get path from unified entry\n   */\n  private getPathFromEntry(entry: UnifiedIndexEntry): string {\n    switch (entry.source) {\n      case 'local':\n        return entry.localFilePath || entry.filename || 'unknown';\n      case 'github':\n        return entry.githubPath || 'unknown';\n      case 'collection':\n        return entry.collectionPath || 'unknown';\n      default:\n        return 'unknown';\n    }\n  }\n  \n  /**\n   * Detect version conflict from sources\n   */\n  private detectVersionConflict(sources: DuplicateInfo['sources']): VersionConflict | undefined {\n    const versions = new Map<string, 'local' | 'github' | 'collection'>();\n    \n    for (const source of sources) {\n      if (source.version && source.version !== 'unknown') {\n        versions.set(source.version, source.source);\n      }\n    }\n    \n    if (versions.size <= 1) {\n      return undefined; // No conflict if all versions are the same or missing\n    }\n    \n    // Build version conflict info\n    const versionConflict: VersionConflict = {\n      recommended: 'local',\n      reason: 'Multiple versions detected'\n    };\n    \n    for (const source of sources) {\n      if (source.version) {\n        versionConflict[source.source] = source.version;\n      }\n    }\n    \n    // Determine recommendation\n    const recommendation = this.determineVersionRecommendationFromSources(sources);\n    versionConflict.recommended = recommendation.source;\n    versionConflict.reason = recommendation.reason;\n    \n    return versionConflict;\n  }\n  \n  /**\n   * Detect version conflict from search results\n   */\n  private detectVersionConflictFromResults(results: UnifiedSearchResult[]): VersionConflict | undefined {\n    const sources = results.map(result => ({\n      source: result.source,\n      version: result.version,\n      lastModified: result.entry.lastModified,\n      path: this.getPathFromEntry(result.entry)\n    }));\n    \n    return this.detectVersionConflict(sources);\n  }\n  \n  /**\n   * Determine version recommendation from version info\n   */\n  private determineVersionRecommendation(versions: VersionInfo['versions']): { source: 'local' | 'github' | 'collection'; reason: string } {\n    // Prefer local if available and not too old\n    if (versions.local) {\n      const localAge = Date.now() - versions.local.lastModified.getTime();\n      const sevenDays = 7 * 24 * 60 * 60 * 1000;\n      \n      if (localAge < sevenDays) {\n        return { source: 'local', reason: 'Local version is recent and authoritative' };\n      }\n    }\n    \n    // Compare versions if available\n    const versionEntries = Object.entries(versions).filter(([_, info]) => info?.version);\n    \n    if (versionEntries.length > 1) {\n      // Find highest version\n      let highest: { source: 'local' | 'github' | 'collection'; version: string } = {\n        source: 'local',\n        version: '0.0.0'\n      };\n      \n      for (const [source, info] of versionEntries) {\n        if (info && this.compareVersions(info.version, highest.version) > 0) {\n          highest = {\n            source: source as 'local' | 'github' | 'collection',\n            version: info.version\n          };\n        }\n      }\n      \n      return { source: highest.source, reason: `Highest version (${highest.version})` };\n    }\n    \n    // Fallback to most recent\n    let mostRecent: { source: 'local' | 'github' | 'collection'; date: Date } = {\n      source: 'local',\n      date: new Date(0)\n    };\n    \n    for (const [source, info] of Object.entries(versions)) {\n      if (info && info.lastModified > mostRecent.date) {\n        mostRecent = {\n          source: source as 'local' | 'github' | 'collection',\n          date: info.lastModified\n        };\n      }\n    }\n    \n    return { source: mostRecent.source, reason: 'Most recently modified' };\n  }\n  \n  /**\n   * Determine version recommendation from sources\n   */\n  private determineVersionRecommendationFromSources(sources: DuplicateInfo['sources']): { source: 'local' | 'github' | 'collection'; reason: string } {\n    // Convert sources to versions format\n    const versions: VersionInfo['versions'] = {};\n    \n    for (const source of sources) {\n      if (source.source === 'local') {\n        versions.local = {\n          version: source.version || 'unknown',\n          lastModified: source.lastModified,\n          path: source.path || 'unknown'\n        };\n      } else if (source.source === 'github') {\n        versions.github = {\n          version: source.version || 'unknown',\n          lastModified: source.lastModified,\n          path: source.path || 'unknown'\n        };\n      } else if (source.source === 'collection') {\n        versions.collection = {\n          version: source.version || 'unknown',\n          lastModified: source.lastModified,\n          path: source.path || 'unknown'\n        };\n      }\n    }\n    \n    return this.determineVersionRecommendation(versions);\n  }\n  \n  /**\n   * Compare semantic versions\n   */\n  private compareVersions(a: string, b: string): number {\n    const parseVersion = (version: string) => {\n      const parts = version.split('.').map(part => parseInt(part) || 0);\n      return [parts[0] || 0, parts[1] || 0, parts[2] || 0];\n    };\n    \n    const [aMajor, aMinor, aPatch] = parseVersion(a);\n    const [bMajor, bMinor, bPatch] = parseVersion(b);\n    \n    if (aMajor !== bMajor) return aMajor - bMajor;\n    if (aMinor !== bMinor) return aMinor - bMinor;\n    return aPatch - bPatch;\n  }\n\n  /**\n   * Remove duplicate results based on name and type\n   */\n  private deduplicateResults(results: UnifiedSearchResult[]): UnifiedSearchResult[] {\n    const seen = new Set<string>();\n    const deduplicated: UnifiedSearchResult[] = [];\n    \n    for (const result of results) {\n      const key = `${result.entry.elementType}:${result.entry.name.toLowerCase()}`;\n      if (!seen.has(key)) {\n        seen.add(key);\n        deduplicated.push(result);\n      }\n    }\n    \n    return deduplicated;\n  }\n\n  /**\n   * Remove duplicate entries based on name and type\n   */\n  private deduplicateEntries(entries: UnifiedIndexEntry[]): UnifiedIndexEntry[] {\n    const seen = new Set<string>();\n    const deduplicated: UnifiedIndexEntry[] = [];\n    \n    for (const entry of entries) {\n      const key = `${entry.elementType}:${entry.name.toLowerCase()}`;\n      if (!seen.has(key)) {\n        seen.add(key);\n        deduplicated.push(entry);\n      }\n    }\n    \n    return deduplicated;\n  }\n  \n  // =====================================================\n  // PERFORMANCE MONITORING AND OPTIMIZATION\n  // =====================================================\n  \n  /**\n   * Stream search results for better performance with large datasets\n   */\n  private async streamSearch(options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    const { query, cursor, maxResults = 1000 } = options;\n    const startTime = Date.now();\n    \n    logger.debug('Starting streaming search', { query: query.substring(0, 50), cursor, maxResults });\n    \n    const results: UnifiedSearchResult[] = [];\n    const sources = this.getEnabledSources(options);\n    \n    // Process sources in sequence for memory efficiency\n    for (const source of sources) {\n      if (results.length >= maxResults) {\n        break;\n      }\n      \n      try {\n        const sourceResults = await this.searchWithFallback(source, query, {\n          ...options,\n          pageSize: Math.min(this.BATCH_SIZE, maxResults - results.length)\n        });\n        \n        results.push(...sourceResults);\n        \n        // Add cursor information for pagination\n        sourceResults.forEach((result, index) => {\n          result.cursor = this.generateCursor(source, index);\n        });\n        \n      } catch (error) {\n        logger.warn(`Streaming search failed for source ${source}`, {\n          error: error instanceof Error ? error.message : String(error)\n        });\n      }\n    }\n    \n    logger.debug('Streaming search completed', {\n      resultCount: results.length,\n      duration: `${Date.now() - startTime}ms`\n    });\n    \n    return results;\n  }\n  \n  /**\n   * Process search results with memory-efficient batching\n   */\n  private async processSearchResultsOptimized(results: UnifiedSearchResult[], options: UnifiedSearchOptions): Promise<UnifiedSearchResult[]> {\n    if (results.length === 0) {\n      return results;\n    }\n    \n    // Process in batches to avoid memory spikes with large result sets\n    const batchSize = Math.min(this.BATCH_SIZE, results.length);\n    const processedResults: UnifiedSearchResult[] = [];\n    \n    for (let i = 0; i < results.length; i += batchSize) {\n      const batch = results.slice(i, i + batchSize);\n      \n      // Apply smart ranking\n      const rankedBatch = this.applySmartRanking(batch, options);\n      \n      // Detect duplicates and conflicts\n      const processedBatch = await this.detectDuplicatesAndConflicts(rankedBatch);\n      \n      processedResults.push(...processedBatch);\n      \n      // Yield control to prevent blocking\n      if (i % (batchSize * 4) === 0) {\n        await new Promise(resolve => setImmediate(resolve));\n      }\n    }\n    \n    // Apply final sorting\n    return this.applySorting(processedResults, options.sortBy || 'relevance', options.query);\n  }\n  \n  /**\n   * Get enabled search sources\n   */\n  private getEnabledSources(options: UnifiedSearchOptions): ('local' | 'github' | 'collection')[] {\n    const sources: ('local' | 'github' | 'collection')[] = [];\n    \n    if (options.includeLocal !== false) sources.push('local');\n    if (options.includeGitHub !== false) sources.push('github');\n    if (options.includeCollection === true) sources.push('collection');\n    \n    return sources;\n  }\n  \n  /**\n   * Batch sources for concurrent processing\n   */\n  private batchSources(sources: ('local' | 'github' | 'collection')[], batchSize: number): ('local' | 'github' | 'collection')[][] {\n    const batches: ('local' | 'github' | 'collection')[][] = [];\n    \n    for (let i = 0; i < sources.length; i += batchSize) {\n      batches.push(sources.slice(i, i + batchSize));\n    }\n    \n    return batches;\n  }\n  \n  /**\n   * Generate cursor for pagination\n   */\n  private generateCursor(source: string, index: number): string {\n    const timestamp = Date.now();\n    return Buffer.from(`${source}:${index}:${timestamp}`).toString('base64');\n  }\n  \n  /**\n   * Trigger memory cleanup when usage is high\n   */\n  private triggerMemoryCleanup(): void {\n    // Force cache cleanup\n    this.resultCache.cleanup();\n    this.indexCache.cleanup();\n    \n    // Suggest garbage collection\n    if (global.gc) {\n      global.gc();\n      logger.debug('Triggered garbage collection');\n    }\n  }\n  \n  /**\n   * Record search performance metrics\n   */\n  private recordSearchMetrics(metrics: SearchMetrics): void {\n    this.performanceMonitor.recordSearch(metrics);\n    \n    // Update cache performance metrics\n    const cacheStats = this.resultCache.getStats();\n    this.performanceMonitor.recordCachePerformance('searchResults', {\n      hitRate: cacheStats.hitRate,\n      avgHitTime: 1, // Placeholder\n      avgMissTime: 5, // Placeholder\n      totalHits: cacheStats.hitCount,\n      totalMisses: cacheStats.missCount,\n      evictions: cacheStats.evictionCount\n    });\n  }\n  \n  /**\n   * Create cache key for search options\n   */\n  private createCacheKey(options: UnifiedSearchOptions): string {\n    return JSON.stringify({\n      query: options.query,\n      includeLocal: options.includeLocal,\n      includeGitHub: options.includeGitHub,\n      includeCollection: options.includeCollection,\n      elementType: options.elementType,\n      page: options.page,\n      pageSize: options.pageSize,\n      sortBy: options.sortBy,\n      lazyLoad: options.lazyLoad\n    });\n  }\n  \n  /**\n   * Get performance statistics\n   */\n  public getPerformanceStats(): {\n    searchStats: any;\n    memoryStats: any;\n    cacheStats: any;\n    trends: any;\n  } {\n    return {\n      searchStats: this.performanceMonitor.getSearchStats(),\n      memoryStats: this.performanceMonitor.getMemoryStats(),\n      cacheStats: {\n        searchResults: this.resultCache.getStats(),\n        indexCache: this.indexCache.getStats()\n      },\n      trends: this.performanceMonitor.analyzeTrends()\n    };\n  }\n}"]}