agentic-qe 1.3.3 → 1.3.5

package/dist/reasoning/QEReasoningBank.js

@@ -29,8 +29,43 @@
  * });
  * ```
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QEReasoningBank = void 0;
+const VectorSimilarity_1 = require("./VectorSimilarity");
+const PatternQualityScorer_1 = require("./PatternQualityScorer");
 /**
  * QEReasoningBank - Main class for pattern storage and retrieval
  *
@@ -49,13 +84,27 @@ exports.QEReasoningBank = void 0;
  * @public
  */
 class QEReasoningBank {
-    constructor() {
+    constructor(config = {}) {
         this.patterns = new Map();
         this.patternIndex = new Map();
+        this.keywordIndex = new Map(); // NEW: keyword-based fast lookup
+        this.frameworkIndex = new Map(); // NEW: framework-based index
         this.versionHistory = new Map();
+        this.vectorCache = new Map();
+        this.similarityCache = new Map(); // NEW: cache for similar patterns
+        this.cacheExpiryTime = 5 * 60 * 1000; // 5 minutes cache TTL
+        this.lastCacheCleanup = Date.now();
+        this.vectorSimilarity = new VectorSimilarity_1.VectorSimilarity({ useIDF: true });
+        this.qualityScorer = new PatternQualityScorer_1.PatternQualityScorer();
+        this.minQuality = config.minQuality ?? 0.7;
+        this.performanceMetrics = {
+            lookupTimes: [],
+            cachehits: 0,
+            cacheMisses: 0
+        };
     }
     /**
-     * Store a new test pattern
+     * Store a new test pattern with quality scoring and vector indexing
      */
     async storePattern(pattern) {
         // Validate pattern
@@ -65,6 +114,22 @@ class QEReasoningBank {
         if (pattern.confidence < 0 || pattern.confidence > 1) {
             throw new Error('Confidence must be between 0 and 1');
         }
+        // Calculate pattern quality if not provided
+        if (pattern.quality === undefined) {
+            const qualityScore = this.qualityScorer.calculateQuality({
+                id: pattern.id,
+                name: pattern.name,
+                code: pattern.examples[0] || pattern.template,
+                template: pattern.template,
+                description: pattern.description,
+                tags: pattern.metadata.tags,
+                usageCount: pattern.usageCount,
+                metadata: {
+                    successRate: pattern.successRate
+                }
+            });
+            pattern.quality = qualityScore.overall;
+        }
         // Version existing pattern
         if (this.patterns.has(pattern.id)) {
             const existing = this.patterns.get(pattern.id);
@@ -74,6 +139,11 @@ class QEReasoningBank {
         }
         // Store pattern
         this.patterns.set(pattern.id, { ...pattern });
+        // Generate and cache vector embedding
+        const patternText = this.getPatternText(pattern);
+        this.vectorSimilarity.indexDocument(patternText);
+        const vector = this.vectorSimilarity.generateEmbedding(patternText);
+        this.vectorCache.set(pattern.id, vector);
         // Update index for fast lookup
         this.updateIndex(pattern);
     }
@@ -84,24 +154,163 @@ class QEReasoningBank {
         return this.patterns.get(id) || null;
     }
     /**
-     * Find matching patterns for a code context
+     * Find matching patterns using vector similarity with performance optimizations
+     * Target: 85%+ matching accuracy, <50ms p95 latency
+     *
+     * **Optimizations:**
+     * - Caching: Frequently accessed patterns cached for 5 minutes
+     * - Indexing: Multi-level indexes (keyword, framework, tag) for fast lookup
+     * - Early termination: Stop processing when enough high-quality matches found
+     * - Batch processing: Process multiple candidates in batches
      */
     async findMatchingPatterns(context, limit = 10) {
+        const startTime = performance.now();
+        // Check cache first
+        const cacheKey = this.getCacheKey(context);
+        if (this.similarityCache.has(cacheKey)) {
+            this.performanceMetrics.cachehits++;
+            const cached = this.similarityCache.get(cacheKey);
+            this.recordLookupTime(performance.now() - startTime);
+            return cached.slice(0, limit);
+        }
+        this.performanceMetrics.cacheMisses++;
+        // Use indexed lookup for fast candidate selection
+        const candidates = this.getIndexedCandidates(context);
+        // If we have indexed candidates, use them; otherwise fall back to full scan
+        const vectorMatches = candidates.length > 0
+            ? this.scoreIndexedCandidates(candidates, context, limit * 2)
+            : await this.vectorSimilaritySearch(context, limit * 2);
         const matches = [];
-        for (const pattern of Array.from(this.patterns.values())) {
-            const confidence = this.calculateMatchConfidence(pattern, context);
-            if (confidence > 0.3) { // Threshold
+        let highQualityCount = 0;
+        // Process candidates with early termination
+        for (const vectorMatch of vectorMatches) {
+            const pattern = this.patterns.get(vectorMatch.id);
+            if (!pattern)
+                continue;
+            // Calculate hybrid confidence (vector similarity + rule-based)
+            const ruleBased = this.calculateMatchConfidence(pattern, context);
+            const vectorSim = vectorMatch.similarity;
+            // Hybrid scoring: 60% vector similarity, 40% rule-based
+            const confidence = vectorSim * 0.6 + ruleBased * 0.4;
+            // Apply quality filter
+            const meetsQuality = (pattern.quality ?? 1.0) >= this.minQuality;
+            if (confidence > 0.3 && meetsQuality) {
+                const applicability = confidence * pattern.successRate * (pattern.quality ?? 1.0);
                 matches.push({
                     pattern,
                     confidence,
-                    reasoning: this.generateReasoning(pattern, context),
-                    applicability: confidence * pattern.successRate
+                    similarity: vectorSim,
+                    reasoning: this.generateReasoning(pattern, context, vectorSim),
+                    applicability
                 });
+                // Early termination: if we have enough high-quality matches, stop
+                if (applicability > 0.85) {
+                    highQualityCount++;
+                    if (highQualityCount >= limit && matches.length >= limit * 1.5) {
+                        break;
+                    }
+                }
             }
         }
-        // Sort by applicability
+        // Sort by applicability (confidence × success rate × quality)
         matches.sort((a, b) => b.applicability - a.applicability);
-        return matches.slice(0, limit);
+        const result = matches.slice(0, limit);
+        // Cache the result
+        this.similarityCache.set(cacheKey, result);
+        this.cleanupCacheIfNeeded();
+        const lookupTime = performance.now() - startTime;
+        this.recordLookupTime(lookupTime);
+        return result;
+    }
+    /**
+     * Get cache key for context
+     */
+    getCacheKey(context) {
+        return JSON.stringify({
+            codeType: context.codeType,
+            framework: context.framework,
+            language: context.language,
+            keywords: context.keywords?.sort()
+        });
+    }
+    /**
+     * Get indexed candidates for fast lookup
+     * Uses multi-level indexes (framework, keywords, tags)
+     */
+    getIndexedCandidates(context) {
+        const candidateIds = new Set();
+        // Framework index lookup (most specific)
+        if (context.framework && this.frameworkIndex.has(context.framework)) {
+            this.frameworkIndex.get(context.framework).forEach(id => candidateIds.add(id));
+        }
+        // Keyword index lookup
+        if (context.keywords && context.keywords.length > 0) {
+            for (const keyword of context.keywords) {
+                if (this.keywordIndex.has(keyword.toLowerCase())) {
+                    this.keywordIndex.get(keyword.toLowerCase()).forEach(id => candidateIds.add(id));
+                }
+            }
+        }
+        return Array.from(candidateIds);
+    }
+    /**
+     * Score indexed candidates efficiently
+     */
+    scoreIndexedCandidates(candidateIds, context, limit) {
+        const queryText = this.buildQueryText(context);
+        const queryVector = this.vectorSimilarity.generateEmbedding(queryText);
+        const scored = candidateIds
+            .map(id => {
+            const vector = this.vectorCache.get(id);
+            if (!vector)
+                return null;
+            const similarity = this.vectorSimilarity.cosineSimilarity(queryVector, vector);
+            return { id, similarity };
+        })
+            .filter((item) => item !== null)
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, limit);
+        return scored;
+    }
+    /**
+     * Fallback vector similarity search
+     */
+    async vectorSimilaritySearch(context, limit) {
+        const queryText = this.buildQueryText(context);
+        const queryVector = this.vectorSimilarity.generateEmbedding(queryText);
+        return this.vectorSimilarity.findTopK(queryVector, this.vectorCache, limit);
+    }
+    /**
+     * Record lookup time for performance monitoring
+     */
+    recordLookupTime(timeMs) {
+        this.performanceMetrics.lookupTimes.push(timeMs);
+        // Keep only last 1000 measurements
+        if (this.performanceMetrics.lookupTimes.length > 1000) {
+            this.performanceMetrics.lookupTimes.shift();
+        }
+    }
+    /**
+     * Cleanup cache if needed (every 5 minutes)
+     */
+    cleanupCacheIfNeeded() {
+        const now = Date.now();
+        if (now - this.lastCacheCleanup > this.cacheExpiryTime) {
+            this.similarityCache.clear();
+            this.lastCacheCleanup = now;
+        }
+    }
+    /**
+     * Find similar patterns by example code
+     * Uses vector similarity for code-based matching
+     */
+    async findSimilarPatterns(exampleCode, framework, limit = 5) {
+        return this.findMatchingPatterns({
+            codeType: 'test',
+            framework,
+            sourceCode: exampleCode,
+            keywords: this.extractKeywords(exampleCode)
+        }, limit);
     }
     /**
      * Update pattern success metrics
@@ -121,7 +330,7 @@ class QEReasoningBank {
         pattern.metadata.updatedAt = new Date();
     }
     /**
-     * Get pattern statistics
+     * Get pattern statistics (alias for getStats for backward compatibility)
      */
     async getStatistics() {
         const patterns = Array.from(this.patterns.values());
@@ -129,6 +338,7 @@ class QEReasoningBank {
             totalPatterns: patterns.length,
             averageConfidence: patterns.reduce((sum, p) => sum + p.confidence, 0) / patterns.length || 0,
             averageSuccessRate: patterns.reduce((sum, p) => sum + p.successRate, 0) / patterns.length || 0,
+            averageQuality: patterns.reduce((sum, p) => sum + (p.quality ?? 0), 0) / patterns.length || 0,
             byCategory: {},
             byFramework: {}
         };
@@ -173,12 +383,33 @@ class QEReasoningBank {
             this.patternIndex.set(pattern.category, new Set());
         }
         this.patternIndex.get(pattern.category).add(pattern.id);
+        // Index by framework (NEW: fast framework lookup)
+        if (!this.frameworkIndex.has(pattern.framework)) {
+            this.frameworkIndex.set(pattern.framework, new Set());
+        }
+        this.frameworkIndex.get(pattern.framework).add(pattern.id);
         // Index by tags
         for (const tag of pattern.metadata.tags) {
             if (!this.patternIndex.has(`tag:${tag}`)) {
                 this.patternIndex.set(`tag:${tag}`, new Set());
             }
             this.patternIndex.get(`tag:${tag}`).add(pattern.id);
+            // Index by keyword (NEW: fast keyword lookup)
+            const keyword = tag.toLowerCase();
+            if (!this.keywordIndex.has(keyword)) {
+                this.keywordIndex.set(keyword, new Set());
+            }
+            this.keywordIndex.get(keyword).add(pattern.id);
+        }
+        // Index name keywords (NEW)
+        const nameWords = pattern.name.toLowerCase().split(/\s+/);
+        for (const word of nameWords) {
+            if (word.length > 2) { // Skip very short words
+                if (!this.keywordIndex.has(word)) {
+                    this.keywordIndex.set(word, new Set());
+                }
+                this.keywordIndex.get(word).add(pattern.id);
+            }
         }
     }
     calculateMatchConfidence(pattern, context) {
@@ -211,8 +442,12 @@ class QEReasoningBank {
         score += pattern.confidence * 0.10;
         return factors > 0 ? Math.min(score, 1.0) : 0;
     }
-    generateReasoning(pattern, context) {
+    generateReasoning(pattern, context, similarity) {
         const reasons = [];
+        // Vector similarity score
+        if (similarity !== undefined) {
+            reasons.push(`Similarity: ${(similarity * 100).toFixed(1)}%`);
+        }
         if (context.framework && pattern.framework === context.framework) {
             reasons.push(`Framework match: ${pattern.framework}`);
         }
@@ -225,10 +460,323 @@ class QEReasoningBank {
                 reasons.push(`Tag matches: ${matchingKeywords.join(', ')}`);
             }
         }
+        if (pattern.quality !== undefined) {
+            reasons.push(`Quality: ${(pattern.quality * 100).toFixed(1)}%`);
+        }
         reasons.push(`Success rate: ${(pattern.successRate * 100).toFixed(1)}%`);
         reasons.push(`Used ${pattern.usageCount} times`);
         return reasons.join('; ');
     }
+    /**
+     * Build query text from context for vector matching
+     */
+    buildQueryText(context) {
+        const parts = [];
+        parts.push(context.codeType);
+        if (context.framework) {
+            parts.push(context.framework);
+        }
+        if (context.language) {
+            parts.push(context.language);
+        }
+        if (context.keywords) {
+            parts.push(...context.keywords);
+        }
+        if (context.sourceCode) {
+            // Extract meaningful tokens from source code
+            parts.push(...this.extractKeywords(context.sourceCode));
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Get pattern text for vector embedding
+     */
+    getPatternText(pattern) {
+        const parts = [];
+        parts.push(pattern.name);
+        parts.push(pattern.description);
+        parts.push(pattern.category);
+        parts.push(pattern.framework);
+        parts.push(...pattern.metadata.tags);
+        if (pattern.examples.length > 0) {
+            parts.push(...this.extractKeywords(pattern.examples[0]));
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Extract keywords from code
+     */
+    extractKeywords(code) {
+        // Simple keyword extraction (can be enhanced with AST analysis)
+        const keywords = [];
+        // Extract function/method names
+        const functionMatches = code.match(/function\s+(\w+)|const\s+(\w+)\s*=/g);
+        if (functionMatches) {
+            keywords.push(...functionMatches.map(m => m.replace(/function|const|=|\s/g, '')));
+        }
+        // Extract identifiers (camelCase, snake_case)
+        const identifiers = code.match(/\b[a-z_][a-zA-Z0-9_]{2,}\b/g);
+        if (identifiers) {
+            keywords.push(...identifiers.slice(0, 20)); // Limit to avoid noise
+        }
+        return keywords.filter(k => k.length > 2);
+    }
+    /**
+     * Match a pattern by exact ID
+     * Alias for getPattern for consistency with pattern matching API
+     */
+    async matchPattern(patternId) {
+        return this.getPattern(patternId);
+    }
+    /**
+     * Find patterns using flexible search criteria
+     * Supports multiple search strategies: vector similarity, tag matching, keyword search
+     */
+    async findPattern(criteria, limit = 10) {
+        // If query provided, use vector similarity search
+        if (criteria.query) {
+            return this.findMatchingPatterns({
+                codeType: 'test',
+                framework: criteria.framework,
+                language: criteria.language,
+                keywords: criteria.tags,
+                sourceCode: criteria.query
+            }, limit);
+        }
+        // Otherwise, use filter-based search
+        let patterns = Array.from(this.patterns.values());
+        // Apply filters
+        if (criteria.category) {
+            patterns = patterns.filter(p => p.category === criteria.category);
+        }
+        if (criteria.framework) {
+            patterns = patterns.filter(p => p.framework === criteria.framework);
+        }
+        if (criteria.language) {
+            patterns = patterns.filter(p => p.language === criteria.language);
+        }
+        if (criteria.tags && criteria.tags.length > 0) {
+            patterns = patterns.filter(p => criteria.tags.some(tag => p.metadata.tags.includes(tag)));
+        }
+        if (criteria.minConfidence !== undefined) {
+            patterns = patterns.filter(p => p.confidence >= criteria.minConfidence);
+        }
+        if (criteria.minQuality !== undefined) {
+            patterns = patterns.filter(p => (p.quality ?? 0) >= criteria.minQuality);
+        }
+        // Sort by quality and success rate
+        patterns.sort((a, b) => {
+            const scoreA = (a.quality ?? 0.5) * a.successRate * a.confidence;
+            const scoreB = (b.quality ?? 0.5) * b.successRate * b.confidence;
+            return scoreB - scoreA;
+        });
+        // Convert to PatternMatch format
+        return patterns.slice(0, limit).map(pattern => ({
+            pattern,
+            confidence: pattern.confidence,
+            similarity: 1.0, // Filter-based match is exact
+            reasoning: this.generateReasoning(pattern, {
+                codeType: 'test',
+                framework: criteria.framework,
+                language: criteria.language,
+                keywords: criteria.tags
+            }),
+            applicability: pattern.confidence * pattern.successRate * (pattern.quality ?? 1.0)
+        }));
+    }
+    /**
+     * Calculate similarity score between two patterns
+     * Returns a score between 0-1 indicating how similar the patterns are
+     */
+    calculateSimilarity(pattern1, pattern2) {
+        let score = 0;
+        let weights = 0;
+        // Framework match (25% weight)
+        weights += 0.25;
+        if (pattern1.framework === pattern2.framework) {
+            score += 0.25;
+        }
+        // Language match (20% weight)
+        weights += 0.20;
+        if (pattern1.language === pattern2.language) {
+            score += 0.20;
+        }
+        // Category match (20% weight)
+        weights += 0.20;
+        if (pattern1.category === pattern2.category) {
+            score += 0.20;
+        }
+        // Tag overlap (35% weight)
+        weights += 0.35;
+        const tags1 = new Set(pattern1.metadata.tags);
+        const tags2 = new Set(pattern2.metadata.tags);
+        const intersection = new Set([...tags1].filter(t => tags2.has(t)));
+        const union = new Set([...tags1, ...tags2]);
+        const jaccardSimilarity = union.size > 0 ? intersection.size / union.size : 0;
+        score += jaccardSimilarity * 0.35;
+        return score / weights;
+    }
+    /**
+     * Search patterns by similarity to a reference pattern
+     */
+    async searchSimilarPatterns(referencePattern, limit = 5) {
+        const matches = [];
+        for (const pattern of Array.from(this.patterns.values())) {
+            if (pattern.id === referencePattern.id)
+                continue;
+            const similarity = this.calculateSimilarity(referencePattern, pattern);
+            if (similarity > 0.3) {
+                matches.push({
+                    pattern,
+                    confidence: pattern.confidence,
+                    similarity,
+                    reasoning: `Similar pattern: ${(similarity * 100).toFixed(1)}% match`,
+                    applicability: similarity * pattern.successRate * (pattern.quality ?? 1.0)
+                });
+            }
+        }
+        // Sort by similarity and quality
+        matches.sort((a, b) => b.applicability - a.applicability);
+        return matches.slice(0, limit);
+    }
+    /**
+     * Load patterns from registry file
+     */
+    async loadFromRegistry(registryPath) {
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const registryData = await fs.readFile(registryPath, 'utf-8');
+            const registry = JSON.parse(registryData);
+            if (!registry.patterns || !Array.isArray(registry.patterns)) {
+                throw new Error('Invalid registry format: patterns array not found');
+            }
+            let loadedCount = 0;
+            for (const pattern of registry.patterns) {
+                // Convert date strings to Date objects
+                if (pattern.metadata?.createdAt) {
+                    pattern.metadata.createdAt = new Date(pattern.metadata.createdAt);
+                }
+                if (pattern.metadata?.updatedAt) {
+                    pattern.metadata.updatedAt = new Date(pattern.metadata.updatedAt);
+                }
+                await this.storePattern(pattern);
+                loadedCount++;
+            }
+            return loadedCount;
+        }
+        catch (error) {
+            throw new Error(`Failed to load patterns from registry: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Save patterns to registry file
+     */
+    async saveToRegistry(registryPath, filter) {
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const patterns = this.exportPatterns(filter);
+            const stats = this.getStats();
+            const registry = {
+                version: '1.0.0',
+                lastUpdated: new Date().toISOString(),
+                patterns,
+                statistics: stats
+            };
+            // Ensure directory exists
+            const dir = path.dirname(registryPath);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(registryPath, JSON.stringify(registry, null, 2), 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save patterns to registry: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Export patterns for cross-project sharing
+     */
+    exportPatterns(filter) {
+        let patterns = Array.from(this.patterns.values());
+        if (filter) {
+            patterns = patterns.filter(p => {
+                if (filter.framework && p.framework !== filter.framework)
+                    return false;
+                if (filter.category && p.category !== filter.category)
+                    return false;
+                if (filter.language && p.language !== filter.language)
+                    return false;
+                return true;
+            });
+        }
+        return patterns;
+    }
+    /**
+     * Import patterns from another project
+     */
+    async importPatterns(patterns) {
+        for (const pattern of patterns) {
+            await this.storePattern(pattern);
+        }
+    }
+    /**
+     * Get pattern statistics including quality metrics
+     */
+    getStats() {
+        const patterns = Array.from(this.patterns.values());
+        const stats = {
+            totalPatterns: patterns.length,
+            byFramework: {},
+            byCategory: {},
+            averageQuality: patterns.reduce((sum, p) => sum + (p.quality ?? 0), 0) / patterns.length || 0,
+            averageSuccessRate: patterns.reduce((sum, p) => sum + p.successRate, 0) / patterns.length || 0
+        };
+        for (const pattern of patterns) {
+            stats.byFramework[pattern.framework] = (stats.byFramework[pattern.framework] || 0) + 1;
+            stats.byCategory[pattern.category] = (stats.byCategory[pattern.category] || 0) + 1;
+        }
+        return stats;
+    }
+    /**
+     * Get performance metrics (NEW)
+     * Returns timing statistics for pattern matching operations
+     */
+    getPerformanceMetrics() {
+        const times = this.performanceMetrics.lookupTimes;
+        if (times.length === 0) {
+            return {
+                avgLookupTime: 0,
+                p95LookupTime: 0,
+                p99LookupTime: 0,
+                cacheHitRate: 0,
+                totalLookups: 0
+            };
+        }
+        const sorted = [...times].sort((a, b) => a - b);
+        const avg = times.reduce((sum, t) => sum + t, 0) / times.length;
+        const p95Index = Math.floor(sorted.length * 0.95);
+        const p99Index = Math.floor(sorted.length * 0.99);
+        const totalRequests = this.performanceMetrics.cachehits + this.performanceMetrics.cacheMisses;
+        const cacheHitRate = totalRequests > 0
+            ? (this.performanceMetrics.cachehits / totalRequests) * 100
+            : 0;
+        return {
+            avgLookupTime: parseFloat(avg.toFixed(2)),
+            p95LookupTime: parseFloat(sorted[p95Index].toFixed(2)),
+            p99LookupTime: parseFloat(sorted[p99Index].toFixed(2)),
+            cacheHitRate: parseFloat(cacheHitRate.toFixed(2)),
+            totalLookups: times.length
+        };
+    }
+    /**
+     * Reset performance metrics (for testing)
+     */
+    resetPerformanceMetrics() {
+        this.performanceMetrics = {
+            lookupTimes: [],
+            cachehits: 0,
+            cacheMisses: 0
+        };
+    }
 }
 exports.QEReasoningBank = QEReasoningBank;
 exports.default = QEReasoningBank;