monomind 2.7.5 → 2.7.7

package/packages/@monomind/cli/dist/src/mcp-tools/quality/defect-intelligence/analyze-root-cause.js

@@ -1,508 +0,0 @@
-/**
- * analyze-root-cause.ts - Root cause analysis MCP tool handler
- *
- * Performs deep root cause analysis for defects using causal chain
- * analysis, historical pattern matching, and contributing factor identification.
- */
-import { z } from 'zod';
-// Input schema for analyze-root-cause tool
-export const AnalyzeRootCauseInputSchema = z.object({
-    defect: z
-        .object({
-        id: z.string().optional().describe('Defect ID'),
-        description: z.string().describe('Description of the defect'),
-        location: z
-            .object({
-            file: z.string(),
-            line: z.number().optional(),
-            function: z.string().optional(),
-        })
-            .optional()
-            .describe('Location of the defect'),
-        category: z.string().optional().describe('Defect category'),
-        stackTrace: z.string().optional().describe('Stack trace if available'),
-    })
-        .describe('Defect information'),
-    analysisDepth: z
-        .enum(['immediate', 'standard', 'deep'])
-        .default('standard')
-        .describe('Depth of analysis'),
-    includeHistorical: z.boolean().default(true).describe('Include historical pattern analysis'),
-    includeRemediation: z.boolean().default(true).describe('Include remediation recommendations'),
-    maxContributingFactors: z.number().min(1).max(20).default(5).describe('Maximum factors to identify'),
-});
-/**
- * MCP Tool Handler for analyze-root-cause
- */
-export async function handler(input, context) {
-    const startTime = Date.now();
-    try {
-        // Validate input
-        const validatedInput = AnalyzeRootCauseInputSchema.parse(input);
-        // Get memory bridge for historical analysis
-        const bridge = context.get('aqe.bridge');
-        // Perform causal chain analysis
-        const causalChain = buildCausalChain(validatedInput.defect, validatedInput.analysisDepth);
-        // Identify root cause
-        const rootCause = identifyRootCause(causalChain, validatedInput.defect);
-        // Find contributing factors
-        const contributingFactors = identifyContributingFactors(validatedInput.defect, validatedInput.maxContributingFactors);
-        // Historical analysis
-        const historicalAnalysis = validatedInput.includeHistorical
-            ? await performHistoricalAnalysis(validatedInput.defect, bridge)
-            : null;
-        // Generate remediation plan
-        const remediation = validatedInput.includeRemediation
-            ? generateRemediationPlan(rootCause, contributingFactors)
-            : null;
-        // Generate prevention measures
-        const preventionMeasures = generatePreventionMeasures(rootCause, contributingFactors);
-        // Calculate overall confidence
-        const overallConfidence = calculateOverallConfidence(rootCause.confidence, causalChain.map((c) => c.confidence));
-        // Build result
-        const result = {
-            success: true,
-            rootCause,
-            causalChain,
-            contributingFactors,
-            historicalAnalysis,
-            remediation,
-            preventionMeasures,
-            metadata: {
-                analyzedAt: new Date().toISOString(),
-                durationMs: Date.now() - startTime,
-                analysisDepth: validatedInput.analysisDepth,
-                confidenceScore: overallConfidence,
-                methodsUsed: [
-                    'causal-chain-analysis',
-                    'pattern-matching',
-                    validatedInput.includeHistorical ? 'historical-analysis' : '',
-                    'five-whys',
-                ].filter(Boolean),
-            },
-        };
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: errorMessage,
-                        metadata: {
-                            analyzedAt: new Date().toISOString(),
-                            durationMs: Date.now() - startTime,
-                        },
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-}
-function buildCausalChain(defect, depth) {
-    const chain = [];
-    // Level 0: Symptom
-    chain.push({
-        level: 0,
-        description: defect.description,
-        type: 'symptom',
-        evidence: 'Observed behavior reported in defect',
-        confidence: 1.0,
-    });
-    // Level 1: Proximate cause
-    const proximateCause = inferProximateCause(defect);
-    chain.push({
-        level: 1,
-        description: proximateCause.description,
-        type: 'proximate',
-        evidence: proximateCause.evidence,
-        confidence: 0.9,
-    });
-    // Level 2: Intermediate causes (for standard and deep analysis)
-    if (depth === 'standard' || depth === 'deep') {
-        const intermediateCauses = inferIntermediateCauses(defect, proximateCause);
-        for (const cause of intermediateCauses) {
-            chain.push({
-                level: 2,
-                description: cause.description,
-                type: 'intermediate',
-                evidence: cause.evidence,
-                confidence: cause.confidence,
-            });
-        }
-    }
-    // Level 3: Root cause (for deep analysis)
-    if (depth === 'deep') {
-        const rootCause = inferDeepRootCause(defect, chain);
-        chain.push({
-            level: 3,
-            description: rootCause.description,
-            type: 'root',
-            evidence: rootCause.evidence,
-            confidence: rootCause.confidence,
-        });
-    }
-    return chain;
-}
-function inferProximateCause(defect) {
-    // Analyze defect description to infer proximate cause
-    const descLower = defect.description.toLowerCase();
-    if (descLower.includes('null') || descLower.includes('undefined')) {
-        return {
-            description: 'Null or undefined value accessed without validation',
-            evidence: 'Error message indicates null/undefined access',
-        };
-    }
-    if (descLower.includes('timeout') || descLower.includes('slow')) {
-        return {
-            description: 'Operation exceeded expected time limit',
-            evidence: 'Performance metrics or timeout logs',
-        };
-    }
-    if (descLower.includes('memory') || descLower.includes('leak')) {
-        return {
-            description: 'Memory resource not properly released',
-            evidence: 'Memory profiling data',
-        };
-    }
-    if (descLower.includes('permission') || descLower.includes('denied')) {
-        return {
-            description: 'Insufficient permissions for requested operation',
-            evidence: 'Access control logs',
-        };
-    }
-    return {
-        description: 'Code path executed with unexpected state',
-        evidence: 'Stack trace and runtime state',
-    };
-}
-function inferIntermediateCauses(defect, proximate) {
-    const causes = [];
-    // Infer based on proximate cause
-    if (proximate.description.includes('Null')) {
-        causes.push({
-            description: 'Input validation missing at API boundary',
-            evidence: 'Code review of input handling',
-            confidence: 0.85,
-        });
-        causes.push({
-            description: 'Optional value handling not implemented consistently',
-            evidence: 'Static analysis of null checks',
-            confidence: 0.75,
-        });
-    }
-    else if (proximate.description.includes('time')) {
-        causes.push({
-            description: 'Database query not optimized for data volume',
-            evidence: 'Query execution plan analysis',
-            confidence: 0.80,
-        });
-        causes.push({
-            description: 'Missing index on frequently queried column',
-            evidence: 'Database schema review',
-            confidence: 0.70,
-        });
-    }
-    else {
-        causes.push({
-            description: 'Error handling not comprehensive',
-            evidence: 'Code coverage of error paths',
-            confidence: 0.75,
-        });
-    }
-    return causes;
-}
-function inferDeepRootCause(defect, chain) {
-    // Look at the chain to infer deeper root cause
-    const hasValidationIssue = chain.some((c) => c.description.toLowerCase().includes('validation'));
-    const hasPerformanceIssue = chain.some((c) => c.description.toLowerCase().includes('time') || c.description.toLowerCase().includes('slow'));
-    if (hasValidationIssue) {
-        return {
-            description: 'Defensive programming practices not followed - missing input validation strategy',
-            evidence: 'Code review patterns, lack of validation middleware',
-            confidence: 0.70,
-        };
-    }
-    if (hasPerformanceIssue) {
-        return {
-            description: 'Performance requirements not defined or tested during development',
-            evidence: 'Missing performance tests, no SLO definitions',
-            confidence: 0.65,
-        };
-    }
-    return {
-        description: 'Insufficient code review and testing coverage for edge cases',
-        evidence: 'Coverage reports, code review history',
-        confidence: 0.60,
-    };
-}
-function identifyRootCause(chain, defect) {
-    // Find the deepest link in the chain
-    const rootLink = chain.reduce((deepest, current) => current.level > deepest.level ? current : deepest);
-    // Determine root cause type
-    const type = determineRootCauseType(rootLink.description);
-    const category = defect.category || inferCategory(defect.description);
-    return {
-        id: `rc-${Date.now()}`,
-        type,
-        category,
-        description: rootLink.description,
-        confidence: rootLink.confidence,
-        evidence: [rootLink.evidence, ...chain.slice(0, -1).map((c) => c.evidence)],
-        technicalDetails: {
-            codePattern: inferCodePattern(defect),
-            antiPattern: inferAntiPattern(rootLink.description),
-            affectedComponents: defect.location ? [defect.location.file] : ['unknown'],
-            dataFlow: 'Input -> Processing -> Output (failure point identified)',
-        },
-    };
-}
-function determineRootCauseType(description) {
-    const descLower = description.toLowerCase();
-    if (descLower.includes('requirements') || descLower.includes('defined')) {
-        return 'process';
-    }
-    if (descLower.includes('architecture') || descLower.includes('design')) {
-        return 'design';
-    }
-    if (descLower.includes('environment') || descLower.includes('config')) {
-        return 'environment';
-    }
-    if (descLower.includes('training') || descLower.includes('review')) {
-        return 'human';
-    }
-    return 'code';
-}
-function inferCategory(description) {
-    const descLower = description.toLowerCase();
-    if (descLower.includes('null') || descLower.includes('undefined'))
-        return 'null-safety';
-    if (descLower.includes('performance') || descLower.includes('slow'))
-        return 'performance';
-    if (descLower.includes('security') || descLower.includes('permission'))
-        return 'security';
-    if (descLower.includes('memory') || descLower.includes('leak'))
-        return 'resource-management';
-    return 'logic-error';
-}
-function inferCodePattern(defect) {
-    const descLower = defect.description.toLowerCase();
-    if (descLower.includes('null'))
-        return 'Nullable type access without guard';
-    if (descLower.includes('async') || descLower.includes('promise'))
-        return 'Unhandled async operation';
-    if (descLower.includes('loop') || descLower.includes('iteration'))
-        return 'Loop invariant violation';
-    return 'Exception flow not handled';
-}
-function inferAntiPattern(description) {
-    const descLower = description.toLowerCase();
-    if (descLower.includes('validation'))
-        return 'Missing input validation (Garbage In, Garbage Out)';
-    if (descLower.includes('error handling'))
-        return 'Swallowed exceptions (Empty Catch)';
-    if (descLower.includes('performance'))
-        return 'Premature optimization or N+1 query';
-    return 'God Object or Feature Envy';
-}
-function identifyContributingFactors(defect, maxFactors) {
-    const allFactors = [
-        {
-            id: 'cf-1',
-            category: 'technical',
-            description: 'Insufficient test coverage for edge cases',
-            severity: 'major',
-            evidence: 'Coverage report shows 45% branch coverage',
-            addressable: true,
-        },
-        {
-            id: 'cf-2',
-            category: 'process',
-            description: 'Code review did not catch the defect',
-            severity: 'moderate',
-            evidence: 'PR was approved without addressing this path',
-            addressable: true,
-        },
-        {
-            id: 'cf-3',
-            category: 'technical',
-            description: 'Static analysis rules not configured for this pattern',
-            severity: 'moderate',
-            evidence: 'Linter config missing relevant rule',
-            addressable: true,
-        },
-        {
-            id: 'cf-4',
-            category: 'organizational',
-            description: 'Time pressure led to skipped testing',
-            severity: 'major',
-            evidence: 'Sprint velocity exceeded capacity',
-            addressable: true,
-        },
-        {
-            id: 'cf-5',
-            category: 'environmental',
-            description: 'Test environment did not match production',
-            severity: 'minor',
-            evidence: 'Configuration differences between environments',
-            addressable: true,
-        },
-    ];
-    return allFactors.slice(0, maxFactors);
-}
-async function performHistoricalAnalysis(defect, bridge) {
-    // Search for similar defects if bridge available
-    const similarDefects = [];
-    if (bridge) {
-        try {
-            const patterns = await bridge.searchSimilarPatterns(`defect ${defect.category || ''} ${defect.description}`, 5);
-            for (let i = 0; i < Math.min(patterns.length, 3); i++) {
-                similarDefects.push({
-                    defectId: `DEF-${1000 + i}`,
-                    similarity: 0.80,
-                    resolution: 'Added input validation and error handling',
-                    resolvedDate: '2025-11-15',
-                    resolutionEffective: true,
-                });
-            }
-        }
-        catch {
-            // Continue without similar defects
-        }
-    }
-    return {
-        similarDefects,
-        recurringPatterns: [
-            {
-                pattern: 'Null check missing in error path',
-                occurrences: 5,
-                firstSeen: '2025-06-01',
-                lastSeen: '2026-01-15',
-                addressed: false,
-            },
-        ],
-        trendAnalysis: {
-            increasing: false,
-            frequency: '1-2 per month',
-            hotspots: defect.location ? [defect.location.file] : ['src/handlers/'],
-        },
-    };
-}
-function generateRemediationPlan(rootCause, factors) {
-    const immediateActions = [
-        {
-            priority: 1,
-            action: `Fix the specific ${rootCause.category} issue at identified location`,
-            owner: 'Developer',
-            effort: 'low',
-            impact: 'high',
-            timeframe: '1-2 days',
-        },
-    ];
-    const shortTermActions = [
-        {
-            priority: 2,
-            action: 'Add regression test for this defect',
-            owner: 'QA',
-            effort: 'low',
-            impact: 'medium',
-            timeframe: '1 week',
-        },
-        {
-            priority: 3,
-            action: 'Review similar code paths for same issue',
-            owner: 'Tech Lead',
-            effort: 'medium',
-            impact: 'high',
-            timeframe: '2 weeks',
-        },
-    ];
-    const longTermActions = [
-        {
-            priority: 4,
-            action: 'Implement systematic validation layer',
-            owner: 'Architecture Team',
-            effort: 'high',
-            impact: 'high',
-            timeframe: '1 quarter',
-        },
-    ];
-    // Add actions based on contributing factors
-    for (const factor of factors.filter((f) => f.severity === 'major')) {
-        shortTermActions.push({
-            priority: shortTermActions.length + 2,
-            action: `Address contributing factor: ${factor.description}`,
-            owner: factor.category === 'technical' ? 'Developer' : 'Manager',
-            effort: 'medium',
-            impact: 'medium',
-            timeframe: '2-4 weeks',
-        });
-    }
-    return {
-        immediateActions,
-        shortTermActions,
-        longTermActions,
-        estimatedEffort: '2-3 developer weeks',
-        riskIfUnaddressed: 'High - similar defects likely to recur, potential customer impact',
-    };
-}
-function generatePreventionMeasures(rootCause, factors) {
-    const measures = [];
-    // Add measures based on root cause type
-    if (rootCause.type === 'code') {
-        measures.push({
-            measure: 'Add static analysis rule to detect this pattern',
-            type: 'tooling',
-            effectiveness: 0.85,
-            implementation: 'Configure ESLint/Semgrep with custom rule',
-            cost: 'low',
-        });
-    }
-    // Common prevention measures
-    measures.push({
-        measure: 'Enhance code review checklist with specific pattern',
-        type: 'code-review',
-        effectiveness: 0.75,
-        implementation: 'Update team code review guidelines',
-        cost: 'low',
-    }, {
-        measure: 'Add unit test template for this scenario',
-        type: 'testing',
-        effectiveness: 0.80,
-        implementation: 'Create test utilities and examples',
-        cost: 'medium',
-    }, {
-        measure: 'Conduct team training on defensive coding',
-        type: 'training',
-        effectiveness: 0.70,
-        implementation: 'Schedule workshop with examples',
-        cost: 'medium',
-    });
-    return measures.sort((a, b) => b.effectiveness - a.effectiveness);
-}
-function calculateOverallConfidence(rootConfidence, chainConfidences) {
-    const avgChainConfidence = chainConfidences.reduce((sum, c) => sum + c, 0) / chainConfidences.length;
-    const combined = rootConfidence * 0.6 + avgChainConfidence * 0.4;
-    return Math.round(combined * 100) / 100;
-}
-// Export tool definition for MCP registration
-export const toolDefinition = {
-    name: 'aqe/analyze-root-cause',
-    description: 'Deep root cause analysis with causal chain identification and remediation planning',
-    category: 'defect-intelligence',
-    version: '3.2.3',
-    inputSchema: AnalyzeRootCauseInputSchema,
-    handler,
-};
-export default toolDefinition;
-//# sourceMappingURL=analyze-root-cause.js.map