@mutineerjs/mutineer 0.8.0 → 0.9.0

package/README.md

@@ -100,6 +100,7 @@ npm run mutineer
 | `--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 |
@@ -170,7 +171,7 @@ export default defineMutineerConfig({
 
 Large repos can generate thousands of mutations. These strategies keep runs fast and incremental.
 
-When you run `mutineer run` without `--changed` or `--changed-with-deps` on an interactive terminal, mutineer warns you and lets you narrow scope before starting:
+When you run `mutineer run` without `--changed`, `--changed-with-deps`, or `--full` on an interactive terminal, mutineer warns you and lets you narrow scope before starting:
 
 ```
 Warning: Running on the full codebase may take a while.

package/dist/bin/__tests__/mutineer.spec.js

@@ -11,6 +11,7 @@ describe('HELP_TEXT', () => {
         '--progress',
         '--changed',
         '--changed-with-deps',
+        '--full',
         '--only-covered-lines',
         '--per-test-coverage',
         '--coverage-file',
@@ -61,6 +62,13 @@ describe('confirmFullRun()', () => {
         const args = ['--changed-with-deps'];
         expect(await confirmFullRun(args)).toBe(args);
     });
+    it('returns args unchanged when --full is present, skipping prompt', async () => {
+        mockTTY(true);
+        const createSpy = vi.spyOn(readline, 'createInterface');
+        const args = ['--full'];
+        expect(await confirmFullRun(args)).toBe(args);
+        expect(createSpy).not.toHaveBeenCalled();
+    });
     it('skips prompt and returns args unchanged when stdin is not a TTY', async () => {
         mockTTY(false);
         const createSpy = vi.spyOn(readline, 'createInterface');

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  --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\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

@@ -24,6 +24,7 @@ Options (run):
   --progress <bar|list|quiet>  Progress display (default: bar)
   --changed                 Mutate only git-changed files
   --changed-with-deps       Mutate changed files + their local dependencies
+  --full                    Mutate full codebase, skipping confirmation prompt
   --only-covered-lines      Mutate only lines covered by tests
   --per-test-coverage       Collect per-test coverage data
   --coverage-file <path>    Path to coverage JSON
@@ -62,7 +63,7 @@ Warning: Running on the full codebase may take a while.
  */
 export async function confirmFullRun(args) {
     const isFullRun = !args.includes('--changed') && !args.includes('--changed-with-deps');
-    if (!isFullRun || !process.stdin.isTTY)
+    if (!isFullRun || !process.stdin.isTTY || args.includes('--full'))
         return args;
     process.stdout.write(FULL_RUN_WARNING);
     const rl = readline.createInterface({

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

@@ -131,6 +131,14 @@ describe('parseCliOptions', () => {
         const opts = parseCliOptions(['--changed-with-deps'], emptyCfg);
         expect(opts.wantsChangedWithDeps).toBe(true);
     });
+    it('parses --full flag', () => {
+        const opts = parseCliOptions(['--full'], emptyCfg);
+        expect(opts.wantsFull).toBe(true);
+    });
+    it('wantsFull defaults to false', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.wantsFull).toBe(false);
+    });
     it('parses --only-covered-lines flag', () => {
         const opts = parseCliOptions(['--only-covered-lines'], emptyCfg);
         expect(opts.wantsOnlyCoveredLines).toBe(true);

package/dist/runner/__tests__/coverage-resolver.spec.js

@@ -8,6 +8,7 @@ function makeOpts(overrides = {}) {
         configPath: undefined,
         wantsChanged: false,
         wantsChangedWithDeps: false,
+        wantsFull: false,
         wantsOnlyCoveredLines: false,
         wantsPerTestCoverage: false,
         coverageFilePath: undefined,

package/dist/runner/args.d.ts

@@ -12,6 +12,7 @@ export interface ParsedCliOptions {
     readonly configPath: string | undefined;
     readonly wantsChanged: boolean;
     readonly wantsChangedWithDeps: boolean;
+    readonly wantsFull: boolean;
     readonly wantsOnlyCoveredLines: boolean;
     readonly wantsPerTestCoverage: boolean;
     readonly coverageFilePath: string | undefined;

package/dist/runner/args.js

@@ -134,6 +134,7 @@ export function parseCliOptions(args, cfg) {
     const configPath = readStringFlag(args, '--config', '-c');
     const wantsChanged = args.includes('--changed');
     const wantsChangedWithDeps = args.includes('--changed-with-deps');
+    const wantsFull = args.includes('--full');
     const wantsOnlyCoveredLines = args.includes('--only-covered-lines') || cfg.onlyCoveredLines === true;
     const wantsPerTestCoverage = args.includes('--per-test-coverage') || cfg.perTestCoverage === true;
     const coverageFilePath = readStringFlag(args, '--coverage-file') ?? cfg.coverageFile;
@@ -163,6 +164,7 @@ export function parseCliOptions(args, cfg) {
         configPath,
         wantsChanged,
         wantsChangedWithDeps,
+        wantsFull,
         wantsOnlyCoveredLines,
         wantsPerTestCoverage,
         coverageFilePath,

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

@@ -61,6 +61,55 @@ describe('Jest adapter', () => {
         expect(args.coverageProvider).toBe('v8');
         expect(args.config).toBe('jest.config.ts');
     });
+    it('does not write captured output to stdout/stderr on success', async () => {
+        const adapter = makeAdapter();
+        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+        const stderrWrite = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        runCLIMock.mockResolvedValueOnce({ results: { success: true } });
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(true);
+        // No output should be replayed on success
+        expect(stdoutWrite).not.toHaveBeenCalled();
+        expect(stderrWrite).not.toHaveBeenCalled();
+        stdoutWrite.mockRestore();
+        stderrWrite.mockRestore();
+    });
+    it('replays captured output to stdout/stderr on failure', async () => {
+        const adapter = makeAdapter();
+        // Spy before runBaseline so adapter's origStdoutWrite/origStderrWrite bind to the spy.
+        // runCLI writes during capture are suppressed; the spy sees only the replay after restore.
+        const writtenStdout = [];
+        const writtenStderr = [];
+        const stdoutSpy = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation((chunk) => {
+            writtenStdout.push(Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk));
+            return true;
+        });
+        const stderrSpy = vi
+            .spyOn(process.stderr, 'write')
+            .mockImplementation((chunk) => {
+            writtenStderr.push(Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk));
+            return true;
+        });
+        runCLIMock.mockImplementationOnce(async () => {
+            process.stdout.write('jest stdout output');
+            process.stderr.write('jest stderr output');
+            return { results: { success: false } };
+        });
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(false);
+        expect(writtenStdout.join('')).toContain('jest stdout output');
+        expect(writtenStderr.join('')).toContain('jest stderr output');
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+    });
     it('maps pool result to mutant status', async () => {
         const adapter = makeAdapter();
         await adapter.init();

package/dist/runner/jest/adapter.js

@@ -33,6 +33,7 @@ function stripMutineerArgs(args) {
         '--mutate',
         '--changed',
         '--changed-with-deps',
+        '--full',
         '--only-covered-lines',
         '--per-test-coverage',
         '--perTestCoverage',
@@ -108,16 +109,43 @@ export class JestAdapter {
             ? 'baseline-with-coverage'
             : 'baseline';
         const cliOptions = buildJestCliOptions(tests, mode, this.jestConfigPath);
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        const origStdoutWrite = process.stdout.write.bind(process.stdout);
+        const origStderrWrite = process.stderr.write.bind(process.stderr);
+        // Temporarily capture stdout/stderr so Jest output is suppressed during baseline;
+        // captured output is replayed below on failure.
+        const makeCapture = (chunks) => function (chunk, encodingOrCb, cb) {
+            chunks.push(Buffer.isBuffer(chunk)
+                ? Buffer.from(chunk)
+                : Buffer.from(chunk));
+            const callback = (typeof encodingOrCb === 'function' ? encodingOrCb : cb);
+            callback?.();
+            return true;
+        };
+        process.stdout.write = makeCapture(stdoutChunks);
+        process.stderr.write = makeCapture(stderrChunks);
+        let success = false;
         try {
             const { runCLI } = await loadRunCLI(this.requireFromCwd);
             const { results } = await runCLI(cliOptions, [this.options.cwd]);
-            return results.success;
+            success = results.success;
         }
         catch (err) {
             log.debug('Failed to run Jest baseline: ' +
                 (err instanceof Error ? err.message : String(err)));
-            return false;
         }
+        finally {
+            process.stdout.write = origStdoutWrite;
+            process.stderr.write = origStderrWrite;
+        }
+        if (!success) {
+            if (stdoutChunks.length)
+                process.stdout.write(Buffer.concat(stdoutChunks));
+            if (stderrChunks.length)
+                process.stderr.write(Buffer.concat(stderrChunks));
+        }
+        return success;
     }
     async runMutant(mutant, tests) {
         if (!this.pool) {

package/dist/runner/orchestrator.js

@@ -124,11 +124,24 @@ export async function runOrchestrator(cliArgs, cwd) {
         log.info('Skipping baseline tests (--skip-baseline)');
     }
     else {
-        log.info(`Running ${baselineTests.length} baseline tests${coverage.enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`);
-        const baselineOk = await adapter.runBaseline(baselineTests, {
-            collectCoverage: coverage.enableCoverageForBaseline,
-            perTestCoverage: coverage.wantsPerTestCoverage,
-        });
+        const baselineMsg = `Running ${baselineTests.length} baseline tests${coverage.enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`;
+        let baselineSpinner = null;
+        if (process.stderr.isTTY) {
+            baselineSpinner = render(createElement(PoolSpinner, { message: baselineMsg }), { stdout: process.stderr, stderr: process.stderr });
+        }
+        else {
+            log.info(baselineMsg);
+        }
+        let baselineOk;
+        try {
+            baselineOk = await adapter.runBaseline(baselineTests, {
+                collectCoverage: coverage.enableCoverageForBaseline,
+                perTestCoverage: coverage.wantsPerTestCoverage,
+            });
+        }
+        finally {
+            baselineSpinner?.unmount();
+        }
         if (!baselineOk) {
             process.exitCode = 1;
             return;

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

@@ -137,6 +137,76 @@ describe('Vitest adapter', () => {
         const args = spawnMock.mock.calls[0][1];
         expect(args.join(' ')).not.toContain('--shard');
     });
+    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);
+        const stderrWrite = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        const listeners = {};
+        spawnMock.mockImplementationOnce(() => ({
+            stdout: {
+                on: (evt, cb) => {
+                    ;
+                    (listeners[`stdout:${evt}`] ??= []).push(cb);
+                },
+            },
+            stderr: {
+                on: (evt, cb) => {
+                    ;
+                    (listeners[`stderr:${evt}`] ??= []).push(cb);
+                },
+            },
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            },
+        }));
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(true);
+        expect(stdoutWrite).not.toHaveBeenCalled();
+        expect(stderrWrite).not.toHaveBeenCalled();
+        stdoutWrite.mockRestore();
+        stderrWrite.mockRestore();
+    });
+    it('replays captured output to stdout/stderr on failure', async () => {
+        const adapter = makeAdapter({ cliArgs: [] });
+        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+        const stderrWrite = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        const stdoutListeners = [];
+        const stderrListeners = [];
+        spawnMock.mockImplementationOnce(() => ({
+            stdout: {
+                on: (evt, cb) => {
+                    if (evt === 'data')
+                        stdoutListeners.push(cb);
+                },
+            },
+            stderr: {
+                on: (evt, cb) => {
+                    if (evt === 'data')
+                        stderrListeners.push(cb);
+                },
+            },
+            on: (evt, cb) => {
+                if (evt === 'exit') {
+                    stdoutListeners.forEach((l) => l(Buffer.from('stdout output')));
+                    stderrListeners.forEach((l) => l(Buffer.from('stderr output')));
+                    cb(1);
+                }
+            },
+        }));
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(false);
+        expect(stdoutWrite).toHaveBeenCalledWith(Buffer.from('stdout output'));
+        expect(stderrWrite).toHaveBeenCalledWith(Buffer.from('stderr output'));
+        stdoutWrite.mockRestore();
+        stderrWrite.mockRestore();
+    });
     it('detects coverage config from vitest config file', async () => {
         const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-vitest-'));
         const cfgPath = path.join(tmp, 'vitest.config.ts');

package/dist/runner/vitest/adapter.js

@@ -44,6 +44,7 @@ function stripMutineerArgs(args) {
         '--mutate',
         '--changed',
         '--changed-with-deps',
+        '--full',
         '--only-covered-lines',
         '--per-test-coverage',
         '--perTestCoverage',
@@ -147,14 +148,24 @@ export class VitestAdapter {
                 env.CI = '1';
             const child = spawn(process.execPath, [this.vitestPath, ...args, ...tests], {
                 cwd: this.options.cwd,
-                stdio: ['ignore', 'inherit', 'inherit'],
+                stdio: ['ignore', 'pipe', 'pipe'],
                 env,
             });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            child.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
+            child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
             child.on('error', (err) => {
                 log.debug('Failed to spawn vitest process: ' + err.message);
                 resolve(false);
             });
             child.on('exit', (code) => {
+                if (code !== 0) {
+                    if (stdoutChunks.length)
+                        process.stdout.write(Buffer.concat(stdoutChunks));
+                    if (stderrChunks.length)
+                        process.stderr.write(Buffer.concat(stderrChunks));
+                }
                 resolve(code === 0);
             });
         });

package/package.json

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