@mutineerjs/mutineer 0.1.0

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

@@ -0,0 +1,105 @@
+import { createVitest } from 'vitest/node';
+import fs from 'node:fs';
+import path from 'node:path';
+import { poolMutineerPlugin } from './plugin.js';
+import { getMutantFilePath, setRedirect, clearRedirect, } from '../shared/index.js';
+import { createLogger } from '../../utils/logger.js';
+const log = createLogger('vitest-runtime');
+export class VitestWorkerRuntime {
+    constructor(options) {
+        this.options = options;
+        this.vitest = null;
+    }
+    async init() {
+        try {
+            this.vitest = await createVitest('test', {
+                watch: true,
+                reporters: ['dot'],
+                silent: true,
+                pool: 'forks',
+                bail: 1,
+                ...(this.options.vitestConfigPath
+                    ? { config: this.options.vitestConfigPath }
+                    : {}),
+            }, {
+                plugins: [poolMutineerPlugin()],
+            });
+            await this.vitest.init();
+            log.debug(`Vitest initialized for worker ${this.options.workerId}`);
+        }
+        catch (err) {
+            log.error(`Failed to initialize Vitest: ${err}`);
+            throw err;
+        }
+    }
+    async shutdown() {
+        if (!this.vitest)
+            return;
+        await this.vitest.close();
+        this.vitest = null;
+    }
+    async run(mutant, tests) {
+        if (!this.vitest) {
+            throw new Error('Vitest runtime not initialized');
+        }
+        const start = Date.now();
+        try {
+            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+            fs.writeFileSync(mutantPath, mutant.code, 'utf8');
+            log.debug(`Wrote mutant to ${mutantPath}`);
+            setRedirect({
+                from: path.resolve(mutant.file),
+                to: mutantPath,
+            });
+            this.vitest.invalidateFile(mutant.file);
+            log.debug(`Invalidated ${mutant.file}`);
+            const specs = [];
+            for (const testFile of tests) {
+                const spec = this.vitest
+                    .getProjectByName('')
+                    ?.createSpecification(testFile);
+                if (spec)
+                    specs.push(spec);
+            }
+            if (specs.length === 0) {
+                return {
+                    killed: false,
+                    durationMs: Date.now() - start,
+                };
+            }
+            log.debug(`Running ${specs.length} test specs`);
+            const results = await this.vitest.runTestSpecifications(specs);
+            const requestedModules = new Set(specs.map((s) => s.moduleId));
+            const relevantModules = results.testModules.filter((mod) => requestedModules.has(mod.moduleId));
+            const modulesForDecision = relevantModules.length
+                ? relevantModules
+                : results.testModules;
+            const killed = modulesForDecision.some((mod) => !mod.ok());
+            return {
+                killed,
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            return {
+                killed: true,
+                durationMs: Date.now() - start,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        finally {
+            // Clear redirect and clean up temp file
+            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+            clearRedirect();
+            try {
+                fs.rmSync(mutantPath, { force: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+export function createVitestWorkerRuntime(options) {
+    return new VitestWorkerRuntime(options);
+}

package/dist/runner/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/vitest/worker.mjs

@@ -0,0 +1,92 @@
+/**
+ * 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 './worker-runtime.js';
+import { createLogger } from '../../utils/logger.js';
+const log = createLogger('vitest-worker');
+// 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));
+}
+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.debug(`Starting worker ${workerId} in ${cwd}`);
+    const runtime = createVitestWorkerRuntime({
+        workerId,
+        cwd,
+        vitestConfigPath,
+    });
+    try {
+        await runtime.init();
+    }
+    catch (err) {
+        log.error(`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.debug(`Invalid JSON: ${line}`);
+            continue;
+        }
+        if (request.type === 'shutdown') {
+            log.debug('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) => {
+    log.error(`Fatal error: ${err}`);
+    process.exit(1);
+});

package/dist/types/api.d.ts

@@ -0,0 +1,20 @@
+import type { MutineerConfig } from './config.js';
+import type { MutantResult } from './mutant.js';
+export type { MutantCacheEntry, MutantResult, MutantStatus } from './mutant.js';
+export type DiffLineType = 'context' | 'add' | 'remove';
+export interface DiffLine {
+    readonly type: DiffLineType;
+    readonly leftNumber?: number;
+    readonly rightNumber?: number;
+    readonly text: string;
+}
+export interface DiffResponse {
+    readonly lines: readonly DiffLine[];
+}
+export interface ApiResponse {
+    readonly mutants: readonly MutantResult[];
+}
+export interface ConfigResponse {
+    readonly config?: MutineerConfig;
+    readonly error?: string;
+}

package/dist/types/api.js

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

package/dist/types/config.d.ts

@@ -0,0 +1,48 @@
+export interface MutateTargetObject {
+    readonly file: string;
+    /** Auto-detected from file extension if omitted (.vue = 'vue:script-setup', else 'module') */
+    readonly kind?: 'vue:script-setup' | 'module';
+}
+/** Target can be a simple path string or an object with file and optional kind */
+export type MutateTarget = string | MutateTargetObject;
+export interface MutineerConfig {
+    readonly targets?: readonly MutateTarget[];
+    /** Mutator names to include (e.g., ['flipStrictEQ', 'andToOr']) */
+    readonly include?: readonly string[];
+    /** Mutator names to exclude (e.g., ['relaxGE']) */
+    readonly exclude?: readonly string[];
+    /** Glob patterns for paths to exclude from mutation (e.g., ['admin/**']) */
+    readonly excludePaths?: readonly string[];
+    readonly maxMutantsPerFile?: number;
+    readonly source?: string | readonly string[];
+    readonly baseRef?: string;
+    readonly testPatterns?: readonly string[];
+    readonly extensions?: readonly string[];
+    readonly autoDiscover?: boolean;
+    /**
+     * Control how Vitest output is handled for mutant runs:
+     * - 'mute' (default) suppresses all output
+     * - 'minimal' echoes only pass/fail summaries
+     * - 'inherit' streams full Vitest output to the CLI
+     */
+    readonly mutantOutput?: 'mute' | 'minimal' | 'inherit';
+    readonly minKillPercent?: number;
+    /** Preferred test runner (defaults to vitest) */
+    readonly runner?: 'vitest' | 'jest';
+    readonly vitestConfig?: string;
+    readonly jestConfig?: string;
+    /** Max depth for dependency resolution with --changed-with-deps (default: 1) */
+    readonly dependencyDepth?: number;
+    /** Path to coverage JSON file (Istanbul format, e.g., coverage/coverage-final.json) */
+    readonly coverageFile?: string;
+    /** Only mutate lines that are covered by tests (requires coverageFile) */
+    readonly onlyCoveredLines?: boolean;
+    /** Request a coverage-instrumented baseline run (implies per-test coverage if available) */
+    readonly coverage?: boolean;
+    /**
+     * Enable per-test coverage collection during the baseline run.
+     * When enabled, Mutineer will try to run only the tests that actually cover a mutated line.
+     * Requires Vitest coverage with perTest support.
+     */
+    readonly perTestCoverage?: boolean;
+}

package/dist/types/config.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Centralised type definitions.
+ *
+ * Re-exports all public types from a single entry point for easier imports
+ * and better tree-shaking.
+ *
+ * Usage:
+ *   import type { MutineerConfig, MutantStatus } from '../types/index.js'
+ */
+export type { MutineerConfig, MutateTarget } from './config.js';
+export type { MutantStatus, MutantRunStatus, MutantCacheEntry, MutantResult, MutantRunSummary, MutantRunResult, MutantPayload, MutantDescriptor, MutantLocation, Variant, } from './mutant.js';
+export type { MutationVariant } from '../core/types.js';
+export { defineMutineerConfig } from '../index.js';

package/dist/types/index.js

@@ -0,0 +1,11 @@
+/**
+ * Centralised type definitions.
+ *
+ * Re-exports all public types from a single entry point for easier imports
+ * and better tree-shaking.
+ *
+ * Usage:
+ *   import type { MutineerConfig, MutantStatus } from '../types/index.js'
+ */
+// Re-export for convenience
+export { defineMutineerConfig } from '../index.js';

package/dist/types/mutant.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared mutant-related type definitions.
+ *
+ * Centralises the shapes used across the runner and adapters so we
+ * don't duplicate unions or object shapes in multiple modules.
+ */
+export type MutantStatus = 'killed' | 'escaped' | 'skipped' | 'error' | 'timeout';
+export type MutantRunStatus = MutantStatus;
+export interface MutantLocation {
+    readonly file: string;
+    readonly line: number;
+    readonly col: number;
+}
+export interface MutantDescriptor extends MutantLocation {
+    readonly id: string;
+    readonly name: string;
+    readonly code: string;
+}
+/** Payload passed to workers/pools for execution. */
+export type MutantPayload = MutantDescriptor;
+/** Variant with attached test files. */
+export interface Variant extends MutantDescriptor {
+    readonly tests: readonly string[];
+}
+export interface MutantCacheEntry extends MutantLocation {
+    readonly status: MutantStatus;
+    readonly mutator: string;
+}
+export interface MutantResult extends MutantCacheEntry {
+    readonly id: string;
+    readonly relativePath: string;
+}
+/** Low-level execution result returned by a worker. */
+export interface MutantRunSummary {
+    readonly killed: boolean;
+    readonly durationMs: number;
+    readonly error?: string;
+}
+/** Normalised result returned by adapters/orchestrator. */
+export interface MutantRunResult {
+    readonly status: MutantRunStatus;
+    readonly durationMs: number;
+    readonly error?: string;
+}

package/dist/types/mutant.js

@@ -0,0 +1,7 @@
+/**
+ * Shared mutant-related type definitions.
+ *
+ * Centralises the shapes used across the runner and adapters so we
+ * don't duplicate unions or object shapes in multiple modules.
+ */
+export {};

package/dist/utils/PoolSpinner.d.ts

@@ -0,0 +1,5 @@
+interface PoolSpinnerProps {
+    message: string;
+}
+export declare function PoolSpinner({ message }: PoolSpinnerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/utils/PoolSpinner.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+export function PoolSpinner({ message }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message] })] }));
+}

package/dist/utils/ProgressBar.d.ts

@@ -0,0 +1,11 @@
+export interface ProgressBarProps {
+    total: number;
+    done: number;
+    killed: number;
+    escaped: number;
+    errors: number;
+    timeouts: number;
+    skipped: number;
+    width?: number;
+}
+export declare function ProgressBar({ total, done, killed, escaped, errors, timeouts, skipped, width, }: ProgressBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/utils/ProgressBar.js

@@ -0,0 +1,9 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function ProgressBar({ total, done, killed, escaped, errors, timeouts, skipped, width = 40, }) {
+    const ratio = total === 0 ? 1 : Math.min(done / total, 1);
+    const filled = Math.round(ratio * width);
+    const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(width - filled);
+    const pct = Math.round(ratio * 100);
+    return (_jsxs(Box, { children: [_jsxs(Text, { children: ["mutants ", done, "/", total, " [", bar, "] ", pct, "%", ' '] }), _jsxs(Text, { color: "green", children: ["killed=", killed] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: "red", children: ["escaped=", escaped] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: "yellow", children: ["errors=", errors] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: "yellow", children: ["timeouts=", timeouts] }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: ["skipped=", skipped] })] }));
+}

package/dist/utils/__tests__/coverage.spec.d.ts

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

package/dist/utils/__tests__/coverage.spec.js

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { loadCoverageData, isLineCovered, getFileCoverageStats, loadPerTestCoverageData, } from '../coverage.js';
+describe('coverage utilities', () => {
+    it('loads coverage data and reports covered lines', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const covPath = path.join(tmpDir, 'coverage-final.json');
+        const filePath = path.join(tmpDir, 'src', 'file.ts');
+        const data = {
+            [filePath]: {
+                path: filePath,
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 2, column: 0 } },
+                    '1': { start: { line: 5, column: 0 }, end: { line: 5, column: 10 } },
+                },
+                s: { '0': 1, '1': 0 },
+            },
+        };
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(covPath, JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData(covPath, tmpDir);
+            expect(isLineCovered(coverage, filePath, 1)).toBe(true);
+            expect(isLineCovered(coverage, filePath, 2)).toBe(true);
+            expect(isLineCovered(coverage, filePath, 3)).toBe(false);
+            expect(isLineCovered(coverage, filePath, 5)).toBe(false);
+            const stats = getFileCoverageStats(coverage, filePath);
+            expect(stats?.count).toBe(2);
+            expect(stats?.lines.has(1)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('returns null stats for missing file', () => {
+        const coverage = { coveredLines: new Map() };
+        expect(getFileCoverageStats(coverage, '/nope.ts')).toBeNull();
+    });
+    it('loads per-test coverage data from various shapes', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const reportsDir = path.join(tmpDir, 'coverage');
+        await fs.mkdir(reportsDir, { recursive: true });
+        const testFile = path.join(tmpDir, 'tests', 'foo.spec.ts');
+        const srcFile = path.join(tmpDir, 'src', 'foo.ts');
+        // Write per-test-coverage.json (format A)
+        const formatA = {
+            tests: {
+                [testFile]: {
+                    files: {
+                        [srcFile]: { lines: [1, 2, 3] },
+                    },
+                },
+            },
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(formatA), 'utf8');
+        // Also drop a tmp file with format B to ensure fallback works when main file is absent
+        const tmpSub = path.join(reportsDir, 'tmp');
+        await fs.mkdir(tmpSub, { recursive: true });
+        const formatB = {
+            [testFile]: {
+                [srcFile]: [4, 5],
+            },
+        };
+        await fs.writeFile(path.join(tmpSub, 'extra.json'), JSON.stringify(formatB), 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(reportsDir, tmpDir);
+            expect(map).not.toBeNull();
+            const perTest = map.get(testFile);
+            expect(perTest).toBeDefined();
+            const lines = perTest.get(srcFile);
+            expect(lines).toBeDefined();
+            // Format A lines present
+            expect(lines.has(1)).toBe(true);
+            expect(lines.has(3)).toBe(true);
+            // Fallback not used yet
+            expect(lines.has(4)).toBe(false);
+            // Remove primary file to force fallback loading from tmp/extra.json
+            await fs.rm(path.join(reportsDir, 'per-test-coverage.json'));
+            const fallback = await loadPerTestCoverageData(reportsDir, tmpDir);
+            expect(fallback).not.toBeNull();
+            const fallbackLines = fallback.get(testFile).get(srcFile);
+            expect(fallbackLines.has(4)).toBe(true);
+            expect(fallbackLines.has(5)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/utils/__tests__/progress.spec.d.ts

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

package/dist/utils/__tests__/progress.spec.js

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Progress } from '../progress.js';
+describe('Progress', () => {
+    let originalConsole;
+    beforeEach(() => {
+        originalConsole = {
+            log: console.log,
+            info: console.info,
+            warn: console.warn,
+            error: console.error,
+        };
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        console.log = originalConsole.log;
+        console.info = originalConsole.info;
+        console.warn = originalConsole.warn;
+        console.error = originalConsole.error;
+    });
+    it('logs run/update/finish messages in list mode and tracks counts', () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const progress = new Progress(5, { mode: 'list' });
+        progress.start();
+        progress.update('killed');
+        progress.update('escaped');
+        progress.update('skipped');
+        progress.update('error');
+        progress.update('timeout');
+        progress.finish();
+        const logs = logSpy.mock.calls.map((args) => args.join(' '));
+        expect(logs[0]).toContain('running 5 mutants');
+        expect(logs.some((l) => l.includes('mutant 1/5 killed'))).toBe(true);
+        expect(logs.some((l) => l.includes('mutant 2/5 escaped'))).toBe(true);
+        expect(logs.some((l) => l.includes('mutant 3/5 skipped'))).toBe(true);
+        expect(logs.some((l) => l.includes('mutant 4/5 error'))).toBe(true);
+        expect(logs.some((l) => l.includes('mutant 5/5 timeout'))).toBe(true);
+        const lastLog = logs[logs.length - 1] ?? '';
+        expect(lastLog).toContain('killed=1');
+        expect(lastLog).toContain('errors=1');
+        expect(lastLog).toContain('timeouts=1');
+    });
+    it('is tolerant to finish before start and clamps negative totals', () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const progress = new Progress(-5, { mode: 'list' });
+        progress.finish(); // no-op
+        progress.start();
+        progress.finish();
+        expect(logSpy).toHaveBeenCalled();
+    });
+});

package/dist/utils/__tests__/summary.spec.d.ts

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

package/dist/utils/__tests__/summary.spec.js

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi } from 'vitest';
+import { computeSummary, printSummary, summarise } from '../summary.js';
+/** Strip ANSI escape codes for clean text assertions */
+const stripAnsi = (s) => s.replace(/\x1B\[[0-9;]*m/g, '');
+function makeEntry(overrides) {
+    return {
+        mutator: 'flip',
+        file: '/tmp/file.ts',
+        line: 1,
+        col: 1,
+        status: 'killed',
+        ...overrides,
+    };
+}
+describe('summary', () => {
+    it('computes totals and kill rate', () => {
+        const cache = {
+            a: makeEntry({ status: 'killed' }),
+            b: makeEntry({ status: 'escaped' }),
+            c: makeEntry({ status: 'skipped' }),
+        };
+        const s = computeSummary(cache);
+        expect(s).toEqual({
+            total: 3,
+            killed: 1,
+            escaped: 1,
+            skipped: 1,
+            evaluated: 2,
+            killRate: 50,
+        });
+    });
+    it('prints a friendly summary with sections', () => {
+        const cache = {
+            a: makeEntry({ status: 'killed', file: '/tmp/a.ts' }),
+            b: makeEntry({ status: 'escaped', file: '/tmp/b.ts', mutator: 'wrap' }),
+        };
+        const summary = computeSummary(cache);
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        printSummary(summary, cache, 1500);
+        const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
+        expect(lines.some((l) => l.includes('Killed Mutants'))).toBe(true);
+        expect(lines.some((l) => l.includes('Escaped Mutants'))).toBe(true);
+        expect(lines.some((l) => l.includes('Duration: 1.50s'))).toBe(true);
+        logSpy.mockRestore();
+    });
+    it('summarise returns summary and prints', () => {
+        const cache = { a: makeEntry({ status: 'killed' }) };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const s = summarise(cache);
+        expect(s.total).toBe(1);
+        expect(logSpy).toHaveBeenCalled();
+        logSpy.mockRestore();
+    });
+});