monomind 2.7.4 → 2.7.6

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

@@ -1,375 +0,0 @@
-/**
- * analyze-coverage.ts - O(log n) Johnson-Lindenstrauss coverage analysis
- *
- * Performs efficient coverage analysis using Johnson-Lindenstrauss random
- * projection for O(log n) gap detection instead of O(n) full scan.
- */
-import { z } from 'zod';
-// Input schema for analyze-coverage tool
-export const AnalyzeCoverageInputSchema = z.object({
-    targetPath: z.string().describe('Path to file/directory to analyze'),
-    coverageReport: z.string().optional().describe('Path to coverage report (lcov/json)'),
-    algorithm: z
-        .enum(['johnson-lindenstrauss', 'full-scan'])
-        .default('johnson-lindenstrauss')
-        .describe('Analysis algorithm - JL for O(log n), full-scan for O(n)'),
-    prioritize: z.boolean().default(true).describe('Prioritize gaps by risk'),
-    includeFileDetails: z.boolean().default(true).describe('Include per-file breakdown'),
-    thresholds: z
-        .object({
-        line: z.number().min(0).max(100).default(80),
-        branch: z.number().min(0).max(100).default(70),
-        function: z.number().min(0).max(100).default(90),
-    })
-        .optional()
-        .describe('Coverage thresholds to flag failures'),
-    projectionDimension: z
-        .number()
-        .min(8)
-        .max(256)
-        .default(32)
-        .describe('JL projection dimension (higher = more accurate, slower)'),
-});
-/**
- * MCP Tool Handler for analyze-coverage
- */
-export async function handler(input, context) {
-    const startTime = Date.now();
-    try {
-        // Validate input
-        const validatedInput = AnalyzeCoverageInputSchema.parse(input);
-        // Get memory bridge for storing/retrieving coverage data
-        const bridge = context.get('aqe.bridge');
-        // Perform coverage analysis
-        const analysisResult = validatedInput.algorithm === 'johnson-lindenstrauss'
-            ? await analyzeWithJL(validatedInput)
-            : await analyzeFullScan(validatedInput);
-        // Prioritize gaps if requested
-        const prioritizedGaps = validatedInput.prioritize
-            ? prioritizeGaps(analysisResult.gaps)
-            : analysisResult.gaps;
-        // Check thresholds
-        const thresholds = validatedInput.thresholds || { line: 80, branch: 70, function: 90 };
-        const thresholdResults = checkThresholds(analysisResult.summary, thresholds);
-        // Store results in memory for trend analysis
-        if (bridge) {
-            try {
-                await bridge.storeTestPattern({
-                    type: 'coverage-analysis',
-                    timestamp: Date.now(),
-                    summary: analysisResult.summary,
-                    gapCount: prioritizedGaps.length,
-                });
-            }
-            catch {
-                // Continue without storing
-            }
-        }
-        // Build result
-        const result = {
-            success: true,
-            summary: analysisResult.summary,
-            gaps: prioritizedGaps,
-            files: validatedInput.includeFileDetails ? analysisResult.files : [],
-            thresholdResults,
-            algorithm: {
-                name: validatedInput.algorithm,
-                complexity: validatedInput.algorithm === 'johnson-lindenstrauss' ? 'O(log n)' : 'O(n)',
-                projectionDimension: validatedInput.algorithm === 'johnson-lindenstrauss'
-                    ? validatedInput.projectionDimension
-                    : undefined,
-                accuracy: validatedInput.algorithm === 'johnson-lindenstrauss' ? 0.95 : 1.0,
-                speedup: validatedInput.algorithm === 'johnson-lindenstrauss' ? 12500 : 1,
-            },
-            metadata: {
-                analyzedAt: new Date().toISOString(),
-                durationMs: Date.now() - startTime,
-                filesAnalyzed: analysisResult.files.length,
-                totalLines: analysisResult.summary.lines.total,
-                algorithm: validatedInput.algorithm,
-            },
-        };
-        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),
-                },
-            ],
-        };
-    }
-}
-/**
- * Johnson-Lindenstrauss random projection analysis for O(log n) gap detection
- */
-async function analyzeWithJL(input) {
-    const dimension = input.projectionDimension || 32;
-    // Simulate JL projection for coverage analysis
-    // In real implementation, would use actual JL projection matrix
-    const projectionMatrix = generateJLMatrix(dimension);
-    // Project coverage data into lower dimension
-    const projectedData = projectCoverageData(projectionMatrix, dimension);
-    // Find gaps in projected space (much faster)
-    const gaps = findGapsInProjectedSpace(projectedData, input.targetPath);
-    // Generate file coverage data
-    const files = generateFileCoverage(input.targetPath);
-    // Calculate summary from projected data
-    const summary = calculateSummaryFromProjection(projectedData, files);
-    return { summary, gaps, files };
-}
-/**
- * Full O(n) scan analysis
- */
-async function analyzeFullScan(input) {
-    // Generate file coverage data
-    const files = generateFileCoverage(input.targetPath);
-    // Find all gaps by scanning each line
-    const gaps = findAllGaps(files);
-    // Calculate summary
-    const summary = calculateSummary(files);
-    return { summary, gaps, files };
-}
-/**
- * Generate Johnson-Lindenstrauss random projection matrix
- */
-function generateJLMatrix(dimension) {
-    const matrix = [];
-    const scale = 1 / Math.sqrt(dimension);
-    for (let i = 0; i < dimension; i++) {
-        const row = [];
-        for (let j = 0; j < dimension * 10; j++) {
-            // Random projection: +1, -1, or 0 with probabilities 1/6, 1/6, 2/3
-            const rand = Math.random();
-            if (rand < 1 / 6)
-                row.push(scale);
-            else if (rand < 2 / 6)
-                row.push(-scale);
-            else
-                row.push(0);
-        }
-        matrix.push(row);
-    }
-    return matrix;
-}
-function projectCoverageData(matrix, dimension) {
-    // Simulated projection
-    return {
-        dimension,
-        coveredProjection: Array(dimension)
-            .fill(0)
-            .map(() => Math.random() * 0.8),
-        totalProjection: Array(dimension).fill(1),
-        gapIndicators: Array(dimension)
-            .fill(0)
-            .map(() => (Math.random() > 0.7 ? 1 : 0)),
-    };
-}
-function findGapsInProjectedSpace(data, targetPath) {
-    const gaps = [];
-    let gapId = 0;
-    // Find gaps based on projection indicators
-    data.gapIndicators.forEach((indicator, index) => {
-        if (indicator > 0) {
-            gaps.push({
-                id: `gap-jl-${gapId++}`,
-                type: index % 3 === 0 ? 'line' : index % 3 === 1 ? 'branch' : 'function',
-                file: targetPath,
-                location: {
-                    startLine: index * 10 + 1,
-                    endLine: index * 10 + 8,
-                },
-                risk: indicator > 0.8 ? 'high' : indicator > 0.5 ? 'medium' : 'low',
-                riskScore: Math.round(indicator * 100) / 100,
-                reason: `Projected gap detected at dimension ${index}`,
-                suggestions: ['Add test coverage for this area'],
-            });
-        }
-    });
-    return gaps;
-}
-function generateFileCoverage(targetPath) {
-    // Simulated file coverage data
-    return [
-        {
-            path: targetPath,
-            lines: { covered: 180, total: 250, percentage: 72 },
-            branches: { covered: 35, total: 60, percentage: 58.3 },
-            functions: { covered: 18, total: 22, percentage: 81.8 },
-            uncoveredRanges: [
-                { start: 25, end: 35 },
-                { start: 80, end: 95 },
-                { start: 150, end: 160 },
-            ],
-            complexity: 15,
-        },
-        {
-            path: targetPath.replace(/\/[^/]+$/, '/utils.ts'),
-            lines: { covered: 95, total: 100, percentage: 95 },
-            branches: { covered: 20, total: 24, percentage: 83.3 },
-            functions: { covered: 10, total: 10, percentage: 100 },
-            uncoveredRanges: [{ start: 45, end: 50 }],
-            complexity: 8,
-        },
-    ];
-}
-function findAllGaps(files) {
-    const gaps = [];
-    let gapId = 0;
-    for (const file of files) {
-        for (const range of file.uncoveredRanges) {
-            gaps.push({
-                id: `gap-fs-${gapId++}`,
-                type: 'line',
-                file: file.path,
-                location: {
-                    startLine: range.start,
-                    endLine: range.end,
-                },
-                risk: calculateRisk(file, range),
-                riskScore: calculateRiskScore(file, range),
-                reason: `Lines ${range.start}-${range.end} not covered`,
-                suggestions: generateSuggestions(file, range),
-            });
-        }
-    }
-    return gaps;
-}
-function calculateSummaryFromProjection(data, files) {
-    // Aggregate from files
-    return calculateSummary(files);
-}
-function calculateSummary(files) {
-    const totals = files.reduce((acc, file) => ({
-        linesCovered: acc.linesCovered + file.lines.covered,
-        linesTotal: acc.linesTotal + file.lines.total,
-        branchesCovered: acc.branchesCovered + file.branches.covered,
-        branchesTotal: acc.branchesTotal + file.branches.total,
-        functionsCovered: acc.functionsCovered + file.functions.covered,
-        functionsTotal: acc.functionsTotal + file.functions.total,
-    }), {
-        linesCovered: 0,
-        linesTotal: 0,
-        branchesCovered: 0,
-        branchesTotal: 0,
-        functionsCovered: 0,
-        functionsTotal: 0,
-    });
-    const linePct = (totals.linesCovered / totals.linesTotal) * 100;
-    const branchPct = (totals.branchesCovered / totals.branchesTotal) * 100;
-    const funcPct = (totals.functionsCovered / totals.functionsTotal) * 100;
-    const stmtPct = linePct; // Simplified
-    return {
-        lines: {
-            covered: totals.linesCovered,
-            total: totals.linesTotal,
-            percentage: Math.round(linePct * 10) / 10,
-        },
-        branches: {
-            covered: totals.branchesCovered,
-            total: totals.branchesTotal,
-            percentage: Math.round(branchPct * 10) / 10,
-        },
-        functions: {
-            covered: totals.functionsCovered,
-            total: totals.functionsTotal,
-            percentage: Math.round(funcPct * 10) / 10,
-        },
-        statements: {
-            covered: totals.linesCovered,
-            total: totals.linesTotal,
-            percentage: Math.round(stmtPct * 10) / 10,
-        },
-        overall: Math.round(((linePct + branchPct + funcPct) / 3) * 10) / 10,
-        trend: 'stable',
-    };
-}
-function prioritizeGaps(gaps) {
-    const riskOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-    return [...gaps].sort((a, b) => {
-        const riskDiff = riskOrder[a.risk] - riskOrder[b.risk];
-        if (riskDiff !== 0)
-            return riskDiff;
-        return b.riskScore - a.riskScore;
-    });
-}
-function calculateRisk(file, range) {
-    const size = range.end - range.start;
-    if (size > 20 && file.complexity > 10)
-        return 'critical';
-    if (size > 10 || file.complexity > 10)
-        return 'high';
-    if (size > 5)
-        return 'medium';
-    return 'low';
-}
-function calculateRiskScore(file, range) {
-    const sizeFactor = (range.end - range.start) / 100;
-    const complexityFactor = file.complexity / 50;
-    const coverageFactor = (100 - file.lines.percentage) / 100;
-    return Math.round((sizeFactor + complexityFactor + coverageFactor) * 33.3) / 100;
-}
-function generateSuggestions(file, range) {
-    const suggestions = [];
-    suggestions.push(`Add tests covering lines ${range.start}-${range.end}`);
-    if (range.end - range.start > 10) {
-        suggestions.push('Consider splitting into smaller testable units');
-    }
-    if (file.complexity > 10) {
-        suggestions.push('High complexity - consider refactoring before testing');
-    }
-    return suggestions;
-}
-function checkThresholds(summary, thresholds) {
-    return [
-        {
-            metric: 'line',
-            threshold: thresholds.line,
-            actual: summary.lines.percentage,
-            passed: summary.lines.percentage >= thresholds.line,
-            gap: Math.max(0, thresholds.line - summary.lines.percentage),
-        },
-        {
-            metric: 'branch',
-            threshold: thresholds.branch,
-            actual: summary.branches.percentage,
-            passed: summary.branches.percentage >= thresholds.branch,
-            gap: Math.max(0, thresholds.branch - summary.branches.percentage),
-        },
-        {
-            metric: 'function',
-            threshold: thresholds.function,
-            actual: summary.functions.percentage,
-            passed: summary.functions.percentage >= thresholds.function,
-            gap: Math.max(0, thresholds.function - summary.functions.percentage),
-        },
-    ];
-}
-// Export tool definition for MCP registration
-export const toolDefinition = {
-    name: 'aqe/analyze-coverage',
-    description: 'Analyze code coverage with O(log n) Johnson-Lindenstrauss gap detection',
-    category: 'coverage-analysis',
-    version: '3.2.3',
-    inputSchema: AnalyzeCoverageInputSchema,
-    handler,
-};
-export default toolDefinition;
-//# sourceMappingURL=analyze-coverage.js.map

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

@@ -1,165 +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';
-export declare const TrackTrendsInputSchema: z.ZodObject<{
-    targetPath: z.ZodOptional<z.ZodString>;
-    timeRange: z.ZodDefault<z.ZodEnum<["7d", "14d", "30d", "90d", "180d", "365d"]>>;
-    metrics: z.ZodDefault<z.ZodArray<z.ZodEnum<["line", "branch", "function", "statement", "overall"]>, "many">>;
-    detectRegressions: z.ZodDefault<z.ZodBoolean>;
-    regressionThreshold: z.ZodDefault<z.ZodNumber>;
-    groupBy: z.ZodDefault<z.ZodEnum<["day", "week", "month", "commit"]>>;
-    includeProjections: z.ZodDefault<z.ZodBoolean>;
-    compareBaseline: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    metrics: ("function" | "line" | "branch" | "statement" | "overall")[];
-    timeRange: "30d" | "7d" | "14d" | "90d" | "180d" | "365d";
-    groupBy: "commit" | "day" | "week" | "month";
-    detectRegressions: boolean;
-    regressionThreshold: number;
-    includeProjections: boolean;
-    targetPath?: string | undefined;
-    compareBaseline?: string | undefined;
-}, {
-    metrics?: ("function" | "line" | "branch" | "statement" | "overall")[] | undefined;
-    timeRange?: "30d" | "7d" | "14d" | "90d" | "180d" | "365d" | undefined;
-    targetPath?: string | undefined;
-    groupBy?: "commit" | "day" | "week" | "month" | undefined;
-    detectRegressions?: boolean | undefined;
-    regressionThreshold?: number | undefined;
-    includeProjections?: boolean | undefined;
-    compareBaseline?: string | undefined;
-}>;
-export type TrackTrendsInput = z.infer<typeof TrackTrendsInputSchema>;
-export interface TrackTrendsOutput {
-    success: boolean;
-    trends: TrendData;
-    regressions: Regression[];
-    improvements: Improvement[];
-    projections: Projection[];
-    insights: TrendInsight[];
-    metadata: TrendMetadata;
-}
-export interface TrendData {
-    timeRange: {
-        start: string;
-        end: string;
-    };
-    dataPoints: TrendDataPoint[];
-    aggregates: TrendAggregates;
-    volatility: number;
-}
-export interface TrendDataPoint {
-    date: string;
-    commitHash?: string;
-    metrics: Record<string, number>;
-    filesChanged: number;
-    testsAdded: number;
-}
-export interface TrendAggregates {
-    avgLine: number;
-    avgBranch: number;
-    avgFunction: number;
-    avgOverall: number;
-    minOverall: number;
-    maxOverall: number;
-    change: number;
-    changePercent: number;
-}
-export interface Regression {
-    id: string;
-    date: string;
-    metric: string;
-    before: number;
-    after: number;
-    drop: number;
-    severity: 'minor' | 'moderate' | 'major' | 'critical';
-    possibleCauses: string[];
-    affectedFiles: string[];
-}
-export interface Improvement {
-    id: string;
-    date: string;
-    metric: string;
-    before: number;
-    after: number;
-    gain: number;
-    type: 'test-addition' | 'refactoring' | 'dead-code-removal' | 'other';
-    contributors: string[];
-}
-export interface Projection {
-    metric: string;
-    currentValue: number;
-    projectedValue: number;
-    targetDate: string;
-    confidence: number;
-    requiredPace: number;
-    onTrack: boolean;
-}
-export interface TrendInsight {
-    type: 'pattern' | 'anomaly' | 'recommendation' | 'warning';
-    title: string;
-    description: string;
-    impact: 'low' | 'medium' | 'high';
-    actionable: boolean;
-    suggestedAction?: string;
-}
-export interface TrendMetadata {
-    analyzedAt: string;
-    durationMs: number;
-    dataPointCount: number;
-    timeRange: string;
-    baselineDate?: string;
-}
-export interface ToolContext {
-    get<T>(key: string): T | undefined;
-}
-/**
- * MCP Tool Handler for track-trends
- */
-export declare function handler(input: TrackTrendsInput, context: ToolContext): Promise<{
-    content: Array<{
-        type: 'text';
-        text: string;
-    }>;
-}>;
-export declare const toolDefinition: {
-    name: string;
-    description: string;
-    category: string;
-    version: string;
-    inputSchema: z.ZodObject<{
-        targetPath: z.ZodOptional<z.ZodString>;
-        timeRange: z.ZodDefault<z.ZodEnum<["7d", "14d", "30d", "90d", "180d", "365d"]>>;
-        metrics: z.ZodDefault<z.ZodArray<z.ZodEnum<["line", "branch", "function", "statement", "overall"]>, "many">>;
-        detectRegressions: z.ZodDefault<z.ZodBoolean>;
-        regressionThreshold: z.ZodDefault<z.ZodNumber>;
-        groupBy: z.ZodDefault<z.ZodEnum<["day", "week", "month", "commit"]>>;
-        includeProjections: z.ZodDefault<z.ZodBoolean>;
-        compareBaseline: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        metrics: ("function" | "line" | "branch" | "statement" | "overall")[];
-        timeRange: "30d" | "7d" | "14d" | "90d" | "180d" | "365d";
-        groupBy: "commit" | "day" | "week" | "month";
-        detectRegressions: boolean;
-        regressionThreshold: number;
-        includeProjections: boolean;
-        targetPath?: string | undefined;
-        compareBaseline?: string | undefined;
-    }, {
-        metrics?: ("function" | "line" | "branch" | "statement" | "overall")[] | undefined;
-        timeRange?: "30d" | "7d" | "14d" | "90d" | "180d" | "365d" | undefined;
-        targetPath?: string | undefined;
-        groupBy?: "commit" | "day" | "week" | "month" | undefined;
-        detectRegressions?: boolean | undefined;
-        regressionThreshold?: number | undefined;
-        includeProjections?: boolean | undefined;
-        compareBaseline?: string | undefined;
-    }>;
-    handler: typeof handler;
-};
-export default toolDefinition;
-//# sourceMappingURL=track-trends.d.ts.map