@mutineerjs/mutineer 0.9.0 → 0.11.0

package/dist/utils/__tests__/summary.spec.js

@@ -123,6 +123,42 @@ describe('summary', () => {
         expect(lines.some((l) => l.includes('foo.spec.ts'))).toBe(true);
         logSpy.mockRestore();
     });
+    it('handles printSummary with no cache argument when total > 0', () => {
+        const summary = {
+            total: 1,
+            killed: 1,
+            escaped: 0,
+            skipped: 0,
+            timeouts: 0,
+            compileErrors: 0,
+            evaluated: 1,
+            killRate: 100,
+        };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        // No cache passed: allEntries=[], maxPathLen=25 (|| 25), maxMutatorLen=10 (|| 10)
+        printSummary(summary);
+        expect(logSpy).toHaveBeenCalled();
+        logSpy.mockRestore();
+    });
+    it('buildJsonReport includes passingTests when present', () => {
+        const cache = {
+            a: makeEntry({
+                status: 'escaped',
+                file: '/tmp/a.ts',
+                mutator: 'flip',
+                passingTests: ['Suite > test one'],
+            }),
+        };
+        const summary = computeSummary(cache);
+        const report = buildJsonReport(summary, cache);
+        expect(report.mutants[0].passingTests).toEqual(['Suite > test one']);
+    });
+    it('buildJsonReport omits passingTests when absent', () => {
+        const cache = { a: makeEntry({ status: 'escaped' }) };
+        const summary = computeSummary(cache);
+        const report = buildJsonReport(summary, cache);
+        expect('passingTests' in report.mutants[0]).toBe(false);
+    });
     it('does not print covering tests when array is absent', () => {
         const cache = {
             a: makeEntry({ status: 'escaped' }),
@@ -176,57 +212,60 @@ describe('summary', () => {
         expect('originalSnippet' in report.mutants[0]).toBe(false);
         expect('coveringTests' in report.mutants[0]).toBe(false);
     });
-    it('prints compile error mutants section by default', () => {
-        const cache = {
-            a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
-            }),
-        };
+    it('prints report hint line', () => {
+        const cache = { a: makeEntry({ status: 'killed' }) };
         const summary = computeSummary(cache);
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         printSummary(summary, cache);
         const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
-        expect(lines.some((l) => l.includes('Compile Error Mutants'))).toBe(true);
+        expect(lines.some((l) => l.includes('Run with --report json to see full mutation details.'))).toBe(true);
+        logSpy.mockRestore();
+    });
+    it('summarise returns summary and prints', () => {
+        const cache = { a: makeEntry({ status: 'killed' }) };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const s = summarise(cache);
+        expect(s.total).toBe(1);
+        expect(logSpy).toHaveBeenCalled();
         logSpy.mockRestore();
     });
-    it('skips compile error section when skipCompileErrors is true', () => {
+    it('counts compile-error status in compileErrors field', () => {
+        const cache = { a: makeEntry({ status: 'compile-error' }) };
+        const s = computeSummary(cache);
+        expect(s.compileErrors).toBe(1);
+        expect(s.killed).toBe(0);
+    });
+    it('categorizes compile-error entries without throwing in printSummary', () => {
         const cache = {
-            a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
-            }),
+            a: makeEntry({ status: 'compile-error', file: '/tmp/a.ts' }),
         };
         const summary = computeSummary(cache);
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        printSummary(summary, cache, undefined, { skipCompileErrors: true });
+        printSummary(summary, cache);
+        expect(summary.compileErrors).toBe(1);
+        logSpy.mockRestore();
+    });
+    it('formats duration in minutes when duration >= 60s', () => {
+        const cache = { a: makeEntry({ status: 'killed' }) };
+        const summary = computeSummary(cache);
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        printSummary(summary, cache, 90000); // 90 seconds = 1m 30.0s
         const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
-        expect(lines.some((l) => l.includes('Compile Error Mutants'))).toBe(false);
+        expect(lines.some((l) => l.includes('1m 30.0s'))).toBe(true);
         logSpy.mockRestore();
     });
-    it('shows compile error section when skipCompileErrors is false', () => {
+    it('prints +N more when escaped mutant has more than 2 covering tests', () => {
         const cache = {
             a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
+                status: 'escaped',
+                coveringTests: ['/t1.spec.ts', '/t2.spec.ts', '/t3.spec.ts'],
             }),
         };
         const summary = computeSummary(cache);
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        printSummary(summary, cache, undefined, { skipCompileErrors: false });
+        printSummary(summary, cache);
         const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
-        expect(lines.some((l) => l.includes('Compile Error Mutants'))).toBe(true);
-        logSpy.mockRestore();
-    });
-    it('summarise returns summary and prints', () => {
-        const cache = { a: makeEntry({ status: 'killed' }) };
-        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        const s = summarise(cache);
-        expect(s.total).toBe(1);
-        expect(logSpy).toHaveBeenCalled();
+        expect(lines.some((l) => l.includes('+1 more'))).toBe(true);
         logSpy.mockRestore();
     });
 });

package/dist/utils/coverage.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { toErrorMessage } from './errors.js';
 /**
  * Load and parse Istanbul-format coverage JSON file.
  * Supports both coverage-final.json (from Istanbul) and Vitest's coverage output.
@@ -17,16 +18,14 @@ export async function loadCoverageData(coverageFile, cwd) {
         raw = await fs.readFile(absPath, 'utf8');
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to read coverage file "${absPath}": ${msg}`);
+        throw new Error(`Failed to read coverage file "${absPath}": ${toErrorMessage(err)}`);
     }
     let data;
     try {
         data = JSON.parse(raw);
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to parse coverage file "${absPath}" as JSON: ${msg}`);
+        throw new Error(`Failed to parse coverage file "${absPath}" as JSON: ${toErrorMessage(err)}`);
     }
     const coveredLines = new Map();
     for (const [filePath, fileCoverage] of Object.entries(data)) {

package/dist/utils/errors.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Error message extraction utility.
+ */
+export declare function toErrorMessage(err: unknown): string;

package/dist/utils/errors.js

@@ -0,0 +1,6 @@
+/**
+ * Error message extraction utility.
+ */
+export function toErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/utils/summary.d.ts

@@ -10,9 +10,7 @@ export interface Summary {
     readonly killRate: number;
 }
 export declare function computeSummary(cache: Readonly<Record<string, MutantCacheEntry>>): Summary;
-export declare function printSummary(summary: Summary, cache?: Readonly<Record<string, MutantCacheEntry>>, durationMs?: number, opts?: {
-    skipCompileErrors?: boolean;
-}): void;
+export declare function printSummary(summary: Summary, cache?: Readonly<Record<string, MutantCacheEntry>>, durationMs?: number): void;
 export interface JsonMutant {
     readonly file: string;
     readonly line: number;
@@ -22,6 +20,7 @@ export interface JsonMutant {
     readonly originalSnippet?: string;
     readonly mutatedSnippet?: string;
     readonly coveringTests?: readonly string[];
+    readonly passingTests?: readonly string[];
 }
 export interface JsonReport {
     readonly schemaVersion: 1;

package/dist/utils/summary.js

@@ -44,7 +44,7 @@ function formatDuration(ms) {
     const remainingSeconds = seconds % 60;
     return `${minutes}m ${remainingSeconds.toFixed(1)}s`;
 }
-export function printSummary(summary, cache, durationMs, opts) {
+export function printSummary(summary, cache, durationMs) {
     console.log('\n' + chalk.dim(SEPARATOR));
     console.log(chalk.bold(' Mutineer Test Suite Summary'));
     console.log(chalk.dim(SEPARATOR));
@@ -113,11 +113,6 @@ export function printSummary(summary, cache, durationMs, opts) {
             }
         }
     }
-    if (entriesByStatus.compileErrors.length && !opts?.skipCompileErrors) {
-        console.log('\n' + chalk.dim('Compile Error Mutants (type-filtered):'));
-        for (const entry of entriesByStatus.compileErrors)
-            console.log('  ' + formatRow(entry));
-    }
     if (entriesByStatus.timeouts.length) {
         console.log('\n' + chalk.yellow.bold('Timed Out Mutants:'));
         for (const entry of entriesByStatus.timeouts)
@@ -148,6 +143,7 @@ export function printSummary(summary, cache, durationMs, opts) {
     if (durationMs !== undefined) {
         console.log(`Duration: ${chalk.cyan(formatDuration(durationMs))}`);
     }
+    console.log(chalk.dim('Run with --report json to see full mutation details.'));
     console.log(chalk.dim(SEPARATOR) + '\n');
 }
 export function buildJsonReport(summary, cache, durationMs) {
@@ -166,6 +162,9 @@ export function buildJsonReport(summary, cache, durationMs) {
         ...(entry.coveringTests !== undefined && {
             coveringTests: entry.coveringTests,
         }),
+        ...(entry.passingTests !== undefined && {
+            passingTests: entry.passingTests,
+        }),
     }));
     return {
         schemaVersion: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "A fast, targeted mutation testing framework for JavaScript and TypeScript",
   "type": "module",
   "private": false,

package/dist/utils/CompileErrors.d.ts

@@ -1,7 +0,0 @@
-import type { MutantCacheEntry } from '../types/mutant.js';
-interface Props {
-    entries: MutantCacheEntry[];
-    cwd: string;
-}
-export declare function CompileErrors({ entries, cwd }: Props): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/utils/CompileErrors.js

@@ -1,24 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import path from 'node:path';
-import { Box, Text, useInput, useApp } from 'ink';
-import { useState, useEffect } from 'react';
-export function CompileErrors({ entries, cwd }) {
-    const { exit } = useApp();
-    const [expanded, setExpanded] = useState(false);
-    useEffect(() => {
-        if (expanded)
-            exit();
-    }, [expanded, exit]);
-    useInput((input, key) => {
-        if (input === 'e') {
-            setExpanded(true);
-        }
-        else if (key.return || input === 'q') {
-            exit();
-        }
-    });
-    if (expanded) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Compile Error Mutants (type-filtered):" }), entries.map((entry, i) => (_jsxs(Text, { dimColor: true, children: ['  \u2022 ', path.relative(cwd, entry.file), "@", entry.line, ",", entry.col, '  ', entry.mutator] }, i)))] }));
-    }
-    return (_jsxs(Box, { gap: 2, children: [_jsxs(Text, { dimColor: true, children: ["Compile Error Mutants (type-filtered): ", entries.length] }), _jsx(Text, { dimColor: true, children: "e expand  return skip" })] }));
-}

package/dist/utils/__tests__/CompileErrors.spec.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockExit = vi.fn();
-const mockSetExpanded = vi.fn();
-let inputHandler;
-let effectCallback;
-vi.mock('ink', () => ({
-    Box: ({ children }) => children,
-    Text: ({ children }) => children,
-    useInput: vi.fn((fn) => {
-        inputHandler = fn;
-    }),
-    useApp: () => ({ exit: mockExit }),
-}));
-vi.mock('react', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        useState: vi.fn((init) => [init, mockSetExpanded]),
-        useEffect: vi.fn((fn) => {
-            effectCallback = fn;
-        }),
-    };
-});
-import { CompileErrors } from '../CompileErrors.js';
-import { useState } from 'react';
-const entries = [
-    {
-        status: 'compile-error',
-        file: '/cwd/src/foo.ts',
-        line: 10,
-        col: 5,
-        mutator: 'returnToNull',
-    },
-    {
-        status: 'compile-error',
-        file: '/cwd/src/bar.ts',
-        line: 20,
-        col: 3,
-        mutator: 'returnFlipBool',
-    },
-];
-describe('CompileErrors', () => {
-    beforeEach(() => {
-        mockExit.mockClear();
-        mockSetExpanded.mockClear();
-        inputHandler = undefined;
-        effectCallback = undefined;
-        vi.mocked(useState).mockImplementation(((init) => [
-            init,
-            mockSetExpanded,
-        ]));
-    });
-    it('registers a useInput handler on render', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        expect(inputHandler).toBeDefined();
-    });
-    it('calls setExpanded(true) when "e" is pressed', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('e', { return: false });
-        expect(mockSetExpanded).toHaveBeenCalledWith(true);
-    });
-    it('calls exit() when return is pressed', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('', { return: true });
-        expect(mockExit).toHaveBeenCalled();
-    });
-    it('calls exit() when "q" is pressed', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('q', { return: false });
-        expect(mockExit).toHaveBeenCalled();
-    });
-    it('does not call exit() or setExpanded for other keys', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        inputHandler('x', { return: false });
-        expect(mockExit).not.toHaveBeenCalled();
-        expect(mockSetExpanded).not.toHaveBeenCalled();
-    });
-    it('registers a useEffect handler on render', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        expect(effectCallback).toBeDefined();
-    });
-    it('useEffect calls exit() when expanded is true', () => {
-        vi.mocked(useState).mockReturnValueOnce([
-            true,
-            mockSetExpanded,
-        ]);
-        CompileErrors({ entries, cwd: '/cwd' });
-        effectCallback();
-        expect(mockExit).toHaveBeenCalled();
-    });
-    it('useEffect does not call exit() when expanded is false', () => {
-        CompileErrors({ entries, cwd: '/cwd' });
-        effectCallback();
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-});