agentic-qe 2.6.5 → 2.7.0

package/dist/cli/commands/analyze.js

@@ -42,6 +42,22 @@ const ora_1 = __importDefault(require("ora"));
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const ProcessExit_1 = require("../../utils/ProcessExit");
+/** Type guard for ExecutionReport */
+function isExecutionReport(data) {
+    if (typeof data !== 'object' || data === null) {
+        return false;
+    }
+    const obj = data;
+    return typeof obj.timestamp === 'string' || obj.timestamp === undefined;
+}
+/** Type guard for CoverageData */
+function isCoverageData(data) {
+    if (typeof data !== 'object' || data === null) {
+        return false;
+    }
+    const obj = data;
+    return typeof obj.overall === 'number' || obj.overall === undefined;
+}
 class AnalyzeCommand {
     static async execute(target, options) {
         console.log(chalk_1.default.blue.bold('\n📊 Analyzing Test Results and Quality Metrics\n'));
@@ -84,9 +100,11 @@ class AnalyzeCommand {
             await this.storeAnalysisResults(analysisResults, recommendations);
         }
         catch (error) {
-            console.error(chalk_1.default.red('❌ Analysis failed:'), error.message);
-            if (options.verbose) {
-                console.error(chalk_1.default.gray(error.stack));
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            console.error(chalk_1.default.red('❌ Analysis failed:'), errorMessage);
+            if (options.verbose && errorStack) {
+                console.error(chalk_1.default.gray(errorStack));
             }
             ProcessExit_1.ProcessExit.exitIfNotTest(1);
         }
@@ -127,12 +145,17 @@ class AnalyzeCommand {
         };
         // Load latest execution
         const latestFile = path.join(reportsDir, executionFiles[0]);
-        testData.latest = await fs.readJson(latestFile);
+        const latestData = await fs.readJson(latestFile);
+        if (isExecutionReport(latestData)) {
+            testData.latest = latestData;
+        }
         // Load historical data (up to 30 most recent)
         for (const file of executionFiles.slice(0, 30)) {
             const filePath = path.join(reportsDir, file);
             const data = await fs.readJson(filePath);
-            testData.history.push(data);
+            if (isExecutionReport(data)) {
+                testData.history.push(data);
+            }
         }
         // Load coverage data if available
         const coverageFiles = reportFiles.filter(file => file.startsWith('coverage-'));
@@ -140,7 +163,9 @@ class AnalyzeCommand {
             const filePath = path.join(reportsDir, file);
             if (await fs.pathExists(filePath)) {
                 const coverage = await fs.readJson(filePath);
-                testData.coverage.push(coverage);
+                if (isCoverageData(coverage)) {
+                    testData.coverage.push(coverage);
+                }
             }
         }
         return testData;
@@ -253,7 +278,7 @@ class AnalyzeCommand {
             });
             analysis.trends.passRate.push({
                 timestamp,
-                value: data.summary?.total > 0 ? (data.summary.passed / data.summary.total) * 100 : 0
+                value: data.summary?.total ? (data.summary.passed / data.summary.total) * 100 : 0
             });
             analysis.trends.testCount.push({
                 timestamp,
@@ -270,7 +295,7 @@ class AnalyzeCommand {
         analysis.predictions = this.generatePredictions(analysis.trends);
         return analysis;
     }
-    static async analyzeGaps(testData, options) {
+    static async analyzeGaps(testData, _options) {
         const analysis = {
             type: 'gaps',
             timestamp: new Date().toISOString(),
@@ -292,6 +317,7 @@ class AnalyzeCommand {
         const quality = await this.analyzeQuality(testData, options);
         const trends = await this.analyzeTrends(testData, options);
         const gaps = await this.analyzeGaps(testData, options);
+        const analyses = [coverage, quality, trends, gaps];
         return {
             type: 'comprehensive',
             timestamp: new Date().toISOString(),
@@ -300,9 +326,9 @@ class AnalyzeCommand {
             trends,
             gaps,
             summary: {
-                overallScore: this.calculateOverallScore([coverage, quality, trends, gaps]),
-                criticalIssues: this.identifyCriticalIssues([coverage, quality, trends, gaps]),
-                topRecommendations: this.prioritizeRecommendations([coverage, quality, trends, gaps])
+                overallScore: this.calculateOverallScore(analyses),
+                criticalIssues: this.identifyCriticalIssues(analyses),
+                topRecommendations: this.prioritizeRecommendations(analyses)
             }
         };
     }
@@ -369,7 +395,7 @@ class AnalyzeCommand {
         if (!latest)
             return gaps;
         // Check for quality issues
-        if (latest.summary?.failed > 0) {
+        if (latest.summary?.failed && latest.summary.failed > 0) {
             gaps.push({
                 type: 'failing_tests',
                 count: latest.summary.failed,
@@ -378,7 +404,7 @@ class AnalyzeCommand {
                 suggestion: 'Fix failing tests to improve quality'
             });
         }
-        if (latest.errors?.length > 0) {
+        if (latest.errors && latest.errors.length > 0) {
             gaps.push({
                 type: 'test_errors',
                 count: latest.errors.length,
@@ -396,7 +422,9 @@ class AnalyzeCommand {
             if (index === 0)
                 return true;
             const prev = reliabilityData[index - 1];
-            const passRateDiff = Math.abs((data.passed / data.total) - (prev.passed / prev.total));
+            const currentPassRate = data.total > 0 ? data.passed / data.total : 0;
+            const prevPassRate = prev.total > 0 ? prev.passed / prev.total : 0;
+            const passRateDiff = Math.abs(currentPassRate - prevPassRate);
             return passRateDiff < 0.1; // Less than 10% variation
         });
         return (consistentResults.length / reliabilityData.length) * 100;
@@ -423,11 +451,11 @@ class AnalyzeCommand {
         };
         const score = metrics.passRate * weights.passRate +
             metrics.testReliability * weights.testReliability +
-            (metrics.coverage || 0) * weights.coverage +
+            0 * weights.coverage + // coverage is not part of QualityMetrics
             (100 - metrics.flakyTests) * weights.flakyTests;
         return Math.max(0, Math.min(100, score));
     }
-    static async identifyQualityIssues(testData, metrics) {
+    static async identifyQualityIssues(_testData, metrics) {
         const issues = [];
         if (metrics.passRate < 90) {
             issues.push({
@@ -497,8 +525,9 @@ class AnalyzeCommand {
             return { direction: 'stable', change: 0 };
         }
         const values = dataPoints.map(point => point.value);
-        const recentAvg = values.slice(0, Math.floor(values.length / 2)).reduce((sum, val) => sum + val, 0) / Math.floor(values.length / 2);
-        const olderAvg = values.slice(Math.floor(values.length / 2)).reduce((sum, val) => sum + val, 0) / (values.length - Math.floor(values.length / 2));
+        const halfLength = Math.floor(values.length / 2);
+        const recentAvg = values.slice(0, halfLength).reduce((sum, val) => sum + val, 0) / halfLength;
+        const olderAvg = values.slice(halfLength).reduce((sum, val) => sum + val, 0) / (values.length - halfLength);
         const change = recentAvg - olderAvg;
         const direction = Math.abs(change) < 1 ? 'stable' : change > 0 ? 'improving' : 'declining';
         return { direction, change };
@@ -508,7 +537,8 @@ class AnalyzeCommand {
         // Simple linear prediction for coverage
         const coverageTrend = this.calculateTrend(trends.coverage);
         if (coverageTrend.direction !== 'stable') {
-            const predicted = trends.coverage[0]?.value + (coverageTrend.change * 2);
+            const currentValue = trends.coverage[0]?.value ?? 0;
+            const predicted = currentValue + (coverageTrend.change * 2);
             predictions.push({
                 type: 'coverage',
                 timeframe: '2 cycles',
@@ -520,47 +550,92 @@ class AnalyzeCommand {
         return predictions;
     }
     static calculateOverallScore(analyses) {
-        const scores = analyses
-            .filter(a => a.metrics?.qualityScore)
-            .map(a => a.metrics.qualityScore);
+        const scores = [];
+        for (const analysis of analyses) {
+            if ('metrics' in analysis && analysis.metrics && 'qualityScore' in analysis.metrics) {
+                scores.push(analysis.metrics.qualityScore);
+            }
+        }
         return scores.length > 0
             ? scores.reduce((sum, score) => sum + score, 0) / scores.length
             : 0;
     }
     static identifyCriticalIssues(analyses) {
         const criticalIssues = [];
-        analyses.forEach(analysis => {
-            if (analysis.issues) {
+        for (const analysis of analyses) {
+            // Handle QualityAnalysis issues
+            if (analysis.type === 'quality' && analysis.issues) {
                 const critical = analysis.issues.filter((issue) => issue.severity === 'high');
                 criticalIssues.push(...critical);
             }
-            if (analysis.gaps) {
+            // Handle CoverageAnalysis gaps
+            if (analysis.type === 'coverage' && analysis.gaps) {
                 const critical = analysis.gaps.filter((gap) => gap.severity === 'high');
                 criticalIssues.push(...critical);
             }
-        });
+            // Handle GapsAnalysis - all gap types
+            if (analysis.type === 'gaps') {
+                const coverageCritical = analysis.coverageGaps.filter((gap) => gap.severity === 'high');
+                const testingCritical = analysis.testingGaps.filter((gap) => gap.severity === 'high');
+                const qualityCritical = analysis.qualityGaps.filter((gap) => gap.severity === 'high');
+                criticalIssues.push(...coverageCritical, ...testingCritical, ...qualityCritical);
+            }
+            // Handle ComprehensiveAnalysis - nested issues and gaps
+            if (analysis.type === 'comprehensive') {
+                if (analysis.quality?.issues) {
+                    const critical = analysis.quality.issues.filter((issue) => issue.severity === 'high');
+                    criticalIssues.push(...critical);
+                }
+                if (analysis.coverage?.gaps) {
+                    const critical = analysis.coverage.gaps.filter((gap) => gap.severity === 'high');
+                    criticalIssues.push(...critical);
+                }
+                if (analysis.gaps) {
+                    const coverageCritical = analysis.gaps.coverageGaps.filter((gap) => gap.severity === 'high');
+                    const qualityCritical = analysis.gaps.qualityGaps.filter((gap) => gap.severity === 'high');
+                    criticalIssues.push(...coverageCritical, ...qualityCritical);
+                }
+            }
+        }
         return criticalIssues;
     }
     static prioritizeRecommendations(analyses) {
         const allRecommendations = [];
-        analyses.forEach(analysis => {
-            if (analysis.recommendations) {
+        for (const analysis of analyses) {
+            if ('recommendations' in analysis && analysis.recommendations) {
                 allRecommendations.push(...analysis.recommendations);
             }
-        });
+        }
         // Sort by priority
+        const priorityOrder = { 'high': 3, 'medium': 2, 'low': 1 };
         return allRecommendations
             .sort((a, b) => {
-            const priorityOrder = { 'high': 3, 'medium': 2, 'low': 1 };
             return (priorityOrder[b.priority] || 0) - (priorityOrder[a.priority] || 0);
         })
             .slice(0, 5); // Top 5 recommendations
     }
-    static async generateRecommendations(analysis, options) {
+    static async generateRecommendations(analysis, _options) {
         const recommendations = [];
         // Coverage-specific recommendations
-        if (analysis.type === 'coverage' || analysis.coverage) {
-            const coverageData = analysis.coverage || analysis.current;
+        if (analysis.type === 'coverage') {
+            const coverageData = analysis.current;
+            if (coverageData.overall < 80) {
+                recommendations.push({
+                    type: 'improve_coverage',
+                    priority: 'high',
+                    title: 'Improve Test Coverage',
+                    description: `Current coverage (${coverageData.overall.toFixed(1)}%) is below recommended 80%`,
+                    actions: [
+                        'Run: agentic-qe generate tests --coverage-target 85',
+                        'Focus on uncovered code paths',
+                        'Add integration tests for complex flows'
+                    ],
+                    estimatedImpact: 'High'
+                });
+            }
+        }
+        else if (analysis.type === 'comprehensive' && analysis.coverage) {
+            const coverageData = analysis.coverage.current;
             if (coverageData.overall < 80) {
                 recommendations.push({
                     type: 'improve_coverage',
@@ -577,14 +652,29 @@ class AnalyzeCommand {
             }
         }
         // Quality-specific recommendations
-        if (analysis.type === 'quality' || analysis.quality) {
-            const qualityData = analysis.quality || analysis;
-            if (qualityData.metrics?.flakyTests > 0) {
+        if (analysis.type === 'quality') {
+            if (analysis.metrics.flakyTests > 0) {
                 recommendations.push({
                     type: 'fix_flaky_tests',
                     priority: 'medium',
                     title: 'Address Flaky Tests',
-                    description: `${qualityData.metrics.flakyTests} potentially flaky tests detected`,
+                    description: `${analysis.metrics.flakyTests} potentially flaky tests detected`,
+                    actions: [
+                        'Review test execution logs',
+                        'Add proper test isolation',
+                        'Check for timing dependencies'
+                    ],
+                    estimatedImpact: 'Medium'
+                });
+            }
+        }
+        else if (analysis.type === 'comprehensive' && analysis.quality) {
+            if (analysis.quality.metrics.flakyTests > 0) {
+                recommendations.push({
+                    type: 'fix_flaky_tests',
+                    priority: 'medium',
+                    title: 'Address Flaky Tests',
+                    description: `${analysis.quality.metrics.flakyTests} potentially flaky tests detected`,
                     actions: [
                         'Review test execution logs',
                         'Add proper test isolation',
@@ -595,8 +685,8 @@ class AnalyzeCommand {
             }
         }
         // Gap-specific recommendations
-        if (analysis.gaps) {
-            analysis.gaps.forEach((gap) => {
+        if (analysis.type === 'coverage' && analysis.gaps) {
+            for (const gap of analysis.gaps) {
                 if (gap.severity === 'high') {
                     recommendations.push({
                         type: 'address_gap',
@@ -607,7 +697,22 @@ class AnalyzeCommand {
                         estimatedImpact: 'High'
                     });
                 }
-            });
+            }
+        }
+        else if (analysis.type === 'gaps') {
+            const allGaps = [...analysis.coverageGaps, ...analysis.testingGaps, ...analysis.qualityGaps];
+            for (const gap of allGaps) {
+                if (gap.severity === 'high') {
+                    recommendations.push({
+                        type: 'address_gap',
+                        priority: 'high',
+                        title: `Address ${gap.type}`,
+                        description: gap.description,
+                        actions: [gap.suggestion],
+                        estimatedImpact: 'High'
+                    });
+                }
+            }
         }
         return recommendations;
     }
@@ -636,14 +741,31 @@ class AnalyzeCommand {
             await fs.writeFile(htmlFile, htmlContent);
         }
         // Generate CSV for trends
-        if (options.format === 'csv' && analysis.trends) {
-            const csvContent = this.generateCsvReport(analysis.trends);
-            const csvFile = `${reportsDir}/trends-${timestamp}.csv`;
-            await fs.writeFile(csvFile, csvContent);
+        if (options.format === 'csv' && 'trends' in analysis && analysis.trends) {
+            const trendsData = analysis.type === 'trends' ? analysis.trends : undefined;
+            if (trendsData) {
+                const csvContent = this.generateCsvReport(trendsData);
+                const csvFile = `${reportsDir}/trends-${timestamp}.csv`;
+                await fs.writeFile(csvFile, csvContent);
+            }
         }
     }
     static generateHtmlReport(reportData) {
         const { analysis, recommendations } = reportData;
+        // Extract current metrics if available
+        const hasCurrent = analysis.type === 'coverage' || (analysis.type === 'comprehensive' && analysis.coverage);
+        const currentOverall = analysis.type === 'coverage'
+            ? analysis.current.overall
+            : analysis.type === 'comprehensive' && analysis.coverage
+                ? analysis.coverage.current.overall
+                : 0;
+        // Extract metrics if available
+        const hasMetrics = analysis.type === 'quality' || (analysis.type === 'comprehensive' && analysis.quality);
+        const metricsData = analysis.type === 'quality'
+            ? analysis.metrics
+            : analysis.type === 'comprehensive' && analysis.quality
+                ? analysis.quality.metrics
+                : null;
         return `<!DOCTYPE html>
 <html>
 <head>
@@ -666,13 +788,13 @@ class AnalyzeCommand {
         <p>Type: ${analysis.type}</p>
     </div>
 
-    ${analysis.current ? `
+    ${hasCurrent ? `
     <div class="section">
         <h2>Current Metrics</h2>
-        <div class="metric">Coverage: ${analysis.current.overall.toFixed(1)}%</div>
-        ${analysis.metrics ? `
-        <div class="metric">Pass Rate: ${analysis.metrics.passRate.toFixed(1)}%</div>
-        <div class="metric">Quality Score: ${analysis.metrics.qualityScore.toFixed(1)}</div>
+        <div class="metric">Coverage: ${currentOverall.toFixed(1)}%</div>
+        ${hasMetrics && metricsData ? `
+        <div class="metric">Pass Rate: ${metricsData.passRate.toFixed(1)}%</div>
+        <div class="metric">Quality Score: ${metricsData.qualityScore.toFixed(1)}</div>
         ` : ''}
     </div>
     ` : ''}
@@ -682,8 +804,8 @@ class AnalyzeCommand {
         <h2>Recommendations</h2>
         ${recommendations.map((rec) => `
         <div class="recommendation">
-            <h3 class="${rec.priority}">${rec.title}</h3>
-            <p>${rec.description}</p>
+            <h3 class="${rec.priority}">${rec.title || rec.type}</h3>
+            <p>${rec.description || rec.message || ''}</p>
             <ul>
                 ${rec.actions.map((action) => `<li>${action}</li>`).join('')}
             </ul>
@@ -701,13 +823,13 @@ class AnalyzeCommand {
     }
     static generateCsvReport(trends) {
         let csv = 'Timestamp,Coverage,PassRate,TestCount,ExecutionTime\n';
-        const maxLength = Math.max(trends.coverage?.length || 0, trends.passRate?.length || 0, trends.testCount?.length || 0, trends.executionTime?.length || 0);
+        const maxLength = Math.max(trends.coverage.length, trends.passRate.length, trends.testCount.length, trends.executionTime.length);
         for (let i = 0; i < maxLength; i++) {
-            const timestamp = trends.coverage?.[i]?.timestamp || '';
-            const coverage = trends.coverage?.[i]?.value || '';
-            const passRate = trends.passRate?.[i]?.value || '';
-            const testCount = trends.testCount?.[i]?.value || '';
-            const executionTime = trends.executionTime?.[i]?.value || '';
+            const timestamp = trends.coverage[i]?.timestamp || '';
+            const coverage = trends.coverage[i]?.value ?? '';
+            const passRate = trends.passRate[i]?.value ?? '';
+            const testCount = trends.testCount[i]?.value ?? '';
+            const executionTime = trends.executionTime[i]?.value ?? '';
             csv += `${timestamp},${coverage},${passRate},${testCount},${executionTime}\n`;
         }
         return csv;
@@ -717,18 +839,36 @@ class AnalyzeCommand {
         console.log(chalk_1.default.gray(`  Type: ${analysis.type}`));
         console.log(chalk_1.default.gray(`  Timestamp: ${analysis.timestamp}`));
         // Display key metrics based on analysis type
-        if (analysis.current) {
+        if (analysis.type === 'coverage') {
             console.log(chalk_1.default.gray(`  Coverage: ${analysis.current.overall.toFixed(1)}%`));
+            if (analysis.trends.direction) {
+                console.log(chalk_1.default.gray(`  Trend: ${analysis.trends.direction}`));
+            }
         }
-        if (analysis.metrics) {
+        else if (analysis.type === 'quality') {
             console.log(chalk_1.default.gray(`  Pass Rate: ${analysis.metrics.passRate.toFixed(1)}%`));
             console.log(chalk_1.default.gray(`  Quality Score: ${analysis.metrics.qualityScore.toFixed(1)}`));
+            if (analysis.trends.direction) {
+                console.log(chalk_1.default.gray(`  Trend: ${analysis.trends.direction}`));
+            }
         }
-        if (analysis.trends?.direction) {
-            console.log(chalk_1.default.gray(`  Trend: ${analysis.trends.direction}`));
+        else if (analysis.type === 'comprehensive') {
+            if (analysis.coverage) {
+                console.log(chalk_1.default.gray(`  Coverage: ${analysis.coverage.current.overall.toFixed(1)}%`));
+            }
+            if (analysis.quality) {
+                console.log(chalk_1.default.gray(`  Pass Rate: ${analysis.quality.metrics.passRate.toFixed(1)}%`));
+                console.log(chalk_1.default.gray(`  Quality Score: ${analysis.quality.metrics.qualityScore.toFixed(1)}`));
+            }
         }
         // Display critical issues
-        const criticalIssues = analysis.issues?.filter((issue) => issue.severity === 'high') || [];
+        let criticalIssues = [];
+        if (analysis.type === 'quality' && analysis.issues) {
+            criticalIssues = analysis.issues.filter((issue) => issue.severity === 'high');
+        }
+        else if (analysis.type === 'comprehensive' && analysis.quality?.issues) {
+            criticalIssues = analysis.quality.issues.filter((issue) => issue.severity === 'high');
+        }
         if (criticalIssues.length > 0) {
             console.log(chalk_1.default.red('\n🚨 Critical Issues:'));
             criticalIssues.forEach((issue) => {
@@ -739,8 +879,8 @@ class AnalyzeCommand {
         if (recommendations.length > 0) {
             console.log(chalk_1.default.yellow('\n💡 Top Recommendations:'));
             recommendations.slice(0, 3).forEach((rec, index) => {
-                console.log(chalk_1.default.gray(`  ${index + 1}. ${rec.title}`));
-                console.log(chalk_1.default.gray(`     ${rec.description}`));
+                console.log(chalk_1.default.gray(`  ${index + 1}. ${rec.title || rec.type}`));
+                console.log(chalk_1.default.gray(`     ${rec.description || rec.message || ''}`));
             });
         }
         console.log(chalk_1.default.yellow('\n📁 Reports Generated:'));
@@ -754,11 +894,25 @@ class AnalyzeCommand {
         console.log(chalk_1.default.gray('  3. Monitor trends over time for continuous improvement'));
     }
     static async storeAnalysisResults(analysis, recommendations) {
+        // Extract metrics or current values depending on analysis type
+        let metricsOrCurrent = null;
+        let issuesCount = 0;
+        if (analysis.type === 'coverage') {
+            metricsOrCurrent = analysis.current;
+        }
+        else if (analysis.type === 'quality') {
+            metricsOrCurrent = analysis.metrics;
+            issuesCount = analysis.issues.length;
+        }
+        else if (analysis.type === 'comprehensive') {
+            metricsOrCurrent = analysis.quality?.metrics || analysis.coverage?.current || null;
+            issuesCount = analysis.quality?.issues?.length || 0;
+        }
         const summary = {
             type: analysis.type,
             timestamp: analysis.timestamp,
-            metrics: analysis.metrics || analysis.current,
-            issues: (analysis.issues || []).length,
+            metrics: metricsOrCurrent,
+            issues: issuesCount,
             recommendations: recommendations.length,
             status: 'completed'
         };
@@ -767,6 +921,7 @@ class AnalyzeCommand {
 npx claude-flow@alpha memory store --key "agentic-qe/analysis/latest" --value '${JSON.stringify(summary)}'
 npx claude-flow@alpha hooks notify --message "Analysis completed: ${analysis.type} analysis with ${recommendations.length} recommendations"
 `;
+        await fs.ensureDir('.agentic-qe/scripts');
         await fs.writeFile('.agentic-qe/scripts/store-analysis-results.sh', coordinationScript);
         await fs.chmod('.agentic-qe/scripts/store-analysis-results.sh', '755');
     }