@agentic-qe/v3 3.0.0-alpha.5 → 3.0.0-alpha.7

package/tests/unit/domains/coverage-analysis/coverage-embedder.test.ts

@@ -1,298 +0,0 @@
-/**
- * Agentic QE v3 - Coverage Embedder Tests
- *
- * Tests for the coverage embedder that converts coverage data into
- * dense vector embeddings for HNSW-based similarity search.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  CoverageEmbedder,
-  createCoverageEmbedder,
-  DEFAULT_EMBEDDER_CONFIG,
-  type CoverageQuery,
-} from '../../../../src/domains/coverage-analysis/services/coverage-embedder';
-import type { FileCoverage, CoverageGap } from '../../../../src/domains/coverage-analysis/interfaces';
-
-describe('CoverageEmbedder', () => {
-  let embedder: CoverageEmbedder;
-
-  beforeEach(() => {
-    embedder = createCoverageEmbedder();
-  });
-
-  describe('embedFileCoverage', () => {
-    it('should create embedding with correct dimensions', () => {
-      const coverage = createTestFileCoverage('src/test.ts', 80, 70, 90, 85);
-      const result = embedder.embedFileCoverage(coverage);
-
-      expect(result.vector).toHaveLength(DEFAULT_EMBEDDER_CONFIG.dimensions);
-    });
-
-    it('should create normalized embedding', () => {
-      const coverage = createTestFileCoverage('src/test.ts', 80, 70, 90, 85);
-      const result = embedder.embedFileCoverage(coverage);
-
-      // L2 normalized vector should have magnitude close to 1
-      const magnitude = Math.sqrt(
-        result.vector.reduce((sum, v) => sum + v * v, 0)
-      );
-      expect(magnitude).toBeCloseTo(1, 1);
-    });
-
-    it('should include accurate metadata', () => {
-      const coverage = createTestFileCoverage('src/test.ts', 80, 70, 90, 85);
-      coverage.uncoveredLines = [10, 11, 12, 13, 14];
-      coverage.uncoveredBranches = [20, 21];
-
-      const result = embedder.embedFileCoverage(coverage);
-
-      expect(result.metadata.filePath).toBe('src/test.ts');
-      expect(result.metadata.lineCoverage).toBeCloseTo(80, 1);
-      expect(result.metadata.branchCoverage).toBeCloseTo(70, 1);
-      expect(result.metadata.functionCoverage).toBeCloseTo(90, 1);
-      expect(result.metadata.statementCoverage).toBeCloseTo(85, 1);
-      expect(result.metadata.uncoveredLineCount).toBe(5);
-      expect(result.metadata.uncoveredBranchCount).toBe(2);
-    });
-
-    it('should calculate risk score based on coverage gaps', () => {
-      // Low coverage = high risk
-      const lowCoverage = createTestFileCoverage('src/low.ts', 30, 20, 40, 35);
-      const lowResult = embedder.embedFileCoverage(lowCoverage);
-
-      // High coverage = low risk
-      const highCoverage = createTestFileCoverage('src/high.ts', 95, 90, 98, 96);
-      const highResult = embedder.embedFileCoverage(highCoverage);
-
-      expect(lowResult.metadata.riskScore).toBeGreaterThan(highResult.metadata.riskScore);
-    });
-
-    it('should have higher confidence for files with more data', () => {
-      // File with all coverage types
-      const fullCoverage = createTestFileCoverage('src/full.ts', 80, 70, 90, 85);
-      fullCoverage.lines.total = 100;
-      fullCoverage.branches.total = 50;
-      fullCoverage.functions.total = 20;
-      fullCoverage.statements.total = 120;
-
-      const fullResult = embedder.embedFileCoverage(fullCoverage);
-
-      // File with minimal data
-      const minCoverage = createTestFileCoverage('src/min.ts', 80, 70, 90, 85);
-      minCoverage.lines.total = 0;
-      minCoverage.branches.total = 0;
-      minCoverage.functions.total = 0;
-      minCoverage.statements.total = 0;
-
-      const minResult = embedder.embedFileCoverage(minCoverage);
-
-      expect(fullResult.confidence).toBeGreaterThan(minResult.confidence);
-    });
-
-    it('should create similar embeddings for similar coverage', () => {
-      const coverage1 = createTestFileCoverage('src/a.ts', 75, 65, 80, 70);
-      const coverage2 = createTestFileCoverage('src/b.ts', 76, 66, 81, 71);
-      const coverage3 = createTestFileCoverage('src/c.ts', 20, 15, 25, 18);
-
-      const result1 = embedder.embedFileCoverage(coverage1);
-      const result2 = embedder.embedFileCoverage(coverage2);
-      const result3 = embedder.embedFileCoverage(coverage3);
-
-      // Coverage1 and coverage2 should be more similar than coverage1 and coverage3
-      const similarity12 = cosineSimilarity(result1.vector, result2.vector);
-      const similarity13 = cosineSimilarity(result1.vector, result3.vector);
-
-      expect(similarity12).toBeGreaterThan(similarity13);
-    });
-  });
-
-  describe('embedCoverageGap', () => {
-    it('should create embedding from coverage gap', () => {
-      const gap: CoverageGap = {
-        id: 'gap-123',
-        file: 'src/test.ts',
-        lines: [10, 11, 12, 13, 14],
-        branches: [20, 21],
-        riskScore: 0.7,
-        severity: 'high',
-        recommendation: 'Add tests',
-      };
-
-      const result = embedder.embedCoverageGap(gap);
-
-      expect(result.vector).toHaveLength(DEFAULT_EMBEDDER_CONFIG.dimensions);
-      expect(result.metadata.filePath).toBe('src/test.ts');
-      expect(result.metadata.uncoveredLineCount).toBe(5);
-      expect(result.metadata.uncoveredBranchCount).toBe(2);
-      expect(result.metadata.riskScore).toBe(0.7);
-    });
-
-    it('should encode gap severity in embedding', () => {
-      const criticalGap: CoverageGap = {
-        id: 'gap-critical',
-        file: 'src/critical.ts',
-        lines: Array.from({ length: 50 }, (_, i) => i + 1),
-        branches: Array.from({ length: 10 }, (_, i) => i + 1),
-        riskScore: 0.9,
-        severity: 'critical',
-        recommendation: 'Critical',
-      };
-
-      const lowGap: CoverageGap = {
-        id: 'gap-low',
-        file: 'src/low.ts',
-        lines: [1, 2],
-        branches: [],
-        riskScore: 0.2,
-        severity: 'low',
-        recommendation: 'Low priority',
-      };
-
-      const criticalResult = embedder.embedCoverageGap(criticalGap);
-      const lowResult = embedder.embedCoverageGap(lowGap);
-
-      // Embeddings should encode risk score differently
-      // The risk score is captured in the embedding
-      expect(criticalResult.metadata.riskScore).toBeGreaterThan(lowResult.metadata.riskScore);
-
-      // The embeddings may be similar due to normalization, but risk scores differ
-      expect(criticalResult.vector[0]).not.toBe(lowResult.vector[0]);
-    });
-  });
-
-  describe('embedQuery', () => {
-    it('should create query embedding from coverage criteria', () => {
-      const query: CoverageQuery = {
-        minLineCoverage: 60,
-        maxLineCoverage: 80,
-        minRiskScore: 0.5,
-      };
-
-      const result = embedder.embedQuery(query);
-
-      expect(result.vector).toHaveLength(DEFAULT_EMBEDDER_CONFIG.dimensions);
-      expect(result.confidence).toBeGreaterThan(0);
-    });
-
-    it('should create different embeddings for different queries', () => {
-      const lowCoverageQuery: CoverageQuery = {
-        maxLineCoverage: 40,
-        minRiskScore: 0.7,
-      };
-
-      const highCoverageQuery: CoverageQuery = {
-        minLineCoverage: 80,
-        maxRiskScore: 0.3,
-      };
-
-      const lowResult = embedder.embedQuery(lowCoverageQuery);
-      const highResult = embedder.embedQuery(highCoverageQuery);
-
-      // Queries should have different metadata
-      expect(lowResult.metadata.lineCoverage).not.toBe(highResult.metadata.lineCoverage);
-
-      // The first few dimensions should differ based on query parameters
-      expect(lowResult.vector[0]).not.toBe(highResult.vector[0]);
-      expect(lowResult.vector[4]).not.toBe(highResult.vector[4]);
-    });
-  });
-
-  describe('batchEmbed', () => {
-    it('should embed multiple files efficiently', () => {
-      const coverages = [
-        createTestFileCoverage('src/a.ts', 80, 70, 90, 85),
-        createTestFileCoverage('src/b.ts', 60, 50, 70, 65),
-        createTestFileCoverage('src/c.ts', 40, 30, 50, 45),
-      ];
-
-      const results = embedder.batchEmbed(coverages);
-
-      expect(results).toHaveLength(3);
-      results.forEach((result) => {
-        expect(result.vector).toHaveLength(DEFAULT_EMBEDDER_CONFIG.dimensions);
-        expect(result.metadata).toBeDefined();
-        expect(result.confidence).toBeGreaterThan(0);
-      });
-    });
-  });
-
-  describe('DEFAULT_EMBEDDER_CONFIG', () => {
-    it('should have sensible default values', () => {
-      expect(DEFAULT_EMBEDDER_CONFIG.dimensions).toBe(128);
-      expect(DEFAULT_EMBEDDER_CONFIG.includePathFeatures).toBe(true);
-      expect(DEFAULT_EMBEDDER_CONFIG.includeTemporalFeatures).toBe(true);
-      expect(DEFAULT_EMBEDDER_CONFIG.normalization).toBe('l2');
-    });
-  });
-
-  describe('custom configuration', () => {
-    it('should respect custom dimensions', () => {
-      const customEmbedder = createCoverageEmbedder({ dimensions: 64 });
-      const coverage = createTestFileCoverage('src/test.ts', 80, 70, 90, 85);
-      const result = customEmbedder.embedFileCoverage(coverage);
-
-      expect(result.vector).toHaveLength(64);
-    });
-
-    it('should respect custom normalization', () => {
-      const minmaxEmbedder = createCoverageEmbedder({ normalization: 'minmax' });
-      const coverage = createTestFileCoverage('src/test.ts', 80, 70, 90, 85);
-      const result = minmaxEmbedder.embedFileCoverage(coverage);
-
-      // MinMax normalized values should be between 0 and 1
-      result.vector.forEach((v) => {
-        expect(v).toBeGreaterThanOrEqual(0);
-        expect(v).toBeLessThanOrEqual(1);
-      });
-    });
-  });
-});
-
-// ============================================================================
-// Test Helpers
-// ============================================================================
-
-function createTestFileCoverage(
-  path: string,
-  lineCoverage: number,
-  branchCoverage: number,
-  functionCoverage: number,
-  statementCoverage: number
-): FileCoverage {
-  const total = 100;
-  const linesCovered = Math.floor((lineCoverage / 100) * total);
-  const branchesCovered = Math.floor((branchCoverage / 100) * 50);
-  const functionsCovered = Math.floor((functionCoverage / 100) * 20);
-  const statementsCovered = Math.floor((statementCoverage / 100) * 120);
-
-  return {
-    path,
-    lines: { covered: linesCovered, total },
-    branches: { covered: branchesCovered, total: 50 },
-    functions: { covered: functionsCovered, total: 20 },
-    statements: { covered: statementsCovered, total: 120 },
-    uncoveredLines: Array.from({ length: total - linesCovered }, (_, i) => i + linesCovered + 1),
-    uncoveredBranches: Array.from(
-      { length: 50 - branchesCovered },
-      (_, i) => i + branchesCovered + 1
-    ),
-  };
-}
-
-function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length) throw new Error('Vector length mismatch');
-
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-  return denominator === 0 ? 0 : dotProduct / denominator;
-}

package/tests/unit/domains/coverage-analysis/hnsw-index.test.ts

@@ -1,292 +0,0 @@
-/**
- * Agentic QE v3 - HNSW Index Tests
- *
- * Tests for the HNSW (Hierarchical Navigable Small World) index wrapper
- * that provides O(log n) vector search for coverage gap detection.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  HNSWIndex,
-  createHNSWIndex,
-  DEFAULT_HNSW_CONFIG,
-  type CoverageVectorMetadata,
-} from '../../../../src/domains/coverage-analysis/services/hnsw-index';
-import { AgentDBBackend } from '../../../../src/kernel/agentdb-backend';
-
-describe('HNSWIndex', () => {
-  let memory: AgentDBBackend;
-  let index: HNSWIndex;
-
-  beforeEach(async () => {
-    memory = new AgentDBBackend({
-      hnsw: {
-        dimensions: 128,
-        M: 16,
-        efConstruction: 200,
-        efSearch: 100,
-        metric: 'cosine',
-      },
-    });
-    await memory.initialize();
-
-    index = createHNSWIndex(memory, { dimensions: 128 });
-  });
-
-  afterEach(async () => {
-    await index.clear();
-    await memory.dispose();
-  });
-
-  describe('insert', () => {
-    it('should insert a vector with metadata', async () => {
-      const vector = createTestVector(128);
-      const metadata: CoverageVectorMetadata = {
-        filePath: 'src/test.ts',
-        lineCoverage: 75,
-        branchCoverage: 60,
-        functionCoverage: 80,
-        statementCoverage: 70,
-        uncoveredLineCount: 25,
-        uncoveredBranchCount: 10,
-        riskScore: 0.6,
-        lastUpdated: Date.now(),
-        totalLines: 100,
-      };
-
-      await index.insert('test-key', vector, metadata);
-
-      const stats = await index.getStats();
-      expect(stats.vectorCount).toBe(1);
-      expect(stats.insertOperations).toBe(1);
-    });
-
-    it('should reject vectors with wrong dimensions', async () => {
-      const wrongVector = createTestVector(64); // Wrong dimension
-
-      await expect(index.insert('test-key', wrongVector)).rejects.toThrow(
-        /dimension mismatch/i
-      );
-    });
-
-    it('should reject vectors with non-finite values', async () => {
-      const invalidVector = createTestVector(128);
-      invalidVector[50] = NaN;
-
-      await expect(index.insert('test-key', invalidVector)).rejects.toThrow(
-        /invalid vector value/i
-      );
-    });
-  });
-
-  describe('search', () => {
-    it('should find similar vectors', async () => {
-      // Insert test vectors with different characteristics
-      const vectors = [
-        { key: 'high-coverage', lineCoverage: 90, riskScore: 0.2 },
-        { key: 'medium-coverage', lineCoverage: 70, riskScore: 0.5 },
-        { key: 'low-coverage', lineCoverage: 40, riskScore: 0.8 },
-      ];
-
-      for (const v of vectors) {
-        const vector = createCoverageVector(v.lineCoverage / 100, v.riskScore);
-        await index.insert(v.key, vector, {
-          filePath: `src/${v.key}.ts`,
-          lineCoverage: v.lineCoverage,
-          branchCoverage: v.lineCoverage - 10,
-          functionCoverage: v.lineCoverage + 5,
-          statementCoverage: v.lineCoverage,
-          uncoveredLineCount: 100 - v.lineCoverage,
-          uncoveredBranchCount: Math.floor((100 - v.lineCoverage) / 2),
-          riskScore: v.riskScore,
-          lastUpdated: Date.now(),
-          totalLines: 100,
-        });
-      }
-
-      // Search for low-coverage pattern
-      const queryVector = createCoverageVector(0.4, 0.8);
-      const results = await index.search(queryVector, 3);
-
-      expect(results.length).toBe(3);
-      // The most similar should be low-coverage
-      expect(results[0].key).toBe('low-coverage');
-      expect(results[0].score).toBeGreaterThan(0.5);
-    });
-
-    it('should return results sorted by similarity', async () => {
-      // Insert multiple vectors
-      for (let i = 0; i < 10; i++) {
-        const coverage = i * 10;
-        const vector = createCoverageVector(coverage / 100, 1 - coverage / 100);
-        await index.insert(`file-${i}`, vector);
-      }
-
-      const queryVector = createCoverageVector(0.5, 0.5);
-      const results = await index.search(queryVector, 5);
-
-      // Results should be sorted by score (descending)
-      for (let i = 1; i < results.length; i++) {
-        expect(results[i - 1].score).toBeGreaterThanOrEqual(results[i].score);
-      }
-    });
-
-    it('should respect k limit', async () => {
-      // Insert many vectors
-      for (let i = 0; i < 20; i++) {
-        await index.insert(`file-${i}`, createTestVector(128));
-      }
-
-      const results = await index.search(createTestVector(128), 5);
-      expect(results.length).toBeLessThanOrEqual(5);
-    });
-  });
-
-  describe('batchInsert', () => {
-    it('should insert multiple vectors efficiently', async () => {
-      const items = [];
-      for (let i = 0; i < 50; i++) {
-        items.push({
-          key: `file-${i}`,
-          vector: createTestVector(128),
-          metadata: {
-            filePath: `src/file-${i}.ts`,
-            lineCoverage: Math.random() * 100,
-            branchCoverage: Math.random() * 100,
-            functionCoverage: Math.random() * 100,
-            statementCoverage: Math.random() * 100,
-            uncoveredLineCount: Math.floor(Math.random() * 100),
-            uncoveredBranchCount: Math.floor(Math.random() * 50),
-            riskScore: Math.random(),
-            lastUpdated: Date.now(),
-            totalLines: 100,
-          } as CoverageVectorMetadata,
-        });
-      }
-
-      await index.batchInsert(items);
-
-      const stats = await index.getStats();
-      expect(stats.vectorCount).toBe(50);
-      expect(stats.insertOperations).toBe(50);
-    });
-  });
-
-  describe('delete', () => {
-    it('should delete a vector', async () => {
-      await index.insert('test-key', createTestVector(128));
-
-      let stats = await index.getStats();
-      expect(stats.vectorCount).toBe(1);
-
-      const deleted = await index.delete('test-key');
-      expect(deleted).toBe(true);
-
-      stats = await index.getStats();
-      expect(stats.vectorCount).toBe(0);
-    });
-
-    it('should return false for non-existent key', async () => {
-      const deleted = await index.delete('non-existent');
-      expect(deleted).toBe(false);
-    });
-  });
-
-  describe('getStats', () => {
-    it('should return accurate statistics', async () => {
-      // Insert some vectors
-      for (let i = 0; i < 10; i++) {
-        await index.insert(`file-${i}`, createTestVector(128));
-      }
-
-      // Perform some searches
-      for (let i = 0; i < 5; i++) {
-        await index.search(createTestVector(128), 3);
-      }
-
-      const stats = await index.getStats();
-
-      expect(stats.vectorCount).toBe(10);
-      expect(stats.insertOperations).toBe(10);
-      expect(stats.searchOperations).toBe(5);
-      expect(stats.indexSizeBytes).toBeGreaterThan(0);
-    });
-
-    it('should track search latencies', async () => {
-      // Insert vectors
-      for (let i = 0; i < 100; i++) {
-        await index.insert(`file-${i}`, createTestVector(128));
-      }
-
-      // Perform searches
-      for (let i = 0; i < 20; i++) {
-        await index.search(createTestVector(128), 10);
-      }
-
-      const stats = await index.getStats();
-
-      expect(stats.avgSearchLatencyMs).toBeGreaterThan(0);
-      expect(stats.p95SearchLatencyMs).toBeGreaterThanOrEqual(stats.avgSearchLatencyMs);
-      expect(stats.p99SearchLatencyMs).toBeGreaterThanOrEqual(stats.p95SearchLatencyMs);
-    });
-  });
-
-  describe('clear', () => {
-    it('should clear all entries', async () => {
-      for (let i = 0; i < 10; i++) {
-        await index.insert(`file-${i}`, createTestVector(128));
-      }
-
-      let stats = await index.getStats();
-      expect(stats.vectorCount).toBe(10);
-
-      await index.clear();
-
-      stats = await index.getStats();
-      expect(stats.vectorCount).toBe(0);
-    });
-  });
-
-  describe('DEFAULT_HNSW_CONFIG', () => {
-    it('should have sensible default values', () => {
-      expect(DEFAULT_HNSW_CONFIG.dimensions).toBe(128);
-      expect(DEFAULT_HNSW_CONFIG.M).toBe(16);
-      expect(DEFAULT_HNSW_CONFIG.efConstruction).toBe(200);
-      expect(DEFAULT_HNSW_CONFIG.efSearch).toBe(100);
-      expect(DEFAULT_HNSW_CONFIG.metric).toBe('cosine');
-    });
-  });
-});
-
-// ============================================================================
-// Test Helpers
-// ============================================================================
-
-function createTestVector(dimensions: number): number[] {
-  const vector = new Array(dimensions).fill(0);
-  for (let i = 0; i < dimensions; i++) {
-    vector[i] = Math.random();
-  }
-  return vector;
-}
-
-function createCoverageVector(coverage: number, risk: number): number[] {
-  const vector = new Array(128).fill(0);
-
-  // Encode coverage metrics
-  vector[0] = coverage;
-  vector[1] = coverage * 0.9; // branch
-  vector[2] = coverage * 1.1; // function
-  vector[3] = coverage; // statement
-
-  // Encode risk
-  vector[4] = risk;
-  vector[5] = risk * 0.8;
-
-  // Fill remaining with derived features
-  for (let i = 6; i < 128; i++) {
-    vector[i] = Math.sin(i * coverage + risk) * 0.5 + 0.5;
-  }
-
-  return vector;
-}