coverage-check 0.2.1 → 0.2.2

package/src/github-comment.mts

@@ -1,79 +0,0 @@
-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 with prior comment: deletes the prior comment.
- * - On pass with no prior comment: 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;
-
-  if (passed && existingId !== null) {
-    await gh(["api", `repos/${repo}/issues/comments/${existingId}`, "-X", "DELETE"]);
-    return;
-  }
-
-  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}`]);
-  }
-}

package/src/github-comment.test.mts

@@ -1,63 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { upsertComment, type GhRunner } from "./github-comment.mts";
-import { COMMENT_MARKER } from "./report.mts";
-
-function makeGh(responses: Record<string, string>): GhRunner & ReturnType<typeof vi.fn> {
-  const impl: GhRunner = (args) => {
-    const key = args.join(" ");
-    for (const [pattern, response] of Object.entries(responses)) {
-      if (key.includes(pattern)) return Promise.resolve(response);
-    }
-    return Promise.resolve("");
-  };
-  return vi.fn<typeof impl>(impl) as GhRunner & ReturnType<typeof vi.fn>;
-}
-
-const FAIL_BODY = `${COMMENT_MARKER}\n## failed`;
-
-describe("upsertComment", () => {
-  it("posts a new comment on failure when none exists", async () => {
-    const gh = makeGh({ "issues/42/comments --paginate": "" });
-    await upsertComment(FAIL_BODY, "owner/repo", 42, false, gh);
-    const calls = gh.mock.calls.map((c) => c[0].join(" "));
-    expect(calls.some((c) => c.includes("issues/42/comments") && !c.includes("PATCH"))).toBe(true);
-  });
-
-  it("patches an existing comment on failure", async () => {
-    const gh = makeGh({ "issues/42/comments --paginate": "99\n" });
-    await upsertComment(FAIL_BODY, "owner/repo", 42, false, gh);
-    const calls = gh.mock.calls.map((c) => c[0].join(" "));
-    expect(calls.some((c) => c.includes("comments/99") && c.includes("PATCH"))).toBe(true);
-  });
-
-  it("deletes an existing comment on pass", async () => {
-    const gh = makeGh({ "issues/42/comments --paginate": "99\n" });
-    await upsertComment("", "owner/repo", 42, true, gh);
-    const calls = gh.mock.calls.map((c) => c[0].join(" "));
-    expect(calls.some((c) => c.includes("comments/99") && c.includes("DELETE"))).toBe(true);
-  });
-
-  it("does nothing on pass when no prior comment exists", async () => {
-    const gh = makeGh({ "issues/42/comments --paginate": "" });
-    await upsertComment("", "owner/repo", 42, true, gh);
-    expect(gh.mock.calls.length).toBe(1);
-  });
-
-  it("finds comment id when paginate produces null on first page then id on second", async () => {
-    const gh = makeGh({ "issues/42/comments --paginate": "\n99\n" });
-    await upsertComment(FAIL_BODY, "owner/repo", 42, false, gh);
-    const calls = gh.mock.calls.map((c) => c[0].join(" "));
-    expect(calls.some((c) => c.includes("comments/99") && c.includes("PATCH"))).toBe(true);
-  });
-
-  it("falls back to POST and does not throw when comment lookup fails", async () => {
-    const lookupErrorGh = vi.fn<GhRunner>((args) =>
-      args.includes("--paginate") ? Promise.reject(new Error("API error")) : Promise.resolve(""),
-    );
-    await expect(
-      upsertComment(FAIL_BODY, "owner/repo", 42, false, lookupErrorGh),
-    ).resolves.toBeUndefined();
-    const calls = lookupErrorGh.mock.calls.map((c) => c[0].join(" "));
-    expect(calls.some((c) => c.includes("issues/42/comments") && !c.includes("PATCH"))).toBe(true);
-  });
-});

package/src/lcov-merge.mts

@@ -1,34 +0,0 @@
-import type { LcovData } from "./types.mts";
-
-/** Merges multiple LcovData maps by summing hit counts per file per line. */
-export function mergeLcov(reports: LcovData[]): LcovData {
-  const merged: LcovData = new Map();
-
-  for (const report of reports) {
-    for (const [file, lines] of report) {
-      let target = merged.get(file);
-      if (target === undefined) {
-        target = new Map();
-        merged.set(file, target);
-      }
-      for (const [lineNo, hits] of lines) {
-        target.set(lineNo, (target.get(lineNo) ?? 0) + hits);
-      }
-    }
-  }
-
-  return merged;
-}
-
-/** Serializes LcovData back to LCOV text format. */
-export function toLcov(lcov: LcovData): string {
-  const lines: string[] = [];
-  for (const [file, fileLines] of lcov) {
-    lines.push(`SF:${file}`);
-    for (const [lineNo, hits] of fileLines) {
-      lines.push(`DA:${lineNo},${hits}`);
-    }
-    lines.push("end_of_record");
-  }
-  return lines.length > 0 ? `${lines.join("\n")}\n` : "";
-}

package/src/lcov-merge.test.mts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseLcov } from "./lcov-parser.mts";
-import { mergeLcov, toLcov } from "./lcov-merge.mts";
-
-describe("mergeLcov", () => {
-  it("merges two reports by summing hit counts", () => {
-    const a = parseLcov(`SF:web/foo.mts\nDA:1,1\nDA:2,0\nend_of_record\n`);
-    const b = parseLcov(`SF:web/foo.mts\nDA:1,2\nDA:3,1\nend_of_record\n`);
-    const merged = mergeLcov([a, b]);
-    const lines = merged.get("web/foo.mts")!;
-    expect(lines.get(1)).toBe(3);
-    expect(lines.get(2)).toBe(0);
-    expect(lines.get(3)).toBe(1);
-  });
-
-  it("includes files present in only one report", () => {
-    const a = parseLcov(`SF:backend/a.mts\nDA:1,1\nend_of_record\n`);
-    const b = parseLcov(`SF:backend/b.mts\nDA:2,1\nend_of_record\n`);
-    const merged = mergeLcov([a, b]);
-    expect(merged.has("backend/a.mts")).toBe(true);
-    expect(merged.has("backend/b.mts")).toBe(true);
-  });
-
-  it("handles a shard that did not execute a given file", () => {
-    const a = parseLcov(`SF:backend/service.mts\nDA:10,1\nend_of_record\n`);
-    const b = parseLcov(`SF:backend/other.mts\nDA:1,1\nend_of_record\n`);
-    const merged = mergeLcov([a, b]);
-    expect(merged.get("backend/service.mts")?.get(10)).toBe(1);
-  });
-
-  it("returns empty map for empty input", () => {
-    expect(mergeLcov([])).toEqual(new Map());
-  });
-});
-
-describe("toLcov", () => {
-  it("serializes an empty map to an empty string", () => {
-    expect(toLcov(new Map())).toBe("");
-  });
-
-  it("round-trips through parseLcov", () => {
-    const original = parseLcov(`SF:backend/foo.mts\nDA:1,2\nDA:3,0\nend_of_record\n`);
-    const text = toLcov(original);
-    const roundTripped = parseLcov(text);
-    expect(roundTripped.get("backend/foo.mts")?.get(1)).toBe(2);
-    expect(roundTripped.get("backend/foo.mts")?.get(3)).toBe(0);
-  });
-
-  it("serializes multiple files", () => {
-    const data = parseLcov(`SF:a.mts\nDA:1,1\nend_of_record\nSF:b.mts\nDA:2,3\nend_of_record\n`);
-    const text = toLcov(data);
-    expect(text).toContain("SF:a.mts");
-    expect(text).toContain("SF:b.mts");
-    expect(text).toContain("DA:1,1");
-    expect(text).toContain("DA:2,3");
-  });
-});

package/src/lcov-parser.mts

@@ -1,46 +0,0 @@
-import type { LcovData } from "./types.mts";
-
-/**
- * Parses LCOV text into a map of repo-root-relative file path → line → hit count.
- *
- * Paths are normalized by stripping a given prefix (e.g. $GITHUB_WORKSPACE or cwd)
- * so callers see repo-root-relative paths regardless of where the runner ran.
- */
-export function parseLcov(text: string, stripPrefixes: string[] = []): LcovData {
-  const result: LcovData = new Map();
-  let currentLines: Map<number, number> | null = null;
-
-  for (const raw of text.split("\n")) {
-    const line = raw.trimEnd();
-
-    if (line.startsWith("SF:")) {
-      let path = line.slice(3);
-      for (const prefix of stripPrefixes) {
-        if (path.startsWith(prefix)) {
-          path = path.slice(prefix.length);
-          break;
-        }
-      }
-      path = normalizePath(path);
-      currentLines = result.get(path) ?? new Map();
-      result.set(path, currentLines);
-    } else if (line.startsWith("DA:") && currentLines !== null) {
-      const rest = line.slice(3);
-      const comma = rest.indexOf(",");
-      if (comma === -1) continue;
-      const lineNo = parseInt(rest.slice(0, comma), 10);
-      const hits = parseInt(rest.slice(comma + 1), 10);
-      if (!Number.isFinite(lineNo) || !Number.isFinite(hits)) continue;
-      const prev = currentLines.get(lineNo) ?? 0;
-      currentLines.set(lineNo, prev + hits);
-    } else if (line === "end_of_record") {
-      currentLines = null;
-    }
-  }
-
-  return result;
-}
-
-function normalizePath(p: string): string {
-  return p.replace(/\\/g, "/").replace(/^\.\//, "");
-}

package/src/lcov-parser.test.mts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseLcov } from "./lcov-parser.mts";
-
-const SIMPLE_LCOV = `
-SF:web/components/Foo.tsx
-DA:1,1
-DA:2,0
-DA:3,1
-end_of_record
-SF:web/components/Bar.tsx
-DA:10,2
-end_of_record
-`;
-
-const ABSOLUTE_LCOV = `
-SF:/home/runner/work/repo/repo/web/lib/api/client.mts
-DA:5,1
-DA:6,0
-end_of_record
-`;
-
-const WINDOWS_LCOV = `
-SF:.\\backend\\services\\foo.mts
-DA:1,1
-end_of_record
-`;
-
-describe("parseLcov", () => {
-  it("parses basic SF and DA records", () => {
-    const result = parseLcov(SIMPLE_LCOV);
-    expect(result.get("web/components/Foo.tsx")?.get(1)).toBe(1);
-    expect(result.get("web/components/Foo.tsx")?.get(2)).toBe(0);
-    expect(result.get("web/components/Bar.tsx")?.get(10)).toBe(2);
-  });
-
-  it("strips provided prefix from absolute paths", () => {
-    const result = parseLcov(ABSOLUTE_LCOV, ["/home/runner/work/repo/repo/"]);
-    expect(result.has("web/lib/api/client.mts")).toBe(true);
-    expect(result.get("web/lib/api/client.mts")?.get(5)).toBe(1);
-  });
-
-  it("normalizes Windows backslash separators", () => {
-    const result = parseLcov(WINDOWS_LCOV);
-    expect(result.has("backend/services/foo.mts")).toBe(true);
-  });
-
-  it("strips leading ./ from SF paths", () => {
-    const lcov = `SF:./web/components/Baz.tsx\nDA:1,1\nend_of_record\n`;
-    const result = parseLcov(lcov);
-    expect(result.has("web/components/Baz.tsx")).toBe(true);
-  });
-
-  it("handles missing end_of_record gracefully", () => {
-    const lcov = `SF:web/foo.mts\nDA:1,1\n`;
-    const result = parseLcov(lcov);
-    expect(result.get("web/foo.mts")?.get(1)).toBe(1);
-  });
-
-  it("sums hits when the same file appears multiple times (shard merge)", () => {
-    const lcov = `
-SF:web/components/Foo.tsx
-DA:1,2
-end_of_record
-SF:web/components/Foo.tsx
-DA:1,3
-DA:2,1
-end_of_record
-`;
-    const result = parseLcov(lcov);
-    expect(result.get("web/components/Foo.tsx")?.get(1)).toBe(5);
-    expect(result.get("web/components/Foo.tsx")?.get(2)).toBe(1);
-  });
-
-  it("skips DA lines with malformed content (no comma)", () => {
-    const lcov = `SF:web/foo.mts\nDA:badline\nDA:1,1\nend_of_record\n`;
-    const result = parseLcov(lcov);
-    expect(result.get("web/foo.mts")?.get(1)).toBe(1);
-    expect(result.get("web/foo.mts")?.size).toBe(1);
-  });
-
-  it("skips DA lines with non-finite values", () => {
-    const lcov = `SF:web/foo.mts\nDA:NaN,1\nDA:1,1\nend_of_record\n`;
-    const result = parseLcov(lcov);
-    expect(result.get("web/foo.mts")?.get(1)).toBe(1);
-  });
-});

package/src/load-artifacts.mts

@@ -1,42 +0,0 @@
-import { readdirSync } from "node:fs";
-import { join } from "node:path";
-
-/** Recursively collects all lcov.info files under the given directory. */
-export function collectLcovFiles(dir: string): string[] {
-  const results: string[] = [];
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...collectLcovFiles(full));
-      } else if (entry.name === "lcov.info") {
-        results.push(full);
-      }
-    }
-  } catch (err) {
-    /* c8 ignore next */
-    if ((err as NodeJS.ErrnoException).code !== "ENOENT")
-      /* c8 ignore next */
-      process.stderr.write(
-        `coverage-check: unexpected error reading artifacts directory ${dir}: ${err}\n`,
-      );
-    // ENOENT: directory does not exist — no artifacts
-  }
-  return results;
-}
-
-/**
- * Builds the list of path prefixes to strip from LCOV SF: lines.
- *
- * Defaults: $GITHUB_WORKSPACE (if set) and cwd are always prepended.
- * Additional prefixes can be passed via the `extra` parameter.
- */
-export function buildStripPrefixes(extra: string[] = []): string[] {
-  const prefixes: string[] = extra.map((p) => (p.endsWith("/") ? p : `${p}/`));
-  const ws = process.env["GITHUB_WORKSPACE"];
-  if (ws) prefixes.push(ws.endsWith("/") ? ws : `${ws}/`);
-  const cwd = process.cwd();
-  /* c8 ignore next -- process.cwd() virtually never returns a trailing-slash path */
-  prefixes.push(cwd.endsWith("/") ? cwd : `${cwd}/`);
-  return prefixes;
-}

package/src/load-artifacts.test.mts

@@ -1,115 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { collectLcovFiles, buildStripPrefixes } from "./load-artifacts.mts";
-
-describe("collectLcovFiles", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "load-artifacts-"));
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("returns empty array for missing directory (ENOENT silenced)", () => {
-    expect(collectLcovFiles(join(tmpDir, "nonexistent"))).toEqual([]);
-  });
-
-  it("returns empty array for empty directory", () => {
-    expect(collectLcovFiles(tmpDir)).toEqual([]);
-  });
-
-  it("finds lcov.info at the top level", () => {
-    writeFileSync(join(tmpDir, "lcov.info"), "");
-    const results = collectLcovFiles(tmpDir);
-    expect(results).toHaveLength(1);
-    expect(results[0]).toContain("lcov.info");
-  });
-
-  it("ignores non-lcov.info files", () => {
-    writeFileSync(join(tmpDir, "coverage.json"), "");
-    writeFileSync(join(tmpDir, "lcov.txt"), "");
-    expect(collectLcovFiles(tmpDir)).toHaveLength(0);
-  });
-
-  it("recursively finds lcov.info in subdirectories", () => {
-    const sub1 = join(tmpDir, "backend");
-    const sub2 = join(tmpDir, "backend", "nested");
-    mkdirSync(sub2, { recursive: true });
-    writeFileSync(join(sub1, "lcov.info"), "");
-    writeFileSync(join(sub2, "lcov.info"), "");
-    const results = collectLcovFiles(tmpDir);
-    expect(results).toHaveLength(2);
-  });
-
-  it("finds lcov.info in multiple sibling subdirectories", () => {
-    mkdirSync(join(tmpDir, "backend"));
-    mkdirSync(join(tmpDir, "frontend"));
-    writeFileSync(join(tmpDir, "backend", "lcov.info"), "");
-    writeFileSync(join(tmpDir, "frontend", "lcov.info"), "");
-    expect(collectLcovFiles(tmpDir)).toHaveLength(2);
-  });
-});
-
-describe("buildStripPrefixes", () => {
-  it("always includes cwd as a suffix-slash prefix", () => {
-    const prefixes = buildStripPrefixes();
-    const cwd = process.cwd();
-    const expected = cwd.endsWith("/") ? cwd : `${cwd}/`;
-    expect(prefixes).toContain(expected);
-  });
-
-  it("includes GITHUB_WORKSPACE when set", () => {
-    const origWs = process.env["GITHUB_WORKSPACE"];
-    process.env["GITHUB_WORKSPACE"] = "/home/runner/work/repo";
-    try {
-      const prefixes = buildStripPrefixes();
-      expect(prefixes.some((p) => p.startsWith("/home/runner/work/repo"))).toBe(true);
-    } finally {
-      if (origWs === undefined) {
-        delete process.env["GITHUB_WORKSPACE"];
-      } else {
-        process.env["GITHUB_WORKSPACE"] = origWs;
-      }
-    }
-  });
-
-  it("does not include github workspace prefix when env var is absent", () => {
-    const origWs = process.env["GITHUB_WORKSPACE"];
-    delete process.env["GITHUB_WORKSPACE"];
-    try {
-      const prefixes = buildStripPrefixes();
-      // Only cwd and extra prefixes should be present
-      expect(prefixes).toHaveLength(1);
-    } finally {
-      if (origWs !== undefined) {
-        process.env["GITHUB_WORKSPACE"] = origWs;
-      }
-    }
-  });
-
-  it("normalizes extra prefixes to end with /", () => {
-    const prefixes = buildStripPrefixes(["/some/path", "/other/path/"]);
-    expect(prefixes[0]).toBe("/some/path/");
-    expect(prefixes[1]).toBe("/other/path/");
-  });
-
-  it("includes GITHUB_WORKSPACE with trailing slash when it already ends with /", () => {
-    const origWs = process.env["GITHUB_WORKSPACE"];
-    process.env["GITHUB_WORKSPACE"] = "/home/runner/work/repo/";
-    try {
-      const prefixes = buildStripPrefixes();
-      expect(prefixes.some((p) => p === "/home/runner/work/repo/")).toBe(true);
-    } finally {
-      if (origWs === undefined) {
-        delete process.env["GITHUB_WORKSPACE"];
-      } else {
-        process.env["GITHUB_WORKSPACE"] = origWs;
-      }
-    }
-  });
-});

package/src/patch-coverage.mts

@@ -1,82 +0,0 @@
-import type {
-  BucketResult,
-  CoverageRule,
-  DiffLines,
-  FileCoverageResult,
-  LcovData,
-} from "./types.mts";
-import { matchRule } from "./rules.mts";
-
-export function computePatchCoverage(
-  diff: DiffLines,
-  lcov: LcovData,
-  rules: CoverageRule[],
-): { buckets: BucketResult[]; informational: FileCoverageResult[] } {
-  const bucketMap = new Map<string, BucketResult>();
-  const informational: FileCoverageResult[] = [];
-
-  for (const [file, changedLineSet] of diff) {
-    const fileLines = lcov.get(file);
-    if (fileLines === undefined) continue; // not in lcov scope — skip
-
-    const coverable: number[] = [];
-    const uncoveredLines: number[] = [];
-    let hit = 0;
-
-    for (const lineNo of changedLineSet) {
-      if (!fileLines.has(lineNo)) continue; // line not tracked by coverage
-      coverable.push(lineNo);
-      if (fileLines.get(lineNo)! > 0) {
-        hit++;
-      } else {
-        uncoveredLines.push(lineNo);
-      }
-    }
-
-    if (coverable.length === 0) continue;
-
-    const rule = matchRule(file, rules);
-    const fileResult: FileCoverageResult = {
-      file,
-      coverable: coverable.length,
-      hit,
-      uncoveredLines: uncoveredLines.sort((a, b) => a - b),
-      rule: rule?.paths ?? null,
-    };
-
-    if (rule === null) {
-      informational.push(fileResult);
-      continue;
-    }
-
-    let bucket = bucketMap.get(rule.paths);
-    if (bucket === undefined) {
-      bucket = {
-        rule: rule.paths,
-        threshold: rule.patch_coverage_min,
-        coverable: 0,
-        hit: 0,
-        files: [],
-        passed: true,
-      };
-      bucketMap.set(rule.paths, bucket);
-    }
-
-    bucket.coverable += coverable.length;
-    bucket.hit += hit;
-    bucket.files.push(fileResult);
-  }
-
-  const buckets = [...bucketMap.values()];
-  for (const bucket of buckets) {
-    /* c8 ignore next -- bucket always has coverable>0 (L36 guard prevents empty-coverable files from reaching bucketMap) */
-    if (bucket.coverable === 0) {
-      bucket.passed = true;
-    } else {
-      const pct = (bucket.hit / bucket.coverable) * 100;
-      bucket.passed = pct >= bucket.threshold;
-    }
-  }
-
-  return { buckets, informational };
-}