@mutineerjs/mutineer 0.4.0 → 0.5.0

package/dist/runner/__tests__/discover.spec.js

@@ -35,6 +35,34 @@ vi.mock('vite', async () => {
     };
 });
 describe('autoDiscoverTargetsAndTests', () => {
+    it('directTestMap only includes direct importers', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-direct-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const moduleX = path.join(srcDir, 'x.ts');
+        const moduleY = path.join(srcDir, 'y.ts');
+        const testFile = path.join(srcDir, 'a.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(moduleY, 'export const y = 2\n', 'utf8');
+        const importY = ['im', 'port { y } from "./y"'].join('');
+        await fs.writeFile(moduleX, `${importY}\nexport const x = 1\n`, 'utf8');
+        const importX = ['im', 'port { x } from "./x"'].join('');
+        await fs.writeFile(testFile, `${importX}\nconsole.log(x)\n`, 'utf8');
+        try {
+            const { directTestMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const testAbs = normalizePath(testFile);
+            const xAbs = normalizePath(moduleX);
+            const yAbs = normalizePath(moduleY);
+            // x is directly imported by the test
+            expect(directTestMap.get(xAbs)?.has(testAbs)).toBe(true);
+            // y is only transitively imported (x -> y), not directly by the test
+            expect(directTestMap.get(yAbs)?.has(testAbs)).toBeFalsy();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('ignores test files when collecting mutate targets', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-'));
         const srcDir = path.join(tmpDir, 'src');

package/dist/runner/__tests__/pool-executor.spec.js

@@ -286,6 +286,90 @@ describe('executePool', () => {
         expect(cache['missing-file-key'].status).toBe('escaped');
         expect(cache['missing-file-key'].originalSnippet).toBeUndefined();
     });
+    it('escaped mutant stores coveringTests', async () => {
+        const tmpFile = path.join(tmpDir, 'covering.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const tests = ['/tests/foo.spec.ts', '/tests/bar.spec.ts'];
+        const task = makeTask({
+            key: 'covering-key',
+            tests,
+            v: {
+                id: 'covering.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests,
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['covering-key'].coveringTests).toEqual(tests);
+    });
+    it('escaped mutant uses directTests for coveringTests when available', async () => {
+        const tmpFile = path.join(tmpDir, 'direct-covering.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const directTests = ['/direct.spec.ts'];
+        const allTests = ['/direct.spec.ts', '/transitive.spec.ts'];
+        const task = makeTask({
+            key: 'direct-covering-key',
+            tests: allTests,
+            directTests,
+            v: {
+                id: 'direct-covering.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests: allTests,
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['direct-covering-key'].coveringTests).toEqual(directTests);
+    });
+    it('killed mutant does not store coveringTests', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi.fn().mockResolvedValue({ status: 'killed', durationMs: 1 }),
+        });
+        const cache = {};
+        const task = makeTask({ key: 'killed-covering-key' });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['killed-covering-key'].coveringTests).toBeUndefined();
+    });
     it('handles adapter errors gracefully and still shuts down', async () => {
         const adapter = makeAdapter({
             runMutant: vi.fn().mockRejectedValue(new Error('adapter failure')),

package/dist/runner/__tests__/tasks.spec.js

@@ -80,6 +80,20 @@ describe('prepareTasks', () => {
         const tasks = prepareTasks([v], null);
         expect(tasks[0].tests).toHaveLength(2);
     });
+    it('populates directTests from directTestMap', () => {
+        const v = makeVariant({ file: '/src/file.ts', tests: ['/tests/a.test.ts'] });
+        const directTestMap = new Map([
+            ['/src/file.ts', new Set(['/tests/direct.test.ts'])],
+        ]);
+        const tasks = prepareTasks([v], null, directTestMap);
+        expect(tasks[0].directTests).toEqual(['/tests/direct.test.ts']);
+    });
+    it('directTests absent when not in directTestMap', () => {
+        const v = makeVariant({ file: '/src/file.ts', tests: ['/tests/a.test.ts'] });
+        const directTestMap = new Map();
+        const tasks = prepareTasks([v], null, directTestMap);
+        expect(tasks[0].directTests).toBeUndefined();
+    });
     it('handles multiple variants', () => {
         const variants = [
             makeVariant({ id: 'file.ts#0', code: 'code1' }),

package/dist/runner/discover.d.ts

@@ -3,5 +3,6 @@ export type TestMap = Map<string, Set<string>>;
 export interface DiscoveryResult {
     readonly targets: MutateTarget[];
     readonly testMap: TestMap;
+    readonly directTestMap: TestMap;
 }
 export declare function autoDiscoverTargetsAndTests(root: string, cfg: MutineerConfig): Promise<DiscoveryResult>;

package/dist/runner/discover.js

@@ -208,12 +208,13 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
         ignore,
     });
     if (!tests.length)
-        return { targets: [], testMap: new Map() };
+        return { targets: [], testMap: new Map(), directTestMap: new Map() };
     const testSet = new Set(tests.map((t) => normalizePath(t)));
     // 2) Create resolver (Vite if available, otherwise Node-based fallback)
     const { resolve, cleanup } = await createResolver(rootAbs, exts);
     const targets = new Map();
     const testMap = new Map();
+    const directTestMap = new Map();
     const contentCache = new Map();
     const resolveCache = new Map(); // key: importer\0spec -> resolved id
     async function crawl(absFile, depth, seen, currentTestAbs) {
@@ -242,6 +243,11 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
             if (!testMap.has(key))
                 testMap.set(key, new Set());
             testMap.get(key).add(currentTestAbs);
+            if (depth === 0) {
+                if (!directTestMap.has(key))
+                    directTestMap.set(key, new Set());
+                directTestMap.get(key).add(currentTestAbs);
+            }
         }
         // read file content to find further imports (works for .vue too; imports are inside <script>)
         let code = contentCache.get(absFile);
@@ -297,7 +303,7 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
                 await crawl(abs, 0, seen, testAbs);
             }
         }
-        return { targets: Array.from(targets.values()), testMap };
+        return { targets: Array.from(targets.values()), testMap, directTestMap };
     }
     finally {
         await cleanup();

package/dist/runner/orchestrator.js

@@ -68,7 +68,7 @@ export async function runOrchestrator(cliArgs, cwd) {
     // 4. Discover targets and tests
     const cache = await readMutantCache(cwd);
     const discovered = await autoDiscoverTargetsAndTests(cwd, cfg);
-    const testMap = discovered.testMap;
+    const { testMap, directTestMap } = discovered;
     const targets = cfg.targets?.length
         ? [...cfg.targets]
         : (cfg.autoDiscover ?? true)
@@ -122,7 +122,7 @@ export async function runOrchestrator(cliArgs, cwd) {
         return;
     }
     // 8. Prepare tasks and execute via worker pool
-    const tasks = prepareTasks(variants, updatedCoverage.perTestCoverage);
+    const tasks = prepareTasks(variants, updatedCoverage.perTestCoverage, directTestMap);
     await executePool({
         tasks,
         adapter,

package/dist/runner/pool-executor.js

@@ -66,7 +66,7 @@ export async function executePool(opts) {
     progress.start();
     let nextIdx = 0;
     async function processTask(task) {
-        const { v, tests, key } = task;
+        const { v, tests, key, directTests } = task;
         log.debug('Cache ' + JSON.stringify(cache));
         const cached = cache[key];
         if (cached) {
@@ -119,6 +119,10 @@ export async function executePool(opts) {
             col: v.col,
             mutator: v.name,
             ...(originalSnippet !== undefined && { originalSnippet, mutatedSnippet }),
+            ...(status === 'escaped' &&
+                (directTests ?? tests).length > 0 && {
+                coveringTests: directTests ?? tests,
+            }),
         };
         progress.update(status);
     }

package/dist/runner/tasks.d.ts

@@ -1,12 +1,14 @@
 import type { Variant } from '../types/mutant.js';
 import type { PerTestCoverageMap } from '../utils/coverage.js';
+import type { TestMap } from './discover.js';
 export interface MutantTask {
     v: Variant;
     tests: string[];
     key: string;
+    directTests?: readonly 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[];
+export declare function prepareTasks(variants: readonly Variant[], perTestCoverage: PerTestCoverageMap | null, directTestMap?: TestMap): MutantTask[];

package/dist/runner/tasks.js

@@ -1,12 +1,13 @@
 import { filterTestsByCoverage } from './variants.js';
 import { hash, keyForTests } from './cache.js';
 import { createLogger } from '../utils/logger.js';
+import { normalizePath } from '../utils/normalizePath.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) {
+export function prepareTasks(variants, perTestCoverage, directTestMap) {
     return variants.map((v) => {
         let tests = Array.from(v.tests);
         if (perTestCoverage && tests.length) {
@@ -20,6 +21,13 @@ export function prepareTasks(variants, perTestCoverage) {
         const testSig = hash(keyForTests(tests));
         const codeSig = hash(v.code);
         const key = `${testSig}:${codeSig}`;
-        return { v, tests, key };
+        const direct = directTestMap?.get(normalizePath(v.file));
+        return {
+            v,
+            tests,
+            key,
+            ...(direct &&
+                direct.size > 0 && { directTests: Array.from(direct).sort() }),
+        };
     });
 }

package/dist/types/mutant.d.ts

@@ -27,6 +27,7 @@ export interface MutantCacheEntry extends MutantLocation {
     readonly mutator: string;
     readonly originalSnippet?: string;
     readonly mutatedSnippet?: string;
+    readonly coveringTests?: readonly string[];
 }
 export interface MutantResult extends MutantCacheEntry {
     readonly id: string;

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

@@ -71,6 +71,32 @@ describe('summary', () => {
         expect(lines.some((l) => l.trimStart().startsWith('+ '))).toBe(false);
         logSpy.mockRestore();
     });
+    it('prints covering test path for escaped mutant', () => {
+        const cache = {
+            a: makeEntry({
+                status: 'escaped',
+                coveringTests: ['/abs/foo.spec.ts'],
+            }),
+        };
+        const summary = computeSummary(cache);
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        printSummary(summary, cache);
+        const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
+        expect(lines.some((l) => l.includes('↳'))).toBe(true);
+        expect(lines.some((l) => l.includes('foo.spec.ts'))).toBe(true);
+        logSpy.mockRestore();
+    });
+    it('does not print covering tests when array is absent', () => {
+        const cache = {
+            a: makeEntry({ status: 'escaped' }),
+        };
+        const summary = computeSummary(cache);
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        printSummary(summary, cache);
+        const lines = logSpy.mock.calls.map((c) => stripAnsi(c.join(' ')));
+        expect(lines.some((l) => l.includes('↳'))).toBe(false);
+        logSpy.mockRestore();
+    });
     it('summarise returns summary and prints', () => {
         const cache = { a: makeEntry({ status: 'killed' }) };
         const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });

package/dist/utils/summary.js

@@ -81,6 +81,15 @@ export function printSummary(summary, cache, durationMs) {
                 console.log('    ' + chalk.red('- ' + entry.originalSnippet));
                 console.log('    ' + chalk.green('+ ' + entry.mutatedSnippet));
             }
+            if (entry.coveringTests?.length) {
+                const shown = entry.coveringTests.slice(0, 2);
+                for (const t of shown) {
+                    console.log('    ' + chalk.dim('↳ ' + path.relative(cwd, t)));
+                }
+                if (entry.coveringTests.length > 2) {
+                    console.log('    ' + chalk.dim(`  +${entry.coveringTests.length - 2} more`));
+                }
+            }
         }
     }
     if (entriesByStatus.skipped.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A fast, targeted mutation testing framework for JavaScript and TypeScript",
   "type": "module",
   "private": false,