coverage-check 0.2.2 → 0.4.0

package/dist/src/cli.mjs

@@ -1,5 +1,7 @@
 import { main as checkMain } from "./commands/check.mjs";
 import { main as storePutMain } from "./commands/store-put.mjs";
+import { main as htmlMain } from "./commands/html.mjs";
+import { main as summaryMain } from "./commands/summary.mjs";
 const stderr = (msg) => process.stderr.write(`${msg}\n`);
 export async function main(argv) {
     const sub = argv[0];
@@ -9,6 +11,10 @@ export async function main(argv) {
         return checkMain(argv.slice(1));
     if (sub === "store-put")
         return storePutMain(argv.slice(1));
+    if (sub === "html")
+        return htmlMain(argv.slice(1));
+    if (sub === "summary")
+        return summaryMain(argv.slice(1));
     stderr(`coverage-check: unknown subcommand: ${JSON.stringify(sub)}`);
     return 2;
 }

package/dist/src/commands/check.mjs

@@ -35,6 +35,7 @@ export async function runCheck(args) {
     const stripPrefixes = buildStripPrefixes(args.stripPrefixes);
     const reports = [];
     const suiteSources = [];
+    const parsedSources = [];
     if (args.store !== null) {
         const suites = await args.store.list();
         for (const suite of suites) {
@@ -45,6 +46,7 @@ export async function runCheck(args) {
                 const lcov = parseLcov(buf.toString("utf8"), stripPrefixes);
                 reports.push(lcov);
                 suiteSources.push({ suite, source: "store", lcov });
+                parsedSources.push({ name: `suite '${suite}'`, lcov });
             }
         }
     }
@@ -54,6 +56,7 @@ export async function runCheck(args) {
         const lcov = parseLcov(readFileSync(f, "utf8"), stripPrefixes);
         reports.push(lcov);
         freshLcovs.push(lcov);
+        parsedSources.push({ name: `file '${f}'`, lcov });
     }
     if (freshLcovs.length > 0) {
         suiteSources.push({
@@ -75,6 +78,27 @@ export async function runCheck(args) {
         stderr(`coverage-check: git diff failed: ${err}`);
         return 2;
     }
+    if (diff.size > 0) {
+        for (const { name, lcov: sourceLcov } of parsedSources) {
+            let contributes = false;
+            for (const [file, changedLines] of diff) {
+                const fileLines = sourceLcov.get(file);
+                if (fileLines) {
+                    for (const lineNo of changedLines) {
+                        if (fileLines.has(lineNo)) {
+                            contributes = true;
+                            break;
+                        }
+                    }
+                }
+                if (contributes)
+                    break;
+            }
+            if (!contributes) {
+                stderr(`coverage-check: warning: coverage from ${name} contributed 0 coverable lines to the patch result. This may indicate a path prefix mismatch.`);
+            }
+        }
+    }
     const { buckets, informational } = computePatchCoverage(diff, lcov, rules);
     const passed = buckets.every((b) => b.passed);
     const result = { buckets, informational, passed };

package/dist/src/commands/html.d.mts

@@ -0,0 +1,14 @@
+export type CoverageHtmlArgs = {
+    activeSuites: string[];
+    artifacts: string;
+    branch: string;
+    output: string;
+    storeFs: string | null;
+    storeS3: string | null;
+    stripPrefixes: string[];
+};
+export declare function parseCoverageHtmlArgs(argv: string[]): CoverageHtmlArgs;
+export declare function buildCoverageHtml(args: CoverageHtmlArgs): Promise<{
+    warnings: string[];
+}>;
+export declare function main(argv: string[]): Promise<number>;

package/dist/src/commands/html.mjs

@@ -0,0 +1,164 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { collectLcovFiles, buildStripPrefixes } from "../load-artifacts.mjs";
+import { lcovBufferToIstanbul } from "../lcov-to-istanbul.mjs";
+import { makeStore } from "../store-factory.mjs";
+function requireValue(flag, value) {
+    if (value === undefined || value.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+    return value;
+}
+export function parseCoverageHtmlArgs(argv) {
+    const args = {
+        activeSuites: [],
+        artifacts: "./coverage-artifacts",
+        branch: "main",
+        output: "./coverage-html",
+        storeFs: null,
+        storeS3: null,
+        stripPrefixes: [],
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const flag = argv[i];
+        const value = () => {
+            const parsed = requireValue(flag, argv[i + 1]);
+            i++;
+            return parsed;
+        };
+        switch (flag) {
+            case "--active-suite":
+                args.activeSuites.push(value());
+                break;
+            case "--artifacts":
+                args.artifacts = value();
+                break;
+            case "--branch":
+                args.branch = value();
+                break;
+            case "--output":
+                args.output = value();
+                break;
+            case "--store-fs":
+                args.storeFs = value();
+                break;
+            case "--store-s3":
+                args.storeS3 = value();
+                break;
+            case "--strip-prefix":
+                args.stripPrefixes.push(value());
+                break;
+            default:
+                throw new Error(`unknown flag: ${flag}`);
+        }
+    }
+    if (args.storeFs && args.storeS3)
+        throw new Error("--store-fs and --store-s3 are mutually exclusive");
+    if (args.branch.length === 0)
+        throw new Error("--branch must not be empty");
+    return args;
+}
+function suiteNameFromArtifactDir(name) {
+    if (!name.startsWith("coverage-"))
+        return null;
+    const suite = name.slice("coverage-".length);
+    return suite.length > 0 ? suite : null;
+}
+function loadCurrentSuiteBuffers(artifacts) {
+    if (!existsSync(artifacts))
+        return [];
+    return readdirSync(artifacts, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .flatMap((entry) => {
+        const suite = suiteNameFromArtifactDir(entry.name);
+        if (!suite)
+            return [];
+        const files = collectLcovFiles(path.join(artifacts, entry.name));
+        if (files.length === 0)
+            return [];
+        return [
+            {
+                suite,
+                source: "current",
+                lcov: Buffer.concat(files.flatMap((f) => [readFileSync(f), Buffer.from("\n")])),
+            },
+        ];
+    })
+        .sort((a, b) => a.suite.localeCompare(b.suite));
+}
+async function loadHistoricalSuiteBuffers(store, branch, activeSuiteNames, currentSuiteNames) {
+    if (store === null) {
+        return {
+            suites: [],
+            warnings: [
+                "Historical main coverage store was not configured; showing current-run coverage only.",
+            ],
+        };
+    }
+    if (activeSuiteNames.size === 0) {
+        return {
+            suites: [],
+            warnings: [
+                "Historical main coverage store was configured without an active suite manifest; showing current-run coverage only.",
+            ],
+        };
+    }
+    try {
+        const historicalNames = [...activeSuiteNames].filter((s) => !currentSuiteNames.has(s));
+        const results = await Promise.all(historicalNames.map(async (suite) => {
+            const lcov = await store.get(suite, { branch });
+            return lcov === null ? { missingSuite: suite } : { suite, lcov };
+        }));
+        const suites = results
+            .filter((r) => "lcov" in r)
+            .map((r) => ({ suite: r.suite, source: "history", lcov: r.lcov }));
+        const missing = results
+            .filter((r) => "missingSuite" in r)
+            .map((r) => r.missingSuite);
+        return {
+            suites,
+            warnings: missing.length === 0
+                ? []
+                : [
+                    `Historical main coverage missing for active suites: ${missing.sort((a, b) => a.localeCompare(b)).join(", ")}.`,
+                ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { suites: [], warnings: [`Historical main coverage could not be read: ${message}`] };
+    }
+}
+export async function buildCoverageHtml(args) {
+    const stripPrefixes = buildStripPrefixes(args.stripPrefixes);
+    const currentSuites = loadCurrentSuiteBuffers(args.artifacts);
+    const historical = await loadHistoricalSuiteBuffers(makeStore({ fs: args.storeFs, s3: args.storeS3 }), args.branch, new Set(args.activeSuites), new Set(currentSuites.map((s) => s.suite)));
+    const allSuites = [...currentSuites, ...historical.suites];
+    const { CoverageReport } = await import("monocart-coverage-reports");
+    const report = new CoverageReport({
+        name: "merged coverage",
+        outputDir: args.output,
+        reports: [["html"]],
+        lcov: true,
+    });
+    for (const suite of allSuites) {
+        await report.add(lcovBufferToIstanbul(suite.lcov, stripPrefixes));
+    }
+    if (allSuites.length > 0) {
+        await report.generate();
+    }
+    return { warnings: historical.warnings };
+}
+export async function main(argv) {
+    let args;
+    try {
+        args = parseCoverageHtmlArgs(argv);
+    }
+    catch (err) {
+        process.stderr.write(`coverage-check html: ${String(err)}\n`);
+        return 2;
+    }
+    const { warnings } = await buildCoverageHtml(args);
+    for (const w of warnings)
+        process.stderr.write(`${w}\n`);
+    return 0;
+}

package/dist/src/commands/store-put.d.mts

@@ -1,6 +1,7 @@
 import type { SuiteStore } from "../suite-store.mts";
 export type StorePutArgs = {
     suite: string;
+    suitePrefix: string;
     store: SuiteStore;
     artifacts: string;
     stripPrefixes: string[];

package/dist/src/commands/store-put.mjs

@@ -1,4 +1,5 @@
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { parseLcov } from "../lcov-parser.mjs";
 import { mergeLcov, toLcov } from "../lcov-merge.mjs";
 import { collectLcovFiles, buildStripPrefixes } from "../load-artifacts.mjs";
@@ -11,6 +12,7 @@ function parseArgs(argv) {
     let storeS3 = null;
     const args = {
         suite: "",
+        suitePrefix: "coverage-",
         artifacts: "./coverage-artifacts",
         stripPrefixes: [],
         sha: undefined,
@@ -30,6 +32,9 @@ function parseArgs(argv) {
             case "--suite":
                 args.suite = val();
                 break;
+            case "--suite-prefix":
+                args.suitePrefix = val();
+                break;
             case "--store":
             case "--store-fs":
                 storeFs = val();
@@ -53,8 +58,6 @@ function parseArgs(argv) {
                 throw new Error(`unknown flag: ${flag}`);
         }
     }
-    if (!args.suite)
-        throw new Error("--suite is required");
     if (storeFs && storeS3)
         throw new Error("--store-fs and --store-s3 are mutually exclusive");
     if (!storeFs && !storeS3)
@@ -64,7 +67,9 @@ function parseArgs(argv) {
     if (hasSha !== hasBranch) {
         throw new Error("--sha and --branch must be provided together");
     }
-    assertSafePathComponent(args.suite, "suite");
+    if (args.suite) {
+        assertSafePathComponent(args.suite, "suite");
+    }
     if (args.sha !== undefined)
         assertSafePathComponent(args.sha, "sha");
     if (args.branch !== undefined && args.branch.length === 0) {
@@ -82,13 +87,42 @@ export async function main(argv) {
         stderr(`coverage-check store-put: ${String(err)}`);
         return 2;
     }
-    return runStorePut(args);
+    if (args.suite) {
+        return runStorePut(args);
+    }
+    return runStorePutMultiSuite(args);
+}
+async function runStorePutMultiSuite(args) {
+    let subdirs;
+    try {
+        subdirs = readdirSync(args.artifacts, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && e.name.startsWith(args.suitePrefix))
+            .map((e) => e.name);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            stdout(`coverage-check store-put: artifacts directory not found at ${args.artifacts}; nothing to store`);
+            return 0;
+        }
+        throw err;
+    }
+    if (subdirs.length === 0) {
+        stdout(`coverage-check store-put: no subdirectories matching prefix "${args.suitePrefix}" under ${args.artifacts}; nothing to store`);
+        return 0;
+    }
+    for (const subdirName of subdirs) {
+        const suite = subdirName.slice(args.suitePrefix.length);
+        const suiteDir = join(args.artifacts, subdirName);
+        const suiteArgs = { ...args, suite, artifacts: suiteDir };
+        await runStorePut(suiteArgs);
+    }
+    return 0;
 }
 export async function runStorePut(args) {
     const lcovFiles = collectLcovFiles(args.artifacts);
     if (lcovFiles.length === 0) {
-        stderr(`coverage-check store-put: no lcov.info files found under ${args.artifacts}`);
-        return 2;
+        stdout(`coverage-check store-put: no lcov.info files under ${args.artifacts}; skipping suite "${args.suite}"`);
+        return 0;
     }
     const stripPrefixes = buildStripPrefixes(args.stripPrefixes);
     const reports = lcovFiles.map((f) => parseLcov(readFileSync(f, "utf8"), stripPrefixes));

package/dist/src/commands/summary/args.d.mts

@@ -0,0 +1,2 @@
+import type { CoverageSummaryArgs } from "./types.mts";
+export declare function parseCoverageSummaryArgs(argv: string[]): CoverageSummaryArgs;

package/dist/src/commands/summary/args.mjs

@@ -0,0 +1,60 @@
+function requireValue(flag, value) {
+    if (value === undefined || value.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+    return value;
+}
+export function parseCoverageSummaryArgs(argv) {
+    const args = {
+        activeSuites: [],
+        artifacts: "./coverage-artifacts",
+        branch: "main",
+        storeFs: null,
+        storeS3: null,
+        summaryFile: process.env["GITHUB_STEP_SUMMARY"] ?? null,
+        stripPrefixes: [],
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const flag = argv[i];
+        const value = () => {
+            const parsed = requireValue(flag, argv[i + 1]);
+            i++;
+            return parsed;
+        };
+        switch (flag) {
+            case "--active-suite":
+                args.activeSuites.push(value());
+                break;
+            case "--artifacts":
+                args.artifacts = value();
+                break;
+            case "--branch":
+                args.branch = value();
+                break;
+            case "--rules":
+                args.rulesFile = value();
+                break;
+            case "--store-fs":
+                args.storeFs = value();
+                break;
+            case "--store-s3":
+                args.storeS3 = value();
+                break;
+            case "--strip-prefix":
+                args.stripPrefixes.push(value());
+                break;
+            case "--summary-file":
+                args.summaryFile = value();
+                break;
+            case "--no-summary-file":
+                args.summaryFile = null;
+                break;
+            default:
+                throw new Error(`unknown flag: ${flag}`);
+        }
+    }
+    if (args.storeFs && args.storeS3)
+        throw new Error("--store-fs and --store-s3 are mutually exclusive");
+    if (args.branch.length === 0)
+        throw new Error("--branch must not be empty");
+    return args;
+}

package/dist/src/commands/summary/groups.d.mts

@@ -0,0 +1,2 @@
+import type { SourceCoverageGroup, SuiteCoverage } from "./types.mts";
+export declare function groupSuitesBySourceFolder(suites: SuiteCoverage[], branch: string, rulesFile?: string): SourceCoverageGroup[];

package/dist/src/commands/summary/groups.mjs

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { load as loadYaml } from "js-yaml";
+import { mergeLcov } from "../../lcov-merge.mjs";
+const otherGroup = { folder: "other", prefix: "" };
+function isCoverageRulesFile(value) {
+    return typeof value === "object" && value !== null;
+}
+function staticFolderFromGlob(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    const firstGlobIndex = normalized.search(/[*?[\]{}]/);
+    const staticPrefix = firstGlobIndex === -1 ? normalized : normalized.slice(0, firstGlobIndex);
+    const folder = staticPrefix.replace(/\/+$/, "");
+    return folder === "" ? null : folder;
+}
+function loadCoverageGroupDefinitions(rulesFile) {
+    const resolvedFile = rulesFile ?? path.join(process.cwd(), ".coverage-rules.yml");
+    if (!existsSync(resolvedFile))
+        return [];
+    const parsed = loadYaml(readFileSync(resolvedFile, "utf8"));
+    const rules = isCoverageRulesFile(parsed) && Array.isArray(parsed.rules) ? parsed.rules : [];
+    return rules.flatMap((rule) => {
+        const paths = Array.isArray(rule.paths)
+            ? rule.paths
+            : rule.paths === undefined
+                ? []
+                : [rule.paths];
+        return paths.flatMap((pattern) => {
+            const folder = staticFolderFromGlob(pattern);
+            return folder === null ? [] : [{ folder, prefix: `${folder}/` }];
+        });
+    });
+}
+function groupForFile(filePath, definitions) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    return (definitions.find((definition) => normalizedPath === definition.folder || normalizedPath.startsWith(definition.prefix)) ?? otherGroup);
+}
+export function groupSuitesBySourceFolder(suites, branch, rulesFile) {
+    const definitions = loadCoverageGroupDefinitions(rulesFile);
+    const groups = new Map();
+    for (const suite of suites) {
+        const suiteReportsByGroup = new Map();
+        for (const [filePath, lines] of suite.lcov.entries()) {
+            const definition = groupForFile(filePath, definitions);
+            const group = groups.get(definition.folder) ?? {
+                branches: new Set(),
+                current: false,
+                history: false,
+                reports: [],
+            };
+            if (suite.source === "current")
+                group.current = true;
+            else {
+                group.history = true;
+                group.branches.add(suite.branch ?? branch);
+            }
+            const suiteReport = suiteReportsByGroup.get(definition.folder) ?? new Map();
+            suiteReport.set(filePath, new Map(lines));
+            suiteReportsByGroup.set(definition.folder, suiteReport);
+            groups.set(definition.folder, group);
+        }
+        for (const [folder, report] of suiteReportsByGroup.entries()) {
+            groups.get(folder)?.reports.push(report);
+        }
+    }
+    const coverageGroups = [];
+    for (const definition of [...definitions, otherGroup]) {
+        const group = groups.get(definition.folder);
+        if (!group)
+            continue;
+        const coverageGroup = {
+            folder: definition.folder,
+            source: group.current && group.history ? "mixed" : group.current ? "current" : "history",
+            lcov: mergeLcov(group.reports),
+        };
+        if (group.branches.size > 0) {
+            coverageGroup.branchesLabel = [...group.branches]
+                .sort((a, b) => a.localeCompare(b))
+                .join(", ");
+        }
+        coverageGroups.push(coverageGroup);
+    }
+    return coverageGroups;
+}

package/dist/src/commands/summary/index.d.mts

@@ -0,0 +1,8 @@
+import { parseCoverageSummaryArgs } from "./args.mts";
+import { groupSuitesBySourceFolder } from "./groups.mts";
+import { renderCoverageSummaryMarkdown, suiteTotals } from "./markdown.mts";
+import type { CoverageSummary, CoverageSummaryArgs, SuiteCoverage } from "./types.mts";
+export type { CoverageSummary, CoverageSummaryArgs, SuiteCoverage };
+export { groupSuitesBySourceFolder, parseCoverageSummaryArgs, renderCoverageSummaryMarkdown, suiteTotals, };
+export declare function buildCoverageSummary(args: CoverageSummaryArgs): Promise<CoverageSummary>;
+export declare function main(argv: string[]): Promise<number>;

package/dist/src/commands/summary/index.mjs

@@ -0,0 +1,118 @@
+import { appendFileSync, existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { parseLcov } from "../../lcov-parser.mjs";
+import { mergeLcov } from "../../lcov-merge.mjs";
+import { collectLcovFiles, buildStripPrefixes } from "../../load-artifacts.mjs";
+import { makeStore } from "../../store-factory.mjs";
+import { parseCoverageSummaryArgs } from "./args.mjs";
+import { groupSuitesBySourceFolder } from "./groups.mjs";
+import { renderCoverageSummaryMarkdown, suiteTotals } from "./markdown.mjs";
+export { groupSuitesBySourceFolder, parseCoverageSummaryArgs, renderCoverageSummaryMarkdown, suiteTotals, };
+function suiteNameFromArtifactDir(name) {
+    if (!name.startsWith("coverage-"))
+        return null;
+    const suite = name.slice("coverage-".length);
+    return suite.length > 0 ? suite : null;
+}
+function loadSuiteCoverage(suite, files, stripPrefixes) {
+    const reports = files.map((file) => parseLcov(readFileSync(file, "utf8"), stripPrefixes));
+    return { suite, source: "current", lcov: mergeLcov(reports) };
+}
+function loadCurrentSuites(artifacts, stripPrefixes) {
+    if (!existsSync(artifacts))
+        return [];
+    return readdirSync(artifacts, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => {
+        const suite = suiteNameFromArtifactDir(entry.name);
+        if (!suite)
+            return null;
+        const files = collectLcovFiles(path.join(artifacts, entry.name));
+        return files.length === 0 ? null : loadSuiteCoverage(suite, files, stripPrefixes);
+    })
+        .filter((suite) => suite !== null)
+        .sort((a, b) => a.suite.localeCompare(b.suite));
+}
+async function loadHistoricalSuites(store, branch, activeSuiteNames, currentSuiteNames, stripPrefixes) {
+    if (store === null) {
+        return {
+            suites: [],
+            warnings: [
+                "Historical main coverage store was not configured; showing current-run coverage only.",
+            ],
+        };
+    }
+    if (activeSuiteNames.size === 0) {
+        return {
+            suites: [],
+            warnings: [
+                "Historical main coverage store was configured without an active suite manifest; showing current-run coverage only.",
+            ],
+        };
+    }
+    try {
+        const historicalSuites = [...activeSuiteNames].filter((suite) => !currentSuiteNames.has(suite));
+        const historical = await Promise.all(historicalSuites.map(async (suite) => {
+            const lcovBuffer = await store.get(suite, { branch });
+            if (lcovBuffer === null)
+                return { missingSuite: suite };
+            return {
+                suite,
+                source: "history",
+                branch,
+                lcov: parseLcov(lcovBuffer.toString("utf8"), stripPrefixes),
+            };
+        }));
+        const suites = historical.filter((suite) => "lcov" in suite && "suite" in suite);
+        const missingSuites = historical
+            .filter((suite) => "missingSuite" in suite)
+            .map((suite) => suite.missingSuite);
+        return {
+            suites,
+            warnings: missingSuites.length === 0
+                ? []
+                : [
+                    `Historical main coverage missing for active suites: ${missingSuites.sort((a, b) => a.localeCompare(b)).join(", ")}.`,
+                ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { suites: [], warnings: [`Historical main coverage could not be read: ${message}`] };
+    }
+}
+function mergedTotals(suites) {
+    const lcov = mergeLcov(suites.map((suite) => suite.lcov));
+    return suiteTotals({ lcov });
+}
+export async function buildCoverageSummary(args) {
+    const stripPrefixes = buildStripPrefixes(args.stripPrefixes);
+    const currentSuites = loadCurrentSuites(args.artifacts, stripPrefixes);
+    const currentTotals = mergedTotals(currentSuites);
+    const historical = await loadHistoricalSuites(makeStore({ fs: args.storeFs, s3: args.storeS3 }), args.branch, new Set(args.activeSuites), new Set(currentSuites.map((suite) => suite.suite)), stripPrefixes);
+    const suites = [...currentSuites, ...historical.suites].sort((a, b) => a.suite.localeCompare(b.suite));
+    return {
+        currentTotals,
+        groups: groupSuitesBySourceFolder(suites, args.branch, args.rulesFile),
+        suites,
+        totals: mergedTotals(suites),
+        warnings: historical.warnings,
+    };
+}
+export async function main(argv) {
+    let args;
+    try {
+        args = parseCoverageSummaryArgs(argv);
+    }
+    catch (err) {
+        process.stderr.write(`coverage-check summary: ${String(err)}\n`);
+        return 2;
+    }
+    const summary = await buildCoverageSummary(args);
+    const markdown = renderCoverageSummaryMarkdown(summary, args.branch, args.storeS3);
+    if (args.summaryFile)
+        appendFileSync(args.summaryFile, markdown, "utf8");
+    else
+        process.stdout.write(markdown);
+    return 0;
+}

package/dist/src/commands/summary/markdown.d.mts

@@ -0,0 +1,5 @@
+import type { CoverageSummary, CoverageTotals } from "./types.mts";
+export declare function suiteTotals(suite: {
+    lcov: Map<string, Map<number, number>>;
+}): CoverageTotals;
+export declare function renderCoverageSummaryMarkdown(summary: CoverageSummary, branch: string, storeS3?: string | null): string;

package/dist/src/commands/summary/markdown.mjs

@@ -0,0 +1,71 @@
+export function suiteTotals(suite) {
+    let hit = 0;
+    let total = 0;
+    for (const lines of suite.lcov.values()) {
+        for (const count of lines.values()) {
+            total++;
+            if (count > 0)
+                hit++;
+        }
+    }
+    return { hit, total };
+}
+function pct(hit, total) {
+    if (total === 0)
+        return "--";
+    return `${((hit / total) * 100).toFixed(1)}% (${hit}/${total})`;
+}
+function escMd(value) {
+    return value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+}
+function codeSpan(value) {
+    const escaped = escMd(value);
+    const longestRun = Math.max(0, ...Array.from(escaped.matchAll(/`+/g), (match) => match[0].length));
+    if (longestRun === 0)
+        return `\`${escaped}\``;
+    const ticks = "`".repeat(longestRun + 1);
+    return `${ticks} ${escaped} ${ticks}`;
+}
+function groupRow(group, branch) {
+    const source = group.source === "current"
+        ? "current run"
+        : group.source === "history"
+            ? `history (${escMd(group.branchesLabel ?? branch)})`
+            : `current run + history (${escMd(group.branchesLabel ?? branch)})`;
+    const totals = suiteTotals(group);
+    return `| ${codeSpan(group.folder)} | ${source} | ${pct(totals.hit, totals.total)} |`;
+}
+function s3ConsoleUrl(spec) {
+    const slash = spec.indexOf("/");
+    const bucket = (slash === -1 ? spec : spec.slice(0, slash)).replace(/^\/+|\/+$/g, "");
+    if (slash === -1)
+        return `https://s3.console.aws.amazon.com/s3/buckets/${bucket}`;
+    const prefix = spec
+        .slice(slash + 1)
+        .replace(/^\/+|\/+$/g, "")
+        .split("/")
+        .map(encodeURIComponent)
+        .join("/");
+    return `https://s3.console.aws.amazon.com/s3/buckets/${bucket}?prefix=${prefix}/`;
+}
+export function renderCoverageSummaryMarkdown(summary, branch, storeS3 = null) {
+    const rows = summary.groups.length === 0
+        ? "| -- | -- | -- |"
+        : summary.groups.map((group) => groupRow(group, branch)).join("\n");
+    const warnings = summary.warnings.length === 0
+        ? ""
+        : `\n\n${summary.warnings.map((warning) => `> ${escMd(warning)}`).join("\n")}`;
+    const storeLink = storeS3 === null
+        ? ""
+        : `\nCoverage store: [${codeSpan(`s3://${storeS3}`)}](${s3ConsoleUrl(storeS3)})\n`;
+    return `## Project coverage summary
+
+Current run line coverage: **${pct(summary.currentTotals.hit, summary.currentTotals.total)}**
+
+Total project line coverage: **${pct(summary.totals.hit, summary.totals.total)}**
+${storeLink}
+| Source folder | Source | Line coverage |
+|---|---|---|
+${rows}${warnings}
+`;
+}

package/dist/src/commands/summary/types.d.mts

@@ -0,0 +1,36 @@
+import type { LcovData } from "../../types.mts";
+export type { LcovData };
+export type Source = "current" | "history";
+export type SuiteCoverage = {
+    suite: string;
+    source: Source;
+    branch?: string;
+    lcov: LcovData;
+};
+export type SourceCoverageGroup = {
+    folder: string;
+    source: Source | "mixed";
+    branchesLabel?: string;
+    lcov: LcovData;
+};
+export type CoverageTotals = {
+    hit: number;
+    total: number;
+};
+export type CoverageSummary = {
+    currentTotals: CoverageTotals;
+    groups: SourceCoverageGroup[];
+    suites: SuiteCoverage[];
+    totals: CoverageTotals;
+    warnings: string[];
+};
+export type CoverageSummaryArgs = {
+    activeSuites: string[];
+    artifacts: string;
+    branch: string;
+    rulesFile?: string;
+    storeFs: string | null;
+    storeS3: string | null;
+    summaryFile: string | null;
+    stripPrefixes: string[];
+};

package/dist/src/commands/summary/types.mjs

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

package/dist/src/commands/summary.d.mts

@@ -0,0 +1,2 @@
+export { buildCoverageSummary, groupSuitesBySourceFolder, main, parseCoverageSummaryArgs, renderCoverageSummaryMarkdown, suiteTotals, } from "./summary/index.mts";
+export type { CoverageSummary, CoverageSummaryArgs, SuiteCoverage } from "./summary/index.mts";

package/dist/src/commands/summary.mjs

@@ -0,0 +1 @@
+export { buildCoverageSummary, groupSuitesBySourceFolder, main, parseCoverageSummaryArgs, renderCoverageSummaryMarkdown, suiteTotals, } from "./summary/index.mjs";

package/dist/src/lcov-parser.mjs

@@ -11,13 +11,21 @@ export function parseLcov(text, stripPrefixes = []) {
         const line = raw.trimEnd();
         if (line.startsWith("SF:")) {
             let path = line.slice(3);
+            let stripped = false;
             for (const prefix of stripPrefixes) {
                 if (path.startsWith(prefix)) {
                     path = path.slice(prefix.length);
+                    stripped = true;
                     break;
                 }
             }
             path = normalizePath(path);
+            if (!stripped && (path.startsWith("/") || /^[A-Z]:\//i.test(path))) {
+                const match = path.match(/^.*?\/_?work\/([^/]+)\/\1\//);
+                if (match) {
+                    path = path.slice(match[0].length);
+                }
+            }
             currentLines = result.get(path) ?? new Map();
             result.set(path, currentLines);
         }

package/dist/src/lcov-to-istanbul.d.mts

@@ -0,0 +1,30 @@
+type Loc = {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+};
+export type IstanbulFileCoverage = {
+    path: string;
+    statementMap: Record<string, Loc>;
+    s: Record<string, number>;
+    fnMap: Record<string, {
+        name: string;
+        decl: Loc;
+        loc: Loc;
+    }>;
+    f: Record<string, number>;
+    branchMap: Record<string, {
+        loc: Loc;
+        type: string;
+        locations: Loc[];
+    }>;
+    b: Record<string, number[]>;
+};
+export type IstanbulCoverage = Record<string, IstanbulFileCoverage>;
+export declare function lcovBufferToIstanbul(lcov: Buffer, stripPrefixes: string[]): IstanbulCoverage;
+export {};

package/dist/src/lcov-to-istanbul.mjs

@@ -0,0 +1,140 @@
+function loc(line) {
+    return { start: { line, column: 0 }, end: { line, column: 999 } };
+}
+function normalizeFilePath(filePath, stripPrefixes) {
+    const normalized = filePath.replace(/\\/g, "/");
+    for (const prefix of stripPrefixes) {
+        const p = prefix.replace(/\\/g, "/").replace(/\/$/, "");
+        if (normalized === p)
+            return "";
+        if (normalized.startsWith(`${p}/`))
+            return normalized.slice(p.length + 1);
+    }
+    return normalized;
+}
+export function lcovBufferToIstanbul(lcov, stripPrefixes) {
+    const coverage = {};
+    let filePath = null;
+    const pendingFnLines = new Map();
+    // Accumulate branches at file scope so counts from all records for the same
+    // file are merged before converting to Istanbul arrays.
+    // filePath → blockKey → branchId → count
+    const fileBranches = new Map();
+    function flush() {
+        pendingFnLines.clear();
+    }
+    for (const line of lcov.toString("utf8").split(/\r?\n/)) {
+        if (line === "end_of_record") {
+            flush();
+            filePath = null;
+            continue;
+        }
+        if (line.startsWith("SF:")) {
+            flush();
+            filePath = normalizeFilePath(line.slice(3).trim(), stripPrefixes);
+            if (filePath && !coverage[filePath]) {
+                coverage[filePath] = {
+                    path: filePath,
+                    statementMap: {},
+                    s: {},
+                    fnMap: {},
+                    f: {},
+                    branchMap: {},
+                    b: {},
+                };
+            }
+            continue;
+        }
+        if (!filePath)
+            continue;
+        const fileCov = coverage[filePath]; // filePath was validated against coverage when SF: was processed
+        if (line.startsWith("DA:")) {
+            const [lineNo, hits] = line.slice(3).split(",", 2);
+            const l = Number.parseInt(lineNo, 10);
+            const h = Number.parseInt(hits ?? "", 10);
+            if (!Number.isInteger(l) || !Number.isInteger(h))
+                continue;
+            const key = String(l);
+            if (fileCov.statementMap[key] === undefined) {
+                fileCov.statementMap[key] = loc(l);
+                fileCov.s[key] = h;
+            }
+            else {
+                fileCov.s[key] = fileCov.s[key] + h;
+            }
+        }
+        else if (line.startsWith("FN:") || line.startsWith("FNL:")) {
+            const rest = line.slice(line.startsWith("FNL:") ? 4 : 3);
+            const firstComma = rest.indexOf(",");
+            if (firstComma === -1)
+                continue;
+            const l = Number.parseInt(rest.slice(0, firstComma), 10);
+            const afterFirst = rest.slice(firstComma + 1);
+            // Handle both FN:start,name and FN:start,end,name (LCOV 2.x three-field form)
+            const secondComma = afterFirst.indexOf(",");
+            const name = secondComma === -1 ? afterFirst : afterFirst.slice(secondComma + 1);
+            if (Number.isInteger(l) && name)
+                pendingFnLines.set(name, l);
+        }
+        else if (line.startsWith("FNDA:") || line.startsWith("FNA:")) {
+            const rest = line.slice(line.startsWith("FNA:") ? 4 : 5);
+            const commaIdx = rest.indexOf(",");
+            if (commaIdx === -1)
+                continue;
+            const h = Number.parseInt(rest.slice(0, commaIdx), 10);
+            const name = rest.slice(commaIdx + 1);
+            if (!Number.isInteger(h) || !name)
+                continue;
+            const startLine = pendingFnLines.get(name) ?? 0;
+            const key = startLine > 0 ? `${name}@${startLine}` : name;
+            const fnLoc = loc(startLine);
+            if (fileCov.fnMap[key] === undefined) {
+                fileCov.fnMap[key] = { name, decl: fnLoc, loc: fnLoc };
+                fileCov.f[key] = h;
+            }
+            else {
+                fileCov.f[key] = fileCov.f[key] + h;
+            }
+        }
+        else if (line.startsWith("BRDA:")) {
+            const parts = line.slice(5).split(",", 4);
+            const lineNo = Number.parseInt(parts[0], 10);
+            const blockId = parts[1] ?? "";
+            const branchId = parts[2] ?? "";
+            const taken = parts[3] === "-" ? 0 : Number.parseInt(parts[3] ?? "", 10);
+            if (!Number.isInteger(lineNo) || !blockId || !branchId || !Number.isInteger(taken))
+                continue;
+            const blockKey = `${lineNo}-${blockId}`;
+            let fileBlocks = fileBranches.get(filePath);
+            if (!fileBlocks) {
+                fileBlocks = new Map();
+                fileBranches.set(filePath, fileBlocks);
+            }
+            let blockBranches = fileBlocks.get(blockKey);
+            if (!blockBranches) {
+                blockBranches = new Map();
+                fileBlocks.set(blockKey, blockBranches);
+            }
+            blockBranches.set(branchId, (blockBranches.get(branchId) ?? 0) + taken);
+        }
+    }
+    flush();
+    // Convert per-file branch accumulator to Istanbul branchMap/b arrays.
+    // All records for a file are fully merged before sorting, so branchId
+    // sets that differ across records are handled correctly.
+    for (const [fp, blocks] of fileBranches) {
+        const fileCov = coverage[fp]; // fp was validated against coverage when added to fileBranches
+        for (const [blockKey, branches] of blocks) {
+            const lineNo = Number.parseInt(blockKey.split("-")[0], 10); // blockKey is always "N-blockId"
+            const branchLoc = loc(lineNo);
+            const sorted = [...branches.entries()].sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }));
+            fileCov.branchMap[blockKey] = {
+                loc: branchLoc,
+                type: "branch",
+                locations: sorted.map(() => branchLoc),
+            };
+            fileCov.b[blockKey] = sorted.map(([, count]) => count);
+        }
+    }
+    return coverage;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coverage-check",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Patch-coverage gate: checks that newly added lines meet per-path coverage thresholds. Supports per-suite LCOV accumulation for conditional CI.",
   "license": "MIT",
   "author": "Jonathan Ong",
@@ -32,7 +32,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1048.0",
-    "js-yaml": "^4.1.1"
+    "js-yaml": "^4.1.1",
+    "monocart-coverage-reports": "^2.12.11"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",