agentic-qe 2.3.2 → 2.3.3

package/dist/mcp/handlers/quality-analyze.js

@@ -1,720 +0,0 @@
-"use strict";
-/**
- * Quality Analysis Handler
- *
- * Handles comprehensive quality analysis and reporting.
- * Generates insights and recommendations for quality improvement.
- *
- * @version 1.0.0
- * @author Agentic QE Team
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QualityAnalyzeHandler = void 0;
-const base_handler_js_1 = require("./base-handler.js");
-const SecureRandom_js_1 = require("../../utils/SecureRandom.js");
-class QualityAnalyzeHandler extends base_handler_js_1.BaseHandler {
-    constructor(registry, hookExecutor) {
-        super();
-        this.analysisHistory = new Map();
-        this.analyzers = new Map();
-        this.registry = registry;
-        this.hookExecutor = hookExecutor;
-        this.initializeAnalyzers();
-    }
-    async handle(args) {
-        const requestId = this.generateRequestId();
-        this.log('info', 'Starting quality analysis', { requestId, params: args.params });
-        let agentId;
-        try {
-            // Validate required parameters
-            this.validateRequired(args, ['params']);
-            this.validateQualityAnalysisParams(args.params);
-            // Spawn or find quality-gate agent
-            const spawnResult = await this.registry.spawnAgent('quality-gate', {
-                name: 'quality-analyzer',
-                description: `Quality analysis for ${args.params.scope}`
-            });
-            agentId = spawnResult.id;
-            this.log('info', 'Quality-gate agent spawned', { agentId });
-            // Execute pre-task hook
-            await this.hookExecutor.executePreTask({
-                description: `Analyzing quality: ${args.params.scope} with metrics: ${args.params.metrics.join(', ')}`,
-                agentType: 'quality-gate',
-                agentId,
-                sessionId: requestId
-            });
-            // Execute quality analysis through agent
-            const { result: qualityReport, executionTime } = await this.measureExecutionTime(async () => {
-                // Ensure dataSource has a default context if missing
-                const dataSourceWithContext = args.dataSource ? {
-                    ...args.dataSource,
-                    context: args.dataSource.context || {
-                        deploymentTarget: 'development',
-                        criticality: 'medium',
-                        environment: process.env.NODE_ENV || 'development',
-                        changes: []
-                    }
-                } : {
-                    context: {
-                        deploymentTarget: 'development',
-                        criticality: 'medium',
-                        environment: process.env.NODE_ENV || 'development',
-                        changes: []
-                    }
-                };
-                const taskResult = await this.registry.executeTask(agentId, {
-                    taskType: 'analyze-quality',
-                    input: args.params,
-                    dataSource: dataSourceWithContext
-                });
-                // If agent returns a quality report, use it; otherwise, perform analysis locally
-                if (taskResult.output && typeof taskResult.output === 'object' && 'id' in taskResult.output) {
-                    return taskResult.output;
-                }
-                // Fallback to local analysis if agent doesn't implement quality analysis yet
-                this.log('info', 'Agent did not return quality report, performing local analysis');
-                return await this.performQualityAnalysis(args.params, args.dataSource);
-            });
-            this.log('info', `Quality analysis completed in ${executionTime.toFixed(2)}ms`, {
-                reportId: qualityReport.id,
-                overallScore: qualityReport.score.overall,
-                grade: qualityReport.score.grade
-            });
-            // Execute post-task hook with results
-            await this.hookExecutor.executePostTask({
-                taskId: agentId,
-                agentType: 'quality-gate',
-                agentId,
-                sessionId: requestId,
-                results: {
-                    reportId: qualityReport.id,
-                    scope: qualityReport.scope,
-                    score: qualityReport.score,
-                    thresholdsPassed: qualityReport.thresholds.passed,
-                    recommendations: qualityReport.recommendations.length,
-                    assessments: qualityReport.assessments.length
-                }
-            });
-            return this.createSuccessResponse(qualityReport, requestId);
-        }
-        catch (error) {
-            this.log('error', 'Quality analysis failed', { error: error instanceof Error ? error.message : String(error) });
-            // Execute error notification hook if agent was spawned
-            if (agentId) {
-                await this.hookExecutor.notify({
-                    message: `Quality analysis failed: ${error instanceof Error ? error.message : String(error)}`,
-                    level: 'error'
-                });
-            }
-            return this.createErrorResponse(error instanceof Error ? error.message : 'Quality analysis failed', requestId);
-        }
-    }
-    initializeAnalyzers() {
-        this.analyzers.set('code', {
-            metrics: ['complexity', 'coverage', 'duplication', 'debt'],
-            tools: ['sonarqube', 'eslint', 'complexity-analysis'],
-            thresholds: {
-                cyclomaticComplexity: 10,
-                coverage: 80,
-                duplication: 3
-            }
-        });
-        this.analyzers.set('tests', {
-            metrics: ['reliability', 'effectiveness', 'efficiency', 'coverage'],
-            tools: ['mutation-testing', 'flaky-test-detection', 'test-metrics'],
-            thresholds: {
-                flakyRate: 2,
-                mutationScore: 75,
-                successRate: 98
-            }
-        });
-        this.analyzers.set('performance', {
-            metrics: ['responseTime', 'throughput', 'resources', 'bottlenecks'],
-            tools: ['performance-profiler', 'load-testing', 'apm'],
-            thresholds: {
-                responseTime: 200,
-                throughput: 1000,
-                cpuUsage: 80
-            }
-        });
-        this.analyzers.set('security', {
-            metrics: ['vulnerabilities', 'compliance', 'dependencies'],
-            tools: ['security-scanner', 'dependency-checker', 'compliance-validator'],
-            thresholds: {
-                criticalVulns: 0,
-                highVulns: 2,
-                complianceScore: 85
-            }
-        });
-    }
-    validateQualityAnalysisParams(params) {
-        const validScopes = ['code', 'tests', 'performance', 'security', 'all'];
-        if (!validScopes.includes(params.scope)) {
-            throw new Error(`Invalid scope: ${params.scope}. Must be one of: ${validScopes.join(', ')}`);
-        }
-        if (!params.metrics || params.metrics.length === 0) {
-            throw new Error('At least one metric must be specified');
-        }
-    }
-    async performQualityAnalysis(params, dataSource) {
-        const reportId = `quality-report-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(3)}`;
-        this.log('info', 'Performing quality analysis', { reportId, scope: params.scope });
-        // Collect metrics based on scope
-        const metrics = await this.collectMetrics(params, dataSource);
-        // Perform assessments
-        const assessments = await this.performAssessments(metrics, params);
-        // Generate recommendations
-        const recommendations = params.generateRecommendations
-            ? await this.generateRecommendations(assessments, metrics)
-            : [];
-        // Analyze trends if historical comparison is enabled
-        const trends = params.historicalComparison
-            ? await this.analyzeTrends(reportId, metrics)
-            : this.createEmptyTrends();
-        // Evaluate thresholds
-        const thresholds = await this.evaluateThresholds(metrics, params.thresholds);
-        // Calculate composite score
-        const score = this.calculateCompositeScore(assessments, thresholds);
-        const qualityReport = {
-            id: reportId,
-            scope: params.scope,
-            analysisType: 'comprehensive',
-            generatedAt: new Date().toISOString(),
-            metrics,
-            assessments,
-            recommendations,
-            trends,
-            thresholds,
-            score
-        };
-        // Store report
-        this.analysisHistory.set(reportId, qualityReport);
-        return qualityReport;
-    }
-    async collectMetrics(params, dataSource) {
-        const metrics = {
-            code: await this.collectCodeMetrics(params, dataSource),
-            test: await this.collectTestMetrics(params, dataSource),
-            performance: await this.collectPerformanceMetrics(params, dataSource),
-            security: await this.collectSecurityMetrics(params, dataSource),
-            maintainability: await this.collectMaintainabilityMetrics(params, dataSource)
-        };
-        return metrics;
-    }
-    async collectCodeMetrics(params, dataSource) {
-        // Simulate code quality metrics collection
-        await new Promise(resolve => setTimeout(resolve, 100));
-        return {
-            complexity: {
-                cyclomatic: SecureRandom_js_1.SecureRandom.randomFloat() * 15 + 5, // 5-20
-                cognitive: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 10, // 10-30
-                maintainabilityIndex: SecureRandom_js_1.SecureRandom.randomFloat() * 40 + 60 // 60-100
-            },
-            coverage: {
-                line: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75, // 75-95%
-                branch: SecureRandom_js_1.SecureRandom.randomFloat() * 25 + 70, // 70-95%
-                function: SecureRandom_js_1.SecureRandom.randomFloat() * 15 + 80, // 80-95%
-                statement: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75 // 75-95%
-            },
-            duplication: {
-                percentage: SecureRandom_js_1.SecureRandom.randomFloat() * 8 + 2, // 2-10%
-                lines: SecureRandom_js_1.SecureRandom.randomInt(50, 550), // 50-550
-                blocks: SecureRandom_js_1.SecureRandom.randomInt(5, 25) // 5-25
-            },
-            technicalDebt: {
-                ratio: SecureRandom_js_1.SecureRandom.randomFloat() * 0.3 + 0.1, // 10-40%
-                estimatedHours: SecureRandom_js_1.SecureRandom.randomFloat() * 100 + 20, // 20-120 hours
-                issues: this.generateTechnicalDebtIssues()
-            }
-        };
-    }
-    async collectTestMetrics(params, dataSource) {
-        // Simulate test quality metrics collection
-        await new Promise(resolve => setTimeout(resolve, 100));
-        return {
-            reliability: {
-                flakyTests: SecureRandom_js_1.SecureRandom.randomInt(0, 5), // 0-5
-                successRate: SecureRandom_js_1.SecureRandom.randomFloat() * 5 + 95, // 95-100%
-                averageRetries: SecureRandom_js_1.SecureRandom.randomFloat() * 0.5 + 0.1 // 0.1-0.6
-            },
-            effectiveness: {
-                mutationScore: SecureRandom_js_1.SecureRandom.randomFloat() * 25 + 70, // 70-95%
-                defectDetectionRate: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75, // 75-95%
-                falsePositiveRate: SecureRandom_js_1.SecureRandom.randomFloat() * 5 + 1 // 1-6%
-            },
-            efficiency: {
-                executionTime: SecureRandom_js_1.SecureRandom.randomFloat() * 300 + 60, // 60-360 seconds
-                parallelization: SecureRandom_js_1.SecureRandom.randomFloat() * 0.3 + 0.6, // 60-90%
-                resourceUsage: SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 40 // 40-70%
-            },
-            coverage: {
-                achieved: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75, // 75-95%
-                target: 80,
-                gaps: this.generateCoverageGaps()
-            }
-        };
-    }
-    async collectPerformanceMetrics(params, dataSource) {
-        // Simulate performance metrics collection
-        await new Promise(resolve => setTimeout(resolve, 100));
-        return {
-            responseTime: {
-                average: SecureRandom_js_1.SecureRandom.randomFloat() * 200 + 50, // 50-250ms
-                p95: SecureRandom_js_1.SecureRandom.randomFloat() * 500 + 100, // 100-600ms
-                p99: SecureRandom_js_1.SecureRandom.randomFloat() * 1000 + 200 // 200-1200ms
-            },
-            throughput: {
-                requestsPerSecond: SecureRandom_js_1.SecureRandom.randomFloat() * 2000 + 500, // 500-2500 RPS
-                concurrent: SecureRandom_js_1.SecureRandom.randomFloat() * 100 + 50 // 50-150 concurrent
-            },
-            resources: {
-                cpu: SecureRandom_js_1.SecureRandom.randomFloat() * 40 + 30, // 30-70%
-                memory: SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 50, // 50-80%
-                network: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 10 // 10-30%
-            },
-            bottlenecks: this.generatePerformanceBottlenecks()
-        };
-    }
-    async collectSecurityMetrics(params, dataSource) {
-        // Simulate security metrics collection
-        await new Promise(resolve => setTimeout(resolve, 100));
-        return {
-            vulnerabilities: {
-                critical: SecureRandom_js_1.SecureRandom.randomInt(0, 2), // 0-1
-                high: SecureRandom_js_1.SecureRandom.randomInt(0, 5), // 0-4
-                medium: SecureRandom_js_1.SecureRandom.randomInt(2, 12), // 2-12
-                low: SecureRandom_js_1.SecureRandom.randomInt(5, 25) // 5-25
-            },
-            compliance: {
-                owasp: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75, // 75-95%
-                score: SecureRandom_js_1.SecureRandom.randomFloat() * 25 + 70, // 70-95
-                issues: this.generateSecurityIssues()
-            },
-            dependencies: {
-                outdated: SecureRandom_js_1.SecureRandom.randomInt(2, 12), // 2-12
-                vulnerable: SecureRandom_js_1.SecureRandom.randomInt(0, 3), // 0-2
-                licenses: this.generateLicenseIssues()
-            }
-        };
-    }
-    async collectMaintainabilityMetrics(params, dataSource) {
-        // Simulate maintainability metrics collection
-        await new Promise(resolve => setTimeout(resolve, 50));
-        return {
-            readability: SecureRandom_js_1.SecureRandom.randomFloat() * 25 + 70, // 70-95
-            documentation: SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 60, // 60-90
-            testability: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75, // 75-95
-            modularity: SecureRandom_js_1.SecureRandom.randomFloat() * 25 + 70, // 70-95
-            changeability: SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 65 // 65-95
-        };
-    }
-    async performAssessments(metrics, params) {
-        const assessments = [];
-        if (params.scope === 'all' || params.scope === 'code') {
-            assessments.push(...this.assessCodeQuality(metrics.code));
-        }
-        if (params.scope === 'all' || params.scope === 'tests') {
-            assessments.push(...this.assessTestQuality(metrics.test));
-        }
-        if (params.scope === 'all' || params.scope === 'performance') {
-            assessments.push(...this.assessPerformanceQuality(metrics.performance));
-        }
-        if (params.scope === 'all' || params.scope === 'security') {
-            assessments.push(...this.assessSecurityQuality(metrics.security));
-        }
-        return assessments;
-    }
-    assessCodeQuality(metrics) {
-        return [
-            {
-                category: 'code-complexity',
-                score: this.normalizeScore(20 - metrics.complexity.cyclomatic, 0, 20) * 100,
-                status: metrics.complexity.cyclomatic < 10 ? 'good' : metrics.complexity.cyclomatic < 15 ? 'fair' : 'poor',
-                details: `Cyclomatic complexity: ${metrics.complexity.cyclomatic.toFixed(1)}`,
-                evidence: ['complexity-analysis', 'static-analysis'],
-                impact: metrics.complexity.cyclomatic > 15 ? 'high' : 'medium'
-            },
-            {
-                category: 'code-coverage',
-                score: metrics.coverage.line,
-                status: metrics.coverage.line > 85 ? 'excellent' : metrics.coverage.line > 75 ? 'good' : 'fair',
-                details: `Line coverage: ${metrics.coverage.line.toFixed(1)}%`,
-                evidence: ['coverage-report', 'test-execution'],
-                impact: metrics.coverage.line < 70 ? 'high' : 'medium'
-            }
-        ];
-    }
-    assessTestQuality(metrics) {
-        return [
-            {
-                category: 'test-reliability',
-                score: metrics.reliability.successRate,
-                status: metrics.reliability.successRate > 98 ? 'excellent' : metrics.reliability.successRate > 95 ? 'good' : 'fair',
-                details: `Test success rate: ${metrics.reliability.successRate.toFixed(1)}%, Flaky tests: ${metrics.reliability.flakyTests}`,
-                evidence: ['test-execution-history', 'flaky-test-detection'],
-                impact: metrics.reliability.successRate < 95 ? 'high' : 'medium'
-            },
-            {
-                category: 'test-effectiveness',
-                score: metrics.effectiveness.mutationScore,
-                status: metrics.effectiveness.mutationScore > 80 ? 'excellent' : metrics.effectiveness.mutationScore > 70 ? 'good' : 'fair',
-                details: `Mutation score: ${metrics.effectiveness.mutationScore.toFixed(1)}%`,
-                evidence: ['mutation-testing', 'defect-analysis'],
-                impact: metrics.effectiveness.mutationScore < 70 ? 'high' : 'medium'
-            }
-        ];
-    }
-    assessPerformanceQuality(metrics) {
-        return [
-            {
-                category: 'response-time',
-                score: this.normalizeScore(500 - metrics.responseTime.p95, 0, 500) * 100,
-                status: metrics.responseTime.p95 < 200 ? 'excellent' : metrics.responseTime.p95 < 500 ? 'good' : 'fair',
-                details: `P95 response time: ${metrics.responseTime.p95.toFixed(0)}ms`,
-                evidence: ['performance-testing', 'apm-monitoring'],
-                impact: metrics.responseTime.p95 > 500 ? 'high' : 'medium'
-            }
-        ];
-    }
-    assessSecurityQuality(metrics) {
-        return [
-            {
-                category: 'security-vulnerabilities',
-                score: this.calculateSecurityScore(metrics.vulnerabilities),
-                status: metrics.vulnerabilities.critical === 0 && metrics.vulnerabilities.high < 2 ? 'good' : 'poor',
-                details: `Critical: ${metrics.vulnerabilities.critical}, High: ${metrics.vulnerabilities.high}`,
-                evidence: ['security-scanning', 'vulnerability-assessment'],
-                impact: metrics.vulnerabilities.critical > 0 ? 'critical' : metrics.vulnerabilities.high > 3 ? 'high' : 'medium'
-            }
-        ];
-    }
-    async generateRecommendations(assessments, metrics) {
-        const recommendations = [];
-        // Generate recommendations based on assessments
-        for (const assessment of assessments) {
-            if (assessment.score < 70 || assessment.status === 'poor' || assessment.status === 'critical') {
-                const recommendation = this.createRecommendationForAssessment(assessment);
-                recommendations.push(recommendation);
-            }
-        }
-        // Add proactive recommendations
-        recommendations.push(...this.generateProactiveRecommendations(metrics));
-        return recommendations;
-    }
-    createRecommendationForAssessment(assessment) {
-        const recommendationMap = {
-            'code-complexity': {
-                title: 'Reduce Code Complexity',
-                description: 'Break down complex functions and classes to improve maintainability',
-                effort: 'medium',
-                impact: 'high',
-                actions: [
-                    {
-                        type: 'code',
-                        description: 'Extract methods from complex functions',
-                        automated: false
-                    }
-                ]
-            },
-            'code-coverage': {
-                title: 'Improve Test Coverage',
-                description: 'Add tests for uncovered code paths',
-                effort: 'medium',
-                impact: 'high',
-                actions: [
-                    {
-                        type: 'test',
-                        description: 'Generate tests for uncovered functions',
-                        automated: true
-                    }
-                ]
-            },
-            'test-reliability': {
-                title: 'Fix Flaky Tests',
-                description: 'Identify and fix unreliable tests',
-                effort: 'high',
-                impact: 'high',
-                actions: [
-                    {
-                        type: 'test',
-                        description: 'Analyze and fix flaky test patterns',
-                        automated: false
-                    }
-                ]
-            }
-        };
-        const template = recommendationMap[assessment.category] || {
-            title: 'Improve Quality',
-            description: 'Address quality issues in this category',
-            effort: 'medium',
-            impact: 'medium',
-            actions: []
-        };
-        return {
-            id: `rec-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(2)}`,
-            category: assessment.category,
-            priority: assessment.impact === 'critical' ? 'critical' : assessment.impact === 'high' ? 'high' : 'medium',
-            title: template.title,
-            description: template.description,
-            effort: template.effort,
-            impact: template.impact,
-            actions: template.actions,
-            estimatedHours: this.estimateHours(template.effort, template.impact)
-        };
-    }
-    generateProactiveRecommendations(metrics) {
-        const recommendations = [];
-        // Add proactive recommendations based on trends and best practices
-        if (metrics.maintainability.documentation < 80) {
-            recommendations.push({
-                id: `rec-proactive-${Date.now()}`,
-                category: 'documentation',
-                priority: 'medium',
-                title: 'Improve Documentation',
-                description: 'Enhance code documentation to improve maintainability',
-                effort: 'low',
-                impact: 'medium',
-                actions: [
-                    {
-                        type: 'code',
-                        description: 'Add JSDoc comments to functions',
-                        automated: true
-                    }
-                ],
-                estimatedHours: 8
-            });
-        }
-        return recommendations;
-    }
-    async analyzeTrends(reportId, metrics) {
-        // Simulate trend analysis
-        return {
-            direction: SecureRandom_js_1.SecureRandom.randomFloat() > 0.5 ? 'improving' : SecureRandom_js_1.SecureRandom.randomFloat() > 0.5 ? 'stable' : 'declining',
-            velocity: SecureRandom_js_1.SecureRandom.randomFloat() * 10 - 5, // -5 to +5
-            predictions: [
-                {
-                    metric: 'overall-quality',
-                    predictedValue: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75, // 75-95
-                    confidence: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 70, // 70-90%
-                    timeframe: '30 days'
-                }
-            ],
-            historical: this.generateHistoricalData()
-        };
-    }
-    createEmptyTrends() {
-        return {
-            direction: 'stable',
-            velocity: 0,
-            predictions: [],
-            historical: []
-        };
-    }
-    async evaluateThresholds(metrics, thresholds) {
-        const failed = [];
-        const warnings = [];
-        // Evaluate each threshold
-        for (const [metric, threshold] of Object.entries(thresholds)) {
-            const actual = this.getMetricValue(metrics, metric);
-            if (actual !== undefined) {
-                if (actual < threshold) {
-                    failed.push({
-                        metric,
-                        actual,
-                        threshold,
-                        severity: actual < threshold * 0.8 ? 'critical' : actual < threshold * 0.9 ? 'error' : 'warning'
-                    });
-                }
-                else if (actual < threshold * 1.1) {
-                    warnings.push({
-                        metric,
-                        actual,
-                        threshold,
-                        message: `${metric} is close to threshold`
-                    });
-                }
-            }
-        }
-        return {
-            passed: failed.length === 0,
-            failed,
-            warnings
-        };
-    }
-    calculateCompositeScore(assessments, thresholds) {
-        // Calculate weighted average of assessment scores
-        const totalScore = assessments.reduce((sum, assessment) => sum + assessment.score, 0);
-        const averageScore = assessments.length > 0 ? totalScore / assessments.length : 0;
-        // Apply threshold penalties
-        const thresholdPenalty = thresholds.failed.length * 5; // 5 points per failed threshold
-        const finalScore = Math.max(0, averageScore - thresholdPenalty);
-        // Calculate breakdown by category
-        const breakdown = {};
-        for (const assessment of assessments) {
-            breakdown[assessment.category] = assessment.score;
-        }
-        // Determine grade
-        let grade;
-        if (finalScore >= 95)
-            grade = 'A+';
-        else if (finalScore >= 90)
-            grade = 'A';
-        else if (finalScore >= 85)
-            grade = 'B+';
-        else if (finalScore >= 80)
-            grade = 'B';
-        else if (finalScore >= 75)
-            grade = 'C+';
-        else if (finalScore >= 70)
-            grade = 'C';
-        else if (finalScore >= 60)
-            grade = 'D';
-        else
-            grade = 'F';
-        return {
-            overall: Math.round(finalScore * 100) / 100,
-            breakdown,
-            grade,
-            interpretation: this.interpretScore(finalScore, grade)
-        };
-    }
-    // Helper methods
-    normalizeScore(value, min, max) {
-        return Math.max(0, Math.min(1, (value - min) / (max - min)));
-    }
-    calculateSecurityScore(vulnerabilities) {
-        const weights = { critical: 50, high: 20, medium: 5, low: 1 };
-        const totalDeduction = vulnerabilities.critical * weights.critical +
-            vulnerabilities.high * weights.high +
-            vulnerabilities.medium * weights.medium +
-            vulnerabilities.low * weights.low;
-        return Math.max(0, 100 - totalDeduction);
-    }
-    estimateHours(effort, impact) {
-        const effortMultiplier = { low: 1, medium: 2, high: 4 };
-        const impactMultiplier = { low: 1, medium: 1.5, high: 2 };
-        return Math.round(4 * // Base hours
-            (effortMultiplier[effort] || 2) *
-            (impactMultiplier[impact] || 1.5));
-    }
-    getMetricValue(metrics, metricPath) {
-        // Simple path resolution for nested metrics
-        const paths = {
-            'coverage': metrics.code.coverage.line,
-            'complexity': metrics.code.complexity.cyclomatic,
-            'duplication': metrics.code.duplication.percentage,
-            'success-rate': metrics.test.reliability.successRate,
-            'mutation-score': metrics.test.effectiveness.mutationScore,
-            'response-time': metrics.performance.responseTime.p95
-        };
-        return paths[metricPath];
-    }
-    interpretScore(score, grade) {
-        if (score >= 90)
-            return 'Excellent quality with minimal issues';
-        if (score >= 80)
-            return 'Good quality with some areas for improvement';
-        if (score >= 70)
-            return 'Acceptable quality but needs attention';
-        if (score >= 60)
-            return 'Below average quality requiring significant improvement';
-        return 'Poor quality requiring immediate attention';
-    }
-    generateTechnicalDebtIssues() {
-        return [
-            {
-                file: 'src/complex-function.js',
-                line: 45,
-                type: 'complexity',
-                severity: 'high',
-                estimatedHours: 4,
-                description: 'Function has high cyclomatic complexity'
-            },
-            {
-                file: 'src/duplicate-code.js',
-                line: 12,
-                type: 'duplication',
-                severity: 'medium',
-                estimatedHours: 2,
-                description: 'Code block is duplicated across multiple files'
-            }
-        ];
-    }
-    generateCoverageGaps() {
-        return [
-            {
-                file: 'src/uncovered.js',
-                lines: [23, 24, 25, 35],
-                functions: ['errorHandler', 'cleanup'],
-                priority: 'high'
-            }
-        ];
-    }
-    generatePerformanceBottlenecks() {
-        return [
-            {
-                type: 'database-query',
-                location: 'UserService.findAll()',
-                impact: 0.4,
-                recommendation: 'Add database index on user.email'
-            },
-            {
-                type: 'memory-leak',
-                location: 'EventHandler.subscribe()',
-                impact: 0.2,
-                recommendation: 'Implement proper cleanup in event handlers'
-            }
-        ];
-    }
-    generateSecurityIssues() {
-        return [
-            {
-                type: 'sql-injection',
-                severity: 'high',
-                description: 'Potential SQL injection vulnerability',
-                location: 'UserController.search()',
-                cwe: 'CWE-89'
-            }
-        ];
-    }
-    generateLicenseIssues() {
-        return [
-            {
-                dependency: 'some-package',
-                license: 'GPL-3.0',
-                compatibility: 'incompatible',
-                risk: 'high'
-            }
-        ];
-    }
-    generateHistoricalData() {
-        const data = [];
-        const now = new Date();
-        for (let i = 30; i >= 0; i--) {
-            const date = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
-            data.push({
-                date: date.toISOString().split('T')[0],
-                metrics: {
-                    'overall-quality': SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 70 + i * 0.5, // Improving trend
-                    'coverage': SecureRandom_js_1.SecureRandom.randomFloat() * 10 + 75 + i * 0.3,
-                    'complexity': SecureRandom_js_1.SecureRandom.randomFloat() * 5 + 8 - i * 0.1
-                }
-            });
-        }
-        return data;
-    }
-    /**
-     * Get quality report by ID
-     */
-    getReport(reportId) {
-        return this.analysisHistory.get(reportId);
-    }
-    /**
-     * List all quality reports
-     */
-    listReports() {
-        return Array.from(this.analysisHistory.values());
-    }
-}
-exports.QualityAnalyzeHandler = QualityAnalyzeHandler;
-//# sourceMappingURL=quality-analyze.js.map