@volter/twin-github 0.1.2 → 2.0.1

package/src/github-graphql.ts

@@ -1,398 +0,0 @@
-// GitHub GraphQL API (v4) — a FAITHFUL SUBSET over the SAME projection the REST twin serves.
-// GitHub's GraphQL graph is enormous; this models a deliberately small, real slice and is
-// HONEST about its partial coverage: a field the twin does not model raises an
-// `undefinedField`-style GraphQL error (the same error class GitHub raises), rather than
-// fabricating a value. The op is resolved against `githubState` (the kernel projection) so it
-// is consistent with the REST surface byte-for-byte.
-//
-// Modeled subset:
-//   query { viewer { login name } }
-//   query { repository(owner, name) { name nameWithOwner isPrivate
-//             pullRequests(first) { totalCount nodes { number title state } }
-//             issues(first) { totalCount nodes { number title state } } } }
-//   query { node(id) { ... on PullRequest { number title } } }   — id = "PR_<owner>/<repo>#<n>"
-//   mutation { addComment(input: { subjectId, body }) { commentEdge { node { id body } } } }
-//   query { repository(owner, name) { discussions(first) { nodes { id number title body category { name slug isAnswerable }
-//             comments { nodes { id body isAnswer } } } } } }   — id = "D_<owner>/<repo>#<n>"
-//   mutation { addDiscussionComment(input: { discussionId, body, replyToId? }) { comment { id body url } } }
-// Anything else (other root fields, unmodeled selection fields) → a typed GraphQL error.
-import { applyGithubWrite, prPlaneDiffFiles } from './github-twin.ts';
-import { githubState, type GithubState } from './github-twin.ts';
-
-export type GraphqlResult = { data?: Record<string, unknown> | null; errors?: Array<{ message: string; type?: string }> };
-
-// A field the twin doesn't model — surfaced as GitHub's `undefinedField` error class (honest
-// partial coverage). The query still fails rather than returning a fabricated value.
-function unmodeled(field: string, onType: string): { message: string; type: string } {
-  return { message: `Field '${field}' doesn't exist on type '${onType}' in the twin's modeled GraphQL subset`, type: 'undefinedField' };
-}
-
-// The fields the twin models per type — a selection naming anything else is an honest error.
-const VIEWER_FIELDS = new Set(['login', 'name', '__typename']);
-// `repo` appears as a token from the `...repo` fragment spread gh's RepositoryInfo query uses; the
-// fragment's own fields live in a separate `fragment repo on Repository {…}` block (validated below).
-const REPO_FIELDS = new Set([
-  'name', 'nameWithOwner', 'isPrivate', 'pullRequests', 'issues', '__typename',
-  // RepositoryInfo (gh pr create / gh repo view): the `repo` fragment + repo-level merge settings.
-  'id', 'owner', 'login', 'hasIssuesEnabled', 'description', 'hasWikiEnabled', 'viewerPermission',
-  'defaultBranchRef', 'parent', 'mergeCommitAllowed', 'rebaseMergeAllowed', 'squashMergeAllowed', 'repo',
-  // gh pr view <n> / gh issue view <n> resolve ONE node by number.
-  'pullRequest', 'issue',
-  // Discussions: real GitHub serves them over GraphQL alone (repository.discussions; addDiscussionComment).
-  'discussions',
-]);
-const DISCUSSION_FIELDS = new Set(['id', 'number', 'title', 'body', 'url', 'createdAt', 'updatedAt', 'category', 'name', 'slug', 'isAnswerable', 'comments', 'author', 'login', 'isAnswered', 'closed', 'locked', '__typename']);
-// The single-PR fields `gh pr view --json …` selects — the exact set the repo's own
-// merge-gate scripts read (headRefOid/state/baseRefName/statusCheckRollup/
-// closingIssuesReferences/changedFiles/labels/body/comments/assignees/reviewRequests; see
-// scripts/human-approval-gate.ts, break-glass-gate.ts, finalize-agent-review.ts,
-// review-prerequisites.ts). `statusCheckRollup` is gh's ALIAS for commits(last:1){…} — the
-// token list admits both spellings. Anything else stays an honest undefinedField error.
-const PR_VIEW_FIELDS = new Set([
-  'number', 'id', 'url', 'title', 'state', 'body', 'isDraft', 'headRefOid', 'headRefName',
-  'baseRefName', 'changedFiles', 'additions', 'deletions', 'createdAt', 'updatedAt', 'closedAt',
-  'mergedAt', 'labels', 'closingIssuesReferences', 'statusCheckRollup', 'commits', 'comments',
-  'assignees', 'reviewRequests', '__typename',
-]);
-// The single-issue fields `gh issue view --json …` selects (human-approval-gate reads a
-// linked issue's labels; finalize-agent-review reads its comments and posts one).
-const ISSUE_VIEW_FIELDS = new Set([
-  'number', 'id', 'url', 'title', 'state', 'body', 'labels', 'comments', 'assignees',
-  'createdAt', 'updatedAt', 'closedAt', 'author', '__typename',
-]);
-const PR_FIELDS = new Set(['number', 'title', 'state', 'id', '__typename',
-  // PR connection node fields gh pr view/list select (modeled from the PR projection).
-  'url', 'baseRefName', 'headRefName', 'isCrossRepository', 'headRepositoryOwner', 'login', 'name']);
-const ISSUE_FIELDS = new Set(['number', 'title', 'state', 'id', '__typename']);
-// Relay connection-level fields valid alongside nodes/totalCount (not object fields).
-const CONNECTION_FIELDS = new Set(['totalCount', 'nodes', 'edges', 'pageInfo', 'node', 'cursor', 'endCursor', 'hasNextPage', '__typename']);
-
-// Extract the inner-brace selection-set field names for a given parent (very small parser —
-// sufficient for the modeled subset; it reads identifiers, ignoring args/aliases/nesting we
-// resolve explicitly). Returns the top-level selected names under the FIRST `{...}` after the
-// parent token.
-function selectionFields(query: string, parentToken: string): string[] {
-  const idx = query.indexOf(parentToken);
-  if (idx < 0) return [];
-  // Skip an optional argument list `(...)` after the parent token BEFORE locating the selection
-  // set — real gh queries put object args there (e.g. `orderBy: { field: CREATED_AT }`), and the
-  // naive `indexOf('{')` would otherwise mistake that argument brace for the selection set.
-  let p = idx + parentToken.length;
-  while (p < query.length && /\s/.test(query[p]!)) p++;
-  if (query[p] === '(') { let d = 0; for (; p < query.length; p++) { if (query[p] === '(') d++; else if (query[p] === ')') { d--; if (d === 0) { p++; break; } } } }
-  const open = query.indexOf('{', p);
-  if (open < 0) return [];
-  let depth = 0; let end = -1;
-  for (let i = open; i < query.length; i++) { if (query[i] === '{') depth++; else if (query[i] === '}') { depth--; if (depth === 0) { end = i; break; } } }
-  if (end < 0) return [];
-  let inner = query.slice(open + 1, end);
-  // iteratively strip ALL nested blocks (and arg parens) so we only see THIS level's fields.
-  let prev = '';
-  while (prev !== inner) { prev = inner; inner = inner.replace(/\{[^{}]*\}/g, ' '); }
-  inner = inner.replace(/\([^()]*\)/g, ' ');
-  return [...inner.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)].map((m) => m[0]).filter((t) => t !== 'on');
-}
-
-// Resolve an argument value for `argName` from the query text: a string literal `arg:"x"` or
-// a variable reference `arg:$v` (looked up in `variables`). Returns undefined when absent.
-function argValue(query: string, argName: string, variables: Record<string, unknown>): string | undefined {
-  const lit = new RegExp(`${argName}:\\s*"([^"]*)"`).exec(query);
-  if (lit) return lit[1];
-  const num = new RegExp(`${argName}:\\s*(-?\\d+)`).exec(query); // Int literal (pullRequest(number: 2))
-  if (num) return num[1];
-  const ref = new RegExp(`${argName}:\\s*\\$([A-Za-z_][A-Za-z0-9_]*)`).exec(query);
-  if (ref && variables[ref[1]!] !== undefined) return String(variables[ref[1]!]);
-  return undefined;
-}
-
-function repoToNodes(state: GithubState, repo: string) {
-  const owner = repo.split('/')[0]!;
-  const prs = state.prs.filter((p) => p.repository === repo).map((p) => ({
-    number: p.number, title: p.title ?? null, state: (p.merged ? 'MERGED' : (p.state ?? 'open')).toUpperCase(), id: `PR_${repo}#${p.number}`,
-    // PR connection node fields gh's `pr view`/`pr list` request — all from the SAME PR projection.
-    url: `https://github.com/${repo}/pull/${p.number}`, baseRefName: p.base_ref ?? null, headRefName: p.head_ref ?? null,
-    isCrossRepository: false, headRepositoryOwner: { id: `U_${owner}`, login: owner, name: null },
-  }));
-  const issues = state.issues.filter((i) => i.repository === repo).map((i) => ({ number: i.number, title: i.title ?? null, state: (i.state ?? 'open').toUpperCase(), id: `I_${repo}#${i.number}` }));
-  return { prs, issues };
-}
-
-/** Resolve a GraphQL operation against the github world (the SAME projection as REST). */
-export async function resolveGithubGraphql(req: { query: string; variables?: Record<string, unknown>; root?: string }): Promise<GraphqlResult> {
-  const query = req.query;
-  const vars = req.variables ?? {};
-  const state = githubState(req.root);
-  const isMutation = /^\s*mutation\b/.test(query);
-
-  // ── mutation addComment(input: { subjectId, body }) ──────────────────────────────────────
-  if (isMutation) {
-    // ── mutation addDiscussionComment(input: { discussionId, body, replyToId? }) ──────────────
-    // discussionId "D_<repo>#<n>" (what repository.discussions returns); maps onto the SAME write path the
-    // REST twin uses for a discussion comment.
-    if (/\baddDiscussionComment\b/.test(query)) {
-      const discussionId = String(vars.discussionId ?? argValue(query, 'discussionId', vars) ?? '');
-      const body = String(vars.body ?? argValue(query, 'body', vars) ?? '');
-      const m = /^D_(.+)#(\d+)$/.exec(discussionId);
-      if (!m) return { errors: [{ message: `Could not resolve to a node with the global id of '${discussionId}'`, type: 'NOT_FOUND' }] };
-      const repo = m[1]!; const number = Number(m[2]);
-      const replyTo = /^DC_(.+)#(\d+)$/.exec(String(vars.replyToId ?? argValue(query, 'replyToId', vars) ?? ''));
-      const res = await applyGithubWrite({ method: 'POST', path: `/repos/${repo}/discussions/${number}/comments`, body: JSON.stringify({ body, ...(replyTo ? { parent_id: Number(replyTo[2]) } : {}) }), root: req.root });
-      if (res.response.status !== 201) return { errors: [{ message: 'addDiscussionComment failed', type: res.response.status === 404 ? 'NOT_FOUND' : 'UNPROCESSABLE' }] };
-      const cid = (res.response.body as { id?: number }).id;
-      return { data: { addDiscussionComment: { comment: { id: `DC_${repo}#${cid}`, body, url: `https://github.com/${repo}/discussions/${number}#discussioncomment-${cid}` } } } };
-    }
-    if (/\baddComment\b/.test(query)) {
-      // subjectId/body come from variables or inline input. subjectId "PR_<repo>#<n>" or "I_…".
-      const subjectId = String(vars.subjectId ?? argValue(query, 'subjectId', vars) ?? '');
-      const body = String(vars.body ?? argValue(query, 'body', vars) ?? '');
-      const m = /^(PR|I)_(.+)#(\d+)$/.exec(subjectId);
-      if (!m) return { errors: [{ message: `Could not resolve to a node with the global id of '${subjectId}'`, type: 'NOT_FOUND' }] };
-      const repo = m[2]!; const number = Number(m[3]);
-      // addComment maps onto the SAME write path the REST twin uses (issue comment).
-      const res = await applyGithubWrite({ method: 'POST', path: `/repos/${repo}/issues/${number}/comments`, body: JSON.stringify({ body }), root: req.root });
-      if (res.response.status !== 201) return { errors: [{ message: 'addComment failed', type: 'UNPROCESSABLE' }] };
-      const cid = (res.response.body as { id?: number }).id;
-      return { data: { addComment: { commentEdge: { node: { id: `IC_${repo}#${cid}`, body } } } } };
-    }
-    // mutation createPullRequest(input: { repositoryId, baseRefName, headRefName, title, body, draft })
-    // — gh pr create's mutation. Maps onto the SAME REST create path; returns the new PR's node id+url.
-    if (/\bcreatePullRequest\b/.test(query)) {
-      const input = (vars.input ?? {}) as Record<string, unknown>;
-      const m = /^R_(.+)$/.exec(String(input.repositoryId ?? ''));
-      if (!m) return { errors: [{ message: `Could not resolve to a Repository with the global id of '${String(input.repositoryId ?? '')}'`, type: 'NOT_FOUND' }] };
-      const repo = m[1]!;
-      const res = await applyGithubWrite({ method: 'POST', path: `/repos/${repo}/pulls`, body: JSON.stringify({ title: input.title, head: input.headRefName, base: input.baseRefName, body: input.body, draft: input.draft === true }), root: req.root });
-      if (res.response.status !== 201) return { errors: [{ message: 'createPullRequest failed', type: 'UNPROCESSABLE' }] };
-      const number = (res.response.body as { number?: number }).number;
-      return { data: { createPullRequest: { pullRequest: { id: `PR_${repo}#${number}`, url: `https://github.com/${repo}/pull/${number}` } } } };
-    }
-    return { errors: [{ message: 'Only addComment + createPullRequest are modeled in the twin GraphQL mutation subset', type: 'undefinedField' }] };
-  }
-
-  // ── query — resolve the recognized root fields; reject unmodeled ones honestly ────────────
-  const rootFields = selectionFields(query, query.match(/^\s*query/) ? 'query' : '{');
-  // viewer
-  if (/\bviewer\b/.test(query)) {
-    const bad = selectionFields(query, 'viewer').find((f) => !VIEWER_FIELDS.has(f));
-    if (bad) return { errors: [unmodeled(bad, 'User')] };
-    return { data: { viewer: { login: 'octocat', name: state.userProfile.name ?? 'The Octocat' } } };
-  }
-  // node(id)
-  if (/\bnode\b/.test(query)) {
-    const id = String(vars.id ?? argValue(query, 'id', vars) ?? '');
-    const m = /^(PR|I)_(.+)#(\d+)$/.exec(id);
-    if (!m) return { errors: [{ message: `Could not resolve to a node with the global id of '${id}'`, type: 'NOT_FOUND' }] };
-    const repo = m[2]!; const number = Number(m[3]);
-    const { prs, issues } = repoToNodes(state, repo);
-    const obj = m[1] === 'PR' ? prs.find((p) => p.number === number) : issues.find((i) => i.number === number);
-    if (!obj) return { errors: [{ message: `Could not resolve to a node with the global id of '${id}'`, type: 'NOT_FOUND' }] };
-    return { data: { node: { number: obj.number, title: obj.title, state: obj.state, id } } };
-  }
-  // repository(owner, name)
-  if (/\brepository\b/.test(query)) {
-    const owner = String(vars.owner ?? argValue(query, 'owner', vars) ?? '');
-    const name = String(vars.name ?? argValue(query, 'name', vars) ?? '');
-    const repo = `${owner}/${name}`;
-    const bad = selectionFields(query, 'repository').find((f) => !REPO_FIELDS.has(f));
-    if (bad) return { errors: [unmodeled(bad, 'Repository')] };
-    const known = state.repos.find((r) => r.full_name === repo);
-    const { prs, issues } = repoToNodes(state, repo);
-    // ── repository.pullRequest(number:) — the single-PR read gh pr view sends ──────────────
-    // (`\bpullRequest\b(?!s)` so the plural connection never shadows it.)
-    // Both single-node branches anchor on the FIELD-WITH-ARGS form (`pullRequest(` /
-    // `issue(`): a bare word match would hijack queries whose owner/name ARGUMENT contains
-    // the token (repository(name: "issue-tracker") — a real §9 round-two find).
-    const prTokenAt = query.search(/\bpullRequest\b(?!s)\s*\(/);
-    if (prTokenAt >= 0) {
-      const sub = query.slice(prTokenAt);
-      const bad = selectionFields(sub, 'pullRequest').find((f) => !PR_VIEW_FIELDS.has(f));
-      if (bad) return { errors: [unmodeled(bad, 'PullRequest')] };
-      const num = Number(vars.number ?? vars.pr_number ?? vars.prNumber ?? argValue(sub, 'number', vars) ?? NaN);
-      const pr = state.prs.find((p) => p.repository === repo && p.number === num);
-      if (!pr) return { errors: [{ message: `Could not resolve to a PullRequest with the number of ${num}.`, type: 'NOT_FOUND' }] };
-      return { data: { repository: { pullRequest: resolvePullRequestView(state, repo, pr, req.root) } } };
-    }
-    // ── repository.issue(number:) — gh issue view's single-issue read ──────────────────────
-    const issueTokenAt = query.search(/\bissue\b(?!s)\s*\(/);
-    if (issueTokenAt >= 0) {
-      const sub = query.slice(issueTokenAt);
-      const bad = selectionFields(sub, 'issue').find((f) => !ISSUE_VIEW_FIELDS.has(f));
-      if (bad) return { errors: [unmodeled(bad, 'Issue')] };
-      const num = Number(vars.number ?? argValue(sub, 'number', vars) ?? NaN);
-      const issue = state.issues.find((i) => i.repository === repo && i.number === num);
-      if (!issue) return { errors: [{ message: `Could not resolve to an Issue with the number of ${num}.`, type: 'NOT_FOUND' }] };
-      const labels = (issue.labels ?? []).map((name) => ({ name }));
-      const comments = state.comments
-        .filter((c) => c.repository === repo && c.number === num && c.kind === 'issue')
-        .map((c) => ({
-          id: `IC_${repo}#${c.id}`, author: null, authorAssociation: 'NONE', body: c.body ?? '',
-          createdAt: c.created_at ?? null, includesCreatedEdit: false, isMinimized: false, minimizedReason: null,
-          reactionGroups: [], url: `https://github.com/${repo}/issues/${num}#issuecomment-${c.id}`, viewerDidAuthor: false,
-        }));
-      return { data: { repository: { issue: {
-        number: num, id: `I_${repo}#${num}`, url: `https://github.com/${repo}/issues/${num}`,
-        title: issue.title ?? null, state: (issue.state ?? 'open').toUpperCase(), body: issue.body ?? '',
-        author: null, createdAt: null, updatedAt: null, closedAt: null,
-        labels: { nodes: labels, totalCount: labels.length },
-        comments: { nodes: comments, totalCount: comments.length, pageInfo: { hasNextPage: false, endCursor: null } },
-        assignees: { nodes: (issue.assignees ?? []).map((login) => ({ login, id: `U_${login}`, name: null })), totalCount: (issue.assignees ?? []).length },
-      } } } };
-    }
-    // ── repository.discussions(first, orderBy) — the community's threads, with their comments ─────
-    if (/\bdiscussions\b/.test(query)) {
-      const bad = selectionFields(query, 'discussions').find((f) => !DISCUSSION_FIELDS.has(f) && !CONNECTION_FIELDS.has(f));
-      if (bad) return { errors: [unmodeled(bad, 'Discussion')] };
-      const categories = state.discussionCategories.filter((c) => c.repository === repo);
-      const nodes = state.discussions.filter((d) => d.repository === repo).map((d) => {
-        const cat = categories.find((c) => c.slug === d.category_slug);
-        const comments = state.discussionComments.filter((c) => c.repository === repo && c.discussion_number === d.number).map((c) => ({
-          id: `DC_${repo}#${c.id}`, body: c.body ?? '', createdAt: c.created_at ?? null, author: null, isAnswer: Boolean(c.is_answer),
-          replyTo: c.parent_id ? { id: `DC_${repo}#${c.parent_id}` } : null,
-        }));
-        return {
-          id: `D_${repo}#${d.number}`, number: d.number, title: d.title ?? null, body: d.body ?? '', url: `https://github.com/${repo}/discussions/${d.number}`,
-          createdAt: d.created_at ?? null, updatedAt: d.updated_at ?? null, author: null, closed: d.state === 'closed', locked: Boolean(d.locked),
-          isAnswered: d.answer_comment_id !== undefined && d.answer_comment_id !== null,
-          category: cat ? { id: `DIC_${repo}#${cat.id}`, name: cat.name, slug: cat.slug, isAnswerable: Boolean(cat.is_answerable) } : null,
-          comments: { nodes: comments, totalCount: comments.length, pageInfo: { hasNextPage: false, endCursor: null } },
-        };
-      });
-      return { data: { repository: { id: `R_${repo}`, nameWithOwner: repo, discussions: { nodes, totalCount: nodes.length, pageInfo: { hasNextPage: false, endCursor: null } } } } };
-    }
-    // unmodeled subfields under pullRequests/issues nodes are honest errors too (connection-level
-    // fields like pageInfo/edges are allowed; only unknown PullRequest/Issue node fields error).
-    if (/\bpullRequests\b/.test(query)) { const b = selectionFields(query, 'pullRequests').find((f) => !PR_FIELDS.has(f) && !CONNECTION_FIELDS.has(f)); if (b) return { errors: [unmodeled(b, 'PullRequest')] }; }
-    if (/\bissues\b/.test(query)) { const b = selectionFields(query, 'issues').find((f) => !ISSUE_FIELDS.has(f) && !CONNECTION_FIELDS.has(f)); if (b) return { errors: [unmodeled(b, 'Issue')] }; }
-    // Honor the connection filter args gh sends: pullRequests(headRefName, states).
-    const headRefName = argValue(query, 'headRefName', vars);
-    const statesArg = vars.states ?? vars.state;
-    const prStates = Array.isArray(statesArg) ? statesArg.map((s) => String(s).toUpperCase()) : undefined;
-    const prNodes = prs
-      .filter((p) => headRefName === undefined || p.headRefName === headRefName)
-      .filter((p) => prStates === undefined || prStates.includes(p.state));
-    // The repo `fragment` fields (gh's RepositoryInfo); derived from the SAME repo projection REST
-    // serves. viewerPermission is ADMIN — the twin's loopback caller is the unauthenticated owner.
-    const repoFragment = {
-      id: `R_${repo}`, name, owner: { login: owner },
-      hasIssuesEnabled: known?.has_issues ?? true, description: known?.description ?? null,
-      hasWikiEnabled: known?.has_wiki ?? true, viewerPermission: 'ADMIN',
-      defaultBranchRef: { name: known?.default_branch ?? 'main' },
-    };
-    const repository: Record<string, unknown> = {
-      ...repoFragment, nameWithOwner: repo, isPrivate: known?.private ?? false,
-      parent: null, mergeCommitAllowed: true, rebaseMergeAllowed: true, squashMergeAllowed: true,
-      pullRequests: { totalCount: prNodes.length, nodes: prNodes, pageInfo: { hasNextPage: false, endCursor: null } },
-      issues: { totalCount: issues.length, nodes: issues.map((i) => ({ number: i.number, title: i.title, state: i.state })), pageInfo: { hasNextPage: false, endCursor: null } },
-    };
-    return { data: { repository } };
-  }
-  // any other top-level field is outside the modeled subset.
-  const unknownRoot = rootFields.find((f) => !['viewer', 'repository', 'node'].includes(f));
-  return { errors: [unmodeled(unknownRoot ?? rootFields[0] ?? 'unknown', 'Query')] };
-}
-
-// ── The single-PR view model (repository.pullRequest) ──────────────────────────────────────
-// Every field folds from the SAME projection the REST twin serves — headRefOid is the PR's
-// resolved head sha, statusCheckRollup folds the SAME check-run/commit-status rows the REST
-// checks surface reads, closingIssuesReferences derives from the PR body's closing keywords
-// (the same linkage real GitHub computes). Nothing here is a second store.
-
-// GitHub GraphQL enum spellings for the rollup (StatusState / CheckStatusState / CheckConclusionState).
-function statusStateEnum(s: string | undefined): string {
-  const v = (s ?? 'pending').toUpperCase();
-  return ['ERROR', 'EXPECTED', 'FAILURE', 'PENDING', 'SUCCESS'].includes(v) ? v : 'PENDING';
-}
-function checkStatusEnum(s: string | undefined): string {
-  const v = (s ?? 'queued').toUpperCase();
-  return ['QUEUED', 'IN_PROGRESS', 'COMPLETED', 'WAITING', 'PENDING', 'REQUESTED'].includes(v) ? v : 'QUEUED';
-}
-function checkConclusionEnum(s: string | undefined): string | null {
-  if (!s) return null;
-  const v = s.toUpperCase();
-  return ['ACTION_REQUIRED', 'TIMED_OUT', 'CANCELLED', 'FAILURE', 'SUCCESS', 'NEUTRAL', 'SKIPPED', 'STARTUP_FAILURE', 'STALE'].includes(v) ? v : null;
-}
-
-/** The closing-keyword issue linkage (Closes/Fixes/Resolves #n) real GitHub derives from the PR body. */
-export function closingIssueNumbersFromBody(body: string | undefined): number[] {
-  const out: number[] = [];
-  for (const m of (body ?? '').matchAll(/\b(?:clos(?:e[sd]?|ing)|fix(?:e[sd]|ing)?|resolv(?:e[sd]?|ing))\s*:?\s+#(\d+)/gi)) {
-    const n = Number(m[1]);
-    if (!out.includes(n)) out.push(n);
-  }
-  return out;
-}
-
-type GhPrRow = GithubState['prs'][number];
-
-function resolvePullRequestView(state: GithubState, repo: string, pr: GhPrRow, root?: string): Record<string, unknown> {
-  const headSha = pr.head_sha ?? '';
-  // Latest commit-status per context (GitHub's rollup shows each context once, most recent wins).
-  const latestByContext = new Map<string, GithubState['statuses'][number]>();
-  for (const s of state.statuses.filter((s) => s.repository === repo && s.sha === headSha).sort((a, b) => a.id - b.id)) {
-    latestByContext.set(s.context ?? 'default', s);
-  }
-  const runs = state.checkRuns.filter((c) => c.repository === repo && c.head_sha === headSha).sort((a, b) => a.id - b.id);
-  const contexts: Array<Record<string, unknown>> = [
-    ...runs.map((c) => ({
-      __typename: 'CheckRun', name: c.name,
-      status: checkStatusEnum(c.status), conclusion: checkConclusionEnum(c.conclusion),
-      startedAt: c.started_at ?? null, completedAt: c.completed_at ?? null, detailsUrl: c.details_url ?? null,
-    })),
-    ...[...latestByContext.values()].map((s) => ({
-      __typename: 'StatusContext', context: s.context, state: statusStateEnum(s.state),
-      targetUrl: s.target_url ?? null, description: s.description ?? null, createdAt: s.created_at ?? null,
-    })),
-  ];
-  const anyFailed = contexts.some((c) =>
-    (c.__typename === 'CheckRun' && ['FAILURE', 'TIMED_OUT', 'CANCELLED', 'ACTION_REQUIRED', 'STARTUP_FAILURE'].includes(String(c.conclusion)))
-    || (c.__typename === 'StatusContext' && ['FAILURE', 'ERROR'].includes(String(c.state))));
-  const anyPending = contexts.some((c) =>
-    (c.__typename === 'CheckRun' && c.conclusion === null)
-    || (c.__typename === 'StatusContext' && ['PENDING', 'EXPECTED'].includes(String(c.state))));
-  const rollupState = contexts.length === 0 ? null : anyFailed ? 'FAILURE' : anyPending ? 'PENDING' : 'SUCCESS';
-  const rollup = {
-    nodes: [{
-      commit: {
-        statusCheckRollup: rollupState === null ? null : {
-          state: rollupState,
-          contexts: { nodes: contexts, totalCount: contexts.length, pageInfo: { hasNextPage: false, endCursor: null } },
-        },
-      },
-    }],
-  };
-  const comments = state.comments
-    .filter((c) => c.repository === repo && c.number === pr.number && c.kind === 'issue')
-    .map((c) => ({
-      id: `IC_${repo}#${c.id}`, author: null, authorAssociation: 'NONE',
-      body: c.body ?? '', createdAt: c.created_at ?? null, includesCreatedEdit: false, isMinimized: false,
-      minimizedReason: null, reactionGroups: [], url: `https://github.com/${repo}/pull/${pr.number}#issuecomment-${c.id}`,
-      viewerDidAuthor: false,
-    }));
-  const closing = closingIssueNumbersFromBody(pr.body)
-    .filter((n) => state.issues.some((i) => i.repository === repo && i.number === n))
-    .map((n) => {
-      const issue = state.issues.find((i) => i.repository === repo && i.number === n)!;
-      return { number: n, title: issue.title ?? null, url: `https://github.com/${repo}/issues/${n}` };
-    });
-  const stateEnum = pr.merged ? 'MERGED' : (pr.state ?? 'open').toUpperCase();
-  // changedFiles: carried count → carried per-file list → the REAL diff from the git plane
-  // (a pushed PR's true file count — merge-gate scope classification depends on this being
-  // the actual paths, not 0) → 0 only when no evidence exists anywhere.
-  const planeFiles = pr.changed_files === undefined && !pr.files?.length ? prPlaneDiffFiles(state, repo, pr, root) : null;
-  return {
-    number: pr.number, id: `PR_${repo}#${pr.number}`, url: `https://github.com/${repo}/pull/${pr.number}`,
-    title: pr.title ?? null, state: stateEnum, body: pr.body ?? '', isDraft: pr.draft ?? false,
-    headRefOid: headSha, headRefName: pr.head_ref ?? null, baseRefName: pr.base_ref ?? null,
-    changedFiles: pr.changed_files ?? pr.files?.length ?? planeFiles?.length ?? 0,
-    additions: pr.additions ?? 0, deletions: pr.deletions ?? 0,
-    createdAt: null, updatedAt: null, closedAt: null, mergedAt: pr.merged_at ?? null,
-    labels: { nodes: (pr.labels ?? []).map((name) => ({ name })), totalCount: (pr.labels ?? []).length },
-    closingIssuesReferences: { nodes: closing, totalCount: closing.length, pageInfo: { hasNextPage: false, endCursor: null } },
-    // gh's `statusCheckRollup` json field is the alias for commits(last:1){…} — serve BOTH
-    // spellings so the alias and the raw field name each resolve.
-    statusCheckRollup: rollup, commits: rollup,
-    comments: { nodes: comments, totalCount: comments.length, pageInfo: { hasNextPage: false, endCursor: null } },
-    assignees: { nodes: (pr.assignees ?? []).map((login) => ({ login, id: `U_${login}`, name: null })), totalCount: (pr.assignees ?? []).length },
-    reviewRequests: { nodes: (pr.requested_reviewers ?? []).map((login) => ({ requestedReviewer: { __typename: 'User', login } })), totalCount: (pr.requested_reviewers ?? []).length },
-  };
-}