@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/domains/coverage-analysis/services/coverage-embedder.ts

@@ -1,733 +0,0 @@
-/**
- * Agentic QE v3 - Coverage Embedder Service
- *
- * Converts code coverage data into dense vector embeddings for efficient
- * similarity search using HNSW index. The embedder creates multi-dimensional
- * representations that capture coverage patterns, risk factors, and file
- * characteristics.
- *
- * Embedding Strategy:
- * - Dimensions 0-15: Coverage metrics (line, branch, function, statement)
- * - Dimensions 16-31: Gap characteristics (size, distribution, density)
- * - Dimensions 32-47: Risk factors (complexity, change frequency, defect history)
- * - Dimensions 48-63: File characteristics (size, type, depth)
- * - Dimensions 64-127: Derived features and semantic signals
- *
- * @module coverage-analysis/coverage-embedder
- */
-
-import { FileCoverage, CoverageGap } from '../interfaces';
-import { CoverageVectorMetadata } from './hnsw-index';
-
-// ============================================================================
-// Embedder Configuration
-// ============================================================================
-
-/**
- * Configuration for coverage embedding generation
- */
-export interface CoverageEmbedderConfig {
-  /** Number of dimensions for the embedding (default: 128) */
-  dimensions: number;
-  /** Include file path features in embedding */
-  includePathFeatures: boolean;
-  /** Include temporal features (last modified, etc.) */
-  includeTemporalFeatures: boolean;
-  /** Normalization method for embeddings */
-  normalization: 'l2' | 'minmax' | 'none';
-}
-
-/**
- * Default embedder configuration
- */
-export const DEFAULT_EMBEDDER_CONFIG: CoverageEmbedderConfig = {
-  dimensions: 128,
-  includePathFeatures: true,
-  includeTemporalFeatures: true,
-  normalization: 'l2',
-};
-
-// ============================================================================
-// Embedder Interface
-// ============================================================================
-
-/**
- * Interface for coverage embedding generation
- */
-export interface ICoverageEmbedder {
-  /** Create embedding from file coverage data */
-  embedFileCoverage(coverage: FileCoverage): EmbeddingResult;
-
-  /** Create embedding from coverage gap */
-  embedCoverageGap(gap: CoverageGap): EmbeddingResult;
-
-  /** Create embedding from query parameters */
-  embedQuery(query: CoverageQuery): EmbeddingResult;
-
-  /** Batch embed multiple file coverages */
-  batchEmbed(coverages: FileCoverage[]): EmbeddingResult[];
-}
-
-/**
- * Query parameters for coverage search
- */
-export interface CoverageQuery {
-  /** Minimum line coverage threshold */
-  minLineCoverage?: number;
-  /** Maximum line coverage threshold */
-  maxLineCoverage?: number;
-  /** Minimum branch coverage threshold */
-  minBranchCoverage?: number;
-  /** Maximum branch coverage threshold */
-  maxBranchCoverage?: number;
-  /** Minimum risk score */
-  minRiskScore?: number;
-  /** Maximum risk score */
-  maxRiskScore?: number;
-  /** File path pattern (for similarity) */
-  filePattern?: string;
-  /** Maximum uncovered lines to find */
-  maxUncoveredLines?: number;
-}
-
-/**
- * Result of embedding generation
- */
-export interface EmbeddingResult {
-  /** The embedding vector */
-  vector: number[];
-  /** Metadata for the embedding */
-  metadata: CoverageVectorMetadata;
-  /** Quality score (0-1) indicating embedding confidence */
-  confidence: number;
-}
-
-// ============================================================================
-// Coverage Embedder Implementation
-// ============================================================================
-
-/**
- * Coverage Embedder Service
- *
- * Generates dense vector embeddings from coverage data for use with
- * HNSW-based similarity search. The embeddings capture coverage patterns,
- * risk profiles, and file characteristics to enable efficient O(log n)
- * gap detection.
- *
- * @example
- * ```typescript
- * const embedder = new CoverageEmbedder();
- * const result = embedder.embedFileCoverage(fileCoverage);
- * await index.insert(fileCoverage.path, result.vector, result.metadata);
- * ```
- */
-export class CoverageEmbedder implements ICoverageEmbedder {
-  private readonly config: CoverageEmbedderConfig;
-
-  constructor(config: Partial<CoverageEmbedderConfig> = {}) {
-    this.config = { ...DEFAULT_EMBEDDER_CONFIG, ...config };
-  }
-
-  /**
-   * Create embedding from file coverage data
-   *
-   * Generates a dense vector representation of the file's coverage
-   * characteristics for similarity search.
-   *
-   * @param coverage - File coverage data to embed
-   * @returns Embedding result with vector and metadata
-   */
-  embedFileCoverage(coverage: FileCoverage): EmbeddingResult {
-    const vector = new Array(this.config.dimensions).fill(0);
-    let offset = 0;
-
-    // Section 1: Coverage Metrics (dimensions 0-15)
-    offset = this.encodeCoverageMetrics(vector, coverage, offset);
-
-    // Section 2: Gap Characteristics (dimensions 16-31)
-    offset = this.encodeGapCharacteristics(vector, coverage, offset);
-
-    // Section 3: Risk Factors (dimensions 32-47)
-    offset = this.encodeRiskFactors(vector, coverage, offset);
-
-    // Section 4: File Characteristics (dimensions 48-63)
-    offset = this.encodeFileCharacteristics(vector, coverage, offset);
-
-    // Section 5: Derived Features (dimensions 64-127)
-    this.encodeDerivedFeatures(vector, coverage, offset);
-
-    // Apply normalization
-    const normalizedVector = this.normalize(vector);
-
-    return {
-      vector: normalizedVector,
-      metadata: this.createMetadata(coverage),
-      confidence: this.calculateConfidence(coverage),
-    };
-  }
-
-  /**
-   * Create embedding from coverage gap
-   *
-   * Generates a vector representation of a coverage gap for finding
-   * similar gaps in the codebase.
-   *
-   * @param gap - Coverage gap to embed
-   * @returns Embedding result with vector and metadata
-   */
-  embedCoverageGap(gap: CoverageGap): EmbeddingResult {
-    const vector = new Array(this.config.dimensions).fill(0);
-
-    // Encode gap-specific features
-    vector[0] = gap.riskScore;
-    vector[1] = Math.min(1, gap.lines.length / 100);
-    vector[2] = Math.min(1, gap.branches.length / 20);
-    vector[3] = this.severityToNumber(gap.severity) / 4;
-
-    // Encode file path characteristics
-    const pathFeatures = this.extractPathFeatures(gap.file);
-    vector[4] = pathFeatures.depth / 10;
-    vector[5] = pathFeatures.hashNormalized;
-
-    // Encode gap distribution
-    if (gap.lines.length > 1) {
-      const lineSpread = gap.lines[gap.lines.length - 1] - gap.lines[0];
-      vector[6] = Math.min(1, lineSpread / 500);
-      vector[7] = gap.lines.length / (lineSpread + 1); // Density
-    }
-
-    // Fill remaining dimensions with derived features
-    for (let i = 8; i < this.config.dimensions; i++) {
-      const seed = gap.riskScore * i + gap.lines.length * 0.01;
-      vector[i] = Math.sin(seed) * 0.5 + 0.5;
-    }
-
-    const normalizedVector = this.normalize(vector);
-
-    return {
-      vector: normalizedVector,
-      metadata: {
-        filePath: gap.file,
-        lineCoverage: 0,
-        branchCoverage: 0,
-        functionCoverage: 0,
-        statementCoverage: 0,
-        uncoveredLineCount: gap.lines.length,
-        uncoveredBranchCount: gap.branches.length,
-        riskScore: gap.riskScore,
-        lastUpdated: Date.now(),
-        totalLines: gap.lines.length > 0 ? gap.lines[gap.lines.length - 1] : 0,
-      },
-      confidence: 0.8, // Gap embeddings have slightly lower confidence
-    };
-  }
-
-  /**
-   * Create embedding from query parameters
-   *
-   * Generates a query vector for finding files matching specific
-   * coverage criteria.
-   *
-   * @param query - Query parameters
-   * @returns Embedding result optimized for similarity search
-   */
-  embedQuery(query: CoverageQuery): EmbeddingResult {
-    const vector = new Array(this.config.dimensions).fill(0);
-
-    // Encode coverage thresholds
-    if (query.minLineCoverage !== undefined) {
-      vector[0] = query.minLineCoverage / 100;
-    }
-    if (query.maxLineCoverage !== undefined) {
-      vector[1] = query.maxLineCoverage / 100;
-    }
-    if (query.minBranchCoverage !== undefined) {
-      vector[2] = query.minBranchCoverage / 100;
-    }
-    if (query.maxBranchCoverage !== undefined) {
-      vector[3] = query.maxBranchCoverage / 100;
-    }
-
-    // Encode risk thresholds
-    if (query.minRiskScore !== undefined) {
-      vector[4] = query.minRiskScore;
-    }
-    if (query.maxRiskScore !== undefined) {
-      vector[5] = query.maxRiskScore;
-    }
-
-    // Encode file pattern if provided
-    if (query.filePattern) {
-      const pathFeatures = this.extractPathFeatures(query.filePattern);
-      vector[6] = pathFeatures.depth / 10;
-      vector[7] = pathFeatures.hashNormalized;
-    }
-
-    // Encode uncovered lines constraint
-    if (query.maxUncoveredLines !== undefined) {
-      vector[8] = Math.min(1, query.maxUncoveredLines / 100);
-    }
-
-    // Fill with neutral values for undefined query parameters
-    for (let i = 9; i < this.config.dimensions; i++) {
-      if (vector[i] === 0) {
-        vector[i] = 0.5; // Neutral value
-      }
-    }
-
-    return {
-      vector: this.normalize(vector),
-      metadata: {
-        filePath: query.filePattern || '',
-        lineCoverage: query.minLineCoverage || 0,
-        branchCoverage: query.minBranchCoverage || 0,
-        functionCoverage: 0,
-        statementCoverage: 0,
-        uncoveredLineCount: query.maxUncoveredLines || 0,
-        uncoveredBranchCount: 0,
-        riskScore: query.minRiskScore || 0,
-        lastUpdated: Date.now(),
-        totalLines: 0,
-      },
-      confidence: 0.7, // Query embeddings have lower confidence
-    };
-  }
-
-  /**
-   * Batch embed multiple file coverages
-   *
-   * Efficiently processes multiple files in parallel.
-   *
-   * @param coverages - Array of file coverages to embed
-   * @returns Array of embedding results
-   */
-  batchEmbed(coverages: FileCoverage[]): EmbeddingResult[] {
-    return coverages.map((coverage) => this.embedFileCoverage(coverage));
-  }
-
-  // ============================================================================
-  // Private Encoding Methods
-  // ============================================================================
-
-  private encodeCoverageMetrics(
-    vector: number[],
-    coverage: FileCoverage,
-    offset: number
-  ): number {
-    // Line coverage (4 dimensions)
-    vector[offset++] = coverage.lines.total > 0
-      ? coverage.lines.covered / coverage.lines.total
-      : 0;
-    vector[offset++] = Math.min(1, coverage.lines.total / 1000);
-    vector[offset++] = Math.min(1, coverage.lines.covered / 500);
-    vector[offset++] = coverage.lines.total > 0
-      ? coverage.uncoveredLines.length / coverage.lines.total
-      : 0;
-
-    // Branch coverage (4 dimensions)
-    vector[offset++] = coverage.branches.total > 0
-      ? coverage.branches.covered / coverage.branches.total
-      : 1;
-    vector[offset++] = Math.min(1, coverage.branches.total / 200);
-    vector[offset++] = Math.min(1, coverage.branches.covered / 100);
-    vector[offset++] = coverage.branches.total > 0
-      ? coverage.uncoveredBranches.length / coverage.branches.total
-      : 0;
-
-    // Function coverage (4 dimensions)
-    vector[offset++] = coverage.functions.total > 0
-      ? coverage.functions.covered / coverage.functions.total
-      : 1;
-    vector[offset++] = Math.min(1, coverage.functions.total / 50);
-    vector[offset++] = Math.min(1, coverage.functions.covered / 25);
-    vector[offset++] = coverage.functions.total > 0
-      ? 1 - coverage.functions.covered / coverage.functions.total
-      : 0;
-
-    // Statement coverage (4 dimensions)
-    vector[offset++] = coverage.statements.total > 0
-      ? coverage.statements.covered / coverage.statements.total
-      : 1;
-    vector[offset++] = Math.min(1, coverage.statements.total / 1000);
-    vector[offset++] = Math.min(1, coverage.statements.covered / 500);
-    vector[offset++] = coverage.statements.total > 0
-      ? 1 - coverage.statements.covered / coverage.statements.total
-      : 0;
-
-    return offset;
-  }
-
-  private encodeGapCharacteristics(
-    vector: number[],
-    coverage: FileCoverage,
-    offset: number
-  ): number {
-    const uncoveredLines = coverage.uncoveredLines;
-    const uncoveredBranches = coverage.uncoveredBranches;
-
-    // Gap size metrics (4 dimensions)
-    vector[offset++] = Math.min(1, uncoveredLines.length / 100);
-    vector[offset++] = Math.min(1, uncoveredBranches.length / 50);
-    vector[offset++] = Math.min(1, (uncoveredLines.length + uncoveredBranches.length) / 150);
-    vector[offset++] = uncoveredLines.length > 0 ? 1 : 0;
-
-    // Gap distribution metrics (4 dimensions)
-    if (uncoveredLines.length > 1) {
-      const sorted = [...uncoveredLines].sort((a, b) => a - b);
-      const spread = sorted[sorted.length - 1] - sorted[0];
-      const density = uncoveredLines.length / (spread + 1);
-
-      vector[offset++] = Math.min(1, spread / 500);
-      vector[offset++] = Math.min(1, density);
-
-      // Gap clustering - count contiguous regions
-      const regions = this.countContiguousRegions(sorted);
-      vector[offset++] = Math.min(1, regions / 10);
-      vector[offset++] = regions > 0 ? uncoveredLines.length / regions : 0; // Avg region size
-    } else {
-      vector[offset++] = 0;
-      vector[offset++] = uncoveredLines.length > 0 ? 1 : 0;
-      vector[offset++] = uncoveredLines.length > 0 ? 0.1 : 0;
-      vector[offset++] = uncoveredLines.length;
-    }
-
-    // Gap position metrics (4 dimensions)
-    if (uncoveredLines.length > 0 && coverage.lines.total > 0) {
-      const firstGap = Math.min(...uncoveredLines);
-      const lastGap = Math.max(...uncoveredLines);
-
-      vector[offset++] = firstGap / coverage.lines.total; // Position of first gap
-      vector[offset++] = lastGap / coverage.lines.total; // Position of last gap
-      vector[offset++] = (lastGap - firstGap) / coverage.lines.total; // Gap span
-      vector[offset++] = uncoveredLines.filter((l) => l <= coverage.lines.total * 0.2).length / uncoveredLines.length; // Early file gaps
-    } else {
-      offset += 4;
-    }
-
-    // Padding (4 dimensions)
-    offset += 4;
-
-    return offset;
-  }
-
-  private encodeRiskFactors(
-    vector: number[],
-    coverage: FileCoverage,
-    offset: number
-  ): number {
-    // Coverage-based risk (4 dimensions)
-    const overallCoverage = this.calculateOverallCoverage(coverage);
-    vector[offset++] = 1 - overallCoverage; // Inverted: higher value = higher risk
-    vector[offset++] = coverage.branches.total > 0
-      ? 1 - coverage.branches.covered / coverage.branches.total
-      : 0;
-    vector[offset++] = coverage.functions.total > 0
-      ? 1 - coverage.functions.covered / coverage.functions.total
-      : 0;
-    vector[offset++] = Math.min(1, coverage.uncoveredLines.length / 50);
-
-    // Size-based risk (4 dimensions)
-    vector[offset++] = Math.min(1, coverage.lines.total / 500);
-    vector[offset++] = Math.min(1, coverage.functions.total / 30);
-    vector[offset++] = Math.min(1, coverage.branches.total / 100);
-    vector[offset++] = coverage.lines.total > 300 ? 0.8 : coverage.lines.total / 375;
-
-    // Gap severity risk (4 dimensions)
-    const largeGapRatio = this.calculateLargeGapRatio(coverage.uncoveredLines);
-    vector[offset++] = largeGapRatio;
-    vector[offset++] = coverage.uncoveredBranches.length > 10 ? 1 : coverage.uncoveredBranches.length / 10;
-    vector[offset++] = coverage.uncoveredLines.length > 30 ? 1 : coverage.uncoveredLines.length / 30;
-    vector[offset++] = this.calculateGapConcentration(coverage);
-
-    // Padding (4 dimensions)
-    offset += 4;
-
-    return offset;
-  }
-
-  private encodeFileCharacteristics(
-    vector: number[],
-    coverage: FileCoverage,
-    offset: number
-  ): number {
-    const pathFeatures = this.extractPathFeatures(coverage.path);
-
-    // Path depth and structure (4 dimensions)
-    vector[offset++] = pathFeatures.depth / 10;
-    vector[offset++] = pathFeatures.hashNormalized;
-    vector[offset++] = pathFeatures.isTest ? 0.1 : 0.9; // Lower priority for test files
-    vector[offset++] = pathFeatures.isConfig ? 0.2 : 0.8; // Lower priority for config files
-
-    // File type features (4 dimensions)
-    vector[offset++] = pathFeatures.extension === 'ts' ? 1 : 0;
-    vector[offset++] = pathFeatures.extension === 'js' ? 1 : 0;
-    vector[offset++] = pathFeatures.extension === 'tsx' || pathFeatures.extension === 'jsx' ? 1 : 0;
-    vector[offset++] = pathFeatures.isIndex ? 0.5 : 0;
-
-    // Directory context (4 dimensions)
-    vector[offset++] = pathFeatures.inSrc ? 1 : 0;
-    vector[offset++] = pathFeatures.inLib ? 0.8 : 0;
-    vector[offset++] = pathFeatures.inDomains ? 1 : 0;
-    vector[offset++] = pathFeatures.inServices ? 0.9 : 0;
-
-    // Padding (4 dimensions)
-    offset += 4;
-
-    return offset;
-  }
-
-  private encodeDerivedFeatures(
-    vector: number[],
-    coverage: FileCoverage,
-    offset: number
-  ): void {
-    // Generate derived features using mathematical transformations
-    const metrics = [
-      coverage.lines.covered / (coverage.lines.total || 1),
-      coverage.branches.covered / (coverage.branches.total || 1),
-      coverage.functions.covered / (coverage.functions.total || 1),
-      coverage.statements.covered / (coverage.statements.total || 1),
-      coverage.uncoveredLines.length / (coverage.lines.total || 1),
-      coverage.uncoveredBranches.length / (coverage.branches.total || 1),
-    ];
-
-    // Cross-metric features
-    for (let i = 0; i < 6; i++) {
-      for (let j = i + 1; j < 6 && offset < this.config.dimensions; j++) {
-        vector[offset++] = (metrics[i] + metrics[j]) / 2; // Average
-        if (offset < this.config.dimensions) {
-          vector[offset++] = Math.abs(metrics[i] - metrics[j]); // Difference
-        }
-      }
-    }
-
-    // Polynomial features
-    while (offset < this.config.dimensions - 6) {
-      const idx = (offset - 64) % metrics.length;
-      vector[offset++] = metrics[idx] * metrics[idx]; // Quadratic
-      if (offset < this.config.dimensions) {
-        vector[offset++] = Math.sqrt(metrics[idx]); // Square root
-      }
-    }
-
-    // Trigonometric features for remaining dimensions
-    while (offset < this.config.dimensions) {
-      const phase = (offset - 64) * 0.1;
-      const baseValue = metrics[(offset - 64) % metrics.length];
-      vector[offset++] = Math.sin(baseValue * Math.PI + phase) * 0.5 + 0.5;
-    }
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private normalize(vector: number[]): number[] {
-    switch (this.config.normalization) {
-      case 'l2':
-        return this.l2Normalize(vector);
-      case 'minmax':
-        return this.minMaxNormalize(vector);
-      default:
-        return vector;
-    }
-  }
-
-  private l2Normalize(vector: number[]): number[] {
-    const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
-    if (norm === 0) return vector;
-    return vector.map((v) => v / norm);
-  }
-
-  private minMaxNormalize(vector: number[]): number[] {
-    const min = Math.min(...vector);
-    const max = Math.max(...vector);
-    const range = max - min;
-    if (range === 0) return vector.map(() => 0.5);
-    return vector.map((v) => (v - min) / range);
-  }
-
-  private createMetadata(coverage: FileCoverage): CoverageVectorMetadata {
-    return {
-      filePath: coverage.path,
-      lineCoverage: coverage.lines.total > 0
-        ? (coverage.lines.covered / coverage.lines.total) * 100
-        : 0,
-      branchCoverage: coverage.branches.total > 0
-        ? (coverage.branches.covered / coverage.branches.total) * 100
-        : 0,
-      functionCoverage: coverage.functions.total > 0
-        ? (coverage.functions.covered / coverage.functions.total) * 100
-        : 0,
-      statementCoverage: coverage.statements.total > 0
-        ? (coverage.statements.covered / coverage.statements.total) * 100
-        : 0,
-      uncoveredLineCount: coverage.uncoveredLines.length,
-      uncoveredBranchCount: coverage.uncoveredBranches.length,
-      riskScore: this.calculateRiskScore(coverage),
-      lastUpdated: Date.now(),
-      totalLines: coverage.lines.total,
-    };
-  }
-
-  private calculateConfidence(coverage: FileCoverage): number {
-    // Higher confidence for files with more data
-    const hasLines = coverage.lines.total > 0;
-    const hasBranches = coverage.branches.total > 0;
-    const hasFunctions = coverage.functions.total > 0;
-    const hasStatements = coverage.statements.total > 0;
-
-    let confidence = 0.5;
-    if (hasLines) confidence += 0.2;
-    if (hasBranches) confidence += 0.1;
-    if (hasFunctions) confidence += 0.1;
-    if (hasStatements) confidence += 0.1;
-
-    return Math.min(1, confidence);
-  }
-
-  private calculateOverallCoverage(coverage: FileCoverage): number {
-    const line = coverage.lines.total > 0
-      ? coverage.lines.covered / coverage.lines.total
-      : 1;
-    const branch = coverage.branches.total > 0
-      ? coverage.branches.covered / coverage.branches.total
-      : 1;
-    const func = coverage.functions.total > 0
-      ? coverage.functions.covered / coverage.functions.total
-      : 1;
-    const stmt = coverage.statements.total > 0
-      ? coverage.statements.covered / coverage.statements.total
-      : 1;
-
-    return (line + branch + func + stmt) / 4;
-  }
-
-  private calculateRiskScore(coverage: FileCoverage): number {
-    const lineCoverageGap = coverage.lines.total > 0
-      ? 1 - coverage.lines.covered / coverage.lines.total
-      : 0;
-    const branchCoverageGap = coverage.branches.total > 0
-      ? 1 - coverage.branches.covered / coverage.branches.total
-      : 0;
-    const functionCoverageGap = coverage.functions.total > 0
-      ? 1 - coverage.functions.covered / coverage.functions.total
-      : 0;
-
-    // Weighted risk score (branches and functions weighted higher)
-    return Math.min(1, lineCoverageGap * 0.3 + branchCoverageGap * 0.4 + functionCoverageGap * 0.3);
-  }
-
-  private countContiguousRegions(sortedLines: number[]): number {
-    if (sortedLines.length === 0) return 0;
-
-    let regions = 1;
-    for (let i = 1; i < sortedLines.length; i++) {
-      if (sortedLines[i] - sortedLines[i - 1] > 3) {
-        regions++;
-      }
-    }
-    return regions;
-  }
-
-  private calculateLargeGapRatio(uncoveredLines: number[]): number {
-    if (uncoveredLines.length === 0) return 0;
-
-    const sorted = [...uncoveredLines].sort((a, b) => a - b);
-    let largeGaps = 0;
-    let currentGapSize = 1;
-
-    for (let i = 1; i < sorted.length; i++) {
-      if (sorted[i] - sorted[i - 1] <= 3) {
-        currentGapSize++;
-      } else {
-        if (currentGapSize > 10) largeGaps++;
-        currentGapSize = 1;
-      }
-    }
-    if (currentGapSize > 10) largeGaps++;
-
-    const totalRegions = this.countContiguousRegions(sorted);
-    return totalRegions > 0 ? largeGaps / totalRegions : 0;
-  }
-
-  private calculateGapConcentration(coverage: FileCoverage): number {
-    if (coverage.uncoveredLines.length === 0 || coverage.lines.total === 0) return 0;
-
-    // Higher concentration = gaps clustered in fewer regions
-    const regions = this.countContiguousRegions([...coverage.uncoveredLines].sort((a, b) => a - b));
-    const idealRegions = Math.ceil(coverage.uncoveredLines.length / 5); // Assume 5 lines per region
-    return regions > 0 ? Math.min(1, idealRegions / regions) : 0;
-  }
-
-  private extractPathFeatures(path: string): PathFeatures {
-    const parts = path.split('/').filter(Boolean);
-    const extension = path.split('.').pop() || '';
-    const fileName = parts[parts.length - 1] || '';
-
-    return {
-      depth: parts.length,
-      extension,
-      hashNormalized: this.hashString(path) / 1000000,
-      isTest: /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(path) || parts.includes('tests') || parts.includes('__tests__'),
-      isConfig: /\.(config|rc)\.(ts|js|json|yaml|yml)$/.test(path),
-      isIndex: fileName.startsWith('index.'),
-      inSrc: parts.includes('src'),
-      inLib: parts.includes('lib'),
-      inDomains: parts.includes('domains'),
-      inServices: parts.includes('services'),
-    };
-  }
-
-  private hashString(str: string): number {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      const chr = str.charCodeAt(i);
-      hash = ((hash << 5) - hash + chr) | 0;
-    }
-    return Math.abs(hash);
-  }
-
-  private severityToNumber(severity: string): number {
-    switch (severity) {
-      case 'critical': return 4;
-      case 'high': return 3;
-      case 'medium': return 2;
-      case 'low': return 1;
-      default: return 0;
-    }
-  }
-}
-
-// ============================================================================
-// Internal Types
-// ============================================================================
-
-interface PathFeatures {
-  depth: number;
-  extension: string;
-  hashNormalized: number;
-  isTest: boolean;
-  isConfig: boolean;
-  isIndex: boolean;
-  inSrc: boolean;
-  inLib: boolean;
-  inDomains: boolean;
-  inServices: boolean;
-}
-
-// ============================================================================
-// Factory Functions
-// ============================================================================
-
-/**
- * Create a new coverage embedder instance
- *
- * @param config - Optional configuration overrides
- * @returns Configured coverage embedder
- */
-export function createCoverageEmbedder(
-  config?: Partial<CoverageEmbedderConfig>
-): CoverageEmbedder {
-  return new CoverageEmbedder(config);
-}