@gitkraken/core-gitlens 0.4.100 → 0.4.101

package/src/plus/integrations/reads/hierarchy.ts

@@ -1,9 +1,9 @@
 import { mapBounded } from '../../../utils/promise.js';
 import { mergeAssessmentInto } from '../collectionMetadata.js';
+import type { IntegrationIds } from '../constants.js';
 import {
 	GitCloudHostIntegrationId,
 	GitSelfManagedHostIntegrationId,
-	type IntegrationIds,
 	providerFanOutConcurrency,
 	supportedOrderedCloudIntegrationIds,
 	supportedOrderedCloudIssuesIntegrationIds,
@@ -28,6 +28,7 @@ import type { ProviderReadContext } from './context.js';
 import { runCaptured } from './drains.js';
 import {
 	assertHierarchyReadTarget,
+	mergeHierarchyResults,
 	orgForProject,
 	resourceMatchesOrg,
 	resourceToOrg,
@@ -132,25 +133,7 @@ export async function listOrgs(
 		return { items: items, warnings: warnings, fetchFailed: fetchFailed };
 	});
 
-	const items: ProviderOrganization[] = [];
-	const warnings: ProviderWarning[] = [];
-	let fetchFailed = false;
-	for (const result of results) {
-		if (result == null) {
-			continue;
-		}
-
-		items.push(...result.items);
-		// Dedupe across the multi-provider fan-out (matches listProjects): a warning that repeats verbatim
-		// across scopes — e.g. the same account surfaced under two ids — shouldn't be reported twice.
-		for (const w of result.warnings) {
-			appendDedupedWarning(warnings, w);
-		}
-		if (result.fetchFailed) {
-			fetchFailed = true;
-		}
-	}
-	return { items: items, warnings: warnings, fetchFailed: fetchFailed || undefined };
+	return mergeHierarchyResults(results);
 }
 
 export async function listProjects(
@@ -281,23 +264,7 @@ export async function listProjects(
 		return { items: items, warnings: warnings, fetchFailed: fetchFailed };
 	});
 
-	const items: ProviderOrganization[] = [];
-	const warnings: ProviderWarning[] = [];
-	let fetchFailed = false;
-	for (const result of results) {
-		if (result == null) {
-			continue;
-		}
-
-		items.push(...result.items);
-		for (const w of result.warnings) {
-			appendDedupedWarning(warnings, w);
-		}
-		if (result.fetchFailed) {
-			fetchFailed = true;
-		}
-	}
-	return { items: items, warnings: warnings, fetchFailed: fetchFailed || undefined };
+	return mergeHierarchyResults(results);
 }
 
 export async function listRepos(
@@ -365,128 +332,141 @@ export async function listRepos(
 	}
 
 	const org = options.org;
-	const cursor = options.cursor ?? pageToCursor(page);
-	const { value, warning } = await runCaptured(
-		options.providerId,
-		domain,
-		options.connectionId,
-		() =>
-			org == null
-				? integration.getRepositoriesForUserResult({
-						cursor: cursor,
-						connectionId: options.connectionId,
-					})
-				: integration.getRepositoriesForOrgResult(org, {
-						project: options.project,
-						cursor: cursor,
-						connectionId: options.connectionId,
-					}),
-		{ warnOnMissingSession: warnOnMissingSessionForDomain(options.providerId, options.domain) },
-	);
+	const warnOnMissingSession = warnOnMissingSessionForDomain(options.providerId, options.domain);
+	const readPage = (cursor: string | undefined) =>
+		runCaptured(
+			options.providerId,
+			domain,
+			options.connectionId,
+			() =>
+				org == null
+					? integration.getRepositoriesForUserResult({ cursor: cursor, connectionId: options.connectionId })
+					: integration.getRepositoriesForOrgResult(org, {
+							project: options.project,
+							cursor: cursor,
+							connectionId: options.connectionId,
+						}),
+			{ warnOnMissingSession: warnOnMissingSession },
+		);
 
-	const items = value?.values ?? [];
-	const warnings = warning != null ? [warning] : [];
-	// The repos read core is cursor-only and can't accept a page size, so don't echo the requested
-	// `itemsPerPage` as if it were applied — report what the provider returned (its own pageSize when
-	// available, else the actual item count).
-	const paged = toProviderPageInfo(items.length, value?.paging);
-	// Convert the SDK collection metadata into scope-aware warnings + failure/truncation flags, appending
-	// them to any captured thrown-error warning without discarding the partial result's items.
-	const assessment = mergeAssessmentInto(warnings, options.providerId, domain, options.connectionId, value?.metadata);
-	// Whether this read honors a page NUMBER, decided from what the provider actually reported rather than
-	// guessed from the absence of a cursor. A numbered-page repos host reports its position (`paging.page`)
-	// and/or its successor (`paging.nextPage`) — Bitbucket's workspace walk consumes `page` as a real 1-based
-	// page and reports `nextPage` without echoing `currentPage`, so both signals have to count. Every wired
-	// cursor-based repos read (GitHub's org/user walks, GitLab's user walk, Bitbucket's cursor read) reports
-	// neither. Keying off `paged.cursor == null` instead read the paging layer's "reported another page,
-	// handed back no continuation" sentinel as evidence of a numbered host, which is exactly backwards.
-	const pageAdvanceable = value?.paging?.page != null || value?.paging?.nextPage != null;
-	// Numbered-page hosts that don't echo `currentPage` may still be advanced by the requested `page` (initial
-	// read) or by the cursor the caller threaded back. A cursor-only host ignores an UNTHREADED `page`
-	// request, so its page-less first page is page 1.
-	const currentPage = resolveCurrentPage({
-		providerPage: paged.page.currentPage,
-		requestedPage: page,
-		suppliedCursor: options.cursor,
-		pageAdvanceable: pageAdvanceable,
-	});
-	// Never advertise `hasMore` without a continuation the caller can act on — the same contract
-	// `listPullRequestsPage`, `listIssuesPage` and `broadenIssues` hold, via the same helper. A provider that
-	// reports another page but hands back neither `endCursor` nor `nextPage` (surfaced as the `'{}'` sentinel,
-	// which `toProviderPageInfo` drops) is terminal-but-incomplete: `hasMore: false` + `page.truncated`.
-	// Synthesizing a page-number cursor for a cursor-only host instead — which is what this read used to do
-	// unconditionally — handed back a continuation the provider ignores, so it answered with its FIRST page
-	// again while still reporting `hasMore: true`. A consumer draining until `hasMore` clears (Kepler's repo
-	// drain does exactly that) then looped to its own page cap, accumulating a duplicate copy of every repo
-	// per round, and never saw a truncation signal.
-	const continuation = resolveContinuation(paged, pageAdvanceable ? currentPage + 1 : undefined);
-	// The org-hierarchy read can also stop at a defensive backstop with more repos unlisted and no cursor to
-	// resume (top-level `truncated`, or `paging.truncated` on a single-page read). Metadata incompleteness and
-	// a demoted continuation are two further, independent sources of the same signal.
-	const truncated =
-		(value?.truncated ?? false) ||
-		(value?.paging?.truncated ?? false) ||
-		assessment.truncated ||
-		continuation.truncated;
-	const result: ProviderPagedResult<ProviderRepositoryShape> = {
-		// Normalize the raw provider-apis repos to the GitLens-owned shape at the surface boundary.
-		items: items.map(toProviderRepositoryShape),
-		warnings: warnings,
-		page: { ...paged.page, currentPage: currentPage, truncated: truncated || undefined },
-		hasMore: continuation.hasMore,
-		cursor: continuation.cursor,
-		fetchFailed: assessment.fetchFailed || (warning != null && value == null) || undefined,
+	/**
+	 * Builds one page's result from what the provider returned. Shared by the initial read and by every round of
+	 * the cursor walk below, so a walked page N is described by exactly the same rules as a directly-requested one
+	 * (position, continuation, truncation) rather than by a second copy of them.
+	 */
+	const toResult = (
+		{ value, warning }: Awaited<ReturnType<typeof readPage>>,
+		requestedPage: number,
+		suppliedCursor: string | undefined,
+	): ProviderPagedResult<ProviderRepositoryShape> => {
+		const items = value?.values ?? [];
+		const warnings = warning != null ? [warning] : [];
+		// The repos read core is cursor-only and can't accept a page size, so don't echo the requested
+		// `itemsPerPage` as if it were applied — report what the provider returned (its own pageSize when
+		// available, else the actual item count).
+		const paged = toProviderPageInfo(items.length, value?.paging);
+		// Convert the SDK collection metadata into scope-aware warnings + failure/truncation flags, appending
+		// them to any captured thrown-error warning without discarding the partial result's items.
+		const assessment = mergeAssessmentInto(
+			warnings,
+			options.providerId,
+			domain,
+			options.connectionId,
+			value?.metadata,
+		);
+		// Whether this read honors a page NUMBER, decided from what the provider actually reported rather than
+		// guessed from the absence of a cursor. A numbered-page repos host reports its position (`paging.page`)
+		// and/or its successor (`paging.nextPage`) — Bitbucket's workspace walk consumes `page` as a real 1-based
+		// page and reports `nextPage` without echoing `currentPage`, so both signals have to count. Every wired
+		// cursor-based repos read (GitHub's org/user walks, GitLab's user walk, Bitbucket's cursor read) reports
+		// neither. Keying off `paged.cursor == null` instead read the paging layer's "reported another page,
+		// handed back no continuation" sentinel as evidence of a numbered host, which is exactly backwards.
+		const pageAdvanceable = value?.paging?.page != null || value?.paging?.nextPage != null;
+		// Numbered-page hosts that don't echo `currentPage` may still be advanced by the requested `page` (initial
+		// read) or by the cursor the caller threaded back. A cursor-only host ignores an UNTHREADED `page`
+		// request, so its page-less first page is page 1.
+		const currentPage = resolveCurrentPage({
+			providerPage: paged.page.currentPage,
+			requestedPage: requestedPage,
+			suppliedCursor: suppliedCursor,
+			pageAdvanceable: pageAdvanceable,
+		});
+		// Never advertise `hasMore` without a continuation the caller can act on — the same contract
+		// `listPullRequestsPage`, `listIssuesPage` and `broadenIssues` hold, via the same helper. A provider that
+		// reports another page but hands back neither `endCursor` nor `nextPage` (surfaced as the `'{}'` sentinel,
+		// which `toProviderPageInfo` drops) is terminal-but-incomplete: `hasMore: false` + `page.truncated`.
+		// Synthesizing a page-number cursor for a cursor-only host instead — which is what this read used to do
+		// unconditionally — handed back a continuation the provider ignores, so it answered with its FIRST page
+		// again while still reporting `hasMore: true`. A consumer draining until `hasMore` clears (Kepler's repo
+		// drain does exactly that) then looped to its own page cap, accumulating a duplicate copy of every repo
+		// per round, and never saw a truncation signal.
+		const continuation = resolveContinuation(paged, pageAdvanceable ? currentPage + 1 : undefined);
+		// The org-hierarchy read can also stop at a defensive backstop with more repos unlisted and no cursor to
+		// resume (top-level `truncated`, or `paging.truncated` on a single-page read). Metadata incompleteness and
+		// a demoted continuation are two further, independent sources of the same signal.
+		const truncated =
+			(value?.truncated ?? false) ||
+			(value?.paging?.truncated ?? false) ||
+			assessment.truncated ||
+			continuation.truncated;
+		return {
+			// Normalize the raw provider-apis repos to the GitLens-owned shape at the surface boundary.
+			items: items.map(toProviderRepositoryShape),
+			warnings: warnings,
+			page: { ...paged.page, currentPage: currentPage, truncated: truncated || undefined },
+			hasMore: continuation.hasMore,
+			cursor: continuation.cursor,
+			fetchFailed: assessment.fetchFailed || (warning != null && value == null) || undefined,
+		};
 	};
 
-	// A cursor-only host ignores the synthesized page cursor above and returns page 1. Detect that from
-	// the provider's own paging metadata, then advance through its real continuations. Numbered hosts
-	// keep their one-request path because `pageAdvanceable` is true.
-	if (options.cursor == null && page > 1 && !pageAdvanceable) {
-		const traversalWarnings = [...result.warnings];
-		let traversalFetchFailed = result.fetchFailed === true;
-		let traversalTruncated = result.page.truncated === true;
-		let previous = result;
-
-		for (let currentPage = 2; currentPage <= page; currentPage++) {
-			if (!previous.hasMore || previous.cursor == null) {
-				return {
-					items: [],
-					warnings: traversalWarnings,
-					page: {
-						currentPage: page,
-						itemsPerPage: 0,
-						truncated: traversalTruncated || undefined,
-					},
-					hasMore: false,
-					fetchFailed: traversalFetchFailed || undefined,
-				};
-			}
-
-			const requested = await listRepos(ctx, {
-				...options,
-				page: currentPage,
-				cursor: previous.cursor,
-			});
-			for (const traversalWarning of requested.warnings) {
-				appendDedupedWarning(traversalWarnings, traversalWarning);
-			}
-			traversalFetchFailed ||= requested.fetchFailed === true;
-			traversalTruncated ||= requested.page.truncated === true;
+	const first = await readPage(options.cursor ?? pageToCursor(page));
+	const result = toResult(first, page, options.cursor);
+	// A numbered-page host honored the synthesized cursor, so this IS page N; a cursor-only host ignored it and
+	// answered with page 1, which the walk below advances. Decided from the provider's own paging metadata rather
+	// than assumed, hence after the read.
+	const pageAdvanceable = first.value?.paging?.page != null || first.value?.paging?.nextPage != null;
+	if (options.cursor != null || page === 1 || pageAdvanceable) return result;
 
-			if (currentPage === page) {
-				return {
-					...requested,
-					warnings: traversalWarnings,
-					page: {
-						...requested.page,
-						truncated: traversalTruncated || undefined,
-					},
-					fetchFailed: traversalFetchFailed || undefined,
-				};
-			}
+	// Walk the provider's real continuations to the requested page. Only the last page's items are kept — pages
+	// 1..N returned as "page N" would duplicate items for a normal paged consumer — while warnings, truncation,
+	// and failure accumulate across the whole walked prefix, since an earlier round's problem still means this
+	// result isn't authoritative. The provider read is re-issued per round, but the integration is resolved once:
+	// re-entering this function per page would repeat its auth resolution N times for page N.
+	const walkedWarnings = [...result.warnings];
+	let walkedFetchFailed = result.fetchFailed === true;
+	let walkedTruncated = result.page.truncated === true;
+	let previous = result;
+	for (let currentPage = 2; currentPage <= page; currentPage++) {
+		if (!previous.hasMore || previous.cursor == null) {
+			// The requested page lies past the provider's terminal cursor: an EMPTY page N, never the last
+			// available page relabeled (see ProviderPageInfo.currentPage).
+			return {
+				items: [],
+				warnings: walkedWarnings,
+				page: { currentPage: page, itemsPerPage: 0, truncated: walkedTruncated || undefined },
+				hasMore: false,
+				fetchFailed: walkedFetchFailed || undefined,
+			};
+		}
 
-			previous = requested;
+		const suppliedCursor = previous.cursor;
+		const requested = toResult(await readPage(suppliedCursor), currentPage, suppliedCursor);
+		for (const warning of requested.warnings) {
+			appendDedupedWarning(walkedWarnings, warning);
 		}
+		walkedFetchFailed ||= requested.fetchFailed === true;
+		walkedTruncated ||= requested.page.truncated === true;
+		if (currentPage === page) {
+			return {
+				...requested,
+				warnings: walkedWarnings,
+				page: { ...requested.page, truncated: walkedTruncated || undefined },
+				fetchFailed: walkedFetchFailed || undefined,
+			};
+		}
+
+		previous = requested;
 	}
 
 	return result;

package/src/plus/integrations/reads/hierarchy.utils.ts

@@ -1,7 +1,8 @@
 import type { IssueResourceDescriptor, ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
 import { IssuesCloudHostIntegrationId } from '../constants.js';
 import type { IntegrationIds } from '../constants.js';
-import type { ProviderOrganization } from '../results.js';
+import type { ProviderOrganization, ProviderResult, ProviderWarning } from '../results.js';
+import { appendDedupedWarning } from '../results.js';
 
 /**
  * Mapping of a provider's own hierarchy vocabulary onto the single {@link ProviderOrganization} shape the facade
@@ -30,6 +31,26 @@ export function resourceMatchesOrg(resource: ResourceDescriptor, org: string): b
 	return resource.key === org || typed.id === org || typed.name === org;
 }
 
+/**
+ * The id of the RESOURCE a project belongs to, used to look up which account (and therefore which user) that
+ * project's issues should be scoped to. Falls back through the project's own identifiers because some providers
+ * (and test doubles) return project descriptors without naming their parent.
+ */
+export function resourceIdForProject(project: ResourceDescriptor): string | undefined {
+	const typed = project as IssueResourceDescriptor & { resourceId?: string };
+	return typed.resourceId ?? typed.id ?? project.key;
+}
+
+/**
+ * A stable identity for one project across facade pages, for the retry/completed bookkeeping an issue-tracker
+ * cursor carries. All three identifiers are included rather than one preferred value: two trackers can reuse the
+ * same project id, so keying on a single field would collapse them into one entry.
+ */
+export function projectKey(project: ResourceDescriptor): string {
+	const typed = project as IssueResourceDescriptor & { resourceId?: string };
+	return JSON.stringify([typed.resourceId ?? '', typed.id ?? '', project.key]);
+}
+
 /**
  * Maps an issue-tracker resource descriptor to the unified {@link ProviderOrganization} org shape. `url` is
  * synthesized when the descriptor carries none, rather than widening the shared `ProviderOrganization.url` to
@@ -90,6 +111,34 @@ export function withProviderContext(providerId: IntegrationIds, item: ProviderOr
 	};
 }
 
+/**
+ * Merges the per-provider slices of a hierarchy fan-out into one flat result.
+ *
+ * `ProviderResult` has no page object, so `fetchFailed` is its only non-authoritative signal — any slice that
+ * failed or came back incomplete has to set it, or a caller would treat a short list as the whole account.
+ * Warnings are deduped because the same account can surface under two ids in one fan-out.
+ */
+export function mergeHierarchyResults<T>(
+	results: readonly ({ items: T[]; warnings: ProviderWarning[]; fetchFailed: boolean } | undefined)[],
+): ProviderResult<T> {
+	const items: T[] = [];
+	const warnings: ProviderWarning[] = [];
+	let fetchFailed = false;
+	for (const result of results) {
+		if (result == null) continue;
+
+		items.push(...result.items);
+		for (const warning of result.warnings) {
+			appendDedupedWarning(warnings, warning);
+		}
+		if (result.fetchFailed) {
+			fetchFailed = true;
+		}
+	}
+
+	return { items: items, warnings: warnings, fetchFailed: fetchFailed || undefined };
+}
+
 /**
  * Rejects a hierarchy read whose scoped selectors have no provider to apply to. `connectionId` and `domain`
  * both select among the connections OF a provider, so either one without `providerId` is ambiguous rather than

package/src/plus/integrations/reads/issueTracker.ts

@@ -3,7 +3,8 @@ import type { IssueShape } from '../../../git/models/issue.js';
 import type { ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
 import { mapBounded } from '../../../utils/promise.js';
 import { mergeAssessmentInto } from '../collectionMetadata.js';
-import { providerFanOutConcurrency, type IntegrationIds } from '../constants.js';
+import type { IntegrationIds } from '../constants.js';
+import { providerFanOutConcurrency } from '../constants.js';
 import { isIssuesIntegration } from '../models/issuesIntegration.js';
 import { IssueFilter, providersMetadata } from '../providers/models.js';
 import { mergeCollectionMetadata, parsePageCursor } from '../providers/utils/providerPaging.js';
@@ -12,7 +13,7 @@ import { isIssuesHostIntegrationId } from '../utils/integration.utils.js';
 import type { ProviderReadContext } from './context.js';
 import { parseIssueTrackerPageCursor, toIssueTrackerPageCursor } from './cursors.js';
 import { runCaptured } from './drains.js';
-import { resourceMatchesOrg } from './hierarchy.utils.js';
+import { projectKey, resourceIdForProject, resourceLabel, resourceMatchesOrg } from './hierarchy.utils.js';
 import { issueTrackerOnlySurfaceWarning, otherWarning } from './warnings.js';
 
 export async function listIssueTrackerIssuesPage(
@@ -219,19 +220,6 @@ export async function listIssueTrackerIssuesPage(
 		return emptyPage(true);
 	}
 
-	const resourceIdForProject = (project: ResourceDescriptor): string | undefined => {
-		const issueProject = project as { id?: string; key: string; resourceId?: string };
-		return issueProject.resourceId ?? issueProject.id ?? issueProject.key;
-	};
-	const retryKeyForProject = (project: ResourceDescriptor): string => {
-		const issueProject = project as { id?: string; key: string; resourceId?: string };
-		return JSON.stringify([issueProject.resourceId ?? '', issueProject.id ?? '', issueProject.key]);
-	};
-	const labelForResource = (resource: ResourceDescriptor): string => {
-		const issueResource = resource as { id?: string; key: string; name?: string };
-		return issueResource.name ?? issueResource.id ?? issueResource.key;
-	};
-
 	// Scope to the current user's assigned issues unless the caller broadens to all assignees. Resolve the
 	// handle from each resource's own account (multi-account safe), capturing any error so its kind
 	// (e.g. auth) is preserved rather than collapsed to a generic warning.
@@ -259,7 +247,7 @@ export async function listIssueTrackerIssuesPage(
 						options.providerId,
 						domain,
 						options.connectionId,
-						`Could not resolve the current user for '${labelForResource(resource)}'; skipping that resource to avoid returning issues assigned to others.`,
+						`Could not resolve the current user for '${resourceLabel(resource)}'; skipping that resource to avoid returning issues assigned to others.`,
 					),
 			);
 			accountLookupFailed = true;
@@ -294,22 +282,22 @@ export async function listIssueTrackerIssuesPage(
 			? matchedProjects.filter(project => {
 					if (userForProject(project) != null) return true;
 
-					const projectKey = retryKeyForProject(project);
-					retryProjectKeys.add(projectKey);
-					completedProjectKeys.delete(projectKey);
+					const key = projectKey(project);
+					retryProjectKeys.add(key);
+					completedProjectKeys.delete(key);
 					return false;
 				})
 			: matchedProjects;
 
 	// Select the untouched window plus any earlier windows/projects that explicitly need retrying. Keys
 	// include the parent resource so two trackers can reuse the same project id without collapsing.
-	const projectsByRetryKey = new Map(scopedProjectsWithUsers.map(project => [retryKeyForProject(project), project]));
+	const projectsByRetryKey = new Map(scopedProjectsWithUsers.map(project => [projectKey(project), project]));
 	const scopedProjectsByKey = new Map<string, ResourceDescriptor>();
 	const addScopedProject = (project: ResourceDescriptor): void => {
-		const projectKey = retryKeyForProject(project);
-		if (completedProjectKeys.has(projectKey)) return;
+		const key = projectKey(project);
+		if (completedProjectKeys.has(key)) return;
 
-		scopedProjectsByKey.set(projectKey, project);
+		scopedProjectsByKey.set(key, project);
 	};
 	for (const retryProject of priorRetryProjects) {
 		const project = projectsByRetryKey.get(retryProject);
@@ -396,7 +384,7 @@ export async function listIssueTrackerIssuesPage(
 	let projectTruncated = projectDiscoveryTruncated;
 	let drainMetadata: CollectionMetadata | undefined;
 	for (const { project, value: result, warning } of perProject) {
-		const projectKey = retryKeyForProject(project);
+		const key = projectKey(project);
 		const retryProject = result == null;
 		if (warning != null) {
 			warnings.push(warning);
@@ -418,13 +406,13 @@ export async function listIssueTrackerIssuesPage(
 			}
 		}
 		if (retryProject) {
-			retryProjectKeys.add(projectKey);
-			completedProjectKeys.delete(projectKey);
+			retryProjectKeys.add(key);
+			completedProjectKeys.delete(key);
 		} else {
 			// A usable partial/truncated project is emitted once and remains structurally incomplete.
 			// Re-running the same project cursor would normally return the same prefix and duplicate it
 			// across facade pages; only a project that returned no value is safe to retry automatically.
-			completedProjectKeys.add(projectKey);
+			completedProjectKeys.add(key);
 		}
 	}
 

package/src/plus/integrations/reads/issues.ts

@@ -1,7 +1,9 @@
 import type { IssueShape } from '../../../git/models/issue.js';
 import { mergeAssessmentInto } from '../collectionMetadata.js';
-import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, type IntegrationIds } from '../constants.js';
-import { IssueFilter, PagingMode, providersMetadata, type ProviderReposInput } from '../providers/models.js';
+import type { IntegrationIds } from '../constants.js';
+import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId } from '../constants.js';
+import type { IssueFilter, ProviderReposInput } from '../providers/models.js';
+import { PagingMode, providersMetadata } from '../providers/models.js';
 import { mergeCollectionMetadata } from '../providers/utils/providerPaging.js';
 import type { ProviderPagedResult, ProviderWarning } from '../results.js';
 import { appendDedupedWarning } from '../results.js';

package/src/plus/integrations/reads/pullRequests.ts

@@ -1,15 +1,8 @@
 import type { PullRequestShape, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
 import { mergeAssessmentInto } from '../collectionMetadata.js';
 import type { IntegrationIds } from '../constants.js';
-import type { GitHostIntegration } from '../models/gitHostIntegration.js';
-import {
-	fromProviderPullRequest,
-	PagingMode,
-	providersMetadata,
-	type ProviderPullRequest,
-	type ProviderReposInput,
-	type PullRequestFilter,
-} from '../providers/models.js';
+import type { ProviderPullRequest, ProviderReposInput, PullRequestFilter } from '../providers/models.js';
+import { fromProviderPullRequest, PagingMode, providersMetadata } from '../providers/models.js';
 import type { ProviderPagedResult } from '../results.js';
 import {
 	isGitHostIntegration,