@mutineerjs/mutineer 0.9.0 → 0.11.0

package/dist/runner/shared/strip-mutineer-args.js

@@ -0,0 +1,47 @@
+const COMMON_CONSUME_NEXT = new Set([
+    '--concurrency',
+    '--progress',
+    '--min-kill-percent',
+    '--config',
+    '-c',
+    '--coverage-file',
+    '--report',
+]);
+const COMMON_DROP_EXACT = new Set([
+    '-m',
+    '--mutate',
+    '--changed',
+    '--changed-with-imports',
+    '--full',
+    '--only-covered-lines',
+    '--per-test-coverage',
+    '--perTestCoverage',
+]);
+const COMMON_DROP_PREFIXES = ['--min-kill-percent=', '--config=', '-c='];
+/**
+ * Strip mutineer-specific CLI args that shouldn't be passed to the underlying
+ * test runner. Callers may supply runner-specific extras via options.
+ */
+export function stripMutineerArgs(args, options = {}) {
+    const consumeNext = options.extraConsumeNext
+        ? new Set([...COMMON_CONSUME_NEXT, ...options.extraConsumeNext])
+        : COMMON_CONSUME_NEXT;
+    const extraPrefixes = options.extraPrefixes ?? [];
+    const allPrefixes = extraPrefixes.length
+        ? [...COMMON_DROP_PREFIXES, ...extraPrefixes]
+        : COMMON_DROP_PREFIXES;
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (COMMON_DROP_EXACT.has(a))
+            continue;
+        if (consumeNext.has(a)) {
+            i++;
+            continue;
+        }
+        if (allPrefixes.some((p) => a.startsWith(p)))
+            continue;
+        out.push(a);
+    }
+    return out;
+}

package/dist/runner/shared/worker-script.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Find a worker/loader script by checking .js -> .mjs -> .ts extension fallback.
+ * Handles compiled (.js), bundled (.mjs), and source (.ts) environments.
+ */
+export declare function resolveWorkerScript(dir: string, basename: string): string;

package/dist/runner/shared/worker-script.js

@@ -0,0 +1,12 @@
+import path from 'node:path';
+import fs from 'node:fs';
+/**
+ * Find a worker/loader script by checking .js -> .mjs -> .ts extension fallback.
+ * Handles compiled (.js), bundled (.mjs), and source (.ts) environments.
+ */
+export function resolveWorkerScript(dir, basename) {
+    const js = path.join(dir, `${basename}.js`);
+    const mjs = path.join(dir, `${basename}.mjs`);
+    const ts = path.join(dir, `${basename}.ts`);
+    return fs.existsSync(js) ? js : fs.existsSync(mjs) ? mjs : ts;
+}

package/dist/runner/ts-checker-worker.d.ts

@@ -2,4 +2,13 @@
  * Worker thread entry point for parallel TypeScript type checking.
  * Receives one file group, runs baseline + per-variant diagnose, posts results.
  */
-export {};
+import ts from 'typescript';
+/** Stable fingerprint for a diagnostic. */
+export declare function diagnosticKey(d: ts.Diagnostic): string;
+/** Create a compiler host that serves `code` for `targetPath`. */
+export declare function makeHost(options: ts.CompilerOptions, targetPath: string, code: string): ts.CompilerHost;
+/** Run semantic diagnostics for `code` in `targetPath`. */
+export declare function diagnose(options: ts.CompilerOptions, targetPath: string, code: string, oldProgram: ts.Program | undefined): {
+    program: ts.Program;
+    keys: Set<string>;
+};

package/dist/runner/ts-checker-worker.js

@@ -7,11 +7,11 @@ import ts from 'typescript';
 import path from 'node:path';
 import fs from 'node:fs';
 /** Stable fingerprint for a diagnostic. */
-function diagnosticKey(d) {
+export function diagnosticKey(d) {
     return `${d.code}:${d.start ?? -1}`;
 }
 /** Create a compiler host that serves `code` for `targetPath`. */
-function makeHost(options, targetPath, code) {
+export function makeHost(options, targetPath, code) {
     const host = ts.createCompilerHost(options);
     const orig = host.getSourceFile.bind(host);
     host.getSourceFile = (fileName, langOrOpts) => {
@@ -23,7 +23,7 @@ function makeHost(options, targetPath, code) {
     return host;
 }
 /** Run semantic diagnostics for `code` in `targetPath`. */
-function diagnose(options, targetPath, code, oldProgram) {
+export function diagnose(options, targetPath, code, oldProgram) {
     const host = makeHost(options, targetPath, code);
     const program = ts.createProgram({
         rootNames: [targetPath],
@@ -39,28 +39,30 @@ function diagnose(options, targetPath, code, oldProgram) {
     const keys = new Set(program.getSemanticDiagnostics(sourceFile).map(diagnosticKey));
     return { program, keys };
 }
-const { options, filePath, variants } = workerData;
-const resolvedPath = path.resolve(filePath);
-let originalCode = '';
-try {
-    originalCode = fs.readFileSync(resolvedPath, 'utf8');
-}
-catch {
-    // empty baseline — all mutant errors count as new
-}
-const { program: baseProgram, keys: baselineKeys } = diagnose(options, resolvedPath, originalCode, undefined);
-let prevProgram = baseProgram;
-const compileErrorIds = [];
-for (const variant of variants) {
-    const { program: mutProgram, keys: mutantKeys } = diagnose(options, resolvedPath, variant.code, prevProgram);
-    prevProgram = mutProgram;
-    let newErrors = 0;
-    for (const key of mutantKeys) {
-        if (!baselineKeys.has(key))
-            newErrors++;
+if (workerData) {
+    const { options, filePath, variants } = workerData;
+    const resolvedPath = path.resolve(filePath);
+    let originalCode = '';
+    try {
+        originalCode = fs.readFileSync(resolvedPath, 'utf8');
+    }
+    catch {
+        // empty baseline — all mutant errors count as new
     }
-    if (newErrors > 0) {
-        compileErrorIds.push(variant.id);
+    const { program: baseProgram, keys: baselineKeys } = diagnose(options, resolvedPath, originalCode, undefined);
+    let prevProgram = baseProgram;
+    const compileErrorIds = [];
+    for (const variant of variants) {
+        const { program: mutProgram, keys: mutantKeys } = diagnose(options, resolvedPath, variant.code, prevProgram);
+        prevProgram = mutProgram;
+        let newErrors = 0;
+        for (const key of mutantKeys) {
+            if (!baselineKeys.has(key))
+                newErrors++;
+        }
+        if (newErrors > 0) {
+            compileErrorIds.push(variant.id);
+        }
     }
+    parentPort.postMessage({ compileErrorIds });
 }
-parentPort.postMessage({ compileErrorIds });

package/dist/runner/ts-checker.d.ts

@@ -15,6 +15,12 @@
 import ts from 'typescript';
 import type { MutineerConfig } from '../types/config.js';
 import type { Variant } from '../types/mutant.js';
+/**
+ * Compiler options used for all type checks: fully isolated, zero I/O.
+ * We read strict/noImplicitAny/etc from the user's tsconfig (to catch the
+ * same errors they care about), but always override lib/resolve settings.
+ */
+export declare function resolveCompilerOptions(tsconfig: string | undefined, cwd: string): ts.CompilerOptions;
 /**
  * Run type checks for one file group synchronously. Used both by the sync
  * fallback (test/dev environments) and by the worker thread.

package/dist/runner/ts-checker.js

@@ -25,7 +25,7 @@ const log = createLogger('ts-checker');
  * We read strict/noImplicitAny/etc from the user's tsconfig (to catch the
  * same errors they care about), but always override lib/resolve settings.
  */
-function resolveCompilerOptions(tsconfig, cwd) {
+export function resolveCompilerOptions(tsconfig, cwd) {
     const base = {
         noEmit: true,
         skipLibCheck: true,

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);
@@ -258,4 +298,258 @@ describe('isCoverageRequestedInArgs', () => {
         expect(isCoverageRequestedInArgs(['--coverage.enabled=false'])).toBe(false);
         expect(isCoverageRequestedInArgs(['--no-coverage'])).toBe(false);
     });
+    it('handles --coverage.enabled with space-separated value', () => {
+        expect(isCoverageRequestedInArgs(['--coverage.enabled', 'false'])).toBe(false);
+        expect(isCoverageRequestedInArgs(['--coverage.enabled', 'true'])).toBe(true);
+        expect(isCoverageRequestedInArgs(['--coverage.enabled', '0'])).toBe(false);
+        expect(isCoverageRequestedInArgs(['--coverage.enabled', 'off'])).toBe(false);
+    });
+    it('handles --coverage= form', () => {
+        expect(isCoverageRequestedInArgs(['--coverage=true'])).toBe(true);
+        expect(isCoverageRequestedInArgs(['--coverage=false'])).toBe(false);
+        expect(isCoverageRequestedInArgs(['--coverage=0'])).toBe(false);
+    });
+    it('handles --coverage.something form (other coverage flags)', () => {
+        expect(isCoverageRequestedInArgs(['--coverage.reporter=json'])).toBe(true);
+        expect(isCoverageRequestedInArgs(['--coverage.all=true'])).toBe(true);
+    });
+});
+describe('Vitest adapter additional coverage', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('strips --min-kill-percent= args from vitest args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--min-kill-percent=80'] });
+        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('--min-kill-percent');
+    });
+    it('strips --config= args from vitest args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--config=./custom.vite.ts'] });
+        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('--config=./custom.vite.ts');
+    });
+    it('passes through non-mutineer args unchanged', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--reporter=verbose'] });
+        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).toContain('--reporter=verbose');
+    });
+    it('handles spawn error event in runBaseline', async () => {
+        const adapter = makeAdapter({ cliArgs: [] });
+        spawnMock.mockImplementationOnce(() => ({
+            stdout: { on: () => { } },
+            stderr: { on: () => { } },
+            on: (evt, cb) => {
+                if (evt === 'error')
+                    cb(new Error('spawn failed'));
+            },
+        }));
+        const result = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(result).toBe(false);
+    });
+    it('throws when runMutant called before init', async () => {
+        const adapter = makeAdapter();
+        await expect(adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t'])).rejects.toThrow('VitestAdapter not initialised');
+    });
+    it('shuts down pool on shutdown()', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        await adapter.shutdown();
+        expect(poolInstance?.shutdown).toHaveBeenCalledTimes(1);
+    });
+    it('does nothing on shutdown() when pool is null', async () => {
+        const adapter = makeAdapter();
+        await expect(adapter.shutdown()).resolves.toBeUndefined();
+    });
+    it('detectCoverageConfig returns false defaults when no vitestConfig', async () => {
+        const adapter = makeAdapter({ config: {} });
+        const result = await adapter.detectCoverageConfig();
+        expect(result).toEqual({ perTestEnabled: false, coverageEnabled: false });
+    });
+    it('detectCoverageConfig returns false defaults when config file missing', async () => {
+        const adapter = makeAdapter({
+            config: { vitestConfig: '/nonexistent/vitest.config.ts' },
+        });
+        const result = await adapter.detectCoverageConfig();
+        expect(result).toEqual({ perTestEnabled: false, coverageEnabled: false });
+    });
+    it('does not prepend "run" if already present in args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['run'] });
+        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];
+        const runCount = args.filter((a) => a === 'run').length;
+        expect(runCount).toBe(1);
+    });
+    it('does not add --watch=false if --watch flag already in args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--watch=false'] });
+        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];
+        const watchCount = args.filter((a) => a.startsWith('--watch')).length;
+        expect(watchCount).toBe(1);
+    });
+    it('does not add --passWithNoTests if already in args', async () => {
+        const adapter = makeAdapter({ cliArgs: ['--passWithNoTests'] });
+        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];
+        const count = args.filter((a) => a === '--passWithNoTests').length;
+        expect(count).toBe(1);
+    });
+    it('does not add coverage flags if --coverage already in args during baseline-with-coverage', async () => {
+        const adapter = makeAdapter({
+            cliArgs: ['--coverage.reporter=html', '--coverage.perTest=true'],
+        });
+        spawnMock.mockImplementationOnce(() => ({
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(0);
+            },
+        }));
+        await adapter.runBaseline(['test-a'], {
+            collectCoverage: true,
+            perTestCoverage: true,
+        });
+        const args = spawnMock.mock.calls[0][1];
+        // --coverage.enabled=true should NOT be added since --coverage.reporter is already present
+        expect(args).not.toContain('--coverage.enabled=true');
+        // --coverage.perTest=true should NOT be added again
+        const perTestCount = args.filter((a) => a.startsWith('--coverage.perTest=')).length;
+        expect(perTestCount).toBe(1);
+    });
+    it('does not override CI env var when already set', async () => {
+        const originalCI = process.env.CI;
+        process.env.CI = 'existing-ci-value';
+        try {
+            const adapter = makeAdapter({ cliArgs: [] });
+            let capturedEnv;
+            spawnMock.mockImplementationOnce((_, __, opts) => {
+                capturedEnv = opts.env;
+                return {
+                    on: (evt, cb) => {
+                        if (evt === 'exit')
+                            cb(0);
+                    },
+                };
+            });
+            await adapter.runBaseline(['test-a'], {
+                collectCoverage: false,
+                perTestCoverage: false,
+            });
+            expect(capturedEnv?.CI).toBe('existing-ci-value');
+        }
+        finally {
+            if (originalCI === undefined)
+                delete process.env.CI;
+            else
+                process.env.CI = originalCI;
+        }
+    });
+    it('runBaseline with non-zero exit and no chunks does not write output', async () => {
+        const adapter = makeAdapter({ cliArgs: [] });
+        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+        const stderrWrite = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        spawnMock.mockImplementationOnce(() => ({
+            stdout: { on: () => { } },
+            stderr: { on: () => { } },
+            on: (evt, cb) => {
+                if (evt === 'exit')
+                    cb(1);
+            },
+        }));
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(false);
+        expect(stdoutWrite).not.toHaveBeenCalled();
+        expect(stderrWrite).not.toHaveBeenCalled();
+        stdoutWrite.mockRestore();
+        stderrWrite.mockRestore();
+    });
+    it('returns error status on pool throw with non-Error', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockRejectedValueOnce('string error');
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({
+            status: 'error',
+            durationMs: 0,
+            error: 'string error',
+        });
+    });
+    it('detectCoverageConfig returns false when coverage is disabled in config', async () => {
+        const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-vitest-'));
+        const cfgPath = path.join(tmp, 'vitest.config.ts');
+        // content with "coverage: false" matches the exclusion regex
+        await fs.writeFile(cfgPath, '// coverage: false');
+        try {
+            const adapter = makeAdapter({
+                cwd: tmp,
+                config: { vitestConfig: cfgPath },
+            });
+            const result = await adapter.detectCoverageConfig();
+            expect(result.coverageEnabled).toBe(false);
+        }
+        finally {
+            await fs.rm(tmp, { recursive: true, force: true });
+        }
+    });
 });

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, afterEach } from 'vitest';
+import { describe, it, expect, afterEach, vi } from 'vitest';
 import fs from 'node:fs/promises';
 import fssync from 'node:fs';
 import path from 'node:path';
@@ -156,6 +156,33 @@ describe('poolMutineerPlugin', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('returns null and logs error when readFileSync throws on redirect', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-plugin-err-'));
+        const fromPath = path.join(tmpDir, 'source.ts');
+        const mutatedPath = path.join(tmpDir, 'mutated.ts');
+        globalThis.__mutineer_redirect__ = {
+            from: fromPath,
+            to: mutatedPath,
+        };
+        const readSpy = vi
+            .spyOn(fssync, 'readFileSync')
+            .mockImplementationOnce(() => {
+            throw new Error('disk error');
+        });
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        try {
+            const load = getLoadFn();
+            const result = load?.(fromPath);
+            expect(result).toBeNull();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to read mutant file'));
+        }
+        finally {
+            readSpy.mockRestore();
+            consoleSpy.mockRestore();
+            globalThis.__mutineer_redirect__ = undefined;
+            await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        }
+    });
     describe('config hook', () => {
         it('returns null when MUTINEER_ACTIVE_ID_FILE is not set', () => {
             const config = getConfigFn();