@gitkraken/core-gitlens 0.1.0

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

@@ -0,0 +1,222 @@
+import type { Cache } 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 },
+		);
+		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

@@ -0,0 +1,356 @@
+import type { Cache } from '../../../../git/cache.js';
+import { GitBranch } from '../../../../git/models/branch.js';
+import type { BranchContributionsOverview, GitBranchesSubProvider } from '../../../../git/providers/branches.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 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;
+			}
+		};
+
+		// 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);
+
+		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,
+		options?: { associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined> },
+		_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;
+
+			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 },
+			);
+
+			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,
+
+				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,
+			};
+		} 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,
+		_cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		if (repoPath == null) return undefined;
+
+		const scope = getScopedLogger();
+
+		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,
+			);
+		} catch (ex) {
+			scope?.error(ex);
+			debugger;
+			return undefined;
+		}
+	}
+}