@mutineerjs/mutineer 0.2.4 → 0.4.0

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

@@ -1,376 +0,0 @@
-/**
- * Vitest Worker Pool
- *
- * Manages a pool of persistent Vitest worker processes that can run
- * multiple mutations without restarting, providing significant speedup
- * over the per-spawn approach.
- *
- * Each worker:
- * - Starts Vitest in watch mode via programmatic API
- * - Receives mutations via stdin (JSON)
- * - Uses dynamic redirect loader to swap module at runtime
- * - Returns results via stdout (JSON)
- */
-import { spawn } from 'node:child_process';
-import * as path from 'node:path';
-import * as readline from 'node:readline';
-import * as fs from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { EventEmitter } from 'node:events';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-class VitestWorker extends EventEmitter {
-    constructor(id, cwd, vitestConfig, debug = false) {
-        super();
-        this.cwd = cwd;
-        this.vitestConfig = vitestConfig;
-        this.debug = debug;
-        this.process = null;
-        this.rl = 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 loaderJs = path.join(__dirname, '..', 'redirect-loader.js');
-        const loaderMjs = path.join(__dirname, '..', 'redirect-loader.mjs');
-        const loaderTs = path.join(__dirname, '..', 'redirect-loader.ts');
-        const loaderScript = fs.existsSync(loaderJs)
-            ? loaderJs
-            : fs.existsSync(loaderMjs)
-                ? loaderMjs
-                : loaderTs;
-        const env = {
-            ...process.env,
-            MUTINEER_WORKER_ID: this.id,
-            MUTINEER_CWD: this.cwd,
-            ...(this.vitestConfig ? { MUTINEER_VITEST_CONFIG: this.vitestConfig } : {}),
-            ...(this.debug ? { MUTINEER_DEBUG: '1' } : {}),
-        };
-        this.log('Starting worker process');
-        this.process = spawn(process.execPath, [
-            '--experimental-strip-types',
-            '--experimental-transform-types',
-            '--no-warnings',
-            '--import', loaderScript,
-            workerScript,
-        ], {
-            cwd: this.cwd,
-            env,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        // Handle stderr (debug/error output)
-        this.process.stderr?.on('data', (data) => {
-            if (this.debug) {
-                process.stderr.write(`[worker-${this.id}] ${data}`);
-            }
-        });
-        // Set up line reader for stdout (JSON messages)
-        this.rl = readline.createInterface({
-            input: this.process.stdout,
-            terminal: false,
-        });
-        this.rl.on('line', (line) => this.handleMessage(line));
-        this.process.on('error', (err) => {
-            this.log(`Process error: ${err.message}`);
-            this.handleExit(1);
-        });
-        this.process.on('exit', (code) => {
-            this.log(`Process exited with code ${code}`);
-            this.handleExit(code ?? 1);
-        });
-        // Wait for ready signal
-        await new Promise((resolve, reject) => {
-            const timeoutMs = 120_000; // allow more time for Vitest init (coverage, large projects)
-            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(line) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return;
-        // Only attempt to parse JSON lines; ignore any other stdout noise
-        if (!trimmed.startsWith('{')) {
-            if (this.debug)
-                this.log(`Non-JSON stdout: ${trimmed}`);
-            return;
-        }
-        let msg;
-        try {
-            msg = JSON.parse(trimmed);
-        }
-        catch {
-            this.log(`Invalid JSON from worker: ${line}`);
-            return;
-        }
-        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;
-                    // Kill and restart the worker on timeout
-                    this.kill();
-                    resolve({ killed: true, durationMs: timeoutMs, error: 'timeout' });
-                }
-            }, timeoutMs);
-            this.pendingTask = { resolve, reject, timeoutHandle };
-            const request = JSON.stringify({ type: 'run', mutant, tests });
-            this.process.stdin.write(request + '\n');
-        });
-    }
-    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.stdin.write(JSON.stringify({ type: 'shutdown' }) + '\n');
-        });
-    }
-    kill() {
-        if (this.process) {
-            try {
-                this.process.kill('SIGKILL');
-            }
-            catch {
-                // Ignore
-            }
-            this.process = null;
-        }
-        this.ready = false;
-    }
-    log(msg) {
-        if (this.debug) {
-            console.error(`[VitestWorker-${this.id}] ${msg}`);
-        }
-    }
-}
-export class VitestPool {
-    constructor(options) {
-        this.workers = [];
-        this.availableWorkers = [];
-        this.waitingTasks = [];
-        this.initialized = false;
-        this.shuttingDown = false;
-        this.options = {
-            cwd: options.cwd,
-            concurrency: options.concurrency,
-            vitestConfig: options.vitestConfig,
-            timeoutMs: options.timeoutMs ?? 10_000,
-            debug: options.debug ?? false,
-            createWorker: options.createWorker,
-        };
-    }
-    async init() {
-        if (this.initialized)
-            return;
-        this.log(`Initializing pool with ${this.options.concurrency} workers`);
-        const startPromises = [];
-        for (let i = 0; i < this.options.concurrency; i++) {
-            const worker = this.options.createWorker?.(`w${i}`, {
-                cwd: this.options.cwd,
-                vitestConfig: this.options.vitestConfig,
-                debug: this.options.debug,
-            }) ??
-                new VitestWorker(`w${i}`, this.options.cwd, this.options.vitestConfig, this.options.debug);
-            worker.on('exit', () => {
-                if (!this.shuttingDown) {
-                    this.handleWorkerExit(worker);
-                }
-            });
-            this.workers.push(worker);
-            startPromises.push(worker.start().then(() => {
-                this.availableWorkers.push(worker);
-                this.log(`Worker ${worker.id} ready`);
-            }));
-        }
-        await Promise.all(startPromises);
-        this.initialized = true;
-        this.log('Pool initialized');
-    }
-    handleWorkerExit(worker) {
-        // Remove from available list
-        const availIdx = this.availableWorkers.indexOf(worker);
-        if (availIdx >= 0) {
-            this.availableWorkers.splice(availIdx, 1);
-        }
-        // Try to restart the worker
-        this.log(`Worker ${worker.id} exited, attempting restart`);
-        const newWorker = this.options.createWorker?.(worker.id, {
-            cwd: this.options.cwd,
-            vitestConfig: this.options.vitestConfig,
-            debug: this.options.debug,
-        }) ??
-            new VitestWorker(worker.id, this.options.cwd, this.options.vitestConfig, this.options.debug);
-        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);
-            this.log(`Worker ${newWorker.id} restarted`);
-        })
-            .catch((err) => {
-            this.log(`Failed to restart worker ${newWorker.id}: ${err}`);
-        });
-    }
-    async acquireWorker() {
-        // Try to get an available worker
-        const worker = this.availableWorkers.shift();
-        if (worker) {
-            return worker;
-        }
-        // Wait for one to become available
-        return new Promise((resolve) => {
-            this.waitingTasks.push(resolve);
-        });
-    }
-    releaseWorker(worker) {
-        // If someone is waiting, give them the worker directly
-        const waiting = this.waitingTasks.shift();
-        if (waiting) {
-            waiting(worker);
-            return;
-        }
-        // Otherwise return to the pool
-        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);
-            return result;
-        }
-        finally {
-            this.releaseWorker(worker);
-        }
-    }
-    async shutdown() {
-        if (this.shuttingDown)
-            return;
-        this.shuttingDown = true;
-        this.log('Shutting down pool');
-        await Promise.all(this.workers.map((w) => w.shutdown()));
-        this.workers = [];
-        this.availableWorkers = [];
-        this.initialized = false;
-        this.log('Pool shut down');
-    }
-    log(msg) {
-        if (this.options.debug) {
-            console.error(`[VitestPool] ${msg}`);
-        }
-    }
-}
-/**
- * Run a single mutation using the pool.
- * Convenience function for integration with orchestrator.
- */
-export async function runWithPool(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),
-        };
-    }
-}

package/dist/runner/pool/vitest/worker.d.mts

@@ -1,15 +0,0 @@
-/**
- * Persistent Vitest worker process.
- *
- * This worker stays alive and receives mutation tasks via stdin,
- * using Vitest's programmatic API to rerun tests without process restart.
- *
- * Communication protocol (JSON-RPC over stdin/stdout):
- *
- * Request: { "type": "run", "mutant": { file, code, id, name }, "tests": string[] }
- * Response: { "type": "result", "killed": boolean, "durationMs": number }
- *
- * Request: { "type": "shutdown" }
- * Response: { "type": "shutdown", "ok": true }
- */
-export {};

package/dist/runner/pool/vitest/worker.mjs

@@ -1,96 +0,0 @@
-/**
- * Persistent Vitest worker process.
- *
- * This worker stays alive and receives mutation tasks via stdin,
- * using Vitest's programmatic API to rerun tests without process restart.
- *
- * Communication protocol (JSON-RPC over stdin/stdout):
- *
- * Request: { "type": "run", "mutant": { file, code, id, name }, "tests": string[] }
- * Response: { "type": "result", "killed": boolean, "durationMs": number }
- *
- * Request: { "type": "shutdown" }
- * Response: { "type": "shutdown", "ok": true }
- */
-import * as readline from 'node:readline';
-import { createVitestWorkerRuntime } from '../../adapters/vitest/worker-runtime.js';
-// Global state for redirect - shared with the plugin via globalThis
-// Type is declared in pool-plugin.ts
-globalThis.__mutineer_redirect__ = { from: null, to: null };
-function send(response) {
-    console.log(JSON.stringify(response));
-}
-function log(msg) {
-    if (process.env.MUTINEER_DEBUG !== '1')
-        return;
-    console.error(`[vitest-worker] ${msg}`);
-}
-async function main() {
-    const workerId = process.env.MUTINEER_WORKER_ID ?? 'unknown';
-    const cwd = process.env.MUTINEER_CWD ?? process.cwd();
-    const vitestConfigPath = process.env.MUTINEER_VITEST_CONFIG;
-    log(`Starting worker ${workerId} in ${cwd}`);
-    const runtime = createVitestWorkerRuntime({
-        workerId,
-        cwd,
-        vitestConfigPath,
-        debug: process.env.MUTINEER_DEBUG === '1',
-    });
-    try {
-        await runtime.init();
-    }
-    catch (err) {
-        console.error('[vitest-worker] Failed to initialize Vitest:', err);
-        process.exit(1);
-    }
-    // Signal ready
-    send({ type: 'ready', workerId });
-    // Process requests from stdin
-    const rl = readline.createInterface({
-        input: process.stdin,
-        terminal: false,
-    });
-    for await (const line of rl) {
-        if (!line.trim())
-            continue;
-        let request;
-        try {
-            request = JSON.parse(line);
-        }
-        catch (err) {
-            log(`Invalid JSON: ${line}`);
-            continue;
-        }
-        if (request.type === 'shutdown') {
-            log('Shutting down');
-            await runtime.shutdown();
-            send({ type: 'shutdown', ok: true });
-            process.exit(0);
-        }
-        if (request.type === 'run') {
-            try {
-                const { mutant, tests } = request;
-                const result = await runtime.run(mutant, tests);
-                send({
-                    type: 'result',
-                    killed: result.killed,
-                    durationMs: result.durationMs,
-                    error: result.error,
-                });
-            }
-            catch (err) {
-                // On error, treat as killed (conservative)
-                send({
-                    type: 'result',
-                    killed: true,
-                    durationMs: 0,
-                    error: String(err),
-                });
-            }
-        }
-    }
-}
-main().catch((err) => {
-    console.error('[vitest-worker] Fatal error:', err);
-    process.exit(1);
-});

package/dist/runner/pool/vitest-worker.d.mts

@@ -1,15 +0,0 @@
-/**
- * Persistent Vitest worker process.
- *
- * This worker stays alive and receives mutation tasks via stdin,
- * using Vitest's programmatic API to rerun tests without process restart.
- *
- * Communication protocol (JSON-RPC over stdin/stdout):
- *
- * Request: { "type": "run", "mutant": { file, code, id, name }, "tests": string[] }
- * Response: { "type": "result", "killed": boolean, "durationMs": number }
- *
- * Request: { "type": "shutdown" }
- * Response: { "type": "shutdown", "ok": true }
- */
-export {};

package/dist/runner/pool/vitest-worker.mjs

@@ -1,96 +0,0 @@
-/**
- * Persistent Vitest worker process.
- *
- * This worker stays alive and receives mutation tasks via stdin,
- * using Vitest's programmatic API to rerun tests without process restart.
- *
- * Communication protocol (JSON-RPC over stdin/stdout):
- *
- * Request: { "type": "run", "mutant": { file, code, id, name }, "tests": string[] }
- * Response: { "type": "result", "killed": boolean, "durationMs": number }
- *
- * Request: { "type": "shutdown" }
- * Response: { "type": "shutdown", "ok": true }
- */
-import * as readline from 'node:readline';
-import { createVitestWorkerRuntime } from '../adapters/vitest-worker-runtime.js';
-// Global state for redirect - shared with the plugin via globalThis
-// Type is declared in pool-plugin.ts
-globalThis.__mutineer_redirect__ = { from: null, to: null };
-function send(response) {
-    console.log(JSON.stringify(response));
-}
-function log(msg) {
-    if (process.env.MUTINEER_DEBUG !== '1')
-        return;
-    console.error(`[vitest-worker] ${msg}`);
-}
-async function main() {
-    const workerId = process.env.MUTINEER_WORKER_ID ?? 'unknown';
-    const cwd = process.env.MUTINEER_CWD ?? process.cwd();
-    const vitestConfigPath = process.env.MUTINEER_VITEST_CONFIG;
-    log(`Starting worker ${workerId} in ${cwd}`);
-    const runtime = createVitestWorkerRuntime({
-        workerId,
-        cwd,
-        vitestConfigPath,
-        debug: process.env.MUTINEER_DEBUG === '1',
-    });
-    try {
-        await runtime.init();
-    }
-    catch (err) {
-        console.error('[vitest-worker] Failed to initialize Vitest:', err);
-        process.exit(1);
-    }
-    // Signal ready
-    send({ type: 'ready', workerId });
-    // Process requests from stdin
-    const rl = readline.createInterface({
-        input: process.stdin,
-        terminal: false,
-    });
-    for await (const line of rl) {
-        if (!line.trim())
-            continue;
-        let request;
-        try {
-            request = JSON.parse(line);
-        }
-        catch (err) {
-            log(`Invalid JSON: ${line}`);
-            continue;
-        }
-        if (request.type === 'shutdown') {
-            log('Shutting down');
-            await runtime.shutdown();
-            send({ type: 'shutdown', ok: true });
-            process.exit(0);
-        }
-        if (request.type === 'run') {
-            try {
-                const { mutant, tests } = request;
-                const result = await runtime.run(mutant, tests);
-                send({
-                    type: 'result',
-                    killed: result.killed,
-                    durationMs: result.durationMs,
-                    error: result.error,
-                });
-            }
-            catch (err) {
-                // On error, treat as killed (conservative)
-                send({
-                    type: 'result',
-                    killed: true,
-                    durationMs: 0,
-                    error: String(err),
-                });
-            }
-        }
-    }
-}
-main().catch((err) => {
-    console.error('[vitest-worker] Fatal error:', err);
-    process.exit(1);
-});

package/dist/runner/shared-module-redirect.d.ts

@@ -1,56 +0,0 @@
-/**
- * Shared module redirection utilities for both Jest and Vitest runners.
- *
- * This module provides common functionality for intercepting module resolution
- * and redirecting imports to mutated versions of source files.
- */
-export interface MutantRedirect {
-    from: string | null;
-    to: string | null;
-}
-declare global {
-    var __mutineer_redirect__: MutantRedirect | undefined;
-}
-/**
- * Get the path where a mutant should be written.
- * Mutants are stored in __mutineer__/ subdirectories alongside source files.
- *
- * @param originalFile - The original source file path
- * @param mutantId - The mutation ID
- * @returns Path to the mutant file in __mutineer__/ directory
- */
-export declare function getMutantFilePath(originalFile: string, mutantId: string): string;
-/**
- * Get the current redirect configuration from globalThis.
- * Used by both Jest and Vitest to check if a module should be redirected.
- *
- * @returns Object with normalized from/to paths, or null if no redirect is active
- */
-export declare function getActiveRedirect(): {
-    from: string;
-    to: string;
-} | null;
-/**
- * Initialize the global redirect state.
- * Should be called once when the runtime starts.
- */
-export declare function initializeRedirect(): void;
-/**
- * Set a redirect for module resolution.
- *
- * @param originalFile - The original source file (absolute path)
- * @param mutantPath - The mutant file path
- */
-export declare function setRedirect(originalFile: string, mutantPath: string): void;
-/**
- * Clear the current redirect.
- */
-export declare function clearRedirect(): void;
-/**
- * Check if a given file path matches the current redirect source.
- * Handles path normalization and extension matching.
- *
- * @param filePath - The file path to check
- * @returns true if this file should be redirected
- */
-export declare function shouldRedirectPath(filePath: string): boolean;