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

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

/**
 * DeploymentReadinessAgent - Aggregates quality signals for deployment risk assessment and go/no-go decisions
 *
 * Core capabilities:
 * - Risk scoring algorithm (aggregates quality-gate, performance, security signals)
 * - Release confidence calculation (0-100 score with thresholds: 95=GO, 70-95=REVIEW, <70=BLOCK)
 * - Rollback risk prediction (deployment blast radius analysis)
 * - Automated deployment checklist validation
 * - Stakeholder report generation (Slack/email/dashboard)
 * - Integration with quality-gate, performance-tester, security-scanner agents
 *
 * Memory namespaces:
 * - aqe/deployment/reports/* - Deployment readiness reports
 * - aqe/deployment/confidence-scores/* - Confidence calculations
 * - aqe/deployment/rollback-risk/* - Rollback predictions
 * - aqe/deployment/decisions/* - Go/No-Go decisions
 * - aqe/deployment/checklists/* - Validation checklists
 */
import { BaseAgent, BaseAgentConfig } from './BaseAgent';
import { QETask } from '../types';
export interface DeploymentReadinessAgentConfig extends BaseAgentConfig {
    integrations?: {
        qualityGate?: boolean;
        performance?: boolean;
        security?: boolean;
        monitoring?: string[];
    };
    thresholds?: {
        minConfidenceScore: number;
        reviewThreshold: number;
        maxRollbackRisk: number;
        maxOpenIncidents: number;
    };
    checklist?: {
        requiredApprovals: string[];
        requiredTests: string[];
        requiredMetrics: string[];
    };
}
export interface DeploymentMetadata {
    deploymentId: string;
    version: string;
    environment: string;
    changeSize?: number;
    filesModified?: number;
    timestamp: Date;
}
export interface QualitySignals {
    qualityGate?: {
        status: 'passed' | 'failed' | 'warning';
        score: number;
        violations: Array<{
            severity: 'blocker' | 'critical' | 'major' | 'minor';
            type: string;
            count: number;
        }>;
    };
    performance?: {
        p50: number;
        p95: number;
        p99: number;
        throughput: number;
        errorRate: number;
        status: 'passed' | 'failed' | 'warning';
    };
    security?: {
        vulnerabilities: {
            critical: number;
            high: number;
            medium: number;
            low: number;
        };
        status: 'passed' | 'failed' | 'warning';
    };
    coverage?: {
        line: number;
        branch: number;
        function: number;
        statement: number;
    };
    testResults?: {
        total: number;
        passed: number;
        failed: number;
        skipped: number;
        flakyCount: number;
    };
}
export interface ReadinessCheckResult {
    deploymentId: string;
    decision: 'GO' | 'REVIEW' | 'BLOCK';
    confidenceScore: number;
    riskLevel: 'low' | 'medium' | 'high' | 'critical';
    signals: QualitySignals;
    checklist: ChecklistResult;
    rollbackRisk: RollbackRiskAssessment;
    reasons: string[];
    recommendations: string[];
    timestamp: Date;
}
export interface ChecklistResult {
    overallStatus: 'passed' | 'failed' | 'partial';
    items: ChecklistItem[];
    passedCount: number;
    failedCount: number;
    warningCount: number;
}
export interface ChecklistItem {
    category: 'code_quality' | 'testing' | 'security' | 'operations' | 'compliance';
    name: string;
    status: 'passed' | 'failed' | 'warning' | 'skipped';
    validatedBy: string;
    details: string;
    required: boolean;
}
export interface RollbackRiskAssessment {
    probability: number;
    level: 'low' | 'medium' | 'high' | 'critical';
    factors: {
        changeSize: number;
        technicalComplexity: number;
        blastRadius: number;
        testCoverage: number;
    };
    estimatedRecoveryTime: number;
    mitigationStrategies: string[];
    rollbackPlan: {
        method: string;
        steps: string[];
        estimatedTime: number;
        automated: boolean;
    };
}
export interface ConfidenceCalculation {
    score: number;
    level: 'very_low' | 'low' | 'medium' | 'high' | 'very_high';
    factors: {
        qualityScore: number;
        performanceScore: number;
        securityScore: number;
    };
    historicalComparison: {
        averageSuccessRate: number;
        thisDeploymentProjection: number;
        percentageImprovement: number;
    };
    basedOnDeployments: number;
    recommendation: string;
}
export interface StakeholderReport {
    deploymentId: string;
    version: string;
    decision: 'GO' | 'REVIEW' | 'BLOCK';
    confidenceScore: number;
    riskLevel: string;
    executiveSummary: string;
    keyMetrics: Record<string, any>;
    changesSummary: string;
    riskAssessment: string;
    deploymentPlan: string;
    outstandingItems: string[];
    recommendation: string;
    format: 'markdown' | 'html' | 'json';
    timestamp: Date;
}
export declare class DeploymentReadinessAgent extends BaseAgent {
    private readonly config;
    private monitoringClients;
    private deploymentHistory;
    constructor(config: DeploymentReadinessAgentConfig);
    protected initializeComponents(): Promise<void>;
    protected loadKnowledge(): Promise<void>;
    protected cleanup(): Promise<void>;
    protected performTask(task: QETask): Promise<any>;
    /**
     * Perform comprehensive deployment readiness check
     */
    private performReadinessCheck;
    /**
     * Aggregate quality signals from all testing stages
     */
    private aggregateQualitySignals;
    /**
     * Calculate release confidence score using weighted factors
     */
    private calculateConfidenceScore;
    private getQualityScore;
    private getPerformanceScore;
    private getSecurityScore;
    private calculateHistoricalComparison;
    private generateConfidenceRecommendation;
    /**
     * Predict rollback probability and prepare mitigation
     */
    private predictRollbackRisk;
    private assessChangeSize;
    private assessTechnicalComplexity;
    private assessBlastRadius;
    private assessTestCoverage;
    private generateMitigationStrategies;
    private generateRollbackPlan;
    private estimateRecoveryTime;
    /**
     * Validate deployment checklist
     */
    private validateChecklist;
    private checkCodeReview;
    private checkCodeQuality;
    private checkLinting;
    private checkUnitTests;
    private checkIntegrationTests;
    private checkE2ETests;
    private checkPerformanceTests;
    private checkVulnerabilities;
    private checkDependencyAudit;
    private checkSecurityScan;
    private checkDatabaseMigrations;
    private checkRollbackPlan;
    private checkMonitoring;
    private checkFeatureFlags;
    private checkCompliance;
    /**
     * Make final deployment decision based on all factors
     */
    private makeDeploymentDecision;
    private calculateRiskLevel;
    /**
     * Generate stakeholder-friendly deployment report
     */
    private generateReadinessReport;
    private generateExecutiveSummary;
    private extractKeyMetrics;
    private generateRiskAssessmentSummary;
    private generateDeploymentPlanSummary;
    private extractOutstandingItems;
    /**
     * Monitor deployment health in real-time
     */
    private monitorDeployment;
    private handleQualityGateResult;
    private handlePerformanceResults;
    private handleSecurityResults;
}
//# sourceMappingURL=DeploymentReadinessAgent.d.ts.map