monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/commands/hooks-coverage-routing.js

@@ -1,399 +0,0 @@
-/**
- * Coverage-aware routing commands: coverage-route, coverage-suggest
- */
-import { output } from '../output.js';
-import { callMCPTool } from '../mcp-client.js';
-import { readCoverageFromDisk, classifyCoverageGap, suggestAgentsForFile, } from './hooks-coverage-utils.js';
-export const coverageRouteCommand = {
-    name: 'coverage-route',
-    description: 'Route task to agents based on test coverage gaps (monovector integration)',
-    options: [
-        {
-            name: 'task',
-            short: 't',
-            description: 'Task description to route',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'threshold',
-            description: 'Coverage threshold percentage (default: 80)',
-            type: 'number',
-            default: 80
-        },
-        {
-            name: 'no-monovector',
-            description: 'Disable monovector integration',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks coverage-route -t "fix bug in auth"', description: 'Route with coverage awareness' },
-        { command: 'monomind hooks coverage-route -t "add tests" --threshold 90', description: 'Route with custom threshold' }
-    ],
-    action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
-        const threshold = ctx.flags.threshold || 80;
-        const useMonovector = !ctx.flags['no-monovector'];
-        if (!task) {
-            output.printError('Task description is required. Use --task or -t flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Analyzing coverage and routing task...' });
-        spinner.start();
-        const diskCoverage = readCoverageFromDisk();
-        if (diskCoverage.found) {
-            spinner.succeed(`Coverage data loaded from ${diskCoverage.source}`);
-            const taskLower = task.toLowerCase();
-            const taskWords = taskLower.split(/\s+/).filter(w => w.length > 2);
-            const scoredFiles = diskCoverage.entries
-                .filter(e => e.lines < threshold)
-                .map(e => {
-                const fileNameLower = e.filePath.toLowerCase();
-                let relevance = 0;
-                for (const word of taskWords) {
-                    if (fileNameLower.includes(word))
-                        relevance += 2;
-                }
-                const coveragePenalty = e.lines / 100;
-                return { ...e, relevance, score: relevance + (1 - coveragePenalty) };
-            })
-                .sort((a, b) => b.score - a.score);
-            const gaps = scoredFiles.slice(0, 8).map(e => {
-                const { gapType, priority } = classifyCoverageGap(e.lines, threshold);
-                return {
-                    filePath: e.filePath,
-                    coveragePercent: e.lines,
-                    gapType,
-                    priority,
-                    suggestedAgents: suggestAgentsForFile(e.filePath),
-                    reason: `${e.lines.toFixed(1)}% coverage, below ${threshold}%`,
-                };
-            });
-            const criticalGaps = gaps.filter(g => g.gapType === 'critical').length;
-            const primaryAgent = taskLower.includes('test') ? 'tester' :
-                taskLower.includes('security') || taskLower.includes('auth') ? 'security-auditor' :
-                    taskLower.includes('fix') || taskLower.includes('bug') ? 'coder' : 'tester';
-            const suggestions = [];
-            if (criticalGaps > 0)
-                suggestions.push(`${criticalGaps} critical coverage gaps need immediate attention`);
-            if (diskCoverage.summary.overallLineCoverage < threshold) {
-                suggestions.push(`Overall line coverage (${diskCoverage.summary.overallLineCoverage.toFixed(1)}%) is below ${threshold}% threshold`);
-            }
-            if (scoredFiles.length > 8)
-                suggestions.push(`${scoredFiles.length - 8} additional files with low coverage`);
-            const result = {
-                success: true,
-                task,
-                coverageAware: true,
-                gaps,
-                routing: {
-                    primaryAgent,
-                    confidence: gaps.length > 0 ? 0.85 : 0.6,
-                    reason: gaps.length > 0
-                        ? `Routing to ${primaryAgent} based on ${gaps.length} coverage gaps related to task`
-                        : `No coverage gaps found related to task, routing to ${primaryAgent}`,
-                    coverageImpact: gaps.length > 0 ? 'high' : 'low',
-                },
-                suggestions,
-                metrics: {
-                    filesAnalyzed: diskCoverage.summary.totalFiles,
-                    totalGaps: scoredFiles.length,
-                    criticalGaps,
-                    avgCoverage: diskCoverage.summary.overallLineCoverage,
-                },
-                source: diskCoverage.source,
-            };
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Agent: ${output.highlight(result.routing.primaryAgent)}`,
-                `Confidence: ${(result.routing.confidence * 100).toFixed(1)}%`,
-                `Coverage-Aware: ${output.success('Yes')} (from ${diskCoverage.source})`,
-                `Reason: ${result.routing.reason}`
-            ].join('\n'), 'Coverage-Aware Routing');
-            if (gaps.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Coverage Gaps'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 35, format: (v) => {
-                                const s = String(v);
-                                return s.length > 32 ? '...' + s.slice(-32) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Type', width: 10 },
-                        { key: 'suggestedAgents', header: 'Agent', width: 15, format: (v) => Array.isArray(v) ? v[0] || '' : String(v) }
-                    ],
-                    data: gaps.slice(0, 8)
-                });
-            }
-            if (result.metrics.filesAnalyzed > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Metrics'));
-                output.printList([
-                    `Files Analyzed: ${result.metrics.filesAnalyzed}`,
-                    `Total Gaps: ${result.metrics.totalGaps}`,
-                    `Critical Gaps: ${result.metrics.criticalGaps}`,
-                    `Average Coverage: ${result.metrics.avgCoverage.toFixed(1)}%`
-                ]);
-            }
-            if (suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Suggestions'));
-                output.printList(suggestions.map(s => output.dim(s)));
-            }
-            return { success: true, data: result };
-        }
-        try {
-            const result = await callMCPTool('coverage_route', { task, threshold, useMonovector });
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Agent: ${output.highlight(result.routing.primaryAgent)}`,
-                `Confidence: ${(result.routing.confidence * 100).toFixed(1)}%`,
-                `Coverage-Aware: ${result.coverageAware ? output.success('Yes') : output.dim('No coverage data')}`,
-                `Reason: ${result.routing.reason}`
-            ].join('\n'), 'Coverage-Aware Routing');
-            if (result.gaps.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Coverage Gaps'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 35, format: (v) => {
-                                const s = String(v);
-                                return s.length > 32 ? '...' + s.slice(-32) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Type', width: 10 },
-                        { key: 'suggestedAgents', header: 'Agent', width: 15, format: (v) => Array.isArray(v) ? v[0] || '' : String(v) }
-                    ],
-                    data: result.gaps.slice(0, 8)
-                });
-            }
-            if (result.metrics.filesAnalyzed > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Metrics'));
-                output.printList([
-                    `Files Analyzed: ${result.metrics.filesAnalyzed}`,
-                    `Total Gaps: ${result.metrics.totalGaps}`,
-                    `Critical Gaps: ${result.metrics.criticalGaps}`,
-                    `Average Coverage: ${result.metrics.avgCoverage.toFixed(1)}%`
-                ]);
-            }
-            if (result.suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Suggestions'));
-                output.printList(result.suggestions.map(s => output.dim(s)));
-            }
-            return { success: true, data: result };
-        }
-        catch {
-            spinner.fail('No coverage data found');
-            output.writeln();
-            output.printWarning('No coverage data found. Run your test suite with coverage first.');
-            output.writeln();
-            output.printList([
-                'Jest:     npx jest --coverage',
-                'Vitest:   npx vitest --coverage',
-                'nyc:      npx nyc npm test',
-                'c8:       npx c8 npm test',
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-export const coverageSuggestCommand = {
-    name: 'coverage-suggest',
-    description: 'Suggest coverage improvements for a path (monovector integration)',
-    options: [
-        {
-            name: 'path',
-            short: 'p',
-            description: 'Path to analyze for coverage suggestions',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'threshold',
-            description: 'Coverage threshold percentage (default: 80)',
-            type: 'number',
-            default: 80
-        },
-        {
-            name: 'limit',
-            short: 'l',
-            description: 'Maximum number of suggestions (default: 20)',
-            type: 'number',
-            default: 20
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks coverage-suggest -p src/', description: 'Suggest improvements for src/' },
-        { command: 'monomind hooks coverage-suggest -p src/services --threshold 90', description: 'Stricter threshold' }
-    ],
-    action: async (ctx) => {
-        const targetPath = ctx.args[0] || ctx.flags.path;
-        const threshold = ctx.flags.threshold || 80;
-        const limit = ctx.flags.limit || 20;
-        if (!targetPath) {
-            output.printError('Path is required. Use --path or -p flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: `Analyzing coverage for ${targetPath}...` });
-        spinner.start();
-        const diskCoverage = readCoverageFromDisk();
-        if (diskCoverage.found) {
-            spinner.succeed(`Coverage data loaded from ${diskCoverage.source}`);
-            const pathLower = targetPath.toLowerCase().replace(/\\/g, '/');
-            const matchingEntries = diskCoverage.entries.filter(e => {
-                const fileLower = e.filePath.toLowerCase().replace(/\\/g, '/');
-                return fileLower.includes(pathLower);
-            });
-            const belowThreshold = matchingEntries.filter(e => e.lines < threshold);
-            const suggestions = belowThreshold.slice(0, limit).map(e => {
-                const { gapType, priority } = classifyCoverageGap(e.lines, threshold);
-                return {
-                    filePath: e.filePath,
-                    coveragePercent: e.lines,
-                    gapType,
-                    priority,
-                    suggestedAgents: suggestAgentsForFile(e.filePath),
-                    reason: e.lines === 0 ? 'No coverage at all' :
-                        e.lines < 20 ? 'Very low coverage, needs tests' :
-                            e.lines < 50 ? 'Below 50%, add more tests' :
-                                `Below ${threshold}% threshold`,
-                };
-            });
-            const totalLinesCov = matchingEntries.length > 0
-                ? matchingEntries.reduce((acc, e) => acc + e.lines, 0) / matchingEntries.length
-                : 0;
-            const totalBranchesCov = matchingEntries.length > 0
-                ? matchingEntries.reduce((acc, e) => acc + e.branches, 0) / matchingEntries.length
-                : 0;
-            const prioritizedFiles = belowThreshold.slice(0, 5).map(e => e.filePath);
-            const result = {
-                success: true,
-                path: targetPath,
-                suggestions,
-                summary: {
-                    totalFiles: matchingEntries.length,
-                    overallLineCoverage: totalLinesCov,
-                    overallBranchCoverage: totalBranchesCov,
-                    filesBelowThreshold: belowThreshold.length,
-                },
-                prioritizedFiles,
-                monovectorAvailable: false,
-                source: diskCoverage.source,
-            };
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Path: ${output.highlight(targetPath)}`,
-                `Files Analyzed: ${result.summary.totalFiles}`,
-                `Line Coverage: ${result.summary.overallLineCoverage.toFixed(1)}%`,
-                `Branch Coverage: ${result.summary.overallBranchCoverage.toFixed(1)}%`,
-                `Below Threshold: ${result.summary.filesBelowThreshold} files`,
-                `Source: ${output.highlight(diskCoverage.source)}`
-            ].join('\n'), 'Coverage Summary');
-            if (suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Improvement Suggestions'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 40, format: (v) => {
-                                const s = String(v);
-                                return s.length > 37 ? '...' + s.slice(-37) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Priority', width: 10 },
-                        { key: 'reason', header: 'Reason', width: 25 }
-                    ],
-                    data: suggestions.slice(0, 15)
-                });
-            }
-            else {
-                output.writeln();
-                output.printSuccess('All files meet coverage threshold!');
-            }
-            if (prioritizedFiles.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Files (Top 5)'));
-                output.printList(prioritizedFiles.slice(0, 5).map(f => output.highlight(f)));
-            }
-            return { success: true, data: result };
-        }
-        try {
-            const result = await callMCPTool('coverage_suggest', { path: targetPath, threshold, limit });
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Path: ${output.highlight(result.path)}`,
-                `Files Analyzed: ${result.summary.totalFiles}`,
-                `Line Coverage: ${result.summary.overallLineCoverage.toFixed(1)}%`,
-                `Branch Coverage: ${result.summary.overallBranchCoverage.toFixed(1)}%`,
-                `Below Threshold: ${result.summary.filesBelowThreshold} files`,
-                `Keyword routing: ${result.monovectorAvailable ? output.success('Available') : output.dim('Unavailable')}`
-            ].join('\n'), 'Coverage Summary');
-            if (result.suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Improvement Suggestions'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 40, format: (v) => {
-                                const s = String(v);
-                                return s.length > 37 ? '...' + s.slice(-37) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Priority', width: 10 },
-                        { key: 'reason', header: 'Reason', width: 25 }
-                    ],
-                    data: result.suggestions.slice(0, 15)
-                });
-            }
-            else {
-                output.writeln();
-                output.printSuccess('All files meet coverage threshold!');
-            }
-            if (result.prioritizedFiles.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Files (Top 5)'));
-                output.printList(result.prioritizedFiles.slice(0, 5).map(f => output.highlight(f)));
-            }
-            return { success: true, data: result };
-        }
-        catch {
-            spinner.fail('No coverage data found');
-            output.writeln();
-            output.printWarning('No coverage data found. Run your test suite with coverage first.');
-            output.writeln();
-            output.printList([
-                'Jest:     npx jest --coverage',
-                'Vitest:   npx vitest --coverage',
-                'nyc:      npx nyc npm test',
-                'c8:       npx c8 npm test',
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-//# sourceMappingURL=hooks-coverage-routing.js.map

package/packages/@monomind/cli/dist/src/commands/hooks-coverage-utils.d.ts

@@ -1,42 +0,0 @@
-/**
- * Coverage utilities for hooks commands.
- * Extracted from hooks.ts (ARCH-1) — reads Jest/Istanbul/lcov coverage files from disk.
- */
-export interface CoverageFileEntry {
-    filePath: string;
-    lines: number;
-    branches: number;
-    functions: number;
-    statements: number;
-}
-export interface CoverageData {
-    found: boolean;
-    source: string;
-    entries: CoverageFileEntry[];
-    summary: {
-        totalFiles: number;
-        overallLineCoverage: number;
-        overallBranchCoverage: number;
-        overallFunctionCoverage: number;
-        overallStatementCoverage: number;
-    };
-}
-/**
- * Read coverage data from disk. Checks these locations in order:
- * 1. coverage/coverage-summary.json (Jest/Istanbul)
- * 2. coverage/lcov.info (lcov format)
- * 3. .nyc_output/out.json (nyc)
- */
-export declare function readCoverageFromDisk(): CoverageData;
-/**
- * Classify a coverage gap by priority type based on coverage percentage and threshold
- */
-export declare function classifyCoverageGap(coveragePct: number, threshold: number): {
-    gapType: string;
-    priority: number;
-};
-/**
- * Suggest agents for a file based on its path
- */
-export declare function suggestAgentsForFile(filePath: string): string[];
-//# sourceMappingURL=hooks-coverage-utils.d.ts.map

package/packages/@monomind/cli/dist/src/commands/hooks-coverage-utils.js

@@ -1,220 +0,0 @@
-/**
- * Coverage utilities for hooks commands.
- * Extracted from hooks.ts (ARCH-1) — reads Jest/Istanbul/lcov coverage files from disk.
- */
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * Read coverage data from disk. Checks these locations in order:
- * 1. coverage/coverage-summary.json (Jest/Istanbul)
- * 2. coverage/lcov.info (lcov format)
- * 3. .nyc_output/out.json (nyc)
- */
-export function readCoverageFromDisk() {
-    const cwd = process.cwd();
-    const noData = {
-        found: false,
-        source: 'none',
-        entries: [],
-        summary: { totalFiles: 0, overallLineCoverage: 0, overallBranchCoverage: 0, overallFunctionCoverage: 0, overallStatementCoverage: 0 },
-    };
-    // 1. Try coverage-summary.json (Jest/Istanbul)
-    for (const relPath of ['coverage/coverage-summary.json', 'coverage-summary.json']) {
-        const summaryPath = join(cwd, relPath);
-        if (existsSync(summaryPath)) {
-            try {
-                if (statSync(summaryPath).size <= 4_194_304) {
-                    const raw = JSON.parse(readFileSync(summaryPath, 'utf-8'));
-                    return parseCoverageSummaryJson(raw, relPath);
-                }
-            }
-            catch {
-                // malformed, try next
-            }
-        }
-    }
-    // 2. Try lcov.info
-    for (const relPath of ['coverage/lcov.info', 'lcov.info']) {
-        const lcovPath = join(cwd, relPath);
-        if (existsSync(lcovPath)) {
-            try {
-                if (statSync(lcovPath).size <= 8_388_608) {
-                    const raw = readFileSync(lcovPath, 'utf-8');
-                    return parseLcovInfo(raw, relPath);
-                }
-            }
-            catch {
-                // malformed, try next
-            }
-        }
-    }
-    // 3. Try .nyc_output/out.json
-    const nycPath = join(cwd, '.nyc_output', 'out.json');
-    if (existsSync(nycPath)) {
-        try {
-            if (statSync(nycPath).size <= 4_194_304) {
-                const raw = JSON.parse(readFileSync(nycPath, 'utf-8'));
-                return parseCoverageSummaryJson(raw, '.nyc_output/out.json');
-            }
-        }
-        catch {
-            // malformed
-        }
-    }
-    return noData;
-}
-function parseCoverageSummaryJson(data, source) {
-    const entries = [];
-    let totalLines = 0, coveredLines = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalStatements = 0, coveredStatements = 0;
-    for (const [filePath, metrics] of Object.entries(data)) {
-        if (filePath === 'total')
-            continue;
-        const m = metrics;
-        if (!m || typeof m !== 'object')
-            continue;
-        const linePct = m.lines?.pct ?? (m.lines?.covered != null ? ((m.lines?.covered ?? 0) / Math.max(m.lines?.total ?? 1, 1)) * 100 : 0);
-        const branchPct = m.branches?.pct ?? (m.branches?.total ? ((m.branches?.covered ?? 0) / m.branches.total) * 100 : 100);
-        const funcPct = m.functions?.pct ?? (m.functions?.total ? ((m.functions?.covered ?? 0) / m.functions.total) * 100 : 100);
-        const stmtPct = m.statements?.pct ?? (m.statements?.total ? ((m.statements?.covered ?? 0) / m.statements.total) * 100 : 100);
-        entries.push({ filePath, lines: linePct, branches: branchPct, functions: funcPct, statements: stmtPct });
-        totalLines += m.lines?.total ?? 0;
-        coveredLines += m.lines?.covered ?? 0;
-        totalBranches += m.branches?.total ?? 0;
-        coveredBranches += m.branches?.covered ?? 0;
-        totalFunctions += m.functions?.total ?? 0;
-        coveredFunctions += m.functions?.covered ?? 0;
-        totalStatements += m.statements?.total ?? 0;
-        coveredStatements += m.statements?.covered ?? 0;
-    }
-    // Also read the total key if present
-    const total = data['total'];
-    const overallLine = total?.lines?.pct ?? (totalLines > 0 ? (coveredLines / totalLines) * 100 : 0);
-    const overallBranch = total?.branches?.pct ?? (totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0);
-    const overallFunction = total?.functions?.pct ?? (totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0);
-    const overallStatement = total?.statements?.pct ?? (totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0);
-    // Sort by lowest line coverage
-    entries.sort((a, b) => a.lines - b.lines);
-    return {
-        found: true,
-        source,
-        entries,
-        summary: {
-            totalFiles: entries.length,
-            overallLineCoverage: overallLine,
-            overallBranchCoverage: overallBranch,
-            overallFunctionCoverage: overallFunction,
-            overallStatementCoverage: overallStatement,
-        },
-    };
-}
-function parseLcovInfo(raw, source) {
-    const entries = [];
-    let currentFile = '';
-    let linesHit = 0, linesFound = 0;
-    let branchesHit = 0, branchesFound = 0;
-    let functionsHit = 0, functionsFound = 0;
-    let totalLines = 0, coveredLines = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalStatements = 0, coveredStatements = 0;
-    const flushRecord = () => {
-        if (currentFile) {
-            entries.push({
-                filePath: currentFile,
-                lines: linesFound > 0 ? (linesHit / linesFound) * 100 : 0,
-                branches: branchesFound > 0 ? (branchesHit / branchesFound) * 100 : 100,
-                functions: functionsFound > 0 ? (functionsHit / functionsFound) * 100 : 100,
-                statements: linesFound > 0 ? (linesHit / linesFound) * 100 : 0,
-            });
-            totalLines += linesFound;
-            coveredLines += linesHit;
-            totalBranches += branchesFound;
-            coveredBranches += branchesHit;
-            totalFunctions += functionsFound;
-            coveredFunctions += functionsHit;
-            totalStatements += linesFound;
-            coveredStatements += linesHit;
-        }
-    };
-    for (const line of raw.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('SF:')) {
-            currentFile = trimmed.slice(3);
-            linesHit = 0;
-            linesFound = 0;
-            branchesHit = 0;
-            branchesFound = 0;
-            functionsHit = 0;
-            functionsFound = 0;
-        }
-        else if (trimmed.startsWith('LH:')) {
-            linesHit = parseInt(trimmed.slice(3), 10) || 0;
-        }
-        else if (trimmed.startsWith('LF:')) {
-            linesFound = parseInt(trimmed.slice(3), 10) || 0;
-        }
-        else if (trimmed.startsWith('BRH:')) {
-            branchesHit = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('BRF:')) {
-            branchesFound = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('FNH:')) {
-            functionsHit = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('FNF:')) {
-            functionsFound = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed === 'end_of_record') {
-            flushRecord();
-            currentFile = '';
-        }
-    }
-    flushRecord();
-    entries.sort((a, b) => a.lines - b.lines);
-    return {
-        found: true,
-        source,
-        entries,
-        summary: {
-            totalFiles: entries.length,
-            overallLineCoverage: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
-            overallBranchCoverage: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 100,
-            overallFunctionCoverage: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
-            overallStatementCoverage: totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0,
-        },
-    };
-}
-/**
- * Classify a coverage gap by priority type based on coverage percentage and threshold
- */
-export function classifyCoverageGap(coveragePct, threshold) {
-    if (coveragePct < threshold * 0.25)
-        return { gapType: 'critical', priority: 10 };
-    if (coveragePct < threshold * 0.5)
-        return { gapType: 'high', priority: 7 };
-    if (coveragePct < threshold * 0.75)
-        return { gapType: 'medium', priority: 5 };
-    if (coveragePct < threshold)
-        return { gapType: 'low', priority: 3 };
-    return { gapType: 'ok', priority: 0 };
-}
-/**
- * Suggest agents for a file based on its path
- */
-export function suggestAgentsForFile(filePath) {
-    const lower = filePath.toLowerCase();
-    if (lower.includes('test') || lower.includes('spec'))
-        return ['tester'];
-    if (lower.includes('security') || lower.includes('auth'))
-        return ['security-auditor', 'tester'];
-    if (lower.includes('api') || lower.includes('route') || lower.includes('controller'))
-        return ['coder', 'tester'];
-    if (lower.includes('model') || lower.includes('schema') || lower.includes('entity'))
-        return ['coder', 'tester'];
-    return ['tester', 'coder'];
-}
-//# sourceMappingURL=hooks-coverage-utils.js.map

package/packages/@monomind/cli/dist/src/commands/hooks-extended-commands.d.ts

@@ -1,11 +0,0 @@
-/**
- * Hooks Extended Commands
- * Token optimization, model routing, Agent Teams integration, and notify commands.
- * Extracted from hooks.ts to reduce file size.
- */
-import type { Command } from '../types.js';
-export declare const modelRouteCommand: Command;
-export declare const modelOutcomeCommand: Command;
-export declare const modelStatsCommand: Command;
-export declare const notifyCommand: Command;
-//# sourceMappingURL=hooks-extended-commands.d.ts.map