@gitkraken/core-gitlens 0.5.102 → 0.5.104

package/src/plus/git-github/api/github.ts

@@ -11,7 +11,7 @@ import {
 } from '../../../git/errors.js';
 import type { Account, UnidentifiedAuthor } from '../../../git/models/author.js';
 import type { DefaultBranch } from '../../../git/models/defaultBranch.js';
-import type { Issue, IssueShape } from '../../../git/models/issue.js';
+import type { Issue, IssueSearchCriteria, IssueShape } from '../../../git/models/issue.js';
 import type { IssueOrPullRequest } from '../../../git/models/issueOrPullRequest.js';
 import type { PullRequest, PullRequestState, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
 import { PullRequestMergeMethod } from '../../../git/models/pullRequest.js';
@@ -66,6 +66,12 @@ import {
 	fromGitHubPullRequestLite,
 } from '../models.js';
 import type { GitHubApiConfig } from './config.js';
+import { githubSearchResultLimit } from './config.js';
+import {
+	gitHubIssueSearchRelationships,
+	toGitHubIssueSearchQualifiers,
+	toGitHubIssueSearchScopeQualifiers,
+} from './issueSearchQuery.js';
 import type { GitHubTokenInfo } from './token.js';
 
 const emptyPagedResult: PagedResult<any> = Object.freeze({ values: [] });
@@ -133,6 +139,31 @@ function getRequestRetryDelay(attempt: number): number {
 	return Math.round(backoff / 2 + Math.random() * (backoff / 2));
 }
 
+/** One aliased `search` field in a multi-search issue request; see {@link GitHubApi.searchIssuesByAlias}. */
+interface AliasedIssueSearch {
+	/** GraphQL alias, also the key this search's cursor is stored under. Must not be `page` or `truncated`. */
+	alias: string;
+	/** The fully-composed GitHub search query, qualifiers included. */
+	query: string;
+}
+
+/** One page of a multi-search issue request, with its composite cursor across every alias. */
+export interface AliasedIssueSearchResult {
+	values: IssueShape[];
+	/** Opaque composite cursor; absent when every alias is exhausted. */
+	cursor?: string;
+	hasMore: boolean;
+	page: number;
+	/** True when the read cannot return everything — GitHub's search ceiling, or an unusable continuation. */
+	truncated: boolean;
+	/**
+	 * The largest `issueCount` any single alias reported, which is what {@link githubSearchResultLimit} applies
+	 * to (the ceiling is per search, not per request). Absent when no request was made — every alias was already
+	 * exhausted — so `undefined` means "not reported", never zero matches.
+	 */
+	totalCount?: number;
+}
+
 // Matches a GraphQL document whose operation is definitely a read query — the `query` keyword as
 // the first significant token, after any leading whitespace or `#` comment lines. We retry only
 // when this matches; a mutation (even one prefixed by a comment), a subscription, or anything we
@@ -3569,7 +3600,7 @@ export class GitHubApi {
 				values: results,
 				cursor: rsp.search.pageInfo.endCursor ?? undefined,
 				hasMore: rsp.search.pageInfo.hasNextPage,
-				truncated: rsp.search.issueCount > 1000,
+				truncated: rsp.search.issueCount > githubSearchResultLimit,
 			};
 		} catch (ex) {
 			throw this.handleException(ex, provider, scope, options?.silent);
@@ -3620,37 +3651,235 @@ export class GitHubApi {
 			categories?: { authored?: boolean; assigned?: boolean; mentioned?: boolean };
 		},
 		cancellation?: AbortSignal,
-	): Promise<
-		| {
-				values: IssueShape[];
-				cursor?: string;
-				hasMore: boolean;
-				page: number;
-				truncated: boolean;
-		  }
-		| undefined
-	> {
+	): Promise<AliasedIssueSearchResult | undefined> {
+		let search = options?.search?.trim() ?? '';
+
+		if (options?.user) {
+			search += ` user:${options.user}`;
+		}
+
+		if (options?.repos != null && options.repos.length > 0) {
+			const repo = '  repo:';
+			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: `assignee:*` requires a SCOPE to be meaningful, but any scope will do — one repository, several,
+		// or an org (measured: `repo:a repo:b … assignee:*` returns exactly the sum of the two per-repo counts).
+		// It is only the UNSCOPED form that is meaningless, matching millions of issues across all of GitHub, so
+		// callers must supply `repos` (or an org qualifier via `search`); the facade refuses the unscoped case.
+		const assignedQualifier = options?.includeAllAssignees ? 'assignee:*' : 'assignee:@me';
+
+		// A category is read when the caller asked for it AND it hasn't been exhausted (a `null` cursor slot,
+		// which `searchIssuesByAlias` maintains). An excluded category needs no cursor bookkeeping: a missing
+		// response category reads back 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,
+		};
+
+		// Two things are fixed here rather than incidental:
+		// - the alias names are this read's persisted cursor keys, so they can't be renamed;
+		// - the ORDER is assigned → mentioned → authored, which is the order the union is emitted in and, because
+		//   the dedupe keeps the first occurrence of a url, also the precedence between the three. An issue that
+		//   is both assigned to and authored by the user surfaces as the assigned one.
+		const searches: AliasedIssueSearch[] = [];
+		if (requested.assigned) {
+			searches.push({ alias: 'assigned', query: `${search} ${baseFilters} ${assignedQualifier}`.trim() });
+		}
+		if (requested.mentioned) {
+			searches.push({ alias: 'mentioned', query: `${search} ${baseFilters} mentions:@me`.trim() });
+		}
+		if (requested.authored) {
+			searches.push({ alias: 'authored', query: `${search} ${baseFilters} author:@me`.trim() });
+		}
+
+		return this.searchIssuesByAlias(provider, token, searches, options, cancellation);
+	}
+
+	/**
+	 * The filtered issue search: issues matching structured criteria over a repository/org scope, with no forced
+	 * relationship to the current user. The issue counterpart of {@link searchMyPullRequestsPage}, and distinct
+	 * from {@link searchMyIssues}, which is permanently bound to `@me`.
+	 *
+	 * Ordering is part of the contract, not an option: always `sort:updated` (most recently updated first). A
+	 * consumer's "show the N most recent" policy at GitHub's result ceiling is only correct under a guaranteed
+	 * order, and an option would let a caller pick relevance order and then truncate to an arbitrary subset.
+	 *
+	 * Each requested relationship becomes its own aliased search, unioned and deduped by url; with none, a single
+	 * search runs over the scope alone. `criteria.text` and the other free-form values are sanitized so user input
+	 * cannot inject a qualifier and re-scope the search — see {@link toGitHubIssueSearchQualifiers}.
+	 */
+	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+	async searchIssuesPage(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		options?: {
+			repos?: string[];
+			org?: string;
+			criteria?: IssueSearchCriteria;
+			baseUrl?: string;
+			avatarSize?: number;
+			includeBody?: boolean;
+			cursor?: string;
+			pageSize?: number;
+		},
+		cancellation?: AbortSignal,
+	): Promise<AliasedIssueSearchResult | undefined> {
+		const base = [
+			...toGitHubIssueSearchScopeQualifiers(options?.org, options?.repos),
+			...toGitHubIssueSearchQualifiers(options?.criteria),
+		].join(' ');
+
+		// One aliased search per relationship, OR-ed by union. They can't be one query: GitHub AND-s qualifiers,
+		// so `author:@me assignee:@me` would return the intersection — issues the user both opened and is assigned
+		// to — instead of either set. With no relationship the scope + criteria are already the whole query.
+		const relationships = options?.criteria?.relationships;
+		const searches: AliasedIssueSearch[] = relationships?.length
+			? relationships.map(r => ({
+					alias: gitHubIssueSearchRelationships[r].alias,
+					query: `${base} ${gitHubIssueSearchRelationships[r].qualifier}`.trim(),
+				}))
+			: [{ alias: 'matched', query: base }];
+
+		return this.searchIssuesByAlias(provider, token, searches, options, cancellation);
+	}
+
+	/**
+	 * Counts issues for several scopes in ONE request, transferring no issues at all — each scope is an aliased
+	 * `search` selecting only `issueCount`, with `first: 0` so no nodes are fetched.
+	 *
+	 * This is what makes a "this will fetch ~N issues" preview affordable: measured against the live API, 30
+	 * aliased counts cost a single rate-limit point. It is still a network request per chunk, so a caller is
+	 * expected to debounce and cache.
+	 *
+	 * Returns counts positionally — one per input scope, same order — because a caller-supplied key must never
+	 * reach the GraphQL document (it would break it); the aliases are generated. `undefined` in a slot means the
+	 * response omitted that alias, which the caller reports as "not counted" rather than as zero.
+	 */
+	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+	async countIssues(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		scopes: readonly { repos?: string[]; org?: string; criteria?: IssueSearchCriteria }[],
+		options?: { baseUrl?: string },
+		cancellation?: AbortSignal,
+	): Promise<(number | undefined)[]> {
+		const scope = getScopedLogger();
+		if (scopes.length === 0) return [];
+
+		const queries = scopes.map(s => {
+			const qualifiers = [
+				...toGitHubIssueSearchScopeQualifiers(s.org, s.repos),
+				...toGitHubIssueSearchQualifiers(s.criteria),
+			];
+
+			// A relationship set is OR-ed across searches, which a single count can't express — the facade splits
+			// such a scope into one count per relationship before calling, so at most one is present here.
+			const relationship = s.criteria?.relationships?.[0];
+			if (relationship != null) {
+				qualifiers.push(gitHubIssueSearchRelationships[relationship].qualifier);
+			}
+			return qualifiers.join(' ');
+		});
+
+		// Aliases are positional and generated (`s0`, `s1`, …): a caller's key is arbitrary text and would break
+		// the document, so the caller maps results back by index.
+		const params = queries.map((_, i) => `$q${i}: String!`).join('\n\t\t\t\t');
+		// `first: 0` is what makes this cheap — `issueCount` alone, no nodes over the wire.
+		const fields = queries
+			.map((_, i) => `s${i}: search(query: $q${i}, type: ISSUE, first: 0) { issueCount }`)
+			.join('\n\t\t\t\t');
+		const query = `query countIssues(
+				${params}
+			) {
+				${fields}
+			}`;
+
+		const variables: Record<string, unknown> = { baseUrl: options?.baseUrl };
+		queries.forEach((q, i) => {
+			variables[`q${i}`] = q;
+		});
+
+		try {
+			const rsp = await this.graphql<Record<string, { issueCount?: number } | undefined>>(
+				provider,
+				token,
+				query,
+				variables,
+				scope,
+				cancellation,
+			);
+			if (rsp == null) return queries.map(() => undefined);
+
+			return queries.map((_, i) => rsp[`s${i}`]?.issueCount);
+		} catch (ex) {
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+
+	/**
+	 * The aliased-search engine behind every GitHub issue search: one GraphQL request carrying N independently
+	 * cursored `search` fields, `@include`-gated so an exhausted or unrequested one costs nothing.
+	 *
+	 * It exists as one implementation because the properties that make it correct are subtle and must not be
+	 * reproduced per read: each alias advances on its OWN cursor and is dropped from the request once exhausted
+	 * (so a finished search is never re-queried, which would re-emit its first page); results are mapped
+	 * node-by-node so one unmappable issue can't discard the page; the union is deduped by `url` rather than by
+	 * `IssueShape.id`, which for some providers is a per-repository number; and a provider that claims another
+	 * page while withholding its `endCursor` is reported as truncated instead of paged forever.
+	 *
+	 * {@link searchMyIssues} is one configuration of it (its three `@me` categories), and its alias names are
+	 * that read's published cursor keys.
+	 *
+	 * `searches` must have unique aliases, each a valid GraphQL name that is neither `page` nor `truncated` —
+	 * the composite cursor keys aliases at its top level, alongside those two reserved fields.
+	 */
+	private async searchIssuesByAlias(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		searches: readonly AliasedIssueSearch[],
+		options?: { baseUrl?: string; avatarSize?: number; includeBody?: boolean; cursor?: string; pageSize?: number },
+		cancellation?: AbortSignal,
+	): Promise<AliasedIssueSearchResult | undefined> {
 		const scope = getScopedLogger();
 
 		type SearchCategory = {
 			issueCount: number;
-			pageInfo?: {
-				endCursor?: string | null;
-				hasNextPage: boolean;
-			};
+			pageInfo?: { endCursor?: string | null; hasNextPage: boolean };
 			nodes: (GitHubIssue | null)[] | null;
 		};
-		interface SearchResult {
-			authored?: SearchCategory;
-			assigned?: SearchCategory;
-			mentioned?: SearchCategory;
-		}
+		/**
+		 * Aliases are keyed at the TOP LEVEL, alongside `page` and `truncated` — the format
+		 * {@link searchMyIssues} has always published, so it stays flat rather than nesting the aliases: a
+		 * consumer's persisted cursor has to keep resuming where it left off.
+		 *
+		 * A slot of `null` means exhausted and a missing slot means never requested; both keep that alias out of
+		 * the next request.
+		 */
 		interface SearchCursor {
 			page?: number;
-			authored?: string | null;
-			assigned?: string | null;
-			mentioned?: string | null;
 			truncated?: boolean;
+			[alias: string]: string | number | boolean | null | undefined;
+		}
+
+		// Enforced, not just documented: aliases share the cursor's top level with `page` and `truncated`, so an
+		// alias colliding with either would overwrite it — and the failure would be SILENT, a page number replaced
+		// by a cursor string that reads back as page 1, restarting the walk with no error and no truncation flag.
+		// Cheap to check, and it fails at the one call that introduced the collision rather than in a consumer's
+		// persisted cursor.
+		const reserved = searches.filter(s => s.alias === 'page' || s.alias === 'truncated');
+		if (reserved.length > 0) {
+			throw new Error(
+				`Issue search alias(es) ${reserved.map(s => `'${s.alias}'`).join(', ')} collide with the composite cursor's reserved keys`,
+			);
 		}
 
 		let cursor: SearchCursor | undefined;
@@ -3660,52 +3889,36 @@ export class GitHubApi {
 			} 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,
+		// A slot is a continuation string, `null` (exhausted), or absent. Anything else came from a malformed or
+		// foreign cursor, and is read as absent rather than threaded back into the request as a continuation.
+		const slotFor = (alias: string): string | null | undefined => {
+			const slot = cursor?.[alias];
+			return slot === null || typeof slot === 'string' ? slot : undefined;
 		};
-		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) {
+		// Every requested search is in the document; an exhausted one is switched OFF by its `@include` gate
+		// rather than removed, so a continuation's request keeps the shape of the first one and GitHub's
+		// query-document cache still recognizes it. `active` is what actually runs.
+		const isActive = (s: AliasedIssueSearch) => slotFor(s.alias) !== null;
+		const active = searches.filter(isActive);
+		// Reading nothing is the honest answer to "every requested search is exhausted (or none was requested)":
+		// widening back to the full set would return items the caller excluded, or re-emit a finished page.
+		if (active.length === 0) {
 			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, after: $authoredCursor, query: $authored, type: ISSUE)
-					@include(if: $includeAuthored) {
-					issueCount
-					pageInfo {
-						endCursor
-						hasNextPage
-					}
-					nodes {
-						... on Issue {
-							${gqIssueFragment}
-							${options?.includeBody ? 'body' : ''}
-						}
-					}
-				}
-				assigned: search(first: 100, after: $assignedCursor, query: $assigned, type: ISSUE)
-					@include(if: $includeAssigned) {
+		// GitHub's search caps a page at 100 regardless of what is asked for.
+		const pageSize = Math.min(100, Math.max(1, Math.trunc(options?.pageSize ?? 100)));
+		// `includeAssigned` etc. — the same variable names the read published before the aliases were made
+		// data-driven, so a recorded/asserted request shape stays recognizable.
+		const includeVar = (alias: string) => `include${alias.charAt(0).toUpperCase()}${alias.slice(1)}`;
+		const params = searches.flatMap(s => [
+			`$${s.alias}: String!`,
+			`$${s.alias}Cursor: String`,
+			`$${includeVar(s.alias)}: Boolean!`,
+		]);
+		const fields = searches.map(
+			s => `${s.alias}: search(first: ${pageSize}, after: $${s.alias}Cursor, query: $${s.alias}, type: ISSUE)
+					@include(if: $${includeVar(s.alias)}) {
 					issueCount
 					pageInfo {
 						endCursor
@@ -3717,114 +3930,84 @@ export class GitHubApi {
 							${options?.includeBody ? 'body' : ''}
 						}
 					}
-				}
-				mentioned: search(first: 100, after: $mentionedCursor, query: $mentioned, type: ISSUE)
-					@include(if: $includeMentioned) {
-					issueCount
-					pageInfo {
-						endCursor
-						hasNextPage
-					}
-					nodes {
-						... on Issue {
-							${gqIssueFragment}
-							${options?.includeBody ? 'body' : ''}
-						}
-					}
-				}
+				}`,
+		);
+		const query = `query searchIssues(
+				${params.join('\n\t\t\t\t')}
+				$avatarSize: Int
+			) {
+				${fields.join('\n\t\t\t\t')}
 			}`;
 
-		let search = options?.search?.trim() ?? '';
-
-		if (options?.user) {
-			search += ` user:${options.user}`;
-		}
-
-		if (options?.repos != null && options.repos.length > 0) {
-			const repo = '  repo:';
-			search += `${repo}${options.repos.join(repo)}`;
+		const variables: Record<string, unknown> = {
+			baseUrl: options?.baseUrl,
+			avatarSize: options?.avatarSize,
+		};
+		for (const s of searches) {
+			variables[s.alias] = s.query;
+			variables[`${s.alias}Cursor`] = slotFor(s.alias) ?? undefined;
+			variables[includeVar(s.alias)] = isActive(s);
 		}
 
-		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<SearchResult>(
+			const rsp = await this.graphql<Record<string, SearchCategory | undefined>>(
 				provider,
 				token,
 				query,
-				{
-					authored: `${search} ${baseFilters} author:@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,
-				},
+				variables,
 				scope,
 				cancellation,
 			);
-
 			if (rsp == null) return { values: [], hasMore: false, page: page, truncated: false };
 
 			// Map node-by-node so one unmappable issue can't discard the whole result set
 			const issues: IssueShape[] = [];
-			for (const node of [
-				...(rsp.assigned?.nodes ?? []),
-				...(rsp.mentioned?.nodes ?? []),
-				...(rsp.authored?.nodes ?? []),
-			]) {
-				if (node?.id == null) continue;
-
-				try {
-					issues.push(fromGitHubIssue(node, provider));
-				} catch (ex) {
-					scope?.warn(`skipped unmappable issue; id=${node.id}, url=${node.url}, ex=${ex}`);
+			for (const s of active) {
+				for (const node of rsp[s.alias]?.nodes ?? []) {
+					if (node?.id == null) continue;
+
+					try {
+						issues.push(fromGitHubIssue(node, provider));
+					} catch (ex) {
+						scope?.warn(`skipped unmappable issue; id=${node.id}, url=${node.url}, ex=${ex}`);
+					}
 				}
 			}
 
+			// Dedupe by `url`, not `IssueShape.id`: for some providers `id` is a per-repository number, so an
+			// id-keyed map would collapse distinct issues across repositories.
 			const results: IterableIterator<IssueShape> = uniqueBy(
 				issues,
 				r => r.url,
 				(original, _current) => original,
 			);
 
-			const nextCategoryCursor = (category: SearchCategory | undefined): string | null => {
-				if (category?.pageInfo?.hasNextPage && category.pageInfo.endCursor) {
-					return category.pageInfo.endCursor;
+			// Every alias gets a slot, so an inactive one keeps its `null` and stays out of the next request. A
+			// missing slot would be read as "never requested", which for a `searches` set that still lists it
+			// would restart it from its first page.
+			const next: SearchCursor = { page: page + 1 };
+			let hasMore = false;
+			let continuationMissing = false;
+			let maxIssueCount = 0;
+			for (const s of searches) {
+				const category = rsp[s.alias];
+				const endCursor =
+					category?.pageInfo?.hasNextPage && category.pageInfo.endCursor ? category.pageInfo.endCursor : null;
+				next[s.alias] = endCursor;
+				if (endCursor != null) {
+					hasMore = true;
 				}
-				return null;
-			};
-			const next: SearchCursor = {
-				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,
-			);
+				if (category?.pageInfo?.hasNextPage === true && category.pageInfo.endCursor == null) {
+					continuationMissing = true;
+				}
+				maxIssueCount = Math.max(maxIssueCount, category?.issueCount ?? 0);
+			}
+
+			// GitHub search exposes at most `githubSearchResultLimit` results PER SEARCH, so the ceiling is
+			// reached as soon as any one alias exceeds it. Paging removes the old 100-item truncation; only that
+			// upstream ceiling or an unusable continuation leaves the read incomplete.
 			const truncated =
-				cursor?.truncated === true ||
-				(rsp.authored?.issueCount ?? 0) > 1000 ||
-				(rsp.assigned?.issueCount ?? 0) > 1000 ||
-				(rsp.mentioned?.issueCount ?? 0) > 1000 ||
-				continuationMissing;
+				cursor?.truncated === true || maxIssueCount > githubSearchResultLimit || continuationMissing;
 			next.truncated = truncated || undefined;
 			return {
 				values: [...results],
@@ -3832,6 +4015,7 @@ export class GitHubApi {
 				hasMore: hasMore,
 				page: page,
 				truncated: truncated,
+				totalCount: maxIssueCount,
 			};
 		} catch (ex) {
 			throw this.handleException(ex, provider, scope);