claude-flow-novice 1.3.6 → 1.5.1

package/.claude-flow-novice/dist/src/swarm-fullstack/workflows/test-result-analyzer.js

@@ -0,0 +1,530 @@
+/**
+ * Test Result Analyzer - Intelligent Failure Categorization and Analysis
+ *
+ * Analyzes test results to categorize failures, identify patterns, and provide
+ * actionable insights for fixing issues.
+ *
+ * Key Features:
+ * - Failure pattern recognition
+ * - Root cause analysis
+ * - Impact assessment
+ * - Priority classification
+ * - Suggested fix strategies
+ */ import { EventEmitter } from 'events';
+export class TestResultAnalyzer extends EventEmitter {
+    logger;
+    knownPatterns = new Map();
+    failureHistory = new Map();
+    constructor(logger){
+        super(), this.logger = logger;
+        this.initializeKnownPatterns();
+    }
+    /**
+   * Analyze test failures and provide comprehensive analysis
+   */ async analyzeFailures(testResults) {
+        this.logger.info('Analyzing test failures', {
+            totalFailures: testResults.failed,
+            totalTests: testResults.totalTests
+        });
+        try {
+            // Generate failure summary
+            const summary = this.generateFailureSummary(testResults);
+            // Categorize failures
+            const categories = this.categorizeFailures(testResults.failures);
+            // Detect patterns
+            const patterns = await this.detectPatterns(testResults.failures);
+            // Identify root causes
+            const rootCauses = await this.identifyRootCauses(testResults.failures, patterns);
+            // Generate recommendations
+            const recommendations = this.generateRecommendations(testResults.failures, patterns, rootCauses);
+            // Assess impact
+            const impactAssessment = this.assessImpact(testResults.failures);
+            const analysis = {
+                testResults,
+                summary,
+                categories,
+                patterns,
+                rootCauses,
+                recommendations,
+                impactAssessment
+            };
+            this.emit('analysis:completed', {
+                analysis
+            });
+            return analysis;
+        } catch (error) {
+            this.logger.error('Failed to analyze test failures', {
+                error
+            });
+            throw error;
+        }
+    }
+    /**
+   * Generate failure summary statistics
+   */ generateFailureSummary(testResults) {
+        const failures = testResults.failures;
+        const summary = {
+            totalFailures: failures.length,
+            criticalFailures: failures.filter((f)=>f.severity === 'critical').length,
+            highFailures: failures.filter((f)=>f.severity === 'high').length,
+            mediumFailures: failures.filter((f)=>f.severity === 'medium').length,
+            lowFailures: failures.filter((f)=>f.severity === 'low').length,
+            byLayer: new Map(),
+            byCategory: new Map(),
+            bySeverity: new Map()
+        };
+        // Group by layer
+        for (const failure of failures){
+            const layerCount = summary.byLayer.get(failure.layer) || 0;
+            summary.byLayer.set(failure.layer, layerCount + 1);
+            const categoryCount = summary.byCategory.get(failure.category) || 0;
+            summary.byCategory.set(failure.category, categoryCount + 1);
+            const severityCount = summary.bySeverity.get(failure.severity) || 0;
+            summary.bySeverity.set(failure.severity, severityCount + 1);
+        }
+        return summary;
+    }
+    /**
+   * Categorize failures by characteristics
+   */ categorizeFailures(failures) {
+        const categories = new Map();
+        for (const failure of failures){
+            const category = this.determineCategory(failure);
+            if (!categories.has(category)) {
+                categories.set(category, []);
+            }
+            categories.get(category).push(failure);
+        }
+        return categories;
+    }
+    /**
+   * Determine failure category from error patterns
+   */ determineCategory(failure) {
+        const error = failure.error.toLowerCase();
+        const stack = failure.stackTrace.toLowerCase();
+        // API/Network failures
+        if (error.includes('fetch') || error.includes('network') || error.includes('xhr') || error.includes('api')) {
+            return 'network-api';
+        }
+        // Database/Data failures
+        if (error.includes('database') || error.includes('query') || error.includes('connection') || error.includes('transaction')) {
+            return 'database';
+        }
+        // Rendering/UI failures
+        if (error.includes('render') || error.includes('component') || error.includes('dom') || error.includes('element not found')) {
+            return 'rendering';
+        }
+        // State management failures
+        if (error.includes('state') || error.includes('store') || error.includes('reducer') || error.includes('dispatch')) {
+            return 'state-management';
+        }
+        // Authentication/Authorization failures
+        if (error.includes('auth') || error.includes('permission') || error.includes('unauthorized') || error.includes('forbidden')) {
+            return 'authentication';
+        }
+        // Validation failures
+        if (error.includes('validation') || error.includes('invalid') || error.includes('required field')) {
+            return 'validation';
+        }
+        // Timing/Race condition failures
+        if (error.includes('timeout') || error.includes('race') || error.includes('async') || error.includes('promise')) {
+            return 'timing-async';
+        }
+        // Memory/Resource failures
+        if (error.includes('memory') || error.includes('heap') || error.includes('resource') || error.includes('leak')) {
+            return 'resource';
+        }
+        // Configuration failures
+        if (error.includes('config') || error.includes('environment') || error.includes('variable')) {
+            return 'configuration';
+        }
+        // Dependency failures
+        if (error.includes('module') || error.includes('import') || error.includes('require') || error.includes('dependency')) {
+            return 'dependency';
+        }
+        return 'unknown';
+    }
+    /**
+   * Detect patterns in failures
+   */ async detectPatterns(failures) {
+        const patterns = [];
+        const errorGroups = new Map();
+        // Group by similar errors
+        for (const failure of failures){
+            const errorKey = this.extractErrorKey(failure.error);
+            if (!errorGroups.has(errorKey)) {
+                errorGroups.set(errorKey, []);
+            }
+            errorGroups.get(errorKey).push(failure);
+        }
+        // Create patterns for groups with multiple occurrences
+        for (const [errorKey, groupFailures] of errorGroups){
+            if (groupFailures.length > 1) {
+                const pattern = {
+                    id: `pattern_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                    pattern: errorKey,
+                    description: this.generatePatternDescription(groupFailures),
+                    occurrences: groupFailures.length,
+                    affectedTests: groupFailures.map((f)=>f.testName),
+                    confidence: Math.min(groupFailures.length / 10, 1),
+                    suggestedFix: this.suggestFixForPattern(errorKey, groupFailures),
+                    relatedPatterns: []
+                };
+                patterns.push(pattern);
+            }
+        }
+        // Check against known patterns
+        for (const pattern of this.knownPatterns.values()){
+            const matchingFailures = failures.filter((f)=>this.matchesPattern(f, pattern.pattern));
+            if (matchingFailures.length > 0) {
+                patterns.push({
+                    ...pattern,
+                    occurrences: matchingFailures.length,
+                    affectedTests: matchingFailures.map((f)=>f.testName)
+                });
+            }
+        }
+        return patterns;
+    }
+    /**
+   * Extract error key for grouping
+   */ extractErrorKey(error) {
+        // Remove specific values and keep structure
+        return error.replace(/\d+/g, 'N') // Replace numbers
+        .replace(/'[^']*'/g, 'STRING') // Replace strings
+        .replace(/"[^"]*"/g, 'STRING').replace(/\b[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\b/gi, 'UUID') // Replace UUIDs
+        .replace(/\s+/g, ' ') // Normalize whitespace
+        .trim().toLowerCase();
+    }
+    /**
+   * Generate pattern description
+   */ generatePatternDescription(failures) {
+        const layers = [
+            ...new Set(failures.map((f)=>f.layer))
+        ];
+        const categories = [
+            ...new Set(failures.map((f)=>f.category))
+        ];
+        return `Pattern affecting ${failures.length} tests in ${layers.join(', ')} layer(s), ${categories.join(', ')} test(s)`;
+    }
+    /**
+   * Suggest fix for pattern
+   */ suggestFixForPattern(errorKey, failures) {
+        const category = this.determineCategory(failures[0]);
+        const suggestions = {
+            'network-api': 'Review API endpoint configurations and network connectivity',
+            database: 'Check database connection strings and query syntax',
+            rendering: 'Verify component props and DOM structure',
+            'state-management': 'Validate state updates and action dispatchers',
+            authentication: 'Review authentication tokens and permission checks',
+            validation: 'Update validation schemas and error handling',
+            'timing-async': 'Add proper async/await handling and increase timeouts',
+            resource: 'Review resource allocation and cleanup logic',
+            configuration: 'Verify environment configuration and variables',
+            dependency: 'Update dependencies and check import paths'
+        };
+        return suggestions[category] || 'Investigate root cause and apply targeted fix';
+    }
+    /**
+   * Check if failure matches pattern
+   */ matchesPattern(failure, pattern) {
+        const errorKey = this.extractErrorKey(failure.error);
+        return errorKey.includes(pattern.toLowerCase()) || pattern.toLowerCase().includes(errorKey);
+    }
+    /**
+   * Identify root causes
+   */ async identifyRootCauses(failures, patterns) {
+        const rootCauses = [];
+        const causesMap = new Map();
+        // Analyze patterns for root causes
+        for (const pattern of patterns){
+            const category = this.determineCategory(failures[0]);
+            const causeId = `cause_${category}`;
+            if (!causesMap.has(causeId)) {
+                const rootCause = {
+                    id: causeId,
+                    category,
+                    description: this.generateRootCauseDescription(category, pattern),
+                    evidence: [
+                        pattern.description
+                    ],
+                    confidence: pattern.confidence,
+                    affectedComponents: this.extractAffectedComponents(failures),
+                    potentialSolutions: this.generatePotentialSolutions(category),
+                    priority: this.calculateRootCausePriority(failures)
+                };
+                causesMap.set(causeId, rootCause);
+            } else {
+                const existing = causesMap.get(causeId);
+                existing.evidence.push(pattern.description);
+                existing.confidence = Math.min(existing.confidence + 0.1, 1);
+            }
+        }
+        return Array.from(causesMap.values());
+    }
+    /**
+   * Generate root cause description
+   */ generateRootCauseDescription(category, pattern) {
+        const descriptions = {
+            'network-api': 'API communication or network connectivity issues',
+            database: 'Database query or connection problems',
+            rendering: 'Component rendering or DOM manipulation issues',
+            'state-management': 'State synchronization or update problems',
+            authentication: 'Authentication or authorization failures',
+            validation: 'Data validation or schema mismatch issues',
+            'timing-async': 'Asynchronous operation or timing problems',
+            resource: 'Resource management or memory issues',
+            configuration: 'Configuration or environment setup problems',
+            dependency: 'Module dependency or import issues'
+        };
+        return descriptions[category] || `${category} related issues`;
+    }
+    /**
+   * Extract affected components
+   */ extractAffectedComponents(failures) {
+        const components = new Set();
+        for (const failure of failures){
+            if (failure.affectedComponents && Array.isArray(failure.affectedComponents)) {
+                failure.affectedComponents.forEach((comp)=>components.add(comp));
+            }
+        }
+        return Array.from(components);
+    }
+    /**
+   * Generate potential solutions
+   */ generatePotentialSolutions(category) {
+        const solutions = {
+            'network-api': [
+                'Verify API endpoint URLs',
+                'Check CORS configuration',
+                'Add proper error handling for network failures',
+                'Implement retry logic with exponential backoff'
+            ],
+            database: [
+                'Verify database connection strings',
+                'Check query syntax and parameters',
+                'Add proper transaction handling',
+                'Implement connection pooling'
+            ],
+            rendering: [
+                'Verify component props are correctly passed',
+                'Check for null/undefined values before rendering',
+                'Add proper error boundaries',
+                'Use conditional rendering for optional elements'
+            ],
+            'state-management': [
+                'Verify action dispatchers are correctly wired',
+                'Check reducer logic for state updates',
+                'Add proper state initialization',
+                'Use immutable update patterns'
+            ],
+            authentication: [
+                'Verify token generation and validation',
+                'Check permission configurations',
+                'Add proper session management',
+                'Implement token refresh logic'
+            ],
+            validation: [
+                'Update validation schemas',
+                'Add comprehensive error messages',
+                'Implement client-side validation',
+                'Use consistent validation rules'
+            ],
+            'timing-async': [
+                'Add proper async/await handling',
+                'Increase timeout values',
+                'Implement proper promise chaining',
+                'Use Promise.all for parallel operations'
+            ],
+            resource: [
+                'Implement proper cleanup in useEffect/componentWillUnmount',
+                'Check for memory leaks',
+                'Add resource pooling',
+                'Implement proper caching strategies'
+            ],
+            configuration: [
+                'Verify environment variables',
+                'Check configuration file syntax',
+                'Add proper default values',
+                'Use configuration validation'
+            ],
+            dependency: [
+                'Update outdated dependencies',
+                'Check import paths',
+                'Verify package.json configurations',
+                'Use consistent module resolution'
+            ]
+        };
+        return solutions[category] || [
+            'Investigate and apply appropriate fix'
+        ];
+    }
+    /**
+   * Calculate root cause priority
+   */ calculateRootCausePriority(failures) {
+        let priority = 50;
+        // Severity impact
+        const criticalCount = failures.filter((f)=>f.severity === 'critical').length;
+        const highCount = failures.filter((f)=>f.severity === 'high').length;
+        priority += criticalCount * 10;
+        priority += highCount * 5;
+        // Quantity impact
+        priority += Math.min(failures.length * 2, 30);
+        return Math.min(priority, 100);
+    }
+    /**
+   * Generate recommendations
+   */ generateRecommendations(failures, patterns, rootCauses) {
+        const recommendations = [];
+        // Recommendations from root causes
+        for (const cause of rootCauses){
+            const recommendation = {
+                type: cause.priority > 70 ? 'fix' : cause.priority > 50 ? 'refactor' : 'investigate',
+                priority: this.mapPriorityToLevel(cause.priority),
+                description: cause.potentialSolutions[0],
+                reasoning: `Root cause: ${cause.description}. Affects ${cause.affectedComponents.length} component(s).`,
+                estimatedEffort: this.estimateEffort(cause.priority, cause.affectedComponents.length),
+                expectedImpact: this.estimateImpact(failures, cause)
+            };
+            recommendations.push(recommendation);
+        }
+        // Pattern-based recommendations
+        for (const pattern of patterns.slice(0, 3)){
+            // Top 3 patterns
+            if (pattern.occurrences > 2) {
+                recommendations.push({
+                    type: 'fix',
+                    priority: 'high',
+                    description: pattern.suggestedFix,
+                    reasoning: `Pattern detected in ${pattern.occurrences} tests`,
+                    estimatedEffort: 30,
+                    expectedImpact: pattern.occurrences / failures.length * 100
+                });
+            }
+        }
+        // General recommendations
+        if (failures.filter((f)=>f.category === 'e2e').length > failures.length * 0.5) {
+            recommendations.push({
+                type: 'investigate',
+                priority: 'medium',
+                description: 'High number of E2E test failures - review integration points',
+                reasoning: 'E2E failures often indicate integration or environment issues',
+                estimatedEffort: 45,
+                expectedImpact: 40
+            });
+        }
+        return recommendations.sort((a, b)=>{
+            const priorityOrder = {
+                critical: 4,
+                high: 3,
+                medium: 2,
+                low: 1
+            };
+            return priorityOrder[b.priority] - priorityOrder[a.priority];
+        });
+    }
+    /**
+   * Map priority number to level
+   */ mapPriorityToLevel(priority) {
+        if (priority >= 80) return 'critical';
+        if (priority >= 60) return 'high';
+        if (priority >= 40) return 'medium';
+        return 'low';
+    }
+    /**
+   * Estimate effort
+   */ estimateEffort(priority, componentCount) {
+        const basEffort = 20; // minutes
+        const priorityMultiplier = priority / 50;
+        const complexityMultiplier = 1 + componentCount * 0.2;
+        return Math.round(basEffort * priorityMultiplier * complexityMultiplier);
+    }
+    /**
+   * Estimate impact
+   */ estimateImpact(failures, cause) {
+        const relatedFailures = failures.filter((f)=>cause.affectedComponents.some((c)=>f.affectedComponents.includes(c)));
+        return relatedFailures.length / failures.length * 100;
+    }
+    /**
+   * Assess impact
+   */ assessImpact(failures) {
+        const criticalFailures = failures.filter((f)=>f.severity === 'critical').length;
+        const highFailures = failures.filter((f)=>f.severity === 'high').length;
+        // Determine users affected
+        let usersAffected = 'none';
+        if (failures.length > 10) usersAffected = 'all';
+        else if (failures.length > 5) usersAffected = 'many';
+        else if (failures.length > 2) usersAffected = 'few';
+        // Features affected
+        const featuresAffected = [
+            ...new Set(failures.flatMap((f)=>f.affectedComponents))
+        ];
+        // Business impact
+        let businessImpact = 'low';
+        if (criticalFailures > 0) businessImpact = 'critical';
+        else if (highFailures > 3) businessImpact = 'high';
+        else if (failures.length > 5) businessImpact = 'medium';
+        // Urgency
+        const urgency = Math.min(50 + criticalFailures * 20 + highFailures * 10 + failures.length * 2, 100);
+        // Risk level
+        let riskLevel = 'low';
+        if (criticalFailures > 0) riskLevel = 'critical';
+        else if (highFailures > 2) riskLevel = 'high';
+        else if (failures.length > 5) riskLevel = 'medium';
+        return {
+            usersAffected,
+            featuresAffected,
+            businessImpact,
+            urgency,
+            riskLevel
+        };
+    }
+    /**
+   * Initialize known patterns
+   */ initializeKnownPatterns() {
+        const commonPatterns = [
+            {
+                id: 'api-timeout',
+                pattern: 'timeout',
+                description: 'API request timeout pattern',
+                occurrences: 0,
+                affectedTests: [],
+                confidence: 0.9,
+                suggestedFix: 'Increase timeout values or optimize API response time',
+                relatedPatterns: [
+                    'network-api'
+                ]
+            },
+            {
+                id: 'null-reference',
+                pattern: 'cannot read property',
+                description: 'Null reference error pattern',
+                occurrences: 0,
+                affectedTests: [],
+                confidence: 0.95,
+                suggestedFix: 'Add null checks and proper initialization',
+                relatedPatterns: [
+                    'rendering',
+                    'state-management'
+                ]
+            },
+            {
+                id: 'async-race',
+                pattern: 'promise',
+                description: 'Asynchronous operation race condition',
+                occurrences: 0,
+                affectedTests: [],
+                confidence: 0.8,
+                suggestedFix: 'Add proper async/await handling and synchronization',
+                relatedPatterns: [
+                    'timing-async'
+                ]
+            }
+        ];
+        for (const pattern of commonPatterns){
+            this.knownPatterns.set(pattern.id, pattern);
+        }
+    }
+}
+
+//# sourceMappingURL=test-result-analyzer.js.map

package/.claude-flow-novice/dist/src/swarm-fullstack/workflows/test-result-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/swarm-fullstack/workflows/test-result-analyzer.ts"],"names":["EventEmitter","TestResultAnalyzer","knownPatterns","Map","failureHistory","logger","initializeKnownPatterns","analyzeFailures","testResults","info","totalFailures","failed","totalTests","summary","generateFailureSummary","categories","categorizeFailures","failures","patterns","detectPatterns","rootCauses","identifyRootCauses","recommendations","generateRecommendations","impactAssessment","assessImpact","analysis","emit","error","length","criticalFailures","filter","f","severity","highFailures","mediumFailures","lowFailures","byLayer","byCategory","bySeverity","failure","layerCount","get","layer","set","categoryCount","category","severityCount","determineCategory","has","push","toLowerCase","stack","stackTrace","includes","errorGroups","errorKey","extractErrorKey","groupFailures","pattern","id","Date","now","Math","random","toString","substr","description","generatePatternDescription","occurrences","affectedTests","map","testName","confidence","min","suggestedFix","suggestFixForPattern","relatedPatterns","values","matchingFailures","matchesPattern","replace","trim","layers","Set","join","suggestions","database","rendering","authentication","validation","resource","configuration","dependency","causesMap","causeId","rootCause","generateRootCauseDescription","evidence","affectedComponents","extractAffectedComponents","potentialSolutions","generatePotentialSolutions","priority","calculateRootCausePriority","existing","Array","from","descriptions","components","isArray","forEach","comp","add","solutions","criticalCount","highCount","cause","recommendation","type","mapPriorityToLevel","reasoning","estimatedEffort","estimateEffort","expectedImpact","estimateImpact","slice","sort","a","b","priorityOrder","critical","high","medium","low","componentCount","basEffort","priorityMultiplier","complexityMultiplier","round","relatedFailures","some","c","usersAffected","featuresAffected","flatMap","businessImpact","urgency","riskLevel","commonPatterns"],"mappings":"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"}