builder-assistant-engineer 0.2.0

package/dist/gates/reports.js

@@ -0,0 +1,349 @@
+import { mkdtemp, readdir, readFile, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { directRunner, expandCommand, testRunners } from "./runners.js";
+export const REPORT_SOURCES = [
+    "vitest-json",
+    "jest-json",
+    "pytest-junit",
+    "go-json",
+    "dotnet-trx",
+    "node-junit",
+];
+const PASSED = new Set(["passed"]);
+const FAILED = new Set(["failed"]);
+const TRX_FAILED = new Set(["Failed", "Error", "Timeout", "Aborted"]);
+const ENTITIES = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+export async function probeFor(cwd, command, sources) {
+    const direct = directRunner(command, sources);
+    if (direct && direct.runner !== "cargo" && direct.runner !== "pytest") {
+        return argumentProbe(cwd, command, direct);
+    }
+    const runners = testRunners(command, sources);
+    if (runners.length > 0 && runners.every((name) => name === "pytest")) {
+        return pytestProbe(command);
+    }
+    const text = expandCommand(command, sources);
+    if (runners.length > 0 &&
+        runners.every((name) => name === "node") &&
+        !/--test-reporter/.test(text)) {
+        return nodeProbe(cwd, command);
+    }
+    return undefined;
+}
+async function argumentProbe(cwd, command, direct) {
+    const { runner, args } = direct;
+    if (runner === "go") {
+        if (args.includes("-args"))
+            return undefined;
+        const json = args.includes("-json") || args.includes("--json");
+        const quiet = command
+            .replace(/(^|\s)-v(=true)?(?=\s|$)/g, "$1")
+            .replace(/\s+/g, " ")
+            .trim();
+        return {
+            command: json ? command : extend(quiet, direct.suffix(["-json"])),
+            env: {},
+            collect: async (stdout) => goReport(stdout),
+            view: goView,
+            dispose: async () => { },
+        };
+    }
+    if (runner === "vitest" && args.some((arg) => arg.startsWith("--outputFile")))
+        return undefined;
+    if (runner === "jest" && args.some((arg) => arg === "--json" || arg.startsWith("--outputFile"))) {
+        return undefined;
+    }
+    if (runner === "dotnet" && args.some((arg) => arg === "--" || arg === "--results-directory")) {
+        return undefined;
+    }
+    const dir = await mkdtemp(join(tmpdir(), "bae-report-"));
+    const file = slashed(join(dir, "report.json"));
+    const extra = extraArgs(runner, slashed(dir), file);
+    if (!extra) {
+        await rm(dir, { recursive: true, force: true });
+        return undefined;
+    }
+    const roots = await rootsOf(cwd);
+    return {
+        command: extend(command, direct.suffix(extra)),
+        env: {},
+        collect: async () => runner === "dotnet"
+            ? trxReport(await readReports(dir, ".trx"))
+            : jestReport(await readText(file), roots, runner === "vitest" ? "vitest-json" : "jest-json"),
+        dispose: () => rm(dir, { recursive: true, force: true }),
+    };
+}
+function extraArgs(runner, dir, file) {
+    if (runner === "vitest")
+        return ["--reporter=default", "--reporter=json", `--outputFile.json=${file}`];
+    if (runner === "jest")
+        return ["--json", `--outputFile=${file}`];
+    if (runner === "dotnet")
+        return ["--logger", "trx", "--results-directory", dir];
+    return undefined;
+}
+async function nodeProbe(cwd, command) {
+    const dir = await mkdtemp(join(tmpdir(), "bae-report-"));
+    const file = slashed(join(dir, "junit.xml"));
+    const existing = process.env.NODE_OPTIONS ?? "";
+    const reporters = `--test-reporter=spec --test-reporter-destination=stdout --test-reporter=junit --test-reporter-destination="${file}"`;
+    const roots = await rootsOf(cwd);
+    return {
+        command,
+        env: { NODE_OPTIONS: `${existing} ${reporters}`.trim() },
+        collect: async () => junitReport(await readText(file), "node-junit", roots),
+        dispose: () => rm(dir, { recursive: true, force: true }),
+    };
+}
+async function pytestProbe(command) {
+    const dir = await mkdtemp(join(tmpdir(), "bae-report-"));
+    const file = slashed(join(dir, "junit.xml"));
+    const existing = process.env.PYTEST_ADDOPTS ?? "";
+    return {
+        command,
+        env: { PYTEST_ADDOPTS: `${existing} --junitxml="${file}"`.trim() },
+        collect: async () => junitReport(await readText(file)),
+        dispose: () => rm(dir, { recursive: true, force: true }),
+    };
+}
+export function jestReport(text, roots, source) {
+    const data = parseJson(text);
+    const files = Array.isArray(data?.testResults) ? data.testResults : undefined;
+    if (!files)
+        return undefined;
+    const tally = { passed: 0, failed: 0, skipped: 0, failing: [], units: [] };
+    for (const file of files) {
+        const name = relativeTo(String(file.name ?? ""), roots);
+        tally.units.push(name);
+        const cases = Array.isArray(file.assertionResults)
+            ? file.assertionResults
+            : [];
+        let failedHere = 0;
+        for (const item of cases) {
+            const status = String(item.status ?? "");
+            if (PASSED.has(status))
+                tally.passed++;
+            else if (FAILED.has(status)) {
+                failedHere++;
+                tally.failed++;
+                tally.failing.push(caseName(item));
+            }
+            else
+                tally.skipped++;
+        }
+        if (file.status === "failed" && failedHere === 0) {
+            tally.failed++;
+            tally.failing.push(name);
+        }
+    }
+    return report(tally, source);
+}
+export function junitReport(text, source = "pytest-junit", roots = []) {
+    if (!text || !/<testsuites?\b/.test(text))
+        return undefined;
+    const tally = { passed: 0, failed: 0, skipped: 0, failing: [], units: [] };
+    for (const { attributes, body } of elements(text, "testcase")) {
+        const name = [attributes.classname, attributes.name].filter(Boolean).join("::");
+        const file = attributes.file ? relativeTo(attributes.file, roots) : undefined;
+        tally.units.push(source === "node-junit" ? (file ?? "") : (attributes.file ?? attributes.classname ?? ""));
+        const title = attributes.name ?? "";
+        const silent = source === "node-junit" &&
+            /\.[cm]?[jt]sx?$/.test(title) &&
+            (/[\\/]/.test(title) || slashed(attributes.file ?? "").endsWith(`/${title}`));
+        if (silent) {
+            const path = relativeTo(attributes.name ?? "", roots);
+            tally.units.push(path);
+            tally.failed++;
+            tally.failing.push(path);
+        }
+        else if (/<(failure|error)\b/.test(body)) {
+            tally.failed++;
+            tally.failing.push(name);
+        }
+        else if (/<skipped\b/.test(body))
+            tally.skipped++;
+        else
+            tally.passed++;
+    }
+    return report(tally, source);
+}
+export function goReport(stdout) {
+    const events = stdout.split(/\r?\n/).flatMap((line) => {
+        const event = line.startsWith("{") ? parseJson(line) : undefined;
+        return event && typeof event.Action === "string" ? [event] : [];
+    });
+    if (events.length === 0)
+        return undefined;
+    const started = new Set();
+    const results = new Map();
+    const packages = new Map();
+    for (const event of events) {
+        const pkg = String(event.Package ?? "");
+        const action = String(event.Action);
+        if (typeof event.Test !== "string") {
+            if (pkg && ["pass", "fail", "skip"].includes(action))
+                packages.set(pkg, action);
+            continue;
+        }
+        const key = `${pkg}::${event.Test}`;
+        if (action === "run")
+            started.add(key);
+        else if (["pass", "fail", "skip"].includes(action) && started.has(key)) {
+            results.set(key, action);
+        }
+    }
+    const tally = { passed: 0, failed: 0, skipped: 0, failing: [], units: [] };
+    for (const [key, action] of results) {
+        if (action === "pass")
+            tally.passed++;
+        else if (action === "skip")
+            tally.skipped++;
+        else {
+            tally.failed++;
+            tally.failing.push(key);
+        }
+    }
+    tally.units.push(...packages.keys());
+    for (const [pkg, action] of packages) {
+        const failedTests = tally.failing.some((name) => name.startsWith(`${pkg}::`));
+        if (action === "fail" && !failedTests) {
+            tally.failed++;
+            tally.failing.push(pkg);
+        }
+    }
+    return report(tally, "go-json");
+}
+export function trxReport(texts) {
+    if (texts.length === 0)
+        return undefined;
+    const tally = { passed: 0, failed: 0, skipped: 0, failing: [], units: [] };
+    for (const text of texts) {
+        for (const { attributes } of elements(text, "UnitTest")) {
+            tally.units.push(slashed(attributes.storage ?? "")
+                .split("/")
+                .at(-1) ?? "");
+        }
+        for (const { attributes } of elements(text, "UnitTestResult")) {
+            const outcome = attributes.outcome ?? "";
+            if (outcome === "Passed")
+                tally.passed++;
+            else if (TRX_FAILED.has(outcome)) {
+                tally.failed++;
+                tally.failing.push(attributes.testName ?? "");
+            }
+            else
+                tally.skipped++;
+        }
+    }
+    return report(tally, "dotnet-trx");
+}
+export function goText(stdout) {
+    const view = goView();
+    return view.push(stdout) + view.end();
+}
+export function goView() {
+    let pending = "";
+    const render = (line) => {
+        const event = line.startsWith("{") ? parseJson(line) : undefined;
+        if (!event || typeof event.Action !== "string")
+            return `${line}\n`;
+        return typeof event.Output === "string" ? event.Output : "";
+    };
+    return {
+        push: (chunk) => {
+            const lines = (pending + chunk).split("\n");
+            pending = lines.pop() ?? "";
+            return lines.map((line) => render(line.replace(/\r$/, ""))).join("");
+        },
+        end: () => {
+            const rest = pending ? render(pending) : "";
+            pending = "";
+            return rest;
+        },
+    };
+}
+function elements(text, tag) {
+    const clean = text.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "");
+    const pattern = new RegExp(`<${tag}((?:\\s+[\\w:.-]+\\s*=\\s*(?:"[^"]*"|'[^']*'))*)\\s*(/?)>`, "g");
+    const found = [];
+    for (const match of clean.matchAll(pattern)) {
+        const start = (match.index ?? 0) + match[0].length;
+        const end = match[2] ? start : clean.indexOf(`</${tag}>`, start);
+        found.push({
+            attributes: attributesOf(match[1] ?? ""),
+            body: end === -1 ? clean.slice(start) : clean.slice(start, end),
+        });
+    }
+    return found;
+}
+function attributesOf(text) {
+    const attributes = {};
+    for (const match of text.matchAll(/([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) {
+        attributes[match[1] ?? ""] = decode(match[2] ?? match[3] ?? "");
+    }
+    return attributes;
+}
+function decode(value) {
+    return value.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (whole, entity) => {
+        if (entity.startsWith("#x") || entity.startsWith("#X")) {
+            return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        }
+        if (entity.startsWith("#"))
+            return String.fromCodePoint(Number(entity.slice(1)));
+        return ENTITIES[entity] ?? whole;
+    });
+}
+function caseName(item) {
+    const ancestors = Array.isArray(item.ancestorTitles) ? item.ancestorTitles.map(String) : [];
+    return [...ancestors, String(item.title ?? item.fullName ?? "")].join(" > ");
+}
+function report(tally, source) {
+    const { passed, failed, skipped } = tally;
+    const unique = (items) => [...new Set(items.filter(Boolean))].sort();
+    return {
+        counts: { passed, failed, skipped },
+        failing: unique(tally.failing),
+        source,
+        units: unique(tally.units),
+    };
+}
+function relativeTo(path, roots) {
+    const normal = slashed(path);
+    const root = roots.find((candidate) => normal.startsWith(`${candidate}/`));
+    return root ? normal.slice(root.length + 1) : normal;
+}
+async function rootsOf(cwd) {
+    const real = await realpath(cwd).catch(() => cwd);
+    return [...new Set([slashed(cwd), slashed(real)])];
+}
+function extend(command, extra) {
+    return extra.length > 0 ? `${command} ${extra.map(quote).join(" ")}` : command;
+}
+function quote(word) {
+    return /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replace(/'/g, "'\\''")}'`;
+}
+function slashed(path) {
+    return path.replace(/\\/g, "/");
+}
+async function readText(path) {
+    return readFile(path, "utf8").catch(() => undefined);
+}
+async function readReports(dir, extension) {
+    const names = await readdir(dir).catch(() => []);
+    const texts = await Promise.all(names.filter((name) => name.endsWith(extension)).map((name) => readText(join(dir, name))));
+    return texts.filter((text) => text !== undefined);
+}
+function parseJson(text) {
+    if (!text)
+        return undefined;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/gates/results.js

@@ -0,0 +1,295 @@
+import { stripVTControlCharacters } from "node:util";
+import { z } from "zod";
+export const countsSchema = z.object({
+    passed: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    skipped: z.number().int().nonnegative(),
+});
+const PARSERS = {
+    vitest,
+    jest,
+    pytest,
+    cargo,
+    go: goTest,
+    mocha,
+    node: nodeTest,
+    bun,
+    deno,
+    unittest,
+    rspec,
+    minitest,
+    phpunit,
+    dotnet,
+    surefire,
+    eslint,
+    playwright,
+    errors: errorsFound,
+};
+const HINTS = [
+    [/\bvitest\b/, ["vitest"]],
+    [/\bjest\b|\b(react-scripts|craco)\s+test\b/, ["jest"]],
+    [/\bmocha\b/, ["mocha"]],
+    [/\bnode\b[^|;&]*--test\b/, ["node"]],
+    [/\b(pytest|py\.test)\b/, ["pytest"]],
+    [/\bgo\s+test\b/, ["go"]],
+    [/\bcargo\s+(test|nextest)\b/, ["cargo"]],
+    [/\brspec\b/, ["rspec"]],
+    [/\b(rails|rake)\s+test\b|\bminitest\b/, ["minitest"]],
+    [/\b(phpunit|pest)\b/, ["phpunit"]],
+    [/\bdotnet\s+test\b/, ["dotnet"]],
+    [/\b(mvnw?|gradlew?)\b/, ["surefire"]],
+    [/\bbun\s+test\b/, ["bun"]],
+    [/\bdeno\s+test\b/, ["deno"]],
+    [/\bunittest\b/, ["unittest"]],
+    [/\beslint\b/, ["eslint"]],
+    [/\bplaywright\b/, ["playwright"]],
+    [/\b(tsc|vue-tsc|biome|ruff|mypy)\b/, ["errors"]],
+];
+export function runnerHint(command) {
+    return [...new Set(HINTS.flatMap(([pattern, names]) => (pattern.test(command) ? names : [])))];
+}
+export function parseSummary(output, hint = []) {
+    const text = stripVTControlCharacters(output).replace(/\r\n?/g, "\n");
+    const names = hint.length > 0 ? hint : Object.keys(PARSERS);
+    const found = names.flatMap((name) => {
+        const item = PARSERS[name](text);
+        return item ? [{ ...item, source: name }] : [];
+    });
+    const latest = found.sort((a, b) => b.at - a.at)[0];
+    return latest ? { counts: latest.counts, source: latest.source } : undefined;
+}
+export function parseCounts(output, hint = []) {
+    return parseSummary(output, hint)?.counts;
+}
+const FAILING = {
+    vitest: [/^\s*FAIL\s+(\S.*? > .+?)\s*$/gm, /^\s*FAIL\s+(\S+)\s*(?:\[.*\])?\s*$/gm],
+    jest: [/^\s*● (?!Test suite failed to run)(.+?)\s*$/gm, /^FAIL\s+(\S+)/gm],
+    pytest: [/^(?:FAILED|ERROR) (\S+::\S+|\S+\.py)/gm],
+    go: [/^\s*--- FAIL: (\S+)/gm, /^FAIL\s+(\S+)\s+(?:\[.*\]|[\d.]+s)/gm, /^panic: .*/gm],
+    cargo: [/^test (\S+) \.\.\. FAILED$/gm, /^error: test failed, to rerun pass (.+)$/gm],
+    rspec: [/^rspec \S+ # (.+)$/gm],
+    unittest: [/^(?:FAIL|ERROR): (\S+ \(.+\))$/gm],
+    node: [/^not ok \d+ - (.+)$/gm],
+    mocha: [/^\s+\d+\) (.+):$/gm],
+    phpunit: [/^\d+\) (\S+::\S+)/gm],
+    dotnet: [/^\s+Failed (\S+) \[/gm],
+    errors: [/^(\S[^(\n]*)\(\d+,\d+\): error (TS\d+)/gm, /^(\S+):\d+:\d+ (lint\/\S+)/gm],
+    playwright: [/^\s+\d+\) (\[.+?\] › .+)$/gm],
+};
+const STRICT = ["vitest", "go", "cargo", "unittest"];
+export function parseFailing(output, hint) {
+    const text = stripVTControlCharacters(output).replace(/\r\n?/g, "\n");
+    const patterns = (hint.length > 0 ? hint : STRICT).flatMap((name) => FAILING[name] ?? []);
+    if (patterns.length === 0)
+        return undefined;
+    const names = patterns.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => (match.slice(1).filter(Boolean).join(" ") || match[0] || "").trim()));
+    return names.length > 0 ? [...new Set(names)].sort() : undefined;
+}
+export function executed(counts) {
+    return counts.passed + counts.failed;
+}
+function counts(passed = 0, failed = 0, skipped = 0) {
+    return { passed, failed, skipped };
+}
+function all(text, pattern) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    return [...text.matchAll(new RegExp(pattern.source, flags))];
+}
+function last(text, pattern) {
+    return all(text, pattern).at(-1);
+}
+function number(value) {
+    return value ? Number(value) : 0;
+}
+function parts(list, separator) {
+    const found = new Map();
+    for (const part of list.split(separator)) {
+        const match = /(\d+)\s+([a-z]+)/i.exec(part.trim());
+        if (match)
+            found.set((match[2] ?? "").toLowerCase(), number(match[1]));
+    }
+    return found;
+}
+function at(match, value) {
+    return match ? { counts: value, at: match.index } : undefined;
+}
+function vitest(text) {
+    const match = last(text, /^\s*Tests\s+((?:\d+ [a-z]+(?: [a-z]+)?(?: \| )?)+)\s*\((\d+)\)/m);
+    if (!match)
+        return undefined;
+    const found = parts(match[1] ?? "", /\|/);
+    return at(match, counts(found.get("passed"), found.get("failed"), (found.get("skipped") ?? 0) + (found.get("todo") ?? 0)));
+}
+function jest(text) {
+    const match = last(text, /^Tests:\s+(.*?)(\d+) total$/m);
+    if (!match)
+        return undefined;
+    const found = parts(match[1] ?? "", /,/);
+    return at(match, counts(found.get("passed"), found.get("failed"), (found.get("skipped") ?? 0) + (found.get("todo") ?? 0)));
+}
+function pytest(text) {
+    const match = last(text, /^(?:=+ )?((?:\d+ (?:passed|failed|skipped|errors?|xfailed|xpassed|deselected|warnings?)(?:, )?)+) in [\d.]+s/m);
+    if (!match)
+        return undefined;
+    const found = parts(match[1] ?? "", /,/);
+    return at(match, counts((found.get("passed") ?? 0) + (found.get("xpassed") ?? 0), (found.get("failed") ?? 0) + (found.get("error") ?? 0) + (found.get("errors") ?? 0), (found.get("skipped") ?? 0) + (found.get("xfailed") ?? 0) + (found.get("deselected") ?? 0)));
+}
+function cargo(output) {
+    const text = cargoText(output);
+    const matches = all(text, /^test result: (?:ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored/m);
+    if (matches.length === 0)
+        return undefined;
+    const sum = matches.reduce((total, match) => counts(total.passed + number(match[1]), total.failed + number(match[2]), total.skipped + number(match[3])), counts());
+    return at(matches.at(-1), { ...sum, failed: sum.failed + cargoCutShort(text) });
+}
+function cargoText(output) {
+    return output.replace(/^---- .+ std(?:out|err) ----$[\s\S]*?^failures:$/gm, "");
+}
+function cargoCutShort(text) {
+    let missing = 0;
+    let open;
+    for (const line of text.split("\n")) {
+        const running = /^running (\d+) tests?$/.exec(line);
+        if (running) {
+            if (open !== undefined)
+                missing += Math.max(open, 1);
+            open = number(running[1]);
+        }
+        else if (/^test result: /.test(line)) {
+            open = undefined;
+        }
+        else if (open !== undefined && /^test \S+ \.\.\. (?:ok|FAILED|ignored)/.test(line)) {
+            open = Math.max(open - 1, 0);
+        }
+    }
+    return missing + (open === undefined ? 0 : Math.max(open, 1));
+}
+export function cargoUnits(output) {
+    return [...cargoText(output).matchAll(/^\s*Running (?:unittests )?(\S+)(?: \(([^)]+)\))?/gm)].map((match) => (match[2] ?? match[1] ?? "").replace(/\\/g, "/").replace(/-[0-9a-f]{16}(\.exe)?$/, ""));
+}
+export function errorLines(output) {
+    const text = stripVTControlCharacters(output).replace(/\r\n?/g, "\n");
+    const lines = text
+        .split("\n")
+        .filter((line) => /\berror\b|\S+:\d+(:\d+)?:/i.test(line))
+        .map((line) => line
+        .replace(/:\d+(:\d+)?/g, "")
+        .replace(/\(\d+,\d+\)/g, "")
+        .replace(/\b\d+(\.\d+)?m?s\b/g, "")
+        .trim())
+        .filter(Boolean);
+    return [...new Set(lines)].sort();
+}
+function goTest(text) {
+    const verbose = all(text, /^\s*--- (PASS|FAIL|SKIP): /m);
+    if (verbose.length === 0 || !/^=== RUN /m.test(text))
+        return undefined;
+    const tally = (kind) => verbose.filter((match) => match[1] === kind).length;
+    return at(verbose.at(-1), counts(tally("PASS"), tally("FAIL"), tally("SKIP")));
+}
+function mocha(text) {
+    const passing = last(text, /^\s*(\d+) passing\b/m);
+    if (!passing)
+        return undefined;
+    const tail = text.slice(passing.index, passing.index + 300);
+    const failing = last(tail, /^\s*(\d+) failing\b/m);
+    const pending = last(tail, /^\s*(\d+) pending\b/m);
+    return at(passing, counts(number(passing[1]), number(failing?.[1]), number(pending?.[1])));
+}
+function nodeTest(text) {
+    const pass = last(text, /^(?:#|ℹ) pass (\d+)$/m);
+    const fail = last(text, /^(?:#|ℹ) fail (\d+)$/m);
+    if (!pass || !fail)
+        return undefined;
+    const skipped = last(text, /^(?:#|ℹ) skipped (\d+)$/m);
+    const todo = last(text, /^(?:#|ℹ) todo (\d+)$/m);
+    return at(fail, counts(number(pass[1]), number(fail[1]), number(skipped?.[1]) + number(todo?.[1])));
+}
+function bun(text) {
+    const pass = last(text, /^\s*(\d+) pass$/m);
+    const fail = last(text, /^\s*(\d+) fail$/m);
+    if (!pass || !fail)
+        return undefined;
+    const skip = last(text, /^\s*(\d+) skip$/m);
+    const todo = last(text, /^\s*(\d+) todo$/m);
+    return at(fail, counts(number(pass[1]), number(fail[1]), number(skip?.[1]) + number(todo?.[1])));
+}
+function deno(text) {
+    const match = last(text, /^(?:ok|FAILED) \| (\d+) passed(?: \(\d+ steps?\))? \| (\d+) failed(?: \(\d+ steps?\))?(?: \| (\d+) ignored)?/m);
+    return match
+        ? at(match, counts(number(match[1]), number(match[2]), number(match[3])))
+        : undefined;
+}
+function unittest(text) {
+    const ran = last(text, /^Ran (\d+) tests? in [\d.]+s$/m);
+    if (!ran)
+        return undefined;
+    const status = last(text, /^(OK|FAILED)(?: \((.*)\))?$/m);
+    const found = parts((status?.[2] ?? "").replace(/=/g, " ").replace(/(\w+) (\d+)/g, "$2 $1"), /,/);
+    const failed = (found.get("failures") ?? 0) + (found.get("errors") ?? 0);
+    const skipped = found.get("skipped") ?? 0;
+    return at(ran, counts(number(ran[1]) - failed - skipped, failed, skipped));
+}
+function rspec(text) {
+    const match = last(text, /^(\d+) examples?, (\d+) failures?(?:, (\d+) pending)?/m);
+    if (!match)
+        return undefined;
+    const failed = number(match[2]);
+    const skipped = number(match[3]);
+    return at(match, counts(number(match[1]) - failed - skipped, failed, skipped));
+}
+function minitest(text) {
+    const match = last(text, /^(\d+) (?:runs|tests), \d+ assertions, (\d+) failures, (\d+) errors, (\d+) skips/m);
+    if (!match)
+        return undefined;
+    const failed = number(match[2]) + number(match[3]);
+    const skipped = number(match[4]);
+    return at(match, counts(number(match[1]) - failed - skipped, failed, skipped));
+}
+function phpunit(text) {
+    const ok = last(text, /^OK \((\d+) tests?, \d+ assertions?\)/m);
+    const match = last(text, /^Tests: (\d+), Assertions: \d+(.*)$/m);
+    if (ok && (!match || ok.index > match.index))
+        return at(ok, counts(number(ok[1])));
+    if (!match)
+        return undefined;
+    const found = parts((match[2] ?? "").replace(/(\w+): (\d+)/g, "$2 $1"), /,/);
+    const failed = (found.get("errors") ?? 0) + (found.get("failures") ?? 0);
+    const skipped = (found.get("skipped") ?? 0) + (found.get("incomplete") ?? 0);
+    return at(match, counts(number(match[1]) - failed - skipped, failed, skipped));
+}
+function dotnet(text) {
+    const matches = all(text, /(?:Passed|Failed)!\s+-\s+Failed:\s+(\d+),\s+Passed:\s+(\d+),\s+Skipped:\s+(\d+),\s+Total:\s+\d+/);
+    if (matches.length === 0)
+        return undefined;
+    const sum = matches.reduce((total, match) => counts(total.passed + number(match[2]), total.failed + number(match[1]), total.skipped + number(match[3])), counts());
+    return at(matches.at(-1), sum);
+}
+function surefire(text) {
+    const match = last(text, /Tests run: (\d+), Failures: (\d+), Errors: (\d+), Skipped: (\d+)/);
+    if (!match)
+        return undefined;
+    const failed = number(match[2]) + number(match[3]);
+    const skipped = number(match[4]);
+    return at(match, counts(number(match[1]) - failed - skipped, failed, skipped));
+}
+function playwright(text) {
+    const passed = last(text, /^\s*(\d+) passed \([\d.]+m?s\)$/m);
+    if (!passed)
+        return undefined;
+    const failed = last(text, /^\s*(\d+) failed$/m);
+    const flaky = last(text, /^\s*(\d+) flaky$/m);
+    const skipped = last(text, /^\s*(\d+) skipped$/m);
+    return at(passed, counts(number(passed[1]) + number(flaky?.[1]), number(failed?.[1]), number(skipped?.[1])));
+}
+function eslint(text) {
+    const match = last(text, /✖ \d+ problems? \((\d+) errors?, \d+ warnings?\)/);
+    return match ? at(match, counts(0, number(match[1]))) : undefined;
+}
+function errorsFound(text) {
+    const match = last(text, /^Found (\d+) errors?\b/m);
+    if (match)
+        return at(match, counts(0, number(match[1])));
+    const lines = all(text, /^\S.*\(\d+,\d+\): error TS\d+:/m);
+    return lines.length > 0 ? at(lines.at(-1), counts(0, lines.length)) : undefined;
+}