@dev.fast/whiteboard 0.3.5-preview.20261022.134 → 0.3.5-preview.20261023.136

package/src/github-pr-graph.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+
+export type RunGitHubApi = (host: string, endpoint: string) => Promise<string>;
+
+const repository = z.object({ full_name: z.string() });
+
+const pullRequest = z.object({
+  number: z.number().int().positive(),
+  title: z.string(),
+  draft: z.boolean().optional(),
+  head: z.object({ ref: z.string(), repo: repository.nullable() }),
+  base: z.object({ ref: z.string(), repo: repository }),
+});
+
+export interface GitHubPullRequest {
+  number: number;
+  url: string;
+  title: string;
+  headBranch: string;
+  baseBranch: string;
+  draft: boolean;
+}
+
+// Repository facts are independent of which PRs have whiteboards. Share a
+// short-lived, coalesced read between source resolution and stack discovery.
+const caches = new WeakMap<
+  RunGitHubApi,
+  Map<
+    string,
+    {
+      expires: number;
+      read: Promise<GitHubPullRequest[]>;
+    }
+  >
+>();
+
+export function readGitHubPullRequests(
+  host: string,
+  slug: string,
+  run: RunGitHubApi,
+): Promise<GitHubPullRequest[]> {
+  let cache = caches.get(run);
+
+  if (!cache) caches.set(run, (cache = new Map()));
+  const key = `${host}/${slug}`.toLowerCase();
+  const previous = cache.get(key);
+
+  if (previous && previous.expires > Date.now()) return previous.read;
+
+  const read = (async () => {
+    const result: GitHubPullRequest[] = [];
+
+    for (let page = 1; page <= 10; page++) {
+      const records = z
+        .array(pullRequest)
+        .parse(
+          JSON.parse(
+            await run(
+              host,
+              `repos/${slug}/pulls?state=open&per_page=100&page=${page}`,
+            ),
+          ),
+        );
+
+      for (const pr of records) {
+        // A fork's identically named branch is not this repository's branch.
+        if (
+          pr.head.repo?.full_name.toLowerCase() !== slug.toLowerCase() ||
+          pr.base.repo.full_name.toLowerCase() !== slug.toLowerCase()
+        )
+          continue;
+        result.push({
+          number: pr.number,
+          url: `https://${host}/${slug}/pull/${pr.number}`,
+          title: pr.title,
+          headBranch: pr.head.ref,
+          baseBranch: pr.base.ref,
+          draft: pr.draft ?? false,
+        });
+      }
+
+      if (records.length < 100) return result;
+    }
+
+    throw new Error(
+      "PR discovery exceeded 1000 open pull requests; refusing a partial stack.",
+    );
+  })();
+
+  cache.set(key, { expires: Date.now() + 60_000, read });
+  // Failures are optional context, but must not poison the next read.
+  void read.catch(() => {
+    if (cache.get(key)?.read === read) cache.delete(key);
+  });
+
+  return read;
+}

package/src/review-api/http.ts

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+
 import {
   type JsonObject,
   type JsonValue,
@@ -608,10 +610,27 @@ export function createReviewApi(
       [...reviewIds].map((reviewId) => [reviewId, linksKey(reviewId)] as const),
     );
 
-    // Bumped when a review's parent or siblings change, so its header
-    // reloads them.
-    const placeRevision = new Map<string, number>();
-    const placeKey = (id: string) => JSON.stringify(placeOf(id));
+    // A digest of a review's place and its project's branches, so a later
+    // stream's matches unless its header or stack moved.
+    const placeKey = (id: string) => {
+      const project = !isShared(id) && store.summary(id)?.project;
+
+      const branches = project
+        ? store
+            .listProject(project.id)
+            .filter(({ origin }) => origin?.branch)
+            .map(({ reviewId, origin, trashedAt }) => [
+              reviewId,
+              origin,
+              trashedAt,
+            ])
+        : [];
+
+      return createHash("sha1")
+        .update(JSON.stringify([placeOf(id), branches]))
+        .digest()
+        .readUInt32BE(0);
+    };
 
     const placeKeys = new Map(
       [...reviewIds].map((reviewId) => [reviewId, placeKey(reviewId)] as const),
@@ -627,7 +646,7 @@ export function createReviewApi(
             activity: store.activity.read(reviewId),
             coverageRevision: data?.coverageRevision ?? 0,
             linksRevision: linksRevision.get(reviewId) ?? 0,
-            placeRevision: placeRevision.get(reviewId) ?? 0,
+            placeRevision: placeKeys.get(reviewId)!,
           },
         };
       } catch (error) {
@@ -681,7 +700,6 @@ export function createReviewApi(
 
         if (next === key) continue;
         placeKeys.set(id, next);
-        placeRevision.set(id, (placeRevision.get(id) ?? 0) + 1);
         marked = markReview(id) || marked;
       }
 
@@ -1996,10 +2014,12 @@ export function createReviewApi(
   app.get("/:id/stack", async (context) => {
     const query = readQuerySchemas.get.parse(context.req.query());
     const id = context.req.param("id");
-    const snapshot = readReview(id, query.version);
+    let snapshot = readReview(id, query.version);
 
     if (isShared(id) || !snapshot.pins) return context.json({ layers: [] });
 
+    if (data) snapshot = await data.discoverPullRequest(snapshot);
+
     const repositoryPath = store
       .repositories()
       .find(
@@ -2163,7 +2183,15 @@ export function createReviewApi(
   app.get("/:id", async (context) => {
     const query = readQuerySchemas.get.parse(context.req.query());
 
-    const snapshot = { ...readReview(context.req.param("id"), query.version) };
+    let snapshot = { ...readReview(context.req.param("id"), query.version) };
+
+    if (
+      data &&
+      query.full &&
+      query.version === undefined &&
+      !isShared(snapshot.reviewId)
+    )
+      snapshot = await data.discoverPullRequest(snapshot);
 
     if (data && query.full) {
       try {
@@ -2223,17 +2251,7 @@ export function createReviewApi(
 
     const request = withBoardRepository(
       await locateRepositories(
-        await pullRequestTargets(
-          body,
-          register,
-          (url, repositoryId) => {
-            if (!data)
-              throw new ReviewInputError("Repositories are unavailable.");
-
-            return data.resolvePullRequest(url, { id: repositoryId });
-          },
-          (id) => store.read(id),
-        ),
+        await pullRequestTargets(body, register, (id) => store.read(id)),
         register,
       ),
       (id) => (store.has(id) ? store.read(id) : undefined),
@@ -2433,10 +2451,6 @@ async function pullRequestTargets(
   // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Request body boundary: commandSchema parses the result.
   body: unknown,
   register: (path: string) => Promise<{ id: string }>,
-  resolve: (
-    url: string,
-    repositoryId: string,
-  ) => Promise<{ target: ReviewTarget }>,
   board: (id: string) => void,
 ) {
   const target = z.strictObject({
@@ -2480,7 +2494,7 @@ async function pullRequestTargets(
     ...located.data,
     operation: {
       ...operation,
-      target: (await resolve(url, repositoryId)).target,
+      repositoryId,
       pullRequestUrl: url,
     },
   };

package/src/review-api/local-data.ts

@@ -20,6 +20,7 @@ import {
   gitCommonDir,
   listCommitRange,
   listTrackedFilesAtCommit,
+  parseGitRemote,
   readFileAtCommit,
   resolveRepoContext,
   runVcs,
@@ -39,6 +40,10 @@ import type {
 } from "@parcel/watcher";
 import { textIncludesQuote } from "@review/evidence.js";
 import { isMissingFileError } from "@review/fs-utils.js";
+import {
+  type GitHubPullRequest,
+  readGitHubPullRequests,
+} from "@review/github-pr-graph.js";
 import { reviewManagedCheckoutRoot } from "@review/review-checkout-paths.js";
 import { ensureReviewPinnedCheckout } from "@review/review-head-checkout.js";
 import { StructuralComparisons } from "@review/server/structural-comparisons.js";
@@ -79,6 +84,7 @@ import {
 } from "./document.js";
 import { decodeImage } from "./image-decode.js";
 import { mapInputSchema } from "./map-input.js";
+import { pullRequestKey, sourceBranchName } from "./origin.js";
 import {
   type PullRequestAddress,
   type PullRequestProvider,
@@ -1052,22 +1058,101 @@ export class LocalReviewData {
 
     return snapshot.pins;
   }
+  /** Optional forge context; never changes the comparison's pins. */
+  private readonly readGitHubApi = (host: string, endpoint: string) =>
+    (this.options.pullRequests ?? defaultPullRequestDeps).run(
+      "gh",
+      ["api", "--hostname", { value: host }, { value: endpoint }],
+      { timeoutMs: 10_000 },
+    );
+
+  async findPullRequest(
+    pins: Pins,
+    branch: string,
+  ): Promise<GitHubPullRequest | undefined> {
+    const context = await resolveRepoContext(
+      this.store.repositoryPath(pins.repositoryId),
+    );
+
+    if (!context?.githubSlug || !context.originUrl) return undefined;
+    const remote = parseGitRemote(context.originUrl);
+
+    if (!remote) return undefined;
+    const name = sourceBranchName(branch);
+
+    const matches = (
+      await readGitHubPullRequests(
+        remote.host,
+        context.githubSlug,
+        this.readGitHubApi,
+      )
+    ).filter((pr) => pr.headBranch === name);
+
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+
+  /** Enrich current display metadata without repinning or rewriting history. */
+  async discoverPullRequest(snapshot: Snapshot): Promise<Snapshot> {
+    const { origin, pins } = snapshot;
+
+    if (!pins || !origin?.branch) return snapshot;
+
+    const found = await this.findPullRequest(pins, origin.branch).catch(
+      () => undefined,
+    );
+
+    if (!found) return snapshot;
+
+    // A manually selected PR must not be replaced by a branch-name match.
+    if (
+      origin.pullRequestUrl &&
+      pullRequestKey(origin.pullRequestUrl) !== pullRequestKey(found.url)
+    )
+      return snapshot;
+
+    return {
+      ...snapshot,
+      origin: {
+        ...origin,
+        pullRequestUrl: found.url,
+        pullRequestNumber: found.number,
+        pullRequestTitle: found.title,
+        pullRequestBaseBranch: found.baseBranch,
+      },
+    };
+  }
+
   /** Capture a label only when its ref still resolves to these exact pins. */
   async headBranch(pins: Pins, headRef?: string): Promise<string | undefined> {
+    const context = await resolveRepoContext(
+      this.store.repositoryPath(pins.repositoryId),
+    );
+
+    if (!context) return undefined;
+
     const vcs = await this.vcs(pins.repositoryId);
 
-    if (!vcs || vcs.kind !== "git") return undefined;
+    const symbolicRef =
+      headRef &&
+      headRef !== "HEAD" &&
+      headRef !== "@" &&
+      !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(headRef)
+        ? headRef
+        : undefined;
+
+    let location: VcsArg[];
+
+    if (symbolicRef) location = ["--git-dir", context.commonDir];
+    else if (vcs?.kind === "git") location = ["-C", vcs.rootPath];
+    else return undefined;
 
     try {
       const { stdout } = await runVcs("git", [
-        "-C",
-        vcs.rootPath,
+        ...location,
         "rev-parse",
         "--symbolic-full-name",
         "--verify",
-        !headRef || /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(headRef)
-          ? "HEAD"
-          : { rev: headRef },
+        symbolicRef ? { rev: symbolicRef } : "HEAD",
       ]);
 
       const ref = stdout.trim();
@@ -1075,13 +1160,18 @@ export class LocalReviewData {
       if (!ref.startsWith("refs/heads/") && !ref.startsWith("refs/remotes/"))
         return undefined;
 
-      const resolved = await vcs.resolveRevision(ref);
+      const { stdout: commit } = await runVcs("git", [
+        ...location,
+        "rev-parse",
+        { rev: ref },
+      ]);
 
-      if (resolved?.commit !== pins.head) return undefined;
+      if (commit.trim() !== pins.head) return undefined;
 
-      return ref.replace(/^refs\/(heads|remotes)\//, "");
+      return ref
+        .replace(/^refs\/remotes\/origin\//, "")
+        .replace(/^refs\/(heads|remotes)\//, "");
     } catch {
-      // Optional provenance must not block authoring in a detached checkout.
       return undefined;
     }
   }
@@ -2215,6 +2305,7 @@ export function openLocalReviewStore(
       resolvePullRequest: (url, repository) =>
         data.resolvePullRequest(url, repository),
       pullRequestTitle: (url) => data.pullRequestTitle(url),
+      findPullRequest: (pins, branch) => data.findPullRequest(pins, branch),
       headBranch: (pins, headRef) => data.headBranch(pins, headRef),
       sourcePins: (snapshot) => data.sourcePins(snapshot),
       unavailableAnchors: (snapshot) => data.unavailableAnchors(snapshot),

package/src/review-api/origin.ts

@@ -16,11 +16,18 @@ export function pullRequestKey(url: string): string {
   return url.toLowerCase();
 }
 
-/** Omission preserves identity; null detaches it without changing import metadata. */
+/** Older snapshots kept origin/ on remote branch labels. */
+export const sourceBranchName = (branch: string | undefined) =>
+  branch?.replace(/^origin\//, "");
+
+/** Omission preserves identity; null removes the PR without changing import
+ * metadata. A new url keeps the title and PR base when the caller omits them
+ * for the same PR. */
 export function setPullRequest(
   snapshot: Pick<Snapshot, "origin">,
   url: string | null | undefined,
   title?: string,
+  baseBranch?: string,
 ) {
   if (url === undefined) return;
 
@@ -29,19 +36,20 @@ export function setPullRequest(
       delete snapshot.origin.pullRequestUrl;
       delete snapshot.origin.pullRequestNumber;
       delete snapshot.origin.pullRequestTitle;
+      delete snapshot.origin.pullRequestBaseBranch;
     }
 
     return;
   }
 
+  const same = snapshot.origin?.pullRequestUrl === url;
   snapshot.origin = {
     ...snapshot.origin,
     pullRequestUrl: url,
     pullRequestNumber: Number(url.split("/").at(-1)),
     pullRequestTitle:
-      title ??
-      (snapshot.origin?.pullRequestUrl === url
-        ? snapshot.origin.pullRequestTitle
-        : undefined),
+      title ?? (same ? snapshot.origin?.pullRequestTitle : undefined),
+    pullRequestBaseBranch:
+      baseBranch ?? (same ? snapshot.origin?.pullRequestBaseBranch : undefined),
   };
 }