@mutineerjs/mutineer 0.3.2 → 0.4.0

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

@@ -193,6 +193,99 @@ describe('executePool', () => {
         const content = JSON.parse(await fs.readFile(cacheFile, 'utf8'));
         expect(content['persist-key']).toBeDefined();
     });
+    it('escaped mutant stores snippets when lines differ', async () => {
+        const tmpFile = path.join(tmpDir, 'source.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'snippet-key',
+            v: {
+                id: 'source.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/file.test.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['snippet-key'].originalSnippet).toBe('const x = a + b');
+        expect(cache['snippet-key'].mutatedSnippet).toBe('const x = a - b');
+    });
+    it('escaped mutant omits snippets when original and mutated lines are identical', async () => {
+        const tmpFile = path.join(tmpDir, 'source2.ts');
+        await fs.writeFile(tmpFile, 'const x = a + b\n');
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'no-snippet-key',
+            v: {
+                id: 'source2.ts#0',
+                name: 'flipArith',
+                file: tmpFile,
+                code: 'const x = a + b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/file.test.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['no-snippet-key'].originalSnippet).toBeUndefined();
+    });
+    it('escaped mutant omits snippets when file read fails', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 1 }),
+        });
+        const cache = {};
+        const task = makeTask({
+            key: 'missing-file-key',
+            v: {
+                id: 'missing.ts#0',
+                name: 'flipArith',
+                file: '/nonexistent/path/missing.ts',
+                code: 'const x = a - b\n',
+                line: 1,
+                col: 10,
+                tests: ['/tests/file.test.ts'],
+            },
+        });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(cache['missing-file-key'].status).toBe('escaped');
+        expect(cache['missing-file-key'].originalSnippet).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/pool-executor.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import { render } from 'ink';
 import { createElement } from 'react';
 import { Progress } from '../utils/progress.js';
@@ -93,12 +94,31 @@ export async function executePool(opts) {
             col: v.col,
         }, tests);
         const status = result.status;
+        let originalSnippet;
+        let mutatedSnippet;
+        if (status === 'escaped') {
+            try {
+                const originalLines = fs.readFileSync(v.file, 'utf8').split('\n');
+                const mutatedLines = v.code.split('\n');
+                const lineIdx = v.line - 1;
+                const orig = originalLines[lineIdx]?.trim();
+                const mutated = mutatedLines[lineIdx]?.trim();
+                if (orig !== undefined && mutated !== undefined && orig !== mutated) {
+                    originalSnippet = orig;
+                    mutatedSnippet = mutated;
+                }
+            }
+            catch {
+                // best-effort
+            }
+        }
         cache[key] = {
             status,
             file: v.file,
             line: v.line,
             col: v.col,
             mutator: v.name,
+            ...(originalSnippet !== undefined && { originalSnippet, mutatedSnippet }),
         };
         progress.update(status);
     }

package/dist/types/mutant.d.ts

@@ -25,6 +25,8 @@ export interface Variant extends MutantDescriptor {
 export interface MutantCacheEntry extends MutantLocation {
     readonly status: MutantStatus;
     readonly mutator: string;
+    readonly originalSnippet?: string;
+    readonly mutatedSnippet?: string;
 }
 export interface MutantResult extends MutantCacheEntry {
     readonly id: string;

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

@@ -43,6 +43,34 @@ describe('summary', () => {
         expect(lines.some((l) => l.includes('Duration: 1.50s'))).toBe(true);
         logSpy.mockRestore();
     });
+    it('prints diff lines for escaped mutant with snippets', () => {
+        const cache = {
+            a: makeEntry({
+                status: 'escaped',
+                originalSnippet: 'return a + b',
+                mutatedSnippet: 'return a - b',
+            }),
+        };
+        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('- return a + b'))).toBe(true);
+        expect(lines.some((l) => l.includes('+ return a - b'))).toBe(true);
+        logSpy.mockRestore();
+    });
+    it('does not print diff lines for escaped mutant without snippets', () => {
+        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.trimStart().startsWith('- '))).toBe(false);
+        expect(lines.some((l) => l.trimStart().startsWith('+ '))).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

@@ -74,8 +74,14 @@ export function printSummary(summary, cache, durationMs) {
     }
     if (entriesByStatus.escaped.length) {
         console.log('\n' + chalk.red.bold('Escaped Mutants:'));
-        for (const entry of entriesByStatus.escaped)
+        for (const entry of entriesByStatus.escaped) {
             console.log('  ' + formatRow(entry));
+            if (entry.originalSnippet !== undefined &&
+                entry.mutatedSnippet !== undefined) {
+                console.log('    ' + chalk.red('- ' + entry.originalSnippet));
+                console.log('    ' + chalk.green('+ ' + entry.mutatedSnippet));
+            }
+        }
     }
     if (entriesByStatus.skipped.length) {
         console.log('\n' + chalk.dim('Skipped Mutants:'));

package/package.json

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