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

package/src/review-api/store.ts

@@ -12,6 +12,7 @@ import {
   boardIconKind,
   boardTitle,
 } from "@dev.fast/review-protocol";
+import type { GitHubPullRequest } from "@review/github-pr-graph.js";
 import { sourceAnchors } from "@review/lens-selection.js";
 import {
   migrateStoredLenses,
@@ -76,7 +77,12 @@ import {
   summarizeEdit,
 } from "./document.js";
 import { type BoardLinkPreview, boardLinkPreview } from "./link-preview.js";
-import { pullRequestKey, pullRequestUrl, setPullRequest } from "./origin.js";
+import {
+  pullRequestKey,
+  pullRequestUrl,
+  setPullRequest,
+  sourceBranchName,
+} from "./origin.js";
 import { upgradeStore } from "./store-migrations.js";
 import {
   BOARD_REPOSITORY_ID_SQL,
@@ -168,7 +174,8 @@ export const commandSchema = z.strictObject({
     z.strictObject({
       type: z.literal("set_target"),
       reviewId,
-      target: reviewTargetSchema,
+      target: reviewTargetSchema.optional(),
+      repositoryId: z.string().min(1).optional(),
       pullRequestUrl: pullRequestUrl.nullable().optional(),
     }),
     z.strictObject({
@@ -250,6 +257,8 @@ export interface SnapshotOrigin {
   pullRequestUrl?: string;
   /** As the forge reported it when the PR was attached. */
   pullRequestTitle?: string;
+  /** The branch the PR merges into, which can differ from baseBranch. */
+  pullRequestBaseBranch?: string;
   /** The legacy review revision this version was imported from. */
   revision?: string;
 }
@@ -424,7 +433,22 @@ export interface ResolvedPullRequest {
   baseBranch: string;
 }
 
+/** A command with its network context resolved, ready for the write queue. */
+interface PreparedCommand {
+  op: z.infer<typeof commandSchema>["operation"];
+  requestedTarget: ReviewTarget | undefined;
+  fromPullRequest: ResolvedPullRequest | undefined;
+  resolvedTarget: { target: ReviewTarget; pins?: Pins } | undefined;
+  resolvedBranch: string | undefined;
+  discoveredPullRequest: GitHubPullRequest | undefined;
+  resolvedTitle: string | undefined;
+}
+
 export interface ReviewProviders {
+  findPullRequest?(
+    pins: Pins,
+    branch: string,
+  ): Promise<GitHubPullRequest | undefined>;
   headBranch?(pins: Pins, headRef?: string): Promise<string | undefined>;
   projectSource?(snapshot: Snapshot, pins: Pins): Promise<Snapshot>;
   /** Fetch a PR into the registered checkout the caller names. */
@@ -474,6 +498,7 @@ export class ReviewStore {
   readonly askHistory: AskHistory;
   private readonly db: DatabaseSync;
   private pending: Promise<unknown> = Promise.resolve();
+  private readonly preparing = new Set<Promise<unknown>>();
   private closing = false;
   private readonly liveSources = new Map<string, Snapshot>();
   private refreshTimer?: ReturnType<typeof setInterval>;
@@ -1010,6 +1035,16 @@ export class ReviewStore {
     return this.checkouts.group(root);
   }
 
+  private sameRepository(left: string, right: string): boolean {
+    if (left === right) return true;
+    const group = this.repositoryGroup(this.repositoryPath(left));
+
+    return (
+      group !== undefined &&
+      group.key === this.repositoryGroup(this.repositoryPath(right))?.key
+    );
+  }
+
   registerRepository(root: string) {
     this.db
       .prepare("INSERT OR IGNORE INTO repositories(id,path,name) VALUES(?,?,?)")
@@ -1026,6 +1061,11 @@ export class ReviewStore {
   /** Forgets a checkout no board uses, after every write queued before it,
    * so a board being made with it keeps it. */
   unregisterRepository(id: string): Promise<void> {
+    if (this.preparing.size)
+      return Promise.allSettled([...this.preparing]).then(() =>
+        this.unregisterRepository(id),
+      );
+
     const run = this.pending.then(async () => {
       this.db.exec("BEGIN IMMEDIATE");
 
@@ -1143,6 +1183,7 @@ export class ReviewStore {
     clearInterval(this.externalChanges);
     clearInterval(this.refreshTimer);
     clearInterval(this.purgeTimer);
+    await Promise.allSettled([...this.preparing]);
     await this.pending;
     this.listeners.clear();
     this.catalogListeners.clear();
@@ -1522,56 +1563,154 @@ export class ReviewStore {
         )
       : this.startPullRequestTitle(command);
 
-    return this.enqueue(async () => {
-      const op = command.operation;
+    const prepared = this.prepareCommand(
+      command,
+      pullRequest,
+      pullRequestTitle,
+      author,
+    ).then((source) => this.applyPreparedCommand(source, initial, author));
 
-      if (op.type === "create") {
-        if (!op.target && !op.pullRequestUrl)
-          throw new ReviewInputError("Supply a target or a pullRequestUrl.");
+    this.preparing.add(prepared);
+    void prepared
+      .finally(() => this.preparing.delete(prepared))
+      .catch(() => {});
 
-        if (op.repositoryId && op.target)
-          throw new ReviewInputError(
-            "A checkout for the PR applies only to a create from pullRequestUrl alone; name it in the target instead.",
-          );
+    return prepared;
+  }
 
-        if (!op.title && op.target && author.kind !== "person")
-          throw new ReviewInputError("Supply a title.");
-      }
+  /** Resolve optional network context before entering the write queue. */
+  private async prepareCommand(
+    command: z.infer<typeof commandSchema>,
+    pullRequest: Promise<ResolvedPullRequest> | undefined,
+    pullRequestTitle: Promise<string | undefined>,
+    author: Author,
+  ): Promise<PreparedCommand> {
+    const op = command.operation;
 
-      const requestedTarget =
-        op.type === "create" || op.type === "set_target"
-          ? op.target
-          : undefined;
+    if (op.type === "create") {
+      if (!op.target && !op.pullRequestUrl)
+        throw new ReviewInputError("Supply a target or a pullRequestUrl.");
+
+      if (op.repositoryId && op.target)
+        throw new ReviewInputError(
+          "A checkout for the PR applies only to a create from pullRequestUrl alone; name it in the target instead.",
+        );
+
+      if (!op.title && op.target && author.kind !== "person")
+        throw new ReviewInputError("Supply a title.");
+    }
+
+    if (op.type === "set_target" && !op.target && !op.pullRequestUrl)
+      throw new ReviewInputError("Supply a target or a pullRequestUrl.");
+
+    const requestedTarget =
+      op.type === "create" || op.type === "set_target" ? op.target : undefined;
+
+    const fromPullRequest = await pullRequest;
+
+    // No commits to resolve; repositoryPath throws if it is unregistered.
+    const resolvedTarget: { target: ReviewTarget; pins?: Pins } | undefined =
+      requestedTarget?.kind === "project"
+        ? (this.repositoryPath(requestedTarget.repositoryId),
+          { target: requestedTarget })
+        : requestedTarget
+          ? await (this.providers.resolveTarget?.(requestedTarget) ??
+              namedCommits(requestedTarget))
+          : fromPullRequest;
 
-      const fromPullRequest = await pullRequest;
+    if (requestedTarget && !resolvedTarget)
+      throw new ReviewInputError("Review targets are unavailable.");
 
-      // No commits to resolve; repositoryPath throws if it is unregistered.
-      const resolvedTarget: { target: ReviewTarget; pins?: Pins } | undefined =
-        requestedTarget?.kind === "project"
-          ? (this.repositoryPath(requestedTarget.repositoryId),
-            { target: requestedTarget })
-          : requestedTarget
-            ? await (this.providers.resolveTarget?.(requestedTarget) ??
-                namedCommits(requestedTarget))
-            : fromPullRequest;
+    const resolvedBranch = fromPullRequest
+      ? fromPullRequest.branch
+      : resolvedTarget?.pins && this.providers.headBranch
+        ? await this.providers.headBranch(
+            resolvedTarget.pins,
+            requestedTarget?.kind === "commits"
+              ? requestedTarget.head
+              : undefined,
+          )
+        : undefined;
+
+    const discoveredPullRequest =
+      resolvedTarget?.pins &&
+      resolvedBranch &&
+      (op.type === "create" || op.type === "set_target") &&
+      op.pullRequestUrl === undefined
+        ? await this.providers
+            .findPullRequest?.(resolvedTarget.pins, resolvedBranch)
+            .catch(() => undefined)
+        : undefined;
 
-      if (requestedTarget && !resolvedTarget)
-        throw new ReviewInputError("Review targets are unavailable.");
+    const resolvedTitle = await pullRequestTitle;
 
+    return {
+      op,
+      requestedTarget,
+      fromPullRequest,
+      resolvedTarget,
+      resolvedBranch,
+      discoveredPullRequest,
+      resolvedTitle,
+    };
+  }
+
+  private applyPreparedCommand(
+    prepared: PreparedCommand,
+    initial: { document: Block[]; origin: SnapshotOrigin } | undefined,
+    author: Author,
+  ) {
+    const {
+      op,
+      requestedTarget,
+      fromPullRequest,
+      resolvedTarget,
+      resolvedBranch,
+      discoveredPullRequest,
+      resolvedTitle,
+    } = prepared;
+
+    return this.enqueue(async () => {
       if (
         op.type === "create" &&
-        op.pullRequestUrl &&
-        op.reuseExisting !== false
+        (op.pullRequestUrl
+          ? op.reuseExisting !== false
+          : op.reuseExisting && resolvedTarget?.pins)
       ) {
-        const [found, ...others] = this.reviewsForPullRequest(
-          op.pullRequestUrl,
-        );
+        const known = op.pullRequestUrl
+          ? this.reviewsForPullRequest(op.pullRequestUrl)
+          : [];
+
+        const branch = fromPullRequest?.branch ?? resolvedBranch;
+        const repository = resolvedTarget?.target.repositoryId;
+        const project = repository && this.projectOfRepository(repository);
+
+        const matching =
+          !known.length && branch && project
+            ? this.list()
+                .filter(
+                  (review) =>
+                    review.project?.id === project &&
+                    sourceBranchName(review.origin?.branch) ===
+                      sourceBranchName(branch) &&
+                    (op.pullRequestUrl
+                      ? !review.origin?.pullRequestUrl
+                      : !review.trashedAt) &&
+                    review.pins !== undefined &&
+                    repository !== undefined &&
+                    this.sameRepository(review.pins.repositoryId, repository),
+                )
+                .reverse()
+                .map((review) => review.reviewId)
+            : [];
+
+        const [found, ...others] = [...known, ...matching];
 
         if (found) {
           const result = this.existingReview(
             found,
             others,
-            // A PR always resolves to commits, so pins are set.
+            // Both resolve to commits, so pins are set.
             resolvedTarget!.pins!,
           );
 
@@ -1642,21 +1781,10 @@ export class ReviewStore {
 
       if (
         (op.type === "create" || op.type === "set_target") &&
-        this.providers.headBranch
-      ) {
-        const pins = resolvedTarget?.pins ?? snapshot.pins;
-
-        if (pins) {
-          const headRef =
-            requestedTarget?.kind === "commits"
-              ? requestedTarget.head
-              : undefined;
-
-          const branch = await this.providers.headBranch(pins, headRef);
-
-          snapshot.origin = { ...snapshot.origin, branch };
-        }
-      }
+        resolvedTarget?.pins &&
+        (this.providers.headBranch || fromPullRequest)
+      )
+        snapshot.origin = { ...snapshot.origin, branch: resolvedBranch };
 
       if (!requestedTarget && fromPullRequest)
         snapshot.origin = {
@@ -1694,7 +1822,7 @@ export class ReviewStore {
               assignFreshIds(block, (prefix) => `${prefix}-${++nextId}`);
           }
 
-          setPullRequest(snapshot, op.pullRequestUrl, await pullRequestTitle);
+          setPullRequest(snapshot, op.pullRequestUrl, resolvedTitle);
           break;
         case "rename":
           snapshot.title = op.title;
@@ -1708,7 +1836,7 @@ export class ReviewStore {
                 resolvedTarget!.target.repositoryId
                 ? null
                 : undefined),
-            await pullRequestTitle,
+            resolvedTitle,
           );
           snapshot.staleSources = [];
 
@@ -1780,6 +1908,33 @@ export class ReviewStore {
         }
       }
 
+      if ((op.type === "create" || op.type === "set_target") && snapshot.pins) {
+        const branch = sourceBranchName(snapshot.origin?.branch);
+
+        const sameBranch =
+          previous?.pins?.repositoryId === snapshot.pins.repositoryId &&
+          sourceBranchName(previous.origin?.branch) === branch;
+
+        // Explicit PR input is resolved once for create and retarget alike.
+        if (op.pullRequestUrl === null) setPullRequest(snapshot, null);
+        else if (op.pullRequestUrl)
+          setPullRequest(
+            snapshot,
+            op.pullRequestUrl,
+            fromPullRequest?.title,
+            fromPullRequest?.baseBranch,
+          );
+        else if (branch && discoveredPullRequest)
+          setPullRequest(
+            snapshot,
+            discoveredPullRequest.url,
+            discoveredPullRequest.title,
+            discoveredPullRequest.baseBranch,
+          );
+        // An explicit binding survives an unavailable optional lookup.
+        else if (previous && !sameBranch) setPullRequest(snapshot, null);
+      }
+
       const warnings = unpinnedWorktree
         ? [
             `Its references now read at ${unpinnedWorktree.slice(0, 7)}, the checkout's last commit, which lacks any uncommitted lines they quoted. Check them.`,
@@ -2010,11 +2165,10 @@ export class ReviewStore {
         .version,
     );
   }
-  /** Runs one write after every write queued before it. */
+  /** Runs an accepted write after every write queued before it. Admission
+   * checks belong at entry points: preparations accepted before close still
+   * need to enqueue their writes while close waits for them. */
   private enqueue<T>(work: () => Promise<T>): Promise<T> {
-    if (this.closing)
-      return Promise.reject(new Error("Review store is closing."));
-
     const run = this.pending.then(work);
 
     this.pending = run.catch(() => {});
@@ -2243,6 +2397,8 @@ export class ReviewStore {
     while (this.leased(reviewId) && Date.now() < deadline)
       await new Promise((resolve) => setTimeout(resolve, DISCARD_POLL_MS));
 
+    if (this.closing) throw new Error("Review store is closing.");
+
     return this.enqueue(async () => {
       if (!this.has(reviewId)) return { deleted: false };
       const snapshot = this.read(reviewId);
@@ -2333,6 +2489,9 @@ export class ReviewStore {
   personEdit(reviewId: string, input: unknown): Promise<PersonEditResult> {
     const body = personEditSchema.parse(input);
 
+    if (this.closing)
+      return Promise.reject(new Error("Review store is closing."));
+
     return this.enqueue(async () => {
       const previous = this.read(reviewId);
 
@@ -3026,7 +3185,11 @@ export class ReviewStore {
   ): Promise<ResolvedPullRequest> | undefined {
     const op = command.operation;
 
-    if (op.type !== "create" || op.target || !op.pullRequestUrl)
+    if (
+      (op.type !== "create" && op.type !== "set_target") ||
+      op.target ||
+      !op.pullRequestUrl
+    )
       return undefined;
 
     if (!this.providers.resolvePullRequest)
@@ -3043,7 +3206,7 @@ export class ReviewStore {
 
     // A PR whose review is in Trash is refused before it is fetched.
     const [existing] =
-      op.reuseExisting === false
+      op.type !== "create" || op.reuseExisting === false
         ? []
         : this.reviewsForPullRequest(op.pullRequestUrl);
 

package/src/review-stack.ts

@@ -5,6 +5,15 @@ import type {
 } from "@dev.fast/review-protocol";
 import { z } from "zod";
 
+import {
+  type RunGitHubApi,
+  readGitHubPullRequests,
+} from "./github-pr-graph.js";
+import { pullRequestKey, sourceBranchName } from "./review-api/origin.js";
+import { pullRequestProvider } from "./review-api/provider.js";
+
+export type { RunGitHubApi };
+
 const GitHubStacksSchema = z.array(
   z.object({
     pull_requests: z.array(
@@ -16,15 +25,28 @@ const GitHubStacksSchema = z.array(
   }),
 );
 
-export type RunGitHubApi = (host: string, endpoint: string) => Promise<string>;
-
-type Subject = Pick<ReviewApiSummary, "origin"> & { reviewId?: string };
+type Subject = Pick<ReviewApiSummary, "origin" | "pins"> & {
+  reviewId?: string;
+};
 
 type Candidate = Pick<
   ReviewApiSummary,
   "reviewId" | "title" | "origin" | "pins" | "trashedAt" | "project"
 >;
 
+/** The branch a review sits on: its PR's target, else the base it names. */
+const baseOf = (review?: Pick<ReviewApiSummary, "origin">) =>
+  sourceBranchName(
+    review?.origin?.pullRequestBaseBranch ?? review?.origin?.baseBranch,
+  );
+
+/** A GitHub PR URL's host, owner/repo slug and number; else undefined. */
+function gitHubPullRequest(url: string | undefined) {
+  const resolution = url ? pullRequestProvider(url) : undefined;
+
+  return resolution?.provider.id === "github" ? resolution.address : undefined;
+}
+
 interface StackEntry {
   branch: string;
   pullRequestNumber: number | null;
@@ -47,6 +69,16 @@ export async function resolveReviewStackLayers(
     options.runGitHubApi ?? defaultRunGitHubApi,
   );
 
+  if (entries.length < 2) {
+    const discovered = await inferredGitHubStack(
+      subject,
+      reviews,
+      options.runGitHubApi ?? defaultRunGitHubApi,
+    ).catch(() => []);
+
+    if (discovered.length > 1) entries = discovered;
+  }
+
   if (!entries.length && options.repositoryPath)
     entries = await localStack(subject, reviews, options.repositoryPath);
 
@@ -135,21 +167,18 @@ async function gitHubStack(
   reviews: readonly Candidate[],
   runGitHubApi: RunGitHubApi,
 ): Promise<StackEntry[]> {
-  const binding = subject.origin?.pullRequestUrl?.match(
-    /^https:\/\/([a-z0-9.-]+)\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/pull\/([1-9]\d*)$/,
-  );
+  const binding = gitHubPullRequest(subject.origin?.pullRequestUrl);
 
   if (!binding) return [];
-  const [, host, owner, repository, number] = binding;
-  const pullRequestNumber = Number(number);
-  const repoKey = `https://${host}/${owner}/${repository}`;
+  const { host, slug, number: pullRequestNumber } = binding;
+  const repoKey = `https://${host}/${slug}`;
   let stacks: GitHubStacks;
 
   try {
     stacks = await readGitHubStacks(
       runGitHubApi,
-      host!,
-      `${owner}/${repository}`,
+      host,
+      slug,
       pullRequestNumber,
     );
   } catch {
@@ -178,6 +207,75 @@ async function gitHubStack(
   }));
 }
 
+/** A stack inferred from open PRs whose bases chain through this one's, for
+ * repositories without GitHub stacks. Whiteboards only annotate the result. */
+async function inferredGitHubStack(
+  subject: Subject,
+  reviews: readonly Candidate[],
+  run: RunGitHubApi,
+): Promise<StackEntry[]> {
+  const binding = gitHubPullRequest(subject.origin?.pullRequestUrl);
+
+  if (!binding) return [];
+  const graph = await readGitHubPullRequests(binding.host, binding.slug, run);
+  const current = graph.find((pr) => pr.number === binding.number);
+
+  if (!current) return [];
+  const chain = [current];
+  const seen = new Set([current.headBranch]);
+
+  const extend = (direction: "base" | "head") => {
+    let end = current;
+
+    for (;;) {
+      const matches = graph.filter((pr) =>
+        direction === "base"
+          ? pr.headBranch === end.baseBranch
+          : pr.baseBranch === end.headBranch,
+      );
+
+      if (matches.length !== 1 || seen.has(matches[0]!.headBranch)) return;
+      end = matches[0]!;
+      seen.add(end.headBranch);
+
+      if (direction === "base") chain.unshift(end);
+      else chain.push(end);
+    }
+  };
+
+  extend("base");
+  extend("head");
+
+  if (chain.length < 2) return [];
+
+  const project = reviews.find((review) => review.reviewId === subject.reviewId)
+    ?.project?.id;
+
+  return chain.map((pr) => ({
+    branch: pr.headBranch,
+    pullRequestNumber: pr.number,
+    pullRequestUrl: pr.url,
+    base: null,
+    subject: pr.title,
+    current: pr.number === current.number,
+    reviews: reviews.filter((review) => {
+      const candidateUrl = review.origin?.pullRequestUrl;
+
+      if (candidateUrl)
+        return pullRequestKey(candidateUrl) === pullRequestKey(pr.url);
+
+      const sameRepository = subject.pins?.repositoryId
+        ? review.pins?.repositoryId === subject.pins.repositoryId
+        : Boolean(project && review.project?.id === project);
+
+      return (
+        sameRepository &&
+        sourceBranchName(review.origin?.branch) === pr.headBranch
+      );
+    }),
+  }));
+}
+
 /** The chain of reviews through this one, linked by the base each names. */
 async function localStack(
   subject: Subject,
@@ -187,21 +285,24 @@ async function localStack(
   const group = reviews.find((review) => review.reviewId === subject.reviewId)
     ?.project?.id;
 
-  const current = subject.origin?.branch;
+  const current = sourceBranchName(subject.origin?.branch);
+  const currentBase = baseOf(subject);
 
   if (!group || !current) return [];
 
-  const main = subject.origin?.baseBranch
+  const main = currentBase
     ? await defaultBranch(repositoryPath).catch(() => null)
     : null;
 
-  const name = (ref: string) => ref.replace(/^origin\//, "");
-
   const inGroup = reviews.filter((review) => review.project?.id === group);
 
+  const branchOf = (review?: Candidate) =>
+    sourceBranchName(review?.origin?.branch);
+
   const latest = (field: "branch" | "baseBranch", branch: string) => {
     const matches = inGroup.filter(
-      (review) => review.origin?.[field] === branch,
+      (review) =>
+        (field === "branch" ? branchOf(review) : baseOf(review)) === branch,
     );
 
     return matches.findLast((review) => !review.trashedAt) ?? matches.at(-1);
@@ -210,16 +311,18 @@ async function localStack(
   const branches = [current];
 
   for (
-    let base = subject.origin?.baseBranch;
-    base && name(base) !== (main && name(main.ref)) && !branches.includes(base);
-    base = latest("branch", base)?.origin?.baseBranch
+    let base = currentBase;
+    base &&
+    base !== (main && sourceBranchName(main.ref)) &&
+    !branches.includes(base);
+    base = baseOf(latest("branch", base))
   )
     branches.unshift(base);
 
   for (
-    let child = latest("baseBranch", current)?.origin?.branch;
+    let child = branchOf(latest("baseBranch", current));
     child && !branches.includes(child);
-    child = latest("baseBranch", child)?.origin?.branch
+    child = branchOf(latest("baseBranch", child))
   )
     branches.push(child);
 
@@ -243,7 +346,7 @@ async function localStack(
     base: (branch === bottom && start?.base) || null,
     subject: (branch === bottom && start?.subject) || null,
     current: branch === current,
-    reviews: inGroup.filter((review) => review.origin?.branch === branch),
+    reviews: inGroup.filter((review) => branchOf(review) === branch),
   }));
 }
 

package/src/sharing/import.ts

@@ -85,9 +85,11 @@ export const sharedSnapshotSchema = z.strictObject({
     .strictObject({
       branch: z.string().optional(),
       baseRef: z.string().optional(),
+      baseBranch: z.string().optional(),
       pullRequestNumber: z.number().int().positive().optional(),
       pullRequestUrl: pullRequestUrl.optional(),
       pullRequestTitle: z.string().optional(),
+      pullRequestBaseBranch: z.string().optional(),
       revision: z.string().optional(),
     })
     .optional(),

package/dist/agent-cli-a7X9Th1U.js

@@ -1,2 +0,0 @@
-import { n as runReviewAgentCli } from "./agent-cli-DpSj5jCW.js";
-export { runReviewAgentCli };

package/dist/profile-BfY9lECc.js

@@ -1,2 +0,0 @@
-import { t as openReviewProfile } from "./profile-BfvRNmRc.js";
-export { openReviewProfile };