@mutineerjs/mutineer 0.9.0 → 0.10.0

package/README.md

@@ -15,10 +15,10 @@ Built for **Vitest** with first-class **Jest** support. Other test runners can b
 
 ## How It Works
 
-1. **Baseline** -- runs your test suite to make sure everything passes before mutating
-2. **Mutate** -- applies AST-safe operator replacements to your source files (not your tests)
-3. **Test** -- re-runs only the tests that import the mutated file; compile errors are detected via parallel TypeScript workers and surfaced in an interactive UI
-4. **Report** -- prints a summary with kill rate, escaped mutants, and per-file breakdowns
+1. **Baseline** - runs your test suite to make sure everything passes before mutating
+2. **Mutate** - applies AST-safe operator replacements to your source files (not your tests)
+3. **Test** - re-runs only the tests that import the mutated file; compile errors are detected via parallel TypeScript workers
+4. **Report** - prints a summary with kill rate, escaped mutants, and per-file breakdowns
 
 Mutations are applied using Babel AST analysis, so operators inside strings and comments are never touched. Mutated code is written to a temporary `__mutineer__` directory next to each source file, then loaded at runtime via Vite plugins (Vitest) or custom resolvers (Jest).
 
@@ -93,23 +93,26 @@ npm run mutineer
 
 ### CLI Options (for `mutineer run`)
 
-| Flag                     | Description                                                     | Default       |
-| ------------------------ | --------------------------------------------------------------- | ------------- |
-| `--runner <type>`        | Test runner: `vitest` or `jest`                                 | `vitest`      |
-| `--config`, `-c`         | Path to config file                                             | auto-detected |
-| `--concurrency <n>`      | Parallel workers (min 1)                                        | CPUs - 1      |
-| `--changed`              | Only mutate files changed vs base branch                        | --            |
-| `--changed-with-deps`    | Include dependents of changed files                             | --            |
-| `--full`                 | Mutate full codebase, skipping confirmation prompt              | --            |
-| `--only-covered-lines`   | Skip mutations on uncovered lines                               | --            |
-| `--per-test-coverage`    | Run only tests that cover the mutated line                      | --            |
-| `--coverage-file <path>` | Path to Istanbul coverage JSON                                  | auto-detected |
-| `--min-kill-percent <n>` | Fail if kill rate is below threshold                            | --            |
-| `--progress <mode>`      | Display mode: `bar`, `list`, or `quiet`                         | `bar`         |
-| `--timeout <ms>`         | Per-mutant test timeout                                         | `30000`       |
-| `--report <format>`      | Output format: `text` or `json` (writes `mutineer-report.json`) | `text`        |
-| `--shard <n>/<total>`    | Run a slice of mutants (e.g. `--shard 1/4`)                     | --            |
-| `--skip-baseline`        | Skip the baseline test run                                      | --            |
+| Flag                      | Description                                                                          | Default       |
+| ------------------------- | ------------------------------------------------------------------------------------ | ------------- |
+| `--runner <type>`         | Test runner: `vitest` or `jest`                                                      | `vitest`      |
+| `--config`, `-c`          | Path to config file                                                                  | auto-detected |
+| `--concurrency <n>`       | Parallel workers (min 1)                                                             | CPUs - 1      |
+| `--changed`               | Only mutate files changed vs base branch                                             | --            |
+| `--changed-with-deps`     | Include dependents of changed files                                                  | --            |
+| `--full`                  | Mutate full codebase, skipping confirmation prompt                                   | --            |
+| `--only-covered-lines`    | Skip mutations on uncovered lines                                                    | --            |
+| `--per-test-coverage`     | Run only tests that cover the mutated line                                           | --            |
+| `--coverage-file <path>`  | Path to Istanbul coverage JSON                                                       | auto-detected |
+| `--min-kill-percent <n>`  | Fail if kill rate is below threshold                                                 | --            |
+| `--progress <mode>`       | Display mode: `bar`, `list`, or `quiet`                                              | `bar`         |
+| `--timeout <ms>`          | Per-mutant test timeout                                                              | `30000`       |
+| `--report <format>`       | Output format: `text` or `json` (writes `mutineer-report.json`)                      | `text`        |
+| `--shard <n>/<total>`     | Run a slice of mutants (e.g. `--shard 1/4`)                                          | --            |
+| `--skip-baseline`         | Skip the baseline test run                                                           | --            |
+| `--vitest-project <name>` | Filter mutations to a specific Vitest workspace project (requires `test.projects`)   | --            |
+| `--typescript`            | Enable TypeScript type-check pre-filtering (skips mutants that cause compile errors) | auto          |
+| `--no-typescript`         | Disable TypeScript type-check pre-filtering                                          | --            |
 
 ### Examples
 
@@ -149,23 +152,25 @@ export default defineMutineerConfig({
 
 ### Config Options
 
-| Option              | Type                 | Description                                      |
-| ------------------- | -------------------- | ------------------------------------------------ |
-| `source`            | `string \| string[]` | Glob patterns for source files to mutate         |
-| `targets`           | `MutateTarget[]`     | Explicit list of files to mutate                 |
-| `runner`            | `'vitest' \| 'jest'` | Test runner to use                               |
-| `vitestConfig`      | `string`             | Path to vitest config                            |
-| `jestConfig`        | `string`             | Path to jest config                              |
-| `include`           | `string[]`           | Only run these mutators                          |
-| `exclude`           | `string[]`           | Skip these mutators                              |
-| `excludePaths`      | `string[]`           | Glob patterns for paths to skip                  |
-| `maxMutantsPerFile` | `number`             | Cap mutations per file                           |
-| `minKillPercent`    | `number`             | Fail if kill rate is below this                  |
-| `onlyCoveredLines`  | `boolean`            | Only mutate lines covered by tests               |
-| `perTestCoverage`   | `boolean`            | Use per-test coverage to select tests            |
-| `baseRef`           | `string`             | Git ref for `--changed` (default: `origin/main`) |
-| `testPatterns`      | `string[]`           | Globs for test file discovery                    |
-| `extensions`        | `string[]`           | File extensions to consider                      |
+| Option              | Type                               | Description                                                                  |
+| ------------------- | ---------------------------------- | ---------------------------------------------------------------------------- |
+| `source`            | `string \| string[]`               | Glob patterns for source files to mutate                                     |
+| `targets`           | `MutateTarget[]`                   | Explicit list of files to mutate                                             |
+| `runner`            | `'vitest' \| 'jest'`               | Test runner to use                                                           |
+| `vitestConfig`      | `string`                           | Path to vitest config                                                        |
+| `jestConfig`        | `string`                           | Path to jest config                                                          |
+| `include`           | `string[]`                         | Only run these mutators                                                      |
+| `exclude`           | `string[]`                         | Skip these mutators                                                          |
+| `excludePaths`      | `string[]`                         | Glob patterns for paths to skip                                              |
+| `maxMutantsPerFile` | `number`                           | Cap mutations per file                                                       |
+| `minKillPercent`    | `number`                           | Fail if kill rate is below this                                              |
+| `onlyCoveredLines`  | `boolean`                          | Only mutate lines covered by tests                                           |
+| `perTestCoverage`   | `boolean`                          | Use per-test coverage to select tests                                        |
+| `baseRef`           | `string`                           | Git ref for `--changed` (default: `origin/main`)                             |
+| `testPatterns`      | `string[]`                         | Globs for test file discovery                                                |
+| `extensions`        | `string[]`                         | File extensions to consider                                                  |
+| `vitestProject`     | `string \| string[]`               | Filter to a specific Vitest workspace project                                |
+| `typescript`        | `boolean \| { tsconfig?: string }` | Enable TS type-check pre-filtering; auto-detected if `tsconfig.json` present |
 
 ## Recommended Workflow
 

package/dist/bin/mutineer.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-export declare const HELP_TEXT = "Usage: mutineer <command> [options]\n\nCommands:\n  init       Create a mutineer.config.ts template\n  run        Run mutation testing\n  clean      Remove __mutineer__ temp directories\n\nOptions (run):\n  --config, -c <path>       Config file path\n  --concurrency <n>         Worker count (default: CPU count - 1)\n  --runner <vitest|jest>    Test runner (default: vitest)\n  --progress <bar|list|quiet>  Progress display (default: bar)\n  --changed                 Mutate only git-changed files\n  --changed-with-deps       Mutate changed files + their local dependencies\n  --full                    Mutate full codebase, skipping confirmation prompt\n  --only-covered-lines      Mutate only lines covered by tests\n  --per-test-coverage       Collect per-test coverage data\n  --coverage-file <path>    Path to coverage JSON\n  --min-kill-percent <n>    Minimum kill % threshold (0\u2013100)\n  --timeout <ms>            Per-mutant test timeout in ms (default: 30000)\n  --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)\n  --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)\n  --skip-baseline           Skip the baseline test run\n\n  --help, -h                Show this help\n  --version, -V             Show version\n";
+export declare const HELP_TEXT = "Usage: mutineer <command> [options]\n\nCommands:\n  init       Create a mutineer.config.ts template\n  run        Run mutation testing\n  clean      Remove __mutineer__ temp directories\n\nOptions (run):\n  --config, -c <path>       Config file path\n  --concurrency <n>         Worker count (default: CPU count - 1)\n  --runner <vitest|jest>    Test runner (default: vitest)\n  --progress <bar|list|quiet>  Progress display (default: bar)\n  --changed                 Mutate only git-changed files\n  --changed-with-deps       Mutate changed files + their local dependencies\n  --full                    Mutate full codebase, skipping confirmation prompt\n  --only-covered-lines      Mutate only lines covered by tests\n  --per-test-coverage       Collect per-test coverage data\n  --coverage-file <path>    Path to coverage JSON\n  --min-kill-percent <n>    Minimum kill % threshold (0\u2013100)\n  --timeout <ms>            Per-mutant test timeout in ms (default: 30000)\n  --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)\n  --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)\n  --skip-baseline           Skip the baseline test run\n  --vitest-project <name>   Filter to a specific Vitest workspace project\n  --typescript              Enable TS type-check pre-filtering\n  --no-typescript           Disable TS type-check pre-filtering\n\n  --help, -h                Show this help\n  --version, -V             Show version\n";
 export declare function getVersion(): string;
 /**
  * When running in full-codebase mode on an interactive TTY, warn the user and

package/dist/bin/mutineer.js

@@ -33,6 +33,9 @@ Options (run):
   --report <text|json>      Output format: text (default) or json (writes mutineer-report.json)
   --shard <n>/<total>       Run a shard of mutants (e.g. --shard 1/4)
   --skip-baseline           Skip the baseline test run
+  --vitest-project <name>   Filter to a specific Vitest workspace project
+  --typescript              Enable TS type-check pre-filtering
+  --no-typescript           Disable TS type-check pre-filtering
 
   --help, -h                Show this help
   --version, -V             Show version

package/dist/runner/__tests__/orchestrator.spec.js

@@ -62,9 +62,7 @@ vi.mock('../ts-checker.js', () => ({
     resolveTsconfigPath: vi.fn().mockReturnValue(undefined),
 }));
 vi.mock('../../core/schemata.js', () => ({
-    generateSchema: vi
-        .fn()
-        .mockReturnValue({
+    generateSchema: vi.fn().mockReturnValue({
         schemaCode: '// @ts-nocheck\n',
         fallbackIds: new Set(),
     }),
@@ -334,6 +332,40 @@ describe('runOrchestrator shard filtering', () => {
         expect(call.shard).toEqual({ index: 1, total: 4 });
     });
 });
+describe('runOrchestrator target ordering', () => {
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        // No explicit targets -- use auto-discovery
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        vi.mocked(enumerateAllVariants).mockResolvedValue([]);
+        vi.mocked(prepareTasks).mockReturnValue([]);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('sorts auto-discovered targets alphabetically before enumeration', async () => {
+        const fileA = '/cwd/src/aaa.ts';
+        const fileB = '/cwd/src/bbb.ts';
+        const fileC = '/cwd/src/ccc.ts';
+        // Return targets in reverse-alphabetical order (simulating non-deterministic fs)
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [fileC, fileA, fileB],
+            testMap: new Map([
+                [fileA, new Set([testFile])],
+                [fileB, new Set([testFile])],
+                [fileC, new Set([testFile])],
+            ]),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator([], '/cwd');
+        const call = vi.mocked(enumerateAllVariants).mock.calls[0][0];
+        expect(call.targets).toEqual([fileA, fileB, fileC]);
+    });
+});
 describe('runOrchestrator --skip-baseline', () => {
     const targetFile = '/cwd/src/foo.ts';
     const testFile = '/cwd/src/__tests__/foo.spec.ts';

package/dist/runner/jest/adapter.js

@@ -27,6 +27,7 @@ function stripMutineerArgs(args) {
         '-c',
         '--coverage-file',
         '--runner',
+        '--report',
     ]);
     const dropExact = new Set([
         '-m',

package/dist/runner/orchestrator.js

@@ -85,6 +85,7 @@ export async function runOrchestrator(cliArgs, cwd) {
         : (cfg.autoDiscover ?? true)
             ? discovered.targets
             : [];
+    targets.sort((a, b) => getTargetFile(a).localeCompare(getTargetFile(b)));
     // Collect all test files for baseline run
     const allTestFiles = new Set();
     for (const target of targets) {

package/dist/runner/pool-executor.js

@@ -7,7 +7,6 @@ import { computeSummary, printSummary, buildJsonReport, } from '../utils/summary
 import { saveCacheAtomic } from './cache.js';
 import { cleanupMutineerDirs } from './cleanup.js';
 import { PoolSpinner } from '../utils/PoolSpinner.js';
-import { CompileErrors } from '../utils/CompileErrors.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('pool-executor');
 /**
@@ -24,7 +23,7 @@ export async function executePool(opts) {
     const mutationStartTime = Date.now();
     // Ensure we only finish once
     let finished = false;
-    const finishOnce = async (interactive = true) => {
+    const finishOnce = async () => {
         if (finished)
             return;
         finished = true;
@@ -41,15 +40,7 @@ export async function executePool(opts) {
             log.info(`JSON report written to ${path.relative(process.cwd(), outPath)}`);
         }
         else {
-            const compileErrorEntries = Object.values(cache).filter((e) => e.status === 'compile-error');
-            const useInteractive = interactive && process.stdout.isTTY && compileErrorEntries.length > 0;
-            printSummary(summary, cache, durationMs, {
-                skipCompileErrors: useInteractive,
-            });
-            if (useInteractive) {
-                const { waitUntilExit } = render(createElement(CompileErrors, { entries: compileErrorEntries, cwd }));
-                await waitUntilExit();
-            }
+            printSummary(summary, cache, durationMs);
         }
         if (opts.minKillPercent !== undefined) {
             const killRateString = summary.killRate.toFixed(2);
@@ -151,6 +142,10 @@ export async function executePool(opts) {
                 (directTests ?? tests).length > 0 && {
                 coveringTests: directTests ?? tests,
             }),
+            ...(status === 'escaped' &&
+                result.passingTests?.length && {
+                passingTests: result.passingTests,
+            }),
         };
         progress.update(status);
     }
@@ -170,7 +165,7 @@ export async function executePool(opts) {
             return;
         signalCleanedUp = true;
         log.info(`\nReceived ${signal}, cleaning up...`);
-        await finishOnce(false);
+        await finishOnce();
         await adapter.shutdown();
         await cleanupMutineerDirs(cwd);
         process.exit(1);

package/dist/runner/vitest/__tests__/adapter.spec.js

@@ -56,6 +56,30 @@ describe('Vitest adapter', () => {
         const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
         expect(res).toEqual({ status: 'killed', durationMs: 10, error: undefined });
     });
+    it('includes passingTests in escaped result', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({
+            killed: false,
+            durationMs: 8,
+            passingTests: ['Suite > test one', 'Suite > test two'],
+        });
+        const res = await adapter.runMutant({ id: '2', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res.status).toBe('escaped');
+        expect(res.passingTests).toEqual(['Suite > test one', 'Suite > test two']);
+    });
+    it('omits passingTests for killed mutants', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({
+            killed: true,
+            durationMs: 5,
+            passingTests: ['should not appear'],
+        });
+        const res = await adapter.runMutant({ id: '3', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res.status).toBe('killed');
+        expect(res.passingTests).toBeUndefined();
+    });
     it('maps pool timeout errors to timeout status', async () => {
         const adapter = makeAdapter();
         await adapter.init();
@@ -137,6 +161,22 @@ describe('Vitest adapter', () => {
         const args = spawnMock.mock.calls[0][1];
         expect(args.join(' ')).not.toContain('--shard');
     });
+    it('strips --report flag and value from vitest args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--report', 'json'] });
+        spawnMock.mockImplementationOnce(() => ({
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            },
+        }));
+        await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        const args = spawnMock.mock.calls[0][1];
+        expect(args.join(' ')).not.toContain('--report');
+        expect(args.join(' ')).not.toContain('json');
+    });
     it('does not write captured output to stdout/stderr on success', async () => {
         const adapter = makeAdapter({ cliArgs: [] });
         const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);

package/dist/runner/vitest/__tests__/pool.spec.js

@@ -245,4 +245,41 @@ describe('VitestPool', () => {
         expect(killSpy).toHaveBeenCalledWith(-42000, 'SIGKILL');
         killSpy.mockRestore();
     });
+    it('threads passingTests from WorkerMessage through to MutantRunSummary', async () => {
+        const pool = new VitestPool({
+            cwd: process.cwd(),
+            concurrency: 1,
+            timeoutMs: 5000,
+            createWorker: (id) => {
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn().mockReturnValue(true);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi.fn().mockResolvedValue({
+                    killed: false,
+                    durationMs: 10,
+                    passingTests: ['Suite > test one', 'Suite > test two'],
+                });
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                return worker;
+            },
+        });
+        await pool.init();
+        const mutant = {
+            id: 'pt1',
+            name: 'mutant',
+            file: 'foo.ts',
+            code: 'x',
+            line: 1,
+            col: 1,
+        };
+        const result = await pool.run(mutant, ['foo.spec.ts']);
+        expect(result.passingTests).toEqual([
+            'Suite > test one',
+            'Suite > test two',
+        ]);
+        await pool.shutdown();
+    });
 });

package/dist/runner/vitest/__tests__/worker-runtime.spec.js

@@ -125,6 +125,66 @@ describe('VitestWorkerRuntime', () => {
         expect(result.error).toBe('string error');
         await runtime.shutdown();
     });
+    it('collects passingTests fullNames from modules when mutant escapes', async () => {
+        const makeModule = (moduleId, names) => ({
+            moduleId,
+            ok: () => true,
+            children: {
+                allTests: (_state) => names.map((n) => ({ fullName: n })),
+            },
+        });
+        runSpecsFn.mockResolvedValue({
+            testModules: [
+                makeModule(path.join(os.tmpdir(), 'test.ts'), [
+                    'Math > adds',
+                    'Math > subtracts',
+                ]),
+            ],
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-pt-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-pt', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#pt',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(os.tmpdir(), 'test.ts')]);
+        expect(result.killed).toBe(false);
+        expect(result.passingTests).toEqual(['Math > adds', 'Math > subtracts']);
+        await runtime.shutdown();
+    });
+    it('omits passingTests when mutant is killed', async () => {
+        runSpecsFn.mockResolvedValue({
+            testModules: [
+                {
+                    moduleId: path.join(os.tmpdir(), 'test.ts'),
+                    ok: () => false,
+                    children: {
+                        allTests: (_state) => [{ fullName: 'Math > adds' }],
+                    },
+                },
+            ],
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-kpt-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-kpt', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#kpt',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(os.tmpdir(), 'test.ts')]);
+        expect(result.killed).toBe(true);
+        expect(result.passingTests).toBeUndefined();
+        await runtime.shutdown();
+    });
     it('falls back to all testModules when no relevant modules match', async () => {
         runSpecsFn.mockResolvedValue({
             testModules: [{ moduleId: 'unknown-module', ok: () => true }],

package/dist/runner/vitest/adapter.js

@@ -38,6 +38,7 @@ function stripMutineerArgs(args) {
         '-c',
         '--coverage-file',
         '--shard',
+        '--report',
     ]);
     const dropExact = new Set([
         '-m',
@@ -190,10 +191,15 @@ export class VitestAdapter {
                     error: result.error,
                 };
             }
+            const status = result.killed ? 'killed' : 'escaped';
             return {
-                status: result.killed ? 'killed' : 'escaped',
+                status,
                 durationMs: result.durationMs,
                 error: result.error,
+                ...(!result.killed &&
+                    result.passingTests && {
+                    passingTests: result.passingTests,
+                }),
             };
         }
         catch (err) {

package/dist/runner/vitest/pool.js

@@ -150,6 +150,7 @@ class VitestWorker extends EventEmitter {
                     killed: msg.killed ?? true,
                     durationMs: msg.durationMs ?? 0,
                     error: msg.error,
+                    ...(msg.passingTests && { passingTests: msg.passingTests }),
                 });
             }
             return;

package/dist/runner/vitest/worker-runtime.js

@@ -105,9 +105,23 @@ export class VitestWorkerRuntime {
                 ? relevantModules
                 : results.testModules;
             const killed = modulesForDecision.some((mod) => !mod.ok());
+            const passingTests = [];
+            if (!killed) {
+                for (const mod of modulesForDecision) {
+                    try {
+                        for (const tc of mod.children?.allTests('passed') ?? []) {
+                            passingTests.push(tc.fullName);
+                        }
+                    }
+                    catch {
+                        // allTests API unavailable in this Vitest version
+                    }
+                }
+            }
             return {
                 killed,
                 durationMs: Date.now() - start,
+                ...(passingTests.length > 0 && { passingTests }),
             };
         }
         catch (err) {

package/dist/runner/vitest/worker.mjs

@@ -82,6 +82,7 @@ async function main() {
                     killed: result.killed,
                     durationMs: result.durationMs,
                     error: result.error,
+                    ...(result.passingTests && { passingTests: result.passingTests }),
                 });
             }
             catch (err) {

package/dist/types/mutant.d.ts

@@ -31,6 +31,7 @@ export interface MutantCacheEntry extends MutantLocation {
     readonly originalSnippet?: string;
     readonly mutatedSnippet?: string;
     readonly coveringTests?: readonly string[];
+    readonly passingTests?: readonly string[];
 }
 export interface MutantResult extends MutantCacheEntry {
     readonly id: string;
@@ -41,10 +42,12 @@ export interface MutantRunSummary {
     readonly killed: boolean;
     readonly durationMs: number;
     readonly error?: string;
+    readonly passingTests?: readonly string[];
 }
 /** Normalised result returned by adapters/orchestrator. */
 export interface MutantRunResult {
     readonly status: MutantRunStatus;
     readonly durationMs: number;
     readonly error?: string;
+    readonly passingTests?: readonly string[];
 }

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

@@ -123,6 +123,25 @@ describe('summary', () => {
         expect(lines.some((l) => l.includes('foo.spec.ts'))).toBe(true);
         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,49 +195,13 @@ 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);
-        logSpy.mockRestore();
-    });
-    it('skips compile error section when skipCompileErrors is true', () => {
-        const cache = {
-            a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
-            }),
-        };
-        const summary = computeSummary(cache);
-        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        printSummary(summary, cache, undefined, { skipCompileErrors: true });
-        const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
-        expect(lines.some((l) => l.includes('Compile Error Mutants'))).toBe(false);
-        logSpy.mockRestore();
-    });
-    it('shows compile error section when skipCompileErrors is false', () => {
-        const cache = {
-            a: makeEntry({
-                status: 'compile-error',
-                file: '/tmp/a.ts',
-                mutator: 'returnToNull',
-            }),
-        };
-        const summary = computeSummary(cache);
-        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        printSummary(summary, cache, undefined, { skipCompileErrors: false });
-        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', () => {

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.10.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.d.ts

@@ -1 +0,0 @@
-export {};

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();
-    });
-});