github-issue-tower-defence-management 1.124.0 → 1.125.1

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.ts

@@ -36,6 +36,7 @@ import {
 
 export const FULL_ISSUE_FETCH_INTERVAL_MS = 60 * 60 * 1000;
 export const INCREMENTAL_FETCH_SKEW_BUFFER_MS = 5 * 60 * 1000;
+export const REQUIRED_CHECKS_CACHE_TTL_MS = 10 * 60 * 1000;
 
 export type CachedProjectIssues = {
   lastFetchedAt: string;
@@ -57,69 +58,6 @@ type TimelineItem = {
     mergeable?: string;
     headRefName?: string;
     baseRefName?: string;
-    baseRepository?: {
-      branchProtectionRules?: {
-        nodes: Array<{
-          pattern: string;
-          requiredStatusCheckContexts: string[];
-        }>;
-      };
-      defaultBranchRef?: {
-        name: string;
-      } | null;
-      rulesets?: {
-        nodes: Array<{
-          name: string;
-          enforcement: string;
-          conditions: {
-            refName: {
-              include: string[];
-              exclude: string[];
-            };
-          };
-          rules: {
-            nodes: Array<{
-              type: string;
-              parameters:
-                | {
-                    requiredStatusChecks: Array<{
-                      context: string;
-                    }>;
-                  }
-                | Record<string, never>;
-            }>;
-          };
-        }>;
-      };
-    };
-    commits?: {
-      nodes: Array<{
-        commit: {
-          statusCheckRollup?: {
-            contexts?: {
-              nodes: Array<
-                | {
-                    __typename: 'CheckRun';
-                    name: string;
-                    conclusion: string | null;
-                    databaseId: number;
-                  }
-                | {
-                    __typename: 'StatusContext';
-                    context: string;
-                    state: string;
-                  }
-              >;
-            };
-          } | null;
-        };
-      }>;
-    };
-    reviewThreads?: {
-      nodes: Array<{
-        isResolved: boolean;
-      }>;
-    };
     baseRef?: {
       name: string;
     } | null;
@@ -143,88 +81,101 @@ type IssueTimelineResponse = {
   errors?: Array<{ message: string }>;
 };
 
+type CiContextNode =
+  | {
+      __typename: 'CheckRun';
+      name: string;
+      conclusion: string | null;
+      databaseId: number;
+    }
+  | {
+      __typename: 'StatusContext';
+      context: string;
+      state: string;
+    };
+
 type PrStatusComputationData = {
   isDraft?: boolean;
   mergeable?: string;
-  baseRepository?: {
-    branchProtectionRules?: {
-      nodes: Array<{
-        pattern: string;
-        requiredStatusCheckContexts: string[];
-      }>;
-    };
-    defaultBranchRef?: {
-      name: string;
-    } | null;
-    rulesets?: {
-      nodes: Array<{
-        name: string;
-        enforcement: string;
-        conditions: {
-          refName: {
-            include: string[];
-            exclude: string[];
-          };
-        };
-        rules: {
-          nodes: Array<{
-            type: string;
-            parameters:
-              | {
-                  requiredStatusChecks: Array<{
-                    context: string;
-                  }>;
-                }
-              | Record<string, never>;
-          }>;
-        };
-      }>;
-    };
-  };
-  commits?: {
-    nodes: Array<{
-      commit: {
-        statusCheckRollup?: {
-          contexts?: {
-            nodes: Array<
-              | {
-                  __typename: 'CheckRun';
-                  name: string;
-                  conclusion: string | null;
-                  databaseId: number;
-                }
-              | {
-                  __typename: 'StatusContext';
-                  context: string;
-                  state: string;
-                }
-            >;
-          };
-        } | null;
-      };
-    }>;
-  };
-  reviewThreads?: {
-    nodes: Array<{
-      isResolved: boolean;
-    }>;
-  };
+  requiredCheckNames: string[];
+  ciContexts: CiContextNode[];
+  reviewThreads: Array<{
+    isResolved: boolean;
+  }>;
 };
 
-type DirectPullRequestResponse = {
+type SlimPullRequestResponse = {
   data?: {
     repository?: {
       pullRequest?: {
         url: string;
         state: string;
+        isDraft?: boolean;
         headRefName?: string;
         baseRefName?: string;
-      } & PrStatusComputationData;
-    };
+        mergeable?: string;
+        headRefOid?: string;
+        reviewThreads?: {
+          pageInfo: {
+            endCursor: string | null;
+            hasNextPage: boolean;
+          };
+          nodes: Array<{
+            isResolved: boolean;
+          }>;
+        };
+      } | null;
+    } | null;
   };
   errors?: Array<{ message: string }>;
 };
 
+type SlimPullRequest = {
+  url: string;
+  state: string;
+  isDraft?: boolean;
+  headRefName?: string;
+  baseRefName?: string;
+  mergeable?: string;
+  headRefOid?: string;
+  reviewThreads: Array<{
+    isResolved: boolean;
+  }>;
+};
+
+type BranchRulesResponseItem = {
+  type: string;
+  parameters?: {
+    required_status_checks?: Array<{
+      context: string;
+    }>;
+  };
+};
+
+type BranchDetailResponse = {
+  protection?: {
+    required_status_checks?: {
+      contexts?: string[];
+    } | null;
+  } | null;
+};
+
+type CheckRunsResponse = {
+  total_count: number;
+  check_runs: Array<{
+    id: number;
+    name: string;
+    conclusion: string | null;
+  }>;
+};
+
+type CombinedStatusResponse = {
+  statuses: Array<{
+    context: string;
+    state: string;
+  }>;
+};
+
 type PullRequestMergeabilityResponse = {
   data?: {
     repository?: {
@@ -244,13 +195,36 @@ function isIssueTimelineResponse(
   return true;
 }
 
-function isDirectPullRequestResponse(
+function isSlimPullRequestResponse(
   value: unknown,
-): value is DirectPullRequestResponse {
+): value is SlimPullRequestResponse {
   if (typeof value !== 'object' || value === null) return false;
   return true;
 }
 
+function isBranchRulesResponse(
+  value: unknown,
+): value is BranchRulesResponseItem[] {
+  return Array.isArray(value);
+}
+
+function isBranchDetailResponse(value: unknown): value is BranchDetailResponse {
+  if (typeof value !== 'object' || value === null) return false;
+  return true;
+}
+
+function isCheckRunsResponse(value: unknown): value is CheckRunsResponse {
+  if (typeof value !== 'object' || value === null) return false;
+  return 'check_runs' in value && Array.isArray(value.check_runs);
+}
+
+function isCombinedStatusResponse(
+  value: unknown,
+): value is CombinedStatusResponse {
+  if (typeof value !== 'object' || value === null) return false;
+  return 'statuses' in value && Array.isArray(value.statuses);
+}
+
 function isPullRequestMergeabilityResponse(
   value: unknown,
 ): value is PullRequestMergeabilityResponse {
@@ -428,58 +402,6 @@ function isPullRequestCommitsResponse(
   return Array.isArray(value) && value.every(isPullRequestCommitsResponseItem);
 }
 
-const fnmatch = (pattern: string, str: string): boolean => {
-  let regexStr = '^';
-  let i = 0;
-  while (i < pattern.length) {
-    const c = pattern[i];
-    if (c === '*') {
-      if (pattern[i + 1] === '*') {
-        regexStr += '.*';
-        i += 2;
-        if (pattern[i] === '/') {
-          i++;
-        }
-      } else {
-        regexStr += '[^/]*';
-        i++;
-      }
-    } else if (c === '?') {
-      regexStr += '[^/]';
-      i++;
-    } else if (c === '[') {
-      let j = i + 1;
-      while (j < pattern.length && pattern[j] !== ']') {
-        j++;
-      }
-      if (j >= pattern.length) {
-        regexStr += '\\[';
-        i++;
-        continue;
-      }
-      const content = pattern.slice(i + 1, j);
-      if (content.length > 0 && (content[0] === '!' || content[0] === '^')) {
-        const body = content.slice(1).replace(/\\/g, '\\\\');
-        regexStr += '[^' + body + ']';
-      } else {
-        const escapedContent = content.replace(/\\/g, '\\\\');
-        regexStr += '[' + escapedContent + ']';
-      }
-      i = j + 1;
-    } else {
-      regexStr += c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      i++;
-    }
-  }
-  regexStr += '$';
-  try {
-    const regex = new RegExp(regexStr);
-    return regex.test(str);
-  } catch {
-    return pattern === str;
-  }
-};
-
 export class ApiV3CheerioRestIssueRepository
   extends BaseGitHubRepository
   implements IssueRepository
@@ -1000,73 +922,13 @@ export class ApiV3CheerioRestIssueRepository
   private computePrStatus = (
     prUrl: string,
     headRefName: string | undefined,
-    baseRefName: string | undefined,
     data: PrStatusComputationData,
   ): RelatedPullRequest => {
     const isConflicted = data.mergeable === 'CONFLICTING';
-    const lastCommit = data.commits?.nodes[0]?.commit;
-    const statusCheckRollup = lastCommit?.statusCheckRollup;
-    const contexts = statusCheckRollup?.contexts?.nodes || [];
-
-    const branchProtectionRules =
-      data.baseRepository?.branchProtectionRules?.nodes || [];
-    const matchingRules = baseRefName
-      ? branchProtectionRules.filter(
-          (rule) =>
-            rule.pattern === baseRefName || fnmatch(rule.pattern, baseRefName),
-        )
-      : [];
-    const requiredCheckNamesSet = new Set<string>();
-    for (const rule of matchingRules) {
-      for (const name of rule.requiredStatusCheckContexts) {
-        requiredCheckNamesSet.add(name);
-      }
-    }
-
-    const rulesets = data.baseRepository?.rulesets?.nodes || [];
-    const defaultBranchName = data.baseRepository?.defaultBranchRef?.name || '';
-    for (const ruleset of rulesets) {
-      if (ruleset.enforcement !== 'ACTIVE') continue;
-      const refIncludes = ruleset.conditions.refName.include;
-      const refExcludes = ruleset.conditions.refName.exclude;
-      const matchesInclude =
-        baseRefName !== undefined &&
-        refIncludes.some((pattern) => {
-          if (pattern === '~DEFAULT_BRANCH') {
-            return baseRefName === defaultBranchName;
-          }
-          if (pattern === '~ALL') {
-            return true;
-          }
-          const branchPattern = pattern.replace(/^refs\/heads\//, '');
-          return (
-            branchPattern === baseRefName || fnmatch(branchPattern, baseRefName)
-          );
-        });
-      if (!matchesInclude) continue;
-      const matchesExclude =
-        baseRefName !== undefined &&
-        refExcludes.some((pattern) => {
-          if (pattern === '~DEFAULT_BRANCH') {
-            return baseRefName === defaultBranchName;
-          }
-          const branchPattern = pattern.replace(/^refs\/heads\//, '');
-          return (
-            branchPattern === baseRefName || fnmatch(branchPattern, baseRefName)
-          );
-        });
-      if (matchesExclude) continue;
-      for (const rule of ruleset.rules.nodes) {
-        if (rule.type !== 'REQUIRED_STATUS_CHECKS') continue;
-        if ('requiredStatusChecks' in rule.parameters) {
-          for (const check of rule.parameters.requiredStatusChecks) {
-            requiredCheckNamesSet.add(check.context);
-          }
-        }
-      }
-    }
+    const hasStatusCheckRollup = data.ciContexts.length > 0;
+    const contexts = data.ciContexts;
 
-    const requiredCheckNames = Array.from(requiredCheckNamesSet);
+    const requiredCheckNames = data.requiredCheckNames;
     const seenContextNames = new Set<string>();
     for (const ctx of contexts) {
       if ('name' in ctx) {
@@ -1106,7 +968,7 @@ export class ApiV3CheerioRestIssueRepository
       'STALE',
     ]);
     const isCiStateSuccess = (() => {
-      if (!statusCheckRollup) return false;
+      if (!hasStatusCheckRollup) return false;
       const latestRuns = [...latestCheckRunByName.values()];
       const statusContexts = contexts.filter(
         (
@@ -1132,7 +994,7 @@ export class ApiV3CheerioRestIssueRepository
     })();
     const isPassedAllCiJob = isCiStateSuccess && allRequiredChecksPassed;
 
-    const reviewThreads = data.reviewThreads?.nodes || [];
+    const reviewThreads = data.reviewThreads;
     const isResolvedAllReviewComments =
       reviewThreads.length === 0 ||
       reviewThreads.every((thread) => thread.isResolved);
@@ -1152,6 +1014,320 @@ export class ApiV3CheerioRestIssueRepository
     };
   };
 
+  private readonly requiredCheckNamesCache = new Map<
+    string,
+    { fetchedAtMs: number; names: string[] }
+  >();
+
+  private getRequiredCheckNames = async (
+    owner: string,
+    repo: string,
+    branch: string,
+  ): Promise<string[]> => {
+    const cacheKey = `${owner}/${repo}/${branch}`;
+    const nowMs = (await this.dateRepository.now()).getTime();
+    const cached = this.requiredCheckNamesCache.get(cacheKey);
+    if (cached && nowMs - cached.fetchedAtMs < REQUIRED_CHECKS_CACHE_TTL_MS) {
+      return cached.names;
+    }
+
+    const ownerSegment = encodeURIComponent(owner);
+    const repoSegment = encodeURIComponent(repo);
+    const branchSegment = encodeURIComponent(branch);
+    const requiredCheckNamesSet = new Set<string>();
+
+    const rulesResponse = await this.fetchWithRateLimitRetry(() =>
+      fetch(
+        `https://api.github.com/repos/${ownerSegment}/${repoSegment}/rules/branches/${branchSegment}?per_page=100`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${this.ghToken}`,
+            Accept: 'application/vnd.github+json',
+          },
+        },
+      ),
+    );
+    if (rulesResponse.ok) {
+      const rulesBody: unknown = await rulesResponse.json();
+      if (!isBranchRulesResponse(rulesBody)) {
+        throw new Error(
+          `Unexpected response shape when fetching branch rules: ${owner}/${repo}/${branch}`,
+        );
+      }
+      for (const rule of rulesBody) {
+        if (rule.type !== 'required_status_checks') continue;
+        for (const check of rule.parameters?.required_status_checks || []) {
+          requiredCheckNamesSet.add(check.context);
+        }
+      }
+    } else if (rulesResponse.status === 403) {
+      const reason = await this.formatGitHubErrorWithStatus(rulesResponse);
+      console.warn(
+        `ApiV3CheerioRestIssueRepository: branch rules are not accessible for ${owner}/${repo}/${branch}, treating as no required checks. reason: ${reason}`,
+      );
+    } else if (rulesResponse.status !== 404) {
+      const reason = await this.formatGitHubErrorWithStatus(rulesResponse);
+      throw new Error(
+        `Failed to fetch branch rules for ${owner}/${repo}/${branch}: ${reason}`,
+      );
+    }
+
+    const branchResponse = await this.fetchWithRateLimitRetry(() =>
+      fetch(
+        `https://api.github.com/repos/${ownerSegment}/${repoSegment}/branches/${branchSegment}`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${this.ghToken}`,
+            Accept: 'application/vnd.github+json',
+          },
+        },
+      ),
+    );
+    if (branchResponse.ok) {
+      const branchBody: unknown = await branchResponse.json();
+      if (!isBranchDetailResponse(branchBody)) {
+        throw new Error(
+          `Unexpected response shape when fetching branch detail: ${owner}/${repo}/${branch}`,
+        );
+      }
+      for (const context of branchBody.protection?.required_status_checks
+        ?.contexts || []) {
+        requiredCheckNamesSet.add(context);
+      }
+    } else if (branchResponse.status === 403) {
+      const reason = await this.formatGitHubErrorWithStatus(branchResponse);
+      console.warn(
+        `ApiV3CheerioRestIssueRepository: branch detail (classic protection) is not accessible for ${owner}/${repo}/${branch}, treating as no required checks. reason: ${reason}`,
+      );
+    } else if (branchResponse.status !== 404) {
+      const reason = await this.formatGitHubErrorWithStatus(branchResponse);
+      throw new Error(
+        `Failed to fetch branch detail for ${owner}/${repo}/${branch}: ${reason}`,
+      );
+    }
+
+    const names = Array.from(requiredCheckNamesSet);
+    this.requiredCheckNamesCache.set(cacheKey, {
+      fetchedAtMs: nowMs,
+      names,
+    });
+    return names;
+  };
+
+  private getCommitCiContexts = async (
+    owner: string,
+    repo: string,
+    commitSha: string,
+  ): Promise<CiContextNode[]> => {
+    const ownerSegment = encodeURIComponent(owner);
+    const repoSegment = encodeURIComponent(repo);
+    const shaSegment = encodeURIComponent(commitSha);
+    const contexts: CiContextNode[] = [];
+
+    const perPage = 100;
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const checkRunsResponse = await this.fetchWithRateLimitRetry(() =>
+        fetch(
+          `https://api.github.com/repos/${ownerSegment}/${repoSegment}/commits/${shaSegment}/check-runs?per_page=${perPage}&page=${page}`,
+          {
+            method: 'GET',
+            headers: {
+              Authorization: `Bearer ${this.ghToken}`,
+              Accept: 'application/vnd.github+json',
+            },
+          },
+        ),
+      );
+      if (!checkRunsResponse.ok) {
+        const reason =
+          await this.formatGitHubErrorWithStatus(checkRunsResponse);
+        throw new Error(
+          `Failed to fetch check runs for ${owner}/${repo}@${commitSha}: ${reason}`,
+        );
+      }
+      const checkRunsBody: unknown = await checkRunsResponse.json();
+      if (!isCheckRunsResponse(checkRunsBody)) {
+        throw new Error(
+          `Unexpected response shape when fetching check runs: ${owner}/${repo}@${commitSha}`,
+        );
+      }
+      for (const checkRun of checkRunsBody.check_runs) {
+        contexts.push({
+          __typename: 'CheckRun',
+          name: checkRun.name,
+          conclusion: checkRun.conclusion
+            ? checkRun.conclusion.toUpperCase()
+            : null,
+          databaseId: checkRun.id,
+        });
+      }
+      if (
+        checkRunsBody.check_runs.length < perPage ||
+        page * perPage >= checkRunsBody.total_count
+      ) {
+        hasMore = false;
+      } else {
+        page += 1;
+      }
+    }
+
+    const combinedStatusResponse = await this.fetchWithRateLimitRetry(() =>
+      fetch(
+        `https://api.github.com/repos/${ownerSegment}/${repoSegment}/commits/${shaSegment}/status?per_page=100`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${this.ghToken}`,
+            Accept: 'application/vnd.github+json',
+          },
+        },
+      ),
+    );
+    if (!combinedStatusResponse.ok) {
+      const reason = await this.formatGitHubErrorWithStatus(
+        combinedStatusResponse,
+      );
+      throw new Error(
+        `Failed to fetch combined status for ${owner}/${repo}@${commitSha}: ${reason}`,
+      );
+    }
+    const combinedStatusBody: unknown = await combinedStatusResponse.json();
+    if (!isCombinedStatusResponse(combinedStatusBody)) {
+      throw new Error(
+        `Unexpected response shape when fetching combined status: ${owner}/${repo}@${commitSha}`,
+      );
+    }
+    for (const status of combinedStatusBody.statuses) {
+      contexts.push({
+        __typename: 'StatusContext',
+        context: status.context,
+        state: status.state.toUpperCase(),
+      });
+    }
+
+    return contexts;
+  };
+
+  private fetchSlimPullRequest = async (
+    owner: string,
+    repo: string,
+    prNumber: number,
+  ): Promise<SlimPullRequest | null> => {
+    const query = `
+      query PullRequestSlimStatus($owner: String!, $repo: String!, $prNumber: Int!, $reviewThreadsAfter: String) {
+        repository(owner: $owner, name: $repo) {
+          pullRequest(number: $prNumber) {
+            url
+            state
+            isDraft
+            headRefName
+            baseRefName
+            mergeable
+            headRefOid
+            reviewThreads(first: 100, after: $reviewThreadsAfter) {
+              pageInfo {
+                endCursor
+                hasNextPage
+              }
+              nodes {
+                isResolved
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    let slimPullRequest: SlimPullRequest | null = null;
+    let reviewThreadsAfter: string | null = null;
+    let hasNextPage = true;
+
+    while (hasNextPage) {
+      const response = await this.fetchWithRateLimitRetry(() =>
+        fetchGithubGraphql({
+          ghToken: this.ghToken,
+          query,
+          variables: { owner, repo, prNumber, reviewThreadsAfter },
+        }),
+      );
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch pull request from GitHub GraphQL API: HTTP ${response.status}`,
+        );
+      }
+
+      const responseData: unknown = await response.json();
+      if (!isSlimPullRequestResponse(responseData)) {
+        throw new Error('Unexpected response shape when fetching pull request');
+      }
+
+      if (responseData.errors && responseData.errors.length > 0) {
+        throw new Error(
+          `GraphQL errors: ${JSON.stringify(responseData.errors)}`,
+        );
+      }
+
+      const pr = responseData.data?.repository?.pullRequest;
+      if (!pr) {
+        return null;
+      }
+
+      if (!slimPullRequest) {
+        slimPullRequest = {
+          url: pr.url,
+          state: pr.state,
+          isDraft: pr.isDraft,
+          headRefName: pr.headRefName,
+          baseRefName: pr.baseRefName,
+          mergeable: pr.mergeable,
+          headRefOid: pr.headRefOid,
+          reviewThreads: [],
+        };
+      }
+      for (const thread of pr.reviewThreads?.nodes || []) {
+        slimPullRequest.reviewThreads.push({ isResolved: thread.isResolved });
+      }
+
+      hasNextPage = pr.reviewThreads?.pageInfo.hasNextPage === true;
+      reviewThreadsAfter = pr.reviewThreads?.pageInfo.endCursor ?? null;
+    }
+
+    return slimPullRequest;
+  };
+
+  private buildRelatedPullRequestFromSlim = async (
+    owner: string,
+    repo: string,
+    slimPullRequest: SlimPullRequest,
+  ): Promise<RelatedPullRequest> => {
+    const requiredCheckNames = slimPullRequest.baseRefName
+      ? await this.getRequiredCheckNames(
+          owner,
+          repo,
+          slimPullRequest.baseRefName,
+        )
+      : [];
+    const ciContexts = slimPullRequest.headRefOid
+      ? await this.getCommitCiContexts(owner, repo, slimPullRequest.headRefOid)
+      : [];
+    return this.computePrStatus(
+      slimPullRequest.url,
+      slimPullRequest.headRefName,
+      {
+        isDraft: slimPullRequest.isDraft,
+        mergeable: slimPullRequest.mergeable,
+        requiredCheckNames,
+        ciContexts,
+        reviewThreads: slimPullRequest.reviewThreads,
+      },
+    );
+  };
+
   private resolveMergeabilityWithRetry = async (
     owner: string,
     repo: string,
@@ -1262,68 +1438,6 @@ export class ApiV3CheerioRestIssueRepository
                       mergeable
                       headRefName
                       baseRefName
-                      baseRepository {
-                        branchProtectionRules(first: 100) {
-                          nodes {
-                            pattern
-                            requiredStatusCheckContexts
-                          }
-                        }
-                        defaultBranchRef {
-                          name
-                        }
-                        rulesets(first: 100) {
-                          nodes {
-                            name
-                            enforcement
-                            conditions {
-                              refName {
-                                include
-                                exclude
-                              }
-                            }
-                            rules(first: 100) {
-                              nodes {
-                                type
-                                parameters {
-                                  ... on RequiredStatusChecksParameters {
-                                    requiredStatusChecks {
-                                      context
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      commits(last: 1) {
-                        nodes {
-                          commit {
-                            statusCheckRollup {
-                              contexts(first: 100) {
-                                nodes {
-                                  __typename
-                                  ... on CheckRun {
-                                    databaseId
-                                    name
-                                    conclusion
-                                  }
-                                  ... on StatusContext {
-                                    context
-                                    state
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      reviewThreads(first: 100) {
-                        nodes {
-                          isResolved
-                        }
-                      }
                       baseRef {
                         name
                       }
@@ -1378,16 +1492,9 @@ export class ApiV3CheerioRestIssueRepository
 
         const pr = item.source;
         const prUrl = pr.url || '';
-        const baseRefName = pr.baseRefName ?? pr.baseRef?.name;
-        const prStatus = this.computePrStatus(
-          prUrl,
-          pr.headRefName,
-          baseRefName,
-          pr,
-        );
 
-        let isConflicted = prStatus.isConflicted;
-        let mergeable = prStatus.mergeable;
+        let isConflicted = pr.mergeable === 'CONFLICTING';
+        let mergeable: string | null = pr.mergeable ?? null;
         if (
           pr.number !== undefined &&
           (pr.mergeable === undefined ||
@@ -1426,6 +1533,38 @@ export class ApiV3CheerioRestIssueRepository
           }
         }
 
+        if (pr.number === undefined) continue;
+
+        let prStatus: RelatedPullRequest;
+        try {
+          const slimPullRequest = await this.fetchSlimPullRequest(
+            owner,
+            repo,
+            pr.number,
+          );
+          if (!slimPullRequest || slimPullRequest.state !== 'OPEN') {
+            console.info(
+              `ApiV3CheerioRestIssueRepository: pull request is no longer open, excluding it from related open PRs. prUrl: ${prUrl}`,
+            );
+            continue;
+          }
+          const baseRefName =
+            slimPullRequest.baseRefName ?? pr.baseRefName ?? pr.baseRef?.name;
+          prStatus = await this.buildRelatedPullRequestFromSlim(owner, repo, {
+            ...slimPullRequest,
+            url: slimPullRequest.url || prUrl,
+            headRefName: slimPullRequest.headRefName ?? pr.headRefName,
+            baseRefName,
+          });
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          console.warn(
+            `ApiV3CheerioRestIssueRepository: fetching pull request status failed, skipping PR for this cycle. prUrl: ${prUrl} error: ${errorMessage}`,
+          );
+          continue;
+        }
+
         relatedPRsMap.set(prUrl, {
           ...prStatus,
           isConflicted,
@@ -1476,112 +1615,16 @@ export class ApiV3CheerioRestIssueRepository
     }
     const { owner, repo, issueNumber: prNumber } = parsedUrl;
 
-    const query = `
-      query PullRequestStatus($owner: String!, $repo: String!, $prNumber: Int!) {
-        repository(owner: $owner, name: $repo) {
-          pullRequest(number: $prNumber) {
-            url
-            state
-            isDraft
-            headRefName
-            baseRefName
-            mergeable
-            baseRepository {
-              branchProtectionRules(first: 100) {
-                nodes {
-                  pattern
-                  requiredStatusCheckContexts
-                }
-              }
-              defaultBranchRef {
-                name
-              }
-              rulesets(first: 100) {
-                nodes {
-                  name
-                  enforcement
-                  conditions {
-                    refName {
-                      include
-                      exclude
-                    }
-                  }
-                  rules(first: 100) {
-                    nodes {
-                      type
-                      parameters {
-                        ... on RequiredStatusChecksParameters {
-                          requiredStatusChecks {
-                            context
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            commits(last: 1) {
-              nodes {
-                commit {
-                  statusCheckRollup {
-                    contexts(first: 100) {
-                      nodes {
-                        __typename
-                        ... on CheckRun {
-                          databaseId
-                          name
-                          conclusion
-                        }
-                        ... on StatusContext {
-                          context
-                          state
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            reviewThreads(first: 100) {
-              nodes {
-                isResolved
-              }
-            }
-          }
-        }
-      }
-    `;
-
-    const response = await this.fetchWithRateLimitRetry(() =>
-      fetchGithubGraphql({
-        ghToken: this.ghToken,
-        query,
-        variables: { owner, repo, prNumber },
-      }),
+    const slimPullRequest = await this.fetchSlimPullRequest(
+      owner,
+      repo,
+      prNumber,
     );
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch pull request from GitHub GraphQL API: HTTP ${response.status}`,
-      );
-    }
-
-    const responseData: unknown = await response.json();
-    if (!isDirectPullRequestResponse(responseData)) {
-      throw new Error('Unexpected response shape when fetching pull request');
-    }
-
-    if (responseData.errors && responseData.errors.length > 0) {
-      throw new Error(`GraphQL errors: ${JSON.stringify(responseData.errors)}`);
-    }
-
-    const pr = responseData.data?.repository?.pullRequest;
-    if (!pr || pr.state !== 'OPEN') {
+    if (!slimPullRequest || slimPullRequest.state !== 'OPEN') {
       return null;
     }
 
-    return this.computePrStatus(pr.url, pr.headRefName, pr.baseRefName, pr);
+    return this.buildRelatedPullRequestFromSlim(owner, repo, slimPullRequest);
   };
 
   closePullRequest = async (prUrl: string): Promise<void> => {