coverage-check 0.1.1 → 0.2.2

package/README.md

@@ -22,46 +22,68 @@ coverage-check check \
 
 Exits `0` on pass, `1` on failure, `2` on configuration error.
 
-### Suite store (conditional CI)
+### Suite store with S3 (conditional CI)
 
-When only some CI suites run per PR (e.g. backend tests only when backend files change), store each suite's LCOV on every run and merge them when checking:
+When only some CI suites run per PR (e.g. backend tests only when backend files change), store each suite's LCOV in S3 and merge them during coverage checks:
 
 ```sh
-# After backend tests run — store this suite's coverage
+# After backend tests run on the main branch — store this suite's coverage
 coverage-check store-put \
   --suite backend \
-  --store ./coverage-store \
+  --store-s3 my-bucket/coverage-store \
   --artifacts ./coverage-artifacts \
   --sha "$GITHUB_SHA" \
-  --ref "$GITHUB_REF"
+  --branch main
 
-# Sync the store directory to persistent storage (e.g. S3, git orphan branch)
-aws s3 sync ./coverage-store s3://my-bucket/coverage-store/
+# On a PR that only runs frontend tests:
+coverage-check check \
+  --rules .coverage-rules.yml \
+  --artifacts ./coverage-artifacts \
+  --store-s3 my-bucket/coverage-store \
+  --suite frontend \
+  --branch main \
+  --base origin/main \
+  --head HEAD
+```
+
+The `--suite` flag on `check` tells the tool to use fresh `--artifacts` for the current suite and pull historical coverage from the store for all other suites. The `--branch` flag selects which branch pointer to follow when reading from the store.
+
+**S3 key layout:**
+
+```text
+<prefix>/<suite>/sha/<sha>/lcov.info          # payload
+<prefix>/<suite>/branch/<encoded-branch>/latest.json  # pointer: { "sha": "...", "timestamp": "..." }
+```
+
+S3-backed stores need `s3:PutObject` for writes and `s3:GetObject` for reading branch pointers and baselines. The pointer reader also checks the previous unencoded pointer key (for example `branch/main/latest.json`) so stores written before branch-name encoding remain readable.
 
-# --- On the next PR that runs only frontend tests ---
+### Suite store with filesystem
 
-# Pull the store
-aws s3 sync s3://my-bucket/coverage-store/ ./coverage-store
+For local development or simpler deployments:
 
-# Store-put the current suite
-coverage-check store-put --suite frontend --store ./coverage-store --artifacts ./coverage-artifacts
+```sh
+coverage-check store-put \
+  --suite backend \
+  --store-fs ./coverage-store \
+  --artifacts ./coverage-artifacts \
+  --sha "$GITHUB_SHA" \
+  --branch main
 
-# Check: merges all stored suites (backend from baseline + frontend from this run)
 coverage-check check \
   --rules .coverage-rules.yml \
   --artifacts ./coverage-artifacts \
-  --store ./coverage-store \
+  --store-fs ./coverage-store \
   --suite frontend \
   --base origin/main \
   --head HEAD
 ```
 
-The `--suite` flag on `check` tells the tool to replace the same-named suite in the store with the fresh `--artifacts` (so you always see this PR's coverage for the suite that ran, and historical coverage for suites that didn't).
-
 ### GitHub PR sticky comment
 
 Pass `--pr` and `--repo` to post (or update) a sticky comment on a pull request. Requires the `gh` CLI and `GH_TOKEN`/`GITHUB_TOKEN`.
 
+On **failure**, the comment is created or updated with the list of uncovered lines. On **pass**, any existing failure comment is **deleted** — no new comment is posted.
+
 ```sh
 coverage-check check \
   --rules .coverage-rules.yml \
@@ -70,6 +92,10 @@ coverage-check check \
   --repo "${{ github.repository }}"
 ```
 
+### GitHub Actions step summary
+
+When `$GITHUB_STEP_SUMMARY` is set, a per-suite totals and per-rule patch-coverage table is appended to the job summary automatically.
+
 ## Rules file
 
 ```yaml
@@ -89,49 +115,49 @@ 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`        | —                      | Path to a suite store directory                                              |
-| `--suite`        | —                      | Name of the current suite (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                                                               |
 
 ### `coverage-check store-put`
 
-| Flag             | Default                | Description                             |
-| ---------------- | ---------------------- | --------------------------------------- |
-| `--suite`        | required               | Suite name to store                     |
-| `--store`        | required               | Path to the suite store directory       |
-| `--artifacts`    | `./coverage-artifacts` | Directory to scan for `lcov.info` files |
-| `--strip-prefix` | —                      | Extra path prefix to strip (repeatable) |
-| `--sha`          | —                      | Git SHA to record in metadata           |
-| `--ref`          | —                      | Git ref to record in metadata           |
+| Flag             | Default                | Description                                                   |
+| ---------------- | ---------------------- | ------------------------------------------------------------- |
+| `--suite`        | required               | Suite name to store                                           |
+| `--store-fs`     | required\*             | Path to a filesystem suite store directory                    |
+| `--store`        | —                      | Alias for `--store-fs`                                        |
+| `--store-s3`     | required\*             | S3 suite store spec: `<bucket>[/<prefix>]`                    |
+| `--sha`          | —                      | Git SHA to associate with this coverage payload               |
+| `--branch`       | —                      | Branch name for the pointer (e.g. `main` or `feature/foo`)    |
+| `--artifacts`    | `./coverage-artifacts` | Directory to scan for `lcov.info` files                       |
+| `--strip-prefix` | —                      | Extra path prefix to strip from LCOV `SF:` lines (repeatable) |
+
+\* Exactly one of `--store-fs` or `--store-s3` is required.
+
+When `--sha` and `--branch` are both provided, `store-put` writes a SHA-addressed payload and advances the branch pointer only if the incoming timestamp is not older than the current pointer. Omitting both flags preserves the legacy `<suite>/lcov.info` storage layout.
 
 ## Programmatic API
 
 ```ts
-import { runCheck, runStorePut, FileSystemSuiteStore } from "coverage-check";
+import { runCheck, runStorePut, FileSystemSuiteStore, S3SuiteStore } from "coverage-check";
 
-// Custom store adapter (e.g. S3)
-import { SuiteStore } from "coverage-check";
+// FileSystem store
+const fsStore = new FileSystemSuiteStore("/path/to/store");
 
-class S3SuiteStore implements SuiteStore {
-  async list() {
-    /* ... */
-  }
-  async get(suite: string) {
-    /* ... */
-  }
-  async put(suite: string, lcov: Buffer, meta?: SuiteMeta) {
-    /* ... */
-  }
-}
+// S3 store (requires AWS credentials — see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html)
+const s3Store = new S3SuiteStore({ bucket: "my-bucket", prefix: "coverage" });
 
 await runCheck({
   rules: ".coverage-rules.yml",
@@ -142,9 +168,41 @@ await runCheck({
   repo: "",
   json: null,
   stripPrefixes: [],
-  store: new S3SuiteStore(),
+  store: s3Store,
   suite: "backend",
+  branch: "main",
 });
+
+await runStorePut({
+  suite: "backend",
+  store: s3Store,
+  artifacts: "./coverage",
+  stripPrefixes: [],
+  sha: "abc123",
+  branch: "main",
+});
+```
+
+You can also implement your own `SuiteStore`:
+
+```ts
+import type { SuiteStore } from "coverage-check";
+
+class MyCustomStore implements SuiteStore {
+  async list(): Promise<string[]> {
+    /* ... */
+  }
+  async get(suite: string, opts?: { sha?: string; branch?: string }): Promise<Buffer | null> {
+    /* ... */
+  }
+  async put(
+    suite: string,
+    lcov: Buffer,
+    meta?: { sha: string; branch: string; timestamp?: string },
+  ): Promise<void> {
+    /* ... */
+  }
+}
 ```
 
 ## License

package/bin/coverage-check.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from "../dist/src/cli.mjs";
+/* c8 ignore next */
+process.exit(await main(process.argv.slice(2)));

package/dist/src/cli.d.mts

@@ -0,0 +1 @@
+export declare function main(argv: string[]): Promise<number>;

package/dist/src/cli.mjs

@@ -0,0 +1,14 @@
+import { main as checkMain } from "./commands/check.mjs";
+import { main as storePutMain } from "./commands/store-put.mjs";
+const stderr = (msg) => process.stderr.write(`${msg}\n`);
+export async function main(argv) {
+    const sub = argv[0];
+    if (!sub || sub.startsWith("-"))
+        return checkMain(argv);
+    if (sub === "check")
+        return checkMain(argv.slice(1));
+    if (sub === "store-put")
+        return storePutMain(argv.slice(1));
+    stderr(`coverage-check: unknown subcommand: ${JSON.stringify(sub)}`);
+    return 2;
+}

package/dist/src/commands/check-args.d.mts

@@ -0,0 +1,20 @@
+import type { SuiteStore } from "../suite-store.mts";
+import type { GhRunner } from "../github-comment.mts";
+export type CheckArgs = {
+    rules: string;
+    artifacts: string;
+    base: string;
+    head: string;
+    pr: number | null;
+    repo: string;
+    json: string | null;
+    stripPrefixes: string[];
+    store: SuiteStore | null;
+    suite: string | null;
+    /** Branch used to resolve baseline from the store. Default: "main". */
+    branch?: string;
+    gh?: GhRunner;
+    /** Path to append the GitHub step summary. Default: $GITHUB_STEP_SUMMARY. */
+    summaryFile?: string | null;
+};
+export declare function parseCheckArgs(argv: string[]): CheckArgs;

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

@@ -0,0 +1,89 @@
+import { makeStore } from "../store-factory.mjs";
+import { assertSafePathComponent } from "../suite-store.mjs";
+export function parseCheckArgs(argv) {
+    let storeFs = null;
+    let storeS3 = null;
+    const args = {
+        rules: ".coverage-rules.yml",
+        artifacts: "./coverage-artifacts",
+        base: "origin/main",
+        head: "HEAD",
+        pr: null,
+        repo: process.env["GITHUB_REPOSITORY"] ?? "",
+        json: null,
+        stripPrefixes: [],
+        store: null,
+        suite: null,
+        branch: "main",
+        summaryFile: process.env["GITHUB_STEP_SUMMARY"] ?? null,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const flag = argv[i];
+        const next = argv[i + 1];
+        const val = () => {
+            if (next === undefined || next.startsWith("--")) {
+                throw new Error(`${flag} requires a value`);
+            }
+            i++;
+            return next;
+        };
+        switch (flag) {
+            case "--rules":
+                args.rules = val();
+                break;
+            case "--artifacts":
+                args.artifacts = val();
+                break;
+            case "--base":
+                args.base = val();
+                break;
+            case "--head":
+                args.head = val();
+                break;
+            case "--repo":
+                args.repo = val();
+                break;
+            case "--json":
+                args.json = val();
+                break;
+            case "--suite": {
+                const s = val();
+                assertSafePathComponent(s, "suite");
+                args.suite = s;
+                break;
+            }
+            case "--strip-prefix":
+                args.stripPrefixes.push(val());
+                break;
+            case "--branch": {
+                const branch = val();
+                if (branch.length === 0)
+                    throw new Error(`invalid branch: ${JSON.stringify(branch)}`);
+                args.branch = branch;
+                break;
+            }
+            case "--store":
+            case "--store-fs":
+                storeFs = val();
+                break;
+            case "--store-s3":
+                storeS3 = val();
+                break;
+            case "--pr": {
+                const raw = val();
+                if (!/^\d+$/.test(raw) || raw === "0")
+                    throw new Error(`--pr must be a positive integer, got: ${JSON.stringify(raw)}`);
+                args.pr = parseInt(raw, 10);
+                break;
+            }
+            default:
+                throw new Error(`unknown flag: ${flag}`);
+        }
+    }
+    if (storeFs && storeS3)
+        throw new Error("--store-fs and --store-s3 are mutually exclusive");
+    if (args.pr !== null && args.repo.trim() === "")
+        throw new Error("--repo is required when --pr is set (or define GITHUB_REPOSITORY)");
+    args.store = makeStore({ fs: storeFs, s3: storeS3 });
+    return args;
+}

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

@@ -0,0 +1,4 @@
+import type { CheckArgs } from "./check-args.mts";
+export type { CheckArgs } from "./check-args.mts";
+export declare function main(argv: string[]): Promise<number>;
+export declare function runCheck(args: CheckArgs): Promise<number>;

package/dist/src/commands/check.mjs

@@ -0,0 +1,128 @@
+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 { loadRules } from "../rules.mjs";
+import { computePatchCoverage } from "../patch-coverage.mjs";
+import { collapseRanges, renderFailureComment } from "../report.mjs";
+import { upsertComment } from "../github-comment.mjs";
+import { collectLcovFiles, buildStripPrefixes } from "../load-artifacts.mjs";
+import { writeSummary } from "../step-summary.mjs";
+import { parseCheckArgs } from "./check-args.mjs";
+const stdout = (msg) => process.stdout.write(`${msg}\n`);
+const stderr = (msg) => process.stderr.write(`${msg}\n`);
+export async function main(argv) {
+    let args;
+    try {
+        args = parseCheckArgs(argv);
+    }
+    catch (err) {
+        stderr(`coverage-check: ${String(err)}`);
+        return 2;
+    }
+    return runCheck(args);
+}
+export async function runCheck(args) {
+    let rules;
+    try {
+        rules = loadRules(args.rules);
+    }
+    catch (err) {
+        stderr(`coverage-check: failed to load rules: ${err}`);
+        return 2;
+    }
+    const branch = args.branch ?? "main";
+    const stripPrefixes = buildStripPrefixes(args.stripPrefixes);
+    const reports = [];
+    const suiteSources = [];
+    if (args.store !== null) {
+        const suites = await args.store.list();
+        for (const suite of suites) {
+            if (suite === args.suite)
+                continue;
+            const buf = await args.store.get(suite, { branch });
+            if (buf !== null) {
+                const lcov = parseLcov(buf.toString("utf8"), stripPrefixes);
+                reports.push(lcov);
+                suiteSources.push({ suite, source: "store", lcov });
+            }
+        }
+    }
+    const lcovFiles = collectLcovFiles(args.artifacts);
+    const freshLcovs = [];
+    for (const f of lcovFiles) {
+        const lcov = parseLcov(readFileSync(f, "utf8"), stripPrefixes);
+        reports.push(lcov);
+        freshLcovs.push(lcov);
+    }
+    if (freshLcovs.length > 0) {
+        suiteSources.push({
+            suite: args.suite ?? "(current)",
+            source: "fresh",
+            lcov: mergeLcov(freshLcovs),
+        });
+    }
+    if (reports.length === 0) {
+        stderr(`coverage-check: no coverage data found — skipping`);
+        return 0;
+    }
+    const lcov = mergeLcov(reports);
+    let diff;
+    try {
+        diff = await getChangedLines(args.base, args.head);
+    }
+    catch (err) {
+        stderr(`coverage-check: git diff failed: ${err}`);
+        return 2;
+    }
+    const { buckets, informational } = computePatchCoverage(diff, lcov, rules);
+    const passed = buckets.every((b) => b.passed);
+    const result = { buckets, informational, passed };
+    if (args.json) {
+        writeFileSync(args.json, JSON.stringify(result, null, 2));
+    }
+    const runUrl = process.env["GITHUB_SERVER_URL"] && process.env["GITHUB_RUN_ID"]
+        ? `${process.env["GITHUB_SERVER_URL"]}/${args.repo}/actions/runs/${process.env["GITHUB_RUN_ID"]}`
+        : "N/A";
+    if (!passed) {
+        stdout("\ncoverage-check: FAILED\n");
+        for (const bucket of buckets.filter((b) => !b.passed)) {
+            /* c8 ignore next -- bucket.coverable is always > 0 by patch-coverage.mts L36 guard */
+            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)}`);
+            }
+        }
+    }
+    else {
+        stdout("\ncoverage-check: PASSED\n");
+        for (const bucket of buckets) {
+            /* c8 ignore next -- bucket.coverable is always > 0 by patch-coverage.mts L36 guard */
+            const pct = bucket.coverable > 0 ? `${((bucket.hit / bucket.coverable) * 100).toFixed(1)}%` : "—";
+            stdout(`  ${bucket.rule}: ${pct} ✓`);
+        }
+    }
+    const summaryFile = args.summaryFile !== undefined
+        ? args.summaryFile
+        : (process.env["GITHUB_STEP_SUMMARY"] ?? null);
+    if (summaryFile) {
+        try {
+            writeSummary(summaryFile, suiteSources, result, runUrl, branch);
+        }
+        catch (err) {
+            stderr(`coverage-check: failed to write step summary: ${err}`);
+            return 2;
+        }
+    }
+    if (args.pr !== null && args.repo) {
+        const body = passed ? "" : renderFailureComment(result, runUrl);
+        try {
+            await upsertComment(body, args.repo, args.pr, passed, args.gh);
+        }
+        catch (err) {
+            stderr(`coverage-check: failed to post PR comment: ${err}`);
+        }
+    }
+    return passed ? 0 : 1;
+}

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

@@ -0,0 +1,11 @@
+import type { SuiteStore } from "../suite-store.mts";
+export type StorePutArgs = {
+    suite: string;
+    store: SuiteStore;
+    artifacts: string;
+    stripPrefixes: string[];
+    sha?: string;
+    branch?: string;
+};
+export declare function main(argv: string[]): Promise<number>;
+export declare function runStorePut(args: StorePutArgs): Promise<number>;

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

@@ -0,0 +1,104 @@
+import { readFileSync } from "node:fs";
+import { parseLcov } from "../lcov-parser.mjs";
+import { mergeLcov, toLcov } from "../lcov-merge.mjs";
+import { collectLcovFiles, buildStripPrefixes } from "../load-artifacts.mjs";
+import { makeStore } from "../store-factory.mjs";
+import { assertSafePathComponent } from "../suite-store.mjs";
+const stdout = (msg) => process.stdout.write(`${msg}\n`);
+const stderr = (msg) => process.stderr.write(`${msg}\n`);
+function parseArgs(argv) {
+    let storeFs = null;
+    let storeS3 = null;
+    const args = {
+        suite: "",
+        artifacts: "./coverage-artifacts",
+        stripPrefixes: [],
+        sha: undefined,
+        branch: undefined,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const flag = argv[i];
+        const next = argv[i + 1];
+        const val = () => {
+            if (next === undefined || next.startsWith("--")) {
+                throw new Error(`${flag} requires a value`);
+            }
+            i++;
+            return next;
+        };
+        switch (flag) {
+            case "--suite":
+                args.suite = val();
+                break;
+            case "--store":
+            case "--store-fs":
+                storeFs = val();
+                break;
+            case "--store-s3":
+                storeS3 = val();
+                break;
+            case "--artifacts":
+                args.artifacts = val();
+                break;
+            case "--strip-prefix":
+                args.stripPrefixes.push(val());
+                break;
+            case "--sha":
+                args.sha = val();
+                break;
+            case "--branch":
+                args.branch = val();
+                break;
+            default:
+                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)
+        throw new Error("--store-fs/--store or --store-s3 is required");
+    const hasSha = args.sha !== undefined;
+    const hasBranch = args.branch !== undefined;
+    if (hasSha !== hasBranch) {
+        throw new Error("--sha and --branch must be provided together");
+    }
+    assertSafePathComponent(args.suite, "suite");
+    if (args.sha !== undefined)
+        assertSafePathComponent(args.sha, "sha");
+    if (args.branch !== undefined && args.branch.length === 0) {
+        throw new Error(`invalid branch: ${JSON.stringify(args.branch)}`);
+    }
+    const store = makeStore({ fs: storeFs, s3: storeS3 });
+    return { ...args, store };
+}
+export async function main(argv) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (err) {
+        stderr(`coverage-check store-put: ${String(err)}`);
+        return 2;
+    }
+    return runStorePut(args);
+}
+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;
+    }
+    const stripPrefixes = buildStripPrefixes(args.stripPrefixes);
+    const reports = lcovFiles.map((f) => parseLcov(readFileSync(f, "utf8"), stripPrefixes));
+    const merged = mergeLcov(reports);
+    const lcovText = toLcov(merged);
+    const meta = args.sha !== undefined && args.branch !== undefined
+        ? { sha: args.sha, branch: args.branch }
+        : undefined;
+    await args.store.put(args.suite, Buffer.from(lcovText, "utf8"), meta);
+    const metaLabel = args.sha !== undefined ? ` sha=${args.sha} branch=${args.branch}` : "";
+    stdout(`coverage-check store-put: stored suite "${args.suite}" (${lcovFiles.length} file(s))${metaLabel}`);
+    return 0;
+}

package/{src/coverage-check.mts → dist/src/coverage-check.d.mts}

@@ -1,15 +1,9 @@
 export { runCheck } from "./commands/check.mts";
 export { runStorePut } from "./commands/store-put.mts";
 export { FileSystemSuiteStore } from "./suite-store.mts";
-
+export { S3SuiteStore } from "./s3-suite-store.mts";
 export type { CheckArgs } from "./commands/check.mts";
 export type { StorePutArgs } from "./commands/store-put.mts";
 export type { SuiteStore, SuiteMeta } from "./suite-store.mts";
-export type {
-  CoverageCheckResult,
-  BucketResult,
-  FileCoverageResult,
-  LcovData,
-  DiffLines,
-  CoverageRule,
-} from "./types.mts";
+export type { S3SuiteStoreOptions } from "./s3-suite-store.mts";
+export type { CoverageCheckResult, BucketResult, FileCoverageResult, LcovData, DiffLines, CoverageRule, } from "./types.mts";

package/dist/src/coverage-check.mjs

@@ -0,0 +1,4 @@
+export { runCheck } from "./commands/check.mjs";
+export { runStorePut } from "./commands/store-put.mjs";
+export { FileSystemSuiteStore } from "./suite-store.mjs";
+export { S3SuiteStore } from "./s3-suite-store.mjs";

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

@@ -0,0 +1,17 @@
+import type { DiffLines } from "./types.mts";
+/**
+ * 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 declare function decodeGitCString(s: string): string;
+/**
+ * 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 declare function parseDiff(text: string): DiffLines;
+/** Runs git diff and returns the parsed result. */
+export declare function getChangedLines(baseRef: string, headRef: string): Promise<DiffLines>;