@gitkraken/core-gitlens 0.5.112 → 0.5.114

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

@@ -0,0 +1,197 @@
+import type { IssueShape } from '../../../git/models/issue.js';
+import { chunk } from '../../../utils/array.js';
+import { mapBounded } from '../../../utils/promise.js';
+import type { IntegrationIds } from '../constants.js';
+import { providerFanOutConcurrency } from '../constants.js';
+import type { ProviderResult, ProviderWarning } from '../results.js';
+import { appendDedupedWarning } from '../results.js';
+import {
+	isGitHostIntegration,
+	isIssuesHostIntegrationId,
+	warnOnMissingSessionForDomain,
+} from '../utils/integration.utils.js';
+import type { ProviderReadContext } from './context.js';
+import { runCaptured } from './drains.js';
+import { gitHostOnlySurfaceWarning, issuesUnsupportedWarning, otherWarning } from './warnings.js';
+
+/**
+ * The BATCH issue read: resolve N `(owner, repo, number)` coordinates in one request.
+ *
+ * A sibling of the issue searches rather than a mode of one, because it answers a different question. A search
+ * asks "what matches"; this asks "does this exact issue exist", which is what a caller correlating a branch name
+ * to the issue it references is actually asking. Three consequences follow, and they are the reason this exists:
+ *
+ * - It resolves by EXACT NUMBER, so relevance never enters into it.
+ * - No result ceiling applies, so there is no partial window to reason about and no omission to report.
+ * - An absent slot is a PROVEN ABSENCE, not "not found within a page budget". That is the property that matters
+ *   most: a caller can CACHE a miss. Emulating this with a paged list cannot prove absence without walking the
+ *   whole scope, so a miss stays unproven and the walk repeats on every pass, forever.
+ *
+ * Modeled on `countIssues` for its shape — caller-owned `key` echoed back, per-target isolation, chunked into as
+ * few requests as possible — because both take a set of independent questions and answer them together.
+ */
+
+/** One issue to resolve, identified by coordinate and echoed back under the caller's own `key`. */
+export interface IssueBatchTarget {
+	/** Caller-owned identifier, echoed on the result so no positional matching is needed. Must be unique. */
+	key: string;
+	owner: string;
+	repo: string;
+	number: number;
+}
+
+/** The answer for one {@link IssueBatchTarget}. */
+export interface IssueBatchResult {
+	key: string;
+	/**
+	 * The resolved issue, or `undefined` when it PROVABLY does not exist (or is not visible to this connection).
+	 *
+	 * Absent is an answer here, unlike every paged read on this facade: a target whose chunk FAILED is not
+	 * returned at all and sets `fetchFailed`, so a caller can tell "proven absent" from "unknown" and cache the
+	 * first without ever caching the second.
+	 */
+	issue?: IssueShape;
+}
+
+/**
+ * How many coordinates go into one upstream request.
+ *
+ * Measured rather than inherited from `issueCountChunkSize`, since that one rests on a zero-node selection and
+ * this carries the full issue projection per alias. Against the live API on all-resolving coordinates: 10 took
+ * 875ms, 25 took 890ms — so up to 25 is effectively free — 50 took 1.3s, and 75 took 2.7s. No complexity refusal
+ * appeared up to 100.
+ *
+ * 25 is where latency is still flat, with room before it degrades. It also puts any realistic correlation batch
+ * in ONE request, which is the whole point of the read.
+ */
+const issueBatchChunkSize = 25;
+
+export async function getIssuesBatch(
+	ctx: ProviderReadContext,
+	options: {
+		providerId: IntegrationIds;
+		targets: readonly IssueBatchTarget[];
+		connectionId?: string;
+		/**
+		 * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+		 * it must come from the trusted authentication configuration, not repository or remote data.
+		 */
+		domain?: string;
+	},
+): Promise<ProviderResult<IssueBatchResult>> {
+	const refused = (warning: ProviderWarning): ProviderResult<IssueBatchResult> => ({
+		items: [],
+		warnings: [warning],
+		fetchFailed: true,
+	});
+
+	if (isIssuesHostIntegrationId(options.providerId)) {
+		return refused(
+			gitHostOnlySurfaceWarning(options.providerId, undefined, options.connectionId, 'Batch issue resolution'),
+		);
+	}
+
+	// Nothing was asked for, so nothing is missing: an empty success, not a refusal.
+	if (options.targets.length === 0) return { items: [], warnings: [] };
+
+	const duplicateKey = findDuplicateKey(options.targets);
+	if (duplicateKey != null) {
+		// Refuses the whole call rather than deduping: `key` exists so the caller can match results without
+		// positional bookkeeping, and two results under one key make that ambiguous for EVERY target, not just
+		// the repeated one.
+		return refused(
+			otherWarning(
+				options.providerId,
+				undefined,
+				options.connectionId,
+				`Duplicate issue batch target key '${duplicateKey}'; keys identify results, so each must be unique.`,
+			),
+		);
+	}
+
+	const integration = await ctx.getIntegrationForRead(options.providerId, options.connectionId, options.domain);
+	if (integration == null) {
+		// A supplied connection or domain that no longer resolves is a broken target, not an empty account.
+		const early = ctx.earlyReturnConnectionWarnings(options.providerId, options.connectionId, options.domain);
+		return { items: [], warnings: early.warnings, fetchFailed: early.fetchFailed || undefined };
+	}
+	if (!isGitHostIntegration(integration)) {
+		return refused(
+			gitHostOnlySurfaceWarning(options.providerId, undefined, options.connectionId, 'Batch issue resolution'),
+		);
+	}
+
+	const domain = ctx.domainForRead(integration, options.providerId, options.connectionId, options.domain);
+	const warnOnMissingSession = warnOnMissingSessionForDomain(options.providerId, options.domain);
+
+	if (!integration.supportsIssues) {
+		return refused(issuesUnsupportedWarning(options.providerId, domain, options.connectionId));
+	}
+
+	const warnings: ProviderWarning[] = [];
+	let fetchFailed = false;
+
+	// Chunks are independent requests over their own slice of targets — nothing in one reads what another
+	// produced, and `runCaptured` never throws — so they run concurrently, bounded like every other fan-out here.
+	// `mapBounded` returns in input order, so `items` stays in target order.
+	const batches = await mapBounded(
+		chunk([...options.targets], issueBatchChunkSize),
+		providerFanOutConcurrency,
+		batch =>
+			runCaptured(
+				options.providerId,
+				domain,
+				options.connectionId,
+				() =>
+					integration.getIssuesBatchResult(
+						batch.map(t => ({ owner: t.owner, repo: t.repo, number: t.number })),
+						undefined,
+						options.connectionId,
+					),
+				{ warnOnMissingSession: warnOnMissingSession },
+			).then(result => ({ batch: batch, ...result })),
+	);
+
+	const items: IssueBatchResult[] = [];
+	for (const { batch, value, warning } of batches) {
+		if (warning != null) {
+			appendDedupedWarning(warnings, warning);
+		}
+		if (value == null) {
+			// A provider that doesn't implement the batch hook answers `undefined` with no error. Either way this
+			// chunk contributes nothing while the chunks around it still do, so its targets are DROPPED rather
+			// than reported as absent — the difference between "unknown" and "proven absent" is the read's whole
+			// value, and a failure must never be cached as an answer.
+			if (warning == null) {
+				appendDedupedWarning(
+					warnings,
+					otherWarning(
+						options.providerId,
+						domain,
+						options.connectionId,
+						`Batch issue resolution is not supported by '${options.providerId}'; resolve issues individually instead.`,
+					),
+				);
+			}
+			fetchFailed = true;
+			continue;
+		}
+
+		for (let i = 0; i < batch.length; i++) {
+			const issue = value[i];
+			items.push({ key: batch[i].key, ...(issue != null ? { issue: issue } : {}) });
+		}
+	}
+
+	return { items: items, warnings: warnings, fetchFailed: fetchFailed || undefined };
+}
+
+function findDuplicateKey(targets: readonly { key: string }[]): string | undefined {
+	const seen = new Set<string>();
+	for (const target of targets) {
+		if (seen.has(target.key)) return target.key;
+
+		seen.add(target.key);
+	}
+	return undefined;
+}

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

@@ -48,6 +48,12 @@ export async function listPullRequestsPage(
 		includeReviewRequested?: boolean;
 		page?: number;
 		cursor?: string;
+		/**
+		 * Requests the lightweight row shape (see {@link IntegrationManager.listPullRequestsPage}). Opt-in
+		 * only, and only on the repo-scoped branch: the account-wide branch has always read the lightweight
+		 * shape and keeps doing so, so an explicit `false` does not widen it back to the full projection.
+		 */
+		summary?: boolean;
 		itemsPerPage?: number;
 		forceSync?: boolean;
 		connectionId?: string;
@@ -115,45 +121,49 @@ export async function listPullRequestsPage(
 		);
 	}
 
-	const includeReviewRequested = accountWide ? (options.includeReviewRequested ?? false) : false;
-	const { value, warning } = await runCaptured(
-		options.providerId,
-		domain,
-		options.connectionId,
-		() =>
-			accountWide
-				? integration.getMyPullRequestsForUserResult(
-						{
-							state: options.states,
-							cursor: cursor,
-							includeReviewRequested: includeReviewRequested,
-							filters: resolvedFilters.filters,
-							summary: true,
-						},
-						options.connectionId,
-					)
-				: integration.getMyPullRequestsForReposResult(
-						options.repos ?? [],
-						// Forward `page`/`pageSize` alongside the cursor so PagingMode.Repo hosts (GitLab, Bitbucket,
-						// Azure), whose per-repo cursor path ignores a synthesized page-number cursor, still honor the
-						// requested page and page size instead of always returning page 1. `filters` scopes the read to
-						// the current user (the core resolves the account for these), so it returns the user's PRs.
-						{
-							state: options.states,
-							filters: resolvedFilters.filters,
-							cursor: cursor,
-							// The normalized `page`, so the number forwarded to the provider can't disagree with the
-							// page-number cursor beside it — both are built from the same value. Only when the caller
-							// asked for one: an omitted page is the provider's own first page.
-							page: options.page != null ? page : undefined,
-							pageSize: options.itemsPerPage,
-						},
-						options.connectionId,
-					),
-		{
-			warnOnMissingSession: warnOnMissingSessionForDomain(options.providerId, options.domain),
-		},
-	);
+	// Everything but the cursor, shared by the initial read and the drain's re-reads below so the two cannot
+	// drift. `summary` is the reason this matters beyond tidiness: a re-read that dropped it would both
+	// revert to the full payload — on the very path that issues the most requests — and return rows of a
+	// different shape than the first page, since a summary row reports `headCommit`/`commitCount` as absent.
+	// `summary` is pinned true here rather than forwarded: this branch has never had a full projection to
+	// fall back to (see the option's doc), so honoring an explicit `false` would promise a widening the read
+	// cannot deliver.
+	const accountWideInput = {
+		state: options.states,
+		includeReviewRequested: options.includeReviewRequested ?? false,
+		filters: resolvedFilters.filters,
+		summary: true,
+	};
+	// `filters` scopes the read to the current user (the core resolves the account for these), so it returns
+	// the user's PRs. `pageSize` rides along so PagingMode.Repo hosts (GitLab, Bitbucket, Azure), whose
+	// per-repo cursor path ignores a synthesized page-number cursor, honor the requested size.
+	const scopedInput = {
+		state: options.states,
+		filters: resolvedFilters.filters,
+		pageSize: options.itemsPerPage,
+		summary: options.summary,
+	};
+	const readPage = (pageCursor: string | undefined, requestedPage?: number) =>
+		runCaptured(
+			options.providerId,
+			domain,
+			options.connectionId,
+			() =>
+				accountWide
+					? integration.getMyPullRequestsForUserResult(
+							{ ...accountWideInput, cursor: pageCursor },
+							options.connectionId,
+						)
+					: integration.getMyPullRequestsForReposResult(
+							options.repos ?? [],
+							{ ...scopedInput, cursor: pageCursor, page: requestedPage },
+							options.connectionId,
+						),
+			{
+				warnOnMissingSession: warnOnMissingSessionForDomain(options.providerId, options.domain),
+			},
+		);
+	const { value, warning } = await readPage(cursor, options.page != null ? page : undefined);
 
 	let items = value?.values ?? [];
 	// Cursor-only account-wide reads start at page 1; a page-only request is advanced through opaque
@@ -180,37 +190,8 @@ export async function listPullRequestsPage(
 				requestedPage: page,
 				itemsPerPage: options.itemsPerPage,
 				warnings: warnings,
-				readPage: (cursor: string) =>
-					runCaptured(
-						options.providerId,
-						domain,
-						options.connectionId,
-						() =>
-							accountWide
-								? integration.getMyPullRequestsForUserResult(
-										{
-											state: options.states,
-											cursor: cursor,
-											includeReviewRequested: includeReviewRequested,
-											filters: resolvedFilters.filters,
-											summary: true,
-										},
-										options.connectionId,
-									)
-								: integration.getMyPullRequestsForReposResult(
-										options.repos ?? [],
-										{
-											state: options.states,
-											filters: resolvedFilters.filters,
-											cursor: cursor,
-											pageSize: options.itemsPerPage,
-										},
-										options.connectionId,
-									),
-						{
-							warnOnMissingSession: warnOnMissingSessionForDomain(options.providerId, options.domain),
-						},
-					),
+				// A drain advances through provider continuations, so only the cursor positions these reads.
+				readPage: (cursor: string) => readPage(cursor),
 			},
 		);
 		items = drained.items;

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

@@ -48,6 +48,8 @@ export async function searchPullRequestsPage(
 		forceSync?: boolean;
 		connectionId?: string;
 		domain?: string;
+		/** See {@link IntegrationManager.searchPullRequestsPage}. */
+		summary?: boolean;
 	},
 ): Promise<ProviderPagedResult<PullRequestShape>> {
 	const page = Math.max(1, Math.trunc(options.page ?? 1));
@@ -142,6 +144,7 @@ export async function searchPullRequestsPage(
 						criteria: options.criteria,
 						cursor: cursor,
 						pageSize: options.itemsPerPage,
+						summary: options.summary,
 					},
 					undefined,
 					options.connectionId,

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

@@ -151,13 +151,18 @@ function sliceOutcome(slice: SweepSlice | undefined): ProviderSweepTargetEvent['
  *
  * The try/catch is what makes the observer observation-only: called from the fan-out's success path, a throwing
  * callback would otherwise propagate out of the `mapBounded` task and reject the entire sweep — corrupting the
- * read, not just the metric. Swallowed silently; the consumer owns its own aggregation.
+ * read, not just the metric. Swallowed silently; the consumer owns its own aggregation. The `void`-typed
+ * callback also admits an `async` consumer, whose rejection is created only after `observe` returns — the
+ * `Promise.resolve(...).catch` swallows that too, so it cannot escape as an unhandled rejection.
  *
  * The domain is resolved here rather than carried out of {@link sweepTarget}, so every target reports it by the
  * same rule no matter how far it got. `resolveDomainForRead` needs no integration instance, which is what makes
  * that possible: a target rejected by the first guard resolves the same host a fully drained one does.
  */
-function startSweepReporting(ctx: ProviderReadContext, observe: (event: ProviderSweepTargetEvent) => void) {
+function startSweepReporting(
+	ctx: ProviderReadContext,
+	observe: (event: ProviderSweepTargetEvent) => void | PromiseLike<unknown>,
+) {
 	const fanOutStartedAt = performance.now();
 
 	return function beginTarget(target: ProviderSweepTarget) {
@@ -165,16 +170,18 @@ function startSweepReporting(ctx: ProviderReadContext, observe: (event: Provider
 
 		return function reportSettled(slice: SweepSlice | undefined) {
 			try {
-				observe({
-					providerId: target.providerId,
-					domain: ctx.resolveDomainForRead(target.providerId, target.connectionId, target.domain),
-					connectionId: target.connectionId,
-					count: slice?.items.length ?? 0,
-					durationMs: performance.now() - startedAt,
-					queueWaitMs: startedAt - fanOutStartedAt,
-					outcome: sliceOutcome(slice),
-					truncated: slice?.truncated ?? false,
-				});
+				void Promise.resolve(
+					observe({
+						providerId: target.providerId,
+						domain: ctx.resolveDomainForRead(target.providerId, target.connectionId, target.domain),
+						connectionId: target.connectionId,
+						count: slice?.items.length ?? 0,
+						durationMs: performance.now() - startedAt,
+						queueWaitMs: startedAt - fanOutStartedAt,
+						outcome: sliceOutcome(slice),
+						truncated: slice?.truncated ?? false,
+					}),
+				).catch(() => {});
 			} catch {}
 		};
 	};

package/src/utils/promiseCache.ts

@@ -97,6 +97,14 @@ export class PromiseCache<K, V> {
 		return this.cache.keys();
 	}
 
+	/**
+	 * Returns the number of entries in the cache, including expired entries that haven't been evicted yet
+	 * (they are only evicted on access), so this reflects what's actually retained in memory.
+	 */
+	get size(): number {
+		return this.cache.size;
+	}
+
 	/**
 	 * Gets a promise from the cache without creating it and updates accessed time
 	 * @param key - The cache key
@@ -139,6 +147,11 @@ export class PromiseCache<K, V> {
 			accessTTL?: number;
 			/** Whether to expire the entry if the promise fails */
 			expireOnError?: boolean;
+			/**
+			 * Called after the factory resolves. If the predicate resolves to true, the entry is evicted while
+			 * the current caller still receives the resolved value.
+			 */
+			evictWhen?: (value: V) => boolean | Promise<boolean>;
 			/**
 			 * TTL (time-to-live) in milliseconds for caching errors. When the factory rejects and `errorTTL` is set,
 			 * the cache entry is replaced with `Promise.resolve(undefined)` for subsequent callers, and the error
@@ -282,6 +295,20 @@ export class PromiseCache<K, V> {
 			}
 		}
 
+		const evictWhen = options?.evictWhen;
+		if (evictWhen != null) {
+			const candidate = entry;
+			void candidate.promise
+				.then(value => evictWhen(value))
+				.then(evict => {
+					if (evict) {
+						deleteIfOwned(this.cache, key, candidate);
+					}
+				})
+				// A retention policy must not surface a rejection independently of the caller-facing operation.
+				.catch(() => {});
+		}
+
 		// Clean up expired entries and enforce capacity limit in one pass
 		if (this.cache.size > 1) {
 			queueMicrotask(() => this.cleanup());
@@ -609,6 +636,11 @@ export class RepoPromiseCacheMap<K, V> {
 			accessTTL?: number;
 			/** Whether to expire the entry if the promise fails */
 			expireOnError?: boolean;
+			/**
+			 * Called after the factory resolves. If the predicate resolves to true, the entry is evicted while
+			 * the current caller still receives the resolved value.
+			 */
+			evictWhen?: (value: V) => boolean | Promise<boolean>;
 			/**
 			 * TTL (time-to-live) in milliseconds for caching errors. When the factory rejects and `errorTTL` is set,
 			 * the cache entry is replaced with `Promise.resolve(undefined)` for subsequent callers, and the error
@@ -755,6 +787,17 @@ export class RepoPromiseCacheMap<K, V> {
 		this.cache.clear();
 	}
 
+	/**
+	 * Returns the total number of entries across all repository caches.
+	 */
+	get entryCount(): number {
+		let count = 0;
+		for (const repoCache of this.cache.values()) {
+			count += repoCache.size;
+		}
+		return count;
+	}
+
 	/**
 	 * Returns the number of repositories in the cache.
 	 */

package/src/utils/resourceUsage.ts

@@ -0,0 +1,5 @@
+export type ResourceUsageUnit = 'bytes' | 'count';
+export type ResourceUsageMetric = `${string}.${ResourceUsageUnit}`;
+
+/** A flat resource-usage snapshot whose metric names carry their units. */
+export type ResourceUsage = Partial<Record<ResourceUsageMetric, number>>;

package/src/utils/string.ts

@@ -430,12 +430,40 @@ export function getTokensFromTemplateRegex(template: string): TokenMatch[] {
 	return tokens;
 }
 
+/**
+ * Above this size, a source string split via {@link iterateByDelimiter} has its yielded records
+ * flattened (see {@link flattenString}) — below it, the parent-pinning cost of sliced strings is
+ * bounded and not worth the copy.
+ */
+const maxDelimiterSourceLength = 128 * 1024;
+
+/**
+ * Forces V8 to create a flat copy of `s`, breaking any sliced-string reference to a parent string.
+ *
+ * V8 represents `substring()` results of 13+ characters as SlicedString views that retain their
+ * entire parent string. A single retained field parsed out of a large buffer (e.g. a git walk's
+ * full stdout) can therefore keep megabytes alive for as long as that field survives. Flattening
+ * copies only the view's own characters, releasing the parent.
+ *
+ * No-op for strings shorter than `minLength`, where pinning is bounded anyway and the copy isn't
+ * worth the allocation.
+ */
+export function flattenString(s: string, minLength = 1024): string {
+	if (s.length < minLength) return s;
+
+	// Concatenating a prefix then slicing it off forces V8 to materialize a flat copy of `s` —
+	// deliberately not a template literal, which V8 can represent as another cons/sliced view.
+	// oxlint-disable-next-line prefer-template
+	return (' ' + s).slice(1);
+}
+
 /**
  * Fast string delimiter iterator
  * Optimized for simple string splitting without generator overhead
  */
 class StringDelimiterIterator implements IterableIterator<string> {
 	private readonly delimiterLen: number;
+	private readonly flatten: boolean;
 	private index = 0;
 	private done = false;
 
@@ -444,6 +472,11 @@ class StringDelimiterIterator implements IterableIterator<string> {
 		private readonly delimiter: string,
 	) {
 		this.delimiterLen = delimiter.length;
+		// Yielded substrings are V8 SlicedStrings that retain their parent; when splitting a large
+		// buffer (e.g. a git walk's full stdout) that parent pinning keeps megabytes alive for as
+		// long as any single parsed field survives. Above this threshold, flatten each yielded
+		// record so it only holds its own characters.
+		this.flatten = data.length > maxDelimiterSourceLength;
 	}
 
 	next(): IteratorResult<string> {
@@ -455,7 +488,11 @@ class StringDelimiterIterator implements IterableIterator<string> {
 		const j = this.data.indexOf(this.delimiter, this.index);
 		const endIndex = j === -1 ? this.data.length : j;
 
-		const value = this.data.substring(this.index, endIndex);
+		// Always flatten here: even a small record pins the entire (potentially huge) parent buffer
+		// through its sliced string, so the minLength guard in flattenString must not apply.
+		const value = this.flatten
+			? flattenString(this.data.substring(this.index, endIndex), 1)
+			: this.data.substring(this.index, endIndex);
 		this.index = endIndex + this.delimiterLen;
 
 		return { done: false, value: value };

package/dist/plus/agents/providers/claudeCodeProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claudeCodeProvider.d.ts","sourceRoot":"","sources":["../../../../src/plus/agents/providers/claudeCodeProvider.ts"],"names":[],"mappings":"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"}