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

package/src/domains/coverage-analysis/coordinator.ts

@@ -1,485 +0,0 @@
-/**
- * Agentic QE v3 - Coverage Analysis Coordinator
- * Orchestrates coverage analysis workflow and domain events
- */
-
-import { Result, ok, err, DomainName, Severity } from '../../shared/types';
-import { EventBus, MemoryBackend } from '../../kernel/interfaces';
-import {
-  createEvent,
-  CoverageAnalysisEvents,
-  CoverageReportPayload,
-  CoverageGapPayload,
-} from '../../shared/events';
-import {
-  CoverageAnalysisAPI,
-  AnalyzeCoverageRequest,
-  CoverageReport,
-  GapDetectionRequest,
-  CoverageGaps,
-  RiskCalculationRequest,
-  RiskReport,
-  TrendRequest,
-  CoverageTrend,
-  SimilarityRequest,
-  SimilarPatterns,
-  CoverageGap,
-  TrendPoint,
-} from './interfaces';
-import {
-  CoverageAnalyzerService,
-  GapDetectorService,
-  RiskScorerService,
-} from './services';
-
-// ============================================================================
-// Coordinator Interface
-// ============================================================================
-
-export interface ICoverageAnalysisCoordinator extends CoverageAnalysisAPI {
-  /** Initialize the coordinator */
-  initialize(): Promise<void>;
-
-  /** Dispose resources */
-  dispose(): Promise<void>;
-
-  /** Check if coordinator is ready */
-  isReady(): boolean;
-}
-
-// ============================================================================
-// Coordinator Implementation
-// ============================================================================
-
-export class CoverageAnalysisCoordinator implements ICoverageAnalysisCoordinator {
-  private readonly coverageAnalyzer: CoverageAnalyzerService;
-  private readonly gapDetector: GapDetectorService;
-  private readonly riskScorer: RiskScorerService;
-  private _initialized = false;
-
-  constructor(
-    private readonly eventBus: EventBus,
-    private readonly memory: MemoryBackend
-  ) {
-    this.coverageAnalyzer = new CoverageAnalyzerService(memory);
-    this.gapDetector = new GapDetectorService(memory);
-    this.riskScorer = new RiskScorerService(memory);
-  }
-
-  /**
-   * Initialize the coordinator and its services
-   */
-  async initialize(): Promise<void> {
-    if (this._initialized) return;
-
-    // Services are stateless, no initialization needed
-    this._initialized = true;
-  }
-
-  /**
-   * Dispose resources
-   */
-  async dispose(): Promise<void> {
-    this._initialized = false;
-  }
-
-  /**
-   * Check if coordinator is ready
-   */
-  isReady(): boolean {
-    return this._initialized;
-  }
-
-  // ============================================================================
-  // CoverageAnalysisAPI Implementation
-  // ============================================================================
-
-  /**
-   * Analyze coverage report and publish results
-   */
-  async analyze(request: AnalyzeCoverageRequest): Promise<Result<CoverageReport, Error>> {
-    try {
-      const result = await this.coverageAnalyzer.analyze(request);
-
-      if (result.success) {
-        // Publish coverage report event
-        await this.publishCoverageReport(result.value);
-      }
-
-      return result;
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Detect coverage gaps using O(log n) vector search
-   */
-  async detectGaps(request: GapDetectionRequest): Promise<Result<CoverageGaps, Error>> {
-    try {
-      const result = await this.gapDetector.detectGaps(request);
-
-      if (result.success) {
-        // Publish gap detection events for high-risk gaps
-        await this.publishGapEvents(result.value.gaps);
-      }
-
-      return result;
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Calculate risk score for uncovered code
-   */
-  async calculateRisk(request: RiskCalculationRequest): Promise<Result<RiskReport, Error>> {
-    try {
-      const result = await this.riskScorer.calculateRisk(request);
-
-      if (result.success && result.value.riskLevel === 'critical') {
-        // Publish risk zone identified event for critical risks
-        await this.publishRiskZoneEvent(result.value);
-      }
-
-      return result;
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Get coverage trend over time
-   */
-  async getTrend(request: TrendRequest): Promise<Result<CoverageTrend, Error>> {
-    try {
-      const { timeRange, granularity } = request;
-
-      // Fetch historical coverage data from memory
-      const historyKeys = await this.memory.search('coverage:history:*', 100);
-
-      if (historyKeys.length === 0) {
-        return ok({
-          dataPoints: [],
-          trend: 'stable',
-          forecast: 0,
-        });
-      }
-
-      // Load and filter data points
-      const dataPoints: TrendPoint[] = [];
-
-      for (const key of historyKeys) {
-        const timestamp = parseInt(key.split(':').pop() || '0', 10);
-        const date = new Date(timestamp);
-
-        if (date >= timeRange.start && date <= timeRange.end) {
-          const summary = await this.memory.get<{
-            line: number;
-            branch: number;
-            function: number;
-            statement: number;
-            files: number;
-          }>(key);
-
-          if (summary) {
-            dataPoints.push({ date, coverage: summary });
-          }
-        }
-      }
-
-      // Sort by date
-      dataPoints.sort((a, b) => a.date.getTime() - b.date.getTime());
-
-      // Aggregate by granularity
-      const aggregated = this.aggregateByGranularity(dataPoints, granularity);
-
-      // Analyze trend
-      const trend = this.analyzeCoverageTrend(aggregated);
-
-      // Forecast next coverage value
-      const forecast = this.forecastCoverage(aggregated);
-
-      return ok({
-        dataPoints: aggregated,
-        trend,
-        forecast,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Find similar coverage patterns using vector search
-   */
-  async findSimilar(request: SimilarityRequest): Promise<Result<SimilarPatterns, Error>> {
-    try {
-      const { pattern, k } = request;
-      const startTime = Date.now();
-
-      // Create embedding for the pattern
-      const embedding = this.createGapEmbedding(pattern);
-
-      // Perform O(log n) vector search
-      const results = await this.memory.vectorSearch(embedding, k);
-
-      // Map results to gap patterns
-      const patterns: Array<{ gap: CoverageGap; similarity: number }> = [];
-
-      for (const result of results) {
-        const metadata = result.metadata as {
-          file?: string;
-          riskScore?: number;
-          severity?: Severity;
-          lineCount?: number;
-        } | undefined;
-
-        if (metadata) {
-          patterns.push({
-            gap: {
-              id: result.key,
-              file: metadata.file || 'unknown',
-              lines: [],
-              branches: [],
-              riskScore: metadata.riskScore || 0,
-              severity: metadata.severity || 'low',
-              recommendation: 'Similar pattern found in codebase',
-            },
-            similarity: result.score,
-          });
-        }
-      }
-
-      const searchTime = Date.now() - startTime;
-
-      return ok({
-        patterns,
-        searchTime,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  // ============================================================================
-  // Event Publishing Methods
-  // ============================================================================
-
-  private async publishCoverageReport(report: CoverageReport): Promise<void> {
-    const payload: CoverageReportPayload = {
-      reportId: crypto.randomUUID(),
-      line: report.summary.line,
-      branch: report.summary.branch,
-      function: report.summary.function,
-      statement: report.summary.statement,
-      files: report.summary.files,
-    };
-
-    const event = createEvent(
-      CoverageAnalysisEvents.CoverageReportCreated,
-      'coverage-analysis' as DomainName,
-      payload
-    );
-
-    await this.eventBus.publish(event);
-  }
-
-  private async publishGapEvents(gaps: CoverageGap[]): Promise<void> {
-    // Publish events for high-risk gaps
-    const highRiskGaps = gaps.filter(
-      (g) => g.severity === 'critical' || g.severity === 'high'
-    );
-
-    for (const gap of highRiskGaps) {
-      const payload: CoverageGapPayload = {
-        gapId: gap.id,
-        file: gap.file,
-        uncoveredLines: gap.lines,
-        uncoveredBranches: gap.branches,
-        riskScore: gap.riskScore,
-      };
-
-      const event = createEvent(
-        CoverageAnalysisEvents.CoverageGapDetected,
-        'coverage-analysis' as DomainName,
-        payload
-      );
-
-      await this.eventBus.publish(event);
-    }
-  }
-
-  private async publishRiskZoneEvent(riskReport: RiskReport): Promise<void> {
-    const event = createEvent(
-      CoverageAnalysisEvents.RiskZoneIdentified,
-      'coverage-analysis' as DomainName,
-      {
-        file: riskReport.file,
-        overallRisk: riskReport.overallRisk,
-        riskLevel: riskReport.riskLevel,
-        topFactors: riskReport.factors.slice(0, 3).map((f) => f.name),
-        recommendations: riskReport.recommendations,
-      }
-    );
-
-    await this.eventBus.publish(event);
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private aggregateByGranularity(
-    dataPoints: TrendPoint[],
-    granularity: 'daily' | 'weekly' | 'monthly'
-  ): TrendPoint[] {
-    if (dataPoints.length === 0) return [];
-
-    const buckets = new Map<string, TrendPoint[]>();
-
-    for (const point of dataPoints) {
-      const key = this.getBucketKey(point.date, granularity);
-      const existing = buckets.get(key) || [];
-      existing.push(point);
-      buckets.set(key, existing);
-    }
-
-    const aggregated: TrendPoint[] = [];
-
-    for (const [, points] of buckets) {
-      if (points.length > 0) {
-        // Average the coverage metrics
-        const avgCoverage = {
-          line: points.reduce((sum, p) => sum + p.coverage.line, 0) / points.length,
-          branch: points.reduce((sum, p) => sum + p.coverage.branch, 0) / points.length,
-          function: points.reduce((sum, p) => sum + p.coverage.function, 0) / points.length,
-          statement: points.reduce((sum, p) => sum + p.coverage.statement, 0) / points.length,
-          files: Math.round(points.reduce((sum, p) => sum + p.coverage.files, 0) / points.length),
-        };
-
-        aggregated.push({
-          date: points[0].date,
-          coverage: avgCoverage,
-        });
-      }
-    }
-
-    return aggregated.sort((a, b) => a.date.getTime() - b.date.getTime());
-  }
-
-  private getBucketKey(date: Date, granularity: 'daily' | 'weekly' | 'monthly'): string {
-    const year = date.getFullYear();
-    const month = date.getMonth();
-    const day = date.getDate();
-
-    switch (granularity) {
-      case 'daily':
-        return `${year}-${month}-${day}`;
-      case 'weekly':
-        const weekNum = Math.floor(day / 7);
-        return `${year}-${month}-W${weekNum}`;
-      case 'monthly':
-        return `${year}-${month}`;
-    }
-  }
-
-  private analyzeCoverageTrend(
-    dataPoints: TrendPoint[]
-  ): 'improving' | 'declining' | 'stable' {
-    if (dataPoints.length < 2) return 'stable';
-
-    // Calculate overall coverage for each point
-    const coverages = dataPoints.map((p) => {
-      const c = p.coverage;
-      return (c.line + c.branch + c.function + c.statement) / 4;
-    });
-
-    // Simple linear regression
-    const n = coverages.length;
-    let sumX = 0;
-    let sumY = 0;
-    let sumXY = 0;
-    let sumXX = 0;
-
-    for (let i = 0; i < n; i++) {
-      sumX += i;
-      sumY += coverages[i];
-      sumXY += i * coverages[i];
-      sumXX += i * i;
-    }
-
-    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
-
-    if (slope > 0.5) return 'improving';
-    if (slope < -0.5) return 'declining';
-    return 'stable';
-  }
-
-  private forecastCoverage(dataPoints: TrendPoint[]): number {
-    if (dataPoints.length === 0) return 0;
-
-    // Calculate overall coverage for each point
-    const coverages = dataPoints.map((p) => {
-      const c = p.coverage;
-      return (c.line + c.branch + c.function + c.statement) / 4;
-    });
-
-    if (coverages.length === 1) return coverages[0];
-
-    // Exponential moving average forecast
-    const alpha = 0.3;
-    let forecast = coverages[0];
-
-    for (let i = 1; i < coverages.length; i++) {
-      forecast = alpha * coverages[i] + (1 - alpha) * forecast;
-    }
-
-    // Adjust based on trend
-    const trend = this.analyzeCoverageTrend(dataPoints);
-    if (trend === 'improving') {
-      forecast = Math.min(100, forecast + 2);
-    } else if (trend === 'declining') {
-      forecast = Math.max(0, forecast - 2);
-    }
-
-    return forecast;
-  }
-
-  private createGapEmbedding(gap: CoverageGap): number[] {
-    const VECTOR_DIMENSION = 128;
-    const embedding = new Array(VECTOR_DIMENSION).fill(0);
-
-    // Encode gap characteristics
-    embedding[0] = gap.riskScore;
-    embedding[1] = Math.min(1, gap.lines.length / 100);
-    embedding[2] = Math.min(1, gap.branches.length / 20);
-    embedding[3] = this.severityToNumber(gap.severity) / 4;
-
-    // Encode file path characteristics
-    const pathHash = gap.file.split('').reduce((acc, c) => acc + c.charCodeAt(0), 0);
-    embedding[4] = (pathHash % 1000) / 1000;
-
-    // Fill remaining with derived features
-    for (let i = 5; i < VECTOR_DIMENSION; i++) {
-      embedding[i] = Math.sin(i * gap.riskScore) * 0.5 + 0.5;
-    }
-
-    return embedding;
-  }
-
-  private severityToNumber(severity: Severity): number {
-    switch (severity) {
-      case 'critical':
-        return 4;
-      case 'high':
-        return 3;
-      case 'medium':
-        return 2;
-      case 'low':
-        return 1;
-      default:
-        return 0;
-    }
-  }
-}

package/src/domains/coverage-analysis/index.ts

@@ -1,114 +0,0 @@
-/**
- * Agentic QE v3 - Coverage Analysis Domain
- *
- * This domain provides O(log n) coverage analysis capabilities using HNSW
- * vector indexing for efficient gap detection across large codebases.
- *
- * Features:
- * - Coverage report analysis with threshold validation
- * - Gap detection using vector similarity search (O(log n) via HNSW)
- * - Risk scoring with multi-factor analysis
- * - Trend analysis and forecasting
- * - Test suggestions for coverage gaps
- * - Sublinear gap detection (ADR-003 implementation)
- *
- * Performance (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      |
- *
- * @module coverage-analysis
- */
-
-// Domain Interface and Types
-export type {
-  CoverageAnalysisAPI,
-  AnalyzeCoverageRequest,
-  CoverageData,
-  FileCoverage,
-  CoverageSummary,
-  CoverageReport,
-  CoverageDelta,
-  GapDetectionRequest,
-  CoverageGaps,
-  CoverageGap,
-  RiskCalculationRequest,
-  RiskFactor,
-  RiskReport,
-  TrendRequest,
-  CoverageTrend,
-  TrendPoint,
-  SimilarityRequest,
-  SimilarPatterns,
-} from './interfaces';
-
-// Services
-export {
-  CoverageAnalyzerService,
-  type ICoverageAnalysisService,
-} from './services/coverage-analyzer';
-
-export {
-  GapDetectorService,
-  type IGapDetectionService,
-  type TestSuggestion,
-} from './services/gap-detector';
-
-export {
-  RiskScorerService,
-  type IRiskScoringService,
-  type RiskTrend,
-  type RiskTrendPoint,
-} from './services/risk-scorer';
-
-// ============================================================================
-// ADR-003: Sublinear Algorithms for Coverage Analysis
-// O(log n) coverage gap detection using HNSW vector indexing
-// ============================================================================
-
-export {
-  HNSWIndex,
-  type IHNSWIndex,
-  type HNSWIndexConfig,
-  type HNSWSearchResult,
-  type HNSWInsertItem,
-  type HNSWIndexStats,
-  type CoverageVectorMetadata,
-  createHNSWIndex,
-  DEFAULT_HNSW_CONFIG,
-} from './services/hnsw-index';
-
-export {
-  CoverageEmbedder,
-  type ICoverageEmbedder,
-  type CoverageEmbedderConfig,
-  type CoverageQuery,
-  type EmbeddingResult,
-  createCoverageEmbedder,
-  DEFAULT_EMBEDDER_CONFIG,
-} from './services/coverage-embedder';
-
-export {
-  SublinearCoverageAnalyzer,
-  type ISublinearCoverageAnalyzer,
-  type SublinearAnalyzerConfig,
-  type SublinearAnalyzerStats,
-  type IndexingResult,
-  type RiskZone,
-  createSublinearAnalyzer,
-  DEFAULT_ANALYZER_CONFIG,
-} from './services/sublinear-analyzer';
-
-// Coordinator
-export {
-  CoverageAnalysisCoordinator,
-  type ICoverageAnalysisCoordinator,
-} from './coordinator';
-
-// Plugin
-export {
-  CoverageAnalysisPlugin,
-  createCoverageAnalysisPlugin,
-} from './plugin';