@pratik7368patil/anchor-core 0.1.15 → 0.1.18

package/dist/index.js

@@ -551,6 +551,14 @@ CREATE TABLE IF NOT EXISTS sync_state (
   history_coverage TEXT,
   history_limit INTEGER,
   history_since TEXT,
+  graphql_cursor TEXT,
+  graphql_cursor_scope TEXT,
+  graphql_cursor_scanned_prs INTEGER,
+  graphql_cursor_matched_prs INTEGER,
+  graphql_cursor_page_size INTEGER,
+  graphql_cursor_reset_at TEXT,
+  graphql_cursor_reason TEXT,
+  graphql_cursor_updated_at TEXT,
   updated_at TEXT NOT NULL
 );
 
@@ -1418,6 +1426,14 @@ function initializeSchema(db) {
   ensureColumn(db, "sync_state", "history_coverage", "TEXT");
   ensureColumn(db, "sync_state", "history_limit", "INTEGER");
   ensureColumn(db, "sync_state", "history_since", "TEXT");
+  ensureColumn(db, "sync_state", "graphql_cursor", "TEXT");
+  ensureColumn(db, "sync_state", "graphql_cursor_scope", "TEXT");
+  ensureColumn(db, "sync_state", "graphql_cursor_scanned_prs", "INTEGER");
+  ensureColumn(db, "sync_state", "graphql_cursor_matched_prs", "INTEGER");
+  ensureColumn(db, "sync_state", "graphql_cursor_page_size", "INTEGER");
+  ensureColumn(db, "sync_state", "graphql_cursor_reset_at", "TEXT");
+  ensureColumn(db, "sync_state", "graphql_cursor_reason", "TEXT");
+  ensureColumn(db, "sync_state", "graphql_cursor_updated_at", "TEXT");
 }
 function ensureColumn(db, tableName, columnName, definition) {
   const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
@@ -1488,6 +1504,83 @@ function updateSyncState(db, repo, lastIndexedPr, metadata = {}) {
     now
   );
 }
+function graphQLFetchCheckpointScope(input) {
+  const historyScope = input.all ? "all" : `limit:${input.limit ?? 200}`;
+  return `${input.repo}|${historyScope}|since:${input.since ?? ""}`;
+}
+function getGraphQLFetchCheckpoint(db, repo, scope) {
+  initializeSchema(db);
+  const row = db.prepare(
+    `SELECT graphql_cursor, graphql_cursor_scope, graphql_cursor_scanned_prs,
+              graphql_cursor_matched_prs, graphql_cursor_page_size, graphql_cursor_reset_at,
+              graphql_cursor_reason, graphql_cursor_updated_at
+       FROM sync_state
+       WHERE repo = ?`
+  ).get(repo);
+  if (!row?.graphql_cursor_scope || row.graphql_cursor_scope !== scope) return void 0;
+  return {
+    repo,
+    scope,
+    cursor: row.graphql_cursor ?? null,
+    scannedPullRequests: row.graphql_cursor_scanned_prs ?? 0,
+    matchedMergedPullRequests: row.graphql_cursor_matched_prs ?? 0,
+    pageSize: row.graphql_cursor_page_size ?? 50,
+    resetAt: row.graphql_cursor_reset_at ?? void 0,
+    reason: row.graphql_cursor_reason ?? "GraphQL budget checkpoint",
+    updatedAt: row.graphql_cursor_updated_at ?? (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+}
+function saveGraphQLFetchCheckpoint(db, checkpoint) {
+  initializeSchema(db);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO sync_state
+     (repo, last_sync_at, last_indexed_pr, history_coverage, history_limit, history_since,
+      graphql_cursor, graphql_cursor_scope, graphql_cursor_scanned_prs,
+      graphql_cursor_matched_prs, graphql_cursor_page_size, graphql_cursor_reset_at,
+      graphql_cursor_reason, graphql_cursor_updated_at, updated_at)
+     VALUES (?, NULL, NULL, 'unknown', NULL, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(repo) DO UPDATE SET
+       graphql_cursor = excluded.graphql_cursor,
+       graphql_cursor_scope = excluded.graphql_cursor_scope,
+       graphql_cursor_scanned_prs = excluded.graphql_cursor_scanned_prs,
+       graphql_cursor_matched_prs = excluded.graphql_cursor_matched_prs,
+       graphql_cursor_page_size = excluded.graphql_cursor_page_size,
+       graphql_cursor_reset_at = excluded.graphql_cursor_reset_at,
+       graphql_cursor_reason = excluded.graphql_cursor_reason,
+       graphql_cursor_updated_at = excluded.graphql_cursor_updated_at,
+       updated_at = excluded.updated_at`
+  ).run(
+    checkpoint.repo,
+    checkpoint.cursor ?? null,
+    checkpoint.scope,
+    checkpoint.scannedPullRequests,
+    checkpoint.matchedMergedPullRequests,
+    checkpoint.pageSize,
+    checkpoint.resetAt ?? null,
+    checkpoint.reason,
+    checkpoint.updatedAt,
+    now
+  );
+}
+function clearGraphQLFetchCheckpoint(db, repo, scope) {
+  initializeSchema(db);
+  const row = db.prepare("SELECT graphql_cursor_scope FROM sync_state WHERE repo = ?").get(repo);
+  if (scope && row?.graphql_cursor_scope && row.graphql_cursor_scope !== scope) return;
+  db.prepare(
+    `UPDATE sync_state SET
+       graphql_cursor = NULL,
+       graphql_cursor_scope = NULL,
+       graphql_cursor_scanned_prs = NULL,
+       graphql_cursor_matched_prs = NULL,
+       graphql_cursor_page_size = NULL,
+       graphql_cursor_reset_at = NULL,
+       graphql_cursor_reason = NULL,
+       graphql_cursor_updated_at = NULL,
+       updated_at = ?
+     WHERE repo = ?`
+  ).run((/* @__PURE__ */ new Date()).toISOString(), repo);
+}
 function deleteExistingPrData(db, prId) {
   const unitRows = db.prepare("SELECT id FROM wisdom_units WHERE pr_id = ?").all(prId);
   const deleteFts = db.prepare("DELETE FROM wisdom_units_fts WHERE unitId = ?");
@@ -5942,6 +6035,25 @@ function getGitHubRateLimitDelayMs(error, attempt, now = Date.now()) {
     reason: `secondary rate limit backoff for ${backoffSeconds} seconds`
   };
 }
+function isGitHubGraphQLResourceLimitError(error) {
+  const message = (error.message ?? "").toLowerCase();
+  return message.includes("resource limit") || message.includes("timeout") || message.includes("timed out") || message.includes("couldn't respond") || message.includes("could not respond") || message.includes("exceeded") && message.includes("node");
+}
+function updateGitHubGraphQLRateLimitState(controller, rateLimit, requestName) {
+  if (!rateLimit || rateLimit.remaining !== 0 || !rateLimit.resetAt) return;
+  const resetAtMs = Date.parse(rateLimit.resetAt);
+  if (!Number.isFinite(resetAtMs)) return;
+  const now = controller.now?.() ?? Date.now();
+  const retryAtMs = Math.max(resetAtMs + 2e3, now);
+  controller.blockedUntilMs = Math.max(controller.blockedUntilMs ?? 0, retryAtMs);
+  controller.onRateLimit?.({
+    waitSeconds: Math.ceil(Math.max(0, retryAtMs - now) / 1e3),
+    retryAt: new Date(retryAtMs).toISOString(),
+    reason: `GraphQL rate limit exhausted${rateLimit.cost ? ` after query cost ${rateLimit.cost}` : ""}`,
+    request: requestName,
+    attempt: 1
+  });
+}
 async function sleep(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
@@ -5986,7 +6098,8 @@ async function paginateWithGitHubRateLimit(requestPage, options) {
   for (let page = 1; ; page += 1) {
     const response = await requestWithGitHubRateLimit(() => requestPage(page), {
       controller: options.controller,
-      requestName: `${options.requestName} page ${page}`
+      requestName: `${options.requestName} page ${page}`,
+      maxRetries: options.maxRetries
     });
     results.push(...response.data);
     if (!hasNextPage(response.headers) && response.data.length < 100) break;
@@ -5996,6 +6109,84 @@ async function paginateWithGitHubRateLimit(requestPage, options) {
   return results;
 }
 
+// src/github/graphql-client.ts
+var GitHubGraphQLError = class extends Error {
+  status;
+  response;
+  constructor(message, options) {
+    super(message);
+    this.name = "GitHubGraphQLError";
+    this.status = options.status;
+    this.response = { headers: options.headers };
+  }
+};
+function headersToRecord(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key.toLowerCase()] = value;
+  });
+  return result;
+}
+function errorStatus(status, errors) {
+  if (status === 403 || status === 429) return status;
+  const message = (errors ?? []).map((error) => error.message ?? "").join("\n").toLowerCase();
+  if (message.includes("rate limit") || message.includes("secondary limit")) return 403;
+  return status >= 400 ? status : 500;
+}
+function errorMessage(status, errors) {
+  const messages = (errors ?? []).map((error) => error.message).filter((message) => Boolean(message?.trim()));
+  if (messages.length > 0) return messages.join("; ");
+  return `GitHub GraphQL request failed with status ${status}.`;
+}
+function createGitHubGraphQLRequester(options) {
+  if (!options.token.trim()) {
+    throw new Error("GitHub authentication is required. Run gh auth login, or export GITHUB_TOKEN/GH_TOKEN.");
+  }
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) throw new Error("Global fetch is unavailable in this Node.js runtime.");
+  return async function requestGitHubGraphQL(query, variables, requestOptions) {
+    return requestWithGitHubRateLimit(
+      async () => {
+        const response = await fetchImpl("https://api.github.com/graphql", {
+          method: "POST",
+          headers: {
+            accept: "application/vnd.github+json",
+            authorization: `Bearer ${options.token}`,
+            "content-type": "application/json",
+            "user-agent": "anchor-local-mcp"
+          },
+          body: JSON.stringify({ query, variables })
+        });
+        const headers = headersToRecord(response.headers);
+        const raw = await response.json();
+        if (!response.ok || raw.errors?.length) {
+          throw new GitHubGraphQLError(errorMessage(response.status, raw.errors), {
+            status: errorStatus(response.status, raw.errors),
+            headers
+          });
+        }
+        if (!raw.data) {
+          throw new GitHubGraphQLError("GitHub GraphQL response did not include data.", {
+            status: response.status,
+            headers
+          });
+        }
+        updateGitHubGraphQLRateLimitState(
+          requestOptions.controller,
+          raw.data.rateLimit,
+          requestOptions.requestName
+        );
+        return { data: raw.data, headers };
+      },
+      {
+        controller: requestOptions.controller,
+        requestName: requestOptions.requestName,
+        maxRetries: requestOptions.maxRetries
+      }
+    );
+  };
+}
+
 // src/github/fetch-pr-details.ts
 async function fetchPullRequestDetails(octokit, repoFullName, pullNumber, controller = {}) {
   const [owner, repo] = repoFullName.split("/");
@@ -6116,6 +6307,756 @@ async function fetchPullRequestDetails(octokit, repoFullName, pullNumber, contro
   };
 }
 
+// src/github/fetch-prs-graphql.ts
+var MIN_PULL_REQUEST_PAGE_SIZE = 5;
+var INITIAL_PULL_REQUEST_PAGE_SIZE = 50;
+var MAX_PULL_REQUEST_PAGE_SIZE = 100;
+var REDUCED_PULL_REQUEST_PAGE_SIZES = [10, 5];
+var CONNECTION_PAGE_SIZE = 100;
+var GRAPHQL_RATE_LIMIT_RESERVE = 250;
+var GraphQLBudget = class {
+  constructor(reserve) {
+    this.reserve = reserve;
+  }
+  reserve;
+  activePageCost = 0;
+  averageCostPerPr;
+  latestRateLimit;
+  beginPage() {
+    this.activePageCost = 0;
+  }
+  observe(rateLimit) {
+    this.latestRateLimit = rateLimit ?? this.latestRateLimit;
+    if (typeof rateLimit?.cost === "number" && Number.isFinite(rateLimit.cost)) {
+      this.activePageCost += Math.max(0, rateLimit.cost);
+    }
+  }
+  completePage(prCount) {
+    if (prCount <= 0 || this.activePageCost <= 0) return;
+    const pageCostPerPr = this.activePageCost / prCount;
+    this.averageCostPerPr = this.averageCostPerPr === void 0 ? pageCostPerPr : this.averageCostPerPr * 0.65 + pageCostPerPr * 0.35;
+  }
+  shouldDefer() {
+    const remaining = this.latestRateLimit?.remaining;
+    return typeof remaining === "number" && remaining <= this.reserve;
+  }
+  rateLimit() {
+    return this.latestRateLimit;
+  }
+  choosePageSize(currentPageSize, remainingPrs) {
+    const remaining = this.latestRateLimit?.remaining;
+    const averageCostPerPr = this.averageCostPerPr;
+    if (typeof remaining !== "number" || remaining <= this.reserve || averageCostPerPr === void 0 || averageCostPerPr <= 0) {
+      return { pageSize: currentPageSize, averageCostPerPr };
+    }
+    const safeBudget = Math.max(0, remaining - this.reserve);
+    const budgetPageSize = Math.max(
+      MIN_PULL_REQUEST_PAGE_SIZE,
+      Math.min(MAX_PULL_REQUEST_PAGE_SIZE, Math.floor(safeBudget / averageCostPerPr))
+    );
+    const growthLimitedPageSize = budgetPageSize > currentPageSize ? Math.min(budgetPageSize, currentPageSize * 2) : budgetPageSize;
+    const cappedPageSize = remainingPrs === void 0 ? growthLimitedPageSize : Math.min(growthLimitedPageSize, Math.max(MIN_PULL_REQUEST_PAGE_SIZE, remainingPrs));
+    return {
+      pageSize: Math.max(MIN_PULL_REQUEST_PAGE_SIZE, Math.min(MAX_PULL_REQUEST_PAGE_SIZE, cappedPageSize)),
+      averageCostPerPr
+    };
+  }
+};
+var PULL_REQUEST_FIELDS = `
+  number
+  url
+  title
+  body
+  createdAt
+  mergedAt
+  updatedAt
+  author { login }
+  labels(first: 100) {
+    nodes { name }
+    pageInfo { hasNextPage endCursor }
+  }
+  files(first: 100) {
+    nodes { path additions deletions }
+    pageInfo { hasNextPage endCursor }
+  }
+  comments(first: 100) {
+    nodes { author { login } body createdAt }
+    pageInfo { hasNextPage endCursor }
+  }
+  reviews(first: 100) {
+    nodes {
+      id
+      author { login }
+      body
+      submittedAt
+      comments(first: 100) {
+        nodes { author { login } body path createdAt }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+  commits(first: 100) {
+    nodes { commit { message } }
+    pageInfo { hasNextPage endCursor }
+  }
+`;
+var LIST_MERGED_PULL_REQUESTS_QUERY = `
+query AnchorMergedPullRequests($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequests(states: MERGED, orderBy: { field: UPDATED_AT, direction: DESC }, first: $first, after: $after) {
+      nodes {
+        ${PULL_REQUEST_FIELDS}
+      }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+`;
+var PULL_REQUEST_FILES_QUERY = `
+query AnchorPullRequestFiles($owner: String!, $name: String!, $number: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      files(first: $first, after: $after) {
+        nodes { path additions deletions }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+`;
+var PULL_REQUEST_COMMENTS_QUERY = `
+query AnchorPullRequestComments($owner: String!, $name: String!, $number: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      comments(first: $first, after: $after) {
+        nodes { author { login } body createdAt }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+`;
+var PULL_REQUEST_REVIEWS_QUERY = `
+query AnchorPullRequestReviews($owner: String!, $name: String!, $number: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviews(first: $first, after: $after) {
+        nodes {
+          id
+          author { login }
+          body
+          submittedAt
+          comments(first: 100) {
+            nodes { author { login } body path createdAt }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+`;
+var PULL_REQUEST_COMMITS_QUERY = `
+query AnchorPullRequestCommits($owner: String!, $name: String!, $number: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      commits(first: $first, after: $after) {
+        nodes { commit { message } }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+`;
+var REVIEW_COMMENTS_QUERY = `
+query AnchorPullRequestReviewComments($reviewId: ID!, $first: Int!, $after: String) {
+  node(id: $reviewId) {
+    ... on PullRequestReview {
+      comments(first: $first, after: $after) {
+        nodes { author { login } body path createdAt }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+`;
+var RATE_LIMIT_QUERY = `
+query AnchorGraphQLRateLimit {
+  rateLimit { cost remaining resetAt }
+}
+`;
+function connectionNodes(connection) {
+  return (connection?.nodes ?? []).filter((node) => Boolean(node));
+}
+async function requestGraphQLWithBudget(requestGraphQL, query, variables, options) {
+  const response = await requestGraphQL(query, variables, {
+    controller: options.controller,
+    requestName: options.requestName
+  });
+  options.budget.observe(response.data.rateLimit);
+  return response;
+}
+function pageInfo(connection) {
+  return connection?.pageInfo ?? { hasNextPage: false, endCursor: null };
+}
+function labelName(label) {
+  return label.name ? { name: label.name } : void 0;
+}
+function mapChangedFile(file) {
+  if (!file.path) return void 0;
+  return {
+    filename: file.path,
+    additions: file.additions ?? 0,
+    deletions: file.deletions ?? 0
+  };
+}
+function mapIssueComment(comment) {
+  return {
+    user: comment.author?.login ? { login: comment.author.login } : null,
+    body: comment.body ?? "",
+    created_at: comment.createdAt ?? void 0
+  };
+}
+function mapReviewComment(comment) {
+  return {
+    user: comment.author?.login ? { login: comment.author.login } : null,
+    body: comment.body ?? "",
+    path: comment.path ?? void 0,
+    created_at: comment.createdAt ?? void 0
+  };
+}
+function mapReviewSummary(review) {
+  return {
+    user: review.author?.login ? { login: review.author.login } : null,
+    body: review.body ?? "",
+    created_at: review.submittedAt ?? void 0,
+    submitted_at: review.submittedAt ?? void 0
+  };
+}
+function mapPullRequest(repo, pull) {
+  return {
+    repo,
+    number: pull.number,
+    html_url: pull.url,
+    title: pull.title,
+    body: pull.body ?? "",
+    user: pull.author?.login ? { login: pull.author.login } : null,
+    labels: connectionNodes(pull.labels).map(labelName).filter((label) => Boolean(label)),
+    created_at: pull.createdAt,
+    merged_at: pull.mergedAt ?? void 0,
+    updated_at: pull.updatedAt ?? pull.mergedAt ?? pull.createdAt,
+    files: connectionNodes(pull.files).map(mapChangedFile).filter((file) => Boolean(file)),
+    reviews: connectionNodes(pull.reviews).map(mapReviewSummary),
+    reviewComments: connectionNodes(pull.reviews).flatMap(
+      (review) => connectionNodes(review.comments).map(mapReviewComment)
+    ),
+    issueComments: connectionNodes(pull.comments).map(mapIssueComment),
+    commits: connectionNodes(pull.commits).map((commit) => ({
+      commit: { message: commit.commit?.message ?? "" }
+    }))
+  };
+}
+async function requestConnection(requestGraphQL, query, connectionName, variables, options) {
+  const response = await requestGraphQLWithBudget(requestGraphQL, query, variables, options);
+  return response.data.repository?.pullRequest?.[connectionName];
+}
+async function appendAdditionalFiles(requestGraphQL, record, initialConnection, options) {
+  let info = pageInfo(initialConnection);
+  while (info.hasNextPage && info.endCursor) {
+    const connection = await requestConnection(
+      requestGraphQL,
+      PULL_REQUEST_FILES_QUERY,
+      "files",
+      {
+        owner: options.owner,
+        name: options.name,
+        number: record.number,
+        first: CONNECTION_PAGE_SIZE,
+        after: info.endCursor
+      },
+      {
+        controller: options.controller,
+        requestName: `GraphQL /repos/${record.repo}/pulls/${record.number}/files`,
+        budget: options.budget
+      }
+    );
+    record.files.push(
+      ...connectionNodes(connection).map(mapChangedFile).filter((file) => Boolean(file))
+    );
+    info = pageInfo(connection);
+  }
+}
+async function appendAdditionalIssueComments(requestGraphQL, record, initialConnection, options) {
+  let info = pageInfo(initialConnection);
+  while (info.hasNextPage && info.endCursor) {
+    const connection = await requestConnection(
+      requestGraphQL,
+      PULL_REQUEST_COMMENTS_QUERY,
+      "comments",
+      {
+        owner: options.owner,
+        name: options.name,
+        number: record.number,
+        first: CONNECTION_PAGE_SIZE,
+        after: info.endCursor
+      },
+      {
+        controller: options.controller,
+        requestName: `GraphQL /repos/${record.repo}/issues/${record.number}/comments`,
+        budget: options.budget
+      }
+    );
+    record.issueComments?.push(...connectionNodes(connection).map(mapIssueComment));
+    info = pageInfo(connection);
+  }
+}
+async function appendAdditionalCommits(requestGraphQL, record, initialConnection, options) {
+  let info = pageInfo(initialConnection);
+  while (info.hasNextPage && info.endCursor) {
+    const connection = await requestConnection(
+      requestGraphQL,
+      PULL_REQUEST_COMMITS_QUERY,
+      "commits",
+      {
+        owner: options.owner,
+        name: options.name,
+        number: record.number,
+        first: CONNECTION_PAGE_SIZE,
+        after: info.endCursor
+      },
+      {
+        controller: options.controller,
+        requestName: `GraphQL /repos/${record.repo}/pulls/${record.number}/commits`,
+        budget: options.budget
+      }
+    );
+    record.commits?.push(
+      ...connectionNodes(connection).map((commit) => ({
+        commit: { message: commit.commit?.message ?? "" }
+      }))
+    );
+    info = pageInfo(connection);
+  }
+}
+async function appendAdditionalReviewComments(requestGraphQL, record, review, options) {
+  let info = pageInfo(review.comments);
+  while (info.hasNextPage && info.endCursor) {
+    const response = await requestGraphQLWithBudget(
+      requestGraphQL,
+      REVIEW_COMMENTS_QUERY,
+      {
+        reviewId: review.id,
+        first: CONNECTION_PAGE_SIZE,
+        after: info.endCursor
+      },
+      {
+        controller: options.controller,
+        requestName: `GraphQL /pull-request-reviews/${review.id}/comments`,
+        budget: options.budget
+      }
+    );
+    const connection = response.data.node?.comments;
+    record.reviewComments?.push(...connectionNodes(connection).map(mapReviewComment));
+    info = pageInfo(connection);
+  }
+}
+async function appendAdditionalReviews(requestGraphQL, record, initialConnection, options) {
+  const reviewsToHydrate = [...connectionNodes(initialConnection)];
+  let info = pageInfo(initialConnection);
+  while (info.hasNextPage && info.endCursor) {
+    const connection = await requestConnection(
+      requestGraphQL,
+      PULL_REQUEST_REVIEWS_QUERY,
+      "reviews",
+      {
+        owner: options.owner,
+        name: options.name,
+        number: record.number,
+        first: CONNECTION_PAGE_SIZE,
+        after: info.endCursor
+      },
+      {
+        controller: options.controller,
+        requestName: `GraphQL /repos/${record.repo}/pulls/${record.number}/reviews`,
+        budget: options.budget
+      }
+    );
+    const reviewNodes = connectionNodes(connection);
+    reviewsToHydrate.push(...reviewNodes);
+    record.reviews?.push(...reviewNodes.map(mapReviewSummary));
+    record.reviewComments?.push(
+      ...reviewNodes.flatMap((review) => connectionNodes(review.comments).map(mapReviewComment))
+    );
+    info = pageInfo(connection);
+  }
+  for (const review of reviewsToHydrate) {
+    await appendAdditionalReviewComments(requestGraphQL, record, review, {
+      controller: options.controller,
+      budget: options.budget
+    });
+  }
+}
+async function hydratePullRequestNestedConnections(requestGraphQL, record, pull, options) {
+  await appendAdditionalFiles(requestGraphQL, record, pull.files, options);
+  await appendAdditionalIssueComments(requestGraphQL, record, pull.comments, options);
+  await appendAdditionalReviews(requestGraphQL, record, pull.reviews, options);
+  await appendAdditionalCommits(requestGraphQL, record, pull.commits, options);
+}
+function mergePatchFiles(record, patchFiles) {
+  const byFilename = new Map(patchFiles.map((file) => [file.filename, file]));
+  let patches = 0;
+  record.files = record.files.map((file) => {
+    const patchFile = byFilename.get(file.filename);
+    if (!patchFile) return file;
+    if (patchFile.patch) patches += 1;
+    return {
+      ...file,
+      additions: patchFile.additions ?? file.additions,
+      deletions: patchFile.deletions ?? file.deletions,
+      patch: patchFile.patch ?? file.patch
+    };
+  });
+  const existing = new Set(record.files.map((file) => file.filename));
+  for (const patchFile of patchFiles) {
+    if (!existing.has(patchFile.filename)) {
+      record.files.push(patchFile);
+      if (patchFile.patch) patches += 1;
+    }
+  }
+  return patches;
+}
+async function fetchPullRequestPatchFiles(octokit, repoFullName, pullNumber, controller) {
+  const [owner, repo] = repoFullName.split("/");
+  if (!owner || !repo) throw new Error(`Invalid repo '${repoFullName}'. Expected owner/name.`);
+  const files = await paginateWithGitHubRateLimit(
+    (page) => octokit.pulls.listFiles({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      per_page: 100,
+      page
+    }),
+    {
+      controller,
+      requestName: `GET /repos/${repoFullName}/pulls/${pullNumber}/files`,
+      maxRetries: 0
+    }
+  );
+  return files.map((file) => ({
+    filename: file.filename,
+    patch: "patch" in file ? file.patch : void 0,
+    additions: file.additions,
+    deletions: file.deletions
+  }));
+}
+async function enrichPullRequestPatchesWithRest(options) {
+  const octokit = options.restClient ?? createGitHubClient(options.token);
+  let nextIndex = 0;
+  let completed = 0;
+  const workerCount = Math.min(options.detailConcurrency, options.records.length);
+  async function worker() {
+    while (nextIndex < options.records.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const record = options.records[index];
+      if (!record) continue;
+      options.onProgress?.({
+        stage: "enriching_pull_request_patches",
+        repo: options.repo,
+        current: index + 1,
+        total: options.records.length,
+        prNumber: record.number,
+        detailConcurrency: options.detailConcurrency
+      });
+      try {
+        const patchFiles = await fetchPullRequestPatchFiles(
+          octokit,
+          options.repo,
+          record.number,
+          options.controller
+        );
+        const patches = mergePatchFiles(record, patchFiles);
+        completed += 1;
+        options.onProgress?.({
+          stage: "enriched_pull_request_patches",
+          repo: options.repo,
+          current: completed,
+          total: options.records.length,
+          prNumber: record.number,
+          detailConcurrency: options.detailConcurrency,
+          patches
+        });
+      } catch (error) {
+        completed += 1;
+        if (!isGitHubRateLimitError(error)) {
+          options.onProgress?.({
+            stage: "skipped_pull_request_patch_enrichment",
+            repo: options.repo,
+            current: completed,
+            total: options.records.length,
+            prNumber: record.number,
+            reason: error instanceof Error ? error.message : String(error)
+          });
+          continue;
+        }
+        options.onProgress?.({
+          stage: "skipped_pull_request_patch_enrichment",
+          repo: options.repo,
+          current: completed,
+          total: options.records.length,
+          prNumber: record.number,
+          reason: "GitHub REST rate limit reached during patch enrichment"
+        });
+      }
+    }
+  }
+  if (workerCount > 0) await Promise.all(Array.from({ length: workerCount }, () => worker()));
+}
+function nextReducedPageSize(current) {
+  return REDUCED_PULL_REQUEST_PAGE_SIZES.find((candidate) => candidate < current);
+}
+function checkpointFromState(options) {
+  return {
+    repo: options.repo,
+    scope: options.scope,
+    cursor: options.cursor ?? null,
+    scannedPullRequests: options.scannedPullRequests,
+    matchedMergedPullRequests: options.matchedMergedPullRequests,
+    pageSize: options.pageSize,
+    resetAt: options.rateLimit?.resetAt ?? void 0,
+    reason: options.reason,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function fetchMergedPullRequestsWithGraphQL(options) {
+  const [owner, name] = options.repo.split("/");
+  if (!owner || !name) throw new Error(`Invalid repo '${options.repo}'. Expected owner/name.`);
+  const requestGraphQL = createGitHubGraphQLRequester({
+    token: options.token,
+    fetchImpl: options.fetchImpl
+  });
+  const sinceTime = options.since ? Date.parse(options.since) : void 0;
+  const records = [];
+  const checkpoint = options.graphQLCheckpoint;
+  const baseScannedPullRequests = checkpoint?.scannedPullRequests ?? 0;
+  const baseMatchedMergedPullRequests = checkpoint?.matchedMergedPullRequests ?? 0;
+  let scannedPullRequests = baseScannedPullRequests;
+  let reachedSinceBoundary = false;
+  let cursor = checkpoint?.cursor ?? void 0;
+  let pageSize = Math.min(
+    MAX_PULL_REQUEST_PAGE_SIZE,
+    checkpoint?.pageSize ?? Math.min(INITIAL_PULL_REQUEST_PAGE_SIZE, options.limit ?? INITIAL_PULL_REQUEST_PAGE_SIZE)
+  );
+  const budget = new GraphQLBudget(GRAPHQL_RATE_LIMIT_RESERVE);
+  const checkpointScope = checkpoint?.scope ?? `${options.repo}|${options.limit === void 0 ? "all" : `limit:${options.limit}`}|since:${options.since ?? ""}`;
+  options.onProgress?.({
+    stage: "discovering_pull_requests",
+    repo: options.repo,
+    all: options.limit === void 0,
+    limit: options.limit,
+    since: options.since,
+    backend: "graphql"
+  });
+  if (checkpoint) {
+    options.onProgress?.({
+      stage: "github_graphql_checkpoint_resumed",
+      repo: options.repo,
+      scannedPullRequests: checkpoint.scannedPullRequests,
+      matchedMergedPullRequests: checkpoint.matchedMergedPullRequests,
+      pageSize: checkpoint.pageSize,
+      resetAt: checkpoint.resetAt
+    });
+  }
+  await requestGraphQLWithBudget(
+    requestGraphQL,
+    RATE_LIMIT_QUERY,
+    {},
+    {
+      controller: options.controller,
+      requestName: "GraphQL rate limit preflight",
+      budget
+    }
+  );
+  const preflightRateLimit = budget.rateLimit();
+  if (budget.shouldDefer()) {
+    options.onGraphQLCheckpoint?.(
+      checkpointFromState({
+        repo: options.repo,
+        scope: checkpointScope,
+        cursor: cursor ?? null,
+        scannedPullRequests,
+        matchedMergedPullRequests: baseMatchedMergedPullRequests,
+        pageSize,
+        rateLimit: preflightRateLimit,
+        reason: "GraphQL budget safety reserve reached before fetching another page"
+      })
+    );
+    options.onProgress?.({
+      stage: "github_graphql_budget_deferred",
+      repo: options.repo,
+      remaining: preflightRateLimit?.remaining,
+      reserve: GRAPHQL_RATE_LIMIT_RESERVE,
+      resetAt: preflightRateLimit?.resetAt,
+      matchedMergedPullRequests: baseMatchedMergedPullRequests
+    });
+    return records;
+  }
+  if (typeof preflightRateLimit?.remaining === "number") {
+    const preflightPageSize = Math.max(
+      MIN_PULL_REQUEST_PAGE_SIZE,
+      Math.min(
+        pageSize,
+        Math.floor((preflightRateLimit.remaining - GRAPHQL_RATE_LIMIT_RESERVE) / 4)
+      )
+    );
+    if (preflightPageSize !== pageSize) {
+      options.onProgress?.({
+        stage: "github_graphql_page_size_selected",
+        repo: options.repo,
+        previousPageSize: pageSize,
+        nextPageSize: preflightPageSize,
+        remaining: preflightRateLimit.remaining
+      });
+      pageSize = preflightPageSize;
+    }
+  }
+  while (true) {
+    let response;
+    budget.beginPage();
+    try {
+      response = await requestGraphQLWithBudget(
+        requestGraphQL,
+        LIST_MERGED_PULL_REQUESTS_QUERY,
+        {
+          owner,
+          name,
+          first: pageSize,
+          after: cursor ?? null
+        },
+        {
+          controller: options.controller,
+          requestName: `GraphQL /repos/${options.repo}/pullRequests`,
+          budget
+        }
+      );
+    } catch (error) {
+      const reducedPageSize = isGitHubGraphQLResourceLimitError(error) ? nextReducedPageSize(pageSize) : void 0;
+      if (!reducedPageSize) throw error;
+      options.onProgress?.({
+        stage: "github_graphql_page_size_reduced",
+        repo: options.repo,
+        previousPageSize: pageSize,
+        nextPageSize: reducedPageSize,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      pageSize = reducedPageSize;
+      continue;
+    }
+    const connection = response.data.repository?.pullRequests;
+    const pullNodes = connectionNodes(connection);
+    scannedPullRequests += pullNodes.length;
+    const recordsBeforePage = records.length;
+    for (const pull of pullNodes) {
+      if (sinceTime && Date.parse(pull.updatedAt ?? pull.mergedAt ?? pull.createdAt) < sinceTime) {
+        reachedSinceBoundary = true;
+        break;
+      }
+      if (!pull.mergedAt) continue;
+      const record = mapPullRequest(options.repo, pull);
+      await hydratePullRequestNestedConnections(requestGraphQL, record, pull, {
+        owner,
+        name,
+        controller: options.controller,
+        budget
+      });
+      records.push(record);
+      if (options.limit !== void 0 && records.length >= options.limit) break;
+    }
+    const pageMatchedPullRequests = records.length - recordsBeforePage;
+    budget.completePage(pageMatchedPullRequests);
+    options.onProgress?.({
+      stage: "scanned_pull_request_page",
+      repo: options.repo,
+      all: options.limit === void 0,
+      limit: options.limit,
+      scannedPullRequests,
+      matchedMergedPullRequests: baseMatchedMergedPullRequests + records.length,
+      backend: "graphql",
+      pageSize
+    });
+    const info = pageInfo(connection);
+    const totalMatchedMergedPullRequests = baseMatchedMergedPullRequests + records.length;
+    if (info.hasNextPage && info.endCursor && budget.shouldDefer()) {
+      const rateLimit = budget.rateLimit();
+      const checkpointToSave = checkpointFromState({
+        repo: options.repo,
+        scope: checkpointScope,
+        cursor: info.endCursor,
+        scannedPullRequests,
+        matchedMergedPullRequests: totalMatchedMergedPullRequests,
+        pageSize,
+        rateLimit,
+        reason: "GraphQL budget safety reserve reached"
+      });
+      options.onGraphQLCheckpoint?.(checkpointToSave);
+      options.onProgress?.({
+        stage: "github_graphql_budget_deferred",
+        repo: options.repo,
+        remaining: rateLimit?.remaining,
+        reserve: GRAPHQL_RATE_LIMIT_RESERVE,
+        resetAt: rateLimit?.resetAt,
+        matchedMergedPullRequests: totalMatchedMergedPullRequests
+      });
+      break;
+    }
+    if (reachedSinceBoundary || options.limit !== void 0 && records.length >= options.limit || !info.hasNextPage || !info.endCursor) {
+      options.onGraphQLCheckpoint?.(null);
+      break;
+    }
+    cursor = info.endCursor;
+    const remainingPrs = options.limit === void 0 ? void 0 : Math.max(0, options.limit - records.length);
+    const decision = budget.choosePageSize(pageSize, remainingPrs);
+    if (decision.pageSize !== pageSize) {
+      options.onProgress?.({
+        stage: "github_graphql_page_size_selected",
+        repo: options.repo,
+        previousPageSize: pageSize,
+        nextPageSize: decision.pageSize,
+        remaining: budget.rateLimit()?.remaining,
+        averageCostPerPr: decision.averageCostPerPr
+      });
+      pageSize = decision.pageSize;
+    }
+  }
+  options.onProgress?.({
+    stage: "discovered_pull_requests",
+    repo: options.repo,
+    all: options.limit === void 0,
+    total: records.length,
+    limit: options.limit,
+    detailConcurrency: options.detailConcurrency,
+    backend: "graphql"
+  });
+  await enrichPullRequestPatchesWithRest({
+    records,
+    repo: options.repo,
+    token: options.token,
+    detailConcurrency: options.detailConcurrency,
+    controller: options.restController ?? options.controller,
+    onProgress: options.onProgress,
+    restClient: options.restClient
+  });
+  return records;
+}
+
 // src/github/fetch-prs.ts
 function resolvePullRequestFetchLimit(options) {
   return options.all ? void 0 : Math.max(1, Math.min(options.limit ?? 200, 1e3));
@@ -6125,6 +7066,18 @@ function resolvePullRequestDetailConcurrency(options) {
   if (!Number.isFinite(value)) return 5;
   return Math.max(1, Math.min(Math.trunc(value), 10));
 }
+function createProgressRateLimitController(repo, onProgress) {
+  return {
+    onRateLimit: (progress) => onProgress?.({
+      stage: "github_rate_limited",
+      repo,
+      ...progress
+    })
+  };
+}
+function shouldFallbackToRestAfterGraphQLError(error) {
+  return !isGitHubRateLimitError(error) && !isGitHubGraphQLResourceLimitError(error);
+}
 async function fetchPullRequestDetailsConcurrently(options) {
   const results = new Array(options.pullNumbers.length);
   let nextIndex = 0;
@@ -6169,19 +7122,12 @@ async function fetchPullRequestDetailsConcurrently(options) {
     return result;
   });
 }
-async function fetchMergedPullRequests(options) {
+async function fetchMergedPullRequestsWithRest(options, rateLimitController) {
   const [owner, repo] = options.repo.split("/");
   if (!owner || !repo) throw new Error(`Invalid repo '${options.repo}'. Expected owner/name.`);
-  const octokit = createGitHubClient(options.token);
+  const octokit = options.restClient ?? createGitHubClient(options.token);
   const limit = resolvePullRequestFetchLimit(options);
   const detailConcurrency = resolvePullRequestDetailConcurrency(options);
-  const rateLimitController = {
-    onRateLimit: (progress) => options.onProgress?.({
-      stage: "github_rate_limited",
-      repo: options.repo,
-      ...progress
-    })
-  };
   const sinceTime = options.since ? Date.parse(options.since) : void 0;
   const pullNumbers = [];
   let scannedPullRequests = 0;
@@ -6192,7 +7138,8 @@ async function fetchMergedPullRequests(options) {
     repo: options.repo,
     all: limit === void 0,
     limit,
-    since: options.since
+    since: options.since,
+    backend: "rest"
   });
   while (true) {
     const response = await requestWithGitHubRateLimit(
@@ -6226,7 +7173,8 @@ async function fetchMergedPullRequests(options) {
       all: limit === void 0,
       limit,
       scannedPullRequests,
-      matchedMergedPullRequests: pullNumbers.length
+      matchedMergedPullRequests: pullNumbers.length,
+      backend: "rest"
     });
     const hasNextPage2 = String(response.headers.link ?? "").includes('rel="next"');
     if (reachedSinceBoundary || limit !== void 0 && pullNumbers.length >= limit || !hasNextPage2) {
@@ -6240,7 +7188,8 @@ async function fetchMergedPullRequests(options) {
     all: limit === void 0,
     total: pullNumbers.length,
     limit,
-    detailConcurrency
+    detailConcurrency,
+    backend: "rest"
   });
   return fetchPullRequestDetailsConcurrently({
     octokit,
@@ -6251,6 +7200,42 @@ async function fetchMergedPullRequests(options) {
     onProgress: options.onProgress
   });
 }
+async function fetchMergedPullRequests(options) {
+  const limit = resolvePullRequestFetchLimit(options);
+  const detailConcurrency = resolvePullRequestDetailConcurrency(options);
+  const graphqlRateLimitController = createProgressRateLimitController(
+    options.repo,
+    options.onProgress
+  );
+  const restRateLimitController = createProgressRateLimitController(options.repo, options.onProgress);
+  try {
+    return await fetchMergedPullRequestsWithGraphQL({
+      token: options.token,
+      repo: options.repo,
+      limit,
+      all: options.all,
+      detailConcurrency,
+      since: options.since,
+      controller: graphqlRateLimitController,
+      restController: restRateLimitController,
+      graphQLCheckpoint: options.graphQLCheckpoint,
+      onGraphQLCheckpoint: options.onGraphQLCheckpoint,
+      onProgress: options.onProgress,
+      fetchImpl: options.fetchImpl,
+      restClient: options.restClient
+    });
+  } catch (error) {
+    if (!shouldFallbackToRestAfterGraphQLError(error)) throw error;
+    options.onProgress?.({
+      stage: "github_fetch_backend_fallback",
+      repo: options.repo,
+      from: "graphql",
+      to: "rest",
+      reason: error instanceof Error ? error.message : String(error)
+    });
+    return fetchMergedPullRequestsWithRest(options, restRateLimitController);
+  }
+}
 
 // src/doctor.ts
 import fs9 from "fs";
@@ -6315,6 +7300,49 @@ async function runDoctor(options) {
       )
     );
   }
+  if (token) {
+    try {
+      const graphqlOk = options.githubGraphQLCheck !== void 0 ? Boolean(await options.githubGraphQLCheck(token)) : options.githubClientFactory !== void 0 ? true : Boolean(
+        await createGitHubGraphQLRequester({ token })(
+          `query AnchorDoctorGraphQL {
+                    viewer { login }
+                    rateLimit { cost remaining resetAt }
+                  }`,
+          {},
+          {
+            controller: {},
+            requestName: "GraphQL doctor reachability check"
+          }
+        )
+      );
+      checks.push(
+        check(
+          "GitHub GraphQL reachable",
+          graphqlOk,
+          graphqlOk ? "GitHub GraphQL API is reachable." : "GitHub GraphQL API check returned an unsuccessful result.",
+          "Check token scope, network access, and GraphQL rate limits. Use read-only repo access."
+        )
+      );
+    } catch (error) {
+      checks.push(
+        check(
+          "GitHub GraphQL reachable",
+          false,
+          `GitHub GraphQL check failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Check token scope, network access, and GraphQL rate limits. Use read-only repo access."
+        )
+      );
+    }
+  } else {
+    checks.push(
+      check(
+        "GitHub GraphQL reachable",
+        false,
+        "Skipped because token is missing.",
+        githubAuthFixMessage()
+      )
+    );
+  }
   const cursorConfigPath = path20.join(gitRoot ?? cwd, ".cursor", "mcp.json");
   let cursorConfig;
   let cursorConfigValid = false;
@@ -6444,6 +7472,7 @@ export {
   DEMO_CODE_FILES,
   DEMO_PULL_REQUESTS,
   DEMO_REPO,
+  GitHubGraphQLError,
   SCHEMA_SQL,
   TEAM_RULES_FILE,
   addRetrievalEval,
@@ -6467,6 +7496,7 @@ export {
   claimKeyFor,
   clampMaxResults,
   classifyArchitectureArea,
+  clearGraphQLFetchCheckpoint,
   clipSentence,
   confidenceAtLeast,
   confidenceLevelFor,
@@ -6474,6 +7504,7 @@ export {
   confidenceReasonsFor,
   countValidTeamRules,
   createGitHubClient,
+  createGitHubGraphQLRequester,
   defaultDatabasePath,
   detectGitHubRepo,
   detectGitRoot,
@@ -6498,6 +7529,7 @@ export {
   extractWisdomUnits,
   feedbackAdjustedScore,
   fetchMergedPullRequests,
+  fetchMergedPullRequestsWithGraphQL,
   fetchPullRequestDetails,
   filesFromDiff,
   formatAnchorContext,
@@ -6507,6 +7539,7 @@ export {
   getArchitectureContext,
   getArchitectureMapContext,
   getGitHubRateLimitDelayMs,
+  getGraphQLFetchCheckpoint,
   getIndexStatus,
   getLastSyncTime,
   getPlaybook,
@@ -6515,6 +7548,7 @@ export {
   getSuggestedPrompts,
   getWisdomCategoryCounts,
   githubAuthFixMessage,
+  graphQLFetchCheckpointScope,
   hasHighSignalLanguage,
   indexCodebase,
   indexPullRequests,
@@ -6522,6 +7556,7 @@ export {
   initPlaybooks,
   initRetrievalEvals,
   initializeSchema,
+  isGitHubGraphQLResourceLimitError,
   isGitHubRateLimitError,
   isHardExcludedCodePath,
   isTestFilePath,
@@ -6557,6 +7592,8 @@ export {
   runDoctor,
   runRetrievalEvals,
   sanitizeHistoricalText,
+  saveGraphQLFetchCheckpoint,
+  shouldFallbackToRestAfterGraphQLError,
   shouldSyncSince,
   sourceTypeLabel,
   stripPromptInjection,
@@ -6566,6 +7603,7 @@ export {
   tokenizeSearchText,
   truncateText,
   uniqueStrings,
+  updateGitHubGraphQLRateLimitState,
   updateSyncState,
   upsertPullRequest,
   validateTeamRulesFile,