/**
 * Agentic QE v3 - Sublinear Coverage Analyzer
 *
 * This is the main implementation of ADR-003: Sublinear Algorithms for Coverage Analysis.
 * Uses HNSW (Hierarchical Navigable Small World) indexing for O(log n) coverage gap
 * detection across large codebases.
 *
 * Performance characteristics (per ADR-003):
 * | Codebase Size | Traditional O(n) | v3 O(log n) | Improvement |
 * |---------------|-----------------|-------------|-------------|
 * | 1,000 files   | 1,000 ops       | 10 ops      | 100x        |
 * | 10,000 files  | 10,000 ops      | 13 ops      | 770x        |
 * | 100,000 files | 100,000 ops     | 17 ops      | 5,900x      |
 *
 * Success metrics target: <100ms gap detection on 100k files
 *
 * @module coverage-analysis/sublinear-analyzer
 */
import { Result, Severity } from '../../../shared/types';
import { MemoryBackend } from '../../../kernel/interfaces';
import { CoverageData, CoverageGaps, CoverageGap, SimilarPatterns } from '../interfaces';
import { CoverageQuery } from './coverage-embedder';
/**
 * Configuration for the sublinear coverage analyzer
 */
export interface SublinearAnalyzerConfig {
    /** Number of nearest neighbors to search (default: 10) */
    searchK: number;
    /** Minimum coverage threshold to identify gaps (default: 80) */
    coverageThreshold: number;
    /** Minimum risk score to include in results (default: 0.3) */
    riskThreshold: number;
    /** Maximum results to return (default: 100) */
    maxResults: number;
    /** Enable automatic index updates on analyze (default: true) */
    autoIndex: boolean;
    /** Batch size for bulk operations (default: 100) */
    batchSize: number;
    /** Vector dimensions for embeddings (default: 128) */
    dimensions: number;
}
/**
 * Default analyzer configuration
 */
export declare const DEFAULT_ANALYZER_CONFIG: SublinearAnalyzerConfig;
/**
 * Interface for sublinear coverage analysis operations
 */
export interface ISublinearCoverageAnalyzer {
    /** Initialize the analyzer and HNSW index */
    initialize(): Promise<void>;
    /** Index coverage data for O(log n) search */
    indexCoverageData(data: CoverageData): Promise<IndexingResult>;
    /** Find coverage gaps using O(log n) HNSW search */
    findGapsSublinear(query: CoverageQuery): Promise<Result<CoverageGaps, Error>>;
    /** Find similar coverage patterns using vector similarity */
    findSimilarPatterns(gap: CoverageGap, k: number): Promise<Result<SimilarPatterns, Error>>;
    /** Detect high-risk coverage zones using embeddings */
    detectRiskZones(threshold: number): Promise<Result<RiskZone[], Error>>;
    /** Get analyzer statistics */
    getStats(): Promise<SublinearAnalyzerStats>;
    /** Clear all indexed data */
    clearIndex(): Promise<void>;
}
/**
 * Result of indexing operation
 */
export interface IndexingResult {
    /** Number of files indexed */
    filesIndexed: number;
    /** Time taken in milliseconds */
    indexingTimeMs: number;
    /** Number of vectors stored */
    vectorsStored: number;
    /** Any errors encountered */
    errors: string[];
}
/**
 * High-risk coverage zone
 */
export interface RiskZone {
    /** File path */
    file: string;
    /** Risk score (0-1) */
    riskScore: number;
    /** Severity level */
    severity: Severity;
    /** Number of uncovered lines */
    uncoveredLines: number;
    /** Number of uncovered branches */
    uncoveredBranches: number;
    /** Recommended actions */
    recommendations: string[];
    /** Similar files with same pattern */
    similarFiles: string[];
}
/**
 * Analyzer statistics
 */
export interface SublinearAnalyzerStats {
    /** Total vectors indexed */
    totalVectors: number;
    /** Total files tracked */
    totalFiles: number;
    /** Index size in bytes */
    indexSizeBytes: number;
    /** Average search latency */
    avgSearchLatencyMs: number;
    /** P95 search latency */
    p95SearchLatencyMs: number;
    /** P99 search latency */
    p99SearchLatencyMs: number;
    /** Total search operations */
    searchOperations: number;
    /** Time since last index update */
    lastIndexUpdateMs: number;
    /** Performance vs linear scan improvement factor */
    performanceImprovement: number;
}
/**
 * Sublinear Coverage Analyzer
 *
 * Implements O(log n) coverage gap detection using HNSW vector indexing.
 * This is the core implementation for ADR-003 performance targets.
 *
 * Key features:
 * - O(log n) gap detection via HNSW approximate nearest neighbor search
 * - Dense coverage embeddings capture coverage patterns
 * - Batch indexing for efficient bulk operations
 * - Risk zone detection using vector similarity clustering
 * - <100ms target for 100k file codebases
 *
 * @example
 * ```typescript
 * const analyzer = new SublinearCoverageAnalyzer(memoryBackend);
 * await analyzer.initialize();
 * await analyzer.indexCoverageData(coverageData);
 *
 * // O(log n) gap detection
 * const gaps = await analyzer.findGapsSublinear({ maxLineCoverage: 60 });
 *
 * // Find similar patterns
 * const similar = await analyzer.findSimilarPatterns(gap, 5);
 * ```
 */
export declare class SublinearCoverageAnalyzer implements ISublinearCoverageAnalyzer {
    private readonly memory;
    private readonly config;
    private readonly hnswIndex;
    private readonly embedder;
    private lastIndexUpdate;
    private fileCount;
    private initialized;
    constructor(memory: MemoryBackend, config?: Partial<SublinearAnalyzerConfig>);
    /**
     * Initialize the analyzer
     */
    initialize(): Promise<void>;
    /**
     * Index coverage data for O(log n) search
     *
     * This method creates dense vector embeddings for each file's coverage
     * data and stores them in the HNSW index for efficient similarity search.
     *
     * Time complexity: O(n log n) for n files during indexing
     * Search complexity: O(log n) after indexing
     *
     * @param data - Coverage data to index
     * @returns Indexing result with statistics
     */
    indexCoverageData(data: CoverageData): Promise<IndexingResult>;
    /**
     * Find coverage gaps using O(log n) HNSW search
     *
     * This is the core sublinear operation. Instead of scanning all files
     * linearly, we use vector similarity to find files matching the query
     * criteria efficiently.
     *
     * Performance: O(log n) operations for n indexed files
     * Target: <100ms for 100k files
     *
     * @param query - Query parameters for gap detection
     * @returns Coverage gaps matching the query
     */
    findGapsSublinear(query: CoverageQuery): Promise<Result<CoverageGaps, Error>>;
    /**
     * Find similar coverage patterns using vector similarity
     *
     * Uses HNSW to find files with similar coverage characteristics
     * to a given gap pattern.
     *
     * @param gap - Coverage gap to find similar patterns for
     * @param k - Number of similar patterns to return
     * @returns Similar patterns with similarity scores
     */
    findSimilarPatterns(gap: CoverageGap, k: number): Promise<Result<SimilarPatterns, Error>>;
    /**
     * Detect high-risk coverage zones using clustering
     *
     * Identifies files with similar high-risk coverage patterns
     * that may require coordinated test improvements.
     *
     * @param threshold - Minimum risk score to include
     * @returns High-risk zones with similar files grouped
     */
    detectRiskZones(threshold: number): Promise<Result<RiskZone[], Error>>;
    /**
     * Get analyzer statistics
     *
     * @returns Current statistics including performance metrics
     */
    getStats(): Promise<SublinearAnalyzerStats>;
    /**
     * Clear all indexed data
     */
    clearIndex(): Promise<void>;
    private filterByQueryCriteria;
    private convertToGaps;
    private createGapFromMetadata;
    private clusterRiskZones;
    private riskScoreToSeverity;
    private generateRecommendation;
    private generateZoneRecommendations;
    private generateUncoveredLineEstimate;
    private generateUncoveredBranchEstimate;
    private generateGapId;
    private estimateEffort;
}
/**
 * Create a new sublinear coverage analyzer instance
 *
 * @param memory - Memory backend for storage
 * @param config - Optional configuration overrides
 * @returns Configured sublinear analyzer
 */
export declare function createSublinearAnalyzer(memory: MemoryBackend, config?: Partial<SublinearAnalyzerConfig>): SublinearCoverageAnalyzer;
//# sourceMappingURL=sublinear-analyzer.d.ts.map