@mutineerjs/mutineer 0.1.0

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

@@ -0,0 +1,376 @@
+/**
+ * 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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1,96 @@
+/**
+ * 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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1,96 @@
+/**
+ * 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/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared utilities for test runner adapters.
+ *
+ * This module provides common functionality used by both Jest and Vitest adapters,
+ * including mutant file path generation and redirect state management.
+ */
+export { getMutantFilePath } from './mutant-paths.js';
+export { setRedirect, getRedirect, clearRedirect, initializeRedirectState, } from './redirect-state.js';
+export type { RedirectConfig } from './redirect-state.js';

package/dist/runner/shared/index.js

@@ -0,0 +1,8 @@
+/**
+ * Shared utilities for test runner adapters.
+ *
+ * This module provides common functionality used by both Jest and Vitest adapters,
+ * including mutant file path generation and redirect state management.
+ */
+export { getMutantFilePath } from './mutant-paths.js';
+export { setRedirect, getRedirect, clearRedirect, initializeRedirectState, } from './redirect-state.js';

package/dist/runner/shared/mutant-paths.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared utilities for managing mutant file paths.
+ */
+/**
+ * Generate a file path for a mutant file in the __mutineer__ directory.
+ *
+ * @param originalFile - Path to the original source file
+ * @param mutantId - Unique identifier for the mutant
+ * @returns Absolute path where the mutant file should be written
+ *
+ * @example
+ * getMutantFilePath('/src/foo.ts', 'mutant#42')
+ * // Returns: '/src/__mutineer__/foo_42.ts'
+ */
+export declare function getMutantFilePath(originalFile: string, mutantId: string): string;

package/dist/runner/shared/mutant-paths.js

@@ -0,0 +1,30 @@
+/**
+ * Shared utilities for managing mutant file paths.
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+/**
+ * Generate a file path for a mutant file in the __mutineer__ directory.
+ *
+ * @param originalFile - Path to the original source file
+ * @param mutantId - Unique identifier for the mutant
+ * @returns Absolute path where the mutant file should be written
+ *
+ * @example
+ * getMutantFilePath('/src/foo.ts', 'mutant#42')
+ * // Returns: '/src/__mutineer__/foo_42.ts'
+ */
+export 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}`);
+}