probatio 0.3.0 → 0.5.0

package/dist/mutate/rust-coverage.js

@@ -1,144 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { exportLlvmProfile, llvmToolsPresent } from "./coverage-map.js";
-/**
- * One instrumented test binary, then one profile per test name.
- * A single cargo test profile does not say which test hit the line.
- */
-export function writeRustCoverage(pkg, testNames, dest) {
-    const names = [...new Set(testNames.map((name) => name.trim()).filter((name) => name.length > 0 && !/\s/.test(name)))];
-    if (names.length === 0)
-        return { ok: false, detail: "rust coverage: no test names" };
-    if (!llvmToolsPresent())
-        return { ok: false, detail: "rust coverage: llvm tool missing" };
-    const env = { ...process.env, RUSTFLAGS: "-C instrument-coverage", CARGO_INCREMENTAL: "0" };
-    const built = spawnSync("cargo", ["test", "--no-run", "--message-format=json"], {
-        cwd: pkg,
-        encoding: "utf8",
-        env,
-        timeout: 180_000,
-        maxBuffer: 32 * 1024 * 1024,
-    });
-    if (built.status !== 0 || built.error)
-        return { ok: false, detail: clip(built.stderr || built.stdout || built.error?.message || "cargo test --no-run failed") };
-    const exes = testExecutables(built.stdout);
-    if (exes.length === 0)
-        return { ok: false, detail: "rust coverage: no test executable" };
-    const work = path.join(path.dirname(dest), "rust-cover");
-    mkdirSync(work, { recursive: true });
-    const files = {};
-    for (const name of names) {
-        for (const exe of exes) {
-            const raw = path.join(work, `${safe(name)}-${safe(path.basename(exe))}.profraw`);
-            const ran = spawnSync(exe, [name, "--exact", "--test-threads=1"], {
-                cwd: pkg,
-                encoding: "utf8",
-                env: { ...env, LLVM_PROFILE_FILE: raw },
-                timeout: 60_000,
-            });
-            if (!existsSync(raw))
-                continue;
-            if (!new RegExp(`^test ${escapeRegExp(name)} \\.\\.\\. ok`, "m").test(`${ran.stdout}\n${ran.stderr}`))
-                continue;
-            const merged = path.join(work, `${safe(name)}-${safe(path.basename(exe))}.profdata`);
-            const exported = exportLlvmProfile(exe, [raw], merged);
-            if (!exported.ok)
-                continue;
-            for (const hit of llvmHits(exported.stdout, pkg))
-                addHit(files, hit.file, hit.line, name);
-        }
-    }
-    if (Object.keys(files).length === 0)
-        return { ok: false, detail: "rust coverage: no covered lines" };
-    writeFileSync(dest, `${JSON.stringify({ files }, null, 2)}\n`);
-    return { ok: true, detail: `${Object.keys(files).length} files` };
-}
-function testExecutables(stdout) {
-    const found = [];
-    for (const line of stdout.split("\n")) {
-        if (!line.startsWith("{"))
-            continue;
-        try {
-            const msg = JSON.parse(line);
-            if (msg.reason !== "compiler-artifact" || !msg.executable || !msg.profile?.test)
-                continue;
-            if (!found.includes(msg.executable))
-                found.push(msg.executable);
-        }
-        catch {
-            continue;
-        }
-    }
-    return found;
-}
-function llvmHits(stdout, pkg) {
-    const start = stdout.indexOf("{");
-    if (start < 0)
-        return [];
-    let parsed;
-    try {
-        parsed = JSON.parse(stdout.slice(start));
-    }
-    catch {
-        return [];
-    }
-    const hits = [];
-    for (const group of parsed.data ?? []) {
-        for (const file of group.files ?? []) {
-            if (!file.filename)
-                continue;
-            const rel = underPkg(file.filename, pkg);
-            if (!rel)
-                continue;
-            for (const segment of file.segments ?? []) {
-                const line = segment[0];
-                const count = segment[2] ?? 0;
-                if (!line || count <= 0)
-                    continue;
-                hits.push({ file: rel, line });
-            }
-        }
-    }
-    return hits;
-}
-function underPkg(filename, pkg) {
-    let file = filename;
-    let root = pkg;
-    try {
-        if (existsSync(filename))
-            file = realpathSync(filename);
-    }
-    catch {
-        // keep the path llvm reported
-    }
-    try {
-        root = realpathSync(pkg);
-    }
-    catch {
-        // keep the package path
-    }
-    const rel = path.relative(root, file);
-    if (!rel || rel.startsWith(".."))
-        return null;
-    return rel.split(path.sep).join("/");
-}
-function addHit(files, file, line, test) {
-    const lines = files[file] ?? {};
-    const key = String(line);
-    const names = lines[key] ?? [];
-    if (!names.includes(test))
-        names.push(test);
-    lines[key] = names;
-    files[file] = lines;
-}
-function safe(value) {
-    return value.replace(/[^A-Za-z0-9._-]+/g, "_");
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function clip(text) {
-    const line = text.trim().split("\n").find((item) => item.trim()) ?? "rust coverage failed";
-    return line.slice(0, 240);
-}

package/dist/mutate/sealed.js

@@ -1,118 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-/** The label stays in its own file. The run report must not repeat these three values. */
-export function readSealedLabel(file) {
-    let text = "";
-    try {
-        text = readFileSync(file, "utf8");
-    }
-    catch {
-        throw new Error("label file could not be read");
-    }
-    const bugId = field(text, "bug_id");
-    const issueId = field(text, "issue_id");
-    const expectedFail = field(text, "expected_fail");
-    if (!bugId || !issueId || !expectedFail)
-        throw new Error("label file needs bug_id, issue_id, and expected_fail");
-    return { bugId, issueId, expectedFail };
-}
-export function labelLeaked(body, label) {
-    return body.includes(label.bugId) || body.includes(label.issueId) || body.includes(label.expectedFail);
-}
-/** The envelope can be clean while a result file on disk still repeats the label. */
-export function sealedTreeLeaked(dir, label) {
-    const visit = (current) => {
-        let names;
-        try {
-            names = readdirSync(current);
-        }
-        catch {
-            return false;
-        }
-        for (const name of names) {
-            const full = path.join(current, name);
-            let info;
-            try {
-                info = statSync(full);
-            }
-            catch {
-                continue;
-            }
-            if (info.isDirectory()) {
-                if (visit(full))
-                    return true;
-                continue;
-            }
-            if (!info.isFile() || info.size > 2_000_000)
-                continue;
-            try {
-                if (labelLeaked(readFileSync(full, "utf8"), label))
-                    return true;
-            }
-            catch {
-                // A binary artifact is not a report.
-            }
-        }
-        return false;
-    };
-    return visit(dir);
-}
-export const LABEL_LEAK_SUMMARY = "The label was copied into the report.";
-function field(text, key) {
-    const match = text.match(new RegExp(`^${key}=(.*)$`, "m"));
-    return match?.[1]?.trim() ?? "";
-}
-/**
- * A sealed run hides the revealing test, but a fix commit often edits an older test too.
- * A kill by that edited test is the fix's own test, not an older test that caught the bug.
- * Returns the edited test files that killed, and whether any kill came from a test the fix left alone.
- */
-export function fixEditedKillers(repo, packageDir, commit, hide, kills) {
-    if (kills.length === 0)
-        return { files: [], olderTestCatch: false };
-    const diff = spawnSync("git", ["-C", repo, "diff", "--name-only", `${commit}^`, commit], { encoding: "utf8" });
-    // No parent, or git failed: nothing is known to be edited, so every kill stays an older-test catch.
-    if (diff.status !== 0)
-        return { files: [], olderTestCatch: true };
-    const hidden = new Set(hide.map((rel) => rel.split(path.sep).join("/")));
-    const edited = diff.stdout
-        .split("\n")
-        .filter((rel) => rel.length > 0)
-        .map((rel) => ({ repoRel: rel, pkgRel: path.relative(packageDir, path.join(repo, rel)).split(path.sep).join("/") }))
-        .filter((item) => !item.pkgRel.startsWith("..") && !hidden.has(item.pkgRel));
-    const text = new Map();
-    const contents = (repoRel) => {
-        if (!text.has(repoRel)) {
-            const shown = spawnSync("git", ["-C", repo, "show", `${commit}:${repoRel}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-            text.set(repoRel, shown.status === 0 ? shown.stdout : "");
-        }
-        return text.get(repoRel) ?? "";
-    };
-    const fileFor = (id) => edited.find((item) => killerInFile(id, item.pkgRel, () => contents(item.repoRel)));
-    const files = new Set();
-    let olderTestCatch = false;
-    for (const kill of kills) {
-        const owners = kill.killedBy.map(fileFor);
-        for (const owner of owners)
-            if (owner)
-                files.add(owner.pkgRel);
-        if (owners.some((owner) => !owner))
-            olderTestCatch = true;
-    }
-    return { files: [...files].sort(), olderTestCatch };
-}
-/** True when a kill id names this file, its class, or a test written in it. */
-function killerInFile(id, rel, read) {
-    if (id.includes(rel) || id.startsWith(`${path.posix.basename(rel)}::`))
-        return true;
-    const stem = path.posix.basename(rel).replace(/\.[^.]+$/, "");
-    // JUnit `pkg.ClassTest.method` or `ClassTest#method`, Go and Rust paths.
-    if (stem.length > 0 && id.split(/[.#:/]+/).includes(stem))
-        return true;
-    const leaf = id.split(/::|#/).pop()?.split(/\.(?=[^.]+$)/).pop()?.replace(/\[.*\]$/, "").trim() ?? "";
-    if (leaf.length < 4)
-        return false;
-    const body = read();
-    return [`"${leaf}"`, `'${leaf}'`, `\`${leaf}\``, `${leaf}(`, `def ${leaf}`, `func ${leaf}`, `fn ${leaf}`].some((needle) => body.includes(needle));
-}

package/dist/mutate/suite-decision.js

@@ -1,130 +0,0 @@
-/** Pure suite decisions. The process spawn stays in the runner. */
-export const UNKNOWN_NEXT = "The suite command is unknown. Pass --suite-command with the command that runs this package's tests.";
-export const TIMEOUT_NEXT = "Timed out. The mutant ran longer than the baseline allows.";
-export const UNVIABLE_NEXT = "The mutant did not build. No test saw it, so it is not a kill and not a gap. No test is needed.";
-export const WHOLE_SUITE_NEXT = "The suite command cannot take a test name, so the whole suite ran.";
-export const TIMEOUT_MULTIPLE = 5;
-/** cargo-mutants uses 20s. A fixture can pass a smaller positive floor. */
-export const TIMEOUT_FLOOR_MS = 20_000;
-/** Marker on a coverage map when the binary has no per-test names. */
-export const WHOLE_PROGRAM_TEST = "suite";
-export function cannotRunNext(artifact) {
-    return `The suite cannot run. ${artifact} is missing and the recipe would download it. Nothing was fetched.`;
-}
-export function resumeNext(ids) {
-    const listed = ids.length > 0 ? ` Not started: ${ids.join(", ")}.` : "";
-    return `Budget stopped the run.${listed} The same command resumes from the mutants already written.`;
-}
-export function noCoverageNext(file, line) {
-    return `No coverage for ${file}:${line}. No test executed that line.`;
-}
-/** Every agent-facing count starts with unseen lines, then survivors. */
-export function leadSummary(noCoverage, survivors, survivorWord, rest) {
-    return `${noCoverage} no coverage, ${survivors} ${survivorWord}, ${rest}`;
-}
-export function campaignSummary(counts) {
-    return leadSummary(counts.noCoverage, counts.survived, "survived", `${counts.killed} killed, ${counts.unviable ? `${counts.unviable} did not build, ` : ""}${counts.flaky} flaky, ${counts.timeouts} timed out, ${counts.errors} errored, of ${counts.finished} finished.`);
-}
-export function timeoutLimitMs(baselineMs, multiple, floorMs) {
-    const floor = Math.max(1, floorMs);
-    const scaled = Math.ceil(Math.max(0, baselineMs) * Math.max(1, multiple));
-    return Math.max(floor, scaled);
-}
-/** Kinds that collect a per-line map on the baseline. Other kinds pay the whole suite. */
-const LINE_MAP_KINDS = new Set(["node", "pytest", "c", "go", "maven", "cargo", "dotnet", "mocha"]);
-/** A baseline this long, with no line map, is too expensive to repeat for a large batch. */
-export const SLOW_BASELINE_MS = 5_000;
-/** Pending mutants above this count, on a slow unmapped suite, are not started. */
-export const LARGE_BATCH = 30;
-export function hasLineMap(kind) {
-    return LINE_MAP_KINDS.has(kind);
-}
-export function scaleStop(input) {
-    if (hasLineMap(input.kind))
-        return { action: "run" };
-    if (input.baselineMs == null || input.baselineMs < SLOW_BASELINE_MS)
-        return { action: "run" };
-    if (input.pending <= LARGE_BATCH)
-        return { action: "run" };
-    const seconds = (input.baselineMs / 1000).toFixed(1);
-    const next = `No line map for this suite. The baseline took ${seconds}s and ${input.pending} mutants are waiting. Narrow --src or pass a patch slice. Nothing was started.`;
-    return { action: "stop", summary: next, next };
-}
-/** What generate tells the agent before any mutant runs. */
-export function generateNext(count, suite) {
-    if (count === 0)
-        return "Nothing to run.";
-    if (!suite)
-        return `${count} mutants. No suite was discovered. Pass --suite-command when you run the batch.`;
-    const map = hasLineMap(suite.kind)
-        ? "The first run pays that suite once, then a line map narrows each mutant."
-        : "This suite has no line map. A baseline of 5 seconds or more with more than 30 mutants stops before the first mutant.";
-    return `${count} mutants. Suite is ${suite.command}. ${map}`;
-}
-/**
- * Unknown layout asks for a command. An explicit command is what runs.
- * `make test` that would curl or wget a missing file does not run.
- */
-export function decideSuite(input) {
-    const command = input.suiteCommand?.trim() ? input.suiteCommand.trim() : input.discovered?.command ?? "";
-    if (isMakeTest(command) && input.makefile) {
-        const artifact = missingFetchArtifact(input.makefile, input.artifactExists);
-        if (artifact) {
-            const next = cannotRunNext(artifact);
-            return { action: "cannot-run", summary: next, next, command: "make test" };
-        }
-    }
-    if (input.suiteCommand?.trim())
-        return { action: "run" };
-    if (input.discovered)
-        return { action: "run" };
-    if (input.candidates.length > 0) {
-        return { action: "unknown", summary: "The suite command is unknown.", next: UNKNOWN_NEXT };
-    }
-    return { action: "no-tests" };
-}
-export function isMakeTest(command) {
-    return /^\s*make\s+test\b/.test(command);
-}
-/**
- * Output paths of curl or wget recipes whose file is not on disk.
- * Returns the base name, which is the artifact named in `next`.
- * A Makefile that fetches for `test` is refused even when variable
- * expansion cannot prove the edge, so a recipe cannot download a jar.
- */
-export function missingFetchArtifact(makefile, exists) {
-    const lines = makefile.split(/\r?\n/);
-    for (const raw of lines) {
-        if (/^\s*#/.test(raw))
-            continue;
-        const line = raw.trim();
-        if (!/\b(curl|wget)\b/.test(line))
-            continue;
-        const artifact = artifactOf(line);
-        if (!artifact)
-            continue;
-        const rel = artifact.replace(/^\.\//, "");
-        if (exists(rel) || exists(pathBase(rel)))
-            continue;
-        return pathBase(rel);
-    }
-    return null;
-}
-function artifactOf(line) {
-    const flagged = line.match(/(?:-o|--output|-O|--output-document)(?:=|\s+)["']?([^\s"']+)["']?/);
-    if (flagged && !flagged[1].startsWith("$") && !flagged[1].startsWith("-"))
-        return flagged[1];
-    const url = line.match(/https?:\/\/\S+/);
-    if (url) {
-        const base = url[0].replace(/["']$/, "").split("?")[0].split("/").pop() ?? "";
-        if (base.includes("."))
-            return base;
-    }
-    if (flagged && !flagged[1].startsWith("-"))
-        return flagged[1];
-    return null;
-}
-function pathBase(rel) {
-    const parts = rel.split(/[/\\]/);
-    return parts[parts.length - 1] || rel;
-}