@mutineerjs/mutineer 0.1.0

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

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+import * as childProcess from 'node:child_process';
+import * as readline from 'node:readline';
+import { VitestPool, runWithPool } from '../pool.js';
+vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
+vi.mock('node:readline', () => ({ createInterface: vi.fn() }));
+describe('VitestPool', () => {
+    const mockProcesses = [];
+    const rlEmitters = [];
+    const fakeWorkers = [];
+    beforeEach(() => {
+        mockProcesses.length = 0;
+        rlEmitters.length = 0;
+        vi.mocked(childProcess.spawn).mockImplementation(() => {
+            const proc = new EventEmitter();
+            proc.stdout = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.stdin = {
+                writes: [],
+                write: (chunk) => {
+                    proc.stdin.writes.push(chunk);
+                },
+            };
+            proc.kill = vi.fn();
+            mockProcesses.push(proc);
+            return proc;
+        });
+        vi.mocked(readline.createInterface).mockImplementation(() => {
+            const rl = new EventEmitter();
+            rlEmitters.push(rl);
+            return rl;
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('runs a mutant through a worker and returns result', async () => {
+        const pool = new VitestPool({
+            cwd: process.cwd(),
+            concurrency: 1,
+            timeoutMs: 5000,
+            createWorker: (id, opts) => {
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn().mockReturnValue(true);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi
+                    .fn()
+                    .mockImplementation(async () => ({ killed: true, durationMs: 42 }));
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                fakeWorkers.push(worker);
+                return worker;
+            },
+        });
+        await pool.init();
+        const mutant = {
+            id: '1',
+            name: 'mutant',
+            file: 'foo.ts',
+            code: 'x',
+            line: 1,
+            col: 1,
+        };
+        const tests = ['foo.spec.ts'];
+        const runPromise = pool.run(mutant, tests);
+        const result = await runPromise;
+        expect(result).toEqual({ killed: true, durationMs: 42, error: undefined });
+        expect(fakeWorkers[0].run).toHaveBeenCalledWith(mutant, tests, 5000);
+        await pool.shutdown();
+    });
+    it('maps runWithPool results to escaped when not killed', async () => {
+        const mockPool = {
+            run: vi.fn().mockResolvedValue({ killed: false, durationMs: 7 }),
+        };
+        const mutant = {
+            id: '2',
+            name: 'm',
+            file: 'bar.ts',
+            code: 'y',
+            line: 2,
+            col: 3,
+        };
+        const tests = ['bar.spec.ts'];
+        const result = await runWithPool(mockPool, mutant, tests);
+        expect(result).toEqual({ status: 'escaped', durationMs: 7 });
+        expect(mockPool.run).toHaveBeenCalledWith(mutant, ['bar.spec.ts']);
+    });
+    it('maps runWithPool errors to error status', async () => {
+        const mockPool = {
+            run: vi.fn().mockRejectedValue(new Error('boom')),
+        };
+        const mutant = {
+            id: '3',
+            name: 'err',
+            file: 'baz.ts',
+            code: 'z',
+            line: 3,
+            col: 4,
+        };
+        const result = await runWithPool(mockPool, mutant, []);
+        expect(result.status).toBe('error');
+    });
+});

package/dist/runner/vitest/__tests__/redirect-loader.spec.d.ts

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

package/dist/runner/vitest/__tests__/redirect-loader.spec.js

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { pathToFileURL } from 'node:url';
+import { resolve as poolResolve } from '../redirect-loader.js';
+describe('pool-redirect-loader resolve', () => {
+    afterEach(() => {
+        ;
+        globalThis.__mutineer_redirect__ = undefined;
+        vi.restoreAllMocks();
+    });
+    it('resolves .js to .ts in the same directory', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        const tsFile = path.join(tmpDir, 'src', 'foo.ts');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(tsFile, 'export const foo = 1', 'utf8');
+        try {
+            const nextResolve = vi.fn();
+            const result = await poolResolve('./foo.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).not.toHaveBeenCalled();
+            expect(result).not.toBeNull();
+            expect(result.shortCircuit).toBe(true);
+            expect(result.url).toBe(pathToFileURL(tsFile).href);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('redirects to mutated file when target matches', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        const fromPath = path.join(tmpDir, 'src', 'target.ts');
+        const mutatedPath = path.join(tmpDir, 'mutated.ts');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(fromPath, 'export const target = true', 'utf8');
+        await fs.writeFile(mutatedPath, 'export const mutated = true', 'utf8');
+        try {
+            ;
+            globalThis.__mutineer_redirect__ = {
+                from: fromPath,
+                to: mutatedPath,
+            };
+            const nextResolve = vi.fn();
+            const result = await poolResolve('./target.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).not.toHaveBeenCalled();
+            expect(result).not.toBeNull();
+            expect(result.shortCircuit).toBe(true);
+            expect(result.url).toBe(pathToFileURL(mutatedPath).href);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('redirects after delegated resolution', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
+        const parentFile = path.join(tmpDir, 'src', 'index.ts');
+        const fromPath = path.join(tmpDir, 'src', 'delegated.ts');
+        const mutatedPath = path.join(tmpDir, 'mutated.ts');
+        await fs.mkdir(path.dirname(parentFile), { recursive: true });
+        await fs.writeFile(parentFile, 'export {}', 'utf8');
+        await fs.writeFile(fromPath, 'export const delegated = true', 'utf8');
+        await fs.writeFile(mutatedPath, 'export const mutated = true', 'utf8');
+        try {
+            ;
+            globalThis.__mutineer_redirect__ = {
+                from: fromPath,
+                to: mutatedPath,
+            };
+            const nextResolve = vi.fn().mockResolvedValue({
+                url: pathToFileURL(fromPath).href,
+                shortCircuit: false,
+            });
+            const result = await poolResolve('./delegated', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
+            expect(nextResolve).toHaveBeenCalledOnce();
+            expect(result).not.toBeNull();
+            expect(result.shortCircuit).toBe(true);
+            expect(result.url).toBe(pathToFileURL(mutatedPath).href);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/runner/vitest/__tests__/worker-runtime.spec.d.ts

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

package/dist/runner/vitest/__tests__/worker-runtime.spec.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createVitestWorkerRuntime } from '../worker-runtime.js';
+const initFn = vi.fn();
+const closeFn = vi.fn();
+const runSpecsFn = vi.fn();
+const invalidateFn = vi.fn();
+const getProjectByNameFn = vi.fn();
+vi.mock('vitest/node', () => ({
+    createVitest: vi.fn(async () => ({
+        init: initFn,
+        close: closeFn,
+        runTestSpecifications: runSpecsFn,
+        invalidateFile: invalidateFn,
+        getProjectByName: getProjectByNameFn,
+    })),
+}));
+describe('VitestWorkerRuntime', () => {
+    const tmpFiles = [];
+    beforeEach(() => {
+        vi.clearAllMocks();
+        getProjectByNameFn.mockReturnValue({
+            createSpecification: (file) => ({ moduleId: file }),
+        });
+        runSpecsFn.mockResolvedValue({
+            testModules: [{ moduleId: 'a', ok: () => false }],
+        });
+    });
+    afterEach(() => {
+        for (const f of tmpFiles.splice(0)) {
+            try {
+                fs.rmSync(f, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    });
+    it('runs specs and reports kill based on results', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w1', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#1',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(tmp, 'test.ts')]);
+        expect(initFn).toHaveBeenCalled();
+        expect(runSpecsFn).toHaveBeenCalled();
+        expect(result.killed).toBe(true);
+        expect(fs.existsSync(path.join(tmp, 'src', '__mutineer__'))).toBe(false);
+        await runtime.shutdown();
+    });
+    it('returns escaped when no specs produced', async () => {
+        getProjectByNameFn.mockReturnValue({ createSpecification: () => null });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w2', cwd: tmp });
+        await runtime.init();
+        const result = await runtime.run({
+            id: 'mut#2',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        }, [path.join(tmp, 'test.ts')]);
+        expect(result.killed).toBe(false);
+        await runtime.shutdown();
+    });
+});

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

@@ -0,0 +1,33 @@
+/**
+ * Vitest Test Runner Adapter
+ *
+ * Implements the TestRunnerAdapter interface for Vitest.
+ * Handles baseline test runs, mutant execution via worker pool,
+ * and coverage configuration detection.
+ */
+import type { TestRunnerAdapter, TestRunnerAdapterOptions, MutantPayload, MutantRunResult, BaselineOptions, CoverageConfig } from '../types.js';
+/**
+ * Vitest adapter implementation.
+ */
+export declare class VitestAdapter implements TestRunnerAdapter {
+    readonly name = "vitest";
+    private readonly options;
+    private readonly vitestPath;
+    private pool;
+    private baseArgs;
+    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>;
+}
+/**
+ * Check if coverage is requested via CLI args.
+ */
+export declare function isCoverageRequestedInArgs(args: string[]): boolean;
+/**
+ * Factory function for creating VitestAdapter instances.
+ */
+export declare function createVitestAdapter(options: TestRunnerAdapterOptions): VitestAdapter;

package/dist/runner/vitest/adapter.js

@@ -0,0 +1,277 @@
+/**
+ * Vitest Test Runner Adapter
+ *
+ * Implements the TestRunnerAdapter interface for Vitest.
+ * Handles baseline test runs, mutant execution via worker pool,
+ * and coverage configuration detection.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { VitestPool } from './pool.js';
+import { createLogger } from '../../utils/logger.js';
+const require = createRequire(import.meta.url);
+const log = createLogger('vitest-adapter');
+/**
+ * Resolve the Vitest CLI entry point.
+ */
+function resolveVitestPath() {
+    try {
+        return require.resolve('vitest/vitest.mjs');
+    }
+    catch {
+        const pkgJson = require.resolve('vitest/package.json');
+        return path.join(path.dirname(pkgJson), 'vitest.mjs');
+    }
+}
+/**
+ * Strip mutineer-specific CLI args that shouldn't be passed to Vitest.
+ */
+function stripMutineerArgs(args) {
+    const out = [];
+    const consumeNext = new Set([
+        '--concurrency',
+        '--progress',
+        '--min-kill-percent',
+        '--config',
+        '-c',
+        '--coverage-file',
+    ]);
+    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;
+}
+/**
+ * Ensure the Vitest config arg is included if specified.
+ */
+function ensureConfigArg(args, vitestConfig, cwd) {
+    if (!vitestConfig)
+        return args;
+    if (args.some((a) => a === '--config' ||
+        a === '-c' ||
+        a.startsWith('--config=') ||
+        a.startsWith('-c='))) {
+        return args;
+    }
+    const resolved = cwd ? path.resolve(cwd, vitestConfig) : vitestConfig;
+    return [...args, '--config', resolved];
+}
+/**
+ * Build Vitest CLI arguments for the given mode.
+ */
+function buildVitestArgs(args, mode) {
+    const result = [...args];
+    if (!result.includes('run') && !result.includes('--run'))
+        result.unshift('run');
+    if (!result.some((a) => a.startsWith('--watch')))
+        result.push('--watch=false');
+    if (!result.some((a) => a.startsWith('--passWithNoTests')))
+        result.push('--passWithNoTests');
+    if (mode === 'baseline-with-coverage') {
+        if (!result.some((a) => a.startsWith('--coverage'))) {
+            result.push('--coverage.enabled=true', '--coverage.reporter=json');
+        }
+        if (!result.some((a) => a.startsWith('--coverage.perTest='))) {
+            result.push('--coverage.perTest=true');
+        }
+    }
+    return result;
+}
+/**
+ * Vitest adapter implementation.
+ */
+export class VitestAdapter {
+    constructor(options) {
+        this.name = 'vitest';
+        this.pool = null;
+        this.baseArgs = [];
+        this.options = options;
+        this.vitestPath = resolveVitestPath();
+        // Prepare base args by stripping mutineer-specific flags
+        const stripped = stripMutineerArgs(options.cliArgs);
+        this.baseArgs = ensureConfigArg(stripped, options.config.vitestConfig, options.cwd);
+    }
+    async init(concurrencyOverride) {
+        const workerCount = Math.max(1, concurrencyOverride ?? this.options.concurrency);
+        this.pool = new VitestPool({
+            cwd: this.options.cwd,
+            concurrency: workerCount,
+            vitestConfig: this.options.config.vitestConfig,
+            timeoutMs: this.options.timeoutMs,
+        });
+        await this.pool.init();
+    }
+    async runBaseline(tests, options) {
+        const mode = options.collectCoverage
+            ? 'baseline-with-coverage'
+            : 'baseline';
+        const args = buildVitestArgs(this.baseArgs, mode);
+        return new Promise((resolve) => {
+            const env = { ...process.env };
+            env.VITEST_WATCH = 'false';
+            if (!env.CI)
+                env.CI = '1';
+            const child = spawn(process.execPath, [this.vitestPath, ...args, ...tests], {
+                cwd: this.options.cwd,
+                stdio: ['ignore', 'inherit', 'inherit'],
+                env,
+            });
+            child.on('error', (err) => {
+                log.debug('Failed to spawn vitest process: ' + err.message);
+                resolve(false);
+            });
+            child.on('exit', (code) => {
+                resolve(code === 0);
+            });
+        });
+    }
+    async runMutant(mutant, tests) {
+        if (!this.pool) {
+            throw new Error('VitestAdapter 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('@vitest/coverage-v8/package.json', {
+                paths: [this.options.cwd],
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async detectCoverageConfig() {
+        const configPath = this.options.config.vitestConfig;
+        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 perTestEnabled = /perTest\s*:\s*true/.test(content);
+            let coverageEnabled = false;
+            if (!/coverage\s*\.\s*enabled\s*:\s*false/.test(content) &&
+                !/coverage\s*:\s*false/.test(content)) {
+                coverageEnabled = /coverage\s*:/.test(content);
+            }
+            return { perTestEnabled, coverageEnabled };
+        }
+        catch {
+            return { perTestEnabled: false, coverageEnabled: false };
+        }
+    }
+}
+/**
+ * Check if coverage is requested via CLI args.
+ */
+export function isCoverageRequestedInArgs(args) {
+    let requested = false;
+    let disabled = false;
+    const isFalsey = (v) => typeof v === 'string' && /^(false|0|off)$/i.test(v);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--no-coverage') {
+            disabled = true;
+            continue;
+        }
+        if (arg === '--coverage') {
+            requested = true;
+            continue;
+        }
+        if (arg === '--coverage.enabled') {
+            const next = args[i + 1];
+            if (isFalsey(next))
+                disabled = true;
+            else
+                requested = true;
+            continue;
+        }
+        if (arg.startsWith('--coverage.enabled=')) {
+            const val = arg.slice('--coverage.enabled='.length);
+            if (isFalsey(val))
+                disabled = true;
+            else
+                requested = true;
+            continue;
+        }
+        if (arg.startsWith('--coverage=')) {
+            const val = arg.slice('--coverage='.length);
+            if (isFalsey(val))
+                disabled = true;
+            else
+                requested = true;
+            continue;
+        }
+        if (arg.startsWith('--coverage.')) {
+            requested = true;
+            continue;
+        }
+    }
+    return requested && !disabled;
+}
+/**
+ * Factory function for creating VitestAdapter instances.
+ */
+export function createVitestAdapter(options) {
+    return new VitestAdapter(options);
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Vitest Test Runner
+ *
+ * Complete Vitest test runner implementation including adapter, pool, worker runtime,
+ * and Vitest-specific plugin/loader utilities.
+ */
+export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs, } from './adapter.js';
+export { VitestPool, runWithPool, type VitestPoolOptions } from './pool.js';
+export { poolMutineerPlugin } from './plugin.js';
+export { resolve as poolRedirectResolve } from './redirect-loader.js';
+export type { MutantPayload, MutantRunResult, MutantRunSummary, } from '../../types/mutant.js';

package/dist/runner/vitest/index.js

@@ -0,0 +1,10 @@
+/**
+ * Vitest Test Runner
+ *
+ * Complete Vitest test runner implementation including adapter, pool, worker runtime,
+ * and Vitest-specific plugin/loader utilities.
+ */
+export { VitestAdapter, createVitestAdapter, isCoverageRequestedInArgs, } from './adapter.js';
+export { VitestPool, runWithPool } from './pool.js';
+export { poolMutineerPlugin } from './plugin.js';
+export { resolve as poolRedirectResolve } from './redirect-loader.js';

package/dist/runner/vitest/plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Vite plugin for persistent Vitest workers.
+ *
+ * Unlike the standard viteMutineerPlugin which reads env vars once at init,
+ * this plugin reads from a global redirect map that can be updated dynamically
+ * between test runs.
+ *
+ * The worker process sets globalThis.__mutineer_redirect__ before each test run,
+ * and this plugin intercepts module loading to return the mutated code.
+ */
+import type { PluginOption } from 'vite';
+export declare function poolMutineerPlugin(): PluginOption;

package/dist/runner/vitest/plugin.js

@@ -0,0 +1,49 @@
+/**
+ * Vite plugin for persistent Vitest workers.
+ *
+ * Unlike the standard viteMutineerPlugin which reads env vars once at init,
+ * this plugin reads from a global redirect map that can be updated dynamically
+ * between test runs.
+ *
+ * The worker process sets globalThis.__mutineer_redirect__ before each test run,
+ * and this plugin intercepts module loading to return the mutated code.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getRedirect } from '../shared/index.js';
+import { createLogger } from '../../utils/logger.js';
+const log = createLogger('mutineer:swap');
+export function poolMutineerPlugin() {
+    return {
+        name: 'mutineer:swap',
+        enforce: 'pre',
+        load(id) {
+            const redirect = getRedirect();
+            if (!redirect) {
+                return null;
+            }
+            // Normalize the module ID, handling query strings
+            const cleanId = id.split('?')[0];
+            let normalizedId;
+            try {
+                normalizedId = path.resolve(cleanId);
+            }
+            catch {
+                return null;
+            }
+            // Check if this is the file we're redirecting
+            if (normalizedId === path.resolve(redirect.from)) {
+                // Read the mutated code from the temp file
+                try {
+                    const mutatedCode = fs.readFileSync(redirect.to, 'utf8');
+                    return mutatedCode;
+                }
+                catch (err) {
+                    log.error(`Failed to read mutant file: ${redirect.to} ${err}`);
+                    return null;
+                }
+            }
+            return null;
+        },
+    };
+}