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

package/src/domains/quality-assessment/coherence/partition-detector.ts

@@ -1,469 +0,0 @@
-/**
- * Agentic QE v3 - Quality Partition Detector
- * ADR-030: Detects clusters of related quality issues
- *
- * Analyzes quality dimensions to identify partitions (clusters) of related issues.
- * Based on graph partitioning concepts from ruvector-mincut.
- */
-
-import {
-  QualityDimensions,
-  QualityPartition,
-  QualityPartitionType,
-  QualityLambda,
-  CoherenceGatePolicy,
-  DEFAULT_COHERENCE_GATE_POLICY,
-} from './types';
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * Dimension groupings for partition detection
- */
-const DIMENSION_GROUPS: Record<QualityPartitionType, (keyof QualityDimensions)[]> = {
-  testing: ['coverage', 'passRate', 'reliability'],
-  security: ['security'],
-  performance: ['performance', 'reliability'],
-  maintainability: ['maintainability', 'technicalDebt', 'duplication'],
-  mixed: [], // Used when issues span multiple groups
-};
-
-/**
- * Configuration for partition detection
- */
-export interface PartitionDetectorConfig {
-  /** Policy settings for thresholds */
-  policy: CoherenceGatePolicy;
-
-  /** Minimum severity to create a partition */
-  minPartitionSeverity: number;
-
-  /** Whether to include file paths in partitions */
-  includeAffectedPaths: boolean;
-}
-
-/**
- * Default detector configuration
- */
-const DEFAULT_DETECTOR_CONFIG: PartitionDetectorConfig = {
-  policy: DEFAULT_COHERENCE_GATE_POLICY,
-  minPartitionSeverity: 0.3,
-  includeAffectedPaths: true,
-};
-
-/**
- * Result of partition detection
- */
-export interface PartitionDetectionResult {
-  /** Detected partitions */
-  partitions: QualityPartition[];
-
-  /** Total number of partitions */
-  partitionCount: number;
-
-  /** Whether quality is fragmented (multiple severe partitions) */
-  isFragmented: boolean;
-
-  /** Overall fragmentation score (0-1, higher = more fragmented) */
-  fragmentationScore: number;
-
-  /** Recommended priority for remediation */
-  priorityPartition?: QualityPartition;
-}
-
-/**
- * Quality Partition Detector
- * Identifies clusters of related quality issues
- */
-export class PartitionDetector {
-  private readonly config: PartitionDetectorConfig;
-
-  constructor(config: Partial<PartitionDetectorConfig> = {}) {
-    this.config = { ...DEFAULT_DETECTOR_CONFIG, ...config };
-  }
-
-  /**
-   * Detect quality partitions from dimensions
-   */
-  detect(dimensions: QualityDimensions): PartitionDetectionResult {
-    const partitions: QualityPartition[] = [];
-    const threshold = this.config.policy.boundaryThreshold;
-
-    // Check each dimension group for issues
-    for (const [groupType, groupDimensions] of Object.entries(DIMENSION_GROUPS)) {
-      if (groupType === 'mixed') continue; // Mixed is handled separately
-
-      const partition = this.analyzeGroup(
-        groupType as QualityPartitionType,
-        groupDimensions,
-        dimensions,
-        threshold
-      );
-
-      if (partition && partition.severity >= this.config.minPartitionSeverity) {
-        partitions.push(partition);
-      }
-    }
-
-    // Check for mixed partition (issues across groups)
-    const mixedPartition = this.detectMixedPartition(dimensions, threshold, partitions);
-    if (mixedPartition && mixedPartition.severity >= this.config.minPartitionSeverity) {
-      // Only add mixed if it reveals additional issues
-      if (!partitions.some(p => p.dimensions.length === mixedPartition.dimensions.length)) {
-        partitions.push(mixedPartition);
-      }
-    }
-
-    // Calculate fragmentation
-    const fragmentationScore = this.calculateFragmentation(partitions, dimensions);
-    const isFragmented = fragmentationScore > 0.5;
-
-    // Find priority partition (most severe)
-    const priorityPartition = partitions.length > 0
-      ? partitions.reduce((a, b) => a.severity > b.severity ? a : b)
-      : undefined;
-
-    return {
-      partitions,
-      partitionCount: partitions.length,
-      isFragmented,
-      fragmentationScore,
-      priorityPartition,
-    };
-  }
-
-  /**
-   * Update a lambda with partition information
-   */
-  updateLambdaWithPartitions(lambda: QualityLambda): QualityLambda {
-    const result = this.detect(lambda.dimensions);
-    return {
-      ...lambda,
-      partitionCount: result.partitionCount,
-    };
-  }
-
-  /**
-   * Get remediation recommendations for partitions
-   */
-  getRemediationPlan(partitions: QualityPartition[]): RemediationPlan {
-    const steps: RemediationStep[] = [];
-
-    // Sort partitions by severity (most severe first)
-    const sorted = [...partitions].sort((a, b) => b.severity - a.severity);
-
-    for (const partition of sorted) {
-      steps.push({
-        partition,
-        priority: this.calculatePriority(partition),
-        estimatedEffort: this.estimateEffort(partition),
-        actions: this.getPartitionActions(partition),
-      });
-    }
-
-    return {
-      steps,
-      totalPartitions: partitions.length,
-      estimatedTotalEffort: steps.reduce((sum, s) => sum + s.estimatedEffort, 0),
-      criticalCount: partitions.filter(p => p.isCritical).length,
-    };
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  /**
-   * Analyze a dimension group for issues
-   */
-  private analyzeGroup(
-    type: QualityPartitionType,
-    groupDimensions: (keyof QualityDimensions)[],
-    dimensions: QualityDimensions,
-    threshold: number
-  ): QualityPartition | null {
-    const affectedDimensions: (keyof QualityDimensions)[] = [];
-    let totalSeverity = 0;
-    let hasCritical = false;
-
-    for (const dim of groupDimensions) {
-      const value = dimensions[dim];
-      if (value !== undefined && value < threshold) {
-        affectedDimensions.push(dim);
-
-        // Calculate severity for this dimension (how far below threshold)
-        const severity = (threshold - value) / threshold;
-        totalSeverity += severity;
-
-        // Check if critical (significantly below threshold)
-        if (value < threshold - 0.2) {
-          hasCritical = true;
-        }
-      }
-    }
-
-    if (affectedDimensions.length === 0) {
-      return null;
-    }
-
-    const avgSeverity = totalSeverity / affectedDimensions.length;
-
-    return {
-      id: uuidv4(),
-      type,
-      dimensions: affectedDimensions,
-      severity: avgSeverity,
-      isCritical: hasCritical,
-      remediation: this.getRemediationForType(type, avgSeverity),
-    };
-  }
-
-  /**
-   * Detect mixed partition (issues spanning multiple groups)
-   */
-  private detectMixedPartition(
-    dimensions: QualityDimensions,
-    threshold: number,
-    existingPartitions: QualityPartition[]
-  ): QualityPartition | null {
-    // Find all dimensions below threshold
-    const allAffected: (keyof QualityDimensions)[] = [];
-
-    for (const [key, value] of Object.entries(dimensions) as [keyof QualityDimensions, number | undefined][]) {
-      if (value !== undefined && value < threshold) {
-        allAffected.push(key);
-      }
-    }
-
-    if (allAffected.length <= 2) {
-      return null; // Not enough for a mixed partition
-    }
-
-    // Check if dimensions span multiple groups
-    const groups = new Set<QualityPartitionType>();
-    for (const dim of allAffected) {
-      for (const [groupType, groupDims] of Object.entries(DIMENSION_GROUPS)) {
-        if (groupDims.includes(dim)) {
-          groups.add(groupType as QualityPartitionType);
-        }
-      }
-    }
-
-    if (groups.size < 2) {
-      return null; // All in same group
-    }
-
-    // Calculate overall severity
-    let totalSeverity = 0;
-    for (const dim of allAffected) {
-      const value = dimensions[dim];
-      if (value !== undefined) {
-        totalSeverity += (threshold - value) / threshold;
-      }
-    }
-    const avgSeverity = totalSeverity / allAffected.length;
-
-    return {
-      id: uuidv4(),
-      type: 'mixed',
-      dimensions: allAffected,
-      severity: avgSeverity,
-      isCritical: avgSeverity > 0.5,
-      remediation: 'Multiple quality areas affected. Consider comprehensive quality review.',
-    };
-  }
-
-  /**
-   * Calculate fragmentation score
-   */
-  private calculateFragmentation(
-    partitions: QualityPartition[],
-    dimensions: QualityDimensions
-  ): number {
-    if (partitions.length === 0) {
-      return 0;
-    }
-
-    // Count total dimensions
-    let totalDimensions = 0;
-    for (const value of Object.values(dimensions)) {
-      if (value !== undefined) {
-        totalDimensions++;
-      }
-    }
-
-    if (totalDimensions === 0) {
-      return 0;
-    }
-
-    // Count affected dimensions across all partitions
-    const affectedDimensions = new Set<keyof QualityDimensions>();
-    for (const partition of partitions) {
-      for (const dim of partition.dimensions) {
-        affectedDimensions.add(dim);
-      }
-    }
-
-    // Fragmentation = (partitions * affected) / (total^2)
-    // Normalized to 0-1 range
-    const score = (partitions.length * affectedDimensions.size) / (totalDimensions * totalDimensions);
-
-    return Math.min(score, 1);
-  }
-
-  /**
-   * Get remediation suggestion for partition type
-   */
-  private getRemediationForType(type: QualityPartitionType, severity: number): string {
-    const remediations: Record<QualityPartitionType, string[]> = {
-      testing: [
-        'Add unit tests for uncovered code paths',
-        'Fix failing tests and investigate root causes',
-        'Implement flaky test detection and stabilization',
-      ],
-      security: [
-        'Run security vulnerability scan',
-        'Update dependencies with known vulnerabilities',
-        'Review and fix security issues immediately',
-      ],
-      performance: [
-        'Profile application for performance bottlenecks',
-        'Optimize slow code paths',
-        'Consider caching or lazy loading strategies',
-      ],
-      maintainability: [
-        'Refactor complex code sections',
-        'Reduce code duplication through abstraction',
-        'Address technical debt in high-impact areas',
-      ],
-      mixed: [
-        'Conduct comprehensive quality review',
-        'Prioritize issues by business impact',
-        'Consider dedicated quality improvement sprint',
-      ],
-    };
-
-    const suggestions = remediations[type];
-    if (severity > 0.7) {
-      return `CRITICAL: ${suggestions[2]}`;
-    } else if (severity > 0.4) {
-      return suggestions[1];
-    }
-    return suggestions[0];
-  }
-
-  /**
-   * Calculate priority for remediation step
-   */
-  private calculatePriority(partition: QualityPartition): 'critical' | 'high' | 'medium' | 'low' {
-    if (partition.isCritical) return 'critical';
-    if (partition.severity > 0.7) return 'high';
-    if (partition.severity > 0.4) return 'medium';
-    return 'low';
-  }
-
-  /**
-   * Estimate effort for partition remediation (in hours)
-   */
-  private estimateEffort(partition: QualityPartition): number {
-    const baseEffort = partition.dimensions.length * 2; // 2 hours per dimension
-    const severityMultiplier = 1 + partition.severity; // Higher severity = more effort
-
-    // Different types have different base efforts
-    const typeMultipliers: Record<QualityPartitionType, number> = {
-      testing: 1.0,
-      security: 1.5, // Security takes more care
-      performance: 1.2,
-      maintainability: 1.3, // Refactoring takes time
-      mixed: 1.5,
-    };
-
-    return Math.ceil(baseEffort * severityMultiplier * typeMultipliers[partition.type]);
-  }
-
-  /**
-   * Get specific actions for partition type
-   */
-  private getPartitionActions(partition: QualityPartition): string[] {
-    const actions: string[] = [];
-
-    switch (partition.type) {
-      case 'testing':
-        actions.push('Review test coverage reports');
-        actions.push('Identify and fix failing tests');
-        if (partition.dimensions.includes('reliability')) {
-          actions.push('Quarantine and fix flaky tests');
-        }
-        break;
-
-      case 'security':
-        actions.push('Run full security scan');
-        actions.push('Review CVE database for dependencies');
-        actions.push('Apply security patches');
-        break;
-
-      case 'performance':
-        actions.push('Profile application performance');
-        actions.push('Review and optimize slow endpoints');
-        actions.push('Check for memory leaks');
-        break;
-
-      case 'maintainability':
-        actions.push('Run code quality analysis');
-        if (partition.dimensions.includes('duplication')) {
-          actions.push('Identify and extract common code');
-        }
-        if (partition.dimensions.includes('technicalDebt')) {
-          actions.push('Prioritize technical debt items');
-        }
-        break;
-
-      case 'mixed':
-        actions.push('Schedule comprehensive quality review');
-        actions.push('Create quality improvement backlog');
-        actions.push('Assign ownership for each area');
-        break;
-    }
-
-    return actions;
-  }
-}
-
-/**
- * Remediation step for a partition
- */
-export interface RemediationStep {
-  partition: QualityPartition;
-  priority: 'critical' | 'high' | 'medium' | 'low';
-  estimatedEffort: number; // hours
-  actions: string[];
-}
-
-/**
- * Complete remediation plan
- */
-export interface RemediationPlan {
-  steps: RemediationStep[];
-  totalPartitions: number;
-  estimatedTotalEffort: number; // hours
-  criticalCount: number;
-}
-
-/**
- * Factory function to create a partition detector
- */
-export function createPartitionDetector(
-  config?: Partial<PartitionDetectorConfig>
-): PartitionDetector {
-  return new PartitionDetector(config);
-}
-
-/**
- * Convenience function to detect partitions
- */
-export function detectQualityPartitions(
-  dimensions: QualityDimensions,
-  config?: Partial<PartitionDetectorConfig>
-): PartitionDetectionResult {
-  const detector = createPartitionDetector(config);
-  return detector.detect(dimensions);
-}