@gitkraken/core-gitlens 0.2.0 → 0.3.0

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()

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

@@ -22,6 +22,7 @@ import { encodeGitLensRevisionUriAuthority } from '../../../../git/utils/uriAuth
 import { debug } from '../../../../utils/decorators/log.js';
 import { union } from '../../../../utils/iterable.js';
 import { getScopedLogger } from '../../../../utils/logger.scoped.js';
+import { getSettledValue } from '../../../../utils/promise.js';
 import type { Uri } from '../../../../utils/uri.js';
 import { fromUri } from '../../../../utils/uri.js';
 import { toTokenInfo } from '../../api/tokenUtils.js';
@@ -58,12 +59,18 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 	async getChangedFilesCount(
 		repoPath: string,
 		to?: string,
-		_from?: string,
+		from?: string,
 		_options?: { uris?: (string | Uri)[]; includeUntracked?: boolean },
 		_cancellation?: AbortSignal,
 	): Promise<GitDiffShortStat | undefined> {
-		// TODO@eamodio if there is no ref we can't return anything, until we can get at the change store from RemoteHub
-		if (!to) return undefined;
+		// Virtual GitHub repos have no working tree, so no working changes can exist.
+		// Without any refs, return empty stats rather than undefined to avoid "uncertain state" callers.
+		if (!to && !from) return { additions: 0, deletions: 0, files: 0 };
+
+		// If only `from` is provided, compare against HEAD
+		if (!to) {
+			to = 'HEAD';
+		}
 
 		const commit = await this.provider.commits.getCommit(repoPath, to);
 		if (commit?.stats == null) return undefined;
@@ -115,27 +122,28 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		}
 
 		try {
-			let result = await github.getComparison(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				stripOrigin(range),
-			);
-
-			const files1 = result?.files;
+			const token = toTokenInfo(this.provider.authenticationProviderId, session);
 
-			let files = files1;
+			let files;
 			if (range2) {
-				result = await github.getComparison(
-					toTokenInfo(this.provider.authenticationProviderId, session),
-					metadata.repo.owner,
-					metadata.repo.name,
-					stripOrigin(range2),
-				);
+				// GitHub doesn't support `..`, so issue both `...` comparisons in parallel and union the results.
+				const [result1, result2] = await Promise.allSettled([
+					github.getComparison(token, metadata.repo.owner, metadata.repo.name, stripOrigin(range)),
+					github.getComparison(token, metadata.repo.owner, metadata.repo.name, stripOrigin(range2)),
+				]);
 
-				const files2 = result?.files;
+				const files1 = getSettledValue(result1)?.files;
+				const files2 = getSettledValue(result2)?.files;
 
 				files = [...new Set(union(files1, files2))];
+			} else {
+				const result = await github.getComparison(
+					token,
+					metadata.repo.owner,
+					metadata.repo.name,
+					stripOrigin(range),
+				);
+				files = result?.files;
 			}
 
 			return files?.map(f => ({

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

@@ -1,9 +1,10 @@
 import type { Cache } from '../../../../git/cache.js';
 import type { GitBranch } from '../../../../git/models/branch.js';
-import type { GitReference } from '../../../../git/models/reference.js';
+import type { GitReference, GitRefTip } from '../../../../git/models/reference.js';
 import { deletedOrMissing } from '../../../../git/models/revision.js';
 import type { GitTag } from '../../../../git/models/tag.js';
 import type { GitRefsSubProvider } from '../../../../git/providers/refs.js';
+import type { GitCommandPriority } from '../../../../git/run.types.js';
 import { createReference } from '../../../../git/utils/reference.utils.js';
 import {
 	createRevisionRange,
@@ -31,32 +32,42 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	}
 
 	@debug()
-	async getMergeBase(
+	getMergeBase(
 		repoPath: string,
 		ref1: string,
 		ref2: string,
-		_options?: { forkPoint?: boolean },
+		_options?: { forkPoint?: boolean; priority?: GitCommandPriority },
 		_cancellation?: AbortSignal,
 	): Promise<string | undefined> {
-		if (repoPath == null) return undefined;
-
-		const scope = getScopedLogger();
-
-		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,
-				createRevisionRange(stripOrigin(ref1), stripOrigin(ref2), '...'),
-			);
-			return result?.merge_base_commit?.sha;
-		} catch (ex) {
-			scope?.error(ex);
-			debugger;
-			return undefined;
-		}
+		if (repoPath == null) return Promise.resolve(undefined);
+
+		const a = stripOrigin(ref1);
+		const b = stripOrigin(ref2);
+		// `merge-base` is symmetric, so normalize ref order in the cache key to coalesce
+		// `(A, B)` and `(B, A)` lookups onto a single entry.
+		const [left, right] = a < b ? [a, b] : [b, a];
+		const cacheKey = `${left}...${right}`;
+		const queryRange = createRevisionRange(a, b, '...');
+
+		return this.cache.mergeBase.getOrCreate(repoPath, cacheKey, async () => {
+			const scope = getScopedLogger();
+
+			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,
+					queryRange,
+				);
+				return result?.merge_base_commit?.sha;
+			} catch (ex) {
+				scope?.error(ex);
+				debugger;
+				return undefined;
+			}
+		});
 	}
 
 	@debug()
@@ -90,6 +101,30 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 		return createReference(ref, repoPath, { refType: 'revision' });
 	}
 
+	@debug()
+	getRefTips(
+		_repoPath: string,
+		_options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		_cancellation?: AbortSignal,
+	): Promise<GitRefTip[]> {
+		// Not implemented for GitHub virtual repos — current consumers (timeline slice-by-branch)
+		// gate this off via `!repo.virtual`. A future implementation can use GraphQL `refs` /
+		// `commit.associatedRefs`.
+		return Promise.resolve([]);
+	}
+
+	@debug()
+	getRefsContainingShas(
+		_repoPath: string,
+		_shas: ReadonlySet<string> | readonly string[],
+		_oldestSha: string,
+		_options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		_cancellation?: AbortSignal,
+	): Promise<Map<string, GitRefTip[]>> {
+		// See `getRefTips` — gated off for virtual repos until GraphQL `commit.associatedRefs` lands.
+		return Promise.resolve(new Map<string, GitRefTip[]>());
+	}
+
 	@debug()
 	async hasBranchOrTag(
 		repoPath: string | undefined,

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

@@ -98,8 +98,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 			});
 		}
 
-		// TODO@eamodio: Implement this
-		return [];
+		return result;
 	}
 
 	@debug()

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

@@ -2,6 +2,7 @@ import type { GitFile } from '../../../../git/models/file.js';
 import type { GitConflictFile } from '../../../../git/models/staging.js';
 import { GitStatus } from '../../../../git/models/status.js';
 import type { GitStatusSubProvider, GitWorkingChangesState } from '../../../../git/providers/status.js';
+import type { GitCommandPriority } from '../../../../git/run.types.js';
 import { gate } from '../../../../utils/decorators/gate.js';
 import { debug } from '../../../../utils/decorators/log.js';
 import { HeadType } from '../../context.js';
@@ -12,7 +13,11 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 
 	@gate()
 	@debug()
-	async getStatus(repoPath: string | undefined, _cancellation?: AbortSignal): Promise<GitStatus | undefined> {
+	async getStatus(
+		repoPath: string | undefined,
+		_options?: { priority?: GitCommandPriority },
+		_cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined> {
 		if (repoPath == null) return undefined;
 
 		const context = await this.provider.ensureRepositoryContext(repoPath);