pr-shepherd 0.2.0 → 0.3.0

package/dist/merge-status/derive.mjs

@@ -0,0 +1,72 @@
+/**
+ * Derives a shepherd `MergeStatusResult` from raw PR data.
+ *
+ * `pr.state` is passed through unchanged; `iterate` handles the cancel action
+ * for non-OPEN (merged/closed) PRs — this function does not branch on it.
+ *
+ * Interpretation order for `status` — first match wins:
+ *   1. mergeable == CONFLICTING       → CONFLICTS
+ *   2. mergeStateStatus DIRTY         → CONFLICTS (GitHub merge conflicts)
+ *   3. copilotReviewInProgress        → BLOCKED
+ *   4. mergeStateStatus BEHIND        → BEHIND
+ *   5. mergeStateStatus BLOCKED / HAS_HOOKS → BLOCKED
+ *   6. mergeStateStatus UNSTABLE      → UNSTABLE
+ *   7. isDraft                        → DRAFT
+ *   8. mergeStateStatus UNKNOWN       → UNKNOWN
+ *   9. mergeStateStatus CLEAN         → CLEAN
+ */
+import { loadConfig } from "../config/load.mjs";
+export function deriveMergeStatus(pr) {
+    const copilotReviewInProgress = detectCopilotReview(pr);
+    let status;
+    if (pr.mergeable === "CONFLICTING") {
+        status = "CONFLICTS";
+    }
+    else if (copilotReviewInProgress) {
+        status = "BLOCKED";
+    }
+    else if (pr.mergeStateStatus === "DIRTY") {
+        // DIRTY means GitHub detected merge conflicts in the branch.
+        status = "CONFLICTS";
+    }
+    else if (pr.mergeStateStatus === "BEHIND") {
+        status = "BEHIND";
+    }
+    else if (pr.mergeStateStatus === "BLOCKED" || pr.mergeStateStatus === "HAS_HOOKS") {
+        status = "BLOCKED";
+    }
+    else if (pr.mergeStateStatus === "UNSTABLE") {
+        status = "UNSTABLE";
+    }
+    else if (pr.isDraft || pr.mergeStateStatus === "DRAFT") {
+        status = "DRAFT";
+    }
+    else if (pr.mergeStateStatus === "UNKNOWN") {
+        status = "UNKNOWN";
+    }
+    else {
+        status = "CLEAN";
+    }
+    return {
+        status,
+        state: pr.state,
+        isDraft: pr.isDraft,
+        mergeable: pr.mergeable,
+        reviewDecision: pr.reviewDecision,
+        copilotReviewInProgress,
+        mergeStateStatus: pr.mergeStateStatus,
+    };
+}
+// ---------------------------------------------------------------------------
+// Copilot review detection
+// ---------------------------------------------------------------------------
+function detectCopilotReview(pr) {
+    // A blocking bot review is "in progress" when:
+    //   1. Any reviewRequest has a login starting with one of the configured prefixes, OR
+    //   2. Any latestReview has such a login AND state == "PENDING"
+    const prefixes = loadConfig().mergeStatus.blockingReviewerLogins.map((l) => l.toLowerCase());
+    const isBlocking = (login) => prefixes.some((p) => login.toLowerCase().startsWith(p));
+    const requested = pr.reviewRequests.some((r) => isBlocking(r.login));
+    const pendingReview = pr.latestReviews.some((r) => isBlocking(r.login) && r.state === "PENDING");
+    return requested || pendingReview;
+}

package/dist/reporters/agent.mjs

@@ -0,0 +1,41 @@
+/**
+ * Projections for the agent-facing iterate output.
+ *
+ * These strip fields that are always-false by the time items reach iterate
+ * (isResolved, isOutdated, isMinimized, createdAtUnix) and metadata that the
+ * monitor prompt never reads (detailsUrl, event, status, conclusion, category,
+ * logExcerpt). The original domain types are preserved for check command output.
+ */
+export function toAgentThread(t) {
+    return { id: t.id, path: t.path, line: t.line, author: t.author, body: t.body };
+}
+export function toAgentComment(c) {
+    return { id: c.id, author: c.author, body: c.body };
+}
+export function toAgentCheck(c) {
+    return { name: c.name, runId: c.runId, detailsUrl: c.detailsUrl, failureKind: c.failureKind };
+}
+/**
+ * Project and deduplicate checks so the agent makes one `gh run view` call
+ * per run (dedup by runId) and skips duplicate external status checks (dedup
+ * by name when runId is null).
+ */
+export function toAgentChecks(checks) {
+    const seenRunIds = new Set();
+    const seenNames = new Set();
+    const result = [];
+    for (const c of checks) {
+        if (c.runId !== null) {
+            if (seenRunIds.has(c.runId))
+                continue;
+            seenRunIds.add(c.runId);
+        }
+        else {
+            if (seenNames.has(c.name))
+                continue;
+            seenNames.add(c.name);
+        }
+        result.push(toAgentCheck(c));
+    }
+    return result;
+}

package/{src/reporters/json.mts → dist/reporters/json.mjs}

@@ -4,9 +4,6 @@
  * Slash commands parse this output to extract IDs, status, and actionable items
  * without string-scraping the human-readable text reporter.
  */
-
-import type { ShepherdReport } from "../types.mts";
-
-export function formatJson(report: ShepherdReport): string {
-  return JSON.stringify(report, null, 2);
+export function formatJson(report) {
+    return JSON.stringify(report, null, 2);
 }

package/dist/reporters/text.mjs

@@ -0,0 +1,111 @@
+/**
+ * Human-readable text reporter for shepherd check output.
+ */
+export function formatText(report) {
+    const lines = [];
+    // Header
+    lines.push(`\nPR #${report.pr} — ${report.repo}`);
+    lines.push(`Status: ${report.status}`);
+    lines.push("");
+    // Merge status
+    const ms = report.mergeStatus;
+    lines.push(`Merge Status: ${ms.status}`);
+    lines.push(`  mergeStateStatus:       ${ms.mergeStateStatus}`);
+    lines.push(`  mergeable:              ${ms.mergeable}`);
+    lines.push(`  reviewDecision:         ${ms.reviewDecision ?? "(none)"}`);
+    lines.push(`  isDraft:                ${ms.isDraft}`);
+    lines.push(`  copilotReviewInProgress:${ms.copilotReviewInProgress}`);
+    lines.push("");
+    // CI checks
+    const { passing, failing, inProgress, skipped } = report.checks;
+    const total = passing.length + failing.length + inProgress.length + skipped.length;
+    lines.push(`CI Checks: ${passing.length}/${total} passed`);
+    if (failing.length > 0) {
+        lines.push(`\nFailed Checks (${failing.length}):`);
+        for (const c of failing) {
+            const triaged = c;
+            const kind = triaged.failureKind ? ` [${triaged.failureKind}]` : "";
+            lines.push(`  - ${c.name}${kind}: ${c.conclusion ?? c.status}`);
+            if (triaged.logExcerpt) {
+                lines.push(indent(triaged.logExcerpt.split("\n").slice(-10).join("\n"), "    "));
+            }
+        }
+    }
+    if (inProgress.length > 0) {
+        lines.push(`\nIn Progress (${inProgress.length}):`);
+        for (const c of inProgress) {
+            lines.push(`  - ${c.name}: ${c.status}`);
+        }
+    }
+    if (skipped.length > 0) {
+        lines.push(`\nSkipped (${skipped.length}): ${skipped.map((c) => c.name).join(", ")}`);
+    }
+    if (report.checks.filtered.length > 0) {
+        lines.push(`\nFiltered (non-PR-trigger) (${report.checks.filtered.length}): ${report.checks.filtered.map((c) => c.name).join(", ")}`);
+        if (report.checks.blockedByFilteredCheck) {
+            lines.push("  Note: PR is BLOCKED and all filtered checks are non-PR-trigger — one of these filtered checks may be a required status check blocking merge.");
+        }
+        else if (report.mergeStatus.status === "BLOCKED") {
+            lines.push("  Note: one or more of these filtered checks may be a required status check blocking merge.");
+        }
+    }
+    lines.push("");
+    // Review threads
+    const { actionable: actionableThreads, autoResolved, autoResolveErrors } = report.threads;
+    if (autoResolved.length > 0) {
+        lines.push(`Auto-resolved outdated threads (${autoResolved.length}):`);
+        for (const t of autoResolved) {
+            lines.push(`  - threadId=${t.id} ${t.path ?? ""}:${t.line ?? "?"} (@${t.author})`);
+        }
+        lines.push("");
+    }
+    if (autoResolveErrors.length > 0) {
+        lines.push(`Auto-resolve errors (${autoResolveErrors.length}):`);
+        for (const e of autoResolveErrors) {
+            lines.push(`  - ${e}`);
+        }
+        lines.push("");
+    }
+    if (actionableThreads.length > 0) {
+        lines.push(`Actionable Review Threads (${actionableThreads.length}):`);
+        for (const t of actionableThreads) {
+            const label = t.path ? `${t.path}:${t.line ?? "?"}` : "(general)";
+            lines.push(`  - threadId=${t.id} ${label} (@${t.author})`);
+            lines.push(`    ${firstLine(t.body)}`);
+        }
+        lines.push("");
+    }
+    // PR comments
+    const { actionable: actionableComments } = report.comments;
+    if (actionableComments.length > 0) {
+        lines.push(`Actionable PR Comments (${actionableComments.length}):`);
+        for (const c of actionableComments) {
+            lines.push(`  - commentId=${c.id} (@${c.author}): ${firstLine(c.body)}`);
+        }
+        lines.push("");
+    }
+    // CHANGES_REQUESTED reviews
+    if (report.changesRequestedReviews.length > 0) {
+        lines.push(`Pending CHANGES_REQUESTED reviews (${report.changesRequestedReviews.length}):`);
+        for (const r of report.changesRequestedReviews) {
+            lines.push(`  - reviewId=${r.id} (@${r.author}): ${firstLine(r.body)}`);
+        }
+        lines.push("");
+    }
+    // Summary
+    const totalActionable = actionableThreads.length + actionableComments.length + report.changesRequestedReviews.length;
+    lines.push(`Summary: ${totalActionable === 0 ? "0 actionable — all threads resolved/minimized" : `${totalActionable} actionable item(s) remaining`}`);
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function firstLine(text) {
+    return (text.split("\n")[0] ?? "").trim().slice(0, 120);
+}
+function indent(text, prefix) {
+    return text
+        .split("\n")
+        .map((l) => prefix + l)
+        .join("\n");
+}

package/dist/types.mjs

@@ -0,0 +1,2 @@
+/** Shared type definitions for the shepherd CLI. */
+export {};

package/package.json

@@ -1,17 +1,15 @@
 {
   "name": "pr-shepherd",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Autonomous PR CI monitor and review-comment resolver for Claude Code",
   "license": "MIT",
   "author": "Jonathan Ong",
   "type": "module",
   "bin": {
-    "pr-shepherd": "./src/index.mts"
+    "pr-shepherd": "./dist/index.mjs"
   },
   "files": [
-    "src/**/*.mts",
-    "src/**/*.json",
-    "src/**/*.gql",
+    "dist/**",
     "skills/**",
     ".claude-plugin/**",
     "marketplace.json",
@@ -33,7 +31,9 @@
     "@vitest/coverage-v8": "^4.1.4"
   },
   "scripts": {
-    "prepublishOnly": "npm run typecheck && npm test",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp src/config.json dist/ && mkdir -p dist/github && cp -r src/github/gql dist/github/",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint src/ skills/",
     "format": "oxfmt src/ skills/ docs/ README.md",

package/skills/check/SKILL.md

@@ -3,7 +3,7 @@ name: check
 description: "Check GitHub CI status and review comments for the current PR"
 argument-hint: "[PR number or URL ...]"
 user-invocable: true
-allowed-tools: ["Bash", "Read", "Grep"]
+allowed-tools: ["Bash"]
 ---
 
 # pr-shepherd check — PR Status

package/skills/monitor/SKILL.md

@@ -76,11 +76,15 @@ Parse the `action` field and act:
   After fixing manually, rerun /pr-shepherd:monitor <PR> to resume.
 
 - `fix_code` → do the following, then stop this iteration (CI needs time):
-  1. For each item in `fix.threads`, `fix.comments`, `fix.checks`, and `fix.changesRequestedReviews`: read the referenced file/line and apply the fix (Edit/Write tools).
-  2. If files were changed, `git add <files> && git commit -m "<appropriate commit message>"`
-  3. `git fetch origin && git rebase origin/<BASE_BRANCH> && git push --force-with-lease` (dangerouslyDisableSandbox: true)
-  4. `HEAD_SHA=$(git rev-parse HEAD)`
-  5. `npx pr-shepherd resolve <PR_NUMBER> --resolve-thread-ids <IDs> --minimize-comment-ids <IDs> --dismiss-review-ids <IDs> --message "address review comments" --require-sha "$HEAD_SHA"` (dangerouslyDisableSandbox: true). Omit any flag whose ID list is empty.
+  1. For each item in `fix.threads` and `fix.comments`: read the referenced file/line and apply the fix (Edit/Write tools).
+  2. For each item in `fix.checks`:
+     - If `runId` is non-null: fetch the failure log with `gh run view <runId> --log-failed` (dangerouslyDisableSandbox: true), scan the output to identify the failure (e.g. grep for `FAIL` for test failures, `error:` for type/compile errors, lint rule names for lint failures), then read the relevant file and apply the fix (Edit/Write tools).
+     - If `runId` is null: the failed check is an external status check that cannot be inspected via run logs. Escalate — tell the user to open `detailsUrl` in the PR checks UI, inspect the failure manually, and rerun `/pr-shepherd:monitor 13` after addressing it. Do not attempt to fix these automatically.
+  3. For each item in `fix.changesRequestedReviews`: read the review body and apply the requested changes.
+  4. If files were changed, `git add <files> && git commit -m "<appropriate commit message>"`
+  5. `git fetch origin && git rebase origin/<BASE_BRANCH> && git push --force-with-lease` (dangerouslyDisableSandbox: true)
+  6. `HEAD_SHA=$(git rev-parse HEAD)`
+  7. `npx pr-shepherd resolve <PR_NUMBER> --resolve-thread-ids <IDs> --minimize-comment-ids <IDs> --dismiss-review-ids <IDs> --message "address review comments" --require-sha "$HEAD_SHA"` (dangerouslyDisableSandbox: true). Omit any flag whose ID list is empty.
 
 ````
 

package/src/cache/file-cache.mts

@@ -1,101 +0,0 @@
-/**
- * Simple filesystem-based cache for shepherd batch reads.
- *
- * Cache entries live in `${TMPDIR}/pr-shepherd-cache/<owner>-<repo>/<pr>/<shape>.json`.
- * TTL defaults to 5 minutes (configurable via PR_SHEPHERD_CACHE_TTL_SECONDS or --cache-ttl).
- *
- * Mutations are never cached — this module is read-path only.
- */
-
-import { readFile, writeFile, rename, mkdir, stat } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { loadConfig } from "../config/load.mts";
-import { SAFE_SEGMENT } from "../util/path-segment.mts";
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export interface CacheOptions {
-  ttlSeconds?: number;
-  disabled?: boolean;
-}
-
-/**
- * Read a value from the cache. Returns null on miss or expiry.
- */
-export async function cacheGet<T>(key: CacheKey, opts: CacheOptions = {}): Promise<T | null> {
-  if (opts.disabled) return null;
-
-  const ttl = opts.ttlSeconds ?? ttlFromEnv() ?? loadConfig().cache.ttlSeconds;
-  // A TTL of 0 (or negative) means "always expired" — skip the filesystem read entirely.
-  if (ttl <= 0) return null;
-
-  try {
-    const path = resolvePath(key);
-    const stats = await stat(path);
-    const ageSeconds = (Date.now() - stats.mtimeMs) / 1000;
-    if (ageSeconds >= ttl) return null;
-
-    const raw = await readFile(path, "utf8");
-    return JSON.parse(raw) as T;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Write a value to the cache (fire-and-forget — never throws).
- */
-export async function cacheSet<T>(key: CacheKey, value: T, opts: CacheOptions = {}): Promise<void> {
-  if (opts.disabled) return;
-
-  try {
-    const path = resolvePath(key);
-    const tmp = `${path}.${randomUUID()}.tmp`;
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(tmp, JSON.stringify(value), "utf8");
-    // Atomic rename — prevents a partial read if two processes write concurrently.
-    await rename(tmp, path);
-  } catch {
-    // Cache writes are best-effort.
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Cache key
-// ---------------------------------------------------------------------------
-
-export interface CacheKey {
-  owner: string;
-  repo: string;
-  pr: number;
-  shape: string;
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-function resolvePath(key: CacheKey): string {
-  for (const [field, value] of [
-    ["owner", key.owner],
-    ["repo", key.repo],
-    ["shape", key.shape],
-  ] as const) {
-    if (!SAFE_SEGMENT.test(value)) {
-      throw new Error(`Invalid cache key segment "${field}": ${value}`);
-    }
-  }
-  const base = process.env["PR_SHEPHERD_CACHE_DIR"] ?? join(tmpdir(), "pr-shepherd-cache");
-  return join(base, `${key.owner}-${key.repo}`, String(key.pr), `${key.shape}.json`);
-}
-
-function ttlFromEnv(): number | undefined {
-  const raw = process.env["PR_SHEPHERD_CACHE_TTL_SECONDS"];
-  if (!raw) return undefined;
-  const parsed = parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}

package/src/cache/file-cache.test.mts

@@ -1,91 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { randomBytes } from "node:crypto";
-import { rm } from "node:fs/promises";
-import { cacheGet, cacheSet, type CacheKey } from "./file-cache.mts";
-
-// Use a unique test prefix so runs never collide.
-function testKey(shape = "test"): CacheKey {
-  return {
-    owner: "test-owner",
-    repo: "test-repo",
-    pr: Math.floor(Math.random() * 900000) + 100000,
-    shape,
-  };
-}
-
-let testCacheDir: string;
-
-beforeEach(() => {
-  // Point cache at a temp subdir isolated per test run.
-  testCacheDir = `${process.env["TMPDIR"] ?? "/tmp"}/shepherd-test-${randomBytes(4).toString("hex")}`;
-  process.env["PR_SHEPHERD_CACHE_DIR"] = testCacheDir;
-});
-
-afterEach(async () => {
-  delete process.env["PR_SHEPHERD_CACHE_DIR"];
-  await rm(testCacheDir, { recursive: true, force: true });
-});
-
-describe("cacheGet / cacheSet", () => {
-  it("returns null on a cache miss", async () => {
-    const result = await cacheGet<string>(testKey());
-    expect(result).toBeNull();
-  });
-
-  it("returns the stored value on a cache hit", async () => {
-    const key = testKey();
-    const value = { foo: "bar", n: 42 };
-    await cacheSet(key, value);
-    const result = await cacheGet<typeof value>(key);
-    expect(result).toEqual(value);
-  });
-
-  it("returns null when the cache entry is expired", async () => {
-    const key = testKey();
-    await cacheSet(key, { data: "stale" });
-    // ttlSeconds=0 means the entry is immediately expired.
-    const result = await cacheGet(key, { ttlSeconds: 0 });
-    expect(result).toBeNull();
-  });
-
-  it("returns the value within TTL", async () => {
-    const key = testKey();
-    await cacheSet(key, "fresh");
-    const result = await cacheGet<string>(key, { ttlSeconds: 60 });
-    expect(result).toBe("fresh");
-  });
-
-  it("returns null when disabled", async () => {
-    const key = testKey();
-    await cacheSet(key, "should-not-be-returned", { disabled: false });
-    const result = await cacheGet(key, { disabled: true });
-    expect(result).toBeNull();
-  });
-
-  it("does not write when disabled", async () => {
-    const key = testKey();
-    await cacheSet(key, "ignored", { disabled: true });
-    const result = await cacheGet(key);
-    expect(result).toBeNull();
-  });
-
-  it("overwrites an existing cache entry", async () => {
-    const key = testKey();
-    await cacheSet(key, "first");
-    await cacheSet(key, "second");
-    const result = await cacheGet<string>(key);
-    expect(result).toBe("second");
-  });
-
-  it("handles different shapes as separate entries", async () => {
-    const pr = Math.floor(Math.random() * 900000) + 100000;
-    const keyA: CacheKey = { owner: "o", repo: "r", pr, shape: "shape-a" };
-    const keyB: CacheKey = { owner: "o", repo: "r", pr, shape: "shape-b" };
-
-    await cacheSet(keyA, "valueA");
-    await cacheSet(keyB, "valueB");
-
-    expect(await cacheGet<string>(keyA)).toBe("valueA");
-    expect(await cacheGet<string>(keyB)).toBe("valueB");
-  });
-});

package/src/cache/fix-attempts.mts

@@ -1,86 +0,0 @@
-/**
- * Persistent attempt counter for the iterate escalation guard.
- *
- * Tracks how many times each review thread has been dispatched to the fix_code
- * handler without being resolved. Counts are reset automatically when the HEAD
- * commit SHA changes (i.e. a new push landed).
- *
- * State lives in `$TMPDIR/pr-shepherd-cache/<owner>-<repo>/<pr>/fix-attempts.json`.
- */
-
-import { readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { SAFE_SEGMENT } from "../util/path-segment.mts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface FixAttemptsState {
-  /** HEAD SHA at the time the counts were last written. Reset key. */
-  headSha: string;
-  /** Map from thread ID → number of fix_code dispatches that included this thread. */
-  threadAttempts: Record<string, number>;
-}
-
-interface CacheKey {
-  owner: string;
-  repo: string;
-  pr: number;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/** Read the current attempt state. Returns null on miss. */
-export async function readFixAttempts(key: CacheKey): Promise<FixAttemptsState | null> {
-  try {
-    const raw = await readFile(resolvePath(key), "utf8");
-    return JSON.parse(raw) as FixAttemptsState;
-  } catch {
-    return null;
-  }
-}
-
-/** Write attempt state (fire-and-forget — never throws). */
-export async function writeFixAttempts(key: CacheKey, state: FixAttemptsState): Promise<void> {
-  let tmp: string | undefined;
-  try {
-    const path = resolvePath(key);
-    tmp = `${path}.${randomUUID()}.tmp`;
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(tmp, JSON.stringify(state), "utf8");
-    await rename(tmp, path);
-    tmp = undefined;
-  } catch {
-    // Best-effort.
-  } finally {
-    if (tmp !== undefined) {
-      try {
-        await unlink(tmp);
-      } catch {
-        // Best-effort cleanup.
-      }
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function resolvePath(key: CacheKey): string {
-  for (const [field, value] of [
-    ["owner", key.owner],
-    ["repo", key.repo],
-  ] as const) {
-    if (!SAFE_SEGMENT.test(value)) {
-      throw new Error(`Invalid cache key segment "${field}": ${value}`);
-    }
-  }
-  const base = process.env["PR_SHEPHERD_CACHE_DIR"] ?? join(tmpdir(), "pr-shepherd-cache");
-  return join(base, `${key.owner}-${key.repo}`, String(key.pr), "fix-attempts.json");
-}

package/src/checks/classify.mts

@@ -1,80 +0,0 @@
-/**
- * Classifies check runs into shepherd categories and filters out irrelevant ones.
- *
- * Rules:
- *   1. Skip checks whose workflow event is NOT `pull_request` or `pull_request_target`.
- *      Push-triggered, merge-queue, schedule, and workflow-dispatch runs are irrelevant
- *      to PR readiness.
- *   2. Drop checks with `conclusion == SKIPPED` or `conclusion == NEUTRAL` from the
- *      pass/fail tally. Report them as "skipped" for transparency but don't block on them.
- */
-
-import type { CheckRun, ClassifiedCheck } from "../types.mts";
-import { loadConfig } from "../config/load.mts";
-
-const RELEVANT_EVENTS = new Set(loadConfig().checks.ciTriggerEvents);
-
-/**
- * Classify a list of raw check runs into shepherd categories.
- *
- * @param checks Raw check runs from the batch query.
- * @returns Classified checks. "filtered" items were excluded from the tally.
- */
-export function classifyChecks(checks: CheckRun[]): ClassifiedCheck[] {
-  return checks.map((c) => classify(c));
-}
-
-function classify(check: CheckRun): ClassifiedCheck {
-  // Filter: runs from non-PR events don't count toward PR readiness.
-  if (check.event !== null && !RELEVANT_EVENTS.has(check.event)) {
-    return { ...check, category: "filtered" };
-  }
-
-  const { status, conclusion } = check;
-
-  // Not yet finished.
-  if (status !== "COMPLETED") {
-    return { ...check, category: "in_progress" };
-  }
-
-  // Skipped / neutral — report but don't block.
-  if (conclusion === "SKIPPED" || conclusion === "NEUTRAL") {
-    return { ...check, category: "skipped" };
-  }
-
-  // Success.
-  if (conclusion === "SUCCESS") {
-    return { ...check, category: "passed" };
-  }
-
-  // Everything else (FAILURE, TIMED_OUT, CANCELLED, ACTION_REQUIRED, STARTUP_FAILURE, STALE).
-  return { ...check, category: "failing" };
-}
-
-// ---------------------------------------------------------------------------
-// Aggregate verdict helpers
-// ---------------------------------------------------------------------------
-
-export interface CiVerdict {
-  /** True when all relevant (non-filtered, non-skipped) checks passed. */
-  allPassed: boolean;
-  /** True when at least one check is still running/queued. */
-  anyInProgress: boolean;
-  /** True when at least one check failed. */
-  anyFailing: boolean;
-  /** Names of checks that were filtered out (triggered by non-PR events). */
-  filteredNames: string[];
-}
-
-/** Compute a high-level CI verdict from a list of classified checks. */
-export function getCiVerdict(classified: ClassifiedCheck[]): CiVerdict {
-  const relevant = classified.filter((c) => c.category !== "filtered" && c.category !== "skipped");
-  const anyInProgress = relevant.some((c) => c.category === "in_progress");
-  const anyFailing = relevant.some((c) => c.category === "failing");
-  // When there are no relevant checks (e.g. docs-only PR where all checks are filtered/skipped),
-  // treat as allPassed rather than blocking — there's nothing to fail.
-  const allPassed = !anyInProgress && !anyFailing;
-  const filteredNames = classified.filter((c) => c.category === "filtered").map((c) => c.name);
-
-  return { allPassed, anyInProgress, anyFailing, filteredNames };
-}