pr-shepherd 0.2.0 → 0.3.0

package/src/checks/classify.test.mts

@@ -1,164 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { classifyChecks, getCiVerdict } from "./classify.mts";
-import type { CheckRun } from "../types.mts";
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-function makeCheck(overrides: Partial<CheckRun>): CheckRun {
-  return {
-    name: "tests",
-    status: "COMPLETED",
-    conclusion: "SUCCESS",
-    detailsUrl: "https://github.com/owner/repo/actions/runs/123/jobs/456",
-    event: "pull_request",
-    runId: "123",
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// classifyChecks
-// ---------------------------------------------------------------------------
-
-describe("classifyChecks — event filtering", () => {
-  it("keeps pull_request checks", () => {
-    const [c] = classifyChecks([makeCheck({ event: "pull_request" })]);
-    expect(c!.category).not.toBe("filtered");
-  });
-
-  it("keeps pull_request_target checks", () => {
-    const [c] = classifyChecks([makeCheck({ event: "pull_request_target" })]);
-    expect(c!.category).not.toBe("filtered");
-  });
-
-  it("filters push-triggered checks", () => {
-    const [c] = classifyChecks([makeCheck({ event: "push" })]);
-    expect(c!.category).toBe("filtered");
-  });
-
-  it("filters merge_group-triggered checks", () => {
-    const [c] = classifyChecks([makeCheck({ event: "merge_group" })]);
-    expect(c!.category).toBe("filtered");
-  });
-
-  it("filters schedule-triggered checks", () => {
-    const [c] = classifyChecks([makeCheck({ event: "schedule" })]);
-    expect(c!.category).toBe("filtered");
-  });
-
-  it("filters workflow_dispatch checks", () => {
-    const [c] = classifyChecks([makeCheck({ event: "workflow_dispatch" })]);
-    expect(c!.category).toBe("filtered");
-  });
-
-  it("keeps checks with null event (StatusContext nodes, no event available)", () => {
-    const [c] = classifyChecks([makeCheck({ event: null })]);
-    expect(c!.category).not.toBe("filtered");
-  });
-});
-
-describe("classifyChecks — conclusion mapping", () => {
-  it("classifies SUCCESS as passed", () => {
-    const [c] = classifyChecks([makeCheck({ conclusion: "SUCCESS" })]);
-    expect(c!.category).toBe("passed");
-  });
-
-  it("classifies SKIPPED as skipped", () => {
-    const [c] = classifyChecks([makeCheck({ conclusion: "SKIPPED" })]);
-    expect(c!.category).toBe("skipped");
-  });
-
-  it("classifies NEUTRAL as skipped", () => {
-    const [c] = classifyChecks([makeCheck({ conclusion: "NEUTRAL" })]);
-    expect(c!.category).toBe("skipped");
-  });
-
-  it("classifies FAILURE as failing", () => {
-    const [c] = classifyChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(c!.category).toBe("failing");
-  });
-
-  it("classifies TIMED_OUT as failing", () => {
-    const [c] = classifyChecks([makeCheck({ conclusion: "TIMED_OUT" })]);
-    expect(c!.category).toBe("failing");
-  });
-
-  it("classifies CANCELLED as failing", () => {
-    const [c] = classifyChecks([makeCheck({ conclusion: "CANCELLED" })]);
-    expect(c!.category).toBe("failing");
-  });
-
-  it("classifies ACTION_REQUIRED as failing", () => {
-    const [c] = classifyChecks([makeCheck({ conclusion: "ACTION_REQUIRED" })]);
-    expect(c!.category).toBe("failing");
-  });
-
-  it("classifies in-progress check (QUEUED) as in_progress", () => {
-    const [c] = classifyChecks([makeCheck({ status: "QUEUED", conclusion: null })]);
-    expect(c!.category).toBe("in_progress");
-  });
-
-  it("classifies in-progress check (IN_PROGRESS) as in_progress", () => {
-    const [c] = classifyChecks([makeCheck({ status: "IN_PROGRESS", conclusion: null })]);
-    expect(c!.category).toBe("in_progress");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getCiVerdict
-// ---------------------------------------------------------------------------
-
-describe("getCiVerdict", () => {
-  it("returns allPassed true when all relevant checks passed", () => {
-    const classified = classifyChecks([
-      makeCheck({ conclusion: "SUCCESS" }),
-      makeCheck({ name: "lint", conclusion: "SUCCESS" }),
-    ]);
-    const verdict = getCiVerdict(classified);
-    expect(verdict.allPassed).toBe(true);
-    expect(verdict.anyFailing).toBe(false);
-    expect(verdict.anyInProgress).toBe(false);
-  });
-
-  it("returns anyFailing when a check failed", () => {
-    const classified = classifyChecks([
-      makeCheck({ conclusion: "SUCCESS" }),
-      makeCheck({ name: "lint", conclusion: "FAILURE" }),
-    ]);
-    const verdict = getCiVerdict(classified);
-    expect(verdict.anyFailing).toBe(true);
-    expect(verdict.allPassed).toBe(false);
-  });
-
-  it("returns anyInProgress when a check is still running", () => {
-    const classified = classifyChecks([
-      makeCheck({ conclusion: "SUCCESS" }),
-      makeCheck({ name: "tests", status: "IN_PROGRESS", conclusion: null }),
-    ]);
-    const verdict = getCiVerdict(classified);
-    expect(verdict.anyInProgress).toBe(true);
-    expect(verdict.allPassed).toBe(false);
-  });
-
-  it("ignores filtered and skipped checks in the verdict", () => {
-    const classified = classifyChecks([
-      makeCheck({ event: "push", conclusion: "FAILURE" }), // filtered
-      makeCheck({ conclusion: "SKIPPED" }), // skipped
-      makeCheck({ name: "tests", conclusion: "SUCCESS" }), // passes
-    ]);
-    const verdict = getCiVerdict(classified);
-    expect(verdict.allPassed).toBe(true);
-    expect(verdict.anyFailing).toBe(false);
-  });
-
-  it("returns allPassed true when no relevant checks exist (e.g. docs-only PR)", () => {
-    // Only filtered checks — no relevant checks → allPassed true (nothing to fail).
-    const classified = classifyChecks([makeCheck({ event: "push", conclusion: "SUCCESS" })]);
-    const verdict = getCiVerdict(classified);
-    expect(verdict.allPassed).toBe(true);
-    expect(verdict.anyFailing).toBe(false);
-    expect(verdict.anyInProgress).toBe(false);
-  });
-});

package/src/checks/triage.mock.test.mts

@@ -1,202 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Hoist mock BEFORE any imports so node:child_process is replaced before
-// triage.mts captures a reference to execFile via promisify().
-// ---------------------------------------------------------------------------
-
-const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
-
-vi.mock("node:child_process", () => ({
-  execFile: (
-    _cmd: string,
-    _args: string[],
-    _opts: Record<string, unknown>,
-    cb: (err: Error | null, result: { stdout: string }) => void,
-  ) => {
-    // Simulate promisify-compatible callback shape.
-    mockExecFile(_cmd, _args, _opts)
-      .then((result: { stdout: string }) => cb(null, result))
-      .catch((err: Error) => cb(err, { stdout: "" }));
-  },
-}));
-
-import { triageFailingChecks } from "./triage.mts";
-import type { ClassifiedCheck } from "../types.mts";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeCheck(overrides: Partial<ClassifiedCheck> = {}): ClassifiedCheck {
-  return {
-    name: "tests",
-    status: "COMPLETED",
-    conclusion: "FAILURE",
-    detailsUrl: "https://github.com/owner/repo/actions/runs/99/jobs/1",
-    event: "pull_request",
-    runId: "run-99",
-    category: "failing",
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  mockExecFile.mockReset();
-});
-
-describe("triageFailingChecks — no runId", () => {
-  it("skips log fetch and returns actionable when runId is null", async () => {
-    const check = makeCheck({ runId: null });
-    const [result] = await triageFailingChecks([check]);
-    expect(result!.failureKind).toBe("actionable");
-    expect(mockExecFile).not.toHaveBeenCalled();
-  });
-});
-
-describe("triageFailingChecks — TIMED_OUT", () => {
-  it("returns timeout for TIMED_OUT conclusion regardless of logs", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "test output: all good\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "TIMED_OUT" })]);
-    expect(result!.failureKind).toBe("timeout");
-  });
-
-  it('returns timeout when logs contain "exceeded the maximum execution time"', async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Run exceeded the maximum execution time\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("timeout");
-  });
-
-  it('returns timeout when logs contain "cancel timeout"', async () => {
-    mockExecFile.mockResolvedValue({ stdout: "cancel timeout after 6 hours\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("timeout");
-  });
-
-  it('returns timeout when logs contain "job was cancelled"', async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Job was cancelled due to timeout\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
-    expect(result!.failureKind).toBe("timeout");
-  });
-});
-
-describe("triageFailingChecks — infrastructure", () => {
-  it("returns infrastructure for CANCELLED + runner error logs", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Runner error: the runner crashed\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
-    expect(result!.failureKind).toBe("infrastructure");
-  });
-
-  it("returns infrastructure for CANCELLED + ECONNRESET logs", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Error: ECONNRESET connection reset\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
-    expect(result!.failureKind).toBe("infrastructure");
-  });
-
-  it('returns infrastructure for CANCELLED + "lost communication with the server"', async () => {
-    mockExecFile.mockResolvedValue({
-      stdout: "The runner has lost communication with the server\n",
-    });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
-    expect(result!.failureKind).toBe("infrastructure");
-  });
-
-  it("returns infrastructure when gh run view fails (empty logs)", async () => {
-    mockExecFile.mockRejectedValue(new Error("exit 1"));
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("infrastructure");
-  });
-
-  it("returns infrastructure for blank logs even with FAILURE conclusion", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "   \n  \n  " });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("infrastructure");
-  });
-});
-
-describe("triageFailingChecks — flaky", () => {
-  it('returns flaky when logs contain "flaky"', async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Test is flaky: TestFooBar failed 1/3 runs\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("flaky");
-  });
-
-  it('returns flaky when logs contain "race condition"', async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Detected race condition in TestBar\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("flaky");
-  });
-
-  it('returns flaky when logs contain "retry"', async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Attempt 3/3 failed, no retry left\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("flaky");
-  });
-});
-
-describe("triageFailingChecks — actionable", () => {
-  it("returns actionable for compile errors", async () => {
-    mockExecFile.mockResolvedValue({
-      stdout: "error TS2345: Argument of type 'string' is not assignable\n",
-    });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("actionable");
-  });
-
-  it("returns actionable for test assertion failures", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "AssertionError: expected 42 to equal 43\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("actionable");
-  });
-
-  it("returns actionable for lint violations", async () => {
-    mockExecFile.mockResolvedValue({
-      stdout: "no-unused-vars: variable `foo` is defined but never used\n",
-    });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.failureKind).toBe("actionable");
-  });
-});
-
-describe("triageFailingChecks — logExcerpt", () => {
-  it("attaches logExcerpt for actionable failures", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "Error: test failed\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.logExcerpt).toBeDefined();
-    expect(result!.logExcerpt).toContain("Error: test failed");
-  });
-
-  it("truncates logExcerpt to 3000 chars", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "x".repeat(10_000) });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect((result!.logExcerpt?.length ?? 0) <= 3000).toBe(true);
-  });
-
-  it("strips ANSI escape codes from logs", async () => {
-    mockExecFile.mockResolvedValue({ stdout: "\u001B[31mERROR\u001B[0m: something failed\n" });
-    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
-    expect(result!.logExcerpt).not.toContain("\u001B");
-    expect(result!.logExcerpt).toContain("ERROR: something failed");
-  });
-});
-
-describe("triageFailingChecks — batch", () => {
-  it("triages multiple checks in parallel", async () => {
-    mockExecFile
-      .mockResolvedValueOnce({ stdout: "AssertionError: expected 1 to equal 2\n" })
-      .mockResolvedValueOnce({ stdout: "Runner error: crashed\n" });
-
-    const checks: ClassifiedCheck[] = [
-      makeCheck({ name: "tests", runId: "run-1", conclusion: "FAILURE" }),
-      makeCheck({ name: "build", runId: "run-2", conclusion: "CANCELLED" }),
-    ];
-    const results = await triageFailingChecks(checks);
-    expect(results).toHaveLength(2);
-    expect(results[0]!.failureKind).toBe("actionable");
-    expect(results[1]!.failureKind).toBe("infrastructure");
-  });
-});

package/src/checks/triage.mts

@@ -1,88 +0,0 @@
-/**
- * Triage failing check runs into four categories:
- *   - timeout: conclusion is TIMED_OUT or logs contain timeout markers.
- *   - infrastructure: conclusion is CANCELLED + infra-error log patterns.
- *   - actionable: compile error, test failure, lint violation from the PR's changes.
- *   - flaky: pre-existing or timing-dependent failures in untouched files.
- *
- * Shepherd computes and returns triage results, including `failureKind`, for
- * downstream callers or slash-command logic to consume.
- */
-
-import { execFile as execFileCb } from "node:child_process";
-import { promisify } from "node:util";
-import type { ClassifiedCheck, TriagedCheck, FailureKind } from "../types.mts";
-import { loadConfig } from "../config/load.mts";
-
-const execFile = promisify(execFileCb);
-
-const config = loadConfig();
-const TIMEOUT_PATTERNS = config.checks.timeoutPatterns.map((p) => new RegExp(p, "i"));
-const INFRA_PATTERNS = config.checks.infraPatterns.map((p) => new RegExp(p, "i"));
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Fetch logs and triage each failing check.
- *
- * Fetching logs is skipped for checks that have no `runId` (e.g. StatusContext nodes).
- */
-export function triageFailingChecks(failingChecks: ClassifiedCheck[]): Promise<TriagedCheck[]> {
-  return Promise.all(failingChecks.map((c) => triageCheck(c)));
-}
-
-// ---------------------------------------------------------------------------
-// Internal
-// ---------------------------------------------------------------------------
-
-async function triageCheck(check: ClassifiedCheck): Promise<TriagedCheck> {
-  if (check.runId === null) {
-    return { ...check, failureKind: "actionable" };
-  }
-
-  const logExcerpt = await fetchFailedLogs(check.runId);
-  const failureKind = classifyLogs(check, logExcerpt);
-
-  return {
-    ...check,
-    failureKind,
-    logExcerpt: logExcerpt.slice(-config.checks.logMaxChars) || undefined,
-  };
-}
-
-async function fetchFailedLogs(runId: string): Promise<string> {
-  try {
-    const { stdout } = await execFile("gh", ["run", "view", runId, "--log-failed"], {
-      maxBuffer: config.execution.triageLogBufferMb * 1024 * 1024,
-    });
-    // Strip ANSI escape codes.
-    // eslint-disable-next-line no-control-regex
-    const ansiEscapes = /\u001B\[[0-9;]*m/g;
-    return stdout.replace(ansiEscapes, "").split("\n").slice(-config.checks.logMaxLines).join("\n");
-  } catch {
-    return "";
-  }
-}
-
-function classifyLogs(check: ClassifiedCheck, logs: string): FailureKind {
-  // Timed out — check conclusion first, then logs.
-  if (check.conclusion === "TIMED_OUT") return "timeout";
-  if (TIMEOUT_PATTERNS.some((re) => re.test(logs))) return "timeout";
-
-  // Infrastructure error — typically CANCELLED with infra markers in logs.
-  if (check.conclusion === "CANCELLED" && INFRA_PATTERNS.some((re) => re.test(logs))) {
-    return "infrastructure";
-  }
-
-  // No logs at all — treat as infrastructure.
-  if (!logs.trim()) return "infrastructure";
-
-  // Heuristic: if the failure is in a file the PR likely didn't touch
-  // and the message contains "flaky" or timing language, call it flaky.
-  if (/flaky|timing|race condition|retry/i.test(logs)) return "flaky";
-
-  // Default: assume actionable.
-  return "actionable";
-}