vibecodedshit 0.0.0-stage → 0.2.0

package/dist/exec/steps/install.js

@@ -0,0 +1,41 @@
+import { inDir, jsManager, requirementsFiles } from './lockfiles.js';
+const JS_INSTALL = {
+    npm: { locked: ['npm', 'ci'], unlocked: ['npm', 'install'] },
+    pnpm: { locked: ['pnpm', 'install', '--frozen-lockfile'], unlocked: ['pnpm', 'install'] },
+    yarn: { locked: ['yarn', 'install', '--immutable'], unlocked: ['yarn', 'install'] },
+    bun: { locked: ['bun', 'install', '--frozen-lockfile'], unlocked: ['bun', 'install'] },
+};
+/** pip installs into `.venv`, so later steps find the packages the same way as with uv, poetry, pdm and pipenv. */
+function pip(args) {
+    return ['sh', '-c', 'python -m venv .venv && exec .venv/bin/pip install "$@"', 'sh', ...args];
+}
+/** Dependencies from the lockfile, or from the manifest when there is none. The only step with the network on. */
+export const install = {
+    name: 'install',
+    network: true,
+    command(ctx) {
+        if (ctx.group === 'typescript_javascript') {
+            if (!ctx.tracked.has(inDir(ctx, 'package.json')))
+                return null;
+            const { manager, locked } = jsManager(ctx);
+            return { argv: [...JS_INSTALL[manager][locked ? 'locked' : 'unlocked']] };
+        }
+        const has = (name) => ctx.tracked.has(inDir(ctx, name));
+        if (has('uv.lock'))
+            return { argv: ['uv', 'sync', '--frozen'] };
+        if (has('poetry.lock'))
+            return { argv: ['poetry', 'install', '--sync'] };
+        if (has('pdm.lock'))
+            return { argv: ['pdm', 'sync'] };
+        if (has('Pipfile.lock'))
+            return { argv: ['pipenv', 'sync'] };
+        const requirements = requirementsFiles(ctx);
+        if (requirements.length > 0)
+            return { argv: pip(requirements.flatMap((file) => ['-r', file])) };
+        if (has('Pipfile'))
+            return { argv: ['pipenv', 'install'] };
+        if (has('pyproject.toml') || has('setup.py'))
+            return { argv: pip(['.']) };
+        return null;
+    },
+};

package/dist/exec/steps/knip.js

@@ -0,0 +1,28 @@
+const KNIP_CONFIG = '/opt/health/knip.json';
+/**
+ * Knip in the installed work copy, for 4.4 and 5.5. The repository's own knip config is not used
+ * (an empty config baked into the image), framework plugins stay enabled. DOTENV_CONFIG_QUIET keeps
+ * dotenv 17 from printing its banner into the report. Network off.
+ */
+export const knip = {
+    name: 'knip',
+    network: false,
+    command() {
+        return {
+            argv: [
+                'health-capture',
+                '/out/knip.json',
+                'env',
+                'DOTENV_CONFIG_QUIET=true',
+                'knip',
+                '--reporter',
+                'json',
+                '--no-progress',
+                '--no-config-hints',
+                '--config',
+                KNIP_CONFIG,
+            ],
+            report: 'knip.json',
+        };
+    },
+};

package/dist/exec/steps/lint.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+const ESLINT_CONFIG = '/opt/health/eslint.config.mjs';
+const RUFF_CONFIG = '/opt/health/ruff.toml';
+/** The methodology's pinned ESLint and ruff rulesets, baked into the image. The repository's own lint config is never used. Network off. */
+export const lint = {
+    name: 'lint',
+    network: false,
+    command(ctx) {
+        const files = ctx.files.map((file) => path.posix.relative(ctx.dir, file));
+        if (files.length === 0)
+            return null;
+        if (ctx.group === 'typescript_javascript') {
+            return {
+                argv: ['health-capture', '/out/eslint.json', 'health-eslint', '-c', ESLINT_CONFIG, '-f', 'json', '--no-error-on-unmatched-pattern', ...files],
+                tool: 'eslint',
+                report: 'eslint.json',
+            };
+        }
+        return {
+            argv: ['health-capture', '/out/ruff.json', 'ruff', 'check', '--config', RUFF_CONFIG, '--no-cache', '--output-format', 'json', ...files],
+            tool: 'ruff',
+            report: 'ruff.json',
+        };
+    },
+};

package/dist/exec/steps/lockfiles.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { chooseJsLockfile } from '../../measure/deps/lockfiles.js';
+export function inDir(ctx, name) {
+    return path.posix.join(ctx.dir, name);
+}
+const MANAGER = {
+    'pnpm-lock.yaml': 'pnpm',
+    'yarn.lock': 'yarn',
+    'bun.lock': 'bun',
+    'bun.lockb': 'bun',
+    'npm-shrinkwrap.json': 'npm',
+    'package-lock.json': 'npm',
+};
+/** The package manager of the lockfile `chooseJsLockfile` picks (the one D5 reads); npm when there is none. */
+export function jsManager(ctx) {
+    const chosen = chooseJsLockfile(Object.keys(MANAGER).filter((name) => ctx.tracked.has(inDir(ctx, name))));
+    return chosen === undefined ? { manager: 'npm', locked: false } : { manager: MANAGER[chosen] ?? 'npm', locked: true };
+}
+/** `requirements*.txt` files directly in the directory, sorted. */
+export function requirementsFiles(ctx) {
+    return [...ctx.tracked]
+        .filter((file) => path.posix.dirname(file) === ctx.dir && /^requirements.*\.txt$/.test(path.posix.basename(file)))
+        .map((file) => path.posix.basename(file))
+        .sort();
+}

package/dist/exec/steps/test.js

@@ -0,0 +1,17 @@
+import { logicGlobs, pythonTargets } from '../test-runners/detect.js';
+import { RUNNERS } from '../test-runners/index.js';
+/**
+ * One run of the invocation's test runner with the report and coverage flags of the methodology, so the
+ * results and the coverage come from a single instrumented run (1.1 to 1.3, and 6.3's test time).
+ * The reports are read from /out, never stdout; the exit code is not the pass/fail source. Network off.
+ */
+export const test = {
+    name: 'test',
+    network: false,
+    command(ctx) {
+        const invocation = ctx.invocation;
+        if (!invocation)
+            return null;
+        return { argv: RUNNERS[invocation.runner].argv(invocation, logicGlobs(ctx.files, ctx.dir), pythonTargets(ctx.files, ctx.dir)) };
+    },
+};

package/dist/exec/steps/typecheck.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { inDir } from './lockfiles.js';
+const JS_FILE = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i;
+function pythonTool(ctx) {
+    const has = (name) => ctx.tracked.has(inDir(ctx, name));
+    const pyproject = ctx.read(inDir(ctx, 'pyproject.toml')) ?? '';
+    if (has('pyrightconfig.json') || /^\s*\[tool\.pyright\]/m.test(pyproject))
+        return 'pyright';
+    const setupCfg = ctx.read(inDir(ctx, 'setup.cfg')) ?? '';
+    if (has('mypy.ini') || has('.mypy.ini') || /^\s*\[tool\.mypy\]/m.test(pyproject) || /^\s*\[mypy\]/m.test(setupCfg))
+        return 'mypy';
+    return 'pyright';
+}
+/** tsc or pyright (mypy when only mypy is configured) with the repository's own config. Network off. */
+export const typecheck = {
+    name: 'typecheck',
+    network: false,
+    command(ctx) {
+        if (ctx.group === 'typescript_javascript') {
+            const base = ['health-capture', '/out/tsc.txt', 'health-tsc', '--noEmit', '--pretty', 'false'];
+            const project = ['tsconfig.json', 'jsconfig.json'].find((name) => ctx.tracked.has(inDir(ctx, name)));
+            if (project)
+                return { argv: [...base, '-p', project], tool: 'tsc', report: 'tsc.txt' };
+            const files = ctx.files.filter((file) => JS_FILE.test(file)).map((file) => path.posix.relative(ctx.dir, file));
+            if (files.length === 0)
+                return null;
+            // No tsconfig or jsconfig: the methodology's default config.
+            const defaults = ['--allowJs', '--checkJs', '--strict', 'false', '--target', 'esnext', '--module', 'esnext', '--moduleResolution', 'bundler', '--jsx', 'preserve', '--skipLibCheck'];
+            return { argv: [...base, ...defaults, ...files], tool: 'tsc', report: 'tsc.txt' };
+        }
+        if (pythonTool(ctx) === 'mypy') {
+            return {
+                argv: ['health-capture', '/out/mypy.txt', 'health-venv', 'mypy', '--no-error-summary', '--no-pretty', '--no-color-output', '.'],
+                tool: 'mypy',
+                report: 'mypy.txt',
+            };
+        }
+        return { argv: ['health-capture', '/out/pyright.json', 'health-venv', 'pyright', '--outputjson'], tool: 'pyright', report: 'pyright.json' };
+    },
+};

package/dist/exec/test-reports/coverage-py.js

@@ -0,0 +1,23 @@
+import { toRepoPath } from '../reports.js';
+const num = (value) => (typeof value === 'number' ? value : 0);
+/** `coverage json` (pytest-cov `--cov-report=json`): `files.<path>.summary`. Null when the text is not that report. */
+export function parseCoveragePy(text, stepDir) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!doc || typeof doc.files !== 'object' || doc.files === null)
+        return null;
+    const files = new Map();
+    for (const [file, entry] of Object.entries(doc.files)) {
+        const summary = entry?.summary ?? {};
+        files.set(toRepoPath(file, stepDir), {
+            lines: { total: num(summary.num_statements), covered: num(summary.covered_lines) },
+            branches: { total: num(summary.num_branches), covered: num(summary.covered_branches) },
+        });
+    }
+    return files;
+}

package/dist/exec/test-reports/coverage-ranges.js

@@ -0,0 +1,65 @@
+import { toRepoPath } from '../reports.js';
+function range(loc, hits) {
+    const start = loc?.start?.line;
+    const end = loc?.end?.line;
+    if (typeof start !== 'number' || typeof end !== 'number' || typeof hits !== 'number')
+        return null;
+    return { start, end, hits };
+}
+/** The istanbul `json` reporter (`coverage-final.json`, also c8 and the v8 provider): the statement and function ranges of each file. Null when the text is not that report. */
+export function parseCoverageRanges(text, stepDir) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof doc !== 'object' || doc === null || Array.isArray(doc))
+        return null;
+    const files = new Map();
+    for (const [file, entry] of Object.entries(doc)) {
+        if (typeof entry !== 'object' || entry === null || typeof entry.statementMap !== 'object')
+            return null;
+        const ranges = [];
+        for (const [id, loc] of Object.entries(entry.statementMap)) {
+            const found = range(loc, entry.s?.[id]);
+            if (found)
+                ranges.push(found);
+        }
+        for (const [id, fn] of Object.entries(entry.fnMap ?? {})) {
+            const found = range(fn.loc, entry.f?.[id]);
+            if (found)
+                ranges.push(found);
+        }
+        files.set(toRepoPath(file, stepDir), ranges);
+    }
+    return files;
+}
+/**
+ * The code lines of a file that ran: a line counts when the innermost statement or function range holding it
+ * has a hit. A line inside no range counts when anything in the file ran. Lines are 1-based.
+ */
+export function coveredLines(codeLines, ranges) {
+    const anyHit = ranges.some((r) => r.hits > 0);
+    const covered = new Set();
+    for (const line of codeLines) {
+        let best = null;
+        let hit = false;
+        for (const r of ranges) {
+            if (r.start > line || r.end < line)
+                continue;
+            const span = r.end - r.start;
+            if (best === null || span < best.end - best.start) {
+                best = r;
+                hit = r.hits > 0;
+            }
+            else if (span === best.end - best.start && r.hits > 0) {
+                hit = true;
+            }
+        }
+        if (best === null ? anyHit : hit)
+            covered.add(line);
+    }
+    return covered;
+}

package/dist/exec/test-reports/coverage-summary.js

@@ -0,0 +1,23 @@
+import { toRepoPath } from '../reports.js';
+function part(value) {
+    return { total: typeof value?.total === 'number' ? value.total : 0, covered: typeof value?.covered === 'number' ? value.covered : 0 };
+}
+/** The istanbul `json-summary` reporter (also c8 and the v8 provider): one entry per file next to `total`. Null when the text is not that report. */
+export function parseCoverageSummary(text, stepDir) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof doc !== 'object' || doc === null || typeof doc.total !== 'object')
+        return null;
+    const files = new Map();
+    for (const [file, entry] of Object.entries(doc)) {
+        if (file === 'total' || typeof entry !== 'object' || entry === null)
+            continue;
+        files.set(toRepoPath(file, stepDir), { lines: part(entry.lines), branches: part(entry.branches) });
+    }
+    return files;
+}

package/dist/exec/test-reports/jest-json.js

@@ -0,0 +1,31 @@
+/**
+ * `jest --json` and `vitest --reporter=json` share one shape. Passed and failed assertions count as
+ * such; pending, skipped, todo and disabled are skipped. A file that failed without any assertion
+ * (it did not load) is one failed case. Null when the text is not a results report.
+ */
+export function parseJestJson(text) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!doc || !Array.isArray(doc.testResults))
+        return null;
+    const counts = { passed: 0, failed: 0, errored: 0, skipped: 0 };
+    for (const file of doc.testResults) {
+        const assertions = file.assertionResults ?? [];
+        if (assertions.length === 0 && file.status === 'failed')
+            counts.failed += 1;
+        for (const assertion of assertions) {
+            if (assertion.status === 'passed')
+                counts.passed += 1;
+            else if (assertion.status === 'failed')
+                counts.failed += 1;
+            else
+                counts.skipped += 1;
+        }
+    }
+    return counts;
+}

package/dist/exec/test-reports/junit.js

@@ -0,0 +1,24 @@
+/**
+ * JUnit XML from pytest and `node --test`. Every `<testcase>` is one case: `<error>` is errored
+ * (a pytest collection error is a testcase with an error), `<failure>` is failed, `<skipped>` is
+ * skipped except pytest's `xfail`, which is left out entirely. Null when there is no testsuite.
+ */
+export function parseJunit(text) {
+    if (!/<testsuites?\b/.test(text))
+        return null;
+    const counts = { passed: 0, failed: 0, errored: 0, skipped: 0 };
+    for (const match of text.matchAll(/<testcase\b[^>]*?(?:\/>|>([\s\S]*?)<\/testcase>)/g)) {
+        const body = match[1] ?? '';
+        if (/<error\b/.test(body))
+            counts.errored += 1;
+        else if (/<failure\b/.test(body))
+            counts.failed += 1;
+        else if (/<skipped\b/.test(body)) {
+            if (!/<skipped\b[^>]*type="pytest\.xfail"/.test(body))
+                counts.skipped += 1;
+        }
+        else
+            counts.passed += 1;
+    }
+    return counts;
+}

package/dist/exec/test-reports/mocha-json.js

@@ -0,0 +1,18 @@
+/** `mocha --reporter json`: `passes`, `failures` and `pending` arrays. Null when the text is not a mocha report. */
+export function parseMochaJson(text) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!doc || typeof doc.stats !== 'object' || !Array.isArray(doc.passes) || !Array.isArray(doc.failures))
+        return null;
+    return {
+        passed: doc.passes.length,
+        failed: doc.failures.length,
+        errored: 0,
+        skipped: Array.isArray(doc.pending) ? doc.pending.length : 0,
+    };
+}

package/dist/exec/test-reports/vitest-json.js

@@ -0,0 +1,5 @@
+import { parseJestJson } from './jest-json.js';
+/** vitest's json reporter is jest-compatible; `test.fails` cases appear as passed. */
+export function parseVitestJson(text) {
+    return parseJestJson(text);
+}

package/dist/exec/test-runners/detect.js

@@ -0,0 +1,99 @@
+import path from 'node:path';
+import { runnerInScript, scriptArgs } from './script.js';
+const DEPENDENCY_ORDER = ['vitest', 'jest', 'mocha'];
+const PYTHON_MANIFESTS = /^(?:pyproject\.toml|setup\.py|setup\.cfg|Pipfile|tox\.ini|requirements.*\.txt)$/;
+function isUnder(dir, parent) {
+    return parent === '.' || dir === parent || dir.startsWith(`${parent}/`);
+}
+/**
+ * The runner a package.json declares: the one its `test` script names, else the first of vitest,
+ * jest, mocha among the dependencies. Null when it declares none (Playwright and Cypress are never run).
+ */
+export function jsRunner(packageJson) {
+    if (packageJson === null)
+        return null;
+    let pkg;
+    try {
+        pkg = JSON.parse(packageJson);
+    }
+    catch {
+        return null;
+    }
+    const script = typeof pkg.scripts?.test === 'string' ? pkg.scripts.test : '';
+    const named = runnerInScript(script);
+    if (named)
+        return { runner: named, args: scriptArgs(script, named) };
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const runner = DEPENDENCY_ORDER.find((name) => name in deps);
+    return runner ? { runner, args: [] } : null;
+}
+function pythonHasTests(input, root) {
+    const underRoot = (file) => file.group === 'python' && isUnder(path.posix.dirname(file.path), root.dir);
+    if (input.scope.files.some((file) => file.role === 'test' && underRoot(file)))
+        return true;
+    const inRoot = (name) => path.posix.join(root.dir, name);
+    if (input.tracked.has(inRoot('tox.ini')) || input.tracked.has(inRoot('noxfile.py')))
+        return true;
+    for (const file of input.tracked) {
+        if (path.posix.dirname(file) !== root.dir || !PYTHON_MANIFESTS.test(path.posix.basename(file)))
+            continue;
+        if (/pytest/.test(input.read(file) ?? ''))
+            return true;
+    }
+    return false;
+}
+/**
+ * Which test runs to make. TypeScript/JavaScript: the install root when its package.json declares a
+ * runner, otherwise each workspace package under it that does. Python: one pytest run per install root
+ * that has a pytest dependency, a test file or a tox/nox config (pytest runs unittest suites too).
+ * At most one invocation per directory.
+ */
+export function detectInvocations(input) {
+    const invocations = [];
+    for (const root of input.roots) {
+        if (root.group === 'python') {
+            if (pythonHasTests(input, root))
+                invocations.push({ dir: root.dir, group: 'python', runner: 'pytest', args: [] });
+            continue;
+        }
+        const manifest = (dir) => path.posix.join(dir, 'package.json');
+        const own = jsRunner(input.read(manifest(root.dir)));
+        if (own) {
+            invocations.push({ dir: root.dir, group: root.group, ...own });
+            continue;
+        }
+        for (const dir of [...input.scope.packages].sort()) {
+            if (dir === root.dir || !isUnder(dir, root.dir))
+                continue;
+            const member = jsRunner(input.read(manifest(dir)));
+            if (member)
+                invocations.push({ dir, group: root.group, ...member });
+        }
+    }
+    return invocations;
+}
+const JS_EXTENSIONS = '{ts,tsx,mts,cts,js,jsx,mjs,cjs}';
+/** Directory-level globs of the logic files beneath `dir`, relative to it (a file at the top is named exactly). */
+export function logicGlobs(logicFiles, dir) {
+    const globs = new Set();
+    for (const file of logicFiles) {
+        const rel = path.posix.relative(dir, file);
+        const [top] = rel.split('/');
+        if (!top)
+            continue;
+        globs.add(top === rel ? rel : `${top}/**/*.${JS_EXTENSIONS}`);
+    }
+    return [...globs].sort();
+}
+/** `--cov` targets for pytest: each top-level directory with Python logic, and top-level modules by name. */
+export function pythonTargets(logicFiles, dir) {
+    const targets = new Set();
+    for (const file of logicFiles) {
+        const rel = path.posix.relative(dir, file);
+        const [top] = rel.split('/');
+        if (!top)
+            continue;
+        targets.add(top === rel ? top.replace(/\.py$/, '') : top);
+    }
+    return [...targets].sort();
+}

package/dist/exec/test-runners/index.js

@@ -0,0 +1,6 @@
+import { jest } from './jest.js';
+import { mocha } from './mocha.js';
+import { nodeTest } from './node-test.js';
+import { pytest } from './pytest.js';
+import { vitest } from './vitest.js';
+export const RUNNERS = { vitest, jest, mocha, 'node-test': nodeTest, pytest };

package/dist/exec/test-runners/jest.js

@@ -0,0 +1,27 @@
+import { parseCoverageRanges } from '../test-reports/coverage-ranges.js';
+import { parseCoverageSummary } from '../test-reports/coverage-summary.js';
+import { parseJestJson } from '../test-reports/jest-json.js';
+export const jest = {
+    results: 'results.json',
+    coverage: 'coverage/coverage-summary.json',
+    ranges: 'coverage/coverage-final.json',
+    argv: (invocation, globs) => [
+        'npx',
+        '--no-install',
+        'jest',
+        '--ci',
+        '--json',
+        '--outputFile=/out/results.json',
+        '--coverage',
+        '--coverageProvider=v8',
+        '--coverageReporters=json-summary',
+        '--coverageReporters=json',
+        '--coverageDirectory=/out/coverage',
+        ...globs.map((glob) => `--collectCoverageFrom=${glob}`),
+        '--coverageThreshold={}',
+        ...invocation.args,
+    ],
+    parseResults: parseJestJson,
+    parseCoverage: parseCoverageSummary,
+    parseRanges: parseCoverageRanges,
+};

package/dist/exec/test-runners/mocha.js

@@ -0,0 +1,28 @@
+import { parseCoverageRanges } from '../test-reports/coverage-ranges.js';
+import { parseCoverageSummary } from '../test-reports/coverage-summary.js';
+import { parseMochaJson } from '../test-reports/mocha-json.js';
+/** mocha has no coverage of its own: c8 wraps it. `--all` reports files no test loads. */
+export const mocha = {
+    results: 'results.json',
+    coverage: 'coverage/coverage-summary.json',
+    ranges: 'coverage/coverage-final.json',
+    argv: (invocation, globs) => [
+        'c8',
+        '--reporter=json-summary',
+        '--reporter=json',
+        '--report-dir=/out/coverage',
+        '--all',
+        ...globs.flatMap((glob) => ['--include', glob]),
+        'npx',
+        '--no-install',
+        'mocha',
+        '--reporter',
+        'json',
+        '--reporter-option',
+        'output=/out/results.json',
+        ...invocation.args,
+    ],
+    parseResults: parseMochaJson,
+    parseCoverage: parseCoverageSummary,
+    parseRanges: parseCoverageRanges,
+};

package/dist/exec/test-runners/node-test.js

@@ -0,0 +1,24 @@
+import { parseCoverageRanges } from '../test-reports/coverage-ranges.js';
+import { parseCoverageSummary } from '../test-reports/coverage-summary.js';
+import { parseJunit } from '../test-reports/junit.js';
+export const nodeTest = {
+    results: 'junit.xml',
+    coverage: 'coverage/coverage-summary.json',
+    ranges: 'coverage/coverage-final.json',
+    argv: (invocation, globs) => [
+        'c8',
+        '--reporter=json-summary',
+        '--reporter=json',
+        '--report-dir=/out/coverage',
+        '--all',
+        ...globs.flatMap((glob) => ['--include', glob]),
+        'node',
+        '--test',
+        '--test-reporter=junit',
+        '--test-reporter-destination=/out/junit.xml',
+        ...invocation.args,
+    ],
+    parseResults: parseJunit,
+    parseCoverage: parseCoverageSummary,
+    parseRanges: parseCoverageRanges,
+};

package/dist/exec/test-runners/pytest.js

@@ -0,0 +1,18 @@
+import { parseCoveragePy } from '../test-reports/coverage-py.js';
+import { parseJunit } from '../test-reports/junit.js';
+/** pytest also runs unittest suites. `health-pytest` is `python -m pytest` in the repository's environment, with the image's pytest and pytest-cov when it has none. */
+export const pytest = {
+    results: 'junit.xml',
+    coverage: 'coverage.json',
+    argv: (_invocation, _globs, targets) => [
+        'health-pytest',
+        '--continue-on-collection-errors',
+        '--junitxml=/out/junit.xml',
+        ...targets.map((target) => `--cov=${target}`),
+        '--cov-branch',
+        '--cov-report=json:/out/coverage.json',
+        '--cov-fail-under=0',
+    ],
+    parseResults: parseJunit,
+    parseCoverage: parseCoveragePy,
+};

package/dist/exec/test-runners/script.js

@@ -0,0 +1,48 @@
+const SEGMENT = /&&|\|\||;|\|/;
+/** Where each runner appears in a `test` script. */
+const RUNNER_PATTERN = {
+    vitest: /\bvitest\b/,
+    jest: /\bjest\b/,
+    mocha: /\bmocha\b/,
+    'node-test': /\bnode\b(?:\s+\S+)*?\s--test\b/,
+};
+/** The runner a script names; when it names several, the first one in the text. */
+export function runnerInScript(script) {
+    let best = null;
+    for (const [runner, pattern] of Object.entries(RUNNER_PATTERN)) {
+        const index = pattern.exec(script)?.index;
+        if (index !== undefined && (best === null || index < best.index))
+            best = { runner, index };
+    }
+    return best?.runner ?? null;
+}
+const DROP_FLAG = /^(?:--watch\S*|-w|--reporter(?:=.*)?|-R|--outputFile(?:=.*)?|--json|--ci|--coverage(?:\..*)?(?:=.*)?|--collectCoverage\S*|--run)$/;
+const VALUE_FLAG = new Set(['--reporter', '-R', '--outputFile']);
+/**
+ * The arguments after the runner in the first segment of the script that names it (a segment ends at
+ * `&&`, `||`, `;` or `|`), without watch, reporter, output and coverage options. Positional arguments
+ * and `--config`, `--project`, `--dir` stay. A leading `run` (vitest) and a `--test` flag (node) are the runner itself.
+ */
+export function scriptArgs(script, runner) {
+    for (const segment of script.split(SEGMENT)) {
+        const tokens = segment.trim().split(/\s+/).filter(Boolean);
+        const at = tokens.findIndex((token) => (runner === 'node-test' ? token === '--test' : new RegExp(`(?:^|/)${runner}$`).test(token)));
+        if (at < 0)
+            continue;
+        const rest = tokens.slice(at + 1);
+        const kept = [];
+        for (let i = 0; i < rest.length; i += 1) {
+            const token = rest[i];
+            if (i === 0 && runner === 'vitest' && (token === 'run' || token === 'watch' || token === 'dev'))
+                continue;
+            if (DROP_FLAG.test(token)) {
+                if (VALUE_FLAG.has(token) && rest[i + 1] !== undefined && !rest[i + 1].startsWith('-'))
+                    i += 1;
+                continue;
+            }
+            kept.push(token);
+        }
+        return kept;
+    }
+    return [];
+}

package/dist/exec/test-runners/spec.js

@@ -0,0 +1 @@
+export {};