agentic-qe 2.3.2 → 2.3.3

package/dist/mcp/handlers/predict-defects.js

@@ -1,722 +0,0 @@
-"use strict";
-/**
- * Defect Prediction Handler
- *
- * Handles AI-driven defect prediction using machine learning models.
- * Analyzes code changes and historical patterns to predict potential defects.
- *
- * @version 1.0.0
- * @author Agentic QE Team
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PredictDefectsHandler = void 0;
-const base_handler_js_1 = require("./base-handler.js");
-const SecureRandom_js_1 = require("../../utils/SecureRandom.js");
-class PredictDefectsHandler extends base_handler_js_1.BaseHandler {
-    constructor(registry, hookExecutor) {
-        super();
-        this.predictionHistory = new Map();
-        this.models = new Map();
-        this.featureExtractors = new Map();
-        this.registry = registry;
-        this.hookExecutor = hookExecutor;
-        this.initializeModels();
-        this.initializeFeatureExtractors();
-    }
-    async handle(args) {
-        const requestId = this.generateRequestId();
-        this.log('info', 'Starting defect prediction', { requestId, scope: args.scope });
-        try {
-            // Execute pre-task hook
-            await this.hookExecutor.executePreTask({
-                description: `Predict defects using ${args.scope.modelType} model for ${args.scope.analysisType} analysis`,
-                agentType: 'defect-predictor'
-            });
-            // Validate required parameters
-            this.validateRequired(args, ['scope']);
-            this.validateDefectPredictionScope(args.scope);
-            // Spawn defect prediction agent via registry
-            const { id: agentId } = await this.registry.spawnAgent('defect-predictor', {} // Agent config - using defaults
-            );
-            const { result: prediction, executionTime } = await this.measureExecutionTime(() => this.predictDefects(args.scope, args.codeChanges));
-            // Execute post-task hook with results
-            await this.hookExecutor.executePostTask({
-                taskId: agentId,
-                results: {
-                    predictionId: prediction.id,
-                    predictionsCount: prediction.predictions.length,
-                    overallRisk: prediction.riskAssessment.overallRisk,
-                    modelMetrics: prediction.modelMetrics
-                }
-            });
-            this.log('info', `Defect prediction completed in ${executionTime.toFixed(2)}ms`, {
-                predictionId: prediction.id,
-                predictionsCount: prediction.predictions.length,
-                overallRisk: prediction.riskAssessment.overallRisk
-            });
-            return this.createSuccessResponse(prediction, requestId);
-        }
-        catch (error) {
-            this.log('error', 'Defect prediction failed', { error: error instanceof Error ? error.message : String(error) });
-            return this.createErrorResponse(error instanceof Error ? error.message : 'Defect prediction failed', requestId);
-        }
-    }
-    initializeModels() {
-        // Initialize different model types
-        this.models.set('neural', {
-            type: 'deep-neural-network',
-            architecture: 'lstm-attention',
-            features: ['code-metrics', 'change-history', 'author-patterns', 'complexity'],
-            accuracy: 0.87,
-            trainingData: 10000
-        });
-        this.models.set('statistical', {
-            type: 'ensemble-classifier',
-            architecture: 'random-forest-gradient-boosting',
-            features: ['statistical-metrics', 'historical-patterns', 'code-churn'],
-            accuracy: 0.82,
-            trainingData: 15000
-        });
-        this.models.set('hybrid', {
-            type: 'neural-statistical-ensemble',
-            architecture: 'weighted-ensemble',
-            features: ['neural-features', 'statistical-features', 'domain-knowledge'],
-            accuracy: 0.91,
-            trainingData: 20000
-        });
-    }
-    initializeFeatureExtractors() {
-        // Code complexity features
-        this.featureExtractors.set('complexity', {
-            features: ['cyclomatic', 'cognitive', 'nesting-depth', 'function-length'],
-            weight: 0.25
-        });
-        // Change history features
-        this.featureExtractors.set('change-history', {
-            features: ['change-frequency', 'lines-changed', 'files-changed', 'commit-size'],
-            weight: 0.20
-        });
-        // Author patterns features
-        this.featureExtractors.set('author-patterns', {
-            features: ['author-experience', 'defect-rate', 'code-quality', 'review-feedback'],
-            weight: 0.15
-        });
-        // Code quality features
-        this.featureExtractors.set('code-quality', {
-            features: ['duplication', 'coverage', 'technical-debt', 'documentation'],
-            weight: 0.20
-        });
-        // Structural features
-        this.featureExtractors.set('structural', {
-            features: ['coupling', 'cohesion', 'inheritance-depth', 'dependencies'],
-            weight: 0.20
-        });
-    }
-    validateDefectPredictionScope(scope) {
-        const validAnalysisTypes = ['file', 'function', 'line', 'module'];
-        if (!validAnalysisTypes.includes(scope.analysisType)) {
-            throw new Error(`Invalid analysis type: ${scope.analysisType}. Must be one of: ${validAnalysisTypes.join(', ')}`);
-        }
-        const validModelTypes = ['neural', 'statistical', 'hybrid'];
-        if (!validModelTypes.includes(scope.modelType)) {
-            throw new Error(`Invalid model type: ${scope.modelType}. Must be one of: ${validModelTypes.join(', ')}`);
-        }
-        if (scope.confidenceThreshold < 0 || scope.confidenceThreshold > 1) {
-            throw new Error('Confidence threshold must be between 0 and 1');
-        }
-        if (scope.historicalDataDays < 7 || scope.historicalDataDays > 365) {
-            throw new Error('Historical data days must be between 7 and 365');
-        }
-    }
-    async predictDefects(scope, codeChanges) {
-        const predictionId = `defect-prediction-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(6)}`;
-        this.log('info', 'Performing defect prediction', {
-            predictionId,
-            analysisType: scope.analysisType,
-            modelType: scope.modelType
-        });
-        // Get model for prediction
-        const model = this.models.get(scope.modelType);
-        // Extract features from code changes
-        const features = await this.extractFeatures(scope, codeChanges);
-        // Make predictions
-        const predictions = await this.makePredictions(scope, features, model);
-        // Calculate model metrics
-        const modelMetrics = this.calculateModelMetrics(model);
-        // Generate recommendations
-        const recommendations = await this.generatePreventionRecommendations(predictions);
-        // Assess overall risk
-        const riskAssessment = this.assessOverallRisk(predictions);
-        // Calculate confidence
-        const confidence = this.calculateOverallConfidence(predictions, model, features);
-        const defectPrediction = {
-            id: predictionId,
-            analysisType: scope.analysisType,
-            modelType: scope.modelType,
-            generatedAt: new Date().toISOString(),
-            predictions,
-            modelMetrics,
-            recommendations,
-            riskAssessment,
-            confidence
-        };
-        // Store prediction
-        this.predictionHistory.set(predictionId, defectPrediction);
-        return defectPrediction;
-    }
-    async extractFeatures(scope, codeChanges) {
-        this.log('info', 'Extracting features for prediction');
-        const allFeatures = new Map();
-        // Extract features based on scope and available extractors
-        for (const [extractorName, extractor] of this.featureExtractors.entries()) {
-            if (!scope.features || scope.features.includes(extractorName)) {
-                const features = await this.extractFeatureGroup(extractorName, extractor, codeChanges);
-                allFeatures.set(extractorName, features);
-            }
-        }
-        return allFeatures;
-    }
-    async extractFeatureGroup(extractorName, extractor, codeChanges) {
-        // Simulate feature extraction based on type
-        await new Promise(resolve => setTimeout(resolve, 50 + SecureRandom_js_1.SecureRandom.randomFloat() * 100));
-        switch (extractorName) {
-            case 'complexity':
-                return this.extractComplexityFeatures(codeChanges);
-            case 'change-history':
-                return this.extractChangeHistoryFeatures(codeChanges);
-            case 'author-patterns':
-                return this.extractAuthorPatternFeatures(codeChanges);
-            case 'code-quality':
-                return this.extractCodeQualityFeatures(codeChanges);
-            case 'structural':
-                return this.extractStructuralFeatures(codeChanges);
-            default:
-                return this.generateMockFeatures(extractorName);
-        }
-    }
-    extractComplexityFeatures(codeChanges) {
-        return {
-            cyclomaticComplexity: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 5, // 5-25
-            cognitiveComplexity: SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 10, // 10-40
-            nestingDepth: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 8 + 1), // 1-8
-            functionLength: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 200 + 10), // 10-210 lines
-            parameterCount: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 10 + 1), // 1-10
-            returnPoints: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 5 + 1) // 1-5
-        };
-    }
-    extractChangeHistoryFeatures(codeChanges) {
-        return {
-            changeFrequency: SecureRandom_js_1.SecureRandom.randomFloat() * 10 + 1, // 1-11 changes per month
-            linesAdded: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 500 + 10), // 10-510
-            linesDeleted: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 200 + 5), // 5-205
-            filesChanged: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 1), // 1-20
-            commitSize: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 1000 + 50), // 50-1050 lines
-            timesSinceLastChange: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 1) // 1-30 days
-        };
-    }
-    extractAuthorPatternFeatures(codeChanges) {
-        return {
-            authorExperience: SecureRandom_js_1.SecureRandom.randomFloat() * 5 + 0.5, // 0.5-5.5 years
-            defectRate: SecureRandom_js_1.SecureRandom.randomFloat() * 0.1 + 0.01, // 1-11% defect rate
-            codeQualityScore: SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 70, // 70-100
-            reviewFeedbackScore: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 75, // 75-95
-            productivityScore: SecureRandom_js_1.SecureRandom.randomFloat() * 25 + 70, // 70-95
-            domainKnowledge: SecureRandom_js_1.SecureRandom.randomFloat() * 40 + 60 // 60-100
-        };
-    }
-    extractCodeQualityFeatures(codeChanges) {
-        return {
-            duplicationPercentage: SecureRandom_js_1.SecureRandom.randomFloat() * 15 + 2, // 2-17%
-            testCoverage: SecureRandom_js_1.SecureRandom.randomFloat() * 30 + 65, // 65-95%
-            technicalDebtRatio: SecureRandom_js_1.SecureRandom.randomFloat() * 0.4 + 0.1, // 10-50%
-            documentationCoverage: SecureRandom_js_1.SecureRandom.randomFloat() * 40 + 50, // 50-90%
-            codeSmells: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 2), // 2-22
-            securityIssues: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 5) // 0-4
-        };
-    }
-    extractStructuralFeatures(codeChanges) {
-        return {
-            couplingBetweenObjects: SecureRandom_js_1.SecureRandom.randomFloat() * 20 + 5, // 5-25
-            lackOfCohesion: SecureRandom_js_1.SecureRandom.randomFloat() * 0.8 + 0.1, // 0.1-0.9
-            inheritanceDepth: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 8 + 1), // 1-8
-            numberOfDependencies: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 50 + 5), // 5-55
-            fanIn: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 15 + 1), // 1-15
-            fanOut: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 10 + 1) // 1-10
-        };
-    }
-    generateMockFeatures(extractorName) {
-        return {
-            feature1: SecureRandom_js_1.SecureRandom.randomFloat(),
-            feature2: SecureRandom_js_1.SecureRandom.randomFloat() * 100,
-            feature3: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 10)
-        };
-    }
-    async makePredictions(scope, features, model) {
-        this.log('info', 'Making defect predictions', { modelType: scope.modelType });
-        const predictions = [];
-        // Generate predictions based on analysis type
-        const targetCount = this.getTargetCount(scope.analysisType);
-        for (let i = 0; i < targetCount; i++) {
-            const prediction = await this.makeSinglePrediction(scope, features, model, i);
-            // Filter by confidence threshold
-            if (prediction.confidence >= scope.confidenceThreshold) {
-                predictions.push(prediction);
-            }
-        }
-        return predictions.sort((a, b) => b.riskScore - a.riskScore);
-    }
-    async makeSinglePrediction(scope, features, model, index) {
-        // Simulate ML model inference
-        const riskScore = this.calculateRiskScore(features, model);
-        const confidence = this.calculatePredictionConfidence(features, model, riskScore);
-        const target = this.generateTarget(scope.analysisType, index);
-        const defectTypes = this.predictDefectTypes(features, model);
-        const analyzedFeatures = this.analyzeFeatureImportance(features);
-        const historicalContext = this.getHistoricalContext(target);
-        return {
-            target,
-            targetType: scope.analysisType,
-            riskScore: Math.round(riskScore * 1000) / 1000,
-            confidence: Math.round(confidence * 1000) / 1000,
-            defectTypes,
-            features: analyzedFeatures,
-            historicalContext,
-            severity: this.calculateSeverity(riskScore),
-            timeframe: this.estimateTimeframe(riskScore, features)
-        };
-    }
-    calculateRiskScore(features, model) {
-        // Simulate ML model scoring
-        let score = 0;
-        let weightSum = 0;
-        for (const [featureGroup, featureValues] of features.entries()) {
-            const extractor = this.featureExtractors.get(featureGroup);
-            if (extractor) {
-                const groupScore = this.calculateFeatureGroupScore(featureValues);
-                score += groupScore * extractor.weight;
-                weightSum += extractor.weight;
-            }
-        }
-        // Normalize and add model-specific adjustments
-        const normalizedScore = weightSum > 0 ? score / weightSum : 0;
-        const modelAdjustment = (model.accuracy - 0.8) * 0.1; // Adjust based on model accuracy
-        return Math.max(0, Math.min(1, normalizedScore + modelAdjustment));
-    }
-    calculateFeatureGroupScore(featureValues) {
-        // Simple scoring based on feature values
-        // In a real implementation, this would use trained weights
-        let score = 0;
-        let count = 0;
-        for (const [key, value] of Object.entries(featureValues)) {
-            if (typeof value === 'number') {
-                // Normalize different types of features
-                let normalizedValue = 0;
-                if (key.includes('complexity') || key.includes('depth') || key.includes('coupling')) {
-                    normalizedValue = Math.min(1, value / 20); // Higher is worse
-                }
-                else if (key.includes('coverage') || key.includes('quality')) {
-                    normalizedValue = 1 - Math.min(1, value / 100); // Lower is worse
-                }
-                else if (key.includes('frequency') || key.includes('count')) {
-                    normalizedValue = Math.min(1, value / 10); // Higher is worse
-                }
-                else {
-                    normalizedValue = Math.min(1, value / 100); // Generic normalization
-                }
-                score += normalizedValue;
-                count++;
-            }
-        }
-        return count > 0 ? score / count : 0;
-    }
-    calculatePredictionConfidence(features, model, riskScore) {
-        // Base confidence on model accuracy
-        let confidence = model.accuracy;
-        // Adjust based on feature completeness
-        const featureCompleteness = features.size / this.featureExtractors.size;
-        confidence *= featureCompleteness;
-        // Adjust based on risk score (extreme values may be less reliable)
-        const extremenessAdjustment = 1 - Math.abs(riskScore - 0.5) * 0.2;
-        confidence *= extremenessAdjustment;
-        // Add some variance
-        confidence += (SecureRandom_js_1.SecureRandom.randomFloat() - 0.5) * 0.1;
-        return Math.max(0.1, Math.min(1, confidence));
-    }
-    predictDefectTypes(features, model) {
-        const defectTypes = [];
-        // Common defect types based on features
-        const typeDefinitions = [
-            {
-                type: 'logic-error',
-                indicators: ['complexity', 'change-history'],
-                baseProbability: 0.3
-            },
-            {
-                type: 'null-pointer',
-                indicators: ['code-quality', 'author-patterns'],
-                baseProbability: 0.2
-            },
-            {
-                type: 'boundary-error',
-                indicators: ['complexity', 'structural'],
-                baseProbability: 0.15
-            },
-            {
-                type: 'concurrency-issue',
-                indicators: ['structural', 'complexity'],
-                baseProbability: 0.1
-            },
-            {
-                type: 'integration-failure',
-                indicators: ['structural', 'change-history'],
-                baseProbability: 0.15
-            },
-            {
-                type: 'performance-degradation',
-                indicators: ['complexity', 'structural'],
-                baseProbability: 0.1
-            }
-        ];
-        for (const typeDef of typeDefinitions) {
-            let probability = typeDef.baseProbability;
-            // Adjust probability based on relevant features
-            for (const indicator of typeDef.indicators) {
-                if (features.has(indicator)) {
-                    const featureScore = this.calculateFeatureGroupScore(features.get(indicator));
-                    probability += featureScore * 0.2;
-                }
-            }
-            if (probability > 0.05) { // Only include if probability > 5%
-                defectTypes.push({
-                    type: typeDef.type,
-                    probability: Math.min(1, probability),
-                    description: this.getDefectTypeDescription(typeDef.type),
-                    examples: this.getDefectTypeExamples(typeDef.type),
-                    prevention: this.getDefectTypePrevention(typeDef.type)
-                });
-            }
-        }
-        return defectTypes.sort((a, b) => b.probability - a.probability);
-    }
-    analyzeFeatureImportance(features) {
-        const analyzedFeatures = [];
-        for (const [featureGroup, featureValues] of features.entries()) {
-            const extractor = this.featureExtractors.get(featureGroup);
-            if (extractor) {
-                for (const [featureName, value] of Object.entries(featureValues)) {
-                    if (typeof value === 'number') {
-                        analyzedFeatures.push({
-                            name: `${featureGroup}.${featureName}`,
-                            value,
-                            importance: extractor.weight * SecureRandom_js_1.SecureRandom.randomFloat(), // Simulate importance
-                            interpretation: this.interpretFeature(featureName, value)
-                        });
-                    }
-                }
-            }
-        }
-        return analyzedFeatures.sort((a, b) => b.importance - a.importance).slice(0, 10); // Top 10
-    }
-    getHistoricalContext(target) {
-        return {
-            similarDefects: Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 10 + 1), // 1-10
-            lastDefectDate: new Date(Date.now() - SecureRandom_js_1.SecureRandom.randomFloat() * 365 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
-            defectPattern: ['regression', 'new-feature', 'refactoring', 'hotfix'][Math.floor(SecureRandom_js_1.SecureRandom.randomFloat() * 4)],
-            changeFrequency: SecureRandom_js_1.SecureRandom.randomFloat() * 5 + 1, // 1-6 changes per month
-            authorExperience: SecureRandom_js_1.SecureRandom.randomFloat() * 5 + 0.5 // 0.5-5.5 years
-        };
-    }
-    calculateSeverity(riskScore) {
-        if (riskScore >= 0.8)
-            return 'critical';
-        if (riskScore >= 0.6)
-            return 'high';
-        if (riskScore >= 0.3)
-            return 'medium';
-        return 'low';
-    }
-    estimateTimeframe(riskScore, features) {
-        // Estimate when defect might manifest
-        const baseTimeframe = Math.floor((1 - riskScore) * 90 + 7); // 7-97 days
-        return `${baseTimeframe} days`;
-    }
-    calculateModelMetrics(model) {
-        return {
-            accuracy: model.accuracy,
-            precision: model.accuracy * 0.95, // Simulate precision
-            recall: model.accuracy * 0.90, // Simulate recall
-            f1Score: model.accuracy * 0.92, // Simulate F1
-            auc: model.accuracy * 0.98, // Simulate AUC
-            trainingData: {
-                samples: model.trainingData,
-                features: 45,
-                timespan: '12 months'
-            },
-            lastTraining: new Date(Date.now() - SecureRandom_js_1.SecureRandom.randomFloat() * 30 * 24 * 60 * 60 * 1000).toISOString(),
-            modelVersion: '2.1.0'
-        };
-    }
-    async generatePreventionRecommendations(predictions) {
-        const recommendations = [];
-        // Generate recommendations based on high-risk predictions
-        const highRiskPredictions = predictions.filter(p => p.riskScore > 0.6);
-        for (const prediction of highRiskPredictions) {
-            for (const defectType of prediction.defectTypes) {
-                if (defectType.probability > 0.3) {
-                    const recommendation = this.createPreventionRecommendation(prediction, defectType);
-                    recommendations.push(recommendation);
-                }
-            }
-        }
-        // Add general preventive recommendations
-        recommendations.push(...this.generateGeneralPreventionRecommendations(predictions));
-        return recommendations.slice(0, 10); // Limit to top 10
-    }
-    createPreventionRecommendation(prediction, defectType) {
-        return {
-            id: `prevention-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(2)}`,
-            category: defectType.type,
-            priority: prediction.severity === 'critical' ? 'critical' : prediction.severity === 'high' ? 'high' : 'medium',
-            title: `Prevent ${defectType.type} in ${prediction.target}`,
-            description: `Implement preventive measures to reduce ${defectType.type} risk from ${(defectType.probability * 100).toFixed(1)}%`,
-            preventiveActions: defectType.prevention.map(prev => ({
-                type: this.categorizePreventionAction(prev),
-                description: prev,
-                automated: this.isActionAutomated(prev),
-                tools: this.getRecommendedTools(prev)
-            })),
-            estimatedEffectiveness: SecureRandom_js_1.SecureRandom.randomFloat() * 0.4 + 0.6, // 60-100%
-            implementationCost: this.estimateImplementationCost(defectType.type),
-            timeToImplement: this.estimateTimeToImplement(defectType.type)
-        };
-    }
-    generateGeneralPreventionRecommendations(predictions) {
-        return [
-            {
-                id: `general-prevention-${Date.now()}`,
-                category: 'general',
-                priority: 'medium',
-                title: 'Enhance Code Review Process',
-                description: 'Implement more thorough code review practices to catch potential defects early',
-                preventiveActions: [
-                    {
-                        type: 'review',
-                        description: 'Require two reviewers for high-risk changes',
-                        automated: false,
-                        tools: ['github', 'gitlab', 'bitbucket']
-                    }
-                ],
-                estimatedEffectiveness: 0.75,
-                implementationCost: 'low',
-                timeToImplement: 5
-            }
-        ];
-    }
-    assessOverallRisk(predictions) {
-        const highRiskCount = predictions.filter(p => p.riskScore > 0.7).length;
-        const mediumRiskCount = predictions.filter(p => p.riskScore > 0.4 && p.riskScore <= 0.7).length;
-        let overallRisk;
-        if (highRiskCount > 3)
-            overallRisk = 'critical';
-        else if (highRiskCount > 1)
-            overallRisk = 'high';
-        else if (mediumRiskCount > 5)
-            overallRisk = 'medium';
-        else
-            overallRisk = 'low';
-        return {
-            overallRisk,
-            riskFactors: this.identifyRiskFactors(predictions),
-            mitigationStrategies: this.generateMitigationStrategies(overallRisk),
-            businessImpact: this.estimateBusinessImpact(overallRisk, predictions)
-        };
-    }
-    calculateOverallConfidence(predictions, model, features) {
-        const averageConfidence = predictions.reduce((sum, p) => sum + p.confidence, 0) / predictions.length;
-        return {
-            score: averageConfidence,
-            factors: [
-                {
-                    factor: 'model-accuracy',
-                    impact: 0.4,
-                    description: `Model accuracy: ${(model.accuracy * 100).toFixed(1)}%`
-                },
-                {
-                    factor: 'feature-completeness',
-                    impact: 0.3,
-                    description: `Feature completeness: ${(features.size / this.featureExtractors.size * 100).toFixed(1)}%`
-                },
-                {
-                    factor: 'data-quality',
-                    impact: 0.3,
-                    description: 'Historical data quality and completeness'
-                }
-            ],
-            limitations: [
-                'Predictions based on historical patterns may not account for novel defect types',
-                'Model accuracy decreases for rarely seen code patterns',
-                'External factors (team changes, tool updates) not fully captured'
-            ],
-            recommendations: [
-                'Continuously retrain models with new defect data',
-                'Validate predictions through manual review for critical components',
-                'Use predictions as guidance, not absolute truth'
-            ]
-        };
-    }
-    // Helper methods
-    getTargetCount(analysisType) {
-        const counts = { file: 10, function: 25, line: 50, module: 5 };
-        return counts[analysisType] || 10;
-    }
-    generateTarget(analysisType, index) {
-        const prefixes = { file: 'src/', function: 'function:', line: 'line:', module: 'module:' };
-        const prefix = prefixes[analysisType] || '';
-        return `${prefix}target_${index + 1}`;
-    }
-    getDefectTypeDescription(type) {
-        const descriptions = {
-            'logic-error': 'Incorrect program logic leading to wrong behavior',
-            'null-pointer': 'Accessing null or undefined references',
-            'boundary-error': 'Array/string index out of bounds errors',
-            'concurrency-issue': 'Race conditions and thread safety problems',
-            'integration-failure': 'Failures in component or system integration',
-            'performance-degradation': 'Code changes causing performance issues'
-        };
-        return descriptions[type] || 'Unknown defect type';
-    }
-    getDefectTypeExamples(type) {
-        const examples = {
-            'logic-error': ['Incorrect conditional logic', 'Wrong calculation formulas', 'Missing edge case handling'],
-            'null-pointer': ['Accessing properties of null objects', 'Using uninitialized variables', 'Missing null checks'],
-            'boundary-error': ['Array index out of bounds', 'String substring errors', 'Loop boundary conditions']
-        };
-        return examples[type] || ['No examples available'];
-    }
-    getDefectTypePrevention(type) {
-        const prevention = {
-            'logic-error': ['Add comprehensive unit tests', 'Use property-based testing', 'Implement code reviews'],
-            'null-pointer': ['Use null-safe operators', 'Add null checks', 'Use static analysis tools'],
-            'boundary-error': ['Validate array bounds', 'Use safe collection methods', 'Add boundary tests']
-        };
-        return prevention[type] || ['Standard code review practices'];
-    }
-    interpretFeature(featureName, value) {
-        if (featureName.includes('complexity')) {
-            return value > 10 ? 'High complexity increases defect risk' : 'Acceptable complexity level';
-        }
-        if (featureName.includes('coverage')) {
-            return value < 70 ? 'Low coverage increases defect risk' : 'Good test coverage';
-        }
-        return `Feature value: ${value.toFixed(2)}`;
-    }
-    categorizePreventionAction(action) {
-        if (action.includes('review'))
-            return 'review';
-        if (action.includes('test'))
-            return 'testing';
-        if (action.includes('refactor'))
-            return 'refactoring';
-        if (action.includes('monitor'))
-            return 'monitoring';
-        return 'review';
-    }
-    isActionAutomated(action) {
-        return action.includes('automated') || action.includes('static analysis') || action.includes('lint');
-    }
-    getRecommendedTools(action) {
-        if (action.includes('test'))
-            return ['jest', 'mocha', 'pytest'];
-        if (action.includes('static'))
-            return ['eslint', 'sonarqube', 'codecov'];
-        if (action.includes('review'))
-            return ['github', 'reviewboard'];
-        return [];
-    }
-    estimateImplementationCost(defectType) {
-        const costs = {
-            'logic-error': 'medium',
-            'null-pointer': 'low',
-            'boundary-error': 'low',
-            'concurrency-issue': 'high',
-            'integration-failure': 'high',
-            'performance-degradation': 'medium'
-        };
-        return costs[defectType] || 'medium';
-    }
-    estimateTimeToImplement(defectType) {
-        const times = {
-            'logic-error': 8,
-            'null-pointer': 4,
-            'boundary-error': 4,
-            'concurrency-issue': 16,
-            'integration-failure': 12,
-            'performance-degradation': 10
-        };
-        return times[defectType] || 8;
-    }
-    identifyRiskFactors(predictions) {
-        return [
-            {
-                factor: 'high-complexity-code',
-                impact: 0.8,
-                likelihood: 0.6,
-                description: 'Multiple components with high cyclomatic complexity'
-            },
-            {
-                factor: 'frequent-changes',
-                impact: 0.6,
-                likelihood: 0.7,
-                description: 'Areas of code with frequent modifications'
-            }
-        ];
-    }
-    generateMitigationStrategies(overallRisk) {
-        return [
-            {
-                strategy: 'Enhanced Testing',
-                effectiveness: 0.8,
-                cost: 0.6,
-                timeToImplement: 2,
-                description: 'Implement comprehensive testing for high-risk areas'
-            },
-            {
-                strategy: 'Code Review Intensification',
-                effectiveness: 0.7,
-                cost: 0.3,
-                timeToImplement: 1,
-                description: 'Require additional reviewers for high-risk changes'
-            }
-        ];
-    }
-    estimateBusinessImpact(overallRisk, predictions) {
-        const impactMultipliers = { low: 1, medium: 2, high: 4, critical: 8 };
-        const multiplier = impactMultipliers[overallRisk];
-        return {
-            estimatedCost: multiplier * 5000, // Base cost $5000
-            timeToResolve: multiplier * 2, // Base time 2 hours
-            affectedUsers: multiplier * 100, // Base users 100
-            reputationImpact: overallRisk === 'critical' ? 'high' : overallRisk === 'high' ? 'medium' : 'low'
-        };
-    }
-    /**
-     * Get prediction by ID
-     */
-    getPrediction(predictionId) {
-        return this.predictionHistory.get(predictionId);
-    }
-    /**
-     * List all predictions
-     */
-    listPredictions() {
-        return Array.from(this.predictionHistory.values());
-    }
-    /**
-     * Get model performance metrics
-     */
-    getModelMetrics(modelType) {
-        return this.models.get(modelType);
-    }
-}
-exports.PredictDefectsHandler = PredictDefectsHandler;
-//# sourceMappingURL=predict-defects.js.map