@mutineerjs/mutineer 0.2.2 → 0.2.4

package/dist/runner/pool-executor.js

@@ -0,0 +1,143 @@
+import { render } from 'ink';
+import { createElement } from 'react';
+import { Progress } from '../utils/progress.js';
+import { computeSummary, printSummary } from '../utils/summary.js';
+import { saveCacheAtomic } from './cache.js';
+import { cleanupMutineerDirs } from './cleanup.js';
+import { PoolSpinner } from '../utils/PoolSpinner.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('pool-executor');
+/**
+ * Execute all mutant tasks through the worker pool.
+ * Handles worker init, progress display, signal handling, and cleanup.
+ */
+export async function executePool(opts) {
+    const { tasks, adapter, cache, concurrency, cwd } = opts;
+    const workerCount = Math.max(1, Math.min(concurrency, tasks.length));
+    const progress = new Progress(tasks.length, {
+        mode: opts.progressMode === 'bar' ? 'bar' : 'list',
+        stream: 'stderr',
+    });
+    const mutationStartTime = Date.now();
+    // Ensure we only finish once
+    let finished = false;
+    const finishOnce = () => {
+        if (finished)
+            return;
+        finished = true;
+        const durationMs = Date.now() - mutationStartTime;
+        progress.finish();
+        const summary = computeSummary(cache);
+        printSummary(summary, cache, durationMs);
+        if (opts.minKillPercent !== undefined) {
+            const killRateString = summary.killRate.toFixed(2);
+            const thresholdString = opts.minKillPercent.toFixed(2);
+            if (summary.killRate < opts.minKillPercent) {
+                const note = summary.evaluated === 0 ? ' No mutants were executed.' : '';
+                log.error(`Mutation kill rate ${killRateString}% did not meet required ${thresholdString}% threshold.${note}`);
+                process.exitCode = 1;
+            }
+            else {
+                log.info(`Mutation kill rate ${killRateString}% meets required ${thresholdString}% threshold`);
+            }
+        }
+    };
+    // Initialize worker pool
+    const workerLogSuffix = workerCount < concurrency ? ` (requested ${concurrency})` : '';
+    log.info(`Initializing ${adapter.name} worker pool with ${workerCount} workers...${workerLogSuffix}`);
+    const poolStart = Date.now();
+    // Ink spinner on stderr while workers start up
+    let spinnerInstance = null;
+    if (process.stderr.isTTY) {
+        spinnerInstance = render(createElement(PoolSpinner, { message: 'Starting pool...' }), { stdout: process.stderr, stderr: process.stderr });
+    }
+    try {
+        await adapter.init(workerCount);
+    }
+    finally {
+        if (spinnerInstance) {
+            spinnerInstance.unmount();
+            spinnerInstance = null;
+        }
+    }
+    const poolDurationMs = Date.now() - poolStart;
+    log.info(`\u2713 Worker pool ready (${poolDurationMs}ms)`);
+    progress.start();
+    let nextIdx = 0;
+    async function processTask(task) {
+        const { v, tests, key } = task;
+        log.debug('Cache ' + JSON.stringify(cache));
+        const cached = cache[key];
+        if (cached) {
+            progress.update(cached.status);
+            return;
+        }
+        if (tests.length === 0) {
+            cache[key] = {
+                status: 'skipped',
+                file: v.file,
+                line: v.line,
+                col: v.col,
+                mutator: v.name,
+            };
+            progress.update('skipped');
+            return;
+        }
+        log.debug(`Running tests for mutant ${v.name} ${JSON.stringify(tests)}`);
+        const result = await adapter.runMutant({
+            id: v.id,
+            name: v.name,
+            file: v.file,
+            code: v.code,
+            line: v.line,
+            col: v.col,
+        }, tests);
+        const status = result.status;
+        cache[key] = {
+            status,
+            file: v.file,
+            line: v.line,
+            col: v.col,
+            mutator: v.name,
+        };
+        progress.update(status);
+    }
+    async function worker() {
+        while (true) {
+            const i = nextIdx++;
+            if (i >= tasks.length)
+                break;
+            await processTask(tasks[i]);
+        }
+    }
+    const workers = [];
+    // Register signal handlers so Ctrl+C / SIGTERM still triggers cleanup
+    let signalCleanedUp = false;
+    const signalHandler = async (signal) => {
+        if (signalCleanedUp)
+            return;
+        signalCleanedUp = true;
+        log.info(`\nReceived ${signal}, cleaning up...`);
+        finishOnce();
+        await adapter.shutdown();
+        await cleanupMutineerDirs(cwd);
+        process.exit(1);
+    };
+    process.on('SIGINT', () => void signalHandler('SIGINT'));
+    process.on('SIGTERM', () => void signalHandler('SIGTERM'));
+    try {
+        for (let i = 0; i < workerCount; i++)
+            workers.push(worker());
+        await Promise.all(workers);
+        await saveCacheAtomic(cwd, cache);
+    }
+    finally {
+        process.removeAllListeners('SIGINT');
+        process.removeAllListeners('SIGTERM');
+        if (!signalCleanedUp) {
+            finishOnce();
+            await adapter.shutdown();
+            await cleanupMutineerDirs(cwd);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,66 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { getMutantFilePath } from '../mutant-paths.js';
+let createdDirs = [];
+afterEach(() => {
+    // Clean up any __mutineer__ directories we created
+    for (const dir of createdDirs) {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+    createdDirs = [];
+});
+describe('getMutantFilePath', () => {
+    it('creates a mutant file path with numeric ID suffix', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'foo.ts');
+        fs.writeFileSync(srcFile, '');
+        const result = getMutantFilePath(srcFile, 'foo.ts#42');
+        createdDirs.push(path.join(tmpDir, '__mutineer__'));
+        expect(result).toBe(path.join(tmpDir, '__mutineer__', 'foo_42.ts'));
+    });
+    it('creates __mutineer__ directory if it does not exist', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'bar.ts');
+        fs.writeFileSync(srcFile, '');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        createdDirs.push(mutineerDir);
+        getMutantFilePath(srcFile, 'bar.ts#1');
+        expect(fs.existsSync(mutineerDir)).toBe(true);
+    });
+    it('handles non-numeric mutant IDs', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'baz.ts');
+        fs.writeFileSync(srcFile, '');
+        createdDirs.push(path.join(tmpDir, '__mutineer__'));
+        const result = getMutantFilePath(srcFile, 'some-weird-id');
+        expect(path.basename(result)).toMatch(/^baz_/);
+        expect(result).toMatch(/\.ts$/);
+    });
+    it('preserves file extension', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'component.vue');
+        fs.writeFileSync(srcFile, '');
+        createdDirs.push(path.join(tmpDir, '__mutineer__'));
+        const result = getMutantFilePath(srcFile, 'component.vue#5');
+        expect(result).toMatch(/\.vue$/);
+        expect(path.basename(result)).toBe('component_5.vue');
+    });
+    it('reuses existing __mutineer__ directory', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-paths-'));
+        const srcFile = path.join(tmpDir, 'foo.ts');
+        fs.writeFileSync(srcFile, '');
+        const mutineerDir = path.join(tmpDir, '__mutineer__');
+        fs.mkdirSync(mutineerDir);
+        createdDirs.push(mutineerDir);
+        // Should not throw
+        const result = getMutantFilePath(srcFile, 'foo.ts#1');
+        expect(result).toBe(path.join(mutineerDir, 'foo_1.ts'));
+    });
+});

package/dist/runner/shared/__tests__/redirect-state.spec.d.ts

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

package/dist/runner/shared/__tests__/redirect-state.spec.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { initializeRedirectState, setRedirect, getRedirect, clearRedirect, } from '../redirect-state.js';
+describe('redirect-state', () => {
+    beforeEach(() => {
+        initializeRedirectState();
+    });
+    describe('initializeRedirectState', () => {
+        it('sets global redirect to null/null', () => {
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: null,
+                to: null,
+            });
+        });
+    });
+    describe('setRedirect', () => {
+        it('sets the redirect config', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: '/src/foo.ts',
+                to: '/tmp/mutant.ts',
+            });
+        });
+    });
+    describe('getRedirect', () => {
+        it('returns null when no redirect is set', () => {
+            expect(getRedirect()).toBeNull();
+        });
+        it('returns the redirect config when set', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            const redirect = getRedirect();
+            expect(redirect).toEqual({
+                from: '/src/foo.ts',
+                to: '/tmp/mutant.ts',
+            });
+        });
+        it('returns null when from is null', () => {
+            globalThis.__mutineer_redirect__ = { from: null, to: '/tmp/mutant.ts' };
+            expect(getRedirect()).toBeNull();
+        });
+        it('returns null when to is null', () => {
+            globalThis.__mutineer_redirect__ = { from: '/src/foo.ts', to: null };
+            expect(getRedirect()).toBeNull();
+        });
+    });
+    describe('clearRedirect', () => {
+        it('resets the redirect to null/null', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            clearRedirect();
+            expect(getRedirect()).toBeNull();
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: null,
+                to: null,
+            });
+        });
+    });
+});

package/dist/runner/tasks.d.ts

@@ -0,0 +1,12 @@
+import type { Variant } from '../types/mutant.js';
+import type { PerTestCoverageMap } from '../utils/coverage.js';
+export interface MutantTask {
+    v: Variant;
+    tests: string[];
+    key: string;
+}
+/**
+ * Prepare mutant tasks from variants by pruning tests via per-test coverage,
+ * sorting tests deterministically, and computing cache keys.
+ */
+export declare function prepareTasks(variants: readonly Variant[], perTestCoverage: PerTestCoverageMap | null): MutantTask[];

package/dist/runner/tasks.js

@@ -0,0 +1,25 @@
+import { filterTestsByCoverage } from './variants.js';
+import { hash, keyForTests } from './cache.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('tasks');
+/**
+ * Prepare mutant tasks from variants by pruning tests via per-test coverage,
+ * sorting tests deterministically, and computing cache keys.
+ */
+export function prepareTasks(variants, perTestCoverage) {
+    return variants.map((v) => {
+        let tests = Array.from(v.tests);
+        if (perTestCoverage && tests.length) {
+            const before = tests.length;
+            tests = filterTestsByCoverage(perTestCoverage, tests, v.file, v.line);
+            if (tests.length !== before) {
+                log.debug(`Pruned tests ${before} -> ${tests.length} for mutant ${v.name} via per-test coverage`);
+            }
+        }
+        tests.sort();
+        const testSig = hash(keyForTests(tests));
+        const codeSig = hash(v.code);
+        const key = `${testSig}:${codeSig}`;
+        return { v, tests, key };
+    });
+}

package/dist/runner/variants.d.ts

@@ -4,8 +4,10 @@
  * Functions for enumerating mutation variants from source files.
  * Handles both regular modules and Vue SFC files.
  */
-import type { MutateTarget } from '../types/config.js';
-import type { MutantPayload } from '../types/mutant.js';
+import type { MutateTarget, MutineerConfig } from '../types/config.js';
+import type { MutantPayload, Variant } from '../types/mutant.js';
+import { type CoverageData } from '../utils/coverage.js';
+import type { TestMap } from './discover.js';
 /**
  * Get file path from target (handles both string and object forms).
  */
@@ -18,4 +20,17 @@ export declare function enumerateVariantsForTarget(root: string, t: MutateTarget
  * Filter tests to only those that cover a specific line in a file.
  */
 export declare function filterTestsByCoverage(perTest: Map<string, Map<string, Set<number>>>, tests: readonly string[], filePath: string, line: number): string[];
+export interface EnumerateAllParams {
+    cwd: string;
+    targets: readonly MutateTarget[];
+    testMap: TestMap;
+    changedFiles: Set<string> | null;
+    coverageData: CoverageData | null;
+    config: MutineerConfig;
+}
+/**
+ * Enumerate variants for all targets, filtering by changed files and coverage.
+ * Links each variant to its relevant test files via the testMap.
+ */
+export declare function enumerateAllVariants(params: EnumerateAllParams): Promise<Variant[]>;
 export type { Variant } from '../types/mutant.js';

package/dist/runner/variants.js

@@ -8,6 +8,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { mutateVueSfcScriptSetup } from '../core/sfc.js';
 import { mutateModuleSource } from '../core/module.js';
+import { normalizePath } from '../utils/normalizePath.js';
+import { isLineCovered } from '../utils/coverage.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('variants');
 /**
@@ -64,3 +66,34 @@ export function filterTestsByCoverage(perTest, tests, filePath, line) {
         return lines.has(line);
     });
 }
+/**
+ * Enumerate variants for all targets, filtering by changed files and coverage.
+ * Links each variant to its relevant test files via the testMap.
+ */
+export async function enumerateAllVariants(params) {
+    const { cwd, targets, testMap, changedFiles, coverageData, config } = params;
+    const enumerated = await Promise.all(targets.map(async (target) => {
+        const file = getTargetFile(target);
+        const absFile = normalizePath(path.isAbsolute(file) ? file : path.join(cwd, file));
+        if (changedFiles && !changedFiles.has(absFile))
+            return [];
+        log.debug('Target file: ' + absFile);
+        const files = await enumerateVariantsForTarget(cwd, target, config.include, config.exclude, config.maxMutantsPerFile);
+        const testsAbs = testMap.get(normalizePath(absFile));
+        const tests = testsAbs ? Array.from(testsAbs) : [];
+        log.debug(`  found ${files.length} variants, linked to ${tests.length} tests`);
+        // Filter by coverage if enabled
+        let filtered = files;
+        if (coverageData) {
+            filtered = files.filter((v) => isLineCovered(coverageData, absFile, v.line));
+            if (filtered.length !== files.length) {
+                log.debug(`  filtered ${files.length} -> ${filtered.length} variants by coverage`);
+            }
+        }
+        return filtered.map((v) => ({ ...v, tests }));
+    }));
+    const variants = [];
+    for (const list of enumerated)
+        variants.push(...list);
+    return variants;
+}

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

@@ -3,6 +3,10 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { pathToFileURL } from 'node:url';
+vi.mock('node:module', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, register: vi.fn() };
+});
 import { resolve as poolResolve } from '../redirect-loader.js';
 describe('pool-redirect-loader resolve', () => {
     afterEach(() => {

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

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

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

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// We need to test with different DEBUG values, so we mock the module dynamically
+describe('logger', () => {
+    let originalDebug;
+    beforeEach(() => {
+        originalDebug = process.env.MUTINEER_DEBUG;
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        if (originalDebug === undefined) {
+            delete process.env.MUTINEER_DEBUG;
+        }
+        else {
+            process.env.MUTINEER_DEBUG = originalDebug;
+        }
+    });
+    it('info logs to console.log', async () => {
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const { createLogger } = await import('../logger.js');
+        const log = createLogger('test');
+        log.info('hello %s', 'world');
+        expect(spy).toHaveBeenCalledWith('hello %s', 'world');
+    });
+    it('warn logs to console.warn', async () => {
+        const spy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const { createLogger } = await import('../logger.js');
+        const log = createLogger('test');
+        log.warn('warning message');
+        expect(spy).toHaveBeenCalledWith('warning message');
+    });
+    it('error logs to console.error', async () => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { createLogger } = await import('../logger.js');
+        const log = createLogger('test');
+        log.error('error message');
+        expect(spy).toHaveBeenCalledWith('error message');
+    });
+    it('debug logs to console.error when DEBUG is enabled', async () => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // DEBUG is a module-level constant, so we check the tag prefix behavior
+        const { createLogger, DEBUG } = await import('../logger.js');
+        const log = createLogger('mytag');
+        log.debug('debug message');
+        if (DEBUG) {
+            expect(spy).toHaveBeenCalledWith('[mytag] debug message');
+        }
+        else {
+            // When DEBUG is false, debug should be a no-op
+            expect(spy).not.toHaveBeenCalled();
+        }
+    });
+    it('debug includes the tag prefix', async () => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { createLogger, DEBUG } = await import('../logger.js');
+        const log = createLogger('custom-tag');
+        log.debug('test');
+        if (DEBUG) {
+            expect(spy).toHaveBeenCalledWith(expect.stringContaining('[custom-tag]'));
+        }
+    });
+});

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

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

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

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { normalizePath } from '../normalizePath.js';
+describe('normalizePath', () => {
+    it('replaces backslashes with forward slashes', () => {
+        expect(normalizePath('src\\utils\\file.ts')).toBe('src/utils/file.ts');
+    });
+    it('handles multiple consecutive backslashes', () => {
+        expect(normalizePath('src\\\\file.ts')).toBe('src//file.ts');
+    });
+    it('leaves forward slashes unchanged', () => {
+        expect(normalizePath('src/utils/file.ts')).toBe('src/utils/file.ts');
+    });
+    it('handles empty string', () => {
+        expect(normalizePath('')).toBe('');
+    });
+    it('handles mixed slashes', () => {
+        expect(normalizePath('src\\utils/file.ts')).toBe('src/utils/file.ts');
+    });
+    it('handles Windows-style absolute paths', () => {
+        expect(normalizePath('C:\\Users\\dev\\project')).toBe('C:/Users/dev/project');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "v0.2.2",
+  "version": "v0.2.4",
   "type": "module",
   "private": false,
   "bin": {
@@ -62,6 +62,8 @@
     "eslint": "^9.39.1",
     "jsdom": "^27.0.0",
     "typescript": "^5.5.4",
+    "vite": "^6.3.6",
+    "vitest": "^4.0.15",
     "vue": "^3.5.12"
   }
 }