pr-shepherd 0.2.0 → 0.4.0

package/src/github/pagination.test.mts

@@ -1,140 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { paginateForward, paginateBackward, type Connection } from "./pagination.mts";
-
-// ---------------------------------------------------------------------------
-// paginateForward
-// ---------------------------------------------------------------------------
-
-describe("paginateForward", () => {
-  it("collects all nodes across three pages", async () => {
-    const pages: Connection<string>[] = [
-      { pageInfo: { hasNextPage: true, endCursor: "cursor1" }, nodes: ["a", "b"] },
-      { pageInfo: { hasNextPage: true, endCursor: "cursor2" }, nodes: ["c"] },
-      { pageInfo: { hasNextPage: false, endCursor: null }, nodes: ["d", "e"] },
-    ];
-    const cursors: Array<string | null> = [];
-    let i = 0;
-
-    const result = await paginateForward((cursor) => {
-      cursors.push(cursor);
-      return Promise.resolve(pages[i++]!);
-    });
-
-    expect(result).toEqual(["a", "b", "c", "d", "e"]);
-    expect(cursors).toEqual([null, "cursor1", "cursor2"]);
-  });
-
-  it("stops after a single page when hasNextPage is false", async () => {
-    let calls = 0;
-    const result = await paginateForward(() => {
-      calls++;
-      return Promise.resolve({
-        pageInfo: { hasNextPage: false, endCursor: null },
-        nodes: ["x", "y"],
-      });
-    });
-
-    expect(result).toEqual(["x", "y"]);
-    expect(calls).toBe(1);
-  });
-
-  it("returns an empty array for an empty first page", async () => {
-    const result = await paginateForward(() =>
-      Promise.resolve({
-        pageInfo: { hasNextPage: false, endCursor: null },
-        nodes: [] as string[],
-      }),
-    );
-
-    expect(result).toEqual([]);
-  });
-
-  it("starts from initialCursor to avoid re-fetching the already-known page", async () => {
-    // Simulates the batch.mts use case: the initial query already returned page
-    // ending at 'cur-first'. paginateForward should start from that endCursor
-    // so it only fetches pages *after* it.
-    const pages: Record<string, Connection<string>> = {
-      "cur-first": {
-        pageInfo: { hasNextPage: true, endCursor: "cur-second" },
-        nodes: ["c", "d"],
-      },
-      "cur-second": {
-        pageInfo: { hasNextPage: false, endCursor: null },
-        nodes: ["e"],
-      },
-    };
-    const cursors: Array<string | null> = [];
-
-    const result = await paginateForward((cursor) => {
-      cursors.push(cursor);
-      return Promise.resolve(pages[cursor ?? ""]!);
-    }, "cur-first");
-
-    // Should fetch pages after 'cur-first', not re-fetch it.
-    expect(cursors).toEqual(["cur-first", "cur-second"]);
-    expect(result).toEqual(["c", "d", "e"]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// paginateBackward
-// ---------------------------------------------------------------------------
-
-describe("paginateBackward", () => {
-  it("collects nodes across pages and returns oldest-first", async () => {
-    // Backward pagination: newest page first, oldest last.
-    const pages: Connection<string>[] = [
-      { pageInfo: { hasPreviousPage: true, startCursor: "cur1" }, nodes: ["newer", "newest"] },
-      { pageInfo: { hasPreviousPage: true, startCursor: "cur2" }, nodes: ["older"] },
-      { pageInfo: { hasPreviousPage: false, startCursor: null }, nodes: ["oldest"] },
-    ];
-    const cursors: Array<string | null> = [];
-    let i = 0;
-
-    const result = await paginateBackward((cursor) => {
-      cursors.push(cursor);
-      return Promise.resolve(pages[i++]!);
-    });
-
-    // unshift inserts older pages at the front.
-    expect(result).toEqual(["oldest", "older", "newer", "newest"]);
-    expect(cursors).toEqual([null, "cur1", "cur2"]);
-  });
-
-  it("returns single-page nodes unchanged", async () => {
-    const result = await paginateBackward(() =>
-      Promise.resolve({
-        pageInfo: { hasPreviousPage: false, startCursor: null },
-        nodes: ["a", "b"],
-      }),
-    );
-
-    expect(result).toEqual(["a", "b"]);
-  });
-
-  it("starts from initialCursor to avoid re-fetching the already-known page", async () => {
-    // Simulates the batch.mts use case: the initial query already returned the
-    // "newest" page (cur-newest). paginateBackward should start from that
-    // startCursor so it only fetches pages *before* it.
-    const pages: Record<string, Connection<string>> = {
-      "cur-newest": {
-        pageInfo: { hasPreviousPage: true, startCursor: "cur-middle" },
-        nodes: ["middle"],
-      },
-      "cur-middle": {
-        pageInfo: { hasPreviousPage: false, startCursor: null },
-        nodes: ["oldest"],
-      },
-    };
-    const cursors: Array<string | null> = [];
-
-    const result = await paginateBackward((cursor) => {
-      cursors.push(cursor);
-      return Promise.resolve(pages[cursor ?? ""]!);
-    }, "cur-newest");
-
-    // Should fetch pages before 'cur-newest', not re-fetch 'cur-newest' itself.
-    expect(cursors).toEqual(["cur-newest", "cur-middle"]);
-    expect(result).toEqual(["oldest", "middle"]);
-  });
-});

package/src/merge-status/derive.mts

@@ -1,74 +0,0 @@
-/**
- * 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 type { BatchPrData, MergeStatusResult } from "../types.mts";
-import { loadConfig } from "../config/load.mts";
-
-export function deriveMergeStatus(pr: BatchPrData): MergeStatusResult {
-  const copilotReviewInProgress = detectCopilotReview(pr);
-
-  let status: MergeStatusResult["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: BatchPrData): boolean {
-  // 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: string) => 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/src/merge-status/derive.test.mts

@@ -1,130 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { deriveMergeStatus } from "./derive.mts";
-import type { BatchPrData } from "../types.mts";
-
-function makePr(overrides: Partial<BatchPrData>): BatchPrData {
-  return {
-    number: 42,
-    state: "OPEN",
-    isDraft: false,
-    mergeable: "MERGEABLE",
-    mergeStateStatus: "CLEAN",
-    reviewDecision: null,
-    headRefOid: "abc123",
-    reviewRequests: [],
-    latestReviews: [],
-    reviewThreads: [],
-    comments: [],
-    changesRequestedReviews: [],
-    checks: [],
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Interpretation order (first match wins)
-// ---------------------------------------------------------------------------
-
-describe("deriveMergeStatus", () => {
-  it("CONFLICTING mergeable → CONFLICTS", () => {
-    const result = deriveMergeStatus(makePr({ mergeable: "CONFLICTING" }));
-    expect(result.status).toBe("CONFLICTS");
-  });
-
-  it("Copilot review requested → BLOCKED", () => {
-    const result = deriveMergeStatus(
-      makePr({ reviewRequests: [{ login: "copilot-pull-request-reviewer[bot]" }] }),
-    );
-    expect(result.status).toBe("BLOCKED");
-    expect(result.copilotReviewInProgress).toBe(true);
-  });
-
-  it("Copilot review PENDING in latestReviews → BLOCKED", () => {
-    const result = deriveMergeStatus(
-      makePr({
-        latestReviews: [{ login: "copilot[bot]", state: "PENDING" }],
-      }),
-    );
-    expect(result.status).toBe("BLOCKED");
-    expect(result.copilotReviewInProgress).toBe(true);
-  });
-
-  it("Copilot review APPROVED in latestReviews → not copilotInProgress", () => {
-    const result = deriveMergeStatus(
-      makePr({
-        latestReviews: [{ login: "copilot[bot]", state: "APPROVED" }],
-      }),
-    );
-    expect(result.copilotReviewInProgress).toBe(false);
-  });
-
-  it("CONFLICTING takes priority over copilot blocked", () => {
-    const result = deriveMergeStatus(
-      makePr({
-        mergeable: "CONFLICTING",
-        reviewRequests: [{ login: "copilot[bot]" }],
-      }),
-    );
-    expect(result.status).toBe("CONFLICTS");
-  });
-
-  it("BEHIND mergeStateStatus → BEHIND", () => {
-    const result = deriveMergeStatus(makePr({ mergeStateStatus: "BEHIND" }));
-    expect(result.status).toBe("BEHIND");
-  });
-
-  it("BLOCKED mergeStateStatus → BLOCKED", () => {
-    const result = deriveMergeStatus(makePr({ mergeStateStatus: "BLOCKED" }));
-    expect(result.status).toBe("BLOCKED");
-  });
-
-  it("UNSTABLE mergeStateStatus → UNSTABLE", () => {
-    const result = deriveMergeStatus(makePr({ mergeStateStatus: "UNSTABLE" }));
-    expect(result.status).toBe("UNSTABLE");
-  });
-
-  it("isDraft → DRAFT", () => {
-    const result = deriveMergeStatus(makePr({ isDraft: true }));
-    expect(result.status).toBe("DRAFT");
-  });
-
-  it("UNKNOWN mergeStateStatus → UNKNOWN", () => {
-    const result = deriveMergeStatus(makePr({ mergeStateStatus: "UNKNOWN" }));
-    expect(result.status).toBe("UNKNOWN");
-  });
-
-  it("CLEAN mergeStateStatus → CLEAN", () => {
-    const result = deriveMergeStatus(makePr({ mergeStateStatus: "CLEAN" }));
-    expect(result.status).toBe("CLEAN");
-  });
-
-  it("includes full detail fields in result", () => {
-    const result = deriveMergeStatus(
-      makePr({ reviewDecision: "CHANGES_REQUESTED", isDraft: false }),
-    );
-    expect(result.reviewDecision).toBe("CHANGES_REQUESTED");
-    expect(result.isDraft).toBe(false);
-    expect(result.mergeable).toBe("MERGEABLE");
-  });
-});
-
-describe("deriveMergeStatus — state pass-through", () => {
-  it("passes OPEN state through", () => {
-    const result = deriveMergeStatus(makePr({ state: "OPEN" }));
-    expect(result.state).toBe("OPEN");
-  });
-
-  it("passes MERGED state through", () => {
-    const result = deriveMergeStatus(
-      makePr({ state: "MERGED", mergeable: "UNKNOWN", mergeStateStatus: "UNKNOWN" }),
-    );
-    expect(result.state).toBe("MERGED");
-  });
-
-  it("passes CLOSED state through", () => {
-    const result = deriveMergeStatus(
-      makePr({ state: "CLOSED", mergeable: "UNKNOWN", mergeStateStatus: "UNKNOWN" }),
-    );
-    expect(result.state).toBe("CLOSED");
-  });
-});

package/src/reporters/text.mts

@@ -1,140 +0,0 @@
-/**
- * Human-readable text reporter for shepherd check output.
- */
-
-import type { ShepherdReport, TriagedCheck } from "../types.mts";
-
-export function formatText(report: ShepherdReport): string {
-  const lines: string[] = [];
-
-  // 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 as TriagedCheck;
-      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: string): string {
-  return (text.split("\n")[0] ?? "").trim().slice(0, 120);
-}
-
-function indent(text: string, prefix: string): string {
-  return text
-    .split("\n")
-    .map((l) => prefix + l)
-    .join("\n");
-}