coverage-check 0.1.1 → 0.2.2

package/dist/src/diff-parser.mjs

@@ -0,0 +1,127 @@
+/**
+ * Decodes a git C-string (inner content between surrounding double-quotes).
+ * Git quotes unusual paths (non-ASCII, spaces, etc.) with core.quotePath=true.
+ * Handles octal byte escapes (\nnn), \\, \", \n, \t.
+ */
+export function decodeGitCString(s) {
+    const bytes = [];
+    for (let i = 0; i < s.length;) {
+        if (s[i] === "\\" && i + 1 < s.length) {
+            const next = s[i + 1];
+            if (next >= "0" && next <= "7") {
+                bytes.push(parseInt(s.slice(i + 1, i + 4), 8));
+                i += 4;
+            }
+            else if (next === "\\") {
+                bytes.push(92);
+                i += 2;
+            }
+            else if (next === '"') {
+                bytes.push(34);
+                i += 2;
+            }
+            else if (next === "n") {
+                bytes.push(10);
+                i += 2;
+            }
+            else if (next === "t") {
+                bytes.push(9);
+                i += 2;
+            }
+            else {
+                bytes.push(s.charCodeAt(i));
+                i++;
+            }
+        }
+        else {
+            bytes.push(s.charCodeAt(i));
+            i++;
+        }
+    }
+    return Buffer.from(new Uint8Array(bytes)).toString("utf8");
+}
+/**
+ * Parses the output of `git diff --unified=0` into a map of
+ * repo-root-relative file path → set of added/modified line numbers.
+ *
+ * Only added lines (lines in the new version) are tracked. Deleted-only
+ * hunks (where the `+` count is 0) are skipped.
+ */
+export function parseDiff(text) {
+    const result = new Map();
+    let currentLines = null;
+    let inHeader = false;
+    for (const raw of text.split("\n")) {
+        const line = raw.trimEnd();
+        // Only parse +++ as a file header when we are in the diff header block
+        // (after `diff --git` / `---`). Without this guard a source line beginning
+        // with `++ b/` would appear as `+++ b/…` in the diff and be misclassified.
+        let newFilePath = null;
+        if (inHeader) {
+            if (line.startsWith("+++ b/")) {
+                newFilePath = line.slice(6);
+            }
+            else if (line.startsWith('+++ "b/') && line.endsWith('"')) {
+                newFilePath = decodeGitCString(line.slice(5, -1)).slice(2);
+            }
+        }
+        if (newFilePath !== null) {
+            inHeader = false;
+            const path = newFilePath;
+            if (path === "dev/null") {
+                currentLines = null;
+                continue;
+            }
+            currentLines = result.get(path) ?? new Set();
+            result.set(path, currentLines);
+        }
+        else if (line.startsWith("--- ")) {
+            // ignore (part of diff header)
+        }
+        else if (line.startsWith("@@ ") && currentLines !== null) {
+            // @@ -old_start[,old_count] +new_start[,new_count] @@
+            const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+            if (!match)
+                continue;
+            const newStart = parseInt(match[1], 10);
+            const newCount = match[2] !== undefined ? parseInt(match[2], 10) : 1;
+            if (newCount === 0)
+                continue;
+            for (let i = 0; i < newCount; i++) {
+                currentLines.add(newStart + i);
+            }
+        }
+        else if (line.startsWith("diff --git ")) {
+            currentLines = null;
+            inHeader = true;
+        }
+    }
+    return result;
+}
+/** Runs git diff and returns the parsed result. */
+export async function getChangedLines(baseRef, headRef) {
+    const { spawn } = await import("node:child_process");
+    const spawnProcess = (cmd, args) => new Promise((resolve, reject) => {
+        const chunks = [];
+        const proc = spawn(cmd, args, { stdio: ["ignore", "pipe", "inherit"] });
+        proc.stdout.on("data", (chunk) => chunks.push(chunk));
+        proc.on("error", reject);
+        proc.on("close", (code) => code === 0
+            ? resolve(Buffer.concat(chunks).toString("utf8"))
+            : reject(new Error(`${cmd} exited with code ${code}`)));
+    });
+    const mergeBase = await spawnProcess("git", ["merge-base", baseRef, headRef]);
+    const base = mergeBase.trim();
+    // --src-prefix/--dst-prefix override diff.noprefix and diff.mnemonicPrefix git config
+    const diff = await spawnProcess("git", [
+        "diff",
+        "--unified=0",
+        "--inter-hunk-context=0",
+        "--no-color",
+        "--src-prefix=a/",
+        "--dst-prefix=b/",
+        base,
+        headRef,
+    ]);
+    return parseDiff(diff);
+}

package/dist/src/github-comment.d.mts

@@ -0,0 +1,9 @@
+export type GhRunner = (args: string[]) => Promise<string>;
+/**
+ * Posts or updates the sticky coverage-check comment on a pull request.
+ *
+ * - On failure: upserts the failure comment body (POST if absent, PATCH if exists).
+ * - On pass with prior comment: deletes the prior comment.
+ * - On pass with no prior comment: stays silent.
+ */
+export declare function upsertComment(body: string, repo: string, pr: number, passed: boolean, gh?: GhRunner): Promise<void>;

package/dist/src/github-comment.mjs

@@ -0,0 +1,66 @@
+import { COMMENT_MARKER } from "./report.mjs";
+/* c8 ignore start */
+async function defaultGhRunner(args) {
+    const { spawn } = await import("node:child_process");
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const proc = spawn("gh", args, { stdio: ["ignore", "pipe", "inherit"] });
+        proc.stdout.on("data", (chunk) => chunks.push(chunk));
+        proc.on("error", reject);
+        proc.on("close", (code) => code === 0
+            ? resolve(Buffer.concat(chunks).toString("utf8"))
+            : reject(new Error(`gh ${args[0]} exited with code ${code}`)));
+    });
+}
+/* c8 ignore stop */
+/** Finds the ID of the existing coverage-check sticky comment, if any. */
+async function findExistingComment(repo, pr, gh) {
+    try {
+        const raw = await gh([
+            "api",
+            `repos/${repo}/issues/${pr}/comments`,
+            "--paginate",
+            "-q",
+            `first(.[] | select(.body | startswith("${COMMENT_MARKER}"))) | .id`,
+        ]);
+        // --paginate applies the jq filter per page; take the first valid ID across all lines
+        const id = raw
+            .split("\n")
+            .map((line) => parseInt(line.trim(), 10))
+            .find((n) => Number.isFinite(n) && n > 0);
+        return id ?? null;
+    }
+    catch (err) {
+        process.stderr.write(`coverage-check: warning: failed to look up existing comment: ${err}\n`);
+        return null;
+    }
+}
+/**
+ * Posts or updates the sticky coverage-check comment on a pull request.
+ *
+ * - On failure: upserts the failure comment body (POST if absent, PATCH if exists).
+ * - On pass with prior comment: deletes the prior comment.
+ * - On pass with no prior comment: stays silent.
+ */
+export async function upsertComment(body, repo, pr, passed, gh = defaultGhRunner) {
+    const existingId = await findExistingComment(repo, pr, gh);
+    if (passed && existingId === null)
+        return;
+    if (passed && existingId !== null) {
+        await gh(["api", `repos/${repo}/issues/comments/${existingId}`, "-X", "DELETE"]);
+        return;
+    }
+    if (existingId !== null) {
+        await gh([
+            "api",
+            `repos/${repo}/issues/comments/${existingId}`,
+            "-X",
+            "PATCH",
+            "-f",
+            `body=${body}`,
+        ]);
+    }
+    else {
+        await gh(["api", `repos/${repo}/issues/${pr}/comments`, "-f", `body=${body}`]);
+    }
+}

package/dist/src/lcov-merge.d.mts

@@ -0,0 +1,5 @@
+import type { LcovData } from "./types.mts";
+/** Merges multiple LcovData maps by summing hit counts per file per line. */
+export declare function mergeLcov(reports: LcovData[]): LcovData;
+/** Serializes LcovData back to LCOV text format. */
+export declare function toLcov(lcov: LcovData): string;

package/dist/src/lcov-merge.mjs

@@ -0,0 +1,29 @@
+/** Merges multiple LcovData maps by summing hit counts per file per line. */
+export function mergeLcov(reports) {
+    const merged = new Map();
+    for (const report of reports) {
+        for (const [file, lines] of report) {
+            let target = merged.get(file);
+            if (target === undefined) {
+                target = new Map();
+                merged.set(file, target);
+            }
+            for (const [lineNo, hits] of lines) {
+                target.set(lineNo, (target.get(lineNo) ?? 0) + hits);
+            }
+        }
+    }
+    return merged;
+}
+/** Serializes LcovData back to LCOV text format. */
+export function toLcov(lcov) {
+    const lines = [];
+    for (const [file, fileLines] of lcov) {
+        lines.push(`SF:${file}`);
+        for (const [lineNo, hits] of fileLines) {
+            lines.push(`DA:${lineNo},${hits}`);
+        }
+        lines.push("end_of_record");
+    }
+    return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+}

package/dist/src/lcov-parser.d.mts

@@ -0,0 +1,8 @@
+import type { LcovData } from "./types.mts";
+/**
+ * Parses LCOV text into a map of repo-root-relative file path → line → hit count.
+ *
+ * Paths are normalized by stripping a given prefix (e.g. $GITHUB_WORKSPACE or cwd)
+ * so callers see repo-root-relative paths regardless of where the runner ran.
+ */
+export declare function parseLcov(text: string, stripPrefixes?: string[]): LcovData;

package/dist/src/lcov-parser.mjs

@@ -0,0 +1,44 @@
+/**
+ * Parses LCOV text into a map of repo-root-relative file path → line → hit count.
+ *
+ * Paths are normalized by stripping a given prefix (e.g. $GITHUB_WORKSPACE or cwd)
+ * so callers see repo-root-relative paths regardless of where the runner ran.
+ */
+export function parseLcov(text, stripPrefixes = []) {
+    const result = new Map();
+    let currentLines = null;
+    for (const raw of text.split("\n")) {
+        const line = raw.trimEnd();
+        if (line.startsWith("SF:")) {
+            let path = line.slice(3);
+            for (const prefix of stripPrefixes) {
+                if (path.startsWith(prefix)) {
+                    path = path.slice(prefix.length);
+                    break;
+                }
+            }
+            path = normalizePath(path);
+            currentLines = result.get(path) ?? new Map();
+            result.set(path, currentLines);
+        }
+        else if (line.startsWith("DA:") && currentLines !== null) {
+            const rest = line.slice(3);
+            const comma = rest.indexOf(",");
+            if (comma === -1)
+                continue;
+            const lineNo = parseInt(rest.slice(0, comma), 10);
+            const hits = parseInt(rest.slice(comma + 1), 10);
+            if (!Number.isFinite(lineNo) || !Number.isFinite(hits))
+                continue;
+            const prev = currentLines.get(lineNo) ?? 0;
+            currentLines.set(lineNo, prev + hits);
+        }
+        else if (line === "end_of_record") {
+            currentLines = null;
+        }
+    }
+    return result;
+}
+function normalizePath(p) {
+    return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}

package/dist/src/load-artifacts.d.mts

@@ -0,0 +1,9 @@
+/** Recursively collects all lcov.info files under the given directory. */
+export declare function collectLcovFiles(dir: string): string[];
+/**
+ * Builds the list of path prefixes to strip from LCOV SF: lines.
+ *
+ * Defaults: $GITHUB_WORKSPACE (if set) and cwd are always prepended.
+ * Additional prefixes can be passed via the `extra` parameter.
+ */
+export declare function buildStripPrefixes(extra?: string[]): string[];

package/dist/src/load-artifacts.mjs

@@ -0,0 +1,41 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+/** Recursively collects all lcov.info files under the given directory. */
+export function collectLcovFiles(dir) {
+    const results = [];
+    try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...collectLcovFiles(full));
+            }
+            else if (entry.name === "lcov.info") {
+                results.push(full);
+            }
+        }
+    }
+    catch (err) {
+        /* c8 ignore next */
+        if (err.code !== "ENOENT")
+            /* c8 ignore next */
+            process.stderr.write(`coverage-check: unexpected error reading artifacts directory ${dir}: ${err}\n`);
+        // ENOENT: directory does not exist — no artifacts
+    }
+    return results;
+}
+/**
+ * Builds the list of path prefixes to strip from LCOV SF: lines.
+ *
+ * Defaults: $GITHUB_WORKSPACE (if set) and cwd are always prepended.
+ * Additional prefixes can be passed via the `extra` parameter.
+ */
+export function buildStripPrefixes(extra = []) {
+    const prefixes = extra.map((p) => (p.endsWith("/") ? p : `${p}/`));
+    const ws = process.env["GITHUB_WORKSPACE"];
+    if (ws)
+        prefixes.push(ws.endsWith("/") ? ws : `${ws}/`);
+    const cwd = process.cwd();
+    /* c8 ignore next -- process.cwd() virtually never returns a trailing-slash path */
+    prefixes.push(cwd.endsWith("/") ? cwd : `${cwd}/`);
+    return prefixes;
+}

package/dist/src/patch-coverage.d.mts

@@ -0,0 +1,5 @@
+import type { BucketResult, CoverageRule, DiffLines, FileCoverageResult, LcovData } from "./types.mts";
+export declare function computePatchCoverage(diff: DiffLines, lcov: LcovData, rules: CoverageRule[]): {
+    buckets: BucketResult[];
+    informational: FileCoverageResult[];
+};

package/dist/src/patch-coverage.mjs

@@ -0,0 +1,65 @@
+import { matchRule } from "./rules.mjs";
+export function computePatchCoverage(diff, lcov, rules) {
+    const bucketMap = new Map();
+    const informational = [];
+    for (const [file, changedLineSet] of diff) {
+        const fileLines = lcov.get(file);
+        if (fileLines === undefined)
+            continue; // not in lcov scope — skip
+        const coverable = [];
+        const uncoveredLines = [];
+        let hit = 0;
+        for (const lineNo of changedLineSet) {
+            if (!fileLines.has(lineNo))
+                continue; // line not tracked by coverage
+            coverable.push(lineNo);
+            if (fileLines.get(lineNo) > 0) {
+                hit++;
+            }
+            else {
+                uncoveredLines.push(lineNo);
+            }
+        }
+        if (coverable.length === 0)
+            continue;
+        const rule = matchRule(file, rules);
+        const fileResult = {
+            file,
+            coverable: coverable.length,
+            hit,
+            uncoveredLines: uncoveredLines.sort((a, b) => a - b),
+            rule: rule?.paths ?? null,
+        };
+        if (rule === null) {
+            informational.push(fileResult);
+            continue;
+        }
+        let bucket = bucketMap.get(rule.paths);
+        if (bucket === undefined) {
+            bucket = {
+                rule: rule.paths,
+                threshold: rule.patch_coverage_min,
+                coverable: 0,
+                hit: 0,
+                files: [],
+                passed: true,
+            };
+            bucketMap.set(rule.paths, bucket);
+        }
+        bucket.coverable += coverable.length;
+        bucket.hit += hit;
+        bucket.files.push(fileResult);
+    }
+    const buckets = [...bucketMap.values()];
+    for (const bucket of buckets) {
+        /* c8 ignore next -- bucket always has coverable>0 (L36 guard prevents empty-coverable files from reaching bucketMap) */
+        if (bucket.coverable === 0) {
+            bucket.passed = true;
+        }
+        else {
+            const pct = (bucket.hit / bucket.coverable) * 100;
+            bucket.passed = pct >= bucket.threshold;
+        }
+    }
+    return { buckets, informational };
+}

package/dist/src/report.d.mts

@@ -0,0 +1,4 @@
+import type { CoverageCheckResult } from "./types.mts";
+export declare const COMMENT_MARKER = "<!-- coverage-check -->";
+export declare function collapseRanges(lines: number[]): string;
+export declare function renderFailureComment(result: CoverageCheckResult, runUrl: string, now?: string): string;

package/dist/src/report.mjs

@@ -0,0 +1,65 @@
+export const COMMENT_MARKER = "<!-- coverage-check -->";
+export function collapseRanges(lines) {
+    if (lines.length === 0)
+        return "";
+    const sorted = [...lines].sort((a, b) => a - b);
+    const ranges = [];
+    let start = sorted[0];
+    let end = start;
+    for (let i = 1; i < sorted.length; i++) {
+        const n = sorted[i];
+        if (n === end + 1) {
+            end = n;
+        }
+        else {
+            ranges.push(start === end ? `L${start}` : `L${start}-${end}`);
+            start = n;
+            end = n;
+        }
+    }
+    ranges.push(start === end ? `L${start}` : `L${start}-${end}`);
+    return ranges.join(", ");
+}
+function pct(bucket) {
+    if (bucket.coverable === 0)
+        return "—";
+    return `${((bucket.hit / bucket.coverable) * 100).toFixed(1)}% (${bucket.hit}/${bucket.coverable})`;
+}
+function renderFileList(files) {
+    return files
+        .filter((f) => f.uncoveredLines.length > 0)
+        .map((f) => `- \`${f.file}\`: ${collapseRanges(f.uncoveredLines)}`)
+        .join("\n");
+}
+export function renderFailureComment(result, runUrl, now = new Date().toISOString()) {
+    const failingBuckets = result.buckets.filter((b) => !b.passed);
+    const table = [
+        "| Workspace rule | Patch coverage | Threshold |",
+        "|---|---|---|",
+        ...failingBuckets.map((b) => `| \`${b.rule}\` | ${pct(b)} | ${b.threshold}% |`),
+    ].join("\n");
+    const sections = failingBuckets
+        .map((b) => {
+        const fileList = renderFileList(b.files);
+        return `**\`${b.rule}\`** (threshold ${b.threshold}%):\n${fileList || "_No line-level data available_"}`;
+    })
+        .join("\n\n");
+    const informationalLines = result.informational
+        .filter((f) => f.uncoveredLines.length > 0)
+        .map((f) => `- \`${f.file}\`: ${collapseRanges(f.uncoveredLines)}`)
+        .join("\n");
+    const informationalSection = informationalLines.length > 0
+        ? `\n<details><summary>Informational (no rule)</summary>\n\n${informationalLines}\n</details>`
+        : "";
+    return `${COMMENT_MARKER}
+## Patch coverage gate failed
+
+${table}
+
+### Uncovered lines
+
+${sections}
+${informationalSection}
+
+_Last updated: ${now} · [Workflow run](${runUrl})_`;
+}

package/dist/src/rules.d.mts

@@ -0,0 +1,4 @@
+import type { CoverageRule } from "./types.mts";
+export declare function loadRules(rulesPath: string): CoverageRule[];
+/** Returns the first matching rule for a repo-root-relative file path, or null. */
+export declare function matchRule(file: string, rules: CoverageRule[]): CoverageRule | null;

package/dist/src/rules.mjs

@@ -0,0 +1,30 @@
+/* c8 ignore next */
+import { readFileSync } from "node:fs";
+import { matchesGlob } from "node:path";
+import yaml from "js-yaml";
+export function loadRules(rulesPath) {
+    const text = readFileSync(rulesPath, "utf8");
+    const parsed = yaml.load(text);
+    if (!Array.isArray(parsed?.rules)) {
+        throw new Error(`${rulesPath}: expected a 'rules' array`);
+    }
+    for (let i = 0; i < parsed.rules.length; i++) {
+        const rule = parsed.rules[i];
+        if (typeof rule?.paths !== "string") {
+            throw new Error(`${rulesPath}: rule[${i}].paths must be a string`);
+        }
+        const min = rule.patch_coverage_min;
+        if (!Number.isFinite(min) || min < 0 || min > 100) {
+            throw new Error(`${rulesPath}: rule[${i}].patch_coverage_min must be a number between 0 and 100`);
+        }
+    }
+    return parsed.rules;
+}
+/** Returns the first matching rule for a repo-root-relative file path, or null. */
+export function matchRule(file, rules) {
+    for (const rule of rules) {
+        if (matchesGlob(file, rule.paths))
+            return rule;
+    }
+    return null;
+}

package/dist/src/s3-suite-store.d.mts

@@ -0,0 +1,28 @@
+import type { SuitePutMeta, SuiteStore } from "./suite-store.mts";
+type ClientLike = {
+    send(cmd: object): Promise<unknown>;
+};
+export type S3SuiteStoreOptions = {
+    bucket: string;
+    prefix?: string;
+    region?: string;
+    /** Inject a custom S3 client (e.g. for testing). */
+    client?: ClientLike;
+};
+export declare class S3SuiteStore implements SuiteStore {
+    private readonly bucket;
+    private readonly prefix;
+    private readonly client;
+    constructor({ bucket, prefix, region, client }: S3SuiteStoreOptions);
+    private key;
+    list(): Promise<string[]>;
+    get(suite: string, opts?: {
+        sha?: string;
+        branch?: string;
+    }): Promise<Buffer | null>;
+    put(suite: string, lcov: Buffer, meta?: SuitePutMeta): Promise<void>;
+    private getLegacy;
+    private shouldWritePointer;
+    private readPointer;
+}
+export {};