ci: enforce coverage threshold locally

Share the coverage threshold check between local test:coverage and CI so missing coverage summaries or below-threshold runs fail before push.

Author: AlbinoGeek

.github/workflows/ci.yml

@@ -31,17 +31,7 @@ jobs:
       - name: Unit tests with coverage
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          bun run test:coverage 2>&1 | tee /tmp/coverage.txt
-          node -e "
-            const out = require('fs').readFileSync('/tmp/coverage.txt', 'utf8');
-            const m = out.match(/all files[^\|]*\|\s*([\d.]+)/i);
-            if (!m) { console.log('No coverage summary found — skipping threshold check.'); process.exit(0); }
-            const pct = parseFloat(m[1]);
-            const min = 80;
-            if (pct < min) { process.stderr.write('Coverage ' + pct.toFixed(1) + '% is below minimum ' + min + '%\n'); process.exit(1); }
-            console.log('Coverage OK: ' + pct.toFixed(1) + '%');
-          "
+        run: bun run test:coverage
 
       - name: Assert Node.js version
         run: node -e "const v=+process.version.slice(1).split('.')[0]; if(v<22)process.exit(1)"

package.json

@@ -31,7 +31,7 @@
     "check": "biome check .",
     "check:fix": "biome check --write .",
     "test": "bun test src/",
-    "test:coverage": "bun test src/ --coverage",
+    "test:coverage": "bun src/coverage-threshold.ts",
     "prepublishOnly": "bun run build && bun run check && bun run test",
     "setup-hooks": "git config core.hooksPath .githooks"
   },

src/coverage-threshold.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+
+import { assertCoverageThreshold, parseAllFilesLineCoverage } from "./coverage-threshold.js";
+
+describe("parseAllFilesLineCoverage", () => {
+  test("extracts line coverage from Bun's All files summary row", () => {
+    const output = `
+------------------------------------|---------|---------|-------------------
+File                                | % Funcs | % Lines | Uncovered Line #s
+------------------------------------|---------|---------|-------------------
+All files                           |   91.05 |   92.03 |
+ src/server/json.ts                 |  100.00 |   96.55 | 16
+`;
+
+    expect(parseAllFilesLineCoverage(output)).toBe(92.03);
+  });
+});
+
+describe("assertCoverageThreshold", () => {
+  test("throws when line coverage is below the minimum", () => {
+    const output = "All files                           |   91.05 |   79.99 |";
+
+    expect(() => assertCoverageThreshold(output, 80)).toThrow(
+      "Coverage 79.99% is below minimum 80%",
+    );
+  });
+});

src/coverage-threshold.ts

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+
+const DEFAULT_MIN_LINE_COVERAGE = 80;
+
+export function parseAllFilesLineCoverage(output: string): number | undefined {
+  const match = output.match(/all files[^\n|]*\|\s*[\d.]+\s*\|\s*([\d.]+)/i);
+  if (!match?.[1]) return undefined;
+
+  return Number.parseFloat(match[1]);
+}
+
+export function assertCoverageThreshold(
+  output: string,
+  minLineCoverage = DEFAULT_MIN_LINE_COVERAGE,
+): void {
+  const coverage = parseAllFilesLineCoverage(output);
+  if (coverage === undefined) {
+    throw new Error("No coverage summary found.");
+  }
+
+  if (coverage < minLineCoverage) {
+    throw new Error(`Coverage ${coverage.toFixed(2)}% is below minimum ${minLineCoverage}%`);
+  }
+
+  console.log(`Coverage OK: ${coverage.toFixed(2)}%`);
+}
+
+async function runCoverageCli(): Promise<void> {
+  const outputChunks: Buffer[] = [];
+  const proc = spawn("bun", ["test", "src/", "--coverage"], {
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  proc.stdout.on("data", (chunk: Buffer) => {
+    outputChunks.push(chunk);
+    process.stdout.write(chunk);
+  });
+  proc.stderr.on("data", (chunk: Buffer) => {
+    outputChunks.push(chunk);
+    process.stderr.write(chunk);
+  });
+
+  const exitCode = await new Promise<number>((resolve) => {
+    proc.on("close", (code) => resolve(code ?? 1));
+  });
+
+  const output = Buffer.concat(outputChunks).toString("utf8");
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+
+  try {
+    assertCoverageThreshold(output);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.main) {
+  await runCoverageCli();
+}