coverage-check 0.1.0

package/src/commands/store-put.mts

@@ -0,0 +1,100 @@
+import { readFileSync } from "node:fs";
+import { parseLcov } from "../lcov-parser.mts";
+import { mergeLcov, toLcov } from "../lcov-merge.mts";
+import { collectLcovFiles, buildStripPrefixes } from "../load-artifacts.mts";
+import { FileSystemSuiteStore } from "../suite-store.mts";
+
+const stdout = (msg: string) => process.stdout.write(`${msg}\n`);
+const stderr = (msg: string) => process.stderr.write(`${msg}\n`);
+
+export type StorePutArgs = {
+  suite: string;
+  store: string;
+  artifacts: string;
+  stripPrefixes: string[];
+  sha: string | null;
+  ref: string | null;
+};
+
+function parseArgs(argv: string[]): StorePutArgs {
+  const args: StorePutArgs = {
+    suite: "",
+    store: "",
+    artifacts: "./coverage-artifacts",
+    stripPrefixes: [],
+    sha: null,
+    ref: null,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i]!;
+    const next = argv[i + 1];
+    const val = (): string => {
+      if (next === undefined) throw new Error(`${flag} requires a value`);
+      i++;
+      return next;
+    };
+    switch (flag) {
+      case "--suite":
+        args.suite = val();
+        break;
+      case "--store":
+        args.store = val();
+        break;
+      case "--artifacts":
+        args.artifacts = val();
+        break;
+      case "--strip-prefix":
+        args.stripPrefixes.push(val());
+        break;
+      case "--sha":
+        args.sha = val();
+        break;
+      case "--ref":
+        args.ref = val();
+        break;
+      default:
+        throw new Error(`unknown flag: ${flag}`);
+    }
+  }
+
+  if (!args.suite) throw new Error("--suite is required");
+  if (!args.store) throw new Error("--store is required");
+  return args;
+}
+
+export async function main(argv: string[]): Promise<number> {
+  let args: StorePutArgs;
+  try {
+    args = parseArgs(argv);
+  } catch (err) {
+    /* c8 ignore next */
+    stderr(`coverage-check store-put: ${err instanceof Error ? err.message : err}`);
+    return 2;
+  }
+  return runStorePut(args);
+}
+
+export async function runStorePut(args: StorePutArgs): Promise<number> {
+  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 store = new FileSystemSuiteStore(args.store);
+  await store.put(args.suite, Buffer.from(lcovText, "utf8"), {
+    sha: args.sha ?? undefined,
+    ref: args.ref ?? undefined,
+  });
+
+  stdout(
+    `coverage-check store-put: stored suite "${args.suite}" (${lcovFiles.length} file(s)) → ${args.store}`,
+  );
+  return 0;
+}

package/src/commands/store-put.test.mts

@@ -0,0 +1,154 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { main, runStorePut } from "./store-put.mts";
+import { FileSystemSuiteStore } from "../suite-store.mts";
+
+describe("main argument parsing", () => {
+  it("returns 2 when --suite is missing", async () => {
+    expect(await main(["--store", "/tmp/store"])).toBe(2);
+  });
+
+  it("returns 2 when --store is missing", async () => {
+    expect(await main(["--suite", "backend"])).toBe(2);
+  });
+
+  it("returns 2 on unknown flag", async () => {
+    expect(await main(["--suite", "backend", "--store", "/tmp/s", "--unknown"])).toBe(2);
+  });
+
+  it("returns 2 when a flag is missing its value", async () => {
+    expect(await main(["--suite"])).toBe(2);
+  });
+});
+
+describe("runStorePut", () => {
+  let tmpDir: string;
+  let artifactsDir: string;
+  let storeDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "store-put-test-"));
+    artifactsDir = join(tmpDir, "artifacts");
+    storeDir = join(tmpDir, "store");
+    mkdirSync(artifactsDir);
+    mkdirSync(storeDir);
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns 2 when no lcov.info files found in artifacts", async () => {
+    expect(
+      await runStorePut({
+        suite: "backend",
+        store: storeDir,
+        artifacts: artifactsDir,
+        stripPrefixes: [],
+        sha: null,
+        ref: null,
+      }),
+    ).toBe(2);
+  });
+
+  it("stores merged lcov from artifacts and returns 0", async () => {
+    writeFileSync(
+      join(artifactsDir, "lcov.info"),
+      "SF:backend/foo.mts\nDA:1,1\nDA:2,0\nend_of_record\n",
+    );
+
+    expect(
+      await runStorePut({
+        suite: "backend",
+        store: storeDir,
+        artifacts: artifactsDir,
+        stripPrefixes: [],
+        sha: "abc123",
+        ref: "refs/heads/main",
+      }),
+    ).toBe(0);
+
+    const store = new FileSystemSuiteStore(storeDir);
+    const suites = await store.list();
+    expect(suites).toContain("backend");
+
+    const buf = await store.get("backend");
+    expect(buf).not.toBeNull();
+    const lcovText = buf!.toString();
+    expect(lcovText).toContain("SF:backend/foo.mts");
+    expect(lcovText).toContain("DA:1,1");
+  });
+
+  it("merges multiple lcov files from nested subdirectories", async () => {
+    const sub = join(artifactsDir, "shard1");
+    mkdirSync(sub);
+    writeFileSync(join(artifactsDir, "lcov.info"), "SF:backend/a.mts\nDA:1,1\nend_of_record\n");
+    writeFileSync(join(sub, "lcov.info"), "SF:backend/b.mts\nDA:2,1\nend_of_record\n");
+
+    expect(
+      await runStorePut({
+        suite: "backend",
+        store: storeDir,
+        artifacts: artifactsDir,
+        stripPrefixes: [],
+        sha: null,
+        ref: null,
+      }),
+    ).toBe(0);
+
+    const store = new FileSystemSuiteStore(storeDir);
+    const buf = await store.get("backend");
+    const lcovText = buf!.toString();
+    expect(lcovText).toContain("SF:backend/a.mts");
+    expect(lcovText).toContain("SF:backend/b.mts");
+  });
+
+  it("accepts --strip-prefix flag", async () => {
+    writeFileSync(
+      join(artifactsDir, "lcov.info"),
+      "SF:/home/runner/work/repo/backend/foo.mts\nDA:1,1\nend_of_record\n",
+    );
+
+    expect(
+      await main([
+        "--suite",
+        "backend",
+        "--store",
+        storeDir,
+        "--artifacts",
+        artifactsDir,
+        "--strip-prefix",
+        "/home/runner/work/repo",
+      ]),
+    ).toBe(0);
+
+    const store = new FileSystemSuiteStore(storeDir);
+    const buf = await store.get("backend");
+    // After stripping the prefix, the stored lcov should have the normalized path
+    expect(buf!.toString()).toContain("SF:backend/foo.mts");
+  });
+
+  it("round-trips through main() CLI interface", async () => {
+    writeFileSync(join(artifactsDir, "lcov.info"), "SF:web/app.tsx\nDA:10,1\nend_of_record\n");
+
+    expect(
+      await main([
+        "--suite",
+        "frontend",
+        "--store",
+        storeDir,
+        "--artifacts",
+        artifactsDir,
+        "--sha",
+        "deadbeef",
+        "--ref",
+        "refs/heads/feat",
+      ]),
+    ).toBe(0);
+
+    const stored = readFileSync(join(storeDir, "frontend", "lcov.info"), "utf8");
+    expect(stored).toContain("SF:web/app.tsx");
+  });
+});

package/src/coverage-check.mts

@@ -0,0 +1,15 @@
+export { runCheck } from "./commands/check.mts";
+export { runStorePut } from "./commands/store-put.mts";
+export { FileSystemSuiteStore } from "./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";

package/src/diff-parser.mts

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

package/src/diff-parser.test.mts

@@ -0,0 +1,178 @@
+import { describe, expect, it } from "vitest";
+import { decodeGitCString, parseDiff } from "./diff-parser.mts";
+
+const SIMPLE_DIFF = `
+diff --git a/web/components/Foo.tsx b/web/components/Foo.tsx
+index abc..def 100644
+--- a/web/components/Foo.tsx
++++ b/web/components/Foo.tsx
+@@ -1,3 +1,5 @@
++import React from 'react'
++
+ export function Foo() {
+-  return null
++  return <div />
+ }
++export const BAR = 1
+`;
+
+const DELETION_DIFF = `
+diff --git a/backend/foo.mts b/backend/foo.mts
+--- a/backend/foo.mts
++++ b/backend/foo.mts
+@@ -5,3 +5,0 @@
+-deleted line
+-deleted line
+-deleted line
+`;
+
+const MULTI_FILE_DIFF = `
+diff --git a/web/components/A.tsx b/web/components/A.tsx
+--- a/web/components/A.tsx
++++ b/web/components/A.tsx
+@@ -1,1 +1,2 @@
+ unchanged
++added
+diff --git a/backend/b.mts b/backend/b.mts
+--- a/backend/b.mts
++++ b/backend/b.mts
+@@ -10,0 +11,1 @@
++new line
+`;
+
+describe("parseDiff", () => {
+  it("parses added lines from a hunk", () => {
+    const result = parseDiff(SIMPLE_DIFF);
+    const fooLines = result.get("web/components/Foo.tsx")!;
+    expect(fooLines.has(1)).toBe(true);
+    expect(fooLines.has(5)).toBe(true);
+    expect(fooLines.size).toBe(5);
+  });
+
+  it("skips pure-deletion hunks (count=0)", () => {
+    const result = parseDiff(DELETION_DIFF);
+    const lines = result.get("backend/foo.mts");
+    expect(!lines || lines.size === 0).toBe(true);
+  });
+
+  it("handles multiple files", () => {
+    const result = parseDiff(MULTI_FILE_DIFF);
+    expect(result.has("web/components/A.tsx")).toBe(true);
+    expect(result.has("backend/b.mts")).toBe(true);
+    expect(result.get("backend/b.mts")?.has(11)).toBe(true);
+  });
+
+  it("skips deleted files (+++ b/dev/null)", () => {
+    const diff = `
+diff --git a/backend/deleted.mts b/backend/deleted.mts
+--- a/backend/deleted.mts
++++ b/dev/null
+@@ -1,3 +0,0 @@
+-deleted line 1
+-deleted line 2
+-deleted line 3
+`;
+    const result = parseDiff(diff);
+    expect(result.has("dev/null")).toBe(false);
+    expect(result.has("backend/deleted.mts")).toBe(false);
+  });
+
+  it("handles hunk headers with trailing section context text", () => {
+    const diff = `
+diff --git a/backend/x.mts b/backend/x.mts
+--- a/backend/x.mts
++++ b/backend/x.mts
+@@ -1,3 +1,5 @@ export function Foo() {
++import React from 'react'
++
+ export function Foo() {
+-  return null
++  return <div />
+ }
++export const BAR = 1
+`;
+    const result = parseDiff(diff);
+    expect(result.get("backend/x.mts")?.size).toBe(5);
+    expect(result.get("backend/x.mts")?.has(1)).toBe(true);
+    expect(result.get("backend/x.mts")?.has(5)).toBe(true);
+  });
+
+  it("handles comma-less hunk lines (single-line change)", () => {
+    const diff = `
+diff --git a/backend/x.mts b/backend/x.mts
+--- a/backend/x.mts
++++ b/backend/x.mts
+@@ -1 +1 @@
+-old
++new
+`;
+    const result = parseDiff(diff);
+    expect(result.get("backend/x.mts")?.has(1)).toBe(true);
+  });
+
+  it("does not misclassify content lines starting with +++ b/ as file headers", () => {
+    const diff = `
+diff --git a/backend/foo.mts b/backend/foo.mts
+--- a/backend/foo.mts
++++ b/backend/foo.mts
+@@ -1,1 +1,2 @@
+ unchanged
++++ b/this-is-content-not-a-header
+`;
+    const result = parseDiff(diff);
+    expect(result.has("backend/foo.mts")).toBe(true);
+    expect(result.has("this-is-content-not-a-header")).toBe(false);
+    expect(result.get("backend/foo.mts")?.has(2)).toBe(true);
+  });
+
+  it("skips malformed hunk header lines (@@ with no valid pattern)", () => {
+    const diff = `
+diff --git a/backend/x.mts b/backend/x.mts
+--- a/backend/x.mts
++++ b/backend/x.mts
+@@ bad hunk header @@
++new line
+`;
+    const result = parseDiff(diff);
+    // malformed @@ line is skipped; no lines added
+    const lines = result.get("backend/x.mts");
+    expect(!lines || lines.size === 0).toBe(true);
+  });
+
+  it("handles git-quoted paths (core.quotePath=true)", () => {
+    const diff = `
+diff --git "a/backend/caf\\303\\251.mts" "b/backend/caf\\303\\251.mts"
+--- "a/backend/caf\\303\\251.mts"
++++ "b/backend/caf\\303\\251.mts"
+@@ -1,1 +1,2 @@
+ existing
++new line
+`;
+    const result = parseDiff(diff);
+    expect(result.has("backend/café.mts")).toBe(true);
+    expect(result.get("backend/café.mts")?.has(2)).toBe(true);
+  });
+});
+
+describe("decodeGitCString", () => {
+  it("returns plain ASCII unchanged", () => {
+    expect(decodeGitCString("backend/foo.mts")).toBe("backend/foo.mts");
+  });
+
+  it("decodes octal UTF-8 byte sequences", () => {
+    expect(decodeGitCString("caf\\303\\251.mts")).toBe("café.mts");
+  });
+
+  it("decodes backslash and double-quote escapes", () => {
+    expect(decodeGitCString('path\\\\to\\"file')).toBe('path\\to"file');
+  });
+
+  it("decodes \\n and \\t escapes", () => {
+    expect(decodeGitCString("line\\nbreak")).toBe("line\nbreak");
+    expect(decodeGitCString("tab\\there")).toBe("tab\there");
+  });
+
+  it("passes through unknown escape sequences unchanged", () => {
+    expect(decodeGitCString("\\z")).toBe("\\z");
+  });
+});

package/src/github-comment.mts

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