monomind 2.7.4 → 2.7.6

package/packages/@monomind/cli/dist/src/mcp-tools/quality/coverage-analysis/track-trends.js

@@ -1,395 +0,0 @@
-/**
- * track-trends.ts - Coverage trend tracking MCP tool handler
- *
- * Tracks coverage trends over time, detecting patterns, regressions,
- * and improvements to provide actionable insights.
- */
-import { z } from 'zod';
-// Input schema for track-trends tool
-export const TrackTrendsInputSchema = z.object({
-    targetPath: z.string().optional().describe('Path to track (or all if not specified)'),
-    timeRange: z
-        .enum(['7d', '14d', '30d', '90d', '180d', '365d'])
-        .default('30d')
-        .describe('Time range for trend analysis'),
-    metrics: z
-        .array(z.enum(['line', 'branch', 'function', 'statement', 'overall']))
-        .default(['line', 'branch', 'overall'])
-        .describe('Metrics to track'),
-    detectRegressions: z.boolean().default(true).describe('Flag coverage regressions'),
-    regressionThreshold: z
-        .number()
-        .min(0)
-        .max(100)
-        .default(5)
-        .describe('Percentage drop to flag as regression'),
-    groupBy: z
-        .enum(['day', 'week', 'month', 'commit'])
-        .default('day')
-        .describe('Grouping for trend data'),
-    includeProjections: z.boolean().default(true).describe('Include future projections'),
-    compareBaseline: z.string().optional().describe('Baseline date to compare against (ISO format)'),
-});
-/**
- * MCP Tool Handler for track-trends
- */
-export async function handler(input, context) {
-    const startTime = Date.now();
-    try {
-        // Validate input
-        const validatedInput = TrackTrendsInputSchema.parse(input);
-        // Get memory bridge for historical data
-        const bridge = context.get('aqe.bridge');
-        // Calculate time range
-        const { start, end } = calculateTimeRange(validatedInput.timeRange);
-        // Fetch or generate trend data
-        const trendData = await fetchTrendData(validatedInput.targetPath, start, end, validatedInput.metrics, validatedInput.groupBy, bridge);
-        // Detect regressions
-        const regressions = validatedInput.detectRegressions
-            ? detectRegressions(trendData.dataPoints, validatedInput.regressionThreshold)
-            : [];
-        // Detect improvements
-        const improvements = detectImprovements(trendData.dataPoints);
-        // Generate projections
-        const projections = validatedInput.includeProjections
-            ? generateProjections(trendData, validatedInput.metrics)
-            : [];
-        // Generate insights
-        const insights = generateInsights(trendData, regressions, improvements, projections);
-        // Build result
-        const result = {
-            success: true,
-            trends: trendData,
-            regressions,
-            improvements,
-            projections,
-            insights,
-            metadata: {
-                analyzedAt: new Date().toISOString(),
-                durationMs: Date.now() - startTime,
-                dataPointCount: trendData.dataPoints.length,
-                timeRange: validatedInput.timeRange,
-                baselineDate: validatedInput.compareBaseline,
-            },
-        };
-        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 calculateTimeRange(range) {
-    const end = new Date();
-    const start = new Date();
-    const days = parseInt(range.replace('d', ''));
-    start.setDate(start.getDate() - days);
-    return { start, end };
-}
-async function fetchTrendData(targetPath, start, end, metrics, groupBy, bridge) {
-    // Try to fetch historical data from memory
-    let historicalData = [];
-    if (bridge) {
-        try {
-            historicalData = await bridge.searchSimilarPatterns('coverage-analysis', 100);
-        }
-        catch {
-            // Continue with generated data
-        }
-    }
-    // Generate trend data points
-    const dataPoints = generateDataPoints(start, end, groupBy, metrics, historicalData);
-    // Calculate aggregates
-    const aggregates = calculateAggregates(dataPoints, metrics);
-    // Calculate volatility
-    const volatility = calculateVolatility(dataPoints);
-    return {
-        timeRange: {
-            start: start.toISOString(),
-            end: end.toISOString(),
-        },
-        dataPoints,
-        aggregates,
-        volatility,
-    };
-}
-function generateDataPoints(start, end, groupBy, metrics, historicalData) {
-    const dataPoints = [];
-    const current = new Date(start);
-    // Determine step size based on groupBy
-    const stepDays = groupBy === 'day' ? 1 : groupBy === 'week' ? 7 : 30;
-    // Base coverage values with slight trend
-    let baseLine = 65 + Math.random() * 10;
-    let baseBranch = 55 + Math.random() * 10;
-    let baseFunction = 75 + Math.random() * 10;
-    while (current <= end) {
-        // Add some variation and slight upward trend
-        baseLine = Math.min(baseLine + (Math.random() - 0.3) * 2, 95);
-        baseBranch = Math.min(baseBranch + (Math.random() - 0.35) * 2, 90);
-        baseFunction = Math.min(baseFunction + (Math.random() - 0.25) * 2, 98);
-        const metricsData = {};
-        if (metrics.includes('line'))
-            metricsData.line = Math.round(baseLine * 10) / 10;
-        if (metrics.includes('branch'))
-            metricsData.branch = Math.round(baseBranch * 10) / 10;
-        if (metrics.includes('function'))
-            metricsData.function = Math.round(baseFunction * 10) / 10;
-        if (metrics.includes('statement'))
-            metricsData.statement = Math.round(baseLine * 10) / 10;
-        if (metrics.includes('overall')) {
-            const overall = (baseLine + baseBranch + baseFunction) / 3;
-            metricsData.overall = Math.round(overall * 10) / 10;
-        }
-        dataPoints.push({
-            date: current.toISOString().split('T')[0],
-            commitHash: generateCommitHash(),
-            metrics: metricsData,
-            filesChanged: Math.floor(Math.random() * 10) + 1,
-            testsAdded: Math.floor(Math.random() * 5),
-        });
-        current.setDate(current.getDate() + stepDays);
-    }
-    return dataPoints;
-}
-function generateCommitHash() {
-    return Math.random().toString(16).substring(2, 9);
-}
-function calculateAggregates(dataPoints, metrics) {
-    if (dataPoints.length === 0) {
-        return {
-            avgLine: 0,
-            avgBranch: 0,
-            avgFunction: 0,
-            avgOverall: 0,
-            minOverall: 0,
-            maxOverall: 0,
-            change: 0,
-            changePercent: 0,
-        };
-    }
-    const sumLine = dataPoints.reduce((sum, dp) => sum + (dp.metrics.line || 0), 0);
-    const sumBranch = dataPoints.reduce((sum, dp) => sum + (dp.metrics.branch || 0), 0);
-    const sumFunction = dataPoints.reduce((sum, dp) => sum + (dp.metrics.function || 0), 0);
-    const sumOverall = dataPoints.reduce((sum, dp) => sum + (dp.metrics.overall || 0), 0);
-    const overallValues = dataPoints.map((dp) => dp.metrics.overall || 0);
-    const minOverall = Math.min(...overallValues);
-    const maxOverall = Math.max(...overallValues);
-    const first = dataPoints[0].metrics.overall || 0;
-    const last = dataPoints[dataPoints.length - 1].metrics.overall || 0;
-    const change = last - first;
-    const changePercent = first > 0 ? (change / first) * 100 : 0;
-    return {
-        avgLine: Math.round((sumLine / dataPoints.length) * 10) / 10,
-        avgBranch: Math.round((sumBranch / dataPoints.length) * 10) / 10,
-        avgFunction: Math.round((sumFunction / dataPoints.length) * 10) / 10,
-        avgOverall: Math.round((sumOverall / dataPoints.length) * 10) / 10,
-        minOverall: Math.round(minOverall * 10) / 10,
-        maxOverall: Math.round(maxOverall * 10) / 10,
-        change: Math.round(change * 10) / 10,
-        changePercent: Math.round(changePercent * 10) / 10,
-    };
-}
-function calculateVolatility(dataPoints) {
-    if (dataPoints.length < 2)
-        return 0;
-    const overallValues = dataPoints.map((dp) => dp.metrics.overall || 0);
-    const mean = overallValues.reduce((sum, v) => sum + v, 0) / overallValues.length;
-    const squaredDiffs = overallValues.map((v) => Math.pow(v - mean, 2));
-    const variance = squaredDiffs.reduce((sum, v) => sum + v, 0) / squaredDiffs.length;
-    return Math.round(Math.sqrt(variance) * 100) / 100;
-}
-function detectRegressions(dataPoints, threshold) {
-    const regressions = [];
-    for (let i = 1; i < dataPoints.length; i++) {
-        const prev = dataPoints[i - 1];
-        const curr = dataPoints[i];
-        for (const [metric, value] of Object.entries(curr.metrics)) {
-            const prevValue = prev.metrics[metric] || 0;
-            const drop = prevValue - value;
-            if (drop >= threshold) {
-                const severity = getSeverity(drop);
-                regressions.push({
-                    id: `reg-${i}-${metric}`,
-                    date: curr.date,
-                    metric,
-                    before: prevValue,
-                    after: value,
-                    drop: Math.round(drop * 10) / 10,
-                    severity,
-                    possibleCauses: generatePossibleCauses(metric, drop),
-                    affectedFiles: [`file-${i}.ts`],
-                });
-            }
-        }
-    }
-    return regressions;
-}
-function getSeverity(drop) {
-    if (drop >= 20)
-        return 'critical';
-    if (drop >= 15)
-        return 'major';
-    if (drop >= 10)
-        return 'moderate';
-    return 'minor';
-}
-function generatePossibleCauses(metric, drop) {
-    const causes = [];
-    if (drop > 10) {
-        causes.push('Large code addition without tests');
-    }
-    causes.push('Removed or disabled tests');
-    if (metric === 'branch') {
-        causes.push('Added complex conditional logic');
-    }
-    if (metric === 'function') {
-        causes.push('Added untested utility functions');
-    }
-    return causes;
-}
-function detectImprovements(dataPoints) {
-    const improvements = [];
-    for (let i = 1; i < dataPoints.length; i++) {
-        const prev = dataPoints[i - 1];
-        const curr = dataPoints[i];
-        for (const [metric, value] of Object.entries(curr.metrics)) {
-            const prevValue = prev.metrics[metric] || 0;
-            const gain = value - prevValue;
-            if (gain >= 3) {
-                improvements.push({
-                    id: `imp-${i}-${metric}`,
-                    date: curr.date,
-                    metric,
-                    before: prevValue,
-                    after: value,
-                    gain: Math.round(gain * 10) / 10,
-                    type: curr.testsAdded > 0 ? 'test-addition' : 'refactoring',
-                    contributors: ['contributor-1'],
-                });
-            }
-        }
-    }
-    return improvements;
-}
-function generateProjections(trendData, metrics) {
-    const projections = [];
-    const dataPoints = trendData.dataPoints;
-    if (dataPoints.length < 2)
-        return projections;
-    // Calculate trend for each metric
-    for (const metric of metrics) {
-        const values = dataPoints.map((dp) => dp.metrics[metric] || 0);
-        const first = values[0];
-        const last = values[values.length - 1];
-        const trend = (last - first) / dataPoints.length;
-        const targetDate = new Date();
-        targetDate.setDate(targetDate.getDate() + 30);
-        const projectedValue = Math.min(last + trend * 30, 100);
-        const target = 80; // Default target
-        projections.push({
-            metric,
-            currentValue: last,
-            projectedValue: Math.round(projectedValue * 10) / 10,
-            targetDate: targetDate.toISOString().split('T')[0],
-            confidence: calculateConfidence(trendData.volatility),
-            requiredPace: Math.round(((target - last) / 30) * 100) / 100,
-            onTrack: projectedValue >= target,
-        });
-    }
-    return projections;
-}
-function calculateConfidence(volatility) {
-    // Lower volatility = higher confidence
-    const confidence = Math.max(0, 1 - volatility / 10);
-    return Math.round(confidence * 100) / 100;
-}
-function generateInsights(trendData, regressions, improvements, projections) {
-    const insights = [];
-    // Trend direction insight
-    if (trendData.aggregates.change > 0) {
-        insights.push({
-            type: 'pattern',
-            title: 'Positive coverage trend',
-            description: `Coverage improved by ${trendData.aggregates.changePercent}% over the analysis period`,
-            impact: trendData.aggregates.changePercent > 5 ? 'high' : 'medium',
-            actionable: false,
-        });
-    }
-    else if (trendData.aggregates.change < -2) {
-        insights.push({
-            type: 'warning',
-            title: 'Negative coverage trend',
-            description: `Coverage declined by ${Math.abs(trendData.aggregates.changePercent)}% over the analysis period`,
-            impact: 'high',
-            actionable: true,
-            suggestedAction: 'Review recent commits and add missing tests',
-        });
-    }
-    // Volatility insight
-    if (trendData.volatility > 5) {
-        insights.push({
-            type: 'anomaly',
-            title: 'High coverage volatility',
-            description: `Coverage varies significantly (std dev: ${trendData.volatility}%)`,
-            impact: 'medium',
-            actionable: true,
-            suggestedAction: 'Investigate inconsistent testing practices',
-        });
-    }
-    // Regression count insight
-    if (regressions.length > 3) {
-        insights.push({
-            type: 'warning',
-            title: 'Frequent regressions detected',
-            description: `${regressions.length} coverage regressions in the analysis period`,
-            impact: 'high',
-            actionable: true,
-            suggestedAction: 'Add coverage gates to CI/CD pipeline',
-        });
-    }
-    // Projection insights
-    const offTrack = projections.filter((p) => !p.onTrack);
-    if (offTrack.length > 0) {
-        insights.push({
-            type: 'recommendation',
-            title: 'Coverage targets at risk',
-            description: `${offTrack.length} metric(s) may not meet targets at current pace`,
-            impact: 'medium',
-            actionable: true,
-            suggestedAction: `Focus on: ${offTrack.map((p) => p.metric).join(', ')}`,
-        });
-    }
-    return insights;
-}
-// Export tool definition for MCP registration
-export const toolDefinition = {
-    name: 'aqe/track-trends',
-    description: 'Track coverage trends over time with regression detection and projections',
-    category: 'coverage-analysis',
-    version: '3.2.3',
-    inputSchema: TrackTrendsInputSchema,
-    handler,
-};
-export default toolDefinition;
-//# sourceMappingURL=track-trends.js.map

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

@@ -1,277 +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';
-export declare const AnalyzeRootCauseInputSchema: z.ZodObject<{
-    defect: z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        description: z.ZodString;
-        location: z.ZodOptional<z.ZodObject<{
-            file: z.ZodString;
-            line: z.ZodOptional<z.ZodNumber>;
-            function: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            file: string;
-            function?: string | undefined;
-            line?: number | undefined;
-        }, {
-            file: string;
-            function?: string | undefined;
-            line?: number | undefined;
-        }>>;
-        category: z.ZodOptional<z.ZodString>;
-        stackTrace: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        description: string;
-        id?: string | undefined;
-        category?: string | undefined;
-        location?: {
-            file: string;
-            function?: string | undefined;
-            line?: number | undefined;
-        } | undefined;
-        stackTrace?: string | undefined;
-    }, {
-        description: string;
-        id?: string | undefined;
-        category?: string | undefined;
-        location?: {
-            file: string;
-            function?: string | undefined;
-            line?: number | undefined;
-        } | undefined;
-        stackTrace?: string | undefined;
-    }>;
-    analysisDepth: z.ZodDefault<z.ZodEnum<["immediate", "standard", "deep"]>>;
-    includeHistorical: z.ZodDefault<z.ZodBoolean>;
-    includeRemediation: z.ZodDefault<z.ZodBoolean>;
-    maxContributingFactors: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    analysisDepth: "standard" | "deep" | "immediate";
-    defect: {
-        description: string;
-        id?: string | undefined;
-        category?: string | undefined;
-        location?: {
-            file: string;
-            function?: string | undefined;
-            line?: number | undefined;
-        } | undefined;
-        stackTrace?: string | undefined;
-    };
-    includeHistorical: boolean;
-    includeRemediation: boolean;
-    maxContributingFactors: number;
-}, {
-    defect: {
-        description: string;
-        id?: string | undefined;
-        category?: string | undefined;
-        location?: {
-            file: string;
-            function?: string | undefined;
-            line?: number | undefined;
-        } | undefined;
-        stackTrace?: string | undefined;
-    };
-    analysisDepth?: "standard" | "deep" | "immediate" | undefined;
-    includeHistorical?: boolean | undefined;
-    includeRemediation?: boolean | undefined;
-    maxContributingFactors?: number | undefined;
-}>;
-export type AnalyzeRootCauseInput = z.infer<typeof AnalyzeRootCauseInputSchema>;
-export interface AnalyzeRootCauseOutput {
-    success: boolean;
-    rootCause: RootCause;
-    causalChain: CausalChainLink[];
-    contributingFactors: ContributingFactor[];
-    historicalAnalysis: HistoricalAnalysis | null;
-    remediation: RemediationPlan | null;
-    preventionMeasures: PreventionMeasure[];
-    metadata: RootCauseMetadata;
-}
-export interface RootCause {
-    id: string;
-    type: 'code' | 'design' | 'process' | 'environment' | 'human';
-    category: string;
-    description: string;
-    confidence: number;
-    evidence: string[];
-    technicalDetails: TechnicalDetails;
-}
-export interface TechnicalDetails {
-    codePattern?: string;
-    antiPattern?: string;
-    affectedComponents: string[];
-    dataFlow?: string;
-    controlFlow?: string;
-}
-export interface CausalChainLink {
-    level: number;
-    description: string;
-    type: 'symptom' | 'proximate' | 'intermediate' | 'root';
-    evidence: string;
-    confidence: number;
-}
-export interface ContributingFactor {
-    id: string;
-    category: 'technical' | 'process' | 'organizational' | 'environmental';
-    description: string;
-    severity: 'major' | 'moderate' | 'minor';
-    evidence: string;
-    addressable: boolean;
-}
-export interface HistoricalAnalysis {
-    similarDefects: SimilarDefectMatch[];
-    recurringPatterns: RecurringPattern[];
-    trendAnalysis: TrendInfo;
-}
-export interface SimilarDefectMatch {
-    defectId: string;
-    similarity: number;
-    resolution: string;
-    resolvedDate: string;
-    resolutionEffective: boolean;
-}
-export interface RecurringPattern {
-    pattern: string;
-    occurrences: number;
-    firstSeen: string;
-    lastSeen: string;
-    addressed: boolean;
-}
-export interface TrendInfo {
-    increasing: boolean;
-    frequency: string;
-    hotspots: string[];
-}
-export interface RemediationPlan {
-    immediateActions: RemediationAction[];
-    shortTermActions: RemediationAction[];
-    longTermActions: RemediationAction[];
-    estimatedEffort: string;
-    riskIfUnaddressed: string;
-}
-export interface RemediationAction {
-    priority: number;
-    action: string;
-    owner: string;
-    effort: 'low' | 'medium' | 'high';
-    impact: 'low' | 'medium' | 'high';
-    timeframe: string;
-}
-export interface PreventionMeasure {
-    measure: string;
-    type: 'code-review' | 'testing' | 'tooling' | 'training' | 'process';
-    effectiveness: number;
-    implementation: string;
-    cost: 'low' | 'medium' | 'high';
-}
-export interface RootCauseMetadata {
-    analyzedAt: string;
-    durationMs: number;
-    analysisDepth: string;
-    confidenceScore: number;
-    methodsUsed: string[];
-}
-export interface ToolContext {
-    get<T>(key: string): T | undefined;
-}
-/**
- * MCP Tool Handler for analyze-root-cause
- */
-export declare function handler(input: AnalyzeRootCauseInput, context: ToolContext): Promise<{
-    content: Array<{
-        type: 'text';
-        text: string;
-    }>;
-}>;
-export declare const toolDefinition: {
-    name: string;
-    description: string;
-    category: string;
-    version: string;
-    inputSchema: z.ZodObject<{
-        defect: z.ZodObject<{
-            id: z.ZodOptional<z.ZodString>;
-            description: z.ZodString;
-            location: z.ZodOptional<z.ZodObject<{
-                file: z.ZodString;
-                line: z.ZodOptional<z.ZodNumber>;
-                function: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                file: string;
-                function?: string | undefined;
-                line?: number | undefined;
-            }, {
-                file: string;
-                function?: string | undefined;
-                line?: number | undefined;
-            }>>;
-            category: z.ZodOptional<z.ZodString>;
-            stackTrace: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            description: string;
-            id?: string | undefined;
-            category?: string | undefined;
-            location?: {
-                file: string;
-                function?: string | undefined;
-                line?: number | undefined;
-            } | undefined;
-            stackTrace?: string | undefined;
-        }, {
-            description: string;
-            id?: string | undefined;
-            category?: string | undefined;
-            location?: {
-                file: string;
-                function?: string | undefined;
-                line?: number | undefined;
-            } | undefined;
-            stackTrace?: string | undefined;
-        }>;
-        analysisDepth: z.ZodDefault<z.ZodEnum<["immediate", "standard", "deep"]>>;
-        includeHistorical: z.ZodDefault<z.ZodBoolean>;
-        includeRemediation: z.ZodDefault<z.ZodBoolean>;
-        maxContributingFactors: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        analysisDepth: "standard" | "deep" | "immediate";
-        defect: {
-            description: string;
-            id?: string | undefined;
-            category?: string | undefined;
-            location?: {
-                file: string;
-                function?: string | undefined;
-                line?: number | undefined;
-            } | undefined;
-            stackTrace?: string | undefined;
-        };
-        includeHistorical: boolean;
-        includeRemediation: boolean;
-        maxContributingFactors: number;
-    }, {
-        defect: {
-            description: string;
-            id?: string | undefined;
-            category?: string | undefined;
-            location?: {
-                file: string;
-                function?: string | undefined;
-                line?: number | undefined;
-            } | undefined;
-            stackTrace?: string | undefined;
-        };
-        analysisDepth?: "standard" | "deep" | "immediate" | undefined;
-        includeHistorical?: boolean | undefined;
-        includeRemediation?: boolean | undefined;
-        maxContributingFactors?: number | undefined;
-    }>;
-    handler: typeof handler;
-};
-export default toolDefinition;
-//# sourceMappingURL=analyze-root-cause.d.ts.map