@mintwork/honest-tests 0.0.0-stage → 0.1.1

package/dist/adapters/js/index.d.ts

@@ -0,0 +1,25 @@
+import type { LanguageAdapter } from '../../core/types.js';
+export declare const jsAdapter: LanguageAdapter;
+export interface TestScript {
+    runner: 'vitest' | 'jest' | 'unknown';
+    /** The script that actually runs tests, after following `npm run x` / `pnpm x` delegation. */
+    script: string;
+    /** The script is one plain command (no `&&`, `;`, pipes) we can run directly with extra arguments. */
+    simple: boolean;
+    /** `test` only delegates to another script (`npm run test:unit`). */
+    delegated: boolean;
+    /** Coverage is switched on (`--coverage` in the script, or `enabled: true` in the runner config). */
+    coverage: boolean;
+}
+/** Follow `"test": "npm run test:unit"` chains to the script that runs the test runner. */
+export declare function resolveTestScript(root: string): TestScript;
+/** Which runner a package.json test script uses — lets us pass test files through. */
+export declare function detectRunner(root: string): 'vitest' | 'jest' | 'unknown';
+/**
+ * How to run `files` (already shell-quoted) once, never in watch mode:
+ * - `test` runs vitest/jest itself: `npm test --silent -- [--run] <files>` (keeps npm pre/post hooks).
+ * - `test` delegates (`npm run test:vitest`): run the plain leaf script directly, since npm would
+ *   swallow `--run` as one of its own flags.
+ * Returns null when we can't safely add arguments (unknown runner, `a && b` chains).
+ */
+export declare function scopedTestCommand(ts: TestScript, files: string[]): string | null;

package/dist/adapters/js/index.js

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { generateJsMutants } from './mutants.js';
+import { parseJsTestFile } from './parse-tests.js';
+const EXT = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.mts', '.cts'];
+const TEST_FILE = /(\.|_|-)(test|spec)\.(m|c)?[jt]sx?$/i;
+/** Co-located `foo/test.ts` / `foo/spec.js` (date-fns style). */
+const BARE_TEST_FILE = /(^|\/)(test|spec)\.(m|c)?[jt]sx?$/i;
+function stripExt(p) {
+    return p.replace(/\.(m|c)?[jt]sx?$/, '').replace(/\/index$/, '');
+}
+const IMPORT_RE = /(?:from\s+|import\s*\(\s*|require\s*\(\s*|mock\s*\(\s*|import\s+)['"]([^'"]+)['"]/g;
+/** Relative imports of a JS/TS file, as extension-less absolute module ids. */
+function localImports(path, source) {
+    const out = [];
+    for (const m of source.matchAll(IMPORT_RE)) {
+        const spec = m[1];
+        if (spec.startsWith('.'))
+            out.push(stripExt(resolve(dirname(path), spec)));
+    }
+    return out;
+}
+export const jsAdapter = {
+    id: 'js',
+    extensions: EXT,
+    isTestFile(path) {
+        const p = path.replace(/\\/g, '/');
+        return TEST_FILE.test(p) || BARE_TEST_FILE.test(p) || (/\/__tests__\//.test(p) && /\.(m|c)?[jt]sx?$/.test(p));
+    },
+    parseTestFile: parseJsTestFile,
+    generateMutants: generateJsMutants,
+    testImportsTarget(testPath, testSource, targetPath) {
+        return localImports(testPath, testSource).includes(stripExt(resolve(targetPath)));
+    },
+    localImports,
+    moduleId: (path) => stripExt(resolve(path)),
+    defaultTestCommand(root) {
+        const pkgPath = join(root, 'package.json');
+        if (!existsSync(pkgPath))
+            return null;
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+            const script = pkg.scripts?.test;
+            if (!script || /no test specified/.test(script))
+                return null;
+            return 'npm test --silent';
+        }
+        catch {
+            return null;
+        }
+    },
+};
+const RUNNER_CONFIGS = [
+    'vitest.config.ts', 'vitest.config.mts', 'vitest.config.js', 'vitest.config.mjs',
+    'vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs',
+    'jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs',
+];
+function coverageEnabledInConfig(root) {
+    for (const name of RUNNER_CONFIGS) {
+        try {
+            const text = readFileSync(join(root, name), 'utf8');
+            if (/coverage\s*:\s*\{[^}]*enabled\s*:\s*true|collectCoverage\s*:\s*true/.test(text))
+                return true;
+        }
+        catch {
+            /* not there */
+        }
+    }
+    return false;
+}
+/** Follow `"test": "npm run test:unit"` chains to the script that runs the test runner. */
+export function resolveTestScript(root) {
+    let scripts = {};
+    try {
+        scripts = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).scripts ?? {};
+    }
+    catch {
+        /* ignore */
+    }
+    let script = scripts.test ?? '';
+    let delegated = false;
+    for (let hops = 0; hops < 5; hops++) {
+        const m = /^\s*(?:npm run|npm run-script|pnpm(?: run)?|yarn(?: run)?|bun run)\s+([\w:.-]+)\s*$/.exec(script);
+        if (!m || scripts[m[1]] === undefined)
+            break;
+        script = scripts[m[1]];
+        delegated = true;
+    }
+    const runner = /\bvitest\b/.test(script) ? 'vitest' : /\bjest\b/.test(script) ? 'jest' : 'unknown';
+    return {
+        runner,
+        script: script.trim(),
+        simple: !/&&|\|\||;|\||`|\$\(/.test(script),
+        delegated,
+        coverage: /--coverage\b(?!=false|\.enabled=false)/.test(script) || coverageEnabledInConfig(root),
+    };
+}
+/** Which runner a package.json test script uses — lets us pass test files through. */
+export function detectRunner(root) {
+    return resolveTestScript(root).runner;
+}
+/**
+ * How to run `files` (already shell-quoted) once, never in watch mode:
+ * - `test` runs vitest/jest itself: `npm test --silent -- [--run] <files>` (keeps npm pre/post hooks).
+ * - `test` delegates (`npm run test:vitest`): run the plain leaf script directly, since npm would
+ *   swallow `--run` as one of its own flags.
+ * Returns null when we can't safely add arguments (unknown runner, `a && b` chains).
+ */
+export function scopedTestCommand(ts, files) {
+    if (ts.runner === 'unknown')
+        return null;
+    // A bare `vitest` script starts a watcher; mutation runs must exit.
+    const needsRun = ts.runner === 'vitest' && !/\bvitest\s+(run|bench)\b|--run\b|--watch=false|--no-watch\b/.test(ts.script);
+    // Coverage only slows mutant runs down, and global thresholds fail when we run a subset of tests.
+    const noCoverage = ts.coverage ? [ts.runner === 'vitest' ? '--coverage.enabled=false' : '--coverage=false'] : [];
+    const extra = [...(needsRun ? ['--run'] : []), ...noCoverage, ...files];
+    if (!ts.delegated)
+        return extra.length ? `npm test --silent -- ${extra.join(' ')}` : 'npm test --silent';
+    if (!ts.simple)
+        return null;
+    return [ts.script, ...extra].join(' ');
+}

package/dist/adapters/js/mutants.d.ts

@@ -0,0 +1,8 @@
+import type { Mutant } from '../../core/types.js';
+/**
+ * Generate simple, high-signal mutants for a JS/TS source file:
+ * operator flips, boolean flips, negation removal, numeric tweaks, and
+ * return-value replacement. Type-only syntax is never touched.
+ */
+export declare function generateJsMutants(path: string, source: string): Mutant[];
+export declare function applyMutant(source: string, m: Mutant): string;

package/dist/adapters/js/mutants.js

@@ -0,0 +1,190 @@
+import { isCall, isMember, parseSource, textOf, walk } from './ast.js';
+const BINARY_SWAPS = {
+    '===': '!==',
+    '!==': '===',
+    '==': '!=',
+    '!=': '==',
+    '<': '<=',
+    '<=': '<',
+    '>': '>=',
+    '>=': '>',
+    '+': '-',
+    '-': '+',
+    '*': '/',
+    '/': '*',
+    '%': '*',
+};
+const LOGICAL_SWAPS = {
+    '&&': '||',
+    '||': '&&',
+};
+const ASSIGN_SWAPS = {
+    '+=': '-=',
+    '-=': '+=',
+    '*=': '/=',
+    '/=': '*=',
+};
+/** Calls whose arguments we never mutate (noise, not behavior). */
+const SKIP_CALLEE = /^(console|logger|log|debug|assert|invariant)$/;
+function isStringish(node) {
+    return node.type === 'StringLiteral' || node.type === 'TemplateLiteral';
+}
+/**
+ * Generate simple, high-signal mutants for a JS/TS source file:
+ * operator flips, boolean flips, negation removal, numeric tweaks, and
+ * return-value replacement. Type-only syntax is never touched.
+ */
+export function generateJsMutants(path, source) {
+    const ast = parseSource(path, source);
+    const mutants = [];
+    const seen = new Set();
+    const lineStarts = [0];
+    for (let i = 0; i < source.length; i++)
+        if (source[i] === '\n')
+            lineStarts.push(i + 1);
+    const position = (offset) => {
+        let lo = 0;
+        let hi = lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStarts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return { line: lo + 1, column: offset - lineStarts[lo] + 1 };
+    };
+    const short = (s) => {
+        const one = s.replace(/\s+/g, ' ');
+        return one.length > 40 ? one.slice(0, 39) + '…' : one;
+    };
+    const add = (_node, start, end, replacement, operator, description) => {
+        const key = `${start}:${end}:${replacement}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        const original = source.slice(start, end);
+        if (original === replacement)
+            return;
+        mutants.push({
+            id: 0,
+            file: path,
+            ...position(start),
+            start,
+            end,
+            original,
+            replacement,
+            operator,
+            description,
+        });
+    };
+    walk(ast, (node, ancestors) => {
+        // Never mutate types, imports, or logging.
+        if (node.type.startsWith('TS') && !['TSAsExpression', 'TSSatisfiesExpression', 'TSNonNullExpression'].includes(node.type)) {
+            return false;
+        }
+        if (node.type === 'ImportDeclaration' || node.type === 'ExportAllDeclaration' || node.type === 'Directive')
+            return false;
+        if (isCall(node)) {
+            let callee = node.callee;
+            while (isMember(callee))
+                callee = callee.object;
+            if (callee.type === 'Identifier' && SKIP_CALLEE.test(callee.name))
+                return false;
+        }
+        const parent = ancestors[ancestors.length - 1];
+        switch (node.type) {
+            case 'BinaryExpression': {
+                const swap = BINARY_SWAPS[node.operator];
+                if (!swap)
+                    break;
+                if ((node.operator === '+' || node.operator === '-') && (isStringish(node.left) || isStringish(node.right)))
+                    break;
+                const left = node.left;
+                const opStart = source.indexOf(node.operator, left.end);
+                if (opStart < 0 || opStart >= node.right.start)
+                    break;
+                add(node, opStart, opStart + node.operator.length, swap, 'binary', `\`${node.operator}\` → \`${swap}\``);
+                break;
+            }
+            case 'LogicalExpression': {
+                const swap = LOGICAL_SWAPS[node.operator];
+                if (!swap)
+                    break;
+                const opStart = source.indexOf(node.operator, node.left.end);
+                if (opStart < 0 || opStart >= node.right.start)
+                    break;
+                add(node, opStart, opStart + node.operator.length, swap, 'logical', `\`${node.operator}\` → \`${swap}\``);
+                break;
+            }
+            case 'AssignmentExpression': {
+                const swap = ASSIGN_SWAPS[node.operator];
+                if (!swap)
+                    break;
+                const opStart = source.indexOf(node.operator, node.left.end);
+                if (opStart < 0 || opStart >= node.right.start)
+                    break;
+                add(node, opStart, opStart + node.operator.length, swap, 'assignment', `\`${node.operator}\` → \`${swap}\``);
+                break;
+            }
+            case 'BooleanLiteral': {
+                add(node, node.start, node.end, String(!node.value), 'boolean', `\`${node.value}\` → \`${!node.value}\``);
+                break;
+            }
+            case 'UnaryExpression': {
+                if (node.operator === '!') {
+                    const arg = textOf(source, node.argument);
+                    add(node, node.start, node.end, `(${arg})`, 'negation', `removed \`!\` from \`!${short(arg)}\``);
+                }
+                break;
+            }
+            case 'NumericLiteral': {
+                // Skip array indices and object keys; they are rarely behavior and mostly noise.
+                if (parent && isMember(parent) && parent.property === node)
+                    break;
+                if (parent && parent.type === 'ObjectProperty' && parent.key === node)
+                    break;
+                const raw = textOf(source, node);
+                if (!/^\d+(\.\d+)?$/.test(raw))
+                    break;
+                const next = node.value === 0 ? '1' : node.value === 1 ? '0' : String(node.value + 1);
+                add(node, node.start, node.end, next, 'number', `\`${raw}\` → \`${next}\``);
+                break;
+            }
+            case 'ReturnStatement': {
+                const arg = node.argument;
+                if (!arg)
+                    break;
+                if (arg.type === 'BooleanLiteral' || (arg.type === 'Identifier' && arg.name === 'undefined'))
+                    break;
+                const fn = [...ancestors].reverse().find((a) => a.type.includes('Function'));
+                if (fn && fn.generator)
+                    break;
+                add(node, arg.start, arg.end, 'undefined', 'return', `return value replaced with \`undefined\``);
+                break;
+            }
+            case 'ArrowFunctionExpression': {
+                if (node.body.type !== 'BlockStatement' && node.body.type !== 'BooleanLiteral') {
+                    const body = node.body;
+                    add(body, body.start, body.end, 'undefined', 'return', `arrow return value replaced with \`undefined\``);
+                }
+                break;
+            }
+            case 'IfStatement': {
+                const test = node.test;
+                add(test, test.start, test.end, 'true', 'condition', `condition \`${short(textOf(source, test))}\` → \`true\``);
+                add(test, test.start, test.end, 'false', 'condition', `condition \`${short(textOf(source, test))}\` → \`false\``);
+                break;
+            }
+            default:
+                break;
+        }
+        return undefined;
+    });
+    mutants.sort((a, b) => a.start - b.start || a.end - b.end);
+    mutants.forEach((m, i) => (m.id = i + 1));
+    return mutants;
+}
+export function applyMutant(source, m) {
+    return source.slice(0, m.start) + m.replacement + source.slice(m.end);
+}

package/dist/adapters/js/parse-tests.d.ts

@@ -0,0 +1,5 @@
+import type { MatcherKind, TestFileModel } from '../../core/types.js';
+export declare function matcherKindOf(name: string | null): MatcherKind;
+/** Expected unit-under-test name for a test file: `pricing.test.ts` -> `pricing`. */
+export declare function unitNameForTestFile(path: string): string;
+export declare function parseJsTestFile(path: string, source: string): TestFileModel;