@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/benchmarks/IndexPerformanceBenchmark.js

@@ -0,0 +1,531 @@
+/**
+ * Comprehensive Performance Benchmarking Suite for DollhouseMCP Indexing System
+ *
+ * Benchmarks:
+ * - Search response times under various loads
+ * - Memory usage patterns with large datasets
+ * - Cache performance and hit rates
+ * - Concurrent operation performance
+ * - Index building and rebuilding times
+ */
+import { UnifiedIndexManager } from '../portfolio/UnifiedIndexManager.js';
+import { PortfolioIndexManager } from '../portfolio/PortfolioIndexManager.js';
+import { PerformanceMonitor } from '../utils/PerformanceMonitor.js';
+import { logger } from '../utils/logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+export class IndexPerformanceBenchmark {
+    unifiedIndexManager;
+    performanceMonitor;
+    benchmarkResults = [];
+    constructor() {
+        this.unifiedIndexManager = UnifiedIndexManager.getInstance();
+        this.performanceMonitor = PerformanceMonitor.getInstance();
+    }
+    /**
+     * Run comprehensive performance benchmark suite
+     */
+    async runFullBenchmarkSuite() {
+        logger.info('Starting comprehensive performance benchmark suite');
+        const suiteStartTime = Date.now();
+        // Clear caches and reset state
+        await this.resetBenchmarkEnvironment();
+        const benchmarks = [
+            () => this.benchmarkSearchPerformance(),
+            () => this.benchmarkMemoryUsage(),
+            () => this.benchmarkCachePerformance(),
+            () => this.benchmarkConcurrentOperations(),
+            () => this.benchmarkLargeDatasetHandling(),
+            () => this.benchmarkIndexBuilding(),
+            () => this.benchmarkStreamingSearch(),
+            () => this.benchmarkLazyLoading()
+        ];
+        // Run each benchmark
+        for (const benchmark of benchmarks) {
+            try {
+                const result = await benchmark();
+                this.benchmarkResults.push(result);
+                // Allow garbage collection between benchmarks
+                await this.waitForGC();
+            }
+            catch (error) {
+                logger.error('Benchmark failed', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        const suite = {
+            name: 'DollhouseMCP Index Performance Suite',
+            results: this.benchmarkResults,
+            summary: this.generateSummary(Date.now() - suiteStartTime)
+        };
+        logger.info('Benchmark suite completed', {
+            totalBenchmarks: suite.results.length,
+            totalDuration: suite.summary.totalDuration,
+            recommendations: suite.summary.recommendations.length
+        });
+        return suite;
+    }
+    /**
+     * Benchmark search performance with various query patterns
+     */
+    async benchmarkSearchPerformance() {
+        const testQueries = [
+            'creative',
+            'professional assistant',
+            'development tools',
+            'data analysis',
+            'machine learning expert',
+            'a very long and complex query that might stress the search system with multiple terms and complex patterns',
+            'specific_exact_match',
+            '' // Empty query test
+        ];
+        const memoryBefore = process.memoryUsage().heapUsed;
+        let peakMemory = memoryBefore;
+        const startTime = Date.now();
+        let totalOperations = 0;
+        let cacheHits = 0;
+        for (const query of testQueries) {
+            for (let i = 0; i < 10; i++) { // 10 iterations per query
+                const options = {
+                    query,
+                    includeLocal: true,
+                    includeGitHub: true,
+                    includeCollection: false,
+                    pageSize: 20
+                };
+                await this.unifiedIndexManager.search(options);
+                totalOperations++;
+                // Track peak memory
+                const currentMemory = process.memoryUsage().heapUsed;
+                if (currentMemory > peakMemory) {
+                    peakMemory = currentMemory;
+                }
+            }
+        }
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        const duration = endTime - startTime;
+        const performanceStats = this.unifiedIndexManager.getPerformanceStats();
+        const searchStats = performanceStats.searchStats;
+        return {
+            name: 'Search Performance',
+            duration,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: peakMemory / (1024 * 1024)
+            },
+            throughput: totalOperations / (duration / 1000),
+            cacheStats: {
+                hitRate: searchStats.cacheHitRate || 0,
+                totalOperations
+            },
+            metadata: {
+                avgSearchTime: searchStats.averageTime || 0,
+                p95SearchTime: searchStats.p95Time || 0,
+                slowQueries: searchStats.slowQueries || 0
+            }
+        };
+    }
+    /**
+     * Benchmark memory usage with large result sets
+     */
+    async benchmarkMemoryUsage() {
+        const memoryBefore = process.memoryUsage().heapUsed;
+        let peakMemory = memoryBefore;
+        const startTime = Date.now();
+        // Create increasingly large search operations
+        const largeBatches = [100, 500, 1000, 2000];
+        for (const batchSize of largeBatches) {
+            const options = {
+                query: '', // Empty query to get all results
+                includeLocal: true,
+                includeGitHub: true,
+                includeCollection: true,
+                pageSize: batchSize,
+                maxResults: batchSize
+            };
+            await this.unifiedIndexManager.search(options);
+            const currentMemory = process.memoryUsage().heapUsed;
+            if (currentMemory > peakMemory) {
+                peakMemory = currentMemory;
+            }
+            // Check for memory leaks
+            if (currentMemory > memoryBefore * 2) {
+                logger.warn('Potential memory leak detected', {
+                    beforeMB: memoryBefore / (1024 * 1024),
+                    currentMB: currentMemory / (1024 * 1024),
+                    batchSize
+                });
+            }
+        }
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        return {
+            name: 'Memory Usage',
+            duration: endTime - startTime,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: peakMemory / (1024 * 1024)
+            },
+            metadata: {
+                memoryGrowthMB: (memoryAfter - memoryBefore) / (1024 * 1024),
+                peakGrowthMB: (peakMemory - memoryBefore) / (1024 * 1024),
+                testedBatchSizes: largeBatches
+            }
+        };
+    }
+    /**
+     * Benchmark cache performance and hit rates
+     */
+    async benchmarkCachePerformance() {
+        const memoryBefore = process.memoryUsage().heapUsed;
+        const startTime = Date.now();
+        // Test cache warming and hit rate optimization
+        const rawQueries = ['test', 'performance', 'benchmark', 'cache'];
+        // DMCP-SEC-004 FIX: Normalize Unicode in all user input
+        const testQueries = rawQueries.map(q => {
+            const normalized = UnicodeValidator.normalize(q);
+            return normalized.isValid ? normalized.normalizedContent : q;
+        });
+        let totalOperations = 0;
+        let cacheHitsBefore = 0;
+        // First pass - cache misses expected
+        for (const query of testQueries) {
+            for (let i = 0; i < 5; i++) {
+                await this.unifiedIndexManager.search({ query, pageSize: 10 });
+                totalOperations++;
+            }
+        }
+        const statsAfterFirstPass = this.unifiedIndexManager.getPerformanceStats();
+        cacheHitsBefore = statsAfterFirstPass.cacheStats.searchResults.hitCount;
+        // Second pass - cache hits expected
+        for (const query of testQueries) {
+            for (let i = 0; i < 5; i++) {
+                await this.unifiedIndexManager.search({ query, pageSize: 10 });
+                totalOperations++;
+            }
+        }
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        const finalStats = this.unifiedIndexManager.getPerformanceStats();
+        const cacheStats = finalStats.cacheStats.searchResults;
+        return {
+            name: 'Cache Performance',
+            duration: endTime - startTime,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: memoryAfter / (1024 * 1024)
+            },
+            cacheStats: {
+                hitRate: cacheStats.hitRate,
+                totalOperations
+            },
+            metadata: {
+                cacheSize: cacheStats.size,
+                evictions: cacheStats.evictionCount,
+                hitRateImprovement: cacheStats.hitRate
+            }
+        };
+    }
+    /**
+     * Benchmark concurrent search operations
+     */
+    async benchmarkConcurrentOperations() {
+        const memoryBefore = process.memoryUsage().heapUsed;
+        let peakMemory = memoryBefore;
+        const startTime = Date.now();
+        const concurrencyLevels = [5, 10, 20, 50];
+        let totalOperations = 0;
+        for (const concurrency of concurrencyLevels) {
+            const promises = [];
+            for (let i = 0; i < concurrency; i++) {
+                const searchPromise = this.unifiedIndexManager.search({
+                    query: `concurrent_test_${i}`,
+                    pageSize: 20
+                });
+                promises.push(searchPromise);
+                totalOperations++;
+            }
+            await Promise.all(promises);
+            const currentMemory = process.memoryUsage().heapUsed;
+            if (currentMemory > peakMemory) {
+                peakMemory = currentMemory;
+            }
+        }
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        const duration = endTime - startTime;
+        return {
+            name: 'Concurrent Operations',
+            duration,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: peakMemory / (1024 * 1024)
+            },
+            throughput: totalOperations / (duration / 1000),
+            metadata: {
+                testedConcurrencyLevels: concurrencyLevels,
+                totalConcurrentOps: totalOperations
+            }
+        };
+    }
+    /**
+     * Benchmark large dataset handling (simulated)
+     */
+    async benchmarkLargeDatasetHandling() {
+        const memoryBefore = process.memoryUsage().heapUsed;
+        let peakMemory = memoryBefore;
+        const startTime = Date.now();
+        // Simulate searches that would stress a large dataset
+        const stressTestQueries = [
+            { query: '', pageSize: 1000 }, // Get all results
+            { query: 'common_term', pageSize: 500 }, // High result count
+            { query: 'very_specific_unique_term', pageSize: 100 }, // Low result count
+            { query: 'partial_match_test', pageSize: 200 } // Medium result count
+        ];
+        let totalResults = 0;
+        for (const testCase of stressTestQueries) {
+            const results = await this.unifiedIndexManager.search({
+                query: testCase.query,
+                pageSize: testCase.pageSize,
+                includeLocal: true,
+                includeGitHub: true,
+                includeCollection: true
+            });
+            totalResults += results.length;
+            const currentMemory = process.memoryUsage().heapUsed;
+            if (currentMemory > peakMemory) {
+                peakMemory = currentMemory;
+            }
+        }
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        return {
+            name: 'Large Dataset Handling',
+            duration: endTime - startTime,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: peakMemory / (1024 * 1024)
+            },
+            metadata: {
+                totalResultsProcessed: totalResults,
+                averageResultsPerQuery: totalResults / stressTestQueries.length,
+                memoryPerResult: (peakMemory - memoryBefore) / totalResults
+            }
+        };
+    }
+    /**
+     * Benchmark index building performance
+     */
+    async benchmarkIndexBuilding() {
+        const memoryBefore = process.memoryUsage().heapUsed;
+        const startTime = Date.now();
+        // Force rebuild of all indexes
+        await this.unifiedIndexManager.rebuildAll();
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        const localStats = await PortfolioIndexManager.getInstance().getStats();
+        return {
+            name: 'Index Building',
+            duration: endTime - startTime,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: memoryAfter / (1024 * 1024)
+            },
+            metadata: {
+                totalElementsIndexed: localStats.totalElements,
+                indexingRate: localStats.totalElements / ((endTime - startTime) / 1000),
+                isStale: localStats.isStale
+            }
+        };
+    }
+    /**
+     * Benchmark streaming search performance
+     */
+    async benchmarkStreamingSearch() {
+        const memoryBefore = process.memoryUsage().heapUsed;
+        let peakMemory = memoryBefore;
+        const startTime = Date.now();
+        const streamingQueries = [
+            { query: 'test', maxResults: 100 },
+            { query: 'assistant', maxResults: 200 },
+            { query: 'creative', maxResults: 150 }
+        ];
+        let totalResults = 0;
+        for (const testCase of streamingQueries) {
+            const results = await this.unifiedIndexManager.search({
+                query: testCase.query,
+                streamResults: true,
+                maxResults: testCase.maxResults,
+                includeLocal: true,
+                includeGitHub: true
+            });
+            totalResults += results.length;
+            const currentMemory = process.memoryUsage().heapUsed;
+            if (currentMemory > peakMemory) {
+                peakMemory = currentMemory;
+            }
+        }
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        return {
+            name: 'Streaming Search',
+            duration: endTime - startTime,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: peakMemory / (1024 * 1024)
+            },
+            throughput: totalResults / ((endTime - startTime) / 1000),
+            metadata: {
+                totalStreamedResults: totalResults,
+                averageMemoryPerResult: (peakMemory - memoryBefore) / totalResults
+            }
+        };
+    }
+    /**
+     * Benchmark lazy loading performance
+     */
+    async benchmarkLazyLoading() {
+        const memoryBefore = process.memoryUsage().heapUsed;
+        const startTime = Date.now();
+        // Test lazy loading with different configurations
+        const lazyLoadTests = [
+            { query: 'lazy_test_1', lazyLoad: true, includeLocal: true, includeGitHub: false, includeCollection: false },
+            { query: 'lazy_test_2', lazyLoad: true, includeLocal: false, includeGitHub: true, includeCollection: false },
+            { query: 'lazy_test_3', lazyLoad: true, includeLocal: true, includeGitHub: true, includeCollection: true },
+            { query: 'lazy_test_4', lazyLoad: false, includeLocal: true, includeGitHub: true, includeCollection: true }
+        ];
+        let totalOperations = 0;
+        for (const testCase of lazyLoadTests) {
+            await this.unifiedIndexManager.search(testCase);
+            totalOperations++;
+        }
+        const endTime = Date.now();
+        const memoryAfter = process.memoryUsage().heapUsed;
+        return {
+            name: 'Lazy Loading',
+            duration: endTime - startTime,
+            memoryUsage: {
+                before: memoryBefore / (1024 * 1024),
+                after: memoryAfter / (1024 * 1024),
+                peak: memoryAfter / (1024 * 1024)
+            },
+            throughput: totalOperations / ((endTime - startTime) / 1000),
+            metadata: {
+                totalLazyOperations: totalOperations,
+                averageOperationTime: (endTime - startTime) / totalOperations
+            }
+        };
+    }
+    /**
+     * Reset benchmark environment
+     */
+    async resetBenchmarkEnvironment() {
+        await this.unifiedIndexManager.rebuildAll();
+        this.performanceMonitor.reset();
+        this.benchmarkResults = [];
+        // Force garbage collection if available
+        if (global.gc) {
+            global.gc();
+        }
+        await this.waitForGC();
+    }
+    /**
+     * Wait for garbage collection to complete
+     */
+    async waitForGC() {
+        return new Promise(resolve => {
+            setImmediate(() => {
+                if (global.gc) {
+                    global.gc();
+                }
+                setTimeout(resolve, 100); // Wait 100ms for GC to complete
+            });
+        });
+    }
+    /**
+     * Generate benchmark summary and recommendations
+     */
+    generateSummary(totalDuration) {
+        const recommendations = [];
+        let totalMemoryUsage = 0;
+        let peakMemoryUsage = 0;
+        // Analyze results and generate recommendations
+        for (const result of this.benchmarkResults) {
+            totalMemoryUsage += result.memoryUsage.after - result.memoryUsage.before;
+            peakMemoryUsage = Math.max(peakMemoryUsage, result.memoryUsage.peak);
+            // Check for performance issues
+            if (result.name === 'Search Performance' && result.metadata?.avgSearchTime > 100) {
+                recommendations.push('Average search time exceeds 100ms. Consider query optimization or increased caching.');
+            }
+            if (result.memoryUsage.peak > 200) {
+                recommendations.push(`High memory usage detected in ${result.name} (${result.memoryUsage.peak.toFixed(1)}MB). Consider memory optimization.`);
+            }
+            if (result.cacheStats?.hitRate && result.cacheStats.hitRate < 0.5) {
+                recommendations.push(`Low cache hit rate in ${result.name} (${result.cacheStats.hitRate.toFixed(2)}). Consider cache size increase or TTL adjustment.`);
+            }
+            if (result.throughput && result.throughput < 10) {
+                recommendations.push(`Low throughput in ${result.name} (${result.throughput.toFixed(1)} ops/sec). Consider performance optimization.`);
+            }
+        }
+        // General recommendations
+        if (peakMemoryUsage > 50) {
+            recommendations.push('Peak memory usage exceeds 50MB. Consider implementing more aggressive memory cleanup.');
+        }
+        if (totalDuration > 30000) {
+            recommendations.push('Total benchmark duration exceeds 30 seconds. Consider performance optimizations.');
+        }
+        return {
+            totalDuration,
+            averageMemoryUsage: totalMemoryUsage / this.benchmarkResults.length,
+            peakMemoryUsage,
+            recommendations
+        };
+    }
+    /**
+     * Export benchmark results to JSON
+     */
+    exportResults(suite) {
+        return JSON.stringify(suite, null, 2);
+    }
+    /**
+     * Generate benchmark report
+     */
+    generateReport(suite) {
+        let report = `# DollhouseMCP Index Performance Benchmark Report\n\n`;
+        report += `**Generated:** ${new Date().toISOString()}\n`;
+        report += `**Total Duration:** ${suite.summary.totalDuration}ms\n`;
+        report += `**Peak Memory Usage:** ${suite.summary.peakMemoryUsage.toFixed(1)}MB\n\n`;
+        report += `## Benchmark Results\n\n`;
+        for (const result of suite.results) {
+            report += `### ${result.name}\n`;
+            report += `- **Duration:** ${result.duration}ms\n`;
+            report += `- **Memory Usage:** ${result.memoryUsage.before.toFixed(1)}MB → ${result.memoryUsage.after.toFixed(1)}MB (Peak: ${result.memoryUsage.peak.toFixed(1)}MB)\n`;
+            if (result.throughput) {
+                report += `- **Throughput:** ${result.throughput.toFixed(1)} ops/sec\n`;
+            }
+            if (result.cacheStats) {
+                report += `- **Cache Hit Rate:** ${result.cacheStats.hitRate.toFixed(2)}\n`;
+            }
+            report += `\n`;
+        }
+        report += `## Recommendations\n\n`;
+        if (suite.summary.recommendations.length === 0) {
+            report += `No performance issues detected. System is performing within acceptable parameters.\n`;
+        }
+        else {
+            for (const recommendation of suite.summary.recommendations) {
+                report += `- ${recommendation}\n`;
+            }
+        }
+        return report;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"IndexPerformanceBenchmark.js","sourceRoot":"","sources":["../../src/benchmarks/IndexPerformanceBenchmark.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive Performance Benchmarking Suite for DollhouseMCP Indexing System\n * \n * Benchmarks:\n * - Search response times under various loads\n * - Memory usage patterns with large datasets\n * - Cache performance and hit rates\n * - Concurrent operation performance\n * - Index building and rebuilding times\n */\n\nimport { UnifiedIndexManager, UnifiedSearchOptions } from '../portfolio/UnifiedIndexManager.js';\nimport { PortfolioIndexManager } from '../portfolio/PortfolioIndexManager.js';\nimport { CollectionIndexCache } from '../cache/CollectionIndexCache.js';\nimport { PerformanceMonitor } from '../utils/PerformanceMonitor.js';\nimport { GitHubClient } from '../collection/GitHubClient.js';\nimport { APICache } from '../cache/APICache.js';\nimport { logger } from '../utils/logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\nexport interface BenchmarkResult {\n  name: string;\n  duration: number;\n  memoryUsage: {\n    before: number;\n    after: number;\n    peak: number;\n  };\n  throughput?: number; // operations per second\n  cacheStats?: {\n    hitRate: number;\n    totalOperations: number;\n  };\n  metadata?: any;\n}\n\nexport interface BenchmarkSuite {\n  name: string;\n  results: BenchmarkResult[];\n  summary: {\n    totalDuration: number;\n    averageMemoryUsage: number;\n    peakMemoryUsage: number;\n    recommendations: string[];\n  };\n}\n\nexport class IndexPerformanceBenchmark {\n  private unifiedIndexManager: UnifiedIndexManager;\n  private performanceMonitor: PerformanceMonitor;\n  private benchmarkResults: BenchmarkResult[] = [];\n\n  constructor() {\n    this.unifiedIndexManager = UnifiedIndexManager.getInstance();\n    this.performanceMonitor = PerformanceMonitor.getInstance();\n  }\n\n  /**\n   * Run comprehensive performance benchmark suite\n   */\n  async runFullBenchmarkSuite(): Promise<BenchmarkSuite> {\n    logger.info('Starting comprehensive performance benchmark suite');\n    const suiteStartTime = Date.now();\n\n    // Clear caches and reset state\n    await this.resetBenchmarkEnvironment();\n\n    const benchmarks = [\n      () => this.benchmarkSearchPerformance(),\n      () => this.benchmarkMemoryUsage(),\n      () => this.benchmarkCachePerformance(),\n      () => this.benchmarkConcurrentOperations(),\n      () => this.benchmarkLargeDatasetHandling(),\n      () => this.benchmarkIndexBuilding(),\n      () => this.benchmarkStreamingSearch(),\n      () => this.benchmarkLazyLoading()\n    ];\n\n    // Run each benchmark\n    for (const benchmark of benchmarks) {\n      try {\n        const result = await benchmark();\n        this.benchmarkResults.push(result);\n        \n        // Allow garbage collection between benchmarks\n        await this.waitForGC();\n      } catch (error) {\n        logger.error('Benchmark failed', {\n          error: error instanceof Error ? error.message : String(error)\n        });\n      }\n    }\n\n    const suite: BenchmarkSuite = {\n      name: 'DollhouseMCP Index Performance Suite',\n      results: this.benchmarkResults,\n      summary: this.generateSummary(Date.now() - suiteStartTime)\n    };\n\n    logger.info('Benchmark suite completed', {\n      totalBenchmarks: suite.results.length,\n      totalDuration: suite.summary.totalDuration,\n      recommendations: suite.summary.recommendations.length\n    });\n\n    return suite;\n  }\n\n  /**\n   * Benchmark search performance with various query patterns\n   */\n  private async benchmarkSearchPerformance(): Promise<BenchmarkResult> {\n    const testQueries = [\n      'creative',\n      'professional assistant',\n      'development tools',\n      'data analysis',\n      'machine learning expert',\n      'a very long and complex query that might stress the search system with multiple terms and complex patterns',\n      'specific_exact_match',\n      ''  // Empty query test\n    ];\n\n    const memoryBefore = process.memoryUsage().heapUsed;\n    let peakMemory = memoryBefore;\n    const startTime = Date.now();\n\n    let totalOperations = 0;\n    let cacheHits = 0;\n\n    for (const query of testQueries) {\n      for (let i = 0; i < 10; i++) { // 10 iterations per query\n        const options: UnifiedSearchOptions = {\n          query,\n          includeLocal: true,\n          includeGitHub: true,\n          includeCollection: false,\n          pageSize: 20\n        };\n\n        await this.unifiedIndexManager.search(options);\n        totalOperations++;\n\n        // Track peak memory\n        const currentMemory = process.memoryUsage().heapUsed;\n        if (currentMemory > peakMemory) {\n          peakMemory = currentMemory;\n        }\n      }\n    }\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n    const duration = endTime - startTime;\n\n    const performanceStats = this.unifiedIndexManager.getPerformanceStats();\n    const searchStats = performanceStats.searchStats;\n\n    return {\n      name: 'Search Performance',\n      duration,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: peakMemory / (1024 * 1024)\n      },\n      throughput: totalOperations / (duration / 1000),\n      cacheStats: {\n        hitRate: searchStats.cacheHitRate || 0,\n        totalOperations\n      },\n      metadata: {\n        avgSearchTime: searchStats.averageTime || 0,\n        p95SearchTime: searchStats.p95Time || 0,\n        slowQueries: searchStats.slowQueries || 0\n      }\n    };\n  }\n\n  /**\n   * Benchmark memory usage with large result sets\n   */\n  private async benchmarkMemoryUsage(): Promise<BenchmarkResult> {\n    const memoryBefore = process.memoryUsage().heapUsed;\n    let peakMemory = memoryBefore;\n    const startTime = Date.now();\n\n    // Create increasingly large search operations\n    const largeBatches = [100, 500, 1000, 2000];\n    \n    for (const batchSize of largeBatches) {\n      const options: UnifiedSearchOptions = {\n        query: '',  // Empty query to get all results\n        includeLocal: true,\n        includeGitHub: true,\n        includeCollection: true,\n        pageSize: batchSize,\n        maxResults: batchSize\n      };\n\n      await this.unifiedIndexManager.search(options);\n\n      const currentMemory = process.memoryUsage().heapUsed;\n      if (currentMemory > peakMemory) {\n        peakMemory = currentMemory;\n      }\n\n      // Check for memory leaks\n      if (currentMemory > memoryBefore * 2) {\n        logger.warn('Potential memory leak detected', {\n          beforeMB: memoryBefore / (1024 * 1024),\n          currentMB: currentMemory / (1024 * 1024),\n          batchSize\n        });\n      }\n    }\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n\n    return {\n      name: 'Memory Usage',\n      duration: endTime - startTime,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: peakMemory / (1024 * 1024)\n      },\n      metadata: {\n        memoryGrowthMB: (memoryAfter - memoryBefore) / (1024 * 1024),\n        peakGrowthMB: (peakMemory - memoryBefore) / (1024 * 1024),\n        testedBatchSizes: largeBatches\n      }\n    };\n  }\n\n  /**\n   * Benchmark cache performance and hit rates\n   */\n  private async benchmarkCachePerformance(): Promise<BenchmarkResult> {\n    const memoryBefore = process.memoryUsage().heapUsed;\n    const startTime = Date.now();\n\n    // Test cache warming and hit rate optimization\n    const rawQueries = ['test', 'performance', 'benchmark', 'cache'];\n    // DMCP-SEC-004 FIX: Normalize Unicode in all user input\n    const testQueries = rawQueries.map(q => {\n      const normalized = UnicodeValidator.normalize(q);\n      return normalized.isValid ? normalized.normalizedContent : q;\n    });\n    let totalOperations = 0;\n    let cacheHitsBefore = 0;\n\n    // First pass - cache misses expected\n    for (const query of testQueries) {\n      for (let i = 0; i < 5; i++) {\n        await this.unifiedIndexManager.search({ query, pageSize: 10 });\n        totalOperations++;\n      }\n    }\n\n    const statsAfterFirstPass = this.unifiedIndexManager.getPerformanceStats();\n    cacheHitsBefore = statsAfterFirstPass.cacheStats.searchResults.hitCount;\n\n    // Second pass - cache hits expected\n    for (const query of testQueries) {\n      for (let i = 0; i < 5; i++) {\n        await this.unifiedIndexManager.search({ query, pageSize: 10 });\n        totalOperations++;\n      }\n    }\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n\n    const finalStats = this.unifiedIndexManager.getPerformanceStats();\n    const cacheStats = finalStats.cacheStats.searchResults;\n\n    return {\n      name: 'Cache Performance',\n      duration: endTime - startTime,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: memoryAfter / (1024 * 1024)\n      },\n      cacheStats: {\n        hitRate: cacheStats.hitRate,\n        totalOperations\n      },\n      metadata: {\n        cacheSize: cacheStats.size,\n        evictions: cacheStats.evictionCount,\n        hitRateImprovement: cacheStats.hitRate\n      }\n    };\n  }\n\n  /**\n   * Benchmark concurrent search operations\n   */\n  private async benchmarkConcurrentOperations(): Promise<BenchmarkResult> {\n    const memoryBefore = process.memoryUsage().heapUsed;\n    let peakMemory = memoryBefore;\n    const startTime = Date.now();\n\n    const concurrencyLevels = [5, 10, 20, 50];\n    let totalOperations = 0;\n\n    for (const concurrency of concurrencyLevels) {\n      const promises = [];\n\n      for (let i = 0; i < concurrency; i++) {\n        const searchPromise = this.unifiedIndexManager.search({\n          query: `concurrent_test_${i}`,\n          pageSize: 20\n        });\n        promises.push(searchPromise);\n        totalOperations++;\n      }\n\n      await Promise.all(promises);\n\n      const currentMemory = process.memoryUsage().heapUsed;\n      if (currentMemory > peakMemory) {\n        peakMemory = currentMemory;\n      }\n    }\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n    const duration = endTime - startTime;\n\n    return {\n      name: 'Concurrent Operations',\n      duration,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: peakMemory / (1024 * 1024)\n      },\n      throughput: totalOperations / (duration / 1000),\n      metadata: {\n        testedConcurrencyLevels: concurrencyLevels,\n        totalConcurrentOps: totalOperations\n      }\n    };\n  }\n\n  /**\n   * Benchmark large dataset handling (simulated)\n   */\n  private async benchmarkLargeDatasetHandling(): Promise<BenchmarkResult> {\n    const memoryBefore = process.memoryUsage().heapUsed;\n    let peakMemory = memoryBefore;\n    const startTime = Date.now();\n\n    // Simulate searches that would stress a large dataset\n    const stressTestQueries = [\n      { query: '', pageSize: 1000 }, // Get all results\n      { query: 'common_term', pageSize: 500 }, // High result count\n      { query: 'very_specific_unique_term', pageSize: 100 }, // Low result count\n      { query: 'partial_match_test', pageSize: 200 } // Medium result count\n    ];\n\n    let totalResults = 0;\n\n    for (const testCase of stressTestQueries) {\n      const results = await this.unifiedIndexManager.search({\n        query: testCase.query,\n        pageSize: testCase.pageSize,\n        includeLocal: true,\n        includeGitHub: true,\n        includeCollection: true\n      });\n\n      totalResults += results.length;\n\n      const currentMemory = process.memoryUsage().heapUsed;\n      if (currentMemory > peakMemory) {\n        peakMemory = currentMemory;\n      }\n    }\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n\n    return {\n      name: 'Large Dataset Handling',\n      duration: endTime - startTime,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: peakMemory / (1024 * 1024)\n      },\n      metadata: {\n        totalResultsProcessed: totalResults,\n        averageResultsPerQuery: totalResults / stressTestQueries.length,\n        memoryPerResult: (peakMemory - memoryBefore) / totalResults\n      }\n    };\n  }\n\n  /**\n   * Benchmark index building performance\n   */\n  private async benchmarkIndexBuilding(): Promise<BenchmarkResult> {\n    const memoryBefore = process.memoryUsage().heapUsed;\n    const startTime = Date.now();\n\n    // Force rebuild of all indexes\n    await this.unifiedIndexManager.rebuildAll();\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n\n    const localStats = await PortfolioIndexManager.getInstance().getStats();\n\n    return {\n      name: 'Index Building',\n      duration: endTime - startTime,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: memoryAfter / (1024 * 1024)\n      },\n      metadata: {\n        totalElementsIndexed: localStats.totalElements,\n        indexingRate: localStats.totalElements / ((endTime - startTime) / 1000),\n        isStale: localStats.isStale\n      }\n    };\n  }\n\n  /**\n   * Benchmark streaming search performance\n   */\n  private async benchmarkStreamingSearch(): Promise<BenchmarkResult> {\n    const memoryBefore = process.memoryUsage().heapUsed;\n    let peakMemory = memoryBefore;\n    const startTime = Date.now();\n\n    const streamingQueries = [\n      { query: 'test', maxResults: 100 },\n      { query: 'assistant', maxResults: 200 },\n      { query: 'creative', maxResults: 150 }\n    ];\n\n    let totalResults = 0;\n\n    for (const testCase of streamingQueries) {\n      const results = await this.unifiedIndexManager.search({\n        query: testCase.query,\n        streamResults: true,\n        maxResults: testCase.maxResults,\n        includeLocal: true,\n        includeGitHub: true\n      });\n\n      totalResults += results.length;\n\n      const currentMemory = process.memoryUsage().heapUsed;\n      if (currentMemory > peakMemory) {\n        peakMemory = currentMemory;\n      }\n    }\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n\n    return {\n      name: 'Streaming Search',\n      duration: endTime - startTime,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: peakMemory / (1024 * 1024)\n      },\n      throughput: totalResults / ((endTime - startTime) / 1000),\n      metadata: {\n        totalStreamedResults: totalResults,\n        averageMemoryPerResult: (peakMemory - memoryBefore) / totalResults\n      }\n    };\n  }\n\n  /**\n   * Benchmark lazy loading performance\n   */\n  private async benchmarkLazyLoading(): Promise<BenchmarkResult> {\n    const memoryBefore = process.memoryUsage().heapUsed;\n    const startTime = Date.now();\n\n    // Test lazy loading with different configurations\n    const lazyLoadTests = [\n      { query: 'lazy_test_1', lazyLoad: true, includeLocal: true, includeGitHub: false, includeCollection: false },\n      { query: 'lazy_test_2', lazyLoad: true, includeLocal: false, includeGitHub: true, includeCollection: false },\n      { query: 'lazy_test_3', lazyLoad: true, includeLocal: true, includeGitHub: true, includeCollection: true },\n      { query: 'lazy_test_4', lazyLoad: false, includeLocal: true, includeGitHub: true, includeCollection: true }\n    ];\n\n    let totalOperations = 0;\n\n    for (const testCase of lazyLoadTests) {\n      await this.unifiedIndexManager.search(testCase);\n      totalOperations++;\n    }\n\n    const endTime = Date.now();\n    const memoryAfter = process.memoryUsage().heapUsed;\n\n    return {\n      name: 'Lazy Loading',\n      duration: endTime - startTime,\n      memoryUsage: {\n        before: memoryBefore / (1024 * 1024),\n        after: memoryAfter / (1024 * 1024),\n        peak: memoryAfter / (1024 * 1024)\n      },\n      throughput: totalOperations / ((endTime - startTime) / 1000),\n      metadata: {\n        totalLazyOperations: totalOperations,\n        averageOperationTime: (endTime - startTime) / totalOperations\n      }\n    };\n  }\n\n  /**\n   * Reset benchmark environment\n   */\n  private async resetBenchmarkEnvironment(): Promise<void> {\n    await this.unifiedIndexManager.rebuildAll();\n    this.performanceMonitor.reset();\n    this.benchmarkResults = [];\n\n    // Force garbage collection if available\n    if (global.gc) {\n      global.gc();\n    }\n\n    await this.waitForGC();\n  }\n\n  /**\n   * Wait for garbage collection to complete\n   */\n  private async waitForGC(): Promise<void> {\n    return new Promise(resolve => {\n      setImmediate(() => {\n        if (global.gc) {\n          global.gc();\n        }\n        setTimeout(resolve, 100); // Wait 100ms for GC to complete\n      });\n    });\n  }\n\n  /**\n   * Generate benchmark summary and recommendations\n   */\n  private generateSummary(totalDuration: number): BenchmarkSuite['summary'] {\n    const recommendations: string[] = [];\n    let totalMemoryUsage = 0;\n    let peakMemoryUsage = 0;\n\n    // Analyze results and generate recommendations\n    for (const result of this.benchmarkResults) {\n      totalMemoryUsage += result.memoryUsage.after - result.memoryUsage.before;\n      peakMemoryUsage = Math.max(peakMemoryUsage, result.memoryUsage.peak);\n\n      // Check for performance issues\n      if (result.name === 'Search Performance' && result.metadata?.avgSearchTime > 100) {\n        recommendations.push('Average search time exceeds 100ms. Consider query optimization or increased caching.');\n      }\n\n      if (result.memoryUsage.peak > 200) {\n        recommendations.push(`High memory usage detected in ${result.name} (${result.memoryUsage.peak.toFixed(1)}MB). Consider memory optimization.`);\n      }\n\n      if (result.cacheStats?.hitRate && result.cacheStats.hitRate < 0.5) {\n        recommendations.push(`Low cache hit rate in ${result.name} (${result.cacheStats.hitRate.toFixed(2)}). Consider cache size increase or TTL adjustment.`);\n      }\n\n      if (result.throughput && result.throughput < 10) {\n        recommendations.push(`Low throughput in ${result.name} (${result.throughput.toFixed(1)} ops/sec). Consider performance optimization.`);\n      }\n    }\n\n    // General recommendations\n    if (peakMemoryUsage > 50) {\n      recommendations.push('Peak memory usage exceeds 50MB. Consider implementing more aggressive memory cleanup.');\n    }\n\n    if (totalDuration > 30000) {\n      recommendations.push('Total benchmark duration exceeds 30 seconds. Consider performance optimizations.');\n    }\n\n    return {\n      totalDuration,\n      averageMemoryUsage: totalMemoryUsage / this.benchmarkResults.length,\n      peakMemoryUsage,\n      recommendations\n    };\n  }\n\n  /**\n   * Export benchmark results to JSON\n   */\n  exportResults(suite: BenchmarkSuite): string {\n    return JSON.stringify(suite, null, 2);\n  }\n\n  /**\n   * Generate benchmark report\n   */\n  generateReport(suite: BenchmarkSuite): string {\n    let report = `# DollhouseMCP Index Performance Benchmark Report\\n\\n`;\n    report += `**Generated:** ${new Date().toISOString()}\\n`;\n    report += `**Total Duration:** ${suite.summary.totalDuration}ms\\n`;\n    report += `**Peak Memory Usage:** ${suite.summary.peakMemoryUsage.toFixed(1)}MB\\n\\n`;\n\n    report += `## Benchmark Results\\n\\n`;\n\n    for (const result of suite.results) {\n      report += `### ${result.name}\\n`;\n      report += `- **Duration:** ${result.duration}ms\\n`;\n      report += `- **Memory Usage:** ${result.memoryUsage.before.toFixed(1)}MB → ${result.memoryUsage.after.toFixed(1)}MB (Peak: ${result.memoryUsage.peak.toFixed(1)}MB)\\n`;\n      \n      if (result.throughput) {\n        report += `- **Throughput:** ${result.throughput.toFixed(1)} ops/sec\\n`;\n      }\n      \n      if (result.cacheStats) {\n        report += `- **Cache Hit Rate:** ${result.cacheStats.hitRate.toFixed(2)}\\n`;\n      }\n      \n      report += `\\n`;\n    }\n\n    report += `## Recommendations\\n\\n`;\n    \n    if (suite.summary.recommendations.length === 0) {\n      report += `No performance issues detected. System is performing within acceptable parameters.\\n`;\n    } else {\n      for (const recommendation of suite.summary.recommendations) {\n        report += `- ${recommendation}\\n`;\n      }\n    }\n\n    return report;\n  }\n}"]}

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

@@ -1 +1 @@
-{"version":3,"file":"CollectionCache.d.ts","sourceRoot":"","sources":["../../src/cache/CollectionCache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;gBAExC,OAAO,GAAE,MAAsB;IAK3C;;OAEG;YACW,cAAc;IAS5B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAkCvD;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BtE;;OAEG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAkB3D;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACG,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IASnE;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAKtC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAWjC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAY1F"}
+{"version":3,"file":"CollectionCache.d.ts","sourceRoot":"","sources":["../../src/cache/CollectionCache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;gBAExC,OAAO,CAAC,EAAE,MAAM;IAc5B;;OAEG;YACW,cAAc;IAS5B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAkCvD;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BtE;;OAEG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAkB3D;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACG,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IASnE;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAKtC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAWjC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAY1F"}