@agentic-qe/v3 3.0.0-alpha.3

package/dist/workers/workers/quality-gate.js

@@ -0,0 +1,348 @@
+/**
+ * Agentic QE v3 - Quality Gate Worker
+ * ADR-014: Background Workers for QE Monitoring
+ *
+ * Continuous quality gate evaluation including:
+ * - Multi-criteria quality assessment
+ * - Release readiness scoring
+ * - Blocking issue detection
+ * - Quality trend tracking
+ */
+import { BaseWorker } from '../base-worker';
+const CONFIG = {
+    id: 'quality-gate',
+    name: 'Quality Gate Evaluator',
+    description: 'Continuously evaluates quality gates and release readiness across all quality dimensions',
+    intervalMs: 5 * 60 * 1000, // 5 minutes
+    priority: 'critical',
+    targetDomains: ['quality-assessment'],
+    enabled: true,
+    timeoutMs: 120000,
+    retryCount: 2,
+    retryDelayMs: 5000,
+};
+export class QualityGateWorker extends BaseWorker {
+    constructor() {
+        super(CONFIG);
+    }
+    async doExecute(context) {
+        const startTime = Date.now();
+        context.logger.info('Starting quality gate evaluation');
+        const findings = [];
+        const recommendations = [];
+        // Evaluate all quality gates
+        const gateStatus = await this.evaluateQualityGates(context);
+        // Analyze gate status
+        this.analyzeGateResults(gateStatus, findings, recommendations);
+        // Check for blockers
+        this.checkBlockers(gateStatus, findings, recommendations);
+        // Compare to previous
+        await this.compareToHistory(context, gateStatus, findings);
+        // Store current status
+        await context.memory.set('quality-gate:current', gateStatus);
+        await context.memory.set('quality-gate:lastCheck', new Date().toISOString());
+        // Add to history
+        const history = await context.memory.get('quality-gate:history') || [];
+        history.push(gateStatus);
+        if (history.length > 100)
+            history.shift();
+        await context.memory.set('quality-gate:history', history);
+        const healthScore = this.calculateHealthScore(gateStatus);
+        context.logger.info('Quality gate evaluation complete', {
+            healthScore,
+            passed: gateStatus.passed,
+            releaseReady: gateStatus.releaseReady,
+            blockers: gateStatus.blockers,
+        });
+        return this.createResult(Date.now() - startTime, {
+            itemsAnalyzed: gateStatus.rules.length,
+            issuesFound: gateStatus.failedRules,
+            healthScore,
+            trend: 'stable',
+            domainMetrics: {
+                gatePassed: gateStatus.passed ? 'YES' : 'NO',
+                releaseReady: gateStatus.releaseReady ? 'YES' : 'NO',
+                passedRules: gateStatus.passedRules,
+                failedRules: gateStatus.failedRules,
+                blockers: gateStatus.blockers,
+                warnings: gateStatus.warnings,
+            },
+        }, findings, recommendations);
+    }
+    async evaluateQualityGates(_context) {
+        // Define quality gate rules
+        const rules = [
+            // Coverage rules
+            {
+                id: 'coverage-line',
+                name: 'Line Coverage',
+                category: 'coverage',
+                threshold: 80,
+                operator: 'gte',
+                currentValue: 78.5,
+                unit: '%',
+                blocking: true,
+            },
+            {
+                id: 'coverage-branch',
+                name: 'Branch Coverage',
+                category: 'coverage',
+                threshold: 70,
+                operator: 'gte',
+                currentValue: 65.2,
+                unit: '%',
+                blocking: false,
+            },
+            // Reliability rules
+            {
+                id: 'reliability-test-pass-rate',
+                name: 'Test Pass Rate',
+                category: 'reliability',
+                threshold: 95,
+                operator: 'gte',
+                currentValue: 98.2,
+                unit: '%',
+                blocking: true,
+            },
+            {
+                id: 'reliability-flaky-tests',
+                name: 'Flaky Test Count',
+                category: 'reliability',
+                threshold: 5,
+                operator: 'lte',
+                currentValue: 3,
+                unit: 'tests',
+                blocking: false,
+            },
+            // Security rules
+            {
+                id: 'security-critical-vulns',
+                name: 'Critical Vulnerabilities',
+                category: 'security',
+                threshold: 0,
+                operator: 'eq',
+                currentValue: 1,
+                unit: 'issues',
+                blocking: true,
+            },
+            {
+                id: 'security-high-vulns',
+                name: 'High Vulnerabilities',
+                category: 'security',
+                threshold: 3,
+                operator: 'lte',
+                currentValue: 2,
+                unit: 'issues',
+                blocking: false,
+            },
+            // Maintainability rules
+            {
+                id: 'maintainability-complexity',
+                name: 'Average Complexity',
+                category: 'maintainability',
+                threshold: 15,
+                operator: 'lte',
+                currentValue: 12,
+                unit: 'score',
+                blocking: false,
+            },
+            {
+                id: 'maintainability-duplication',
+                name: 'Code Duplication',
+                category: 'maintainability',
+                threshold: 5,
+                operator: 'lte',
+                currentValue: 3.2,
+                unit: '%',
+                blocking: false,
+            },
+            // Performance rules
+            {
+                id: 'performance-test-duration',
+                name: 'Avg Test Duration',
+                category: 'performance',
+                threshold: 500,
+                operator: 'lte',
+                currentValue: 245,
+                unit: 'ms',
+                blocking: false,
+            },
+        ];
+        // Evaluate each rule
+        let passedRules = 0;
+        let failedRules = 0;
+        let blockers = 0;
+        let warnings = 0;
+        for (const rule of rules) {
+            const passed = this.evaluateRule(rule);
+            if (passed) {
+                passedRules++;
+            }
+            else {
+                failedRules++;
+                if (rule.blocking) {
+                    blockers++;
+                }
+                else {
+                    warnings++;
+                }
+            }
+        }
+        return {
+            passed: blockers === 0,
+            passedRules,
+            failedRules,
+            blockers,
+            warnings,
+            releaseReady: blockers === 0 && warnings <= 2,
+            rules,
+        };
+    }
+    evaluateRule(rule) {
+        switch (rule.operator) {
+            case 'gte':
+                return rule.currentValue >= rule.threshold;
+            case 'lte':
+                return rule.currentValue <= rule.threshold;
+            case 'eq':
+                return rule.currentValue === rule.threshold;
+            default:
+                return false;
+        }
+    }
+    analyzeGateResults(status, findings, recommendations) {
+        // Report failed rules
+        for (const rule of status.rules) {
+            if (!this.evaluateRule(rule)) {
+                const severity = rule.blocking ? 'critical' : 'medium';
+                findings.push({
+                    type: 'quality-gate-failure',
+                    severity,
+                    domain: 'quality-assessment',
+                    title: `Quality Gate Failed: ${rule.name}`,
+                    description: `${rule.name} is ${rule.currentValue}${rule.unit}, threshold is ${rule.operator === 'gte' ? '>=' : rule.operator === 'lte' ? '<=' : '='} ${rule.threshold}${rule.unit}`,
+                    context: {
+                        ruleId: rule.id,
+                        category: rule.category,
+                        currentValue: rule.currentValue,
+                        threshold: rule.threshold,
+                        blocking: rule.blocking,
+                    },
+                });
+            }
+        }
+        // Category-specific recommendations
+        const coverageFailures = status.rules
+            .filter(r => r.category === 'coverage' && !this.evaluateRule(r));
+        if (coverageFailures.length > 0) {
+            recommendations.push({
+                priority: coverageFailures.some(r => r.blocking) ? 'p0' : 'p2',
+                domain: 'quality-assessment',
+                action: 'Improve Test Coverage',
+                description: `${coverageFailures.length} coverage gates are failing. Add tests to increase coverage.`,
+                estimatedImpact: 'high',
+                effort: 'medium',
+                autoFixable: true,
+            });
+        }
+        const securityFailures = status.rules
+            .filter(r => r.category === 'security' && !this.evaluateRule(r));
+        if (securityFailures.length > 0) {
+            recommendations.push({
+                priority: 'p0',
+                domain: 'quality-assessment',
+                action: 'Address Security Issues',
+                description: 'Security gates are failing. Resolve vulnerabilities before release.',
+                estimatedImpact: 'high',
+                effort: 'medium',
+                autoFixable: false,
+            });
+        }
+    }
+    checkBlockers(status, findings, recommendations) {
+        if (status.blockers > 0) {
+            findings.push({
+                type: 'release-blocked',
+                severity: 'critical',
+                domain: 'quality-assessment',
+                title: 'Release Blocked',
+                description: `${status.blockers} blocking issues prevent release`,
+                context: {
+                    blockers: status.blockers,
+                    blockingRules: status.rules
+                        .filter(r => r.blocking && !this.evaluateRule(r))
+                        .map(r => r.name),
+                },
+            });
+            recommendations.push({
+                priority: 'p0',
+                domain: 'quality-assessment',
+                action: 'Resolve Release Blockers',
+                description: 'Address all blocking quality gate failures before proceeding with release.',
+                estimatedImpact: 'high',
+                effort: 'medium',
+                autoFixable: false,
+            });
+        }
+        else if (!status.releaseReady) {
+            findings.push({
+                type: 'release-warning',
+                severity: 'medium',
+                domain: 'quality-assessment',
+                title: 'Release Not Recommended',
+                description: `No blockers, but ${status.warnings} warnings suggest caution`,
+                context: { warnings: status.warnings },
+            });
+        }
+    }
+    async compareToHistory(context, current, findings) {
+        const previous = await context.memory.get('quality-gate:current');
+        if (!previous)
+            return;
+        // Check for regression
+        if (previous.passed && !current.passed) {
+            findings.push({
+                type: 'quality-gate-regression',
+                severity: 'high',
+                domain: 'quality-assessment',
+                title: 'Quality Gate Regression',
+                description: 'Quality gates were passing previously but are now failing',
+                context: {
+                    previousBlockers: previous.blockers,
+                    currentBlockers: current.blockers,
+                },
+            });
+        }
+        // Check for improvement
+        if (!previous.passed && current.passed) {
+            findings.push({
+                type: 'quality-gate-improvement',
+                severity: 'info',
+                domain: 'quality-assessment',
+                title: 'Quality Gates Now Passing',
+                description: 'All quality gates are now passing after previous failures',
+                context: {
+                    previousFailures: previous.failedRules,
+                    currentFailures: current.failedRules,
+                },
+            });
+        }
+    }
+    calculateHealthScore(status) {
+        if (status.rules.length === 0)
+            return 100;
+        // Base score from pass rate
+        const passRate = status.passedRules / status.rules.length;
+        let score = passRate * 70;
+        // Penalty for blockers
+        score -= status.blockers * 15;
+        // Penalty for warnings
+        score -= status.warnings * 5;
+        // Bonus for release readiness
+        if (status.releaseReady) {
+            score += 10;
+        }
+        return Math.max(0, Math.min(100, Math.round(score)));
+    }
+}
+//# sourceMappingURL=quality-gate.js.map

package/dist/workers/workers/quality-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-gate.js","sourceRoot":"","sources":["../../../src/workers/workers/quality-gate.ts"],"names":[],"mappings":"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"}

package/dist/workers/workers/regression-monitor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Agentic QE v3 - Regression Monitor Worker
+ * ADR-014: Background Workers for QE Monitoring
+ *
+ * Watches for regressions including:
+ * - Test result regressions
+ * - Performance regressions
+ * - Coverage regressions
+ * - Quality metric regressions
+ */
+import { BaseWorker } from '../base-worker';
+import { WorkerContext, WorkerResult } from '../interfaces';
+export declare class RegressionMonitorWorker extends BaseWorker {
+    constructor();
+    protected doExecute(context: WorkerContext): Promise<WorkerResult>;
+    private collectCurrentSnapshot;
+    private detectRegressions;
+    private analyzeRegressions;
+    private getDomainForType;
+    private formatMetricName;
+    private formatRegressionDescription;
+    private calculateHealthScore;
+}
+//# sourceMappingURL=regression-monitor.d.ts.map

package/dist/workers/workers/regression-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regression-monitor.d.ts","sourceRoot":"","sources":["../../../src/workers/workers/regression-monitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAEL,aAAa,EACb,YAAY,EAGb,MAAM,eAAe,CAAC;AAqCvB,qBAAa,uBAAwB,SAAQ,UAAU;;cAKrC,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA2D1D,sBAAsB;IAkBpC,OAAO,CAAC,iBAAiB;IAwFzB,OAAO,CAAC,kBAAkB;IAsE1B,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,oBAAoB;CAwB7B"}

package/dist/workers/workers/regression-monitor.js

@@ -0,0 +1,280 @@
+/**
+ * Agentic QE v3 - Regression Monitor Worker
+ * ADR-014: Background Workers for QE Monitoring
+ *
+ * Watches for regressions including:
+ * - Test result regressions
+ * - Performance regressions
+ * - Coverage regressions
+ * - Quality metric regressions
+ */
+import { BaseWorker } from '../base-worker';
+const CONFIG = {
+    id: 'regression-monitor',
+    name: 'Regression Monitor',
+    description: 'Monitors for regressions in test results, performance, coverage, and quality metrics',
+    intervalMs: 10 * 60 * 1000, // 10 minutes
+    priority: 'high',
+    targetDomains: ['test-execution', 'coverage-analysis', 'quality-assessment'],
+    enabled: true,
+    timeoutMs: 120000,
+    retryCount: 2,
+    retryDelayMs: 10000,
+};
+export class RegressionMonitorWorker extends BaseWorker {
+    constructor() {
+        super(CONFIG);
+    }
+    async doExecute(context) {
+        const startTime = Date.now();
+        context.logger.info('Starting regression monitoring');
+        const findings = [];
+        const recommendations = [];
+        // Get current snapshot
+        const currentSnapshot = await this.collectCurrentSnapshot(context);
+        // Get baseline (previous snapshot)
+        const baseline = await context.memory.get('regression:baseline');
+        // Detect regressions
+        let regressions = [];
+        if (baseline) {
+            regressions = this.detectRegressions(baseline, currentSnapshot);
+            this.analyzeRegressions(regressions, findings, recommendations);
+        }
+        // Store current as new baseline
+        await context.memory.set('regression:baseline', currentSnapshot);
+        // Store regression history
+        const history = await context.memory.get('regression:history') || [];
+        if (regressions.length > 0) {
+            history.push(...regressions);
+            // Keep last 100 regressions
+            while (history.length > 100)
+                history.shift();
+            await context.memory.set('regression:history', history);
+        }
+        const healthScore = this.calculateHealthScore(regressions);
+        context.logger.info('Regression monitoring complete', {
+            healthScore,
+            regressionsDetected: regressions.length,
+        });
+        return this.createResult(Date.now() - startTime, {
+            itemsAnalyzed: 5, // Number of metrics checked
+            issuesFound: regressions.length,
+            healthScore,
+            trend: regressions.length > 0 ? 'degrading' : 'stable',
+            domainMetrics: {
+                testPassRate: `${currentSnapshot.testPassRate}%`,
+                lineCoverage: `${currentSnapshot.coverage.line}%`,
+                avgTestDuration: `${currentSnapshot.avgTestDuration}ms`,
+                qualityScore: currentSnapshot.qualityScore,
+                regressionsDetected: regressions.length,
+            },
+        }, findings, recommendations);
+    }
+    async collectCurrentSnapshot(_context) {
+        // In a real implementation, this would query actual metrics
+        return {
+            timestamp: new Date(),
+            testPassRate: 98.2,
+            coverage: {
+                line: 78.5,
+                branch: 65.2,
+            },
+            avgTestDuration: 245,
+            failedTests: [
+                'test-execution/retry-handler.test.ts::should retry failed tests',
+                'coordination/workflow.test.ts::should handle concurrent workflows',
+            ],
+            qualityScore: 82,
+        };
+    }
+    detectRegressions(baseline, current) {
+        const regressions = [];
+        // Test pass rate regression
+        if (current.testPassRate < baseline.testPassRate - 1) {
+            const change = current.testPassRate - baseline.testPassRate;
+            regressions.push({
+                type: 'test',
+                metric: 'testPassRate',
+                previousValue: baseline.testPassRate,
+                currentValue: current.testPassRate,
+                changePercent: change,
+                severity: change < -5 ? 'critical' : change < -2 ? 'high' : 'medium',
+                affectedTests: current.failedTests,
+            });
+        }
+        // Coverage regression
+        if (current.coverage.line < baseline.coverage.line - 2) {
+            const change = current.coverage.line - baseline.coverage.line;
+            regressions.push({
+                type: 'coverage',
+                metric: 'lineCoverage',
+                previousValue: baseline.coverage.line,
+                currentValue: current.coverage.line,
+                changePercent: change,
+                severity: change < -5 ? 'high' : 'medium',
+            });
+        }
+        if (current.coverage.branch < baseline.coverage.branch - 3) {
+            const change = current.coverage.branch - baseline.coverage.branch;
+            regressions.push({
+                type: 'coverage',
+                metric: 'branchCoverage',
+                previousValue: baseline.coverage.branch,
+                currentValue: current.coverage.branch,
+                changePercent: change,
+                severity: change < -5 ? 'high' : 'medium',
+            });
+        }
+        // Performance regression
+        const durationChange = ((current.avgTestDuration - baseline.avgTestDuration) / baseline.avgTestDuration) * 100;
+        if (durationChange > 20) {
+            regressions.push({
+                type: 'performance',
+                metric: 'avgTestDuration',
+                previousValue: baseline.avgTestDuration,
+                currentValue: current.avgTestDuration,
+                changePercent: durationChange,
+                severity: durationChange > 50 ? 'high' : 'medium',
+            });
+        }
+        // Quality score regression
+        if (current.qualityScore < baseline.qualityScore - 5) {
+            const change = current.qualityScore - baseline.qualityScore;
+            regressions.push({
+                type: 'quality',
+                metric: 'qualityScore',
+                previousValue: baseline.qualityScore,
+                currentValue: current.qualityScore,
+                changePercent: change,
+                severity: change < -10 ? 'critical' : change < -5 ? 'high' : 'medium',
+            });
+        }
+        // New test failures
+        const newFailures = current.failedTests.filter(t => !baseline.failedTests.includes(t));
+        if (newFailures.length > 0) {
+            regressions.push({
+                type: 'test',
+                metric: 'newFailures',
+                previousValue: 0,
+                currentValue: newFailures.length,
+                changePercent: 100,
+                severity: newFailures.length > 5 ? 'critical' : newFailures.length > 2 ? 'high' : 'medium',
+                affectedTests: newFailures,
+            });
+        }
+        return regressions;
+    }
+    analyzeRegressions(regressions, findings, recommendations) {
+        for (const regression of regressions) {
+            const domain = this.getDomainForType(regression.type);
+            findings.push({
+                type: `${regression.type}-regression`,
+                severity: regression.severity,
+                domain,
+                title: `${this.formatMetricName(regression.metric)} Regression Detected`,
+                description: this.formatRegressionDescription(regression),
+                context: {
+                    previousValue: regression.previousValue,
+                    currentValue: regression.currentValue,
+                    changePercent: regression.changePercent.toFixed(2),
+                    affectedTests: regression.affectedTests,
+                },
+            });
+        }
+        // Generate recommendations based on regression types
+        const testRegressions = regressions.filter(r => r.type === 'test');
+        if (testRegressions.length > 0) {
+            const criticalOrHigh = testRegressions.filter(r => r.severity === 'critical' || r.severity === 'high');
+            if (criticalOrHigh.length > 0) {
+                recommendations.push({
+                    priority: 'p0',
+                    domain: 'test-execution',
+                    action: 'Investigate Test Regressions Immediately',
+                    description: `${criticalOrHigh.length} significant test regressions detected. Review recent changes.`,
+                    estimatedImpact: 'high',
+                    effort: 'medium',
+                    autoFixable: false,
+                });
+            }
+        }
+        const coverageRegressions = regressions.filter(r => r.type === 'coverage');
+        if (coverageRegressions.length > 0) {
+            recommendations.push({
+                priority: 'p1',
+                domain: 'coverage-analysis',
+                action: 'Address Coverage Regression',
+                description: 'Code coverage has decreased. Add tests for new/changed code.',
+                estimatedImpact: 'medium',
+                effort: 'medium',
+                autoFixable: true,
+            });
+        }
+        const performanceRegressions = regressions.filter(r => r.type === 'performance');
+        if (performanceRegressions.length > 0) {
+            recommendations.push({
+                priority: 'p2',
+                domain: 'test-execution',
+                action: 'Investigate Performance Regression',
+                description: 'Test execution has slowed. Review for new slow tests or infrastructure issues.',
+                estimatedImpact: 'medium',
+                effort: 'low',
+                autoFixable: false,
+            });
+        }
+    }
+    getDomainForType(type) {
+        switch (type) {
+            case 'test':
+            case 'performance':
+                return 'test-execution';
+            case 'coverage':
+                return 'coverage-analysis';
+            case 'quality':
+                return 'quality-assessment';
+            default:
+                return 'quality-assessment';
+        }
+    }
+    formatMetricName(metric) {
+        const names = {
+            testPassRate: 'Test Pass Rate',
+            lineCoverage: 'Line Coverage',
+            branchCoverage: 'Branch Coverage',
+            avgTestDuration: 'Test Duration',
+            qualityScore: 'Quality Score',
+            newFailures: 'New Test Failures',
+        };
+        return names[metric] || metric;
+    }
+    formatRegressionDescription(regression) {
+        if (regression.metric === 'newFailures') {
+            return `${regression.currentValue} new test failures detected since last check`;
+        }
+        const direction = regression.changePercent > 0 ? 'increased' : 'decreased';
+        const unit = regression.type === 'performance' ? 'ms' : '%';
+        return `${this.formatMetricName(regression.metric)} ${direction} from ${regression.previousValue}${unit} to ${regression.currentValue}${unit} (${regression.changePercent > 0 ? '+' : ''}${regression.changePercent.toFixed(1)}%)`;
+    }
+    calculateHealthScore(regressions) {
+        if (regressions.length === 0)
+            return 100;
+        let score = 100;
+        for (const regression of regressions) {
+            switch (regression.severity) {
+                case 'critical':
+                    score -= 25;
+                    break;
+                case 'high':
+                    score -= 15;
+                    break;
+                case 'medium':
+                    score -= 8;
+                    break;
+                case 'low':
+                    score -= 3;
+                    break;
+            }
+        }
+        return Math.max(0, Math.round(score));
+    }
+}
+//# sourceMappingURL=regression-monitor.js.map