@reviewflow/sdk 0.0.0-stage → 6.21.0

package/src/github/fetchCompareDiff.ts

@@ -0,0 +1,21 @@
+import type { GitHubTransport } from "./transport.ts";
+
+/**
+ * The compare endpoint rather than the pull request's own diff: it takes any
+ * range, so a single commit or "since my last review" reads like the whole
+ * pull request. Three dots, from the merge base, as a local `git diff` does.
+ * GitHub refuses it past 300 files or 20,000 lines.
+ */
+export const fetchCompareDiff = (
+  transport: GitHubTransport,
+  { ownerRepo, base, head }: { ownerRepo: string; base: string; head: string },
+): Promise<string> => {
+  const [owner, name, ...rest] = ownerRepo.split("/");
+  if (owner === undefined || name === undefined || rest.length > 0) {
+    throw new Error(`${ownerRepo} is not owner/repo`);
+  }
+  return transport.text({
+    path: `repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/compare/${base}...${head}`,
+    accept: "application/vnd.github.diff",
+  });
+};

package/src/github/imageProxies.ts

@@ -0,0 +1,43 @@
+/**
+ * GitHub serves the images of a body through camo, its image proxy, so the
+ * host of an image a stranger put in a pull request never learns who read it
+ * nor when. A camo url is signed with GitHub's key: it cannot be built, only
+ * read from the html GitHub renders (`bodyHTML`), where each proxied `<img>`
+ * keeps the url the markdown wrote in `data-canonical-src`.
+ */
+
+const imgTag = /<img\b[^>]*>/gi;
+
+const decodeAttribute = (value: string): string =>
+  value
+    .replaceAll("&quot;", '"')
+    .replaceAll("&#39;", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&");
+
+const attribute = (tag: string, name: string): string | null => {
+  const match = new RegExp(`\\s${name}="([^"]*)"`, "i").exec(tag);
+  return match?.[1] === undefined ? null : decodeAttribute(match[1]);
+};
+
+/** The url each image of `html` was written with, to the one GitHub serves it from. */
+export const imageProxiesOf = (
+  html: string | null | undefined,
+): Record<string, string> => {
+  const proxies: Record<string, string> = {};
+  for (const [tag] of (html ?? "").matchAll(imgTag)) {
+    const src = attribute(tag, "src");
+    const canonical = attribute(tag, "data-canonical-src");
+    if (src !== null && canonical !== null && src !== canonical) {
+      proxies[canonical] = src;
+    }
+  }
+  return proxies;
+};
+
+/** Every body's proxies of one part, merged. */
+export const mergeImageProxies = (
+  htmls: readonly (string | null | undefined)[],
+): Record<string, string> =>
+  Object.assign({}, ...htmls.map(imageProxiesOf)) as Record<string, string>;

package/src/github/lineDiff.ts

@@ -0,0 +1,145 @@
+export type DiffLineKind = "added" | "context" | "removed";
+
+export interface DiffLine {
+  kind: DiffLineKind;
+  text: string;
+}
+
+/**
+ * Past this many cells the table is not built at all and the two sides are
+ * emitted whole — every old line removed, then every new line added. Still a
+ * correct diff, only not a minimal one, and 400×400 is well past anything an
+ * `Edit` has measured (153 lines is the largest) once the common prefix and
+ * suffix are off. The cap is in cells rather than lines because that is what
+ * the allocation is: a 1200-line cap on each side would allow a 5.7MB transient
+ * array, several times per page.
+ */
+const maxDiffCells = 160_000;
+
+/** A file that ends in a newline is not a file with a blank last line. */
+const toLines = (value: string): string[] => {
+  if (value === "") return [];
+  const lines = value.split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+};
+
+const context = (text: string): DiffLine => ({ kind: "context", text });
+const removed = (text: string): DiffLine => ({ kind: "removed", text });
+const added = (text: string): DiffLine => ({ kind: "added", text });
+
+const wholeSides = (before: string[], after: string[]): DiffLine[] => [
+  ...before.map(removed),
+  ...after.map(added),
+];
+
+/**
+ * The shortest edit script between two runs that share neither their first nor
+ * their last line, by the longest common subsequence of them.
+ *
+ * At a position where a removal and an addition both apply, the removal is
+ * emitted first — git's order, and the one that lets the two be read as a
+ * replacement of each other.
+ */
+const shortestEdit = (before: string[], after: string[]): DiffLine[] => {
+  const height = before.length;
+  const width = after.length + 1;
+  const common = new Uint32Array((height + 1) * width);
+
+  for (let row = height - 1; row >= 0; row--) {
+    const beforeLine = before[row];
+    for (let column = after.length - 1; column >= 0; column--) {
+      common[row * width + column] =
+        beforeLine === after[column]
+          ? (common[(row + 1) * width + column + 1] ?? 0) + 1
+          : Math.max(
+              common[(row + 1) * width + column] ?? 0,
+              common[row * width + column + 1] ?? 0,
+            );
+    }
+  }
+
+  const lines: DiffLine[] = [];
+  let row = 0;
+  let column = 0;
+
+  while (row < height && column < after.length) {
+    if (before[row] === after[column]) {
+      lines.push(context(before[row] ?? ""));
+      row++;
+      column++;
+      continue;
+    }
+    if (
+      (common[(row + 1) * width + column] ?? 0) >=
+      (common[row * width + column + 1] ?? 0)
+    ) {
+      lines.push(removed(before[row] ?? ""));
+      row++;
+      continue;
+    }
+    lines.push(added(after[column] ?? ""));
+    column++;
+  }
+
+  return [
+    ...lines,
+    ...before.slice(row).map(removed),
+    ...after.slice(column).map(added),
+  ];
+};
+
+/**
+ * The two sides of a change, line by line.
+ *
+ * **The common prefix and suffix come off first**, and that is the guard that
+ * does the real work rather than the cell cap below it: Claude Code's
+ * `old_string` and `new_string` are a fragment and its replacement, and a
+ * fragment is chosen to be unique, which means it almost always opens and
+ * closes on lines the replacement keeps. Trimming them is O(n+m) and allocates
+ * nothing, and it collapses nearly every measured edit to a handful of lines
+ * before the table is sized.
+ *
+ * A whole new file is `before: ""`, which trims to nothing and comes back as
+ * every line added.
+ */
+export const diffLines = ({
+  before,
+  after,
+}: {
+  before: string;
+  after: string;
+}): DiffLine[] => {
+  const beforeLines = toLines(before);
+  const afterLines = toLines(after);
+
+  let head = 0;
+  while (
+    head < beforeLines.length &&
+    head < afterLines.length &&
+    beforeLines[head] === afterLines[head]
+  ) {
+    head++;
+  }
+
+  let tail = 0;
+  while (
+    tail < beforeLines.length - head &&
+    tail < afterLines.length - head &&
+    beforeLines[beforeLines.length - 1 - tail] ===
+      afterLines[afterLines.length - 1 - tail]
+  ) {
+    tail++;
+  }
+
+  const beforeMiddle = beforeLines.slice(head, beforeLines.length - tail);
+  const afterMiddle = afterLines.slice(head, afterLines.length - tail);
+
+  return [
+    ...beforeLines.slice(0, head).map(context),
+    ...(beforeMiddle.length * afterMiddle.length > maxDiffCells
+      ? wholeSides(beforeMiddle, afterMiddle)
+      : shortestEdit(beforeMiddle, afterMiddle)),
+    ...beforeLines.slice(beforeLines.length - tail).map(context),
+  ];
+};

package/src/github/prQuery.ts

@@ -0,0 +1,298 @@
+import type {
+  PrMergeable,
+  PrReviewDecision,
+  PrState,
+} from "../types/entities.ts";
+
+/**
+ * One branch to ask GitHub about — a task's current branch, which is the only
+ * branch a PR is wanted for (a task has N branches over time and only the
+ * latest one is live).
+ */
+export interface PrQueryTarget {
+  branchId: string;
+  taskId: string;
+  /** `owner/repo`, from `repo.owner_repo` */
+  ownerRepo: string;
+  branch: string;
+}
+
+export interface PrQuery {
+  query: string;
+  /** alias -> the branch it asks about; how an answer is matched back */
+  targetsByAlias: Map<string, PrQueryTarget>;
+}
+
+/**
+ * Every branch is one aliased field in one document, so the whole board costs a
+ * single HTTP request and — because every connection is asked for `first: 1` —
+ * a single point of the GraphQL rate limit. A query per PR would be one request
+ * and one point *each*, which is the thing this exists to avoid.
+ *
+ * The counts come off `checkRunCountsByState` / `statusContextCountsByState`
+ * rather than off the context nodes: those are aggregates GitHub computes, so
+ * `contexts(first: 1)` returns exact totals for a PR with two hundred checks
+ * without transferring or paying for them.
+ */
+export const prFields = `fragment prFields on PullRequest {
+  number
+  state
+  isDraft
+  reviewDecision
+  mergedAt
+  mergeable
+  headRefOid
+  baseRefName
+  commits(last: 1) {
+    nodes {
+      commit {
+        statusCheckRollup {
+          contexts(first: 1) {
+            checkRunCountsByState { count state }
+            statusContextCountsByState { count state }
+          }
+        }
+      }
+    }
+  }
+}`;
+
+/**
+ * `owner/repo` exactly, because that is what the GraphQL arguments are. A value
+ * that does not split into two segments is skipped rather than guessed at: it
+ * would resolve to a repository that is not the operator's, and registration
+ * already refuses a repo with no usable remote.
+ */
+export const splitOwnerRepo = (
+  ownerRepo: string,
+): { owner: string; name: string } | null => {
+  const segments = ownerRepo.split("/");
+  const [owner, name] = segments;
+  if (segments.length !== 2 || !owner || !name) return null;
+  return { owner, name };
+};
+
+/** Returns null when no target is queryable, so no request is made at all. */
+export const buildPrQuery = (targets: PrQueryTarget[]): PrQuery | null => {
+  const byRepo = new Map<string, { alias: string; branch: string }[]>();
+  const targetsByAlias = new Map<string, PrQueryTarget>();
+
+  targets.forEach((target, index) => {
+    if (target.branch === "" || splitOwnerRepo(target.ownerRepo) === null) {
+      return;
+    }
+    const alias = `t${String(index)}`;
+    targetsByAlias.set(alias, target);
+    const existing = byRepo.get(target.ownerRepo);
+    const entry = { alias, branch: target.branch };
+    if (existing) existing.push(entry);
+    else byRepo.set(target.ownerRepo, [entry]);
+  });
+
+  if (targetsByAlias.size === 0) return null;
+
+  const repoBlocks = [...byRepo].map(([ownerRepo, branches], repoIndex) => {
+    const { owner, name } = splitOwnerRepo(ownerRepo) as {
+      owner: string;
+      name: string;
+    };
+    const branchFields = branches.map(
+      ({ alias, branch }) =>
+        // Newest first: a branch that had a closed PR and then a new one is
+        // described by the new one, and `first: 1` is what keeps the cost flat.
+        `    ${alias}: pullRequests(headRefName: ${JSON.stringify(branch)}, first: 1, orderBy: { field: CREATED_AT, direction: DESC }) { nodes { ...prFields } }`,
+    );
+    return [
+      `  r${String(repoIndex)}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {`,
+      ...branchFields,
+      "  }",
+    ].join("\n");
+  });
+
+  return {
+    query: `query {\n${repoBlocks.join("\n")}\n}\n\n${prFields}`,
+    targetsByAlias,
+  };
+};
+
+interface GhCountByState {
+  count: number;
+  state: string;
+}
+
+export interface GhPullRequest {
+  number: number;
+  state: string;
+  isDraft: boolean;
+  reviewDecision: string | null;
+  mergedAt: string | null;
+  mergeable: string;
+  headRefOid: string;
+  baseRefName: string;
+  commits: {
+    nodes: {
+      commit: {
+        statusCheckRollup: {
+          contexts: {
+            checkRunCountsByState: GhCountByState[] | null;
+            statusContextCountsByState: GhCountByState[] | null;
+          };
+        } | null;
+      };
+    }[];
+  };
+}
+
+/**
+ * Repository aliases at the top level, branch aliases inside each. A repository
+ * the token cannot see comes back as a null alias next to the ones that
+ * resolved, which is why this reads defensively rather than asserting a shape.
+ */
+export type PrQueryData = Record<
+  string,
+  Record<string, { nodes: (GhPullRequest | null)[] | null } | null> | null
+>;
+
+/**
+ * How GitHub's rollup states fold into the three counts `pr` keeps.
+ *
+ * A whitelist, like the hook mapper: a state GitHub adds later is ignored
+ * rather than counted as something, because the one thing worse than an
+ * unranked board is a board that calls a red PR green.
+ *
+ * `CANCELLED` and `STALE` count as pending rather than failed on purpose. They
+ * mean "no answer for this commit" — a superseded run after a force-push is the
+ * common cause — and calling that a failure would raise `checksFailing` on a
+ * PR nobody needs to look at, which is how an attention signal stops being read.
+ */
+export const checkOutcomes = new Map<string, "failed" | "passed" | "pending">([
+  ["ACTION_REQUIRED", "failed"],
+  ["ERROR", "failed"],
+  ["FAILURE", "failed"],
+  ["STARTUP_FAILURE", "failed"],
+  ["TIMED_OUT", "failed"],
+
+  ["COMPLETED", "passed"],
+  ["NEUTRAL", "passed"],
+  ["SKIPPED", "passed"],
+  ["SUCCESS", "passed"],
+
+  ["CANCELLED", "pending"],
+  ["EXPECTED", "pending"],
+  ["IN_PROGRESS", "pending"],
+  ["PENDING", "pending"],
+  ["QUEUED", "pending"],
+  ["STALE", "pending"],
+  ["WAITING", "pending"],
+]);
+
+interface CheckCounts {
+  checksPassed: number;
+  checksFailed: number;
+  checksPending: number;
+}
+
+const countChecks = (pullRequest: GhPullRequest): CheckCounts => {
+  const totals = { failed: 0, passed: 0, pending: 0 };
+  const contexts =
+    pullRequest.commits.nodes[0]?.commit.statusCheckRollup?.contexts;
+
+  for (const { count, state } of [
+    ...(contexts?.checkRunCountsByState ?? []),
+    ...(contexts?.statusContextCountsByState ?? []),
+  ]) {
+    const outcome = checkOutcomes.get(state);
+    if (outcome !== undefined) totals[outcome] += count;
+  }
+
+  return {
+    checksPassed: totals.passed,
+    checksFailed: totals.failed,
+    checksPending: totals.pending,
+  };
+};
+
+/** `isDraft` is a separate field upstream; `pr.state` folds it in. */
+const prStates = new Map<string, PrState>([
+  ["CLOSED", "closed"],
+  ["MERGED", "merged"],
+]);
+
+const toPrState = (state: string, isDraft: boolean): PrState | null => {
+  if (state === "OPEN") return isDraft ? "draft" : "open";
+  return prStates.get(state) ?? null;
+};
+
+const reviewDecisions = new Map<string, PrReviewDecision>([
+  ["APPROVED", "approved"],
+  ["CHANGES_REQUESTED", "changesRequested"],
+  ["REVIEW_REQUIRED", "reviewRequired"],
+]);
+
+const mergeables = new Map<string, PrMergeable>([
+  ["CONFLICTING", "conflicting"],
+  ["MERGEABLE", "mergeable"],
+]);
+
+export interface FetchedPr extends CheckCounts {
+  target: PrQueryTarget;
+  number: number;
+  state: PrState;
+  reviewDecision: PrReviewDecision;
+  mergeable: PrMergeable;
+  mergedAt: string | null;
+  /** always set by GitHub; null only from a reviewflow document that lacks it */
+  headSha: string | null;
+  /** null only from a reviewflow server that predates `baseRef` */
+  baseRef: string | null;
+}
+
+/** Null for a state GitHub added after this was written. */
+export const toFetchedPr = (
+  target: PrQueryTarget,
+  pullRequest: GhPullRequest,
+): FetchedPr | null => {
+  const state = toPrState(pullRequest.state, pullRequest.isDraft);
+  if (state === null) return null;
+  return {
+    target,
+    number: pullRequest.number,
+    state,
+    reviewDecision:
+      pullRequest.reviewDecision === null
+        ? null
+        : (reviewDecisions.get(pullRequest.reviewDecision) ?? null),
+    mergeable: mergeables.get(pullRequest.mergeable) ?? "unknown",
+    mergedAt: pullRequest.mergedAt,
+    headSha: pullRequest.headRefOid,
+    baseRef: pullRequest.baseRefName,
+    ...countChecks(pullRequest),
+  };
+};
+
+/**
+ * Only the aliases that both resolved and carry a pull request produce a row. A
+ * branch with no PR is not an absence to record — it is the normal state of a
+ * worktree whose work has not been pushed for review yet.
+ */
+export const parsePrQueryResponse = (
+  data: PrQueryData | null,
+  targetsByAlias: Map<string, PrQueryTarget>,
+): FetchedPr[] => {
+  if (data === null) return [];
+  const found: FetchedPr[] = [];
+
+  for (const repository of Object.values(data)) {
+    if (!repository) continue;
+    for (const [alias, connection] of Object.entries(repository)) {
+      const target = targetsByAlias.get(alias);
+      const pullRequest = connection?.nodes?.[0];
+      if (!target || !pullRequest) continue;
+
+      const fetched = toFetchedPr(target, pullRequest);
+      if (fetched !== null) found.push(fetched);
+    }
+  }
+
+  return found;
+};