coverage-check 0.2.3 → 0.5.0

package/README.md

@@ -96,6 +96,30 @@ coverage-check check \
 
 When `$GITHUB_STEP_SUMMARY` is set, a per-suite totals and per-rule patch-coverage table is appended to the job summary automatically.
 
+### Diagnosing uncovered lines
+
+Pass `--annotate-source` to print the trimmed source text of each uncovered line alongside its line number:
+
+```
+coverage-check: FAILED
+
+  backend/**: 80.0% (4/5) — threshold 90%
+    backend/foo.mts:
+      L42  function f(a = 1) {
+      L55  const { x } = opts
+```
+
+This makes it immediately clear which construct needs execution to satisfy V8/Istanbul line coverage.
+Two common sources of confusion:
+
+- **Default parameters** — `function f(a = 1)` is only fully covered when the function is called
+  _without_ that argument so the default expression executes.
+- **Shorthand object properties** — `const { x } = opts` is covered when `opts.x` is actually
+  accessed during the test.
+
+The annotation affects only the stdout failure output. The GitHub PR sticky comment and Actions step
+summary are unchanged.
+
 ## Rules file
 
 ```yaml
@@ -115,21 +139,22 @@ Rules are matched in order; the first match wins. Files in the diff not matched
 
 ### `coverage-check check`
 
-| Flag             | Default                | Description                                                                                  |
-| ---------------- | ---------------------- | -------------------------------------------------------------------------------------------- |
-| `--rules`        | `.coverage-rules.yml`  | Path to YAML rules file                                                                      |
-| `--artifacts`    | `./coverage-artifacts` | Directory to scan for `lcov.info` files                                                      |
-| `--base`         | `origin/main`          | Base git ref for `git diff`                                                                  |
-| `--head`         | `HEAD`                 | Head git ref for `git diff`                                                                  |
-| `--store-fs`     | —                      | Path to a filesystem suite store directory                                                   |
-| `--store`        | —                      | Alias for `--store-fs`                                                                       |
-| `--store-s3`     | —                      | S3 suite store spec: `<bucket>[/<prefix>]`                                                   |
-| `--branch`       | `"main"`               | Branch pointer to follow when reading from the store                                         |
-| `--suite`        | —                      | Name of the current suite (no `/` or `\\`); fresh artifacts override this suite in the store |
-| `--strip-prefix` | —                      | Extra path prefix to strip from LCOV `SF:` lines (repeatable)                                |
-| `--pr`           | —                      | Pull request number for sticky comment                                                       |
-| `--repo`         | `$GITHUB_REPOSITORY`   | `owner/repo` for sticky comment                                                              |
-| `--json`         | —                      | Write JSON result to this path                                                               |
+| Flag                | Default                | Description                                                                                                |
+| ------------------- | ---------------------- | ---------------------------------------------------------------------------------------------------------- |
+| `--rules`           | `.coverage-rules.yml`  | Path to YAML rules file                                                                                    |
+| `--artifacts`       | `./coverage-artifacts` | Directory to scan for `lcov.info` files                                                                    |
+| `--base`            | `origin/main`          | Base git ref for `git diff`                                                                                |
+| `--head`            | `HEAD`                 | Head git ref for `git diff`                                                                                |
+| `--store-fs`        | —                      | Path to a filesystem suite store directory                                                                 |
+| `--store`           | —                      | Alias for `--store-fs`                                                                                     |
+| `--store-s3`        | —                      | S3 suite store spec: `<bucket>[/<prefix>]`                                                                 |
+| `--branch`          | `"main"`               | Branch pointer to follow when reading from the store                                                       |
+| `--suite`           | —                      | Name of the current suite (no `/` or `\\`); fresh artifacts override this suite in the store               |
+| `--strip-prefix`    | —                      | Extra path prefix to strip from LCOV `SF:` lines (repeatable)                                              |
+| `--pr`              | —                      | Pull request number for sticky comment                                                                     |
+| `--repo`            | `$GITHUB_REPOSITORY`   | `owner/repo` for sticky comment                                                                            |
+| `--json`            | —                      | Write JSON result to this path                                                                             |
+| `--annotate-source` | —                      | Print the trimmed source text of each uncovered line in stdout (does not alter PR comment or step summary) |
 
 ### `coverage-check store-put`
 

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-args.d.mts

@@ -16,5 +16,7 @@ export type CheckArgs = {
     gh?: GhRunner;
     /** Path to append the GitHub step summary. Default: $GITHUB_STEP_SUMMARY. */
     summaryFile?: string | null;
+    /** Annotate each uncovered line with its trimmed source text in stdout. Default: false. */
+    annotateSource?: boolean;
 };
 export declare function parseCheckArgs(argv: string[]): CheckArgs;

package/dist/src/commands/check-args.mjs

@@ -16,6 +16,7 @@ export function parseCheckArgs(argv) {
         suite: null,
         branch: "main",
         summaryFile: process.env["GITHUB_STEP_SUMMARY"] ?? null,
+        annotateSource: false,
     };
     for (let i = 0; i < argv.length; i++) {
         const flag = argv[i];
@@ -76,6 +77,9 @@ export function parseCheckArgs(argv) {
                 args.pr = parseInt(raw, 10);
                 break;
             }
+            case "--annotate-source":
+                args.annotateSource = true;
+                break;
             default:
                 throw new Error(`unknown flag: ${flag}`);
         }

package/dist/src/commands/check.mjs

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { parseLcov } from "../lcov-parser.mjs";
 import { mergeLcov } from "../lcov-merge.mjs";
 import { getChangedLines } from "../diff-parser.mjs";
+import { getChangedLineContent } from "../diff-parser-content.mjs";
 import { loadRules } from "../rules.mjs";
 import { computePatchCoverage } from "../patch-coverage.mjs";
 import { collapseRanges, renderFailureComment } from "../report.mjs";
@@ -71,8 +72,15 @@ export async function runCheck(args) {
     }
     const lcov = mergeLcov(reports);
     let diff;
+    let diffContent = null;
     try {
-        diff = await getChangedLines(args.base, args.head);
+        if (args.annotateSource) {
+            diffContent = await getChangedLineContent(args.base, args.head);
+            diff = new Map([...diffContent].map(([f, m]) => [f, new Set(m.keys())]));
+        }
+        else {
+            diff = await getChangedLines(args.base, args.head);
+        }
     }
     catch (err) {
         stderr(`coverage-check: git diff failed: ${err}`);
@@ -115,7 +123,17 @@ export async function runCheck(args) {
             const pct = bucket.coverable > 0 ? `${((bucket.hit / bucket.coverable) * 100).toFixed(1)}%` : "—";
             stdout(`  ${bucket.rule}: ${pct} (${bucket.hit}/${bucket.coverable}) — threshold ${bucket.threshold}%`);
             for (const file of bucket.files.filter((f) => f.uncoveredLines.length > 0)) {
-                stdout(`    ${file.file}: ${collapseRanges(file.uncoveredLines)}`);
+                if (diffContent !== null) {
+                    stdout(`    ${file.file}:`);
+                    for (const lineNo of file.uncoveredLines) {
+                        /* c8 ignore next -- diffContent is single-sourced from the same diff, lineNo is always present */
+                        const text = diffContent.get(file.file)?.get(lineNo) ?? "";
+                        stdout(`      L${lineNo}  ${text}`);
+                    }
+                }
+                else {
+                    stdout(`    ${file.file}: ${collapseRanges(file.uncoveredLines)}`);
+                }
             }
         }
     }

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>;