@mutineerjs/mutineer 0.1.0

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

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { createJestAdapter } from '../adapter.js';
+// Mock JestPool to avoid real processes
+let poolInstance = null;
+let poolCtorOpts = null;
+vi.mock('../pool.js', () => {
+    class MockPool {
+        constructor(opts) {
+            this.init = vi.fn();
+            this.run = vi.fn();
+            this.shutdown = vi.fn();
+            poolCtorOpts = opts;
+            poolInstance = this;
+        }
+    }
+    return { JestPool: MockPool };
+});
+// Mock runCLI from jest
+const runCLIMock = vi.fn();
+vi.mock('@jest/core', () => ({
+    runCLI: runCLIMock,
+}));
+function makeAdapter(opts = {}) {
+    return createJestAdapter({
+        cwd: opts.cwd ?? process.cwd(),
+        concurrency: opts.concurrency ?? 2,
+        timeoutMs: opts.timeoutMs ?? 1000,
+        config: opts.config ?? { jestConfig: undefined },
+        cliArgs: opts.cliArgs ?? ['--changed'],
+    });
+}
+describe('Jest adapter', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('initializes pool with override concurrency', async () => {
+        const adapter = makeAdapter();
+        await adapter.init(4);
+        expect(poolInstance?.init).toHaveBeenCalledTimes(1);
+        expect(poolCtorOpts.concurrency).toBe(4);
+    });
+    it('runs baseline via runCLI with coverage when requested', async () => {
+        const adapter = makeAdapter({
+            config: { jestConfig: 'jest.config.ts' },
+        });
+        runCLIMock.mockResolvedValueOnce({ results: { success: true } });
+        const ok = await adapter.runBaseline(['test-a'], {
+            collectCoverage: true,
+            perTestCoverage: false,
+        });
+        expect(ok).toBe(true);
+        expect(runCLIMock).toHaveBeenCalledTimes(1);
+        const args = runCLIMock.mock.calls[0][0];
+        expect(args.collectCoverage).toBe(true);
+        expect(args.coverageProvider).toBe('v8');
+        expect(args.config).toBe('jest.config.ts');
+    });
+    it('maps pool result to mutant status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 10 });
+        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 });
+    });
+    it('maps pool errors to error status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({
+            killed: false,
+            durationMs: 12,
+            error: 'crash',
+        });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'error', durationMs: 12, error: 'crash' });
+    });
+    it('maps killed with failure messages to killed status', async () => {
+        const adapter = makeAdapter();
+        await adapter.init();
+        poolInstance.run.mockResolvedValueOnce({
+            killed: true,
+            durationMs: 12,
+            error: 'expect(received).toBe(expected)',
+        });
+        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        expect(res).toEqual({ status: 'killed', durationMs: 12 });
+    });
+    it('detects coverage config from jest config file', 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 = { collectCoverage: true }');
+        try {
+            const adapter = makeAdapter({
+                cwd: tmp,
+                config: { jestConfig: 'jest.config.ts' },
+            });
+            const coverage = await adapter.detectCoverageConfig();
+            expect(coverage.coverageEnabled).toBe(true);
+            expect(coverage.perTestEnabled).toBe(false);
+        }
+        finally {
+            await fs.rm(tmp, { recursive: true, force: true });
+        }
+    });
+});

package/dist/runner/jest/adapter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Jest Test Runner Adapter
+ *
+ * Implements the TestRunnerAdapter interface for Jest using runCLI.
+ * Baseline runs are executed directly via runCLI; mutant runs are delegated
+ * to a pool of long-lived worker processes that also use runCLI with a
+ * redirect resolver to swap in mutated code.
+ */
+import type { TestRunnerAdapter, TestRunnerAdapterOptions, MutantPayload, MutantRunResult, BaselineOptions, CoverageConfig } from '../types.js';
+export declare class JestAdapter implements TestRunnerAdapter {
+    readonly name = "jest";
+    private readonly options;
+    private jestConfigPath?;
+    private pool;
+    private readonly requireFromCwd;
+    constructor(options: TestRunnerAdapterOptions);
+    init(concurrencyOverride?: number): Promise<void>;
+    runBaseline(tests: readonly string[], options: BaselineOptions): Promise<boolean>;
+    runMutant(mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
+    shutdown(): Promise<void>;
+    hasCoverageProvider(): boolean;
+    detectCoverageConfig(): Promise<CoverageConfig>;
+}
+export declare function createJestAdapter(options: TestRunnerAdapterOptions): JestAdapter;

package/dist/runner/jest/adapter.js

@@ -0,0 +1,191 @@
+/**
+ * Jest Test Runner Adapter
+ *
+ * Implements the TestRunnerAdapter interface for Jest using runCLI.
+ * Baseline runs are executed directly via runCLI; mutant runs are delegated
+ * to a pool of long-lived worker processes that also use runCLI with a
+ * redirect resolver to swap in mutated code.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+// import os from 'node:os'
+import { JestPool } from './pool.js';
+import { createLogger } from '../../utils/logger.js';
+const require = createRequire(import.meta.url);
+const log = createLogger('jest-adapter');
+/**
+ * Strip mutineer-specific CLI args that shouldn't be passed to Jest.
+ */
+function stripMutineerArgs(args) {
+    const out = [];
+    const consumeNext = new Set([
+        '--concurrency',
+        '--progress',
+        '--min-kill-percent',
+        '--config',
+        '-c',
+        '--coverage-file',
+        '--runner',
+    ]);
+    const dropExact = new Set([
+        '-m',
+        '--mutate',
+        '--changed',
+        '--changed-with-deps',
+        '--only-covered-lines',
+        '--per-test-coverage',
+        '--perTestCoverage',
+    ]);
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (dropExact.has(a))
+            continue;
+        if (consumeNext.has(a)) {
+            i++;
+            continue;
+        }
+        if (a.startsWith('--min-kill-percent='))
+            continue;
+        if (a.startsWith('--config=') || a.startsWith('-c='))
+            continue;
+        out.push(a);
+    }
+    return out;
+}
+async function loadRunCLI(requireFromCwd) {
+    try {
+        return requireFromCwd('@jest/core');
+    }
+    catch {
+        return import('@jest/core');
+    }
+}
+/**
+ * Build Jest runCLI options for the given mode.
+ */
+function buildJestCliOptions(tests, mode, jestConfigPath) {
+    const opts = {
+        _: [...tests],
+        $0: 'mutineer',
+        runInBand: true,
+        runTestsByPath: true,
+        watch: false,
+        passWithNoTests: true,
+        testPathPattern: [...tests],
+    };
+    if (jestConfigPath) {
+        opts.config = jestConfigPath;
+    }
+    if (mode === 'baseline-with-coverage') {
+        opts.coverage = true;
+        opts.collectCoverage = true;
+        opts.coverageProvider = 'v8';
+    }
+    return opts;
+}
+export class JestAdapter {
+    constructor(options) {
+        this.name = 'jest';
+        this.pool = null;
+        this.options = options;
+        this.jestConfigPath = options.config.jestConfig;
+        stripMutineerArgs(options.cliArgs);
+        this.requireFromCwd = createRequire(path.join(options.cwd, 'package.json'));
+    }
+    async init(concurrencyOverride) {
+        const workerCount = Math.max(1, concurrencyOverride ?? this.options.concurrency);
+        this.pool = new JestPool({
+            cwd: this.options.cwd,
+            concurrency: workerCount,
+            jestConfig: this.options.config.jestConfig,
+            timeoutMs: this.options.timeoutMs,
+        });
+        await this.pool.init();
+    }
+    async runBaseline(tests, options) {
+        const mode = options.collectCoverage
+            ? 'baseline-with-coverage'
+            : 'baseline';
+        const cliOptions = buildJestCliOptions(tests, mode, this.jestConfigPath);
+        try {
+            const { runCLI } = await loadRunCLI(this.requireFromCwd);
+            const { results } = await runCLI(cliOptions, [this.options.cwd]);
+            return results.success;
+        }
+        catch (err) {
+            log.debug('Failed to run Jest baseline: ' +
+                (err instanceof Error ? err.message : String(err)));
+            return false;
+        }
+    }
+    async runMutant(mutant, tests) {
+        if (!this.pool) {
+            throw new Error('JestAdapter not initialized. Call init() first.');
+        }
+        try {
+            const result = await this.pool.run(mutant, [...tests]);
+            if (result.error === 'timeout') {
+                return {
+                    status: 'timeout',
+                    durationMs: result.durationMs,
+                    error: result.error,
+                };
+            }
+            if (result.error && !result.killed) {
+                return {
+                    status: 'error',
+                    durationMs: result.durationMs,
+                    error: result.error,
+                };
+            }
+            return {
+                status: result.killed ? 'killed' : 'escaped',
+                durationMs: result.durationMs,
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                durationMs: 0,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async shutdown() {
+        if (this.pool) {
+            await this.pool.shutdown();
+            this.pool = null;
+        }
+    }
+    hasCoverageProvider() {
+        try {
+            require.resolve('jest/package.json', { paths: [this.options.cwd] });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async detectCoverageConfig() {
+        const configPath = this.options.config.jestConfig;
+        if (!configPath) {
+            return { perTestEnabled: false, coverageEnabled: false };
+        }
+        try {
+            const abs = path.isAbsolute(configPath)
+                ? configPath
+                : path.join(this.options.cwd, configPath);
+            const content = await fs.readFile(abs, 'utf8');
+            const coverageEnabled = /collectCoverage\s*:\s*true/.test(content) ||
+                /coverageProvider\s*:/.test(content);
+            return { perTestEnabled: false, coverageEnabled };
+        }
+        catch {
+            return { perTestEnabled: false, coverageEnabled: false };
+        }
+    }
+}
+export function createJestAdapter(options) {
+    return new JestAdapter(options);
+}

package/dist/runner/jest/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Jest Test Runner
+ *
+ * Complete Jest test runner implementation including adapter, pool, and worker runtime.
+ */
+export { JestAdapter, createJestAdapter } from './adapter.js';
+export { JestPool, runWithJestPool, type JestPoolOptions } from './pool.js';
+export type { MutantPayload, MutantRunResult, MutantRunSummary, } from '../../types/mutant.js';

package/dist/runner/jest/index.js

@@ -0,0 +1,7 @@
+/**
+ * Jest Test Runner
+ *
+ * Complete Jest test runner implementation including adapter, pool, and worker runtime.
+ */
+export { JestAdapter, createJestAdapter } from './adapter.js';
+export { JestPool, runWithJestPool } from './pool.js';

package/dist/runner/jest/pool.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter } from 'node:events';
+import type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../types/mutant.js';
+declare class JestWorker extends EventEmitter {
+    private readonly cwd;
+    private readonly jestConfig?;
+    readonly id: string;
+    private process;
+    private pendingTask;
+    private ready;
+    private shuttingDown;
+    constructor(id: string, cwd: string, jestConfig?: string | undefined);
+    start(): Promise<void>;
+    private handleMessage;
+    private handleExit;
+    isReady(): boolean;
+    isBusy(): boolean;
+    run(mutant: MutantPayload, tests: string[], timeoutMs?: number): Promise<MutantRunSummary>;
+    shutdown(): Promise<void>;
+    kill(): void;
+}
+export interface JestPoolOptions {
+    cwd: string;
+    concurrency: number;
+    jestConfig?: string;
+    timeoutMs?: number;
+    createWorker?: (id: string, opts: {
+        cwd: string;
+        jestConfig?: string;
+    }) => JestWorker;
+}
+export declare class JestPool {
+    private workers;
+    private availableWorkers;
+    private waitingTasks;
+    private readonly options;
+    private initialized;
+    private shuttingDown;
+    constructor(options: JestPoolOptions);
+    init(): Promise<void>;
+    private handleWorkerExit;
+    private acquireWorker;
+    private releaseWorker;
+    run(mutant: MutantPayload, tests: string[]): Promise<MutantRunSummary>;
+    shutdown(): Promise<void>;
+}
+export declare function runWithJestPool(pool: JestPool, mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
+export type { MutantPayload, MutantRunResult, MutantRunSummary, } from '../../types/mutant.js';

package/dist/runner/jest/pool.js

@@ -0,0 +1,307 @@
+import { fork } from 'node:child_process';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { EventEmitter } from 'node:events';
+import { createLogger, DEBUG } from '../../utils/logger.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const workerLog = createLogger('JestWorker');
+const poolLog = createLogger('JestPool');
+class JestWorker extends EventEmitter {
+    constructor(id, cwd, jestConfig) {
+        super();
+        this.cwd = cwd;
+        this.jestConfig = jestConfig;
+        this.process = null;
+        this.pendingTask = null;
+        this.ready = false;
+        this.shuttingDown = false;
+        this.id = id;
+    }
+    async start() {
+        const workerJs = path.join(__dirname, 'worker.js');
+        const workerMts = path.join(__dirname, 'worker.mjs');
+        const workerTs = path.join(__dirname, 'worker.mts');
+        const workerScript = fs.existsSync(workerJs)
+            ? workerJs
+            : fs.existsSync(workerMts)
+                ? workerMts
+                : workerTs;
+        const env = {
+            ...process.env,
+            MUTINEER_WORKER_ID: this.id,
+            MUTINEER_CWD: this.cwd,
+            ...(this.jestConfig ? { MUTINEER_JEST_CONFIG: this.jestConfig } : {}),
+            ...(DEBUG ? { MUTINEER_DEBUG: '1' } : {}),
+        };
+        workerLog.debug(`[${this.id}] Starting Jest worker process`);
+        this.process = fork(workerScript, [], {
+            cwd: this.cwd,
+            env,
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            execArgv: [
+                '--experimental-strip-types',
+                '--experimental-transform-types',
+                '--no-warnings',
+            ],
+        });
+        this.process.stderr?.on('data', (data) => {
+            if (DEBUG) {
+                process.stderr.write(`[jest-worker-${this.id}] ${data}`);
+            }
+        });
+        this.process.on('message', (msg) => this.handleMessage(msg));
+        this.process.on('error', (err) => {
+            workerLog.debug(`[${this.id}] Process error: ${err.message}`);
+            this.handleExit(1);
+        });
+        this.process.on('exit', (code) => {
+            workerLog.debug(`[${this.id}] Process exited with code ${code}`);
+            this.handleExit(code ?? 1);
+        });
+        await new Promise((resolve, reject) => {
+            const timeoutMs = 60_000;
+            const timeout = setTimeout(() => {
+                reject(new Error(`Worker ${this.id} did not become ready in time (${timeoutMs}ms)`));
+            }, timeoutMs);
+            this.once('ready', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.once('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    handleMessage(raw) {
+        const msg = raw;
+        if (msg.type === 'ready') {
+            this.ready = true;
+            this.emit('ready');
+            return;
+        }
+        if (msg.type === 'result') {
+            if (this.pendingTask) {
+                const { resolve, timeoutHandle } = this.pendingTask;
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.pendingTask = null;
+                resolve({
+                    killed: msg.killed ?? true,
+                    durationMs: msg.durationMs ?? 0,
+                    error: msg.error,
+                });
+            }
+            return;
+        }
+        if (msg.type === 'shutdown') {
+            this.emit('shutdown');
+            return;
+        }
+    }
+    handleExit(code) {
+        this.ready = false;
+        if (this.pendingTask && !this.shuttingDown) {
+            const { reject, timeoutHandle } = this.pendingTask;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            this.pendingTask = null;
+            reject(new Error(`Worker exited unexpectedly with code ${code}`));
+        }
+        this.emit('exit', code);
+    }
+    isReady() {
+        return this.ready && this.process !== null && !this.shuttingDown;
+    }
+    isBusy() {
+        return this.pendingTask !== null;
+    }
+    async run(mutant, tests, timeoutMs = 10_000) {
+        if (!this.isReady()) {
+            throw new Error(`Worker ${this.id} is not ready`);
+        }
+        if (this.isBusy()) {
+            throw new Error(`Worker ${this.id} is busy`);
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                if (this.pendingTask) {
+                    this.pendingTask = null;
+                    this.kill();
+                    resolve({ killed: true, durationMs: timeoutMs, error: 'timeout' });
+                }
+            }, timeoutMs);
+            this.pendingTask = { resolve, reject, timeoutHandle };
+            this.process.send?.({ type: 'run', mutant, tests });
+        });
+    }
+    async shutdown() {
+        if (!this.process || this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this.kill();
+                resolve();
+            }, 5000);
+            this.once('shutdown', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.process.send?.({ type: 'shutdown' });
+        });
+    }
+    kill() {
+        if (this.process) {
+            try {
+                this.process.kill('SIGKILL');
+            }
+            catch {
+                // ignore
+            }
+            this.process = null;
+        }
+        this.ready = false;
+    }
+}
+export class JestPool {
+    constructor(options) {
+        this.workers = [];
+        this.availableWorkers = [];
+        this.waitingTasks = [];
+        this.initialized = false;
+        this.shuttingDown = false;
+        this.options = {
+            cwd: options.cwd,
+            concurrency: options.concurrency,
+            jestConfig: options.jestConfig,
+            timeoutMs: options.timeoutMs ?? 10_000,
+            createWorker: options.createWorker,
+        };
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        const startPromises = [];
+        for (let i = 0; i < this.options.concurrency; i++) {
+            const worker = this.options.createWorker?.(`w${i}`, {
+                cwd: this.options.cwd,
+                jestConfig: this.options.jestConfig,
+            }) ?? new JestWorker(`w${i}`, this.options.cwd, this.options.jestConfig);
+            worker.on('exit', () => {
+                if (!this.shuttingDown) {
+                    this.handleWorkerExit(worker);
+                }
+            });
+            this.workers.push(worker);
+            startPromises.push(worker.start().then(() => {
+                this.availableWorkers.push(worker);
+            }));
+        }
+        await Promise.all(startPromises);
+        this.initialized = true;
+    }
+    handleWorkerExit(worker) {
+        const availIdx = this.availableWorkers.indexOf(worker);
+        if (availIdx >= 0) {
+            this.availableWorkers.splice(availIdx, 1);
+        }
+        const newWorker = this.options.createWorker?.(worker.id, {
+            cwd: this.options.cwd,
+            jestConfig: this.options.jestConfig,
+        }) ?? new JestWorker(worker.id, this.options.cwd, this.options.jestConfig);
+        const idx = this.workers.indexOf(worker);
+        if (idx >= 0) {
+            this.workers[idx] = newWorker;
+        }
+        newWorker.on('exit', () => {
+            if (!this.shuttingDown) {
+                this.handleWorkerExit(newWorker);
+            }
+        });
+        newWorker
+            .start()
+            .then(() => {
+            this.releaseWorker(newWorker);
+        })
+            .catch((err) => {
+            poolLog.debug(`Failed to restart worker ${newWorker.id}: ${err}`);
+        });
+    }
+    async acquireWorker() {
+        const worker = this.availableWorkers.shift();
+        if (worker) {
+            return worker;
+        }
+        return new Promise((resolve) => {
+            this.waitingTasks.push(resolve);
+        });
+    }
+    releaseWorker(worker) {
+        const waiting = this.waitingTasks.shift();
+        if (waiting) {
+            waiting(worker);
+            return;
+        }
+        if (worker.isReady()) {
+            this.availableWorkers.push(worker);
+        }
+    }
+    async run(mutant, tests) {
+        if (!this.initialized) {
+            throw new Error('Pool not initialized. Call init() first.');
+        }
+        if (this.shuttingDown) {
+            throw new Error('Pool is shutting down');
+        }
+        const worker = await this.acquireWorker();
+        try {
+            const result = await worker.run(mutant, tests, this.options.timeoutMs);
+            poolLog.debug(`worker ${worker.id} returned killed=${result.killed} error=${result.error ?? 'none'} duration=${result.durationMs}`);
+            return result;
+        }
+        finally {
+            this.releaseWorker(worker);
+        }
+    }
+    async shutdown() {
+        if (this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        await Promise.all(this.workers.map((w) => w.shutdown()));
+        this.workers = [];
+        this.availableWorkers = [];
+        this.initialized = false;
+    }
+}
+export async function runWithJestPool(pool, mutant, tests) {
+    try {
+        const result = await pool.run(mutant, [...tests]);
+        if (result.error === 'timeout') {
+            return {
+                status: 'timeout',
+                durationMs: result.durationMs,
+                error: result.error,
+            };
+        }
+        if (result.error && !result.killed) {
+            return {
+                status: 'error',
+                durationMs: result.durationMs,
+                error: result.error,
+            };
+        }
+        return {
+            status: result.killed ? 'killed' : 'escaped',
+            durationMs: result.durationMs,
+        };
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            durationMs: 0,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}