@mutineerjs/mutineer 0.2.3 → 0.3.2

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__/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/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/package.json

@@ -1,10 +1,33 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "v0.2.3",
+  "version": "0.3.2",
+  "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"
   }
 }