@mutineerjs/mutineer 0.2.4 → 0.4.0

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

@@ -38,6 +38,173 @@ describe('coverage utilities', () => {
         const coverage = { coveredLines: new Map() };
         expect(getFileCoverageStats(coverage, '/nope.ts')).toBeNull();
     });
+    it('loads coverage from a relative path', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const filePath = '/src/file.ts';
+        const data = {
+            [filePath]: {
+                path: filePath,
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 1 },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData('cov.json', tmpDir);
+            expect(coverage.coveredLines.size).toBeGreaterThan(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('throws on missing coverage file', async () => {
+        await expect(loadCoverageData('/nonexistent/path.json', '/tmp')).rejects.toThrow('Failed to read coverage file');
+    });
+    it('throws on invalid JSON in coverage file', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        await fs.writeFile(path.join(tmpDir, 'bad.json'), 'not json', 'utf8');
+        try {
+            await expect(loadCoverageData(path.join(tmpDir, 'bad.json'), tmpDir)).rejects.toThrow('Failed to parse coverage file');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('skips files with missing statementMap or s', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const data = {
+            '/src/nomap.ts': { path: '/src/nomap.ts' },
+            '/src/nos.ts': {
+                path: '/src/nos.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData(path.join(tmpDir, 'cov.json'), tmpDir);
+            expect(coverage.coveredLines.size).toBe(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('normalizes relative file paths in coverage data', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const data = {
+            'src/relative.ts': {
+                path: 'src/relative.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 1 },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData(path.join(tmpDir, 'cov.json'), tmpDir);
+            // Should have resolved relative path
+            const absPath = path.join(tmpDir, 'src/relative.ts');
+            expect(coverage.coveredLines.has(absPath)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('skips files where all statements have zero hits', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const data = {
+            '/src/uncovered.ts': {
+                path: '/src/uncovered.ts',
+                statementMap: {
+                    '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } },
+                },
+                s: { '0': 0 },
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, 'cov.json'), JSON.stringify(data), 'utf8');
+        try {
+            const coverage = await loadCoverageData(path.join(tmpDir, 'cov.json'), tmpDir);
+            expect(coverage.coveredLines.size).toBe(0);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('isLineCovered returns false for uncovered file', () => {
+        const coverage = { coveredLines: new Map() };
+        expect(isLineCovered(coverage, '/nonexistent.ts', 1)).toBe(false);
+    });
+    it('returns null for per-test coverage when no files found', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        await fs.mkdir(path.join(tmpDir, 'empty-reports'), { recursive: true });
+        try {
+            const map = await loadPerTestCoverageData(path.join(tmpDir, 'empty-reports'), tmpDir);
+            expect(map).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('loads per-test coverage in format B (direct arrays)', 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 formatB = {
+            '/test/a.spec.ts': {
+                '/src/a.ts': [1, 2, 3],
+            },
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(formatB), 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(reportsDir, tmpDir);
+            expect(map).not.toBeNull();
+            const lines = map.get('/test/a.spec.ts').get('/src/a.ts');
+            expect(lines.has(1)).toBe(true);
+            expect(lines.has(3)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('handles per-test coverage with non-object/null values gracefully', 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 data = {
+            '/test/a.spec.ts': null,
+            '/test/b.spec.ts': 'not-an-object',
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(data), 'utf8');
+        try {
+            const map = await loadPerTestCoverageData(reportsDir, tmpDir);
+            // No valid entries, should return null
+            expect(map).toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('uses relative reportsDir when not absolute', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-coverage-'));
+        const reportsDir = path.join(tmpDir, 'reports');
+        await fs.mkdir(reportsDir, { recursive: true });
+        const data = {
+            '/test/a.spec.ts': { '/src/a.ts': [1] },
+        };
+        await fs.writeFile(path.join(reportsDir, 'per-test-coverage.json'), JSON.stringify(data), 'utf8');
+        try {
+            // Pass relative path
+            const map = await loadPerTestCoverageData('reports', tmpDir);
+            expect(map).not.toBeNull();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     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');

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

@@ -47,4 +47,100 @@ describe('Progress', () => {
         progress.finish();
         expect(logSpy).toHaveBeenCalled();
     });
+    it('ignores update and finish calls when not started', () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const progress = new Progress(3, { mode: 'list' });
+        progress.update('killed'); // no-op: not started
+        progress.finish(); // no-op: not started
+        expect(logSpy).not.toHaveBeenCalled();
+    });
+    it('ignores duplicate start and calls after finish', () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const progress = new Progress(2, { mode: 'list' });
+        progress.start();
+        progress.start(); // no-op: already started
+        progress.finish();
+        progress.update('killed'); // no-op: already finished
+        progress.finish(); // no-op: already finished
+        // Only one start message and one finish message
+        const logs = logSpy.mock.calls.map((args) => args.join(' '));
+        const startLogs = logs.filter((l) => l.includes('running 2 mutants'));
+        expect(startLogs).toHaveLength(1);
+    });
+    it('uses stdout stream when configured', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const progress = new Progress(1, { mode: 'list', stream: 'stdout' });
+        progress.start();
+        progress.update('killed');
+        progress.finish();
+        // Should still log to console (non-TTY path)
+        expect(console.log).toHaveBeenCalled();
+    });
+    it('writes progress bar in TTY mode', () => {
+        const writeSpy = vi.fn();
+        const fakeStream = {
+            isTTY: true,
+            write: writeSpy,
+            columns: 120,
+        };
+        // Patch process.stderr to simulate TTY
+        const origStderr = process.stderr;
+        Object.defineProperty(process, 'stderr', {
+            value: fakeStream,
+            writable: true,
+            configurable: true,
+        });
+        try {
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const progress = new Progress(3, { mode: 'bar' });
+            progress.start();
+            expect(writeSpy).toHaveBeenCalled(); // hide cursor + bar
+            const hideCursor = writeSpy.mock.calls.find((c) => c[0].includes('\x1b[?25l'));
+            expect(hideCursor).toBeDefined();
+            progress.update('killed');
+            progress.update('escaped');
+            progress.finish();
+            // Show cursor on finish
+            const showCursor = writeSpy.mock.calls.find((c) => c[0].includes('\x1b[?25h'));
+            expect(showCursor).toBeDefined();
+            // Final summary still logged via console.log
+            expect(logSpy).toHaveBeenCalled();
+        }
+        finally {
+            Object.defineProperty(process, 'stderr', {
+                value: origStderr,
+                writable: true,
+                configurable: true,
+            });
+        }
+    });
+    it('handles zero total in bar mode', () => {
+        const writeSpy = vi.fn();
+        const fakeStream = {
+            isTTY: true,
+            write: writeSpy,
+            columns: 80,
+        };
+        const origStderr = process.stderr;
+        Object.defineProperty(process, 'stderr', {
+            value: fakeStream,
+            writable: true,
+            configurable: true,
+        });
+        try {
+            vi.spyOn(console, 'log').mockImplementation(() => { });
+            const progress = new Progress(0, { mode: 'bar' });
+            progress.start();
+            progress.finish();
+            // Should not throw; ratio should be 1 (100%)
+            expect(writeSpy).toHaveBeenCalled();
+        }
+        finally {
+            Object.defineProperty(process, 'stderr', {
+                value: origStderr,
+                writable: true,
+                configurable: true,
+            });
+        }
+    });
 });

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,10 +1,33 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "v0.2.4",
+  "version": "0.4.0",
+  "description": "A fast, targeted mutation testing framework for JavaScript and TypeScript",
   "type": "module",
   "private": false,
+  "license": "MIT",
+  "author": "Billy Jones",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mutineerjs/mutineer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mutineerjs/mutineer/issues"
+  },
+  "homepage": "https://github.com/mutineerjs/mutineer#readme",
+  "keywords": [
+    "mutation-testing",
+    "testing",
+    "vitest",
+    "jest",
+    "typescript",
+    "javascript",
+    "code-quality"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
   "bin": {
-    "mutineer": "./dist/bin/mutineer.js"
+    "mutineer": "dist/bin/mutineer.js"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,46 +47,72 @@
     "test:watch": "vitest",
     "test:coverage": "vitest --run --coverage",
     "lint": "eslint --config ./eslint.config.cjs --ext .ts,.js src/",
-    "mutate": "MUTINEER_DEBUG=0 tsx src/bin/mutineer.ts --config mutineer.config.ts"
+    "mutate": "MUTINEER_DEBUG=0 tsx src/bin/mutineer.ts --config mutineer.config.ts",
+    "prepare": "husky",
+    "prepublishOnly": "npm run build"
+  },
+  "lint-staged": {
+    "src/**/*.ts": [
+      "eslint --config ./eslint.config.cjs --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
   },
   "dependencies": {
-    "@babel/parser": "^7.28.4",
-    "@babel/traverse": "^7.28.4",
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.28.4",
     "chalk": "^5.6.2",
     "fast-glob": "^3.3.3",
-    "ink": "^5.2.1",
+    "ink": "^6.8.0",
     "ink-spinner": "^5.0.0",
     "magic-string": "^0.30.9",
-    "react": "^18.3.1",
-    "tsx": "^4.20.6"
+    "react": "^19.2.4",
+    "tsx": "^4.21.0"
   },
   "peerDependencies": {
     "@vitejs/plugin-vue": "^5.1.4",
     "@vitest/coverage-v8": "^4.0.15",
     "@vue/compiler-sfc": ">=3.4.0",
     "esbuild": "^0.25.10",
-    "vite": "^6.3.6",
-    "vitest": "^4.0.15"
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
   },
   "peerDependenciesMeta": {
-    "@vitejs/plugin-vue": { "optional": true },
-    "@vitest/coverage-v8": { "optional": true },
-    "@vue/compiler-sfc": { "optional": true },
-    "vitest": { "optional": true },
-    "vite": { "optional": true }
+    "@vitejs/plugin-vue": {
+      "optional": true
+    },
+    "@vitest/coverage-v8": {
+      "optional": true
+    },
+    "@vue/compiler-sfc": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@commitlint/cli": "^20.4.3",
+    "@commitlint/config-conventional": "^20.4.3",
     "@types/babel__traverse": "^7.28.0",
-    "@types/node": "^24.7.0",
+    "@types/node": "^25.3.5",
     "@types/react": "^19.2.14",
-    "@typescript-eslint/eslint-plugin": "^8.47.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
     "@typescript-eslint/parser": "^8.47.0",
-    "eslint": "^9.39.1",
-    "jsdom": "^27.0.0",
+    "eslint": "^10.0.3",
+    "husky": "^9.1.7",
+    "jsdom": "^28.1.0",
+    "lint-staged": "^16.1.0",
+    "prettier": "^3.8.1",
     "typescript": "^5.5.4",
-    "vite": "^6.3.6",
-    "vitest": "^4.0.15",
-    "vue": "^3.5.12"
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18",
+    "vue": "^3.5.30"
   }
 }