@gitkraken/core-gitlens 0.4.0 → 0.4.101

package/dist/plus/git-github/api/github.js

@@ -11,6 +11,7 @@ import { AuthenticationError, AuthenticationErrorReason, RequestClientError, Req
 import { PullRequestMergeMethod } from '../../../git/models/pullRequest.js';
 import { getGitHubNoReplyAddressParts } from '../../../git/remotes/github.js';
 import { createRevisionRange, getRevisionRangeParts, isRevisionRange, isSha, } from '../../../git/utils/revision.utils.js';
+import { chunk } from '../../../utils/array.js';
 import { base64 } from '../../../utils/base64.js';
 import { CancellationError } from '../../../utils/cancellation.js';
 import { trace } from '../../../utils/decorators/log.js';
@@ -32,6 +33,8 @@ const emptyBlameResult = Object.freeze({ ranges: [] });
 const maxRequestRetries = 2;
 const requestRetryBaseDelay = 300; // ms
 const requestRetryMaxDelay = 2000; // ms
+/** How many email->login user searches to alias into a single GraphQL request (keeps query cost within limits). */
+const accountResolveBatchSize = 25;
 function isRetryableTransientError(ex) {
     // An aborted request is rethrown as the original `AbortError` (not a `RequestError`), so it is
     // excluded here. octokit maps a fetch/network failure to a `RequestError` with status 500 and
@@ -49,6 +52,29 @@ function isRetryableTransientError(ex) {
             return false;
     }
 }
+/**
+ * When a rate-limited request may be retried, as a UTC epoch in seconds, or `undefined` when the response says
+ * nothing useful. Header precedence follows GitHub's own guidance
+ * (docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api): `retry-after` wins when present —
+ * it is the only one a secondary limit reliably sets — and `x-ratelimit-reset` covers the primary limit.
+ */
+function rateLimitResetAt(ex) {
+    const headers = ex.response?.headers;
+    if (headers == null)
+        return undefined;
+    // `retry-after` is a delay in seconds, not an epoch, so it has to be added to now to compare with `resetAt`.
+    const retryAfter = toPositiveInt(headers['retry-after']);
+    if (retryAfter != null)
+        return Math.floor(Date.now() / 1000) + retryAfter;
+    return toPositiveInt(headers['x-ratelimit-reset']);
+}
+function toPositiveInt(value) {
+    if (value == null)
+        return undefined;
+    const parsed = typeof value === 'number' ? value : parseInt(value, 10);
+    // Rejects NaN and a nonsensical negative/zero, either of which would present as an already-elapsed reset.
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
 function getRequestRetryDelay(attempt) {
     // Exponential backoff with equal jitter, capped — spreads retries so a brief upstream blip
     // isn't hammered by every in-flight request landing on the same schedule.
@@ -78,15 +104,18 @@ author {
 	avatarUrl(size: $avatarSize)
 	url
 }
+body
 baseRefName
 baseRefOid
 headRefName
 headRefOid
 headRepository {
+	isFork
 	name
 	owner {
 		login
 	}
+	sshUrl
 	url
 }
 isCrossRepository
@@ -99,6 +128,7 @@ repository {
 	owner {
 		login
 	}
+	sshUrl
 	url
 	viewerPermission
 }
@@ -360,6 +390,47 @@ export class GitHubApi {
             throw this.handleException(ex, provider, scope);
         }
     }
+    async getAccountsForEmails(provider, token, emails, options) {
+        const scope = getScopedLogger();
+        // Resolves email -> login for many emails in one request via field aliasing, chunked to keep query cost within
+        // GitHub's limits. Each email is passed as a GraphQL variable (never interpolated into the query string) so an
+        // attacker-controllable commit email can't inject query structure. Keyed by lowercased email.
+        //
+        // This is intentionally best-effort: user-by-email search only matches accounts whose email is public, and the
+        // search API is subject to GitHub's separate search/secondary rate limits, so misses and per-batch failures are
+        // expected and tolerated. GitHub noreply addresses (the common case) are decoded locally by the caller without
+        // hitting this at all.
+        const result = new Map();
+        if (emails.length === 0)
+            return result;
+        for (const batch of chunk(emails, accountResolveBatchSize)) {
+            const declarations = batch.map((_, i) => `$q${i}: String!`).join(', ');
+            const fields = batch
+                .map((_, i) => `e${i}: search(type: USER, query: $q${i}, first: 1) { nodes { ... on User { login } } }`)
+                .join('\n\t');
+            const query = `query getAccountsForEmails(${declarations}) {\n\t${fields}\n}`;
+            const variables = { ...options };
+            batch.forEach((email, i) => {
+                variables[`q${i}`] = `in:email ${email}`;
+            });
+            try {
+                const rsp = await this.graphql(provider, token, query, variables, scope);
+                if (rsp == null)
+                    continue;
+                batch.forEach((email, i) => {
+                    const login = rsp[`e${i}`]?.nodes?.[0]?.login;
+                    if (login) {
+                        result.set(email.toLowerCase(), login);
+                    }
+                });
+            }
+            catch (ex) {
+                // Best-effort enrichment — a failed batch (e.g. query cost) shouldn't abort the others.
+                scope?.error(ex);
+            }
+        }
+        return result;
+    }
     async getDefaultBranch(provider, token, owner, repo, options) {
         const scope = getScopedLogger();
         try {
@@ -487,7 +558,7 @@ export class GitHubApi {
 ) {
 	repository(name: $repo, owner: $owner) {
 		pullRequest(number: $number) {
-			${gqlPullRequestFragment}
+			${gqlPullRequestLiteFragment}
 		}
 	}
 }`;
@@ -1372,6 +1443,33 @@ export class GitHubApi {
             throw this.handleException(ex, undefined, scope);
         }
     }
+    async getUserSshSigningKeys(provider, token, username, options) {
+        const scope = getScopedLogger();
+        // SSH signing keys are public, so this works for any user with the current token (no extra scope needed).
+        // TODO@eamodio implement pagination
+        try {
+            const rsp = await this.request(provider, token, 'GET /users/{username}/ssh_signing_keys', { username: username, per_page: 100, ...options }, scope);
+            return rsp?.data ?? [];
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return [];
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getCurrentUserSshSigningKeys(provider, token, options) {
+        const scope = getScopedLogger();
+        // TODO@eamodio implement pagination
+        try {
+            const rsp = await this.request(provider, token, 'GET /user/ssh_signing_keys', { per_page: 100, ...options }, scope);
+            return rsp?.data ?? [];
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return [];
+            throw this.handleException(ex, provider, scope);
+        }
+    }
     async getDefaultBranchName(token, owner, repo) {
         const scope = getScopedLogger();
         try {
@@ -1944,20 +2042,18 @@ export class GitHubApi {
             case 410: // Gone
             case 422: // Unprocessable Entity
                 throw new RequestNotFoundError(ex);
-            // case 429: //Too Many Requests
+            case 429: // Too Many Requests
+                // GitHub returns "a `403` or `429` response" for BOTH its primary and secondary rate limits
+                // (docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api). 429 is unambiguous —
+                // unlike 403, it is never a permission failure — so it needs no message check.
+                throw new RequestRateLimitError(ex, accessToken, rateLimitResetAt(ex));
             case 401: // Unauthorized
                 throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Unauthorized, ex);
             case 403: // Forbidden
+                // The other status the rate limits arrive on, but 403 is also a plain permission failure, so here
+                // the message is the discriminant.
                 if (ex.message.includes('rate limit')) {
-                    let resetAt;
-                    const reset = ex.response?.headers?.['x-ratelimit-reset'];
-                    if (reset != null) {
-                        resetAt = parseInt(reset, 10);
-                        if (Number.isNaN(resetAt)) {
-                            resetAt = undefined;
-                        }
-                    }
-                    throw new RequestRateLimitError(ex, accessToken, resetAt);
+                    throw new RequestRateLimitError(ex, accessToken, rateLimitResetAt(ex));
                 }
                 throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
             case 500: // Internal Server Error
@@ -2041,26 +2137,28 @@ export class GitHubApi {
         // The /u/e endpoint automatically falls back to gravatar if not found
         return `https://avatars.githubusercontent.com/u/e?email=${encodeURIComponent(email)}&s=${avatarSize}`;
     }
-    async searchMyPullRequests(provider, token, options, cancellation) {
+    async searchMyPullRequestsPage(provider, token, options, cancellation) {
         const scope = getScopedLogger();
         const limit = Math.min(100, this.config.getLaunchpadQueryLimit?.() ?? 100);
         try {
             const query = `query searchMyPullRequests(
-	$search: String!
-	$avatarSize: Int
-) {
-	search(first: ${limit}, query: $search, type: ISSUE) {
-		issueCount
-		nodes {
-			...on PullRequest {
-				${gqlPullRequestFragment}
+		$search: String!
+		$cursor: String
+		$avatarSize: Int
+	) {
+		search(first: ${limit}, after: $cursor, query: $search, type: ISSUE) {
+			issueCount
+			pageInfo {
+				endCursor
+				hasNextPage
+			}
+			nodes {
+				...on PullRequest {
+					${options?.summary ? gqlPullRequestLiteFragment : gqlPullRequestFragment}
+				}
 			}
 		}
-	}
-	viewer {
-		login
-	}
-}`;
+	}`;
             let search = options?.search?.trim() ?? '';
             if (options?.user) {
                 search += ` user:${options.user}`;
@@ -2068,85 +2166,131 @@ export class GitHubApi {
             if (options?.repos?.length) {
                 search += ` repo:${options.repos.join(' repo:')}`;
             }
-            // Hack for now, ultimately this should be passed in
             const ignoredRepos = this.config.getLaunchpadIgnoredRepositories?.() ?? [];
             if (ignoredRepos.length) {
                 search += ` -repo:${ignoredRepos.join(' -repo:')}`;
             }
-            // Hack for now, ultimately this should be passed in
             const enabledOrgs = this.config.getLaunchpadIncludedOrganizations?.() ?? [];
             if (enabledOrgs.length) {
                 search += ` org:${enabledOrgs.join(' org:')}`;
             }
             else {
-                // Hack for now, ultimately this should be passed in
                 const ignoredOrgs = this.config.getLaunchpadIgnoredOrganizations?.() ?? [];
                 if (ignoredOrgs.length) {
                     search += ` -org:${ignoredOrgs.join(' -org:')}`;
                 }
             }
+            const stateQualifier = options?.state === 'closed'
+                ? 'is:closed is:unmerged'
+                : options?.state === 'merged'
+                    ? 'is:merged'
+                    : options?.state === 'all'
+                        ? ''
+                        : 'is:open';
+            const relationshipQualifier = options?.includeDefaultInvolvement === false
+                ? 'is:pr archived:false'
+                : 'is:pr involves:@me archived:false';
             const rsp = await this.graphql(provider, token, query, {
-                search: `is:open is:pr involves:@me archived:false ${search}`.trim(),
+                search: [stateQualifier, relationshipQualifier, search].filter(Boolean).join(' ').trim(),
+                cursor: options?.cursor,
                 baseUrl: options?.baseUrl,
                 avatarSize: options?.avatarSize,
             }, scope, cancellation);
             if (rsp == null)
-                return [];
-            const viewer = rsp.viewer.login;
-            function toQueryResult(pr) {
-                const reasons = [];
-                if (pr.author.login === viewer) {
-                    reasons.push('authored');
-                }
-                if (pr.assignees.nodes.some(a => a.login === viewer)) {
-                    reasons.push('assigned');
-                }
-                if (pr.reviewRequests.nodes.some(r => r.requestedReviewer?.login === viewer)) {
-                    reasons.push('review-requested');
-                }
-                if (reasons.length === 0) {
-                    reasons.push('mentioned');
-                }
-                return fromGitHubPullRequest(pr, provider);
-            }
-            const results = rsp.search.nodes.map(pr => toQueryResult(pr));
-            return results;
+                return { values: [], hasMore: false, truncated: false };
+            const results = rsp.search.nodes.map(pr => options?.summary ? fromGitHubPullRequestLite(pr, provider) : fromGitHubPullRequest(pr, provider));
+            return {
+                values: results,
+                cursor: rsp.search.pageInfo.endCursor ?? undefined,
+                hasMore: rsp.search.pageInfo.hasNextPage,
+                truncated: rsp.search.issueCount > 1000,
+            };
         }
         catch (ex) {
             throw this.handleException(ex, provider, scope, options?.silent);
         }
     }
+    async searchMyPullRequests(provider, token, options, cancellation) {
+        return (await this.searchMyPullRequestsPage(provider, token, options, cancellation)).values;
+    }
     async searchMyIssues(provider, token, options, cancellation) {
         const scope = getScopedLogger();
-        const issueFragement = `${gqIssueFragment}${options?.includeBody
-            ? `
-			body
-			`
-            : ''}`;
+        let cursor;
+        if (options?.cursor != null) {
+            try {
+                cursor = JSON.parse(options.cursor);
+            }
+            catch { }
+        }
+        const page = Math.max(1, Math.trunc(cursor?.page ?? 1));
+        // A category is read when the caller asked for it AND it hasn't been exhausted (`null` cursor slot). An
+        // excluded category needs no cursor bookkeeping: `nextCategoryCursor` reads a missing response category as
+        // `null`, so it stays excluded across continuations on its own.
+        const categories = options?.categories;
+        const requested = {
+            authored: categories?.authored ?? categories == null,
+            assigned: categories?.assigned ?? categories == null,
+            mentioned: categories?.mentioned ?? categories == null,
+        };
+        const includeAuthored = requested.authored && cursor?.authored !== null;
+        const includeAssigned = requested.assigned && cursor?.assigned !== null;
+        const includeMentioned = requested.mentioned && cursor?.mentioned !== null;
+        // Reading nothing is the honest answer to "none of the three": widening back to the union would return
+        // issues the caller explicitly excluded.
+        if (!includeAuthored && !includeAssigned && !includeMentioned) {
+            return { values: [], hasMore: false, page: page, truncated: cursor?.truncated === true };
+        }
         const query = `query searchMyIssues(
 				$authored: String!
 				$assigned: String!
 				$mentioned: String!
+				$authoredCursor: String
+				$assignedCursor: String
+				$mentionedCursor: String
+				$includeAuthored: Boolean!
+				$includeAssigned: Boolean!
+				$includeMentioned: Boolean!
 				$avatarSize: Int
 			) {
-				authored: search(first: 100, query: $authored, type: ISSUE) {
+				authored: search(first: 100, after: $authoredCursor, query: $authored, type: ISSUE)
+					@include(if: $includeAuthored) {
+					issueCount
+					pageInfo {
+						endCursor
+						hasNextPage
+					}
 					nodes {
 						... on Issue {
-							${issueFragement}
+							${gqIssueFragment}
+							${options?.includeBody ? 'body' : ''}
 						}
 					}
 				}
-				assigned: search(first: 100, query: $assigned, type: ISSUE) {
+				assigned: search(first: 100, after: $assignedCursor, query: $assigned, type: ISSUE)
+					@include(if: $includeAssigned) {
+					issueCount
+					pageInfo {
+						endCursor
+						hasNextPage
+					}
 					nodes {
 						... on Issue {
-							${issueFragement}
+							${gqIssueFragment}
+							${options?.includeBody ? 'body' : ''}
 						}
 					}
 				}
-				mentioned: search(first: 100, query: $mentioned, type: ISSUE) {
+				mentioned: search(first: 100, after: $mentionedCursor, query: $mentioned, type: ISSUE)
+					@include(if: $includeMentioned) {
+					issueCount
+					pageInfo {
+						endCursor
+						hasNextPage
+					}
 					nodes {
 						... on Issue {
-							${issueFragement}
+							${gqIssueFragment}
+							${options?.includeBody ? 'body' : ''}
 						}
 					}
 				}
@@ -2160,11 +2304,26 @@ export class GitHubApi {
             search += `${repo}${options.repos.join(repo)}`;
         }
         const baseFilters = 'type:issue is:open archived:false';
+        // `includeAllAssignees` broadens the assigned category from "assigned to me" to "assigned to anyone"
+        // (`assignee:*` is GitHub's has-any-assignee qualifier). Authored/mentioned stay bound to `@me` — they're
+        // user-relative by definition, so an all-assignees read still only surfaces the current user's authored
+        // and mentioned issues plus every assigned-to-anyone issue.
+        //
+        // NOTE: GitHub only honors `assignee:*` when the search is scoped to a single repository (see GitHub's
+        // issue-search docs). Callers using `includeAllAssignees` must scope the read via `repos` (the broaden
+        // fan-out does this per org/repo); an unscoped account-wide `assignee:*` is not meaningful to GitHub.
+        const assignedQualifier = options?.includeAllAssignees ? 'assignee:*' : 'assignee:@me';
         try {
             const rsp = await this.graphql(provider, token, query, {
                 authored: `${search} ${baseFilters} author:@me`.trim(),
-                assigned: `${search} ${baseFilters} assignee:@me`.trim(),
+                assigned: `${search} ${baseFilters} ${assignedQualifier}`.trim(),
                 mentioned: `${search} ${baseFilters} mentions:@me`.trim(),
+                authoredCursor: cursor?.authored ?? undefined,
+                assignedCursor: cursor?.assigned ?? undefined,
+                mentionedCursor: cursor?.mentioned ?? undefined,
+                includeAuthored: includeAuthored,
+                includeAssigned: includeAssigned,
+                includeMentioned: includeMentioned,
                 baseUrl: options?.baseUrl,
                 avatarSize: options?.avatarSize,
             }, scope, cancellation);
@@ -2172,9 +2331,37 @@ export class GitHubApi {
                 return fromGitHubIssue(issue, provider);
             }
             if (rsp == null)
-                return [];
-            const results = uniqueBy([...rsp.assigned.nodes, ...rsp.mentioned.nodes, ...rsp.authored.nodes].map(toQueryResult), r => r.url, (original, _current) => original);
-            return [...results];
+                return { values: [], hasMore: false, page: page, truncated: false };
+            const results = uniqueBy([...(rsp.assigned?.nodes ?? []), ...(rsp.mentioned?.nodes ?? []), ...(rsp.authored?.nodes ?? [])].map(toQueryResult), r => r.url, (original, _current) => original);
+            const nextCategoryCursor = (category) => {
+                if (category?.pageInfo?.hasNextPage && category.pageInfo.endCursor) {
+                    return category.pageInfo.endCursor;
+                }
+                return null;
+            };
+            const next = {
+                page: page + 1,
+                authored: nextCategoryCursor(rsp.authored),
+                assigned: nextCategoryCursor(rsp.assigned),
+                mentioned: nextCategoryCursor(rsp.mentioned),
+            };
+            const hasMore = next.authored != null || next.assigned != null || next.mentioned != null;
+            // GitHub search exposes at most 1,000 results per category. Paging removes the previous 100-item
+            // truncation; only the upstream search ceiling or an unusable continuation remains incomplete.
+            const continuationMissing = [rsp.authored, rsp.assigned, rsp.mentioned].some(category => category?.pageInfo?.hasNextPage === true && category.pageInfo.endCursor == null);
+            const truncated = cursor?.truncated === true ||
+                (rsp.authored?.issueCount ?? 0) > 1000 ||
+                (rsp.assigned?.issueCount ?? 0) > 1000 ||
+                (rsp.mentioned?.issueCount ?? 0) > 1000 ||
+                continuationMissing;
+            next.truncated = truncated || undefined;
+            return {
+                values: [...results],
+                cursor: hasMore ? JSON.stringify(next) : undefined,
+                hasMore: hasMore,
+                page: page,
+                truncated: truncated,
+            };
         }
         catch (ex) {
             throw this.handleException(ex, provider, scope);
@@ -2182,12 +2369,20 @@ export class GitHubApi {
     }
     async searchPullRequests(provider, token, options, cancellation) {
         const scope = getScopedLogger();
+        const pageSize = 10;
+        const include = options?.include?.length ? options.include : undefined;
+        const requiresPagination = shouldPaginateGitHubSearchState(include);
         try {
             const query = `query searchPullRequests(
 	$searchQuery: String!
+		$cursor: String
 	$avatarSize: Int
 ) {
-	search(first: 10, query: $searchQuery, type: ISSUE) {
+		search(first: ${pageSize}, after: $cursor, query: $searchQuery, type: ISSUE) {
+			pageInfo {
+				endCursor
+				hasNextPage
+			}
 		nodes {
 			...on PullRequest {
 				${gqlPullRequestFragment}
@@ -2203,15 +2398,31 @@ export class GitHubApi {
                 const repo = ' repo:';
                 search += `${repo}${options.repos.join(repo)}`;
             }
-            const rsp = await this.graphql(provider, token, query, {
-                searchQuery: `is:pr is:open archived:false ${search.trim()}`,
-                baseUrl: options?.baseUrl,
-                avatarSize: options?.avatarSize,
-            }, scope, cancellation);
-            if (rsp == null)
-                return [];
-            const results = rsp.search.nodes.map(pr => fromGitHubPullRequest(pr, provider));
-            return results;
+            const searchQuery = ['is:pr', toGitHubSearchStateQualifier(include), 'archived:false', search.trim()]
+                .filter(Boolean)
+                .join(' ');
+            // Bound the paginated case with a defensive page backstop like the other paged provider drains, so a
+            // large, low-match result set can't fan out into an unbounded request loop.
+            const maxSearchPages = 20;
+            let cursor;
+            const results = [];
+            for (let page = 0; page < maxSearchPages; page++) {
+                const rsp = await this.graphql(provider, token, query, {
+                    searchQuery: searchQuery,
+                    cursor: cursor,
+                    baseUrl: options?.baseUrl,
+                    avatarSize: options?.avatarSize,
+                }, scope, cancellation);
+                if (rsp == null)
+                    return [];
+                const pageResults = filterPullRequestsBySearchState(rsp.search.nodes.map(pr => fromGitHubPullRequest(pr, provider)), include);
+                results.push(...pageResults);
+                cursor = rsp.search.pageInfo.endCursor ?? undefined;
+                if (!requiresPagination || results.length >= pageSize || !rsp.search.pageInfo.hasNextPage) {
+                    break;
+                }
+            }
+            return results.slice(0, pageSize);
         }
         catch (ex) {
             throw this.handleException(ex, provider, scope);
@@ -2281,6 +2492,9 @@ __decorate([
         }),
     })
 ], GitHubApi.prototype, "getAccountForEmail", null);
+__decorate([
+    trace({ args: (provider, token) => ({ provider: provider?.name, token: `<token:${token.microHash}>` }) })
+], GitHubApi.prototype, "getAccountsForEmails", null);
 __decorate([
     trace({
         args: (provider, token, owner, repo) => ({
@@ -2482,6 +2696,18 @@ __decorate([
 __decorate([
     trace({ args: (token, owner, repo) => ({ token: `<token:${token.microHash}>`, owner: owner, repo: repo }) })
 ], GitHubApi.prototype, "getContributors", null);
+__decorate([
+    trace({
+        args: (provider, token, username) => ({
+            provider: provider?.name,
+            token: `<token:${token.microHash}>`,
+            username: username,
+        }),
+    })
+], GitHubApi.prototype, "getUserSshSigningKeys", null);
+__decorate([
+    trace({ args: (provider, token) => ({ provider: provider?.name, token: `<token:${token.microHash}>` }) })
+], GitHubApi.prototype, "getCurrentUserSshSigningKeys", null);
 __decorate([
     trace({ args: (token, owner, repo) => ({ token: `<token:${token.microHash}>`, owner: owner, repo: repo }) })
 ], GitHubApi.prototype, "getDefaultBranchName", null);
@@ -2524,6 +2750,9 @@ __decorate([
 __decorate([
     trace({ args: (provider, token) => ({ provider: provider?.name, token: `<token:${token.microHash}>` }) })
 ], GitHubApi.prototype, "getEnterpriseVersion", null);
+__decorate([
+    trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+], GitHubApi.prototype, "searchMyPullRequestsPage", null);
 __decorate([
     trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 ], GitHubApi.prototype, "searchMyPullRequests", null);
@@ -2546,4 +2775,46 @@ __decorate([
 function isGitHubDotCom(options) {
     return options?.baseUrl == null || options.baseUrl === 'https://api.github.com';
 }
+// Translates the requested PR states into a GitHub search state qualifier. GitHub search treats
+// `is:closed` as closed-or-merged, `is:merged` as its subset, and `is:unmerged` as open + closed
+// (not-merged), so `closed` and `merged` (distinct in our model) map to `is:closed is:unmerged` and
+// `is:merged`. `undefined` preserves the historical open-only default.
+export function toGitHubSearchStateQualifier(include) {
+    if (include == null)
+        return 'is:open';
+    const opened = include.includes('opened');
+    const closed = include.includes('closed');
+    const merged = include.includes('merged');
+    if (opened && closed && merged)
+        return ''; // all states -> no qualifier
+    if (opened && closed)
+        return 'is:unmerged';
+    if (closed && merged)
+        return 'is:closed';
+    // `opened && merged` isn't expressible as a single AND qualifier; omit it here and post-filter.
+    if (opened && merged)
+        return '';
+    if (opened)
+        return 'is:open';
+    if (merged)
+        return 'is:merged';
+    if (closed)
+        return 'is:closed is:unmerged';
+    return 'is:open'; // empty include -> default
+}
+export function filterPullRequestsBySearchState(pullRequests, include) {
+    const states = include?.length ? include : ['opened'];
+    const allowedStates = new Set(states);
+    // There are only 3 possible states, so a full set means every state is allowed; use the deduped set
+    // size rather than the raw length so duplicates (e.g. `['opened', 'opened', 'closed']`) don't skip filtering.
+    if (allowedStates.size === 3)
+        return pullRequests;
+    return pullRequests.filter(pr => allowedStates.has(pr.state));
+}
+function shouldPaginateGitHubSearchState(include) {
+    if (include == null || include.length === 0)
+        return false;
+    const uniqueStates = new Set(include);
+    return uniqueStates.size === 2 && uniqueStates.has('opened') && uniqueStates.has('merged');
+}
 //# sourceMappingURL=github.js.map