@gitkraken/core-gitlens 0.5.116 → 0.7.0

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

@@ -1,225 +0,0 @@
-import type { Cache } from '../../../../git/cache.js';
-import { shouldEvictBlameCacheEntry } from '../../../../git/cache.js';
-import type { GitBlame, GitBlameAuthor, ProgressiveGitBlame } from '../../../../git/models/blame.js';
-import type { GitCommitLine } from '../../../../git/models/commit.js';
-import { GitCommit, GitCommitIdentity } from '../../../../git/models/commit.js';
-import { GitFileChange } from '../../../../git/models/fileChange.js';
-import { GitFileIndexStatus } from '../../../../git/models/fileStatus.js';
-import type { GitBlameSubProvider } from '../../../../git/providers/blame.js';
-import type { DiffRange } from '../../../../git/providers/types.js';
-import { getBlameRange } from '../../../../git/utils/blame.utils.js';
-import { debug } from '../../../../utils/decorators/log.js';
-import { createDisposable } from '../../../../utils/disposable.js';
-import { Logger } from '../../../../utils/logger.js';
-import { normalizePath } from '../../../../utils/path.js';
-import { joinUriPath } from '../../../../utils/uri.js';
-import { toTokenInfo } from '../../api/tokenUtils.js';
-import type { GitHubGitProviderInternal } from '../githubProvider.js';
-
-function isViewer(name: string, viewer: string | undefined): boolean | undefined {
-	return (viewer != null && name === viewer) || undefined;
-}
-
-export class BlameGitHubSubProvider implements GitBlameSubProvider {
-	constructor(
-		private readonly cache: Cache,
-		private readonly provider: GitHubGitProviderInternal,
-	) {}
-
-	@debug()
-	async getBlame(
-		repoPath: string,
-		path: string,
-		rev?: string,
-		contents?: string,
-		_options?: { args?: string[] | null; ignoreWhitespace?: boolean },
-	): Promise<GitBlame | undefined> {
-		// GitHub doesn't support contents-based blame
-		if (contents != null) return undefined;
-
-		if (await this.provider.context.hasUncommittedChanges?.(repoPath, path)) return undefined;
-
-		const cacheKey = `${normalizePath(path)}:${rev ?? ''}`;
-		const progressive = await this.cache.blame.getOrCreate(
-			repoPath,
-			cacheKey,
-			async () => {
-				const blame = await this.getBlameCore(repoPath, path, rev);
-				if (blame == null) return undefined;
-
-				return createCompletedBlame(blame);
-			},
-			{ errorTTL: 1000 * 60, evictWhen: shouldEvictBlameCacheEntry },
-		);
-		return progressive?.completed;
-	}
-
-	@debug()
-	async getBlameForLine(
-		repoPath: string,
-		path: string,
-		editorLine: number,
-		rev?: string,
-		contents?: string,
-		options?: { forceSingleLine?: boolean } & { args?: string[] | null; ignoreWhitespace?: boolean },
-	): Promise<{ author: GitBlameAuthor & { lineCount: number }; commit: GitCommit; line: GitCommitLine } | undefined> {
-		// GitHub doesn't support contents-based blame
-		if (contents != null) return undefined;
-
-		if (await this.provider.context.hasUncommittedChanges?.(repoPath, path)) return undefined;
-
-		const blame = await this.getBlame(repoPath, path, rev, contents, options);
-		if (blame == null) return undefined;
-
-		let blameLine = blame.lines[editorLine];
-		if (blameLine == null) {
-			if (blame.lines.length !== editorLine) return undefined;
-
-			blameLine = blame.lines[editorLine - 1];
-		}
-
-		const commit = blame.commits.get(blameLine.sha);
-		if (commit == null) return undefined;
-
-		const author = blame.authors.get(commit.author.name)!;
-		return {
-			author: { ...author, lineCount: commit.lines.length },
-			commit: commit,
-			line: blameLine,
-		};
-	}
-
-	@debug()
-	async getBlameForRange(
-		repoPath: string,
-		path: string,
-		range: DiffRange,
-		rev?: string,
-		contents?: string,
-		options?: { args?: string[] | null; ignoreWhitespace?: boolean },
-	): Promise<GitBlame | undefined> {
-		const blame = await this.getBlame(repoPath, path, rev, contents, options);
-		if (blame == null) return undefined;
-
-		return getBlameRange(blame, range);
-	}
-
-	private async getBlameCore(repoPath: string, path: string, rev: string | undefined): Promise<GitBlame | undefined> {
-		try {
-			const context = await this.provider.ensureRepositoryContext(repoPath);
-			if (context == null) return undefined;
-
-			const { metadata, github, session } = context;
-
-			const root = this.provider.createVirtualUri(repoPath, undefined);
-
-			const resolvedRef = !rev || rev === 'HEAD' ? (await metadata.getRevision()).revision : rev;
-			const blame = await github.getBlame(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				resolvedRef,
-				path,
-			);
-
-			const authors = new Map<string, GitBlameAuthor>();
-			const commits = new Map<string, GitCommit>();
-			const lines: GitCommitLine[] = [];
-
-			for (const range of blame.ranges) {
-				const c = range.commit;
-
-				const { viewer = session.account.label } = blame;
-
-				let author = authors.get(c.author.name);
-				if (author == null) {
-					author = { name: c.author.name, lineCount: 0, current: isViewer(c.author.name, viewer) };
-					authors.set(c.author.name, author);
-				}
-
-				author.lineCount += range.endingLine - range.startingLine + 1;
-
-				let commit = commits.get(c.oid);
-				if (commit == null) {
-					commit = new GitCommit(
-						repoPath,
-						c.oid,
-						new GitCommitIdentity(
-							c.author.name,
-							c.author.email,
-							new Date(c.author.date),
-							c.author.avatarUrl,
-							isViewer(c.author.name, viewer),
-						),
-						new GitCommitIdentity(
-							c.committer.name,
-							c.committer.email,
-							new Date(c.committer.date),
-							undefined,
-							isViewer(c.committer.name, viewer),
-						),
-						c.message.split('\n', 1)[0],
-						c.parents.nodes[0]?.oid ? [c.parents.nodes[0]?.oid] : [],
-						c.message,
-						{
-							files: undefined,
-							filtered: {
-								files: [
-									new GitFileChange(
-										root.toString(),
-										path,
-										GitFileIndexStatus.Modified,
-										joinUriPath(root, path),
-									),
-								],
-								pathspec: path,
-							},
-						},
-						{
-							files: c.changedFiles ?? 0,
-							additions: c.additions ?? 0,
-							deletions: c.deletions ?? 0,
-						},
-						[],
-					);
-
-					commits.set(c.oid, commit);
-				}
-
-				for (let i = range.startingLine; i <= range.endingLine; i++) {
-					const line: GitCommitLine = { sha: c.oid, originalLine: i, line: i };
-					commit.lines.push(line);
-					lines[i - 1] = line;
-				}
-			}
-
-			const sortedAuthors = new Map([...authors.entries()].sort((a, b) => b[1].lineCount - a[1].lineCount));
-
-			return {
-				repoPath: repoPath,
-				authors: sortedAuthors,
-				commits: commits,
-				lines: lines,
-			};
-		} catch (ex) {
-			debugger;
-			if (!String(ex).includes('No provider registered with')) {
-				Logger.error(ex);
-			}
-			return undefined;
-		}
-	}
-}
-
-/** Creates an already-completed progressive blame. Used when the provider doesn't support streaming. */
-function createCompletedBlame(blame: GitBlame): ProgressiveGitBlame {
-	const noop = createDisposable(() => {});
-	return {
-		current: blame,
-		isComplete: true,
-		completed: Promise.resolve(blame),
-		onDidProgress: function () {
-			return noop;
-		},
-	};
-}

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

@@ -1,401 +0,0 @@
-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';
-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';
-import type { GitHubBranch } from '../../models.js';
-import type { GitHubGitProviderInternal } from '../githubProvider.js';
-
-export class BranchesGitSubProvider implements GitBranchesSubProvider {
-	constructor(
-		private readonly cache: Cache,
-		private readonly provider: GitHubGitProviderInternal,
-	) {}
-
-	@debug()
-	async getBranch(repoPath: string, name?: string, cancellation?: AbortSignal): Promise<GitBranch | undefined> {
-		const scope = getScopedLogger();
-
-		if (name != null) {
-			const {
-				values: [branch],
-			} = await this.getBranches(repoPath, { filter: b => b.name === name }, cancellation);
-			return branch;
-		}
-
-		return this.cache.branch.getOrCreate(
-			repoPath,
-			async (_cacheable, signal): Promise<GitBranch | undefined> => {
-				// Prefer the cache-provided aggregate signal (only fires when every joined
-				// caller aborts); fall back to this caller's cancellation for the first-caller path.
-				signal ??= cancellation;
-				const {
-					values: [branch],
-				} = await this.getBranches(repoPath, { filter: b => b.current }, signal);
-				if (branch != null) return branch;
-
-				try {
-					const { metadata } = await this.provider.ensureRepositoryContext(repoPath);
-
-					const revision = await metadata.getRevision();
-					switch (revision.type) {
-						case HeadType.Tag:
-						case HeadType.Commit:
-							return new GitBranch(
-								repoPath,
-								`refs/heads/${revision.name}`,
-								true,
-								undefined,
-								undefined,
-								revision.revision,
-								undefined,
-								false,
-								true,
-							);
-					}
-
-					return undefined;
-				} catch (ex) {
-					debugger;
-					scope?.error(ex);
-					return undefined;
-				}
-			},
-			cancellation,
-		);
-	}
-
-	@debug({ args: repoPath => ({ repoPath: repoPath }) })
-	async getBranches(
-		repoPath: string | undefined,
-		options?: {
-			filter?: (b: GitBranch) => boolean;
-			ordering?: 'date' | 'author-date' | 'topo' | null;
-			paging?: PagingOptions;
-			sort?: boolean | BranchSortOptions;
-		},
-		cancellation?: AbortSignal,
-	): Promise<PagedResult<GitBranch>> {
-		if (repoPath == null) return emptyPagedResult;
-
-		const path = repoPath;
-
-		const scope = getScopedLogger();
-
-		const load = async (cacheable?: CacheController): Promise<PagedResult<GitBranch>> => {
-			try {
-				const { metadata, github, session } = await this.provider.ensureRepositoryContext(path);
-
-				const branches: GitBranch[] = [];
-
-				const commitOrdering = options?.ordering;
-
-				function addBranches(branch: GitHubBranch, current: boolean) {
-					const date = new Date(
-						commitOrdering === 'author-date' ? branch.target.authoredDate : branch.target.committedDate,
-					);
-					const ref = branch.target.oid;
-
-					branches.push(
-						new GitBranch(
-							path,
-							`refs/heads/${branch.name}`,
-							current,
-							date,
-							undefined,
-							ref,
-							{
-								name: `origin/${branch.name}`,
-								missing: false,
-								state: { ahead: 0, behind: 0 },
-							},
-							false,
-						),
-						new GitBranch(
-							path,
-							`refs/remotes/origin/${branch.name}`,
-							false,
-							date,
-							undefined,
-							ref,
-							undefined,
-							false,
-						),
-					);
-				}
-
-				let currentBranch: string | undefined;
-
-				const revision = await metadata.getRevision();
-				switch (revision.type) {
-					case HeadType.Branch:
-						currentBranch = revision.name;
-						break;
-					case HeadType.RemoteBranch: {
-						const index = revision.name.indexOf(':');
-						currentBranch = index === -1 ? revision.name : revision.name.substring(index + 1);
-						break;
-					}
-				}
-
-				let cursor = options?.paging?.cursor;
-				const loadAll = cursor == null;
-
-				while (true) {
-					const result = await github.getBranches(
-						toTokenInfo(this.provider.authenticationProviderId, session),
-						metadata.repo.owner,
-						metadata.repo.name,
-						{ cursor: cursor },
-					);
-
-					for (const branch of result.values) {
-						addBranches(branch, branch.name === currentBranch);
-					}
-
-					if (!result.paging?.more || !loadAll) return { ...result, values: branches };
-
-					cursor = result.paging.cursor;
-				}
-			} catch (ex) {
-				scope?.error(ex);
-				debugger;
-
-				// Mark the cache entry invalidated so the empty fallback self-evicts on settle
-				// rather than getting stuck serving stale emptiness to subsequent callers.
-				cacheable?.invalidate();
-				return emptyPagedResult;
-			}
-		};
-
-		// 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) {
-			result = {
-				...result,
-				values: result.values.filter(options.filter),
-			};
-		}
-
-		if (options?.sort != null) {
-			sortBranches(result.values, typeof options.sort === 'boolean' ? undefined : options.sort);
-		}
-
-		return result;
-	}
-
-	@debug()
-	async getBranchContributionsOverview(
-		repoPath: string,
-		ref: 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?: {
-			associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined>;
-			priority?: GitCommandPriority;
-		},
-		_cancellation?: AbortSignal,
-	): Promise<BranchContributionsOverview | undefined> {
-		const scope = getScopedLogger();
-
-		// 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;
-
-			// 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' });
-
-			let totalCommits = 0;
-			let totalFiles = 0;
-			let totalAdditions = 0;
-			let totalDeletions = 0;
-			let firstCommitTimestamp;
-			let latestCommitTimestamp;
-
-			for (const c of result.contributors) {
-				totalCommits += c.contributionCount;
-				totalFiles += c.stats?.files ?? 0;
-				totalAdditions += c.stats?.additions ?? 0;
-				totalDeletions += c.stats?.deletions ?? 0;
-
-				const firstTimestamp = c.firstCommitDate?.getTime();
-				const latestTimestamp = c.latestCommitDate?.getTime();
-
-				if (firstTimestamp != null || latestTimestamp != null) {
-					firstCommitTimestamp =
-						firstCommitTimestamp != null
-							? Math.min(firstCommitTimestamp, firstTimestamp ?? Infinity, latestTimestamp ?? Infinity)
-							: (firstTimestamp ?? latestTimestamp);
-
-					latestCommitTimestamp =
-						latestCommitTimestamp != null
-							? Math.max(latestCommitTimestamp, firstTimestamp ?? -Infinity, latestTimestamp ?? -Infinity)
-							: (latestTimestamp ?? firstTimestamp);
-				}
-			}
-
-			return {
-				repoPath: repoPath,
-				branch: ref,
-				mergeTarget: mergeTarget,
-				mergeBase: mergeBase,
-				mergeBaseDate: mergeBaseCommit?.committer?.date ?? mergeBaseCommit?.author?.date,
-
-				commits: totalCommits,
-				files: totalFiles,
-				additions: totalAdditions,
-				deletions: totalDeletions,
-
-				latestCommitDate: latestCommitTimestamp != null ? new Date(latestCommitTimestamp) : undefined,
-				firstCommitDate: firstCommitTimestamp != null ? new Date(firstCommitTimestamp) : undefined,
-
-				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;
-		}
-	}
-
-	@debug()
-	async getBranchesWithCommits(
-		repoPath: string,
-		shas: string[],
-		branch?: string | undefined,
-		options?:
-			| { all?: boolean; commitDate?: Date; mode?: 'contains' | 'pointsAt' }
-			| { commitDate?: Date; mode?: 'contains' | 'pointsAt'; remotes?: boolean },
-		_cancellation?: AbortSignal,
-	): Promise<string[]> {
-		if (repoPath == null || options?.commitDate == null) return [];
-
-		const scope = getScopedLogger();
-
-		try {
-			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
-
-			let branches;
-
-			if (branch) {
-				branches = await github.getBranchWithCommit(
-					toTokenInfo(this.provider.authenticationProviderId, session),
-					metadata.repo.owner,
-					metadata.repo.name,
-					branch,
-					shas.map(stripOrigin),
-					options?.mode ?? 'contains',
-					options?.commitDate,
-				);
-			} else {
-				branches = await github.getBranchesWithCommits(
-					toTokenInfo(this.provider.authenticationProviderId, session),
-					metadata.repo.owner,
-					metadata.repo.name,
-					shas.map(stripOrigin),
-					options?.mode ?? 'contains',
-					options?.commitDate,
-				);
-			}
-
-			return branches;
-		} catch (ex) {
-			scope?.error(ex);
-			debugger;
-			return [];
-		}
-	}
-
-	@debug()
-	async getDefaultBranchName(
-		repoPath: string | undefined,
-		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. `local` asks for a network-free resolution (the graph's hot
-		// path): a remote repo has no local symref to read, so honor that contract by returning undefined
-		// rather than making the API round-trip the caller explicitly asked to avoid.
-		options?: { priority?: GitCommandPriority; local?: boolean },
-		_cancellation?: AbortSignal,
-	): Promise<string | undefined> {
-		if (repoPath == null) return undefined;
-		if (options?.local) 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 {
-			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;
-			return undefined;
-		}
-	}
-}