@ruvector/ruvllm 0.2.3 → 2.4.0

package/dist/cjs/benchmarks/embedding-benchmark.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Embedding Quality Benchmark for RuvLTRA Models
+ *
+ * Tests embedding quality for Claude Code use cases:
+ * - Code similarity detection
+ * - Task clustering
+ * - Semantic search accuracy
+ */
+export interface EmbeddingPair {
+    id: string;
+    text1: string;
+    text2: string;
+    similarity: 'high' | 'medium' | 'low' | 'none';
+    category: string;
+}
+export interface EmbeddingResult {
+    pairId: string;
+    expectedSimilarity: string;
+    computedScore: number;
+    correct: boolean;
+    latencyMs: number;
+}
+export interface ClusterTestCase {
+    id: string;
+    items: string[];
+    expectedCluster: string;
+}
+export interface EmbeddingBenchmarkResults {
+    similarityAccuracy: number;
+    similarityByCategory: Record<string, number>;
+    avgSimilarityLatencyMs: number;
+    clusterPurity: number;
+    silhouetteScore: number;
+    searchMRR: number;
+    searchNDCG: number;
+    similarityResults: EmbeddingResult[];
+    totalPairs: number;
+}
+/**
+ * Ground truth similarity pairs for testing
+ * Tests whether embeddings correctly capture semantic similarity
+ */
+export declare const SIMILARITY_TEST_PAIRS: EmbeddingPair[];
+/**
+ * Search relevance test cases
+ * Query + documents with relevance scores
+ */
+export interface SearchTestCase {
+    id: string;
+    query: string;
+    documents: {
+        text: string;
+        relevance: number;
+    }[];
+}
+export declare const SEARCH_TEST_CASES: SearchTestCase[];
+/**
+ * Cluster test cases - items that should cluster together
+ */
+export declare const CLUSTER_TEST_CASES: ClusterTestCase[];
+/**
+ * Check if computed similarity matches expected category
+ */
+export declare function isCorrectSimilarity(expected: 'high' | 'medium' | 'low' | 'none', computed: number): boolean;
+/**
+ * Calculate Mean Reciprocal Rank for search results
+ */
+export declare function calculateMRR(rankings: {
+    relevant: boolean;
+}[][]): number;
+/**
+ * Calculate NDCG for search results
+ */
+export declare function calculateNDCG(results: {
+    relevance: number;
+}[], idealOrder: {
+    relevance: number;
+}[]): number;
+/**
+ * Calculate silhouette score for clustering
+ */
+export declare function calculateSilhouette(embeddings: number[][], labels: number[]): number;
+/**
+ * Run the embedding benchmark
+ */
+export declare function runEmbeddingBenchmark(embedder: (text: string) => number[], similarityFn: (a: number[], b: number[]) => number): EmbeddingBenchmarkResults;
+/**
+ * Format embedding benchmark results for display
+ */
+export declare function formatEmbeddingResults(results: EmbeddingBenchmarkResults): string;
+declare const _default: {
+    SIMILARITY_TEST_PAIRS: EmbeddingPair[];
+    SEARCH_TEST_CASES: SearchTestCase[];
+    CLUSTER_TEST_CASES: ClusterTestCase[];
+    runEmbeddingBenchmark: typeof runEmbeddingBenchmark;
+    formatEmbeddingResults: typeof formatEmbeddingResults;
+    isCorrectSimilarity: typeof isCorrectSimilarity;
+    calculateMRR: typeof calculateMRR;
+    calculateNDCG: typeof calculateNDCG;
+};
+export default _default;
+//# sourceMappingURL=embedding-benchmark.d.ts.map

package/dist/cjs/benchmarks/embedding-benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-benchmark.d.ts","sourceRoot":"","sources":["../../../src/benchmarks/embedding-benchmark.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IAC/C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IAExC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,sBAAsB,EAAE,MAAM,CAAC;IAG/B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IAGxB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IAGnB,iBAAiB,EAAE,eAAe,EAAE,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,EA8ChD,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAClD;AAED,eAAO,MAAM,iBAAiB,EAAE,cAAc,EAwD7C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAAe,EAwD/C,CAAC;AAYF;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,EAC5C,QAAQ,EAAE,MAAM,GACf,OAAO,CAGT;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,EAAE,EAAE,GAClC,MAAM,CASR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,EAChC,UAAU,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,GAClC,MAAM,CAUR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAAE,EAAE,EACtB,MAAM,EAAE,MAAM,EAAE,GACf,MAAM,CA8CR;AAUD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAAE,EACpC,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,GACjD,yBAAyB,CA0G3B;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,yBAAyB,GAAG,MAAM,CAyDjF;;;;;;;;;;;AAED,wBASE"}

package/dist/cjs/benchmarks/embedding-benchmark.js

@@ -0,0 +1,436 @@
+"use strict";
+/**
+ * Embedding Quality Benchmark for RuvLTRA Models
+ *
+ * Tests embedding quality for Claude Code use cases:
+ * - Code similarity detection
+ * - Task clustering
+ * - Semantic search accuracy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLUSTER_TEST_CASES = exports.SEARCH_TEST_CASES = exports.SIMILARITY_TEST_PAIRS = void 0;
+exports.isCorrectSimilarity = isCorrectSimilarity;
+exports.calculateMRR = calculateMRR;
+exports.calculateNDCG = calculateNDCG;
+exports.calculateSilhouette = calculateSilhouette;
+exports.runEmbeddingBenchmark = runEmbeddingBenchmark;
+exports.formatEmbeddingResults = formatEmbeddingResults;
+/**
+ * Ground truth similarity pairs for testing
+ * Tests whether embeddings correctly capture semantic similarity
+ */
+exports.SIMILARITY_TEST_PAIRS = [
+    // === HIGH SIMILARITY (same concept, different wording) ===
+    { id: 'H001', text1: 'implement user authentication', text2: 'create login functionality', similarity: 'high', category: 'code-task' },
+    { id: 'H002', text1: 'write unit tests for the API', text2: 'create test cases for REST endpoints', similarity: 'high', category: 'code-task' },
+    { id: 'H003', text1: 'fix the null pointer exception', text2: 'resolve the NullPointerException bug', similarity: 'high', category: 'debugging' },
+    { id: 'H004', text1: 'optimize database queries', text2: 'improve SQL query performance', similarity: 'high', category: 'performance' },
+    { id: 'H005', text1: 'deploy to production', text2: 'release to prod environment', similarity: 'high', category: 'devops' },
+    { id: 'H006', text1: 'refactor the legacy code', text2: 'restructure old codebase', similarity: 'high', category: 'refactoring' },
+    { id: 'H007', text1: 'add error handling', text2: 'implement exception handling', similarity: 'high', category: 'code-task' },
+    { id: 'H008', text1: 'create REST API endpoint', text2: 'build HTTP API route', similarity: 'high', category: 'code-task' },
+    { id: 'H009', text1: 'check for SQL injection', text2: 'audit for SQLi vulnerabilities', similarity: 'high', category: 'security' },
+    { id: 'H010', text1: 'document the API', text2: 'write API documentation', similarity: 'high', category: 'documentation' },
+    // Code snippets - same functionality
+    { id: 'H011', text1: 'function add(a, b) { return a + b; }', text2: 'const sum = (x, y) => x + y;', similarity: 'high', category: 'code-snippet' },
+    { id: 'H012', text1: 'for (let i = 0; i < arr.length; i++)', text2: 'arr.forEach((item, index) => {})', similarity: 'high', category: 'code-snippet' },
+    { id: 'H013', text1: 'async function fetchData() { await fetch(url); }', text2: 'const getData = async () => { await axios.get(url); }', similarity: 'high', category: 'code-snippet' },
+    // === MEDIUM SIMILARITY (related but different) ===
+    { id: 'M001', text1: 'implement user authentication', text2: 'create user registration', similarity: 'medium', category: 'code-task' },
+    { id: 'M002', text1: 'write unit tests', text2: 'write integration tests', similarity: 'medium', category: 'testing' },
+    { id: 'M003', text1: 'fix the bug in checkout', text2: 'debug the payment flow', similarity: 'medium', category: 'debugging' },
+    { id: 'M004', text1: 'optimize frontend performance', text2: 'improve backend response time', similarity: 'medium', category: 'performance' },
+    { id: 'M005', text1: 'deploy to staging', text2: 'deploy to production', similarity: 'medium', category: 'devops' },
+    { id: 'M006', text1: 'React component', text2: 'Vue component', similarity: 'medium', category: 'code-snippet' },
+    { id: 'M007', text1: 'PostgreSQL query', text2: 'MySQL query', similarity: 'medium', category: 'code-snippet' },
+    { id: 'M008', text1: 'REST API', text2: 'GraphQL API', similarity: 'medium', category: 'code-task' },
+    { id: 'M009', text1: 'Node.js server', text2: 'Python Flask server', similarity: 'medium', category: 'code-snippet' },
+    { id: 'M010', text1: 'add caching layer', text2: 'implement rate limiting', similarity: 'medium', category: 'performance' },
+    // === LOW SIMILARITY (same domain, different task) ===
+    { id: 'L001', text1: 'implement authentication', text2: 'write documentation', similarity: 'low', category: 'code-task' },
+    { id: 'L002', text1: 'fix bug', text2: 'add new feature', similarity: 'low', category: 'code-task' },
+    { id: 'L003', text1: 'optimize query', text2: 'review pull request', similarity: 'low', category: 'mixed' },
+    { id: 'L004', text1: 'deploy application', text2: 'design architecture', similarity: 'low', category: 'mixed' },
+    { id: 'L005', text1: 'frontend React code', text2: 'backend database migration', similarity: 'low', category: 'code-snippet' },
+    { id: 'L006', text1: 'security audit', text2: 'performance benchmark', similarity: 'low', category: 'mixed' },
+    { id: 'L007', text1: 'write unit tests', text2: 'create CI/CD pipeline', similarity: 'low', category: 'mixed' },
+    { id: 'L008', text1: 'CSS styling', text2: 'database schema', similarity: 'low', category: 'code-snippet' },
+    // === NO SIMILARITY (unrelated) ===
+    { id: 'N001', text1: 'implement user login', text2: 'the weather is nice today', similarity: 'none', category: 'unrelated' },
+    { id: 'N002', text1: 'fix JavaScript bug', text2: 'recipe for chocolate cake', similarity: 'none', category: 'unrelated' },
+    { id: 'N003', text1: 'deploy Kubernetes cluster', text2: 'book a flight to Paris', similarity: 'none', category: 'unrelated' },
+    { id: 'N004', text1: 'optimize SQL query', text2: 'learn to play guitar', similarity: 'none', category: 'unrelated' },
+    { id: 'N005', text1: 'const x = 42;', text2: 'roses are red violets are blue', similarity: 'none', category: 'unrelated' },
+];
+exports.SEARCH_TEST_CASES = [
+    {
+        id: 'S001',
+        query: 'how to implement user authentication in Node.js',
+        documents: [
+            { text: 'Implementing JWT authentication in Express.js with passport', relevance: 3 },
+            { text: 'Node.js login system with bcrypt password hashing', relevance: 3 },
+            { text: 'Building a React login form component', relevance: 2 },
+            { text: 'PostgreSQL user table schema design', relevance: 1 },
+            { text: 'How to deploy Docker containers', relevance: 0 },
+        ],
+    },
+    {
+        id: 'S002',
+        query: 'fix memory leak in JavaScript',
+        documents: [
+            { text: 'Debugging memory leaks with Chrome DevTools heap snapshots', relevance: 3 },
+            { text: 'Common causes of memory leaks in Node.js applications', relevance: 3 },
+            { text: 'JavaScript garbage collection explained', relevance: 2 },
+            { text: 'Optimizing React component re-renders', relevance: 1 },
+            { text: 'CSS flexbox layout tutorial', relevance: 0 },
+        ],
+    },
+    {
+        id: 'S003',
+        query: 'database migration best practices',
+        documents: [
+            { text: 'Schema migration strategies for zero-downtime deployments', relevance: 3 },
+            { text: 'Using Prisma migrate for PostgreSQL schema changes', relevance: 3 },
+            { text: 'Database backup and recovery procedures', relevance: 2 },
+            { text: 'SQL query optimization techniques', relevance: 1 },
+            { text: 'React state management with Redux', relevance: 0 },
+        ],
+    },
+    {
+        id: 'S004',
+        query: 'write unit tests for React components',
+        documents: [
+            { text: 'Testing React components with Jest and React Testing Library', relevance: 3 },
+            { text: 'Snapshot testing for UI components', relevance: 3 },
+            { text: 'Mocking API calls in frontend tests', relevance: 2 },
+            { text: 'End-to-end testing with Cypress', relevance: 1 },
+            { text: 'Kubernetes pod configuration', relevance: 0 },
+        ],
+    },
+    {
+        id: 'S005',
+        query: 'optimize API response time',
+        documents: [
+            { text: 'Implementing Redis caching for API endpoints', relevance: 3 },
+            { text: 'Database query optimization with indexes', relevance: 3 },
+            { text: 'Using CDN for static asset delivery', relevance: 2 },
+            { text: 'Load balancing strategies for microservices', relevance: 2 },
+            { text: 'Writing clean JavaScript code', relevance: 0 },
+        ],
+    },
+];
+/**
+ * Cluster test cases - items that should cluster together
+ */
+exports.CLUSTER_TEST_CASES = [
+    {
+        id: 'CL001',
+        expectedCluster: 'authentication',
+        items: [
+            'implement user login',
+            'add JWT token validation',
+            'create password reset flow',
+            'implement OAuth integration',
+            'add two-factor authentication',
+        ],
+    },
+    {
+        id: 'CL002',
+        expectedCluster: 'testing',
+        items: [
+            'write unit tests',
+            'add integration tests',
+            'create E2E test suite',
+            'improve test coverage',
+            'add snapshot tests',
+        ],
+    },
+    {
+        id: 'CL003',
+        expectedCluster: 'database',
+        items: [
+            'optimize SQL queries',
+            'add database indexes',
+            'create migration script',
+            'implement connection pooling',
+            'design schema for users table',
+        ],
+    },
+    {
+        id: 'CL004',
+        expectedCluster: 'frontend',
+        items: [
+            'build React component',
+            'add CSS styling',
+            'implement responsive design',
+            'create form validation',
+            'add loading spinner',
+        ],
+    },
+    {
+        id: 'CL005',
+        expectedCluster: 'devops',
+        items: [
+            'set up CI/CD pipeline',
+            'configure Kubernetes deployment',
+            'create Docker container',
+            'add monitoring alerts',
+            'implement auto-scaling',
+        ],
+    },
+];
+/**
+ * Expected similarity score ranges
+ */
+const SIMILARITY_THRESHOLDS = {
+    high: { min: 0.7, max: 1.0 },
+    medium: { min: 0.4, max: 0.7 },
+    low: { min: 0.2, max: 0.4 },
+    none: { min: 0.0, max: 0.2 },
+};
+/**
+ * Check if computed similarity matches expected category
+ */
+function isCorrectSimilarity(expected, computed) {
+    const threshold = SIMILARITY_THRESHOLDS[expected];
+    return computed >= threshold.min && computed <= threshold.max;
+}
+/**
+ * Calculate Mean Reciprocal Rank for search results
+ */
+function calculateMRR(rankings) {
+    let sumRR = 0;
+    for (const ranking of rankings) {
+        const firstRelevantIdx = ranking.findIndex(r => r.relevant);
+        if (firstRelevantIdx >= 0) {
+            sumRR += 1 / (firstRelevantIdx + 1);
+        }
+    }
+    return sumRR / rankings.length;
+}
+/**
+ * Calculate NDCG for search results
+ */
+function calculateNDCG(results, idealOrder) {
+    const dcg = results.reduce((sum, r, i) => {
+        return sum + (Math.pow(2, r.relevance) - 1) / Math.log2(i + 2);
+    }, 0);
+    const idcg = idealOrder.reduce((sum, r, i) => {
+        return sum + (Math.pow(2, r.relevance) - 1) / Math.log2(i + 2);
+    }, 0);
+    return idcg > 0 ? dcg / idcg : 0;
+}
+/**
+ * Calculate silhouette score for clustering
+ */
+function calculateSilhouette(embeddings, labels) {
+    // Simplified silhouette calculation
+    const n = embeddings.length;
+    if (n < 2)
+        return 0;
+    let totalSilhouette = 0;
+    for (let i = 0; i < n; i++) {
+        const cluster = labels[i];
+        // Calculate mean intra-cluster distance (a)
+        let intraSum = 0;
+        let intraCount = 0;
+        for (let j = 0; j < n; j++) {
+            if (i !== j && labels[j] === cluster) {
+                intraSum += euclideanDistance(embeddings[i], embeddings[j]);
+                intraCount++;
+            }
+        }
+        const a = intraCount > 0 ? intraSum / intraCount : 0;
+        // Calculate min mean inter-cluster distance (b)
+        const otherClusters = [...new Set(labels)].filter(c => c !== cluster);
+        let minInterMean = Infinity;
+        for (const otherCluster of otherClusters) {
+            let interSum = 0;
+            let interCount = 0;
+            for (let j = 0; j < n; j++) {
+                if (labels[j] === otherCluster) {
+                    interSum += euclideanDistance(embeddings[i], embeddings[j]);
+                    interCount++;
+                }
+            }
+            if (interCount > 0) {
+                minInterMean = Math.min(minInterMean, interSum / interCount);
+            }
+        }
+        const b = minInterMean === Infinity ? 0 : minInterMean;
+        // Silhouette for this point
+        const s = Math.max(a, b) > 0 ? (b - a) / Math.max(a, b) : 0;
+        totalSilhouette += s;
+    }
+    return totalSilhouette / n;
+}
+function euclideanDistance(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        sum += Math.pow(a[i] - b[i], 2);
+    }
+    return Math.sqrt(sum);
+}
+/**
+ * Run the embedding benchmark
+ */
+function runEmbeddingBenchmark(embedder, similarityFn) {
+    const similarityResults = [];
+    const latencies = [];
+    // Test similarity pairs
+    for (const pair of exports.SIMILARITY_TEST_PAIRS) {
+        const start = performance.now();
+        const emb1 = embedder(pair.text1);
+        const emb2 = embedder(pair.text2);
+        const score = similarityFn(emb1, emb2);
+        const latencyMs = performance.now() - start;
+        latencies.push(latencyMs);
+        similarityResults.push({
+            pairId: pair.id,
+            expectedSimilarity: pair.similarity,
+            computedScore: score,
+            correct: isCorrectSimilarity(pair.similarity, score),
+            latencyMs,
+        });
+    }
+    // Calculate similarity accuracy
+    const correctSimilarity = similarityResults.filter(r => r.correct).length;
+    const similarityAccuracy = correctSimilarity / similarityResults.length;
+    // Accuracy by category
+    const categories = [...new Set(exports.SIMILARITY_TEST_PAIRS.map(p => p.category))];
+    const similarityByCategory = {};
+    for (const cat of categories) {
+        const catResults = similarityResults.filter((r, i) => exports.SIMILARITY_TEST_PAIRS[i].category === cat);
+        similarityByCategory[cat] = catResults.filter(r => r.correct).length / catResults.length;
+    }
+    // Test search quality (MRR and NDCG)
+    const searchRankings = [];
+    let totalNDCG = 0;
+    for (const testCase of exports.SEARCH_TEST_CASES) {
+        const queryEmb = embedder(testCase.query);
+        const docScores = testCase.documents.map(doc => ({
+            ...doc,
+            score: similarityFn(queryEmb, embedder(doc.text)),
+        }));
+        // Sort by computed score
+        const sorted = [...docScores].sort((a, b) => b.score - a.score);
+        // For MRR
+        searchRankings.push(sorted.map(d => ({ relevant: d.relevance >= 2 })));
+        // For NDCG
+        const idealOrder = [...testCase.documents].sort((a, b) => b.relevance - a.relevance);
+        totalNDCG += calculateNDCG(sorted, idealOrder);
+    }
+    const searchMRR = calculateMRR(searchRankings);
+    const searchNDCG = totalNDCG / exports.SEARCH_TEST_CASES.length;
+    // Test clustering
+    const allClusterItems = [];
+    exports.CLUSTER_TEST_CASES.forEach((tc, clusterIdx) => {
+        tc.items.forEach(item => {
+            allClusterItems.push({ text: item, cluster: clusterIdx });
+        });
+    });
+    const clusterEmbeddings = allClusterItems.map(item => embedder(item.text));
+    const clusterLabels = allClusterItems.map(item => item.cluster);
+    const silhouetteScore = calculateSilhouette(clusterEmbeddings, clusterLabels);
+    // Calculate cluster purity (how well items stay in their expected cluster)
+    // Using simple nearest-neighbor classification
+    let correctCluster = 0;
+    for (let i = 0; i < clusterEmbeddings.length; i++) {
+        let nearestIdx = -1;
+        let nearestDist = Infinity;
+        for (let j = 0; j < clusterEmbeddings.length; j++) {
+            if (i !== j) {
+                const dist = euclideanDistance(clusterEmbeddings[i], clusterEmbeddings[j]);
+                if (dist < nearestDist) {
+                    nearestDist = dist;
+                    nearestIdx = j;
+                }
+            }
+        }
+        if (nearestIdx >= 0 && clusterLabels[nearestIdx] === clusterLabels[i]) {
+            correctCluster++;
+        }
+    }
+    const clusterPurity = correctCluster / clusterEmbeddings.length;
+    return {
+        similarityAccuracy,
+        similarityByCategory,
+        avgSimilarityLatencyMs: latencies.reduce((a, b) => a + b, 0) / latencies.length,
+        clusterPurity,
+        silhouetteScore,
+        searchMRR,
+        searchNDCG,
+        similarityResults,
+        totalPairs: similarityResults.length,
+    };
+}
+/**
+ * Format embedding benchmark results for display
+ */
+function formatEmbeddingResults(results) {
+    const lines = [];
+    lines.push('');
+    lines.push('╔══════════════════════════════════════════════════════════════╗');
+    lines.push('║             EMBEDDING BENCHMARK RESULTS                      ║');
+    lines.push('╠══════════════════════════════════════════════════════════════╣');
+    lines.push(`║  Similarity Detection: ${(results.similarityAccuracy * 100).toFixed(1)}%`.padEnd(63) + '║');
+    lines.push('╠══════════════════════════════════════════════════════════════╣');
+    lines.push('║  By Category:                                                ║');
+    for (const [cat, acc] of Object.entries(results.similarityByCategory).sort((a, b) => b[1] - a[1])) {
+        const bar = '█'.repeat(Math.floor(acc * 20)) + '░'.repeat(20 - Math.floor(acc * 20));
+        lines.push(`║    ${cat.padEnd(18)} [${bar}] ${(acc * 100).toFixed(0).padStart(3)}%  ║`);
+    }
+    lines.push('╠══════════════════════════════════════════════════════════════╣');
+    lines.push('║  Clustering Quality:                                         ║');
+    lines.push(`║    Cluster Purity:    ${(results.clusterPurity * 100).toFixed(1)}%`.padEnd(63) + '║');
+    lines.push(`║    Silhouette Score:  ${results.silhouetteScore.toFixed(3)}`.padEnd(63) + '║');
+    lines.push('╠══════════════════════════════════════════════════════════════╣');
+    lines.push('║  Search Quality:                                             ║');
+    lines.push(`║    MRR (Mean Reciprocal Rank):  ${results.searchMRR.toFixed(3)}`.padEnd(63) + '║');
+    lines.push(`║    NDCG:                        ${results.searchNDCG.toFixed(3)}`.padEnd(63) + '║');
+    lines.push('╠══════════════════════════════════════════════════════════════╣');
+    lines.push(`║  Avg Latency: ${results.avgSimilarityLatencyMs.toFixed(2)}ms per pair`.padEnd(63) + '║');
+    lines.push('╚══════════════════════════════════════════════════════════════╝');
+    // Quality assessment
+    lines.push('');
+    lines.push('Quality Assessment:');
+    if (results.similarityAccuracy >= 0.8) {
+        lines.push('  ✓ Similarity detection: EXCELLENT (≥80%)');
+    }
+    else if (results.similarityAccuracy >= 0.6) {
+        lines.push('  ~ Similarity detection: GOOD (60-80%)');
+    }
+    else {
+        lines.push('  ✗ Similarity detection: NEEDS IMPROVEMENT (<60%)');
+    }
+    if (results.searchMRR >= 0.8) {
+        lines.push('  ✓ Search quality (MRR): EXCELLENT (≥0.8)');
+    }
+    else if (results.searchMRR >= 0.5) {
+        lines.push('  ~ Search quality (MRR): ACCEPTABLE (0.5-0.8)');
+    }
+    else {
+        lines.push('  ✗ Search quality (MRR): NEEDS IMPROVEMENT (<0.5)');
+    }
+    if (results.clusterPurity >= 0.8) {
+        lines.push('  ✓ Clustering: EXCELLENT (≥80% purity)');
+    }
+    else if (results.clusterPurity >= 0.6) {
+        lines.push('  ~ Clustering: ACCEPTABLE (60-80% purity)');
+    }
+    else {
+        lines.push('  ✗ Clustering: NEEDS IMPROVEMENT (<60% purity)');
+    }
+    return lines.join('\n');
+}
+exports.default = {
+    SIMILARITY_TEST_PAIRS: exports.SIMILARITY_TEST_PAIRS,
+    SEARCH_TEST_CASES: exports.SEARCH_TEST_CASES,
+    CLUSTER_TEST_CASES: exports.CLUSTER_TEST_CASES,
+    runEmbeddingBenchmark,
+    formatEmbeddingResults,
+    isCorrectSimilarity,
+    calculateMRR,
+    calculateNDCG,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"embedding-benchmark.js","sourceRoot":"","sources":["../../../src/benchmarks/embedding-benchmark.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Embedding Quality Benchmark for RuvLTRA Models\n *\n * Tests embedding quality for Claude Code use cases:\n * - Code similarity detection\n * - Task clustering\n * - Semantic search accuracy\n */\n\nexport interface EmbeddingPair {\n  id: string;\n  text1: string;\n  text2: string;\n  similarity: 'high' | 'medium' | 'low' | 'none';\n  category: string;\n}\n\nexport interface EmbeddingResult {\n  pairId: string;\n  expectedSimilarity: string;\n  computedScore: number;\n  correct: boolean;\n  latencyMs: number;\n}\n\nexport interface ClusterTestCase {\n  id: string;\n  items: string[];\n  expectedCluster: string;\n}\n\nexport interface EmbeddingBenchmarkResults {\n  // Similarity detection\n  similarityAccuracy: number;\n  similarityByCategory: Record<string, number>;\n  avgSimilarityLatencyMs: number;\n\n  // Clustering quality\n  clusterPurity: number;\n  silhouetteScore: number;\n\n  // Search quality\n  searchMRR: number; // Mean Reciprocal Rank\n  searchNDCG: number; // Normalized Discounted Cumulative Gain\n\n  // Details\n  similarityResults: EmbeddingResult[];\n  totalPairs: number;\n}\n\n/**\n * Ground truth similarity pairs for testing\n * Tests whether embeddings correctly capture semantic similarity\n */\nexport const SIMILARITY_TEST_PAIRS: EmbeddingPair[] = [\n  // === HIGH SIMILARITY (same concept, different wording) ===\n  { id: 'H001', text1: 'implement user authentication', text2: 'create login functionality', similarity: 'high', category: 'code-task' },\n  { id: 'H002', text1: 'write unit tests for the API', text2: 'create test cases for REST endpoints', similarity: 'high', category: 'code-task' },\n  { id: 'H003', text1: 'fix the null pointer exception', text2: 'resolve the NullPointerException bug', similarity: 'high', category: 'debugging' },\n  { id: 'H004', text1: 'optimize database queries', text2: 'improve SQL query performance', similarity: 'high', category: 'performance' },\n  { id: 'H005', text1: 'deploy to production', text2: 'release to prod environment', similarity: 'high', category: 'devops' },\n  { id: 'H006', text1: 'refactor the legacy code', text2: 'restructure old codebase', similarity: 'high', category: 'refactoring' },\n  { id: 'H007', text1: 'add error handling', text2: 'implement exception handling', similarity: 'high', category: 'code-task' },\n  { id: 'H008', text1: 'create REST API endpoint', text2: 'build HTTP API route', similarity: 'high', category: 'code-task' },\n  { id: 'H009', text1: 'check for SQL injection', text2: 'audit for SQLi vulnerabilities', similarity: 'high', category: 'security' },\n  { id: 'H010', text1: 'document the API', text2: 'write API documentation', similarity: 'high', category: 'documentation' },\n\n  // Code snippets - same functionality\n  { id: 'H011', text1: 'function add(a, b) { return a + b; }', text2: 'const sum = (x, y) => x + y;', similarity: 'high', category: 'code-snippet' },\n  { id: 'H012', text1: 'for (let i = 0; i < arr.length; i++)', text2: 'arr.forEach((item, index) => {})', similarity: 'high', category: 'code-snippet' },\n  { id: 'H013', text1: 'async function fetchData() { await fetch(url); }', text2: 'const getData = async () => { await axios.get(url); }', similarity: 'high', category: 'code-snippet' },\n\n  // === MEDIUM SIMILARITY (related but different) ===\n  { id: 'M001', text1: 'implement user authentication', text2: 'create user registration', similarity: 'medium', category: 'code-task' },\n  { id: 'M002', text1: 'write unit tests', text2: 'write integration tests', similarity: 'medium', category: 'testing' },\n  { id: 'M003', text1: 'fix the bug in checkout', text2: 'debug the payment flow', similarity: 'medium', category: 'debugging' },\n  { id: 'M004', text1: 'optimize frontend performance', text2: 'improve backend response time', similarity: 'medium', category: 'performance' },\n  { id: 'M005', text1: 'deploy to staging', text2: 'deploy to production', similarity: 'medium', category: 'devops' },\n  { id: 'M006', text1: 'React component', text2: 'Vue component', similarity: 'medium', category: 'code-snippet' },\n  { id: 'M007', text1: 'PostgreSQL query', text2: 'MySQL query', similarity: 'medium', category: 'code-snippet' },\n  { id: 'M008', text1: 'REST API', text2: 'GraphQL API', similarity: 'medium', category: 'code-task' },\n  { id: 'M009', text1: 'Node.js server', text2: 'Python Flask server', similarity: 'medium', category: 'code-snippet' },\n  { id: 'M010', text1: 'add caching layer', text2: 'implement rate limiting', similarity: 'medium', category: 'performance' },\n\n  // === LOW SIMILARITY (same domain, different task) ===\n  { id: 'L001', text1: 'implement authentication', text2: 'write documentation', similarity: 'low', category: 'code-task' },\n  { id: 'L002', text1: 'fix bug', text2: 'add new feature', similarity: 'low', category: 'code-task' },\n  { id: 'L003', text1: 'optimize query', text2: 'review pull request', similarity: 'low', category: 'mixed' },\n  { id: 'L004', text1: 'deploy application', text2: 'design architecture', similarity: 'low', category: 'mixed' },\n  { id: 'L005', text1: 'frontend React code', text2: 'backend database migration', similarity: 'low', category: 'code-snippet' },\n  { id: 'L006', text1: 'security audit', text2: 'performance benchmark', similarity: 'low', category: 'mixed' },\n  { id: 'L007', text1: 'write unit tests', text2: 'create CI/CD pipeline', similarity: 'low', category: 'mixed' },\n  { id: 'L008', text1: 'CSS styling', text2: 'database schema', similarity: 'low', category: 'code-snippet' },\n\n  // === NO SIMILARITY (unrelated) ===\n  { id: 'N001', text1: 'implement user login', text2: 'the weather is nice today', similarity: 'none', category: 'unrelated' },\n  { id: 'N002', text1: 'fix JavaScript bug', text2: 'recipe for chocolate cake', similarity: 'none', category: 'unrelated' },\n  { id: 'N003', text1: 'deploy Kubernetes cluster', text2: 'book a flight to Paris', similarity: 'none', category: 'unrelated' },\n  { id: 'N004', text1: 'optimize SQL query', text2: 'learn to play guitar', similarity: 'none', category: 'unrelated' },\n  { id: 'N005', text1: 'const x = 42;', text2: 'roses are red violets are blue', similarity: 'none', category: 'unrelated' },\n];\n\n/**\n * Search relevance test cases\n * Query + documents with relevance scores\n */\nexport interface SearchTestCase {\n  id: string;\n  query: string;\n  documents: { text: string; relevance: number }[]; // relevance: 0-3 (0=irrelevant, 3=highly relevant)\n}\n\nexport const SEARCH_TEST_CASES: SearchTestCase[] = [\n  {\n    id: 'S001',\n    query: 'how to implement user authentication in Node.js',\n    documents: [\n      { text: 'Implementing JWT authentication in Express.js with passport', relevance: 3 },\n      { text: 'Node.js login system with bcrypt password hashing', relevance: 3 },\n      { text: 'Building a React login form component', relevance: 2 },\n      { text: 'PostgreSQL user table schema design', relevance: 1 },\n      { text: 'How to deploy Docker containers', relevance: 0 },\n    ],\n  },\n  {\n    id: 'S002',\n    query: 'fix memory leak in JavaScript',\n    documents: [\n      { text: 'Debugging memory leaks with Chrome DevTools heap snapshots', relevance: 3 },\n      { text: 'Common causes of memory leaks in Node.js applications', relevance: 3 },\n      { text: 'JavaScript garbage collection explained', relevance: 2 },\n      { text: 'Optimizing React component re-renders', relevance: 1 },\n      { text: 'CSS flexbox layout tutorial', relevance: 0 },\n    ],\n  },\n  {\n    id: 'S003',\n    query: 'database migration best practices',\n    documents: [\n      { text: 'Schema migration strategies for zero-downtime deployments', relevance: 3 },\n      { text: 'Using Prisma migrate for PostgreSQL schema changes', relevance: 3 },\n      { text: 'Database backup and recovery procedures', relevance: 2 },\n      { text: 'SQL query optimization techniques', relevance: 1 },\n      { text: 'React state management with Redux', relevance: 0 },\n    ],\n  },\n  {\n    id: 'S004',\n    query: 'write unit tests for React components',\n    documents: [\n      { text: 'Testing React components with Jest and React Testing Library', relevance: 3 },\n      { text: 'Snapshot testing for UI components', relevance: 3 },\n      { text: 'Mocking API calls in frontend tests', relevance: 2 },\n      { text: 'End-to-end testing with Cypress', relevance: 1 },\n      { text: 'Kubernetes pod configuration', relevance: 0 },\n    ],\n  },\n  {\n    id: 'S005',\n    query: 'optimize API response time',\n    documents: [\n      { text: 'Implementing Redis caching for API endpoints', relevance: 3 },\n      { text: 'Database query optimization with indexes', relevance: 3 },\n      { text: 'Using CDN for static asset delivery', relevance: 2 },\n      { text: 'Load balancing strategies for microservices', relevance: 2 },\n      { text: 'Writing clean JavaScript code', relevance: 0 },\n    ],\n  },\n];\n\n/**\n * Cluster test cases - items that should cluster together\n */\nexport const CLUSTER_TEST_CASES: ClusterTestCase[] = [\n  {\n    id: 'CL001',\n    expectedCluster: 'authentication',\n    items: [\n      'implement user login',\n      'add JWT token validation',\n      'create password reset flow',\n      'implement OAuth integration',\n      'add two-factor authentication',\n    ],\n  },\n  {\n    id: 'CL002',\n    expectedCluster: 'testing',\n    items: [\n      'write unit tests',\n      'add integration tests',\n      'create E2E test suite',\n      'improve test coverage',\n      'add snapshot tests',\n    ],\n  },\n  {\n    id: 'CL003',\n    expectedCluster: 'database',\n    items: [\n      'optimize SQL queries',\n      'add database indexes',\n      'create migration script',\n      'implement connection pooling',\n      'design schema for users table',\n    ],\n  },\n  {\n    id: 'CL004',\n    expectedCluster: 'frontend',\n    items: [\n      'build React component',\n      'add CSS styling',\n      'implement responsive design',\n      'create form validation',\n      'add loading spinner',\n    ],\n  },\n  {\n    id: 'CL005',\n    expectedCluster: 'devops',\n    items: [\n      'set up CI/CD pipeline',\n      'configure Kubernetes deployment',\n      'create Docker container',\n      'add monitoring alerts',\n      'implement auto-scaling',\n    ],\n  },\n];\n\n/**\n * Expected similarity score ranges\n */\nconst SIMILARITY_THRESHOLDS = {\n  high: { min: 0.7, max: 1.0 },\n  medium: { min: 0.4, max: 0.7 },\n  low: { min: 0.2, max: 0.4 },\n  none: { min: 0.0, max: 0.2 },\n};\n\n/**\n * Check if computed similarity matches expected category\n */\nexport function isCorrectSimilarity(\n  expected: 'high' | 'medium' | 'low' | 'none',\n  computed: number\n): boolean {\n  const threshold = SIMILARITY_THRESHOLDS[expected];\n  return computed >= threshold.min && computed <= threshold.max;\n}\n\n/**\n * Calculate Mean Reciprocal Rank for search results\n */\nexport function calculateMRR(\n  rankings: { relevant: boolean }[][]\n): number {\n  let sumRR = 0;\n  for (const ranking of rankings) {\n    const firstRelevantIdx = ranking.findIndex(r => r.relevant);\n    if (firstRelevantIdx >= 0) {\n      sumRR += 1 / (firstRelevantIdx + 1);\n    }\n  }\n  return sumRR / rankings.length;\n}\n\n/**\n * Calculate NDCG for search results\n */\nexport function calculateNDCG(\n  results: { relevance: number }[],\n  idealOrder: { relevance: number }[]\n): number {\n  const dcg = results.reduce((sum, r, i) => {\n    return sum + (Math.pow(2, r.relevance) - 1) / Math.log2(i + 2);\n  }, 0);\n\n  const idcg = idealOrder.reduce((sum, r, i) => {\n    return sum + (Math.pow(2, r.relevance) - 1) / Math.log2(i + 2);\n  }, 0);\n\n  return idcg > 0 ? dcg / idcg : 0;\n}\n\n/**\n * Calculate silhouette score for clustering\n */\nexport function calculateSilhouette(\n  embeddings: number[][],\n  labels: number[]\n): number {\n  // Simplified silhouette calculation\n  const n = embeddings.length;\n  if (n < 2) return 0;\n\n  let totalSilhouette = 0;\n\n  for (let i = 0; i < n; i++) {\n    const cluster = labels[i];\n\n    // Calculate mean intra-cluster distance (a)\n    let intraSum = 0;\n    let intraCount = 0;\n    for (let j = 0; j < n; j++) {\n      if (i !== j && labels[j] === cluster) {\n        intraSum += euclideanDistance(embeddings[i], embeddings[j]);\n        intraCount++;\n      }\n    }\n    const a = intraCount > 0 ? intraSum / intraCount : 0;\n\n    // Calculate min mean inter-cluster distance (b)\n    const otherClusters = [...new Set(labels)].filter(c => c !== cluster);\n    let minInterMean = Infinity;\n\n    for (const otherCluster of otherClusters) {\n      let interSum = 0;\n      let interCount = 0;\n      for (let j = 0; j < n; j++) {\n        if (labels[j] === otherCluster) {\n          interSum += euclideanDistance(embeddings[i], embeddings[j]);\n          interCount++;\n        }\n      }\n      if (interCount > 0) {\n        minInterMean = Math.min(minInterMean, interSum / interCount);\n      }\n    }\n    const b = minInterMean === Infinity ? 0 : minInterMean;\n\n    // Silhouette for this point\n    const s = Math.max(a, b) > 0 ? (b - a) / Math.max(a, b) : 0;\n    totalSilhouette += s;\n  }\n\n  return totalSilhouette / n;\n}\n\nfunction euclideanDistance(a: number[], b: number[]): number {\n  let sum = 0;\n  for (let i = 0; i < a.length; i++) {\n    sum += Math.pow(a[i] - b[i], 2);\n  }\n  return Math.sqrt(sum);\n}\n\n/**\n * Run the embedding benchmark\n */\nexport function runEmbeddingBenchmark(\n  embedder: (text: string) => number[],\n  similarityFn: (a: number[], b: number[]) => number\n): EmbeddingBenchmarkResults {\n  const similarityResults: EmbeddingResult[] = [];\n  const latencies: number[] = [];\n\n  // Test similarity pairs\n  for (const pair of SIMILARITY_TEST_PAIRS) {\n    const start = performance.now();\n    const emb1 = embedder(pair.text1);\n    const emb2 = embedder(pair.text2);\n    const score = similarityFn(emb1, emb2);\n    const latencyMs = performance.now() - start;\n\n    latencies.push(latencyMs);\n\n    similarityResults.push({\n      pairId: pair.id,\n      expectedSimilarity: pair.similarity,\n      computedScore: score,\n      correct: isCorrectSimilarity(pair.similarity, score),\n      latencyMs,\n    });\n  }\n\n  // Calculate similarity accuracy\n  const correctSimilarity = similarityResults.filter(r => r.correct).length;\n  const similarityAccuracy = correctSimilarity / similarityResults.length;\n\n  // Accuracy by category\n  const categories = [...new Set(SIMILARITY_TEST_PAIRS.map(p => p.category))];\n  const similarityByCategory: Record<string, number> = {};\n  for (const cat of categories) {\n    const catResults = similarityResults.filter(\n      (r, i) => SIMILARITY_TEST_PAIRS[i].category === cat\n    );\n    similarityByCategory[cat] = catResults.filter(r => r.correct).length / catResults.length;\n  }\n\n  // Test search quality (MRR and NDCG)\n  const searchRankings: { relevant: boolean }[][] = [];\n  let totalNDCG = 0;\n\n  for (const testCase of SEARCH_TEST_CASES) {\n    const queryEmb = embedder(testCase.query);\n    const docScores = testCase.documents.map(doc => ({\n      ...doc,\n      score: similarityFn(queryEmb, embedder(doc.text)),\n    }));\n\n    // Sort by computed score\n    const sorted = [...docScores].sort((a, b) => b.score - a.score);\n\n    // For MRR\n    searchRankings.push(sorted.map(d => ({ relevant: d.relevance >= 2 })));\n\n    // For NDCG\n    const idealOrder = [...testCase.documents].sort((a, b) => b.relevance - a.relevance);\n    totalNDCG += calculateNDCG(sorted, idealOrder);\n  }\n\n  const searchMRR = calculateMRR(searchRankings);\n  const searchNDCG = totalNDCG / SEARCH_TEST_CASES.length;\n\n  // Test clustering\n  const allClusterItems: { text: string; cluster: number }[] = [];\n  CLUSTER_TEST_CASES.forEach((tc, clusterIdx) => {\n    tc.items.forEach(item => {\n      allClusterItems.push({ text: item, cluster: clusterIdx });\n    });\n  });\n\n  const clusterEmbeddings = allClusterItems.map(item => embedder(item.text));\n  const clusterLabels = allClusterItems.map(item => item.cluster);\n  const silhouetteScore = calculateSilhouette(clusterEmbeddings, clusterLabels);\n\n  // Calculate cluster purity (how well items stay in their expected cluster)\n  // Using simple nearest-neighbor classification\n  let correctCluster = 0;\n  for (let i = 0; i < clusterEmbeddings.length; i++) {\n    let nearestIdx = -1;\n    let nearestDist = Infinity;\n    for (let j = 0; j < clusterEmbeddings.length; j++) {\n      if (i !== j) {\n        const dist = euclideanDistance(clusterEmbeddings[i], clusterEmbeddings[j]);\n        if (dist < nearestDist) {\n          nearestDist = dist;\n          nearestIdx = j;\n        }\n      }\n    }\n    if (nearestIdx >= 0 && clusterLabels[nearestIdx] === clusterLabels[i]) {\n      correctCluster++;\n    }\n  }\n  const clusterPurity = correctCluster / clusterEmbeddings.length;\n\n  return {\n    similarityAccuracy,\n    similarityByCategory,\n    avgSimilarityLatencyMs: latencies.reduce((a, b) => a + b, 0) / latencies.length,\n    clusterPurity,\n    silhouetteScore,\n    searchMRR,\n    searchNDCG,\n    similarityResults,\n    totalPairs: similarityResults.length,\n  };\n}\n\n/**\n * Format embedding benchmark results for display\n */\nexport function formatEmbeddingResults(results: EmbeddingBenchmarkResults): string {\n  const lines: string[] = [];\n\n  lines.push('');\n  lines.push('╔══════════════════════════════════════════════════════════════╗');\n  lines.push('║             EMBEDDING BENCHMARK RESULTS                      ║');\n  lines.push('╠══════════════════════════════════════════════════════════════╣');\n  lines.push(`║  Similarity Detection: ${(results.similarityAccuracy * 100).toFixed(1)}%`.padEnd(63) + '║');\n  lines.push('╠══════════════════════════════════════════════════════════════╣');\n  lines.push('║  By Category:                                                ║');\n\n  for (const [cat, acc] of Object.entries(results.similarityByCategory).sort((a, b) => b[1] - a[1])) {\n    const bar = '█'.repeat(Math.floor(acc * 20)) + '░'.repeat(20 - Math.floor(acc * 20));\n    lines.push(`║    ${cat.padEnd(18)} [${bar}] ${(acc * 100).toFixed(0).padStart(3)}%  ║`);\n  }\n\n  lines.push('╠══════════════════════════════════════════════════════════════╣');\n  lines.push('║  Clustering Quality:                                         ║');\n  lines.push(`║    Cluster Purity:    ${(results.clusterPurity * 100).toFixed(1)}%`.padEnd(63) + '║');\n  lines.push(`║    Silhouette Score:  ${results.silhouetteScore.toFixed(3)}`.padEnd(63) + '║');\n  lines.push('╠══════════════════════════════════════════════════════════════╣');\n  lines.push('║  Search Quality:                                             ║');\n  lines.push(`║    MRR (Mean Reciprocal Rank):  ${results.searchMRR.toFixed(3)}`.padEnd(63) + '║');\n  lines.push(`║    NDCG:                        ${results.searchNDCG.toFixed(3)}`.padEnd(63) + '║');\n  lines.push('╠══════════════════════════════════════════════════════════════╣');\n  lines.push(`║  Avg Latency: ${results.avgSimilarityLatencyMs.toFixed(2)}ms per pair`.padEnd(63) + '║');\n  lines.push('╚══════════════════════════════════════════════════════════════╝');\n\n  // Quality assessment\n  lines.push('');\n  lines.push('Quality Assessment:');\n\n  if (results.similarityAccuracy >= 0.8) {\n    lines.push('  ✓ Similarity detection: EXCELLENT (≥80%)');\n  } else if (results.similarityAccuracy >= 0.6) {\n    lines.push('  ~ Similarity detection: GOOD (60-80%)');\n  } else {\n    lines.push('  ✗ Similarity detection: NEEDS IMPROVEMENT (<60%)');\n  }\n\n  if (results.searchMRR >= 0.8) {\n    lines.push('  ✓ Search quality (MRR): EXCELLENT (≥0.8)');\n  } else if (results.searchMRR >= 0.5) {\n    lines.push('  ~ Search quality (MRR): ACCEPTABLE (0.5-0.8)');\n  } else {\n    lines.push('  ✗ Search quality (MRR): NEEDS IMPROVEMENT (<0.5)');\n  }\n\n  if (results.clusterPurity >= 0.8) {\n    lines.push('  ✓ Clustering: EXCELLENT (≥80% purity)');\n  } else if (results.clusterPurity >= 0.6) {\n    lines.push('  ~ Clustering: ACCEPTABLE (60-80% purity)');\n  } else {\n    lines.push('  ✗ Clustering: NEEDS IMPROVEMENT (<60% purity)');\n  }\n\n  return lines.join('\\n');\n}\n\nexport default {\n  SIMILARITY_TEST_PAIRS,\n  SEARCH_TEST_CASES,\n  CLUSTER_TEST_CASES,\n  runEmbeddingBenchmark,\n  formatEmbeddingResults,\n  isCorrectSimilarity,\n  calculateMRR,\n  calculateNDCG,\n};\n"]}