@mutineerjs/mutineer 0.1.0

package/dist/runner/adapters/jest/index.js

@@ -0,0 +1,216 @@
+/**
+ * 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/jest/pool.js';
+const require = createRequire(import.meta.url);
+/**
+ * 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;
+}
+// function getMutantFilePath(originalFile: string, mutantId: string): string {
+// 	const dir = path.dirname(originalFile)
+// 	const ext = path.extname(originalFile)
+// 	const basename = path.basename(originalFile, ext)
+// 	const mutineerDir = path.join(dir, '__mutineer__')
+// 	return path.join(mutineerDir, `${basename}_${mutantId.replace(/[^a-zA-Z0-9]/g, '_').slice(0, 20)}${ext}`)
+// }
+// function ensureMutineerDir(file: string): void {
+// 	const dir = path.dirname(file)
+// 	if (!fs) return
+// }
+// function createResolverModule(workerId: string): string {
+// 	const resolverPath = path.join(os.tmpdir(), `mutineer-jest-resolver-${workerId}.cjs`)
+// 	const resolverCode = `
+// const path = require('path');
+// const { defaultResolver } = require('jest-resolve');
+// module.exports = (request, options) => {
+//   const from = process.env.MUTINEER_REDIRECT_FROM;
+//   const to = process.env.MUTINEER_REDIRECT_TO;
+//   if (!from || !to) {
+//     return defaultResolver(request, options);
+//   }
+//   const normalizedFrom = path.resolve(from);
+//   const baseDir = options?.basedir ?? process.cwd();
+//   const candidate = path.resolve(baseDir, request);
+//   if (candidate === normalizedFrom || request === normalizedFrom) {
+//     return defaultResolver(to, options);
+//   }
+//   return defaultResolver(request, options);
+// };
+// `
+// 	fs.writeFile(resolverPath, resolverCode, 'utf8')
+// 		.catch(() => {
+// 			/* ignore */
+// 		})
+// 	return resolverPath
+// }
+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,
+            debug: this.options.debug,
+        });
+        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) {
+            if (this.options.debug) {
+                console.error('Failed to run Jest baseline', 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) {
+                return { status: 'error', durationMs: result.durationMs, error: result.error };
+            }
+            return {
+                status: result.killed ? 'killed' : 'escaped',
+                durationMs: result.durationMs,
+                error: result.error,
+            };
+        }
+        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/adapters/jest/worker-runtime.d.ts

@@ -0,0 +1,37 @@
+import type { MutantPayload } from '../types.js';
+import type { MutantRunSummary } from '../../../types/mutant.js';
+declare global {
+    var __mutineer_redirect__: {
+        from: string | null;
+        to: string | null;
+    } | undefined;
+}
+interface JestTestResult {
+    failureMessage?: string;
+}
+interface JestAggregatedResult {
+    success: boolean;
+    numTotalTests?: number;
+    testResults?: JestTestResult[];
+}
+export type JestRunCLI = (argv: Record<string, unknown>, projects: string[]) => Promise<{
+    results: JestAggregatedResult;
+    globalConfig: unknown;
+}>;
+export interface JestWorkerRuntimeOptions {
+    workerId: string;
+    cwd: string;
+    jestConfigPath?: string;
+    debug?: boolean;
+}
+export declare class JestWorkerRuntime {
+    private readonly options;
+    private resolverPath;
+    private readonly requireFromCwd;
+    constructor(options: JestWorkerRuntimeOptions);
+    init(): Promise<void>;
+    shutdown(): Promise<void>;
+    run(mutant: MutantPayload, tests: string[]): Promise<MutantRunSummary>;
+}
+export declare function createJestWorkerRuntime(options: JestWorkerRuntimeOptions): JestWorkerRuntime;
+export {};

package/dist/runner/adapters/jest/worker-runtime.js

@@ -0,0 +1,171 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { createRequire } from 'node:module';
+globalThis.__mutineer_redirect__ = { from: null, to: null };
+function getMutantFilePath(originalFile, mutantId) {
+    const dir = path.dirname(originalFile);
+    const ext = path.extname(originalFile);
+    const basename = path.basename(originalFile, ext);
+    const mutineerDir = path.join(dir, '__mutineer__');
+    if (!fs.existsSync(mutineerDir)) {
+        fs.mkdirSync(mutineerDir, { recursive: true });
+    }
+    const idMatch = mutantId.match(/#(\d+)$/);
+    const suffix = idMatch ? idMatch[1] : mutantId.replace(/[^a-zA-Z0-9]/g, '_').slice(0, 20);
+    return path.join(mutineerDir, `${basename}_${suffix}${ext}`);
+}
+function resolveDefaultResolver(cwdRequire) {
+    try {
+        cwdRequire('jest-resolve');
+        return 'jest-resolve';
+    }
+    catch {
+        return 'jest-resolve';
+    }
+}
+function createResolverModule(workerId, requireFromCwd, projectCwd) {
+    const resolverPath = path.join(os.tmpdir(), `mutineer-jest-resolver-${workerId}.cjs`);
+    // Resolve defaultResolver relative to the project so we don't require jest-resolve as a global dep
+    const defaultResolverPath = resolveDefaultResolver(requireFromCwd);
+    const projectPkgPath = path.join(projectCwd, 'package.json');
+    const resolverCode = `
+const path = require('path');
+const { createRequire } = require('module');
+const projectRequire = createRequire(${JSON.stringify(projectPkgPath)});
+const defaultResolverModule = projectRequire(${JSON.stringify(defaultResolverPath)});
+const defaultResolver = defaultResolverModule.default || defaultResolverModule;
+
+module.exports = (request, options) => {
+  const resolveWith = (req, opts) => {
+    const baseOpts = { ...opts, paths: [${JSON.stringify(projectCwd + '/node_modules')}] };
+    if (options?.defaultResolver) return options.defaultResolver(req, baseOpts);
+    return defaultResolver(req, baseOpts);
+  };
+
+  const from = process.env.MUTINEER_REDIRECT_FROM;
+  const to = process.env.MUTINEER_REDIRECT_TO;
+  const normalizedFrom = from ? path.resolve(from) : null;
+
+  const resolved = (() => {
+    try { return resolveWith(request, options); } catch { return null; }
+  })();
+  const baseDir = options?.basedir ?? process.cwd();
+  const candidate = path.resolve(baseDir, request);
+  const matchesFrom = (p) => {
+    if (!normalizedFrom) return false;
+    const abs = path.resolve(p);
+    if (abs === normalizedFrom) return true;
+    const withExt = path.extname(abs) ? abs : abs + path.extname(normalizedFrom);
+    return path.resolve(withExt) === normalizedFrom;
+  };
+
+  if (normalizedFrom && (matchesFrom(candidate) || (resolved && matchesFrom(resolved)))) {
+    return to;
+  }
+
+  return resolved ?? resolveWith(request, options);
+};
+`;
+    fs.writeFileSync(resolverPath, resolverCode, 'utf8');
+    return resolverPath;
+}
+async function loadRunCLI(requireFromCwd) {
+    try {
+        return requireFromCwd('@jest/core');
+    }
+    catch {
+        return import('@jest/core');
+    }
+}
+export class JestWorkerRuntime {
+    constructor(options) {
+        this.options = options;
+        this.resolverPath = null;
+        this.requireFromCwd = createRequire(path.join(options.cwd, 'package.json'));
+    }
+    async init() {
+        this.resolverPath = createResolverModule(this.options.workerId, this.requireFromCwd, this.options.cwd);
+    }
+    async shutdown() {
+        if (this.resolverPath) {
+            try {
+                fs.rmSync(this.resolverPath, { force: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+            this.resolverPath = null;
+        }
+    }
+    async run(mutant, tests) {
+        const start = Date.now();
+        if (!this.resolverPath) {
+            throw new Error('Resolver not initialized');
+        }
+        try {
+            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+            fs.writeFileSync(mutantPath, mutant.code, 'utf8');
+            const redirectFrom = path.resolve(mutant.file);
+            globalThis.__mutineer_redirect__ = { from: redirectFrom, to: mutantPath };
+            process.env.MUTINEER_REDIRECT_FROM = redirectFrom;
+            process.env.MUTINEER_REDIRECT_TO = mutantPath;
+            const cliOptions = {
+                _: [...tests],
+                $0: 'mutineer',
+                runInBand: true,
+                runTestsByPath: true,
+                testPathPattern: [...tests],
+                watch: false,
+                passWithNoTests: true,
+                resolver: this.resolverPath,
+                silent: true,
+            };
+            if (this.options.jestConfigPath) {
+                cliOptions.config = this.options.jestConfigPath;
+            }
+            const { runCLI } = await loadRunCLI(this.requireFromCwd);
+            const { results } = await runCLI(cliOptions, [this.options.cwd]);
+            const killed = !results.success;
+            const failureMessages = results.testResults
+                ?.map((r) => r.failureMessage)
+                .filter(Boolean)
+                .join('\n');
+            if (this.options.debug) {
+                console.error(`[jest-worker:${this.options.workerId}] runCLI success=${results.success} tests=${results.numTotalTests ?? 'n/a'}`);
+            }
+            return {
+                killed,
+                durationMs: Date.now() - start,
+                error: failureMessages || undefined,
+            };
+        }
+        catch (err) {
+            if (this.options.debug) {
+                console.error(`[jest-worker:${this.options.workerId}] runCLI error`, err);
+            }
+            return {
+                killed: true,
+                durationMs: Date.now() - start,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        finally {
+            const redirect = globalThis.__mutineer_redirect__;
+            globalThis.__mutineer_redirect__ = { from: null, to: null };
+            delete process.env.MUTINEER_REDIRECT_FROM;
+            delete process.env.MUTINEER_REDIRECT_TO;
+            try {
+                if (redirect?.to) {
+                    fs.rmSync(redirect.to, { force: true });
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+export function createJestWorkerRuntime(options) {
+    return new JestWorkerRuntime(options);
+}

package/dist/runner/adapters/jest-worker-runtime.d.ts

@@ -0,0 +1,37 @@
+import type { MutantPayload } from './types.js';
+import type { MutantRunSummary } from '../../types/mutant.js';
+declare global {
+    var __mutineer_redirect__: {
+        from: string | null;
+        to: string | null;
+    } | undefined;
+}
+interface JestTestResult {
+    failureMessage?: string;
+}
+interface JestAggregatedResult {
+    success: boolean;
+    numTotalTests?: number;
+    testResults?: JestTestResult[];
+}
+export type JestRunCLI = (argv: Record<string, unknown>, projects: string[]) => Promise<{
+    results: JestAggregatedResult;
+    globalConfig: unknown;
+}>;
+export interface JestWorkerRuntimeOptions {
+    workerId: string;
+    cwd: string;
+    jestConfigPath?: string;
+    debug?: boolean;
+}
+export declare class JestWorkerRuntime {
+    private readonly options;
+    private resolverPath;
+    private readonly requireFromCwd;
+    constructor(options: JestWorkerRuntimeOptions);
+    init(): Promise<void>;
+    shutdown(): Promise<void>;
+    run(mutant: MutantPayload, tests: string[]): Promise<MutantRunSummary>;
+}
+export declare function createJestWorkerRuntime(options: JestWorkerRuntimeOptions): JestWorkerRuntime;
+export {};

package/dist/runner/adapters/jest-worker-runtime.js

@@ -0,0 +1,171 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { createRequire } from 'node:module';
+globalThis.__mutineer_redirect__ = { from: null, to: null };
+function getMutantFilePath(originalFile, mutantId) {
+    const dir = path.dirname(originalFile);
+    const ext = path.extname(originalFile);
+    const basename = path.basename(originalFile, ext);
+    const mutineerDir = path.join(dir, '__mutineer__');
+    if (!fs.existsSync(mutineerDir)) {
+        fs.mkdirSync(mutineerDir, { recursive: true });
+    }
+    const idMatch = mutantId.match(/#(\d+)$/);
+    const suffix = idMatch ? idMatch[1] : mutantId.replace(/[^a-zA-Z0-9]/g, '_').slice(0, 20);
+    return path.join(mutineerDir, `${basename}_${suffix}${ext}`);
+}
+function resolveDefaultResolver(cwdRequire) {
+    try {
+        cwdRequire('jest-resolve');
+        return 'jest-resolve';
+    }
+    catch {
+        return 'jest-resolve';
+    }
+}
+function createResolverModule(workerId, requireFromCwd, projectCwd) {
+    const resolverPath = path.join(os.tmpdir(), `mutineer-jest-resolver-${workerId}.cjs`);
+    // Resolve defaultResolver relative to the project so we don't require jest-resolve as a global dep
+    const defaultResolverPath = resolveDefaultResolver(requireFromCwd);
+    const projectPkgPath = path.join(projectCwd, 'package.json');
+    const resolverCode = `
+const path = require('path');
+const { createRequire } = require('module');
+const projectRequire = createRequire(${JSON.stringify(projectPkgPath)});
+const defaultResolverModule = projectRequire(${JSON.stringify(defaultResolverPath)});
+const defaultResolver = defaultResolverModule.default || defaultResolverModule;
+
+module.exports = (request, options) => {
+  const resolveWith = (req, opts) => {
+    const baseOpts = { ...opts, paths: [${JSON.stringify(projectCwd + '/node_modules')}] };
+    if (options?.defaultResolver) return options.defaultResolver(req, baseOpts);
+    return defaultResolver(req, baseOpts);
+  };
+
+  const from = process.env.MUTINEER_REDIRECT_FROM;
+  const to = process.env.MUTINEER_REDIRECT_TO;
+  const normalizedFrom = from ? path.resolve(from) : null;
+
+  const resolved = (() => {
+    try { return resolveWith(request, options); } catch { return null; }
+  })();
+  const baseDir = options?.basedir ?? process.cwd();
+  const candidate = path.resolve(baseDir, request);
+  const matchesFrom = (p) => {
+    if (!normalizedFrom) return false;
+    const abs = path.resolve(p);
+    if (abs === normalizedFrom) return true;
+    const withExt = path.extname(abs) ? abs : abs + path.extname(normalizedFrom);
+    return path.resolve(withExt) === normalizedFrom;
+  };
+
+  if (normalizedFrom && (matchesFrom(candidate) || (resolved && matchesFrom(resolved)))) {
+    return to;
+  }
+
+  return resolved ?? resolveWith(request, options);
+};
+`;
+    fs.writeFileSync(resolverPath, resolverCode, 'utf8');
+    return resolverPath;
+}
+async function loadRunCLI(requireFromCwd) {
+    try {
+        return requireFromCwd('@jest/core');
+    }
+    catch {
+        return import('@jest/core');
+    }
+}
+export class JestWorkerRuntime {
+    constructor(options) {
+        this.options = options;
+        this.resolverPath = null;
+        this.requireFromCwd = createRequire(path.join(options.cwd, 'package.json'));
+    }
+    async init() {
+        this.resolverPath = createResolverModule(this.options.workerId, this.requireFromCwd, this.options.cwd);
+    }
+    async shutdown() {
+        if (this.resolverPath) {
+            try {
+                fs.rmSync(this.resolverPath, { force: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+            this.resolverPath = null;
+        }
+    }
+    async run(mutant, tests) {
+        const start = Date.now();
+        if (!this.resolverPath) {
+            throw new Error('Resolver not initialized');
+        }
+        try {
+            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+            fs.writeFileSync(mutantPath, mutant.code, 'utf8');
+            const redirectFrom = path.resolve(mutant.file);
+            globalThis.__mutineer_redirect__ = { from: redirectFrom, to: mutantPath };
+            process.env.MUTINEER_REDIRECT_FROM = redirectFrom;
+            process.env.MUTINEER_REDIRECT_TO = mutantPath;
+            const cliOptions = {
+                _: [...tests],
+                $0: 'mutineer',
+                runInBand: true,
+                runTestsByPath: true,
+                testPathPattern: [...tests],
+                watch: false,
+                passWithNoTests: true,
+                resolver: this.resolverPath,
+                silent: true,
+            };
+            if (this.options.jestConfigPath) {
+                cliOptions.config = this.options.jestConfigPath;
+            }
+            const { runCLI } = await loadRunCLI(this.requireFromCwd);
+            const { results } = await runCLI(cliOptions, [this.options.cwd]);
+            const killed = !results.success;
+            const failureMessages = results.testResults
+                ?.map((r) => r.failureMessage)
+                .filter(Boolean)
+                .join('\n');
+            if (this.options.debug) {
+                console.error(`[jest-worker:${this.options.workerId}] runCLI success=${results.success} tests=${results.numTotalTests ?? 'n/a'}`);
+            }
+            return {
+                killed,
+                durationMs: Date.now() - start,
+                error: failureMessages || undefined,
+            };
+        }
+        catch (err) {
+            if (this.options.debug) {
+                console.error(`[jest-worker:${this.options.workerId}] runCLI error`, err);
+            }
+            return {
+                killed: true,
+                durationMs: Date.now() - start,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        finally {
+            const redirect = globalThis.__mutineer_redirect__;
+            globalThis.__mutineer_redirect__ = { from: null, to: null };
+            delete process.env.MUTINEER_REDIRECT_FROM;
+            delete process.env.MUTINEER_REDIRECT_TO;
+            try {
+                if (redirect?.to) {
+                    fs.rmSync(redirect.to, { force: true });
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+export function createJestWorkerRuntime(options) {
+    return new JestWorkerRuntime(options);
+}

package/dist/runner/adapters/jest.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;