agentic-qe/dist/agents/RegressionRiskAnalyzerAgent.d.ts

Agentic Quality Engineering Fleet System - AI-driven quality management platform

/**
 * RegressionRiskAnalyzerAgent - P1 Smart Test Selection Specialist
 *
 * Implements intelligent regression risk analysis using:
 * - Git integration for change detection
 * - AST parsing for code impact analysis
 * - ML-based historical pattern recognition
 * - Risk heat map generation
 * - Smart test selection (45 min → 5 min CI feedback)
 *
 * ROI: 300% through 90% CI time reduction while maintaining 95% defect detection
 *
 * Based on SPARC methodology and Week 3+ specification
 */
import { BaseAgent, BaseAgentConfig } from './BaseAgent';
import { QETask } from '../types';
export interface RegressionRiskAnalyzerConfig extends BaseAgentConfig {
    gitIntegration?: boolean;
    gitRepository?: string;
    baseBranch?: string;
    astParsing?: boolean;
    supportedLanguages?: string[];
    mlModelEnabled?: boolean;
    mlModelPath?: string;
    historicalDataWindow?: number;
    riskWeights?: {
        changedLines: number;
        complexity: number;
        criticality: number;
        dependencyCount: number;
        historicalFailures: number;
    };
    testSelectionStrategy?: 'smart' | 'full' | 'fast';
    changeImpactThreshold?: number;
    confidenceLevel?: number;
    riskHeatMapEnabled?: boolean;
    heatMapUpdateInterval?: number;
    ciOptimizationEnabled?: boolean;
    maxParallelWorkers?: number;
}
export interface ChangeAnalysis {
    commitSha: string;
    author: string;
    timestamp: Date;
    changedFiles: ChangedFile[];
    directImpact: string[];
    transitiveImpact: string[];
    blastRadius: BlastRadius;
    riskScore: number;
    riskLevel: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    testImpact: TestImpact;
    recommendation: string;
}
export interface ChangedFile {
    path: string;
    linesAdded: number;
    linesDeleted: number;
    complexity: number;
    criticality: number;
    reason?: string;
    changeType: 'added' | 'modified' | 'deleted' | 'renamed';
}
export interface BlastRadius {
    files: number;
    modules: number;
    services: number;
    controllers: number;
    affectedFeatures: string[];
    potentialUsers: number;
    revenueAtRisk: number;
}
export interface TestImpact {
    requiredTests: string[];
    totalTests: number;
    estimatedRuntime: string;
}
export interface TestSelection {
    selected: TestInfo[];
    total: number;
    reductionRate: number;
    estimatedRuntime: string;
    fullSuiteRuntime: string;
    timeSaved: string;
    confidence: number;
    skippedTests: number;
    skippedReasons: Record<string, number>;
}
export interface TestInfo {
    path: string;
    reason: string;
    failureProbability: number;
    priority: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
    runtime: string;
    coverageOverlap?: number;
}
export interface RiskHeatMap {
    timeWindow: string;
    modules: ModuleRisk[];
    visualization: string;
    updatedAt: Date;
}
export interface ModuleRisk {
    path: string;
    riskScore: number;
    riskLevel: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    factors: {
        changeFrequency: number;
        complexity: number;
        failureCount: number;
        criticality: number;
        coverage: number;
    };
    heatColor: string;
    recommendation: string;
}
export interface DependencyGraph {
    nodes: DependencyNode[];
    edges: DependencyEdge[];
    analysis: GraphAnalysis;
}
export interface DependencyNode {
    id: string;
    type: 'service' | 'controller' | 'utility' | 'model';
    criticality: number;
    path: string;
}
export interface DependencyEdge {
    from: string;
    to: string;
    type: 'imports' | 'calls' | 'extends';
    strength: number;
}
export interface GraphAnalysis {
    centralityScores: Record<string, number>;
    criticalPaths: CriticalPath[];
    circularDependencies: CircularDependency[];
}
export interface CriticalPath {
    path: string[];
    risk: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    reason: string;
}
export interface CircularDependency {
    cycle: string[];
    severity: 'LOW' | 'MEDIUM' | 'HIGH';
    recommendation: string;
}
export interface HistoricalPattern {
    pattern: string;
    historicalOccurrences: number;
    failureRate: number;
    commonFailures: string[];
    recommendation: string;
}
export interface MLModelMetrics {
    accuracy: number;
    precision: number;
    recall: number;
    f1Score: number;
    trainingSize: number;
    falsePositiveRate: number;
    falseNegativeRate: number;
}
export declare class RegressionRiskAnalyzerAgent extends BaseAgent {
    private readonly config;
    private dependencyGraph?;
    private coverageMap;
    private historicalData;
    private riskHeatMap?;
    private mlModel?;
    constructor(config: RegressionRiskAnalyzerConfig);
    protected initializeComponents(): Promise<void>;
    protected performTask(task: QETask): Promise<any>;
    protected loadKnowledge(): Promise<void>;
    protected cleanup(): Promise<void>;
    /**
     * Analyze code changes to determine impact and risk
     */
    analyzeChanges(params: {
        baseSha?: string;
        targetSha?: string;
        prNumber?: number;
    }): Promise<ChangeAnalysis>;
    /**
     * Select minimal test suite based on change analysis
     */
    selectTests(params: {
        changeAnalysis?: ChangeAnalysis;
        strategy?: 'smart' | 'full' | 'fast';
        confidence?: number;
    }): Promise<TestSelection>;
    /**
     * Calculate risk score for changes
     */
    calculateRiskScore(params: any): number;
    /**
     * Generate risk heat map
     */
    generateRiskHeatMap(): Promise<RiskHeatMap>;
    /**
     * Calculate blast radius of changes
     */
    calculateBlastRadius(params: {
        changedFiles: ChangedFile[];
        directImpact: string[];
        transitiveImpact: string[];
    }): Promise<BlastRadius>;
    /**
     * Optimize CI configuration
     */
    optimizeCI(params: {
        testSelection: TestSelection;
        maxWorkers?: number;
    }): Promise<any>;
    /**
     * Analyze release risk
     */
    analyzeRelease(params: {
        baseline: string;
        candidate: string;
    }): Promise<any>;
    /**
     * Train ML model on historical data
     */
    trainMLModel(params: {
        dataWindow?: number;
    }): Promise<MLModelMetrics>;
    private initializeGitIntegration;
    private getGitDiff;
    private parseGitDiff;
    private getGitAuthor;
    private getCommitsBetween;
    private buildDependencyGraph;
    private findDirectDependencies;
    private findTransitiveDependencies;
    private smartTestSelection;
    private fastTestSelection;
    private getCoverageBasedTests;
    private getDependencyBasedTests;
    private getHistoricalBasedTests;
    private getMLPredictedTests;
    private calculateRiskScoreFromAnalysis;
    private getRiskLevel;
    private calculateModuleRisk;
    private loadCoverageMap;
    private loadHistoricalData;
    private initializeMLModel;
    private getAllTests;
    private getAllFiles;
    private findAffectedTests;
    private calculateFileComplexity;
    private getFileCriticality;
    private classifyFileType;
    private extractServiceName;
    private extractFeatureName;
    private calculateTotalRuntime;
    private parseRuntime;
    private formatRuntime;
    private calculateTimeDifference;
    private distributeTestsAcrossWorkers;
    private calculateSpeedup;
    private deduplicateTests;
    private categorizeSkippedTests;
    private generateRecommendation;
    private generateModuleRecommendation;
    private getRiskColor;
    private generateHeatMapVisualization;
    private getRiskEmoji;
    private findSimilarChanges;
    private loadHistoricalTestResults;
    private mockDirectDependencies;
    private generateMockChangedFiles;
}
//# sourceMappingURL=RegressionRiskAnalyzerAgent.d.ts.map