@claude-flow/cli 3.56.7 → 3.56.9

package/dist/src/commands/coverage-reader.js

@@ -0,0 +1,247 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+/** Coverage reports are build output the project controls: refuse anything large enough to stall or exhaust the process. */
+const MAX_REPORT_BYTES = 64 * 1024 * 1024;
+/** The file's text, or undefined when it is missing, not a regular file, unreadable, or over the size cap. */
+function readReport(path) {
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile() || stat.size > MAX_REPORT_BYTES)
+            return undefined;
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Read coverage data from disk. Checks these locations in order:
+ * 1. coverage/coverage-summary.json (Jest/Istanbul)
+ * 2. coverage/lcov.info (lcov format)
+ * 3. coverage/coverage-final.json (Istanbul counters)
+ * 4. .nyc_output/out.json (nyc counters or legacy summary)
+ */
+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 text = readReport(join(cwd, relPath));
+        if (text !== undefined) {
+            try {
+                const raw = JSON.parse(text);
+                const report = parseCoverageSummaryJson(raw, relPath);
+                if (report.found)
+                    return report;
+            }
+            catch {
+                // malformed, try next
+            }
+        }
+    }
+    // 2. Try lcov.info
+    for (const relPath of ['coverage/lcov.info', 'lcov.info']) {
+        const raw = readReport(join(cwd, relPath));
+        if (raw !== undefined) {
+            try {
+                const report = parseLcovInfo(raw, relPath);
+                if (report.found)
+                    return report;
+            }
+            catch {
+                // malformed, try next
+            }
+        }
+    }
+    // Istanbul's raw counter map (Jest, Vitest, nyc).
+    for (const relPath of ['coverage/coverage-final.json', 'coverage-final.json', '.nyc_output/out.json']) {
+        const text = readReport(join(cwd, relPath));
+        if (text === undefined)
+            continue;
+        try {
+            const raw = JSON.parse(text);
+            const report = parseIstanbulCoverage(raw, relPath);
+            if (report.found)
+                return report;
+            const legacy = parseCoverageSummaryJson(raw, relPath);
+            if (legacy.found)
+                return legacy;
+        }
+        catch {
+            // Missing or malformed, try the next supported report.
+        }
+    }
+    return noData;
+}
+function parseCoverageSummaryJson(data, source) {
+    const entries = [];
+    const metricsByFile = [];
+    for (const [filePath, metrics] of Object.entries(data)) {
+        if (filePath === 'total')
+            continue;
+        const m = metrics;
+        if (!m || typeof m !== 'object')
+            continue;
+        if (!['lines', 'branches', 'functions', 'statements'].some(key => m[key]))
+            continue;
+        metricsByFile.push(m);
+        const linePct = percentage(m.lines) ?? 0;
+        const branchPct = (percentage(m.branches) ?? 0);
+        const funcPct = (percentage(m.functions) ?? 0);
+        const stmtPct = (percentage(m.statements) ?? 0);
+        entries.push({ filePath, lines: linePct, branches: branchPct, functions: funcPct, statements: stmtPct });
+    }
+    // Only aggregate complete counts. A missing denominator is unknown, not empty.
+    const total = data['total'];
+    const aggregate = (key) => {
+        const supplied = percentage(total?.[key]);
+        if (supplied !== undefined)
+            return supplied;
+        const metrics = metricsByFile.map(file => file[key]);
+        if (metrics.length === 0 || !metrics.every(hasCounts))
+            return 0;
+        return ratio(metrics.reduce((sum, m) => sum + m.covered, 0), metrics.reduce((sum, m) => sum + m.total, 0));
+    };
+    // Sort by lowest line coverage
+    entries.sort((a, b) => a.lines - b.lines);
+    return {
+        found: entries.length > 0,
+        source,
+        entries,
+        summary: {
+            totalFiles: entries.length,
+            overallLineCoverage: aggregate('lines'),
+            overallBranchCoverage: aggregate('branches'),
+            overallFunctionCoverage: aggregate('functions'),
+            overallStatementCoverage: aggregate('statements'),
+        },
+    };
+}
+function parseLcovInfo(raw, source) {
+    const entries = [];
+    let currentFile = '';
+    let linesHit = 0, linesFound = 0;
+    let branchesHit = 0, branchesFound = 0;
+    let functionsHit = 0, functionsFound = 0;
+    let totalLH = 0, totalLF = 0, totalBH = 0, totalBF = 0, totalFH = 0, totalFF = 0;
+    const flushRecord = () => {
+        if (currentFile) {
+            // A corrupt record cannot report more hits than lines, or a negative count.
+            linesHit = Math.min(linesHit, linesFound);
+            branchesHit = Math.min(branchesHit, branchesFound);
+            functionsHit = Math.min(functionsHit, functionsFound);
+            totalLH += linesHit;
+            totalLF += linesFound;
+            totalBH += branchesHit;
+            totalBF += branchesFound;
+            totalFH += functionsHit;
+            totalFF += functionsFound;
+            entries.push({
+                filePath: currentFile,
+                lines: linesFound > 0 ? (linesHit / linesFound) * 100 : 100,
+                branches: branchesFound > 0 ? (branchesHit / branchesFound) * 100 : 100,
+                functions: functionsFound > 0 ? (functionsHit / functionsFound) * 100 : 100,
+                statements: linesFound > 0 ? (linesHit / linesFound) * 100 : 100,
+            });
+        }
+    };
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('SF:')) {
+            flushRecord();
+            currentFile = trimmed.slice(3);
+            linesHit = 0;
+            linesFound = 0;
+            branchesHit = 0;
+            branchesFound = 0;
+            functionsHit = 0;
+            functionsFound = 0;
+        }
+        else if (trimmed.startsWith('LH:')) {
+            linesHit = count(trimmed.slice(3));
+        }
+        else if (trimmed.startsWith('LF:')) {
+            linesFound = count(trimmed.slice(3));
+        }
+        else if (trimmed.startsWith('BRH:')) {
+            branchesHit = count(trimmed.slice(4));
+        }
+        else if (trimmed.startsWith('BRF:')) {
+            branchesFound = count(trimmed.slice(4));
+        }
+        else if (trimmed.startsWith('FNH:')) {
+            functionsHit = count(trimmed.slice(4));
+        }
+        else if (trimmed.startsWith('FNF:')) {
+            functionsFound = count(trimmed.slice(4));
+        }
+        else if (trimmed === 'end_of_record') {
+            flushRecord();
+            currentFile = '';
+        }
+    }
+    flushRecord();
+    entries.sort((a, b) => a.lines - b.lines);
+    return {
+        found: entries.length > 0,
+        source,
+        entries,
+        summary: {
+            totalFiles: entries.length,
+            overallLineCoverage: ratio(totalLH, totalLF),
+            overallBranchCoverage: ratio(totalBH, totalBF),
+            overallFunctionCoverage: ratio(totalFH, totalFF),
+            overallStatementCoverage: ratio(totalLH, totalLF),
+        },
+    };
+}
+/** A non-negative integer count; anything else in a report line is treated as 0. */
+function count(text) {
+    const n = parseInt(text, 10);
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}
+function ratio(covered, total) {
+    return total > 0 ? covered / total * 100 : 100;
+}
+function hasCounts(metric) {
+    return typeof metric?.total === 'number' && Number.isFinite(metric.total) && metric.total >= 0
+        && typeof metric.covered === 'number' && Number.isFinite(metric.covered)
+        && metric.covered >= 0 && metric.covered <= metric.total;
+}
+function percentage(metric) {
+    if (typeof metric?.pct === 'number' && Number.isFinite(metric.pct)
+        && metric.pct >= 0 && metric.pct <= 100)
+        return metric.pct;
+    return hasCounts(metric) ? ratio(metric.covered, metric.total) : undefined;
+}
+/** Istanbul line coverage uses the maximum statement hit count on each start line. */
+function parseIstanbulCoverage(data, source) {
+    const summary = {};
+    for (const [filePath, value] of Object.entries(data)) {
+        const cov = value;
+        if (!cov || !cov.s || !cov.f || !cov.b || !cov.statementMap)
+            continue;
+        const lines = new Map();
+        for (const [id, hits] of Object.entries(cov.s)) {
+            const line = cov.statementMap[id]?.start?.line;
+            if (!Number.isInteger(line) || line < 1)
+                throw new Error('Invalid Istanbul statement location');
+            lines.set(line, Math.max(lines.get(line) ?? 0, hits));
+        }
+        const metric = (hits) => {
+            if (hits.some(n => !Number.isFinite(n) || n < 0))
+                throw new Error('Invalid Istanbul counter');
+            const covered = hits.filter(n => n > 0).length;
+            return { total: hits.length, covered, pct: ratio(covered, hits.length) };
+        };
+        summary[filePath] = { lines: metric([...lines.values()]), statements: metric(Object.values(cov.s)),
+            functions: metric(Object.values(cov.f)), branches: metric(Object.values(cov.b).flat()) };
+    }
+    return parseCoverageSummaryJson(summary, source);
+}
+//# sourceMappingURL=coverage-reader.js.map

package/dist/src/commands/hooks.js

@@ -1,10 +1,14 @@
+/**
+ * V3 CLI Hooks Command
+ * Self-learning hooks system for intelligent workflow automation
+ */
 import { validateFeedbackPatterns } from '../memory/feedback-patterns.js';
+import { readCoverageFromDisk } from './coverage-reader.js';
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { storeCommand } from './transfer-store.js';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
 import { getSecurityStatus as sharedGetSecurityStatus, getSwarmStatus as sharedGetSwarmStatus, getGitUncommittedCount as sharedGetGitUncommittedCount, } from '../funnel/local-signals.js';
 /**
  * #1686 — `?? 0` only defaults null/undefined; NaN slips through and
@@ -16,181 +20,6 @@ function safeNum(value, fallback = 0) {
     const n = typeof value === 'number' ? value : Number(value);
     return Number.isFinite(n) ? n : fallback;
 }
-/**
- * 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)
- */
-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 {
-                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 {
-                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 {
-            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;
-    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,
-            });
-        }
-    };
-    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);
-    let totalLH = 0, totalLF = 0, totalBH = 0, totalBF = 0;
-    for (const e of entries) {
-        // Approximate from percentages (we lost exact counts after flush, but summaries are okay)
-        totalLH += e.lines;
-        totalLF += 100;
-        totalBH += e.branches;
-        totalBF += 100;
-    }
-    const n = entries.length || 1;
-    return {
-        found: true,
-        source,
-        entries,
-        summary: {
-            totalFiles: entries.length,
-            overallLineCoverage: totalLH / n,
-            overallBranchCoverage: totalBH / n,
-            overallFunctionCoverage: 0,
-            overallStatementCoverage: totalLH / n,
-        },
-    };
-}
 /**
  * Classify a coverage gap by priority type based on coverage percentage and threshold
  */
@@ -2996,7 +2825,7 @@ const coverageRouteCommand = {
                 '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'));
+            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, coverage/coverage-final.json, or .nyc_output/out.json'));
             return { success: false, exitCode: 1 };
         }
     }
@@ -3187,7 +3016,7 @@ const coverageSuggestCommand = {
                 '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'));
+            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, coverage/coverage-final.json, or .nyc_output/out.json'));
             return { success: false, exitCode: 1 };
         }
     }
@@ -3407,7 +3236,7 @@ const coverageGapsCommand = {
                 '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'));
+            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, coverage/coverage-final.json, or .nyc_output/out.json'));
             return { success: false, exitCode: 1 };
         }
     }

package/dist/src/commands/tui.js

@@ -9,7 +9,7 @@
  * a one-line hint and exit 2, unless --plain asks for one frame as plain text and exit 0 (ADR-489 decision E).
  *
  *   npx ruflo tui                 # interactive, in a terminal
- *   npx ruflo tui --view swarm    # start on the Swarm page (keys 1-5 or o c s e m switch pages)
+ *   npx ruflo tui --view swarm    # start on the Swarm page (keys 1-6 or o c s e m a switch pages)
  *   npx ruflo tui --plain | head  # one plain frame, exit 0 (scripts, CI)
  *   npx ruflo tui | cat           # not a terminal and no --plain: a hint on stderr, exit 2
  */
@@ -55,7 +55,7 @@ export const tuiCommand = {
     ],
     examples: [
         { command: 'npx ruflo tui', description: 'Open the console in this terminal' },
-        { command: 'npx ruflo tui --view swarm', description: 'Start on the Swarm page (keys 1-5 switch pages, tab cycles, q quits)' },
+        { command: 'npx ruflo tui --view swarm', description: 'Start on the Swarm page (keys 1-6 switch pages, tab cycles, q quits)' },
         { command: 'npx ruflo tui --view ai --model openai/gpt-4o-mini --max-spend-usd 0.1', description: 'The AI page on a cheap OpenRouter model, stopping at $0.10 reported (key in $OPENROUTER_API_KEY, never shown)' },
         { command: 'npx ruflo tui --plain | head -40', description: 'One plain frame, exit 0: for scripts and CI (no terminal needed)' },
     ],