@mutineerjs/mutineer 0.9.0 → 0.11.0

package/dist/runner/__tests__/pool-executor.spec.js

@@ -211,6 +211,22 @@ describe('executePool', () => {
         // default file should NOT exist
         await expect(fs.access(path.join(tmpDir, '.mutineer-cache.json'))).rejects.toThrow();
     });
+    it('writes mutineer-report.json when reportFormat=json without shard', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'json-no-shard-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            reportFormat: 'json',
+        });
+        const reportFile = path.join(tmpDir, 'mutineer-report.json');
+        const content = JSON.parse(await fs.readFile(reportFile, 'utf8'));
+        expect(content.schemaVersion).toBe(1);
+    });
     it('writes shard-suffixed JSON report when shard and reportFormat=json are set', async () => {
         const adapter = makeAdapter();
         const cache = {};
@@ -516,6 +532,67 @@ describe('executePool', () => {
         expect(cacheStringifyCalls.length).toBe(1);
         stringifySpy.mockRestore();
     });
+    it('uses bar mode for Progress when progressMode is bar', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        // Should not throw, and bar mode writes to stderr (no isTTY in tests so uses console.log)
+        await executePool({
+            tasks: [makeTask({ key: 'bar-mode-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'bar',
+            cwd: tmpDir,
+        });
+        expect(cache['bar-mode-key'].status).toBe('killed');
+    });
+    it('stores passingTests when result contains passingTests', async () => {
+        const tmpFile = path.join(tmpDir, 'passing.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi.fn().mockResolvedValue({
+                status: 'escaped',
+                durationMs: 1,
+                passingTests: ['/tests/foo.spec.ts'],
+            }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'passing-key',
+            v: {
+                id: 'passing.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/foo.spec.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['passing-key'].passingTests).toEqual(['/tests/foo.spec.ts']);
+    });
+    it('sets exitCode and logs no-mutants note when minKillPercent is set but no mutants evaluated', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            minKillPercent: 80,
+            cwd: tmpDir,
+        });
+        expect(process.exitCode).toBe(1);
+    });
     it('handles adapter errors gracefully and still shuts down', async () => {
         const adapter = makeAdapter({
             runMutant: vi.fn().mockRejectedValue(new Error('adapter failure')),

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

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

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

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import path from 'node:path';
+import ts from 'typescript';
+import { diagnosticKey, makeHost, diagnose } from '../ts-checker-worker.js';
+const defaultOptions = {
+    strict: true,
+    noEmit: true,
+    target: ts.ScriptTarget.ES2020,
+};
+describe('diagnosticKey', () => {
+    it('returns code:start string for diagnostic with start', () => {
+        const d = { code: 2345, start: 10 };
+        expect(diagnosticKey(d)).toBe('2345:10');
+    });
+    it('returns code:-1 when start is undefined', () => {
+        const d = { code: 1234, start: undefined };
+        expect(diagnosticKey(d)).toBe('1234:-1');
+    });
+});
+describe('makeHost', () => {
+    it('returns custom source file for the target path', () => {
+        const targetPath = path.resolve('/fake/target.ts');
+        const code = 'const x: string = 1';
+        const host = makeHost(defaultOptions, targetPath, code);
+        const sf = host.getSourceFile(targetPath, ts.ScriptTarget.ES2020);
+        expect(sf).toBeDefined();
+        expect(sf.text).toBe(code);
+    });
+    it('falls back to orig for non-target files', () => {
+        const targetPath = path.resolve('/fake/target.ts');
+        const host = makeHost(defaultOptions, targetPath, 'const x = 1');
+        // A file that doesn't exist and isn't the target — should return undefined
+        const sf = host.getSourceFile('/some/other/file.ts', ts.ScriptTarget.ES2020);
+        expect(sf).toBeUndefined();
+    });
+});
+describe('diagnose', () => {
+    it('returns empty keys for valid TypeScript code', () => {
+        const targetPath = path.resolve('/fake/valid.ts');
+        const code = 'const x: number = 1\n';
+        const { keys } = diagnose(defaultOptions, targetPath, code, undefined);
+        expect(keys.size).toBe(0);
+    }, 15000);
+    it('detects type errors and returns diagnostic keys', () => {
+        const targetPath = path.resolve('/fake/invalid.ts');
+        const code = 'const x: number = "hello"\n';
+        const { keys } = diagnose(defaultOptions, targetPath, code, undefined);
+        expect(keys.size).toBeGreaterThan(0);
+        for (const key of keys) {
+            expect(key).toMatch(/^\d+:\d+$/);
+        }
+    }, 15000);
+    it('returns empty keys when sourceFile not found', () => {
+        // diagnose with empty code for a path that resolves to something ts can not find
+        const targetPath = path.resolve('/absolutely/nonexistent/path/foo.ts');
+        // Pass code that makes it hard for ts to find the sourceFile by alternate path
+        const { keys } = diagnose(defaultOptions, targetPath, '', undefined);
+        expect(keys instanceof Set).toBe(true);
+    }, 15000);
+    it('accepts an oldProgram for incremental compilation', () => {
+        const targetPath = path.resolve('/fake/incr.ts');
+        const { program: p1 } = diagnose(defaultOptions, targetPath, 'const x = 1\n', undefined);
+        const { keys } = diagnose(defaultOptions, targetPath, 'const x: string = 1\n', p1);
+        expect(keys instanceof Set).toBe(true);
+    }, 15000);
+});

package/dist/runner/__tests__/ts-checker.spec.js

@@ -1,6 +1,8 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import path from 'node:path';
-import { resolveTypescriptEnabled, resolveTsconfigPath, checkTypes, } from '../ts-checker.js';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { resolveTypescriptEnabled, resolveTsconfigPath, resolveCompilerOptions, checkTypes, checkFileSync, } from '../ts-checker.js';
 // Directory with a real tsconfig.json (the project root, 3 levels up from __tests__)
 const CWD_WITH_TSCONFIG = path.resolve(import.meta.dirname, '../../../');
 // A temp-like directory unlikely to have tsconfig.json
@@ -17,6 +19,45 @@ function makeVariant(overrides = {}) {
         ...overrides,
     };
 }
+describe('resolveCompilerOptions', () => {
+    let tmpDir;
+    let brokenTsconfigDir;
+    beforeAll(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-tsco-'));
+        brokenTsconfigDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-tsco-broken-'));
+        // Write a broken tsconfig (invalid JSON)
+        await fs.writeFile(path.join(brokenTsconfigDir, 'tsconfig.json'), '{ invalid json', 'utf8');
+    });
+    afterAll(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+        await fs.rm(brokenTsconfigDir, { recursive: true, force: true });
+    });
+    it('returns base options when no tsconfig found in cwd', () => {
+        const opts = resolveCompilerOptions(undefined, tmpDir);
+        expect(opts.noEmit).toBe(true);
+        expect(opts.noLib).toBe(true);
+        expect(opts.noResolve).toBe(true);
+    });
+    it('returns base options when tsconfig has parse errors', () => {
+        const opts = resolveCompilerOptions(undefined, brokenTsconfigDir);
+        expect(opts.noEmit).toBe(true);
+        expect(opts.noLib).toBe(true);
+    });
+    it('parses real tsconfig and merges options', () => {
+        const opts = resolveCompilerOptions(undefined, CWD_WITH_TSCONFIG);
+        // Should still override these core isolation settings
+        expect(opts.noEmit).toBe(true);
+        expect(opts.noLib).toBe(true);
+        expect(opts.noResolve).toBe(true);
+        expect(opts.skipLibCheck).toBe(true);
+    });
+    it('uses explicit tsconfig path when provided', () => {
+        const tsconfigPath = path.join(CWD_WITH_TSCONFIG, 'tsconfig.json');
+        const opts = resolveCompilerOptions(tsconfigPath, CWD_WITH_TSCONFIG);
+        expect(opts.noEmit).toBe(true);
+        expect(opts.noLib).toBe(true);
+    });
+});
 describe('resolveTsconfigPath', () => {
     it('returns undefined for boolean true', () => {
         expect(resolveTsconfigPath({ typescript: true })).toBeUndefined();
@@ -97,6 +138,28 @@ describe('checkTypes', () => {
         expect(result.has('multi.ts#0')).toBe(false);
         expect(result.has('multi.ts#1')).toBe(true);
     }, 15000);
+    it('uses tsconfig from CWD_WITH_TSCONFIG when provided', async () => {
+        const variant = makeVariant({
+            id: 'with-tsconfig.ts#0',
+            file: '/nonexistent/with-tsconfig.ts',
+            code: 'const x: number = 1',
+        });
+        // Should not flag valid code even when cwd has tsconfig
+        const result = await checkTypes([variant], undefined, CWD_WITH_TSCONFIG);
+        expect(result.has('with-tsconfig.ts#0')).toBe(false);
+    }, 30000);
+    it('filters out mutant errors that were already in baseline', async () => {
+        // The original file also has a type error (same code as mutant) — no NEW errors
+        const variant = makeVariant({
+            id: 'baseline-error.ts#0',
+            file: '/nonexistent/baseline-error.ts',
+            // The mutant code is IDENTICAL to what we'd read as baseline (empty string)
+            // so any errors in the mutant were already in the baseline
+            code: 'const x: number = 1', // valid code - no new errors compared to empty baseline
+        });
+        const result = await checkTypes([variant], undefined, CWD_WITHOUT_TSCONFIG);
+        expect(result.has('baseline-error.ts#0')).toBe(false);
+    }, 15000);
     it('checks variants from different files independently', async () => {
         const validA = makeVariant({
             id: 'a.ts#0',
@@ -113,3 +176,27 @@ describe('checkTypes', () => {
         expect(result.has('b.ts#0')).toBe(true);
     }, 15000);
 });
+describe('checkFileSync', () => {
+    let tmpDir;
+    beforeAll(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-checkfilesync-'));
+    });
+    afterAll(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it('does not flag errors that are already present in the baseline file', async () => {
+        // Write a baseline file with a type error
+        const errorFile = path.join(tmpDir, 'baseline-err.ts');
+        await fs.writeFile(errorFile, 'const x: number = "bad string"', 'utf8');
+        const options = resolveCompilerOptions(undefined, tmpDir);
+        const variant = makeVariant({
+            id: 'baseline-err.ts#0',
+            file: errorFile,
+            // Mutant has the same type error as the baseline file
+            code: 'const x: number = "bad string"',
+        });
+        // The error exists in both baseline and mutant — no NEW errors, so not flagged
+        const ids = checkFileSync(options, errorFile, [variant]);
+        expect(ids).not.toContain('baseline-err.ts#0');
+    }, 15000);
+});

package/dist/runner/args.d.ts

@@ -11,7 +11,7 @@ import type { MutineerConfig } from '../types/config.js';
 export interface ParsedCliOptions {
     readonly configPath: string | undefined;
     readonly wantsChanged: boolean;
-    readonly wantsChangedWithDeps: boolean;
+    readonly wantsChangedWithImports: boolean;
     readonly wantsFull: boolean;
     readonly wantsOnlyCoveredLines: boolean;
     readonly wantsPerTestCoverage: boolean;

package/dist/runner/args.js

@@ -133,7 +133,7 @@ export function parseShardOption(args) {
 export function parseCliOptions(args, cfg) {
     const configPath = readStringFlag(args, '--config', '-c');
     const wantsChanged = args.includes('--changed');
-    const wantsChangedWithDeps = args.includes('--changed-with-deps');
+    const wantsChangedWithImports = args.includes('--changed-with-imports');
     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;
@@ -163,7 +163,7 @@ export function parseCliOptions(args, cfg) {
     return {
         configPath,
         wantsChanged,
-        wantsChangedWithDeps,
+        wantsChangedWithImports,
         wantsFull,
         wantsOnlyCoveredLines,
         wantsPerTestCoverage,

package/dist/runner/config.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createLogger } from '../utils/logger.js';
+import { toErrorMessage } from '../utils/errors.js';
 // Constants
 const CONFIG_FILENAMES = [
     'mutineer.config.ts',
@@ -71,8 +72,7 @@ export async function loadMutineerConfig(cwd, configPath) {
         return loadedConfig;
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to load config from ${configFile}: ${message}`);
+        throw new Error(`Failed to load config from ${configFile}: ${toErrorMessage(err)}`);
     }
 }
 /**
@@ -88,7 +88,6 @@ async function loadTypeScriptConfig(filePath) {
         return loaded?.config ?? {};
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`Cannot load TypeScript config. Ensure 'vite' is installed or rename to .js/.mjs:\n${message}`);
+        throw new Error(`Cannot load TypeScript config. Ensure 'vite' is installed or rename to .js/.mjs:\n${toErrorMessage(err)}`);
     }
 }

package/dist/runner/coverage-resolver.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { loadCoverageData, loadPerTestCoverageData, } from '../utils/coverage.js';
 import { isCoverageRequestedInArgs } from './vitest/index.js';
 import { createLogger } from '../utils/logger.js';
+import { toErrorMessage } from '../utils/errors.js';
 const log = createLogger('coverage-resolver');
 /**
  * Resolve all coverage-related configuration from CLI options, config, and adapter detection.
@@ -76,7 +77,7 @@ export async function loadCoverageAfterBaseline(resolution, cwd) {
             log.info(`Loaded coverage for ${coverageData.coveredLines.size} files`);
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+            const msg = toErrorMessage(err);
             log.warn(`Warning: Could not load coverage data: ${msg}`);
             log.warn('Continuing without coverage filtering.');
         }

package/dist/runner/discover.js

@@ -4,6 +4,7 @@ import { createRequire } from 'node:module';
 import fg from 'fast-glob';
 import { normalizePath } from '../utils/normalizePath.js';
 import { createLogger } from '../utils/logger.js';
+import { toErrorMessage } from '../utils/errors.js';
 const TEST_PATTERNS_DEFAULT = [
     '**/*.test.[jt]s?(x)',
     '**/*.spec.[jt]s?(x)',
@@ -99,8 +100,7 @@ async function createViteResolver(rootAbs, exts) {
                     typeof vue === 'function' ? [vue()] : [];
             }
             catch (err) {
-                const detail = err instanceof Error ? err.message : String(err);
-                log.warn(`Unable to load @vitejs/plugin-vue; Vue SFC imports may fail to resolve (${detail})`);
+                log.warn(`Unable to load @vitejs/plugin-vue; Vue SFC imports may fail to resolve (${toErrorMessage(err)})`);
             }
         }
     }

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

@@ -32,6 +32,15 @@ function makeAdapter(opts = {}) {
         cliArgs: opts.cliArgs ?? ['--changed'],
     });
 }
+function makeAdapterWithArgs(cliArgs) {
+    return createJestAdapter({
+        cwd: process.cwd(),
+        concurrency: 2,
+        timeoutMs: 1000,
+        config: { jestConfig: undefined },
+        cliArgs,
+    });
+}
 describe('Jest adapter', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -157,3 +166,163 @@ describe('Jest adapter', () => {
         }
     });
 });
+describe('Jest adapter additional coverage', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('strips --min-kill-percent= and --config= and -c= style args', () => {
+        const adapter = makeAdapterWithArgs([
+            '--min-kill-percent=50',
+            '--config=jest.config.ts',
+            '-c=x',
+            '--verbose',
+        ]);
+        expect(adapter).toBeDefined();
+    });
+    it('strips consumeNext args like --concurrency and --runner', () => {
+        const adapter = makeAdapterWithArgs([
+            '--concurrency',
+            '4',
+            '--runner',
+            'jest',
+        ]);
+        expect(adapter).toBeDefined();
+    });
+    it('runBaseline catches runCLI Error and returns false', async () => {
+        const adapter = makeAdapter();
+        runCLIMock.mockRejectedValueOnce(new Error('jest crashed'));
+        const ok = await adapter.runBaseline(['test.spec.ts'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(false);
+    });
+    it('runBaseline catches non-Error runCLI rejection and returns false', async () => {
+        const adapter = makeAdapter();
+        runCLIMock.mockRejectedValueOnce('string rejection');
+        const ok = await adapter.runBaseline(['test.spec.ts'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(false);
+    });
+    it('makeCapture handles Buffer chunks and callback signatures', async () => {
+        const adapter = makeAdapter();
+        runCLIMock.mockImplementationOnce(async () => {
+            // Buffer chunk (covers Buffer.isBuffer true branch)
+            process.stdout.write(Buffer.from('buffered'));
+            // Write with encoding arg (covers typeof encodingOrCb !== 'function' → use cb)
+            const cb1 = vi.fn();
+            process.stdout.write('str-with-encoding', 'utf8', cb1);
+            // Write with function as second arg (covers typeof encodingOrCb === 'function')
+            const cb2 = vi.fn();
+            process.stdout.write('str-with-cb', cb2);
+            return { results: { success: false } };
+        });
+        const writtenStdout = [];
+        const spy = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation((chunk) => {
+            writtenStdout.push(Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk));
+            return true;
+        });
+        await adapter.runBaseline(['test.spec.ts'], {
+            collectCoverage: false,
+            perTestCoverage: false,
+        });
+        spy.mockRestore();
+        expect(writtenStdout.join('')).toContain('buffered');
+    });
+    it('runMutant throws if init() not called', async () => {
+        const adapter = makeAdapter();
+        await expect(adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t'])).rejects.toThrow('JestAdapter not initialised');
+    });
+    it('runMutant returns error on pool.run() Error throw', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockRejectedValueOnce(new Error('pool crashed'));
+        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: 'pool crashed',
+        });
+    });
+    it('runMutant returns error on pool.run() non-Error throw', 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('runMutant maps escaped result', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: false, durationMs: 8 });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'escaped', durationMs: 8 });
+    });
+    it('runMutant maps timeout result', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({
+            killed: false,
+            durationMs: 30000,
+            error: 'timeout',
+        });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({
+            status: 'timeout',
+            durationMs: 30000,
+            error: 'timeout',
+        });
+    });
+    it('shutdown with pool calls pool.shutdown and nulls pool', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        await adapter.shutdown();
+        expect(poolInstance.shutdown).toHaveBeenCalledTimes(1);
+    });
+    it('shutdown with no pool is a no-op', async () => {
+        const adapter = makeAdapter();
+        await expect(adapter.shutdown()).resolves.toBeUndefined();
+    });
+    it('hasCoverageProvider returns false when jest not found in cwd', () => {
+        const adapter = makeAdapter({ cwd: os.tmpdir() });
+        // Resolving jest/package.json from os.tmpdir() should fail
+        const result = adapter.hasCoverageProvider();
+        expect(result).toBe(false);
+    });
+    it('detectCoverageConfig returns defaults when no jestConfig set', async () => {
+        const adapter = makeAdapter({ config: { jestConfig: undefined } });
+        const coverage = await adapter.detectCoverageConfig();
+        expect(coverage).toEqual({ perTestEnabled: false, coverageEnabled: false });
+    });
+    it('detectCoverageConfig returns false on unreadable config file', async () => {
+        const adapter = makeAdapter({
+            config: { jestConfig: '/nonexistent/path/jest.config.ts' },
+        });
+        const coverage = await adapter.detectCoverageConfig();
+        expect(coverage).toEqual({ perTestEnabled: false, coverageEnabled: false });
+    });
+    it('detectCoverageConfig detects coverageProvider pattern', async () => {
+        const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-jest-'));
+        const cfgPath = path.join(tmp, 'jest.config.ts');
+        await fs.writeFile(cfgPath, 'module.exports = { coverageProvider: "v8" }');
+        try {
+            const adapter = makeAdapter({
+                cwd: tmp,
+                config: { jestConfig: cfgPath },
+            });
+            const coverage = await adapter.detectCoverageConfig();
+            expect(coverage.coverageEnabled).toBe(true);
+        }
+        finally {
+            await fs.rm(tmp, { recursive: true, force: true });
+        }
+    });
+});