coverage-check 0.2.1 → 0.2.2

package/src/commands/store-put.mts

@@ -1,115 +0,0 @@
-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 { makeStore } from "../store-factory.mts";
-import { assertSafePathComponent } from "../suite-store.mts";
-import type { SuiteStore } 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: SuiteStore;
-  artifacts: string;
-  stripPrefixes: string[];
-  sha: string;
-  branch: string;
-};
-
-function parseArgs(argv: string[]): StorePutArgs {
-  let storeFs: string | null = null;
-  let storeS3: string | null = null;
-  const args = {
-    suite: "",
-    artifacts: "./coverage-artifacts",
-    stripPrefixes: [] as string[],
-    sha: "",
-    branch: "",
-  };
-
-  for (let i = 0; i < argv.length; i++) {
-    const flag = argv[i]!;
-    const next = argv[i + 1];
-    const val = (): string => {
-      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");
-  if (!args.sha) throw new Error("--sha is required");
-  if (!args.branch) throw new Error("--branch is required");
-  assertSafePathComponent(args.suite, "suite");
-  assertSafePathComponent(args.sha, "sha");
-  assertSafePathComponent(args.branch, "branch");
-
-  const store = makeStore({ fs: storeFs, s3: storeS3 })!;
-  return { ...args, store };
-}
-
-export async function main(argv: string[]): Promise<number> {
-  let args: StorePutArgs;
-  try {
-    args = parseArgs(argv);
-  } catch (err) {
-    stderr(`coverage-check store-put: ${String(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);
-
-  await args.store.put(args.suite, Buffer.from(lcovText, "utf8"), {
-    sha: args.sha,
-    branch: args.branch,
-  });
-
-  stdout(
-    `coverage-check store-put: stored suite "${args.suite}" (${lcovFiles.length} file(s)) sha=${args.sha} branch=${args.branch}`,
-  );
-  return 0;
-}

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

@@ -1,248 +0,0 @@
-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, vi } 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", "--sha", "abc", "--branch", "main"])).toBe(2);
-  });
-
-  it("returns 2 when --store is missing", async () => {
-    expect(await main(["--suite", "backend", "--sha", "abc", "--branch", "main"])).toBe(2);
-  });
-
-  it("returns 2 when --sha is missing", async () => {
-    expect(await main(["--suite", "backend", "--store", "/tmp/s", "--branch", "main"])).toBe(2);
-  });
-
-  it("returns 2 when --branch is missing", async () => {
-    expect(await main(["--suite", "backend", "--store", "/tmp/s", "--sha", "abc"])).toBe(2);
-  });
-
-  it("returns 2 when a flag token follows as the value (e.g. --suite --store)", async () => {
-    expect(await main(["--suite", "--store"])).toBe(2);
-  });
-
-  it("accepts --store-s3 flag (returns 2 when no lcov files, not unknown-flag error)", async () => {
-    const chunks: string[] = [];
-    vi.spyOn(process.stderr, "write").mockImplementation((c: unknown) => {
-      chunks.push(String(c));
-      return true;
-    });
-    try {
-      expect(
-        await main([
-          "--suite",
-          "backend",
-          "--store-s3",
-          "my-bucket/prefix",
-          "--sha",
-          "abc",
-          "--branch",
-          "main",
-          "--artifacts",
-          "/tmp/__nonexistent_dir__",
-        ]),
-      ).toBe(2);
-      const stderr = chunks.join("");
-      expect(stderr).toContain("no lcov.info files found");
-      expect(stderr).not.toContain("unknown flag");
-    } finally {
-      vi.restoreAllMocks();
-    }
-  });
-
-  it("returns 2 when both --store-fs and --store-s3 are provided", async () => {
-    expect(
-      await main([
-        "--suite",
-        "backend",
-        "--store-fs",
-        "/tmp/s",
-        "--store-s3",
-        "bucket",
-        "--sha",
-        "abc",
-        "--branch",
-        "main",
-      ]),
-    ).toBe(2);
-  });
-
-  it("returns 2 on unknown flag", async () => {
-    expect(
-      await main([
-        "--suite",
-        "backend",
-        "--store",
-        "/tmp/s",
-        "--sha",
-        "abc",
-        "--branch",
-        "main",
-        "--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;
-  let store: FileSystemSuiteStore;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "store-put-test-"));
-    artifactsDir = join(tmpDir, "artifacts");
-    storeDir = join(tmpDir, "store");
-    mkdirSync(artifactsDir);
-    mkdirSync(storeDir);
-    store = new FileSystemSuiteStore(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,
-        artifacts: artifactsDir,
-        stripPrefixes: [],
-        sha: "abc123",
-        branch: "main",
-      }),
-    ).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,
-        artifacts: artifactsDir,
-        stripPrefixes: [],
-        sha: "abc123",
-        branch: "main",
-      }),
-    ).toBe(0);
-
-    const suites = await store.list();
-    expect(suites).toContain("backend");
-
-    const buf = await store.get("backend", { branch: "main" });
-    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,
-        artifacts: artifactsDir,
-        stripPrefixes: [],
-        sha: "abc123",
-        branch: "main",
-      }),
-    ).toBe(0);
-
-    const buf = await store.get("backend", { branch: "main" });
-    const lcovText = buf!.toString();
-    expect(lcovText).toContain("SF:backend/a.mts");
-    expect(lcovText).toContain("SF:backend/b.mts");
-  });
-
-  it("accepts --strip-prefix flag via main()", 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",
-        "--sha",
-        "abc123",
-        "--branch",
-        "main",
-      ]),
-    ).toBe(0);
-
-    const buf = await store.get("backend", { branch: "main" });
-    expect(buf!.toString()).toContain("SF:backend/foo.mts");
-  });
-
-  it("--store-fs is an alias for --store", async () => {
-    writeFileSync(join(artifactsDir, "lcov.info"), "SF:web/app.tsx\nDA:10,1\nend_of_record\n");
-
-    expect(
-      await main([
-        "--suite",
-        "frontend",
-        "--store-fs",
-        storeDir,
-        "--artifacts",
-        artifactsDir,
-        "--sha",
-        "deadbeef",
-        "--branch",
-        "main",
-      ]),
-    ).toBe(0);
-
-    const stored = readFileSync(join(storeDir, "frontend", "sha", "deadbeef", "lcov.info"), "utf8");
-    expect(stored).toContain("SF:web/app.tsx");
-  });
-
-  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",
-        "--branch",
-        "main",
-      ]),
-    ).toBe(0);
-
-    const stored = readFileSync(join(storeDir, "frontend", "sha", "deadbeef", "lcov.info"), "utf8");
-    expect(stored).toContain("SF:web/app.tsx");
-  });
-});

package/src/diff-parser.mts

@@ -1,127 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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");
-  });
-});