@agentic-qe/v3 3.0.0-alpha.3

package/dist/mcp/tools/coverage-analysis/index.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Agentic QE v3 - Coverage Analysis MCP Tools
+ *
+ * qe/coverage/analyze - Analyze code coverage using REAL parsers
+ * qe/coverage/gaps - Find coverage gaps using O(log n) HNSW search
+ *
+ * This module wraps the REAL coverage-analysis domain services.
+ * Uses actual LCOV/JSON parsing and vector-based gap detection.
+ */
+import { MCPToolBase, MCPToolConfig, MCPToolContext } from '../base';
+import { ToolResult } from '../../types';
+export interface CoverageAnalyzeParams {
+    target?: string;
+    coverageFile?: string;
+    thresholds?: CoverageThresholds;
+    includeRisk?: boolean;
+    includeRiskScoring?: boolean;
+    mlPowered?: boolean;
+    dryRun?: boolean;
+    [key: string]: unknown;
+}
+export interface CoverageThresholds {
+    lines?: number;
+    branches?: number;
+    functions?: number;
+    statements?: number;
+}
+export interface CoverageAnalyzeResult {
+    summary: CoverageSummary;
+    byFile: FileCoverage[];
+    thresholdsPassed: boolean;
+    riskScore?: number;
+    trends?: CoverageTrend;
+}
+export interface CoverageSummary {
+    lines: CoverageMetric;
+    branches: CoverageMetric;
+    functions: CoverageMetric;
+    statements: CoverageMetric;
+}
+export interface CoverageMetric {
+    covered: number;
+    total: number;
+    percentage: number;
+}
+export interface FileCoverage {
+    file: string;
+    lines: number;
+    branches: number;
+    functions: number;
+    uncoveredLines: number[];
+}
+export interface CoverageTrend {
+    direction: 'improving' | 'declining' | 'stable';
+    delta: number;
+    history: {
+        date: string;
+        coverage: number;
+    }[];
+}
+export interface CoverageGapsParams {
+    target?: string;
+    coverageFile?: string;
+    minRisk?: number;
+    limit?: number;
+    prioritization?: 'complexity' | 'criticality' | 'change-frequency' | 'ml-confidence';
+    [key: string]: unknown;
+}
+export interface CoverageGapsResult {
+    gaps: CoverageGap[];
+    totalGaps: number;
+    criticalGaps: number;
+    suggestedTests: TestSuggestion[];
+}
+export interface CoverageGap {
+    file: string;
+    lines: number[];
+    type: 'uncovered-line' | 'uncovered-branch' | 'uncovered-function';
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    riskScore: number;
+    reason: string;
+}
+export interface TestSuggestion {
+    file: string;
+    description: string;
+    estimatedCoverageGain: number;
+    priority: number;
+}
+export declare class CoverageAnalyzeTool extends MCPToolBase<CoverageAnalyzeParams, CoverageAnalyzeResult> {
+    readonly config: MCPToolConfig;
+    private analyzerService;
+    private getService;
+    execute(params: CoverageAnalyzeParams, context: MCPToolContext): Promise<ToolResult<CoverageAnalyzeResult>>;
+    /**
+     * Returns demo coverage data when no real data is available.
+     * Only used when demoMode is explicitly requested or as fallback with warning.
+     */
+    private getDemoResult;
+}
+export declare class CoverageGapsTool extends MCPToolBase<CoverageGapsParams, CoverageGapsResult> {
+    readonly config: MCPToolConfig;
+    private gapService;
+    private getService;
+    execute(params: CoverageGapsParams, context: MCPToolContext): Promise<ToolResult<CoverageGapsResult>>;
+    /**
+     * Returns demo gap data when no real coverage data is available.
+     * Only used when demoMode is explicitly requested or as fallback with warning.
+     */
+    private getDemoGapsResult;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/tools/coverage-analysis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tools/coverage-analysis/index.ts"],"names":[],"mappings":"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"}

package/dist/mcp/tools/coverage-analysis/index.js

@@ -0,0 +1,577 @@
+/**
+ * Agentic QE v3 - Coverage Analysis MCP Tools
+ *
+ * qe/coverage/analyze - Analyze code coverage using REAL parsers
+ * qe/coverage/gaps - Find coverage gaps using O(log n) HNSW search
+ *
+ * This module wraps the REAL coverage-analysis domain services.
+ * Uses actual LCOV/JSON parsing and vector-based gap detection.
+ */
+import { MCPToolBase } from '../base';
+import { CoverageAnalyzerService } from '../../../domains/coverage-analysis/services/coverage-analyzer';
+import { GapDetectorService } from '../../../domains/coverage-analysis/services/gap-detector';
+import { findAndParseCoverage, parseCoverage, } from '../../../domains/coverage-analysis/services/coverage-parser';
+// ============================================================================
+// Helper: Create Minimal Memory Backend
+// ============================================================================
+function createMinimalMemoryBackend() {
+    const store = new Map();
+    const vectors = new Map();
+    return {
+        async initialize() {
+            // No initialization needed
+        },
+        async dispose() {
+            store.clear();
+            vectors.clear();
+        },
+        async set(key, value, _options) {
+            store.set(key, { value });
+        },
+        async get(key) {
+            const entry = store.get(key);
+            return entry ? entry.value : undefined;
+        },
+        async delete(key) {
+            return store.delete(key);
+        },
+        async has(key) {
+            return store.has(key);
+        },
+        async search(_pattern, _limit) {
+            return [];
+        },
+        async vectorSearch(embedding, k) {
+            const results = Array.from(vectors.entries())
+                .map(([key, data]) => {
+                let dot = 0, normA = 0, normB = 0;
+                for (let i = 0; i < embedding.length; i++) {
+                    dot += embedding[i] * (data.embedding[i] || 0);
+                    normA += embedding[i] * embedding[i];
+                    normB += (data.embedding[i] || 0) * (data.embedding[i] || 0);
+                }
+                const score = dot / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
+                return { key, score, metadata: data.metadata };
+            })
+                .sort((a, b) => b.score - a.score)
+                .slice(0, k);
+            return results;
+        },
+        async storeVector(key, embedding, metadata) {
+            vectors.set(key, { embedding, metadata });
+        },
+    };
+}
+// ============================================================================
+// Helper: Calculate Coverage Summary from Files
+// ============================================================================
+function calculateSummary(files) {
+    let totalLines = 0, coveredLines = 0;
+    let totalBranches = 0, coveredBranches = 0;
+    let totalFunctions = 0, coveredFunctions = 0;
+    let totalStatements = 0, coveredStatements = 0;
+    for (const file of files) {
+        totalLines += file.lines.total;
+        coveredLines += file.lines.covered;
+        totalBranches += file.branches.total;
+        coveredBranches += file.branches.covered;
+        totalFunctions += file.functions.total;
+        coveredFunctions += file.functions.covered;
+        totalStatements += file.statements.total;
+        coveredStatements += file.statements.covered;
+    }
+    return {
+        line: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
+        branch: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0,
+        function: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
+        statement: totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0,
+        files: files.length,
+    };
+}
+// ============================================================================
+// Helper: Convert Parsed Coverage to Domain Format
+// ============================================================================
+function convertParsedToDomainFormat(parsed) {
+    const files = [];
+    for (const [filePath, coverage] of parsed.files.entries()) {
+        files.push({
+            path: coverage.relativePath || filePath,
+            lines: {
+                covered: coverage.lines.covered,
+                total: coverage.lines.total,
+            },
+            branches: {
+                covered: coverage.branches.covered,
+                total: coverage.branches.total,
+            },
+            functions: {
+                covered: coverage.functions.covered,
+                total: coverage.functions.total,
+            },
+            statements: {
+                covered: coverage.statements.covered,
+                total: coverage.statements.total,
+            },
+            uncoveredLines: coverage.lines.uncoveredLines,
+            uncoveredBranches: coverage.branches.uncoveredBranches.map((b) => b.line),
+        });
+    }
+    return files;
+}
+// ============================================================================
+// Coverage Analyze Tool
+// ============================================================================
+export class CoverageAnalyzeTool extends MCPToolBase {
+    config = {
+        name: 'qe/coverage/analyze',
+        description: 'Analyze code coverage using real LCOV/JSON parsing and compare against thresholds. Includes risk scoring and trend analysis.',
+        domain: 'coverage-analysis',
+        schema: COVERAGE_ANALYZE_SCHEMA,
+        streaming: true,
+        timeout: 180000,
+    };
+    analyzerService = null;
+    getService(context) {
+        if (!this.analyzerService) {
+            const memory = context.memory;
+            this.analyzerService = new CoverageAnalyzerService(memory || createMinimalMemoryBackend());
+        }
+        return this.analyzerService;
+    }
+    async execute(params, context) {
+        const { target = '.', coverageFile, thresholds = { lines: 80, branches: 70, functions: 80, statements: 80 }, includeRisk = false, includeRiskScoring = false, dryRun = false, } = params;
+        const shouldIncludeRisk = includeRisk || includeRiskScoring;
+        try {
+            this.emitStream(context, {
+                status: 'analyzing',
+                message: `Analyzing coverage for ${target}`,
+            });
+            if (this.isAborted(context)) {
+                return { success: false, error: 'Operation aborted' };
+            }
+            // Check if demo mode is EXPLICITLY requested (only for testing/docs)
+            if (this.isDemoMode(context) || dryRun) {
+                this.markAsDemoData(context, 'Demo mode explicitly requested');
+                return this.getDemoResult(target, thresholds, shouldIncludeRisk, context);
+            }
+            // Parse real coverage data - NO FALLBACKS
+            let parsedReport = null;
+            if (coverageFile) {
+                try {
+                    parsedReport = await parseCoverage(coverageFile, target);
+                }
+                catch (parseError) {
+                    // Return error - don't silently fall back to fake data
+                    return {
+                        success: false,
+                        error: `Failed to parse coverage file '${coverageFile}': ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+                    };
+                }
+            }
+            else {
+                // Try to find coverage in target directory
+                parsedReport = await findAndParseCoverage(target);
+            }
+            // If no coverage data found, return error with actionable guidance
+            if (!parsedReport || parsedReport.files.size === 0) {
+                return {
+                    success: false,
+                    error: `No coverage data found in '${target}'. Run your test suite with coverage enabled (e.g., 'npm test -- --coverage') and ensure coverage reports are generated (lcov.info, coverage-final.json, etc.)`,
+                };
+            }
+            // Mark as real data - we have actual coverage
+            this.markAsRealData();
+            // Convert to domain format
+            const domainFiles = convertParsedToDomainFormat(parsedReport);
+            // Use real analyzer service
+            const service = this.getService(context);
+            const analyzeResult = await service.analyze({
+                coverageData: { files: domainFiles, summary: calculateSummary(domainFiles) },
+                threshold: thresholds.lines || 80,
+                includeFileDetails: true,
+            });
+            if (!analyzeResult.success) {
+                return {
+                    success: false,
+                    error: `Analysis failed: ${analyzeResult.error?.message || 'Unknown error'}`,
+                };
+            }
+            const report = analyzeResult.value;
+            // Build output summary from parsed data
+            const summary = {
+                lines: {
+                    covered: parsedReport.summary.lines.covered,
+                    total: parsedReport.summary.lines.total,
+                    percentage: Math.round(parsedReport.summary.lines.percentage * 100) / 100,
+                },
+                branches: {
+                    covered: parsedReport.summary.branches.covered,
+                    total: parsedReport.summary.branches.total,
+                    percentage: Math.round(parsedReport.summary.branches.percentage * 100) / 100,
+                },
+                functions: {
+                    covered: parsedReport.summary.functions.covered,
+                    total: parsedReport.summary.functions.total,
+                    percentage: Math.round(parsedReport.summary.functions.percentage * 100) / 100,
+                },
+                statements: {
+                    covered: parsedReport.summary.statements.covered,
+                    total: parsedReport.summary.statements.total,
+                    percentage: Math.round(parsedReport.summary.statements.percentage * 100) / 100,
+                },
+            };
+            // Build file-level coverage
+            const byFile = domainFiles.map((f) => ({
+                file: f.path,
+                lines: Math.round((f.lines.covered / (f.lines.total || 1)) * 100),
+                branches: Math.round((f.branches.covered / (f.branches.total || 1)) * 100),
+                functions: Math.round((f.functions.covered / (f.functions.total || 1)) * 100),
+                uncoveredLines: f.uncoveredLines.slice(0, 20), // Limit for output
+            }));
+            // Check thresholds
+            const thresholdsPassed = summary.lines.percentage >= (thresholds.lines || 0) &&
+                summary.branches.percentage >= (thresholds.branches || 0) &&
+                summary.functions.percentage >= (thresholds.functions || 0) &&
+                summary.statements.percentage >= (thresholds.statements || 0);
+            // Calculate risk score if requested
+            let riskScore;
+            if (shouldIncludeRisk) {
+                const totalUncovered = domainFiles.reduce((sum, f) => sum + f.uncoveredLines.length, 0);
+                const avgCoverage = (summary.lines.percentage + summary.branches.percentage + summary.functions.percentage) / 3;
+                riskScore = Math.round((1 - avgCoverage / 100 + Math.min(totalUncovered / 1000, 0.5)) * 100) / 100;
+            }
+            // Build trend from delta if available
+            let trends;
+            if (report.delta) {
+                trends = {
+                    direction: report.delta.trend,
+                    delta: Math.round((report.delta.line + report.delta.branch + report.delta.function) / 3 * 100) / 100,
+                    history: [
+                        { date: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0], coverage: summary.lines.percentage - (report.delta.line || 0) },
+                        { date: new Date().toISOString().split('T')[0], coverage: summary.lines.percentage },
+                    ],
+                };
+            }
+            this.emitStream(context, {
+                status: 'complete',
+                message: `Coverage analysis complete: ${summary.lines.percentage}% lines covered`,
+                progress: 100,
+            });
+            return {
+                success: true,
+                data: {
+                    summary,
+                    byFile,
+                    thresholdsPassed,
+                    riskScore,
+                    trends,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Coverage analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Returns demo coverage data when no real data is available.
+     * Only used when demoMode is explicitly requested or as fallback with warning.
+     */
+    getDemoResult(target, thresholds, includeRisk, context) {
+        const summary = {
+            lines: { covered: 850, total: 1000, percentage: 85.0 },
+            branches: { covered: 120, total: 150, percentage: 80.0 },
+            functions: { covered: 90, total: 100, percentage: 90.0 },
+            statements: { covered: 900, total: 1050, percentage: 85.71 },
+        };
+        const byFile = [
+            { file: `${target}/service.ts`, lines: 92, branches: 85, functions: 95, uncoveredLines: [45, 67, 89] },
+            { file: `${target}/utils.ts`, lines: 78, branches: 70, functions: 85, uncoveredLines: [12, 34, 56, 78, 90] },
+            { file: `${target}/handler.ts`, lines: 88, branches: 82, functions: 90, uncoveredLines: [23, 45] },
+        ];
+        const thresholdsPassed = summary.lines.percentage >= (thresholds.lines || 0) &&
+            summary.branches.percentage >= (thresholds.branches || 0) &&
+            summary.functions.percentage >= (thresholds.functions || 0) &&
+            summary.statements.percentage >= (thresholds.statements || 0);
+        this.emitStream(context, {
+            status: 'complete',
+            message: `Coverage analysis complete (sample data): ${summary.lines.percentage}% lines covered`,
+            progress: 100,
+        });
+        return {
+            success: true,
+            data: {
+                summary,
+                byFile,
+                thresholdsPassed,
+                riskScore: includeRisk ? 0.25 : undefined,
+                trends: {
+                    direction: 'improving',
+                    delta: 2.5,
+                    history: [
+                        { date: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0], coverage: 82.5 },
+                        { date: new Date().toISOString().split('T')[0], coverage: 85.0 },
+                    ],
+                },
+            },
+        };
+    }
+}
+// ============================================================================
+// Coverage Gaps Tool
+// ============================================================================
+export class CoverageGapsTool extends MCPToolBase {
+    config = {
+        name: 'qe/coverage/gaps',
+        description: 'Find coverage gaps using O(log n) HNSW vector search. Prioritizes by risk, complexity, or ML confidence using real coverage data.',
+        domain: 'coverage-analysis',
+        schema: COVERAGE_GAPS_SCHEMA,
+        streaming: true,
+        timeout: 120000,
+    };
+    gapService = null;
+    getService(context) {
+        if (!this.gapService) {
+            const memory = context.memory;
+            this.gapService = new GapDetectorService(memory || createMinimalMemoryBackend());
+        }
+        return this.gapService;
+    }
+    async execute(params, context) {
+        const { target = '.', coverageFile, minRisk = 0.3, limit = 20, prioritization = 'complexity', } = params;
+        try {
+            this.emitStream(context, {
+                status: 'detecting',
+                message: `Detecting coverage gaps in ${target} (O(log n) search)`,
+            });
+            if (this.isAborted(context)) {
+                return { success: false, error: 'Operation aborted' };
+            }
+            // Parse real coverage data
+            let parsedReport = null;
+            if (coverageFile) {
+                try {
+                    parsedReport = await parseCoverage(coverageFile, target);
+                }
+                catch (parseError) {
+                    return {
+                        success: false,
+                        error: `Failed to parse coverage file: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+                    };
+                }
+            }
+            else {
+                parsedReport = await findAndParseCoverage(target);
+            }
+            // Check if demo mode is EXPLICITLY requested (only for testing/docs)
+            if (this.isDemoMode(context)) {
+                this.markAsDemoData(context, 'Demo mode explicitly requested');
+                return this.getDemoGapsResult(target, minRisk, limit, context);
+            }
+            // If no coverage data found, return error with actionable guidance
+            if (!parsedReport || parsedReport.files.size === 0) {
+                return {
+                    success: false,
+                    error: `No coverage data found in '${target}'. Run your test suite with coverage enabled to generate coverage reports before detecting gaps.`,
+                };
+            }
+            // Mark as real data - we have actual coverage
+            this.markAsRealData();
+            // Convert to domain format
+            const domainFiles = convertParsedToDomainFormat(parsedReport);
+            // Use real gap detector service
+            const service = this.getService(context);
+            // Map prioritization to service strategy
+            const prioritizeStrategy = prioritization === 'change-frequency' ? 'recent-changes' : 'risk';
+            const gapResult = await service.detectGaps({
+                coverageData: { files: domainFiles, summary: calculateSummary(domainFiles) },
+                minCoverage: 80,
+                prioritize: prioritizeStrategy,
+            });
+            if (!gapResult.success) {
+                return {
+                    success: false,
+                    error: `Gap detection failed: ${gapResult.error?.message || 'Unknown error'}`,
+                };
+            }
+            const detectedGaps = gapResult.value;
+            // Filter by minimum risk and convert to output format
+            const gaps = detectedGaps.gaps
+                .filter((g) => g.riskScore >= minRisk)
+                .slice(0, limit)
+                .map((g) => ({
+                file: g.file,
+                lines: g.lines,
+                type: g.branches.length > 0 ? 'uncovered-branch' : 'uncovered-line',
+                severity: g.severity,
+                riskScore: Math.round(g.riskScore * 100) / 100,
+                reason: g.recommendation,
+            }));
+            // Generate test suggestions based on gaps
+            const suggestedTests = gaps.slice(0, 5).map((gap, idx) => ({
+                file: gap.file.replace(/\.ts$/, '.test.ts'),
+                description: `Add tests for ${gap.lines.length} uncovered lines in ${gap.file}`,
+                estimatedCoverageGain: Math.round((gap.lines.length / (detectedGaps.totalUncoveredLines || 1)) * 100 * 100) / 100,
+                priority: idx + 1,
+            }));
+            this.emitStream(context, {
+                status: 'complete',
+                message: `Found ${gaps.length} coverage gaps (${detectedGaps.totalUncoveredLines} uncovered lines)`,
+                progress: 100,
+            });
+            return {
+                success: true,
+                data: {
+                    gaps,
+                    totalGaps: detectedGaps.gaps.length,
+                    criticalGaps: gaps.filter((g) => g.severity === 'critical').length,
+                    suggestedTests,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Gap detection failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Returns demo gap data when no real coverage data is available.
+     * Only used when demoMode is explicitly requested or as fallback with warning.
+     */
+    getDemoGapsResult(target, minRisk, limit, context) {
+        const allGaps = [
+            {
+                file: `${target}/service.ts`,
+                lines: [45, 67, 89, 102, 115],
+                type: 'uncovered-line',
+                severity: 'high',
+                riskScore: 0.85,
+                reason: 'Core business logic with no test coverage',
+            },
+            {
+                file: `${target}/utils.ts`,
+                lines: [12, 34, 56],
+                type: 'uncovered-branch',
+                severity: 'medium',
+                riskScore: 0.65,
+                reason: 'Utility functions missing edge case tests',
+            },
+            {
+                file: `${target}/handler.ts`,
+                lines: [23, 45, 67, 89],
+                type: 'uncovered-function',
+                severity: 'critical',
+                riskScore: 0.92,
+                reason: 'Error handling paths untested',
+            },
+            {
+                file: `${target}/validator.ts`,
+                lines: [10, 20, 30],
+                type: 'uncovered-line',
+                severity: 'low',
+                riskScore: 0.35,
+                reason: 'Simple validation logic',
+            },
+        ];
+        // Filter by minimum risk score
+        const gaps = allGaps
+            .filter((g) => g.riskScore >= minRisk)
+            .slice(0, limit);
+        const suggestedTests = gaps.slice(0, 5).map((gap, idx) => ({
+            file: gap.file.replace(/\.ts$/, '.test.ts'),
+            description: `Add tests for ${gap.lines.length} uncovered lines in ${gap.file}`,
+            estimatedCoverageGain: Math.round((gap.lines.length / 50) * 100 * 100) / 100,
+            priority: idx + 1,
+        }));
+        this.emitStream(context, {
+            status: 'complete',
+            message: `Found ${gaps.length} coverage gaps (sample data)`,
+            progress: 100,
+        });
+        return {
+            success: true,
+            data: {
+                gaps,
+                totalGaps: gaps.length,
+                criticalGaps: gaps.filter((g) => g.severity === 'critical').length,
+                suggestedTests,
+            },
+        };
+    }
+}
+// ============================================================================
+// Schemas
+// ============================================================================
+const COVERAGE_ANALYZE_SCHEMA = {
+    type: 'object',
+    properties: {
+        target: {
+            type: 'string',
+            description: 'Target directory to analyze (searches for coverage files)',
+            default: '.',
+        },
+        coverageFile: {
+            type: 'string',
+            description: 'Path to coverage report file (lcov.info, coverage-final.json, etc.)',
+        },
+        thresholds: {
+            type: 'object',
+            description: 'Coverage thresholds',
+            properties: {
+                lines: { type: 'number', description: 'Line coverage threshold' },
+                branches: { type: 'number', description: 'Branch coverage threshold' },
+                functions: { type: 'number', description: 'Function coverage threshold' },
+                statements: { type: 'number', description: 'Statement coverage threshold' },
+            },
+        },
+        includeRisk: {
+            type: 'boolean',
+            description: 'Include risk score analysis',
+            default: false,
+        },
+        mlPowered: {
+            type: 'boolean',
+            description: 'Use ML-powered analysis (vector similarity)',
+            default: false,
+        },
+    },
+};
+const COVERAGE_GAPS_SCHEMA = {
+    type: 'object',
+    properties: {
+        target: {
+            type: 'string',
+            description: 'Target directory to analyze',
+            default: '.',
+        },
+        coverageFile: {
+            type: 'string',
+            description: 'Path to coverage report file',
+        },
+        minRisk: {
+            type: 'number',
+            description: 'Minimum risk score to include (0-1)',
+            minimum: 0,
+            maximum: 1,
+            default: 0.3,
+        },
+        limit: {
+            type: 'number',
+            description: 'Maximum number of gaps to return',
+            minimum: 1,
+            maximum: 100,
+            default: 20,
+        },
+        prioritization: {
+            type: 'string',
+            description: 'Gap prioritization strategy',
+            enum: ['complexity', 'criticality', 'change-frequency', 'ml-confidence'],
+            default: 'complexity',
+        },
+    },
+};
+//# sourceMappingURL=index.js.map