@gitkraken/core-gitlens 0.1.0 → 0.3.0

package/src/plus/git-github/providers/github/branches.ts

@@ -1,6 +1,7 @@
 import type { Cache } from '../../../../git/cache.js';
 import { GitBranch } from '../../../../git/models/branch.js';
 import type { BranchContributionsOverview, GitBranchesSubProvider } from '../../../../git/providers/branches.js';
+import type { GitCommandPriority } from '../../../../git/run.types.js';
 import { createRevisionRange, stripOrigin } from '../../../../git/utils/revision.utils.js';
 import type { BranchSortOptions } from '../../../../git/utils/sorting.js';
 import { sortBranches, sortContributors } from '../../../../git/utils/sorting.js';
@@ -8,6 +9,7 @@ import { debug } from '../../../../utils/decorators/log.js';
 import { getScopedLogger } from '../../../../utils/logger.scoped.js';
 import type { PagedResult, PagingOptions } from '../../../../utils/paging.js';
 import { emptyPagedResult } from '../../../../utils/paging.js';
+import { getSettledValue } from '../../../../utils/promise.js';
 import type { CacheController } from '../../../../utils/promiseCache.js';
 import { toTokenInfo } from '../../api/tokenUtils.js';
 import { HeadType } from '../../context.js';
@@ -85,6 +87,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		cancellation?: AbortSignal,
 	): Promise<PagedResult<GitBranch>> {
 		if (repoPath == null) return emptyPagedResult;
+
 		const path = repoPath;
 
 		const scope = getScopedLogger();
@@ -175,12 +178,14 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			}
 		};
 
-		// Bypass cache entirely for paged follow-ups — they're driven by an opaque cursor and
-		// don't represent "all branches".
-		const branchesPromise =
-			options?.paging?.cursor != null
-				? load()
-				: this.cache.branches.getOrCreate(path, cacheable => load(cacheable), cancellation);
+		// Compose cache key with cursor so re-loads of the same page hit the cache;
+		// `repoPath` (no suffix) is reserved for the full "all branches" entry.
+		// TODO: `cache.branches` is `PromiseMap<RepoPath, ...>` keyed exactly by repoPath, so
+		// `clearCaches('branches')` / `unregisterRepoPath` will not invalidate composite-key entries.
+		// Acceptable today because branches don't change during a virtual-repo session, but the entries
+		// leak in memory until provider GC. Long-term: switch to RepoPromiseCacheMap or add prefix-invalidate.
+		const cacheKey = options?.paging?.cursor != null ? `${path}#${options.paging.cursor}` : path;
+		const branchesPromise = this.cache.branches.getOrCreate(cacheKey, cacheable => load(cacheable), cancellation);
 
 		let result = await branchesPromise;
 		if (options?.filter != null) {
@@ -201,33 +206,34 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	async getBranchContributionsOverview(
 		repoPath: string,
 		ref: string,
-		options?: { associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined> },
+		// `priority` is unused — the GitHub provider doesn't go through the local git command
+		// queue, so the priority signal has no effect here. Accepted for interface compatibility.
+		options?: {
+			associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined>;
+			priority?: GitCommandPriority;
+		},
 		_cancellation?: AbortSignal,
 	): Promise<BranchContributionsOverview | undefined> {
 		const scope = getScopedLogger();
 
-		try {
-			let mergeTarget: string | undefined;
-
-			// PR-based lookup (GitHub provider has no stored targets or base branch detection)
-			if (options?.associatedPullRequest != null) {
-				const pr = await options.associatedPullRequest;
-				if (pr?.refs?.base != null) {
-					mergeTarget = pr.refs.base.branch;
-				}
-			}
-
-			mergeTarget ??= await this.getDefaultBranchName(repoPath);
-			if (mergeTarget == null) return undefined;
-
+		// Expensive body — runs only on cache miss. Closes over `mergeTarget` so the cache key
+		// (`${ref}|${mergeTarget}`) fully captures every input that affects the result.
+		const fetchBody = async (mergeTarget: string): Promise<BranchContributionsOverview | undefined> => {
 			const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget);
 			if (mergeBase == null) return undefined;
 
-			const result = await this.provider.contributors.getContributors(
-				repoPath,
-				createRevisionRange(mergeBase, ref, '..'),
-				{ stats: true },
-			);
+			// Fetch the merge-base commit's committer date in parallel with contributors so consumers
+			// that just need the date for the scope window don't pay a separate round-trip.
+			// `allSettled` so a transient failure in one side doesn't drop the overview entirely.
+			const [contributorsSettled, mergeBaseCommitSettled] = await Promise.allSettled([
+				this.provider.contributors.getContributors(repoPath, createRevisionRange(mergeBase, ref, '..'), {
+					stats: true,
+				}),
+				this.provider.commits.getCommit(repoPath, mergeBase),
+			]);
+
+			const result = getSettledValue(contributorsSettled) ?? { contributors: [] };
+			const mergeBaseCommit = getSettledValue(mergeBaseCommitSettled);
 
 			sortContributors(result.contributors, { orderBy: 'score:desc' });
 
@@ -265,6 +271,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				branch: ref,
 				mergeTarget: mergeTarget,
 				mergeBase: mergeBase,
+				mergeBaseDate: mergeBaseCommit?.committer?.date ?? mergeBaseCommit?.author?.date,
 
 				commits: totalCommits,
 				files: totalFiles,
@@ -276,6 +283,31 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 
 				contributors: result.contributors,
 			};
+		};
+
+		try {
+			// Resolve `mergeTarget` (PR base or default branch). Only the expensive body below is
+			// cached — keyed on `${ref}|${mergeTarget}` so callers that resolve to the same target
+			// share the result, while differing targets get independent slots.
+			let mergeTarget: string | undefined;
+
+			if (options?.associatedPullRequest != null) {
+				const pr = await options.associatedPullRequest;
+				if (pr?.refs?.base != null) {
+					mergeTarget = pr.refs.base.branch;
+				}
+			}
+
+			mergeTarget ??= await this.getDefaultBranchName(repoPath);
+			if (mergeTarget == null) return undefined;
+
+			// Safe to cache despite PR retargeting: the cache key includes the resolved `mergeTarget`,
+			// so a retargeted PR resolves to a fresh slot and the old entry is stale-but-unused (and
+			// TTL-evicts). The prior "no outer cache here" rationale assumed a `ref`-only key.
+			const resolvedTarget = mergeTarget;
+			return await this.cache.getBranchOverview(repoPath, `${ref}|${resolvedTarget}`, () =>
+				fetchBody(resolvedTarget),
+			);
 		} catch (ex) {
 			scope?.error(ex);
 			return undefined;
@@ -333,20 +365,30 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	@debug()
 	async getDefaultBranchName(
 		repoPath: string | undefined,
-		_remote?: string,
+		remote?: string,
+		// `priority` is unused — the GitHub provider doesn't go through the local git command
+		// queue, so the priority signal has no effect here. Accepted for interface compatibility.
+		_options?: { priority?: GitCommandPriority },
 		_cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		if (repoPath == null) return undefined;
 
+		remote ??= 'origin';
+
 		const scope = getScopedLogger();
 
+		// Throw inside the factory so RepoPromiseCacheMap's default `expireOnError` evicts the
+		// entry — a transient API failure shouldn't poison the cache for the rest of the session.
+		// The outer try/catch preserves the existing `undefined`-on-error contract for callers.
 		try {
-			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
-			return await github.getDefaultBranchName(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-			);
+			return await this.cache.getDefaultBranchName(repoPath, remote, async () => {
+				const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+				return github.getDefaultBranchName(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+				);
+			});
 		} catch (ex) {
 			scope?.error(ex);
 			debugger;

package/src/plus/git-github/providers/github/commits.ts

@@ -41,94 +41,103 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 	) {}
 
 	@debug()
-	async getCommit(repoPath: string, rev: string, _cancellation?: AbortSignal): Promise<GitCommit | undefined> {
-		if (repoPath == null) return undefined;
-
-		const scope = getScopedLogger();
+	getCommit(repoPath: string, rev: string, _cancellation?: AbortSignal): Promise<GitCommit | undefined> {
+		if (repoPath == null) return Promise.resolve(undefined);
 
-		try {
-			if (isUncommitted(rev, true)) {
+		// Don't cache uncommitted-changes synthesis — it's date-sensitive
+		if (isUncommitted(rev, true)) {
+			return (async () => {
 				return createUncommittedChangesCommit(
 					repoPath,
 					rev,
 					new Date(),
 					await this.provider.config.getCurrentUser(repoPath),
 				);
-			}
+			})();
+		}
 
-			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+		// TODO: resolve symbolic refs (HEAD, branch names) to SHA before caching to avoid
+		// short staleness windows. For now we cascade-clear on 'branch'/'branches'.
+		return this.cache.commit.getOrCreate(repoPath, stripOrigin(rev), async () => {
+			const scope = getScopedLogger();
 
-			const commit = await github.getCommit(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				stripOrigin(rev),
-			);
-			if (commit == null) return undefined;
+			try {
+				const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
 
-			const repoUri = coerceUri(repoPath);
+				const commit = await github.getCommit(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+					stripOrigin(rev),
+				);
+				if (commit == null) return undefined;
 
-			const { viewer = session.account.label } = commit;
-
-			return new GitCommit(
-				repoPath,
-				commit.oid,
-				new GitCommitIdentity(
-					commit.author.name,
-					commit.author.email,
-					new Date(commit.author.date),
-					commit.author.avatarUrl,
-					isViewer(commit.author.name, viewer),
-				),
-				new GitCommitIdentity(
-					commit.committer.name,
-					commit.committer.email,
-					new Date(commit.committer.date),
-					undefined,
-					isViewer(commit.committer.name, viewer),
-				),
-				commit.message.split('\n', 1)[0],
-				commit.parents.nodes.map(p => p.oid),
-				commit.message,
-				{
-					files: commit.files?.map(f => toFileChange(repoUri, repoPath, f)),
-				},
-				{
-					files: commit.changedFiles ?? 0,
-					additions: commit.additions ?? 0,
-					deletions: commit.deletions ?? 0,
-				},
-				[],
-			);
-		} catch (ex) {
-			scope?.error(ex);
-			debugger;
-			return undefined;
-		}
+				const repoUri = coerceUri(repoPath);
+
+				const { viewer = session.account.label } = commit;
+
+				return new GitCommit(
+					repoPath,
+					commit.oid,
+					new GitCommitIdentity(
+						commit.author.name,
+						commit.author.email,
+						new Date(commit.author.date),
+						commit.author.avatarUrl,
+						isViewer(commit.author.name, viewer),
+					),
+					new GitCommitIdentity(
+						commit.committer.name,
+						commit.committer.email,
+						new Date(commit.committer.date),
+						undefined,
+						isViewer(commit.committer.name, viewer),
+					),
+					commit.message.split('\n', 1)[0],
+					commit.parents.nodes.map(p => p.oid),
+					commit.message,
+					{
+						files: commit.files?.map(f => toFileChange(repoUri, repoPath, f)),
+					},
+					{
+						files: commit.changedFiles ?? 0,
+						additions: commit.additions ?? 0,
+						deletions: commit.deletions ?? 0,
+					},
+					[],
+				);
+			} catch (ex) {
+				scope?.error(ex);
+				debugger;
+				return undefined;
+			}
+		});
 	}
 
 	@debug()
-	async getCommitCount(repoPath: string, rev: string, _cancellation?: AbortSignal): Promise<number | undefined> {
-		if (repoPath == null) return undefined;
+	getCommitCount(repoPath: string, rev: string, _cancellation?: AbortSignal): Promise<number | undefined> {
+		if (repoPath == null) return Promise.resolve(undefined);
 
-		const scope = getScopedLogger();
+		return this.cache.commitCount.getOrCreate(repoPath, stripOrigin(rev), async () => {
+			const scope = getScopedLogger();
 
-		try {
-			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+			try {
+				const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
 
-			const count = await github.getCommitCount(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				stripOrigin(rev),
-			);
+				const count = await github.getCommitCount(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+					stripOrigin(rev),
+				);
 
-			return count;
-		} catch (ex) {
-			scope?.error(ex);
-			debugger;
-			return undefined;
-		}
+				return count;
+			} catch (ex) {
+				scope?.error(ex);
+				debugger;
+				return undefined;
+			}
+		});
 	}
 
 	@debug()
@@ -149,102 +158,111 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 	): Promise<GitCommit | undefined> {
 		if (repoPath == null) return undefined;
 
-		const scope = getScopedLogger();
-
-		try {
-			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+		const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
 
-			const rootUri = this.provider.getProviderRootUri(this.provider.getAbsoluteUri(pathOrUri, repoPath));
-			const file = this.provider.getRelativePath(this.provider.getAbsoluteUri(pathOrUri, repoPath), rootUri);
+		const rootUri = this.provider.getProviderRootUri(this.provider.getAbsoluteUri(pathOrUri, repoPath));
+		const file = this.provider.getRelativePath(this.provider.getAbsoluteUri(pathOrUri, repoPath), rootUri);
+
+		// Resolve HEAD/empty rev to the metadata revision so the cache key is stable across callers
+		const resolvedRev = !rev || rev === 'HEAD' ? (await metadata.getRevision()).revision : rev;
+		// Path-scoped variant lives in the same slot as `getCommit` but with a `|file` suffix to
+		// keep it distinct from the unscoped commit entry.
+		const cacheKey = `${stripOrigin(resolvedRev)}|${file}`;
+
+		return this.cache.commit.getOrCreate(repoPath, cacheKey, async () => {
+			const scope = getScopedLogger();
+
+			try {
+				const commit = await github.getCommitForFile(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+					stripOrigin(resolvedRev),
+					file,
+				);
+				if (commit == null) return undefined;
 
-			rev = !rev || rev === 'HEAD' ? (await metadata.getRevision()).revision : rev;
-			const commit = await github.getCommitForFile(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				stripOrigin(rev),
-				file,
-			);
-			if (commit == null) return undefined;
+				const repoUri = coerceUri(repoPath);
+				const { viewer = session.account.label } = commit;
 
-			const repoUri = coerceUri(repoPath);
-			const { viewer = session.account.label } = commit;
-
-			return new GitCommit(
-				repoPath,
-				commit.oid,
-				new GitCommitIdentity(
-					commit.author.name,
-					commit.author.email,
-					new Date(commit.author.date),
-					commit.author.avatarUrl,
-					isViewer(commit.author.name, viewer),
-				),
-				new GitCommitIdentity(
-					commit.committer.name,
-					commit.committer.email,
-					new Date(commit.committer.date),
-					undefined,
-					isViewer(commit.committer.name, viewer),
-				),
-				commit.message.split('\n', 1)[0],
-				commit.parents.nodes.map(p => p.oid),
-				commit.message,
-				commit.files != null
-					? {
-							files: undefined,
-							filtered: {
-								files: commit.files?.map(f => toFileChange(repoUri, repoPath, f)),
-								pathspec: file,
-							},
-						}
-					: undefined,
-				{
-					files: commit.changedFiles ?? 0,
-					additions: commit.additions ?? 0,
-					deletions: commit.deletions ?? 0,
-				},
-				[],
-			);
-		} catch (ex) {
-			scope?.error(ex);
-			debugger;
-			return undefined;
-		}
+				return new GitCommit(
+					repoPath,
+					commit.oid,
+					new GitCommitIdentity(
+						commit.author.name,
+						commit.author.email,
+						new Date(commit.author.date),
+						commit.author.avatarUrl,
+						isViewer(commit.author.name, viewer),
+					),
+					new GitCommitIdentity(
+						commit.committer.name,
+						commit.committer.email,
+						new Date(commit.committer.date),
+						undefined,
+						isViewer(commit.committer.name, viewer),
+					),
+					commit.message.split('\n', 1)[0],
+					commit.parents.nodes.map(p => p.oid),
+					commit.message,
+					commit.files != null
+						? {
+								files: undefined,
+								filtered: {
+									files: commit.files?.map(f => toFileChange(repoUri, repoPath, f)),
+									pathspec: file,
+								},
+							}
+						: undefined,
+					{
+						files: commit.changedFiles ?? 0,
+						additions: commit.additions ?? 0,
+						deletions: commit.deletions ?? 0,
+					},
+					[],
+				);
+			} catch (ex) {
+				scope?.error(ex);
+				debugger;
+				return undefined;
+			}
+		});
 	}
 
 	@debug()
-	async getLeftRightCommitCount(
+	getLeftRightCommitCount(
 		repoPath: string,
 		range: GitRevisionRange,
 		_options?: { authors?: GitUser[]; excludeMerges?: boolean },
 		_cancellation?: AbortSignal,
 	): Promise<LeftRightCommitCountResult | undefined> {
-		if (repoPath == null) return undefined;
+		if (repoPath == null) return Promise.resolve(undefined);
 
-		const scope = getScopedLogger();
+		return this.cache.leftRightCommitCount.getOrCreate(repoPath, stripOrigin(range), async () => {
+			const scope = getScopedLogger();
 
-		const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
 
-		try {
-			const result = await github.getComparison(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				stripOrigin(range),
-			);
+			try {
+				const result = await github.getComparison(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+					stripOrigin(range),
+				);
 
-			if (result == null) return undefined;
+				if (result == null) return undefined;
 
-			return {
-				left: result.behind_by,
-				right: result.ahead_by,
-			};
-		} catch (ex) {
-			scope?.error(ex);
-			debugger;
-			return undefined;
-		}
+				return {
+					left: result.behind_by,
+					right: result.ahead_by,
+				};
+			} catch (ex) {
+				scope?.error(ex);
+				debugger;
+				return undefined;
+			}
+		});
 	}
 
 	@debug()
@@ -445,6 +463,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 
 		const context = await this.provider.ensureRepositoryContext(repoPath);
 		if (context == null) return undefined;
+
 		const { metadata, github, session } = context;
 
 		const uri = this.provider.getAbsoluteUri(path, repoPath);
@@ -601,19 +620,71 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		options?: GitLogShasOptions,
 		cancellation?: AbortSignal,
 	): Promise<Iterable<string>> {
-		// TODO@eamodio optimize this
+		if (repoPath == null) return [];
 
-		let log: GitLog | undefined;
-		if (options?.pathOrUri != null) {
-			log = await this.getLogForPath(repoPath, options.pathOrUri, rev, options, cancellation);
-		} else {
-			log = await this.getLog(repoPath, rev, options, cancellation);
+		const scope = getScopedLogger();
+
+		// `authors` and `all` filters aren't supported by the lightweight SHA-only query;
+		// fall back to the full log path when set.
+		if (options?.authors?.length || options?.all) {
+			let log: GitLog | undefined;
+			if (options?.pathOrUri != null) {
+				log = await this.getLogForPath(repoPath, options.pathOrUri, rev, options, cancellation);
+			} else {
+				log = await this.getLog(repoPath, rev, options, cancellation);
+			}
+			if (log == null) return [];
+
+			const shas = map(log.commits.values(), c => c.ref);
+			// Note: reversal only applies to the first page — subsequent pages loaded via pagination are not reversed
+			return options?.reverse ? [...shas].reverse() : shas;
 		}
-		if (log == null) return [];
 
-		const shas = map(log.commits.values(), c => c.ref);
-		// Note: reversal only applies to the first page — subsequent pages loaded via pagination are not reversed
-		return options?.reverse ? [...shas].reverse() : shas;
+		const limit = this.provider.getPagingLimit(options?.limit);
+
+		try {
+			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+
+			rev = !rev || rev === 'HEAD' ? (await metadata.getRevision()).revision : rev;
+
+			let path: string | undefined;
+			if (options?.pathOrUri != null) {
+				const rootUri = this.provider.getProviderRootUri(
+					this.provider.getAbsoluteUri(options.pathOrUri, repoPath),
+				);
+				path = this.provider.getRelativePath(
+					this.provider.getAbsoluteUri(options.pathOrUri, repoPath),
+					rootUri,
+				);
+			}
+
+			const strippedRev = stripOrigin(rev);
+			const sinceISO = options?.since ? new Date(options.since).toISOString() : '';
+			const cacheKey = `${strippedRev}|${path ?? ''}|${sinceISO}|${limit}|${options?.cursor ?? ''}`;
+
+			const shas = await this.cache.logShas.getOrCreate(repoPath, cacheKey, async () => {
+				const result = await github.getCommitShas(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+					strippedRev,
+					{
+						after: options?.cursor,
+						limit: limit,
+						path: path,
+						since: options?.since ? new Date(options.since) : undefined,
+					},
+				);
+				return result.values;
+			});
+
+			// Note: reversal only applies to the first page — subsequent pages loaded via pagination are not reversed
+			return options?.reverse ? shas.toReversed() : shas;
+		} catch (ex) {
+			scope?.error(ex);
+			debugger;
+			return [];
+		}
 	}
 
 	@debug()