@gitkraken/core-gitlens 0.4.0 → 0.4.100

package/src/git-cli/providers/branches.ts

@@ -693,7 +693,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							'--',
 						);
 
-						if (result.cancelled || signal?.aborted) {
+						if (result.completion.status === 'cancelled' || signal?.aborted) {
 							throw new CancellationError();
 						}
 
@@ -727,7 +727,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	async getDefaultBranchName(
 		repoPath: string | undefined,
 		remote?: string,
-		options?: { priority?: GitCommandPriority },
+		options?: { priority?: GitCommandPriority; local?: boolean },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		if (repoPath == null) return undefined;
@@ -736,6 +736,25 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		const priority = options?.priority;
 		const priorityOpts = priority != null ? { priority: priority } : undefined;
 
+		// Local-only: read just the existing local symref, never contacting the remote. Bypass the shared
+		// cache entirely — it's keyed by repoPath+remote, so caching a local miss (or sharing this in-flight
+		// promise) would starve a concurrent networked caller of the real default branch. The local read is
+		// a cheap ref lookup, fine to repeat per call.
+		if (options?.local) {
+			try {
+				const result = await this.git.run(
+					{ cwd: this.cache.getCommonPath(repoPath), cancellation: cancellation, ...priorityOpts },
+					'symbolic-ref',
+					'--short',
+					`refs/remotes/${remote}/HEAD`,
+				);
+				return result.stdout.trim() || undefined;
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				return undefined;
+			}
+		}
+
 		return this.cache.getDefaultBranchName(repoPath, remote, async commonPath => {
 			let retried = false;
 			while (true) {
@@ -868,20 +887,32 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	}
 
 	@debug()
-	getBranchMergedStatus(
+	async getBranchMergedStatus(
 		repoPath: string,
 		branch: GitBranchReference,
 		into: GitBranchReference,
 		cancellation?: AbortSignal,
 	): Promise<GitBranchMergedStatus> {
 		if (branch.name === into.name || branch.upstream?.name === into.name) {
-			return Promise.resolve({ merged: false });
+			return { merged: false };
 		}
 
+		// Hoisted so it can feed the cache key below (its tip is a 3rd key input) and the mapper
+		// below reuses it instead of resolving it a second time.
+		const localInto = into.remote
+			? await this.getLocalBranchByUpstream(repoPath, into.name, cancellation)
+			: undefined;
+
 		// Cache key omits repoPath so worktrees of the same common repo share the cached answer.
-		// Branch refs (`refs/heads/*` / `refs/remotes/*`) are unique within a common repo, so
-		// `name` + `remote` flag is the minimal stable identity.
-		const cacheKey = `${branch.remote ? 'r' : 'l'}:${branch.name}|${into.remote ? 'r' : 'l'}:${into.name}`;
+		// Content-keyed on the involved tip shas (the result is a pure function of them), so tip
+		// movement mints a new key instead of relying on eviction; falls back to the name-only
+		// identity when a sha is missing (defensive — the sole caller always supplies both tips).
+		const cacheKey =
+			branch.sha != null && into.sha != null
+				? `${branch.remote ? 'r' : 'l'}:${branch.name}@${branch.sha}|${into.remote ? 'r' : 'l'}:${into.name}@${into.sha}${
+						localInto?.sha != null ? `|L:${localInto.name}@${localInto.sha}` : ''
+					}`
+				: `${branch.remote ? 'r' : 'l'}:${branch.name}|${into.remote ? 'r' : 'l'}:${into.name}`;
 
 		return this.cache.getBranchMergedStatus(
 			repoPath,
@@ -890,38 +921,29 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				const result = await this.getBranchMergedStatusCore(commonPath, branch, into, signal);
 				if (result.merged) return result;
 
-				// If the branch we are checking is a remote branch, check if it has been merged into its local branch (if there is one)
-				if (into.remote) {
-					const localIntoBranch = await this.getLocalBranchByUpstream(commonPath, into.name, signal);
-					// If there is a local branch and it is not the branch we are checking, check if it has been merged into it
-					if (localIntoBranch != null && localIntoBranch.name !== branch.name) {
-						// Skip the second full merge-check cycle when the local branch points at the same commit as the remote —
-						// the merge-base/cherry/diff/apply pipeline would produce the same answer we already got for `into` above
-						if (localIntoBranch.sha != null && localIntoBranch.sha === into.sha) {
-							return { merged: false };
-						}
+				// If there is a local branch and it is not the branch we are checking, check if it has been merged into it
+				if (localInto != null && localInto.name !== branch.name) {
+					// Skip the second full merge-check cycle when the local branch points at the same commit as the remote —
+					// the merge-base/cherry/diff/apply pipeline would produce the same answer we already got for `into` above
+					if (localInto.sha != null && localInto.sha === into.sha) {
+						return { merged: false };
+					}
 
-						const result = await this.getBranchMergedStatusCore(
-							commonPath,
-							branch,
-							localIntoBranch,
-							signal,
-						);
-						if (result.merged) {
-							// `localBranchOnly` is built against `commonPath` here; the cache mapper rewrites
-							// `repoPath`/`id` to the requesting worktree on retrieval.
-							return {
-								...result,
-								localBranchOnly: createReference(localIntoBranch.ref, localIntoBranch.repoPath, {
-									id: localIntoBranch.id,
-									refType: 'branch',
-									name: localIntoBranch.name,
-									remote: localIntoBranch.remote,
-									upstream: localIntoBranch.upstream,
-									sha: localIntoBranch.sha,
-								}),
-							};
-						}
+					const result = await this.getBranchMergedStatusCore(commonPath, branch, localInto, signal);
+					if (result.merged) {
+						// `localBranchOnly` is built against `commonPath` here; the cache mapper rewrites
+						// `repoPath`/`id` to the requesting worktree on retrieval.
+						return {
+							...result,
+							localBranchOnly: createReference(localInto.ref, commonPath, {
+								id: getBranchId(commonPath, localInto.remote, localInto.name),
+								refType: 'branch',
+								name: localInto.name,
+								remote: localInto.remote,
+								upstream: localInto.upstream,
+								sha: localInto.sha,
+							}),
+						};
 					}
 				}
 

package/src/git-cli/providers/commits.ts

@@ -10,7 +10,7 @@ import type { GitLog } from '../../git/models/log.js';
 import type { GitReflog } from '../../git/models/reflog.js';
 import type { GitRevisionRange } from '../../git/models/revision.js';
 import type { SearchQuery, SearchQueryFilters } from '../../git/models/search.js';
-import type { CommitSignature } from '../../git/models/signature.js';
+import type { CommitSignature, SshSignedCommit } from '../../git/models/signature.js';
 import type { GitUser } from '../../git/models/user.js';
 import type {
 	GitCommitReachability,
@@ -58,6 +58,10 @@ import {
 } from '../parsers/logParser.js';
 import { getReflogParser, parseGitRefLog } from '../parsers/reflogParser.js';
 import { parseSignatureOutput, signatureFormat } from '../parsers/signatureParser.js';
+import {
+	extractCommitterFromCommitObject,
+	extractSshPublicKeyFromCommitObject,
+} from '../parsers/sshSignatureParser.js';
 import { createCommitFileset } from './commitFilesetUtils.js';
 import { convertStashesToStdin } from './stash.js';
 
@@ -118,7 +122,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			rev,
 			'--',
 		);
-		if (result.cancelled || cancellation?.aborted) {
+		if (result.completion.status === 'cancelled' || cancellation?.aborted) {
 			throw new CancellationError();
 		}
 
@@ -146,7 +150,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			'--remotes',
 			'--',
 		);
-		if (result.cancelled || cancellation?.aborted) {
+		if (result.completion.status === 'cancelled' || cancellation?.aborted) {
 			throw new CancellationError();
 		}
 
@@ -178,7 +182,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			...parser.arguments,
 			rev,
 		);
-		if (result.cancelled || cancellation?.aborted) return undefined;
+		if (result.completion.status === 'cancelled' || cancellation?.aborted) return undefined;
 
 		for (const entry of parser.parse(result.stdout)) {
 			const authorSeconds = Number(entry.authorDate);
@@ -331,9 +335,9 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				return { refs: refs };
 			} catch (ex) {
 				cacheable?.invalidate();
-				debugger;
 				if (isCancellationError(ex)) throw ex;
 
+				debugger;
 				scope?.error(ex);
 
 				return undefined;
@@ -440,7 +444,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 					'HEAD',
 					'--',
 				);
-				if (result.cancelled || cancellation?.aborted) {
+				if (result.completion.status === 'cancelled' || cancellation?.aborted) {
 					throw new CancellationError();
 				}
 
@@ -475,7 +479,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				range,
 				'--',
 			);
-			if (result.cancelled || cancellation?.aborted) {
+			if (result.completion.status === 'cancelled' || cancellation?.aborted) {
 				throw new CancellationError();
 			}
 			if (!result.stdout) return undefined;
@@ -887,7 +891,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 						}
 						return moreLog.commits;
 					},
-					// eslint-disable-next-line no-loop-func
+					// oxlint-disable-next-line no-loop-func
 					query: (limit: number | undefined) =>
 						this.getLogCore(log.repoPath, rev, { ...options, limit: limit }),
 				};
@@ -1255,6 +1259,10 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			rev1,
 			rev2,
 		);
+		// A cancelled check has no answer. `completion` now keeps that distinct from a real "is an ancestor"
+		// result — the missing `exitCode` alone already makes the check below `false` — but callers branch on
+		// `isCancellationError`, so this still has to throw rather than quietly answer "no".
+		if (cancellation?.aborted) throw new CancellationError();
 		return result.exitCode === 0;
 	}
 
@@ -1304,8 +1312,30 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			let stashes: Map<string, GitStashCommit> | undefined;
 			let stdin: string | undefined;
 
+			let resolvedShas: Set<string> | undefined;
 			if (shas?.size) {
-				stdin = join(shas, '\n');
+				resolvedShas = await this.provider.revision.resolveShas(repoPath, shas, cancellation);
+				if (cancellation?.aborted) throw new CancellationError();
+				// Short SHA(s) matched no commit: return empty (empty stdin to `--no-walk --stdin`
+				// would return HEAD, so we must not fall through to git).
+				if (!resolvedShas.size) {
+					return {
+						search: search,
+						log: {
+							repoPath: repoPath,
+							commits: new Map(),
+							sha: undefined,
+							searchFilters: filters,
+							count: 0,
+							limit: options?.limit ?? cfg?.search?.maxItems ?? 0,
+							hasMore: false,
+						},
+					};
+				}
+			}
+
+			if (resolvedShas?.size) {
+				stdin = join(resolvedShas, '\n');
 				args.push('--no-walk');
 			} else if (!filters.refs) {
 				// Don't include stashes when using ref: filter, as they would add unrelated commits
@@ -1476,6 +1506,69 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			return false;
 		}
 	}
+
+	@debug()
+	async getCommitsSshSigners(repoPath: string, shas: string[]): Promise<Map<string, SshSignedCommit>> {
+		const scope = getScopedLogger();
+
+		const result = new Map<string, SshSignedCommit>();
+		if (shas.length === 0) return result;
+
+		try {
+			// Read every commit object in a single `cat-file --batch` process (the SHAs are piped to stdin) rather than
+			// spawning one `git` per commit — the embedded SSH signature and committer identity are then parsed from
+			// each raw object, avoiding a separate (and far heavier) `git log` pass to enumerate identities.
+			const data = await this.git.run<Buffer>(
+				{ cwd: repoPath, errors: 'ignore', stdin: `${shas.join('\n')}\n`, encoding: 'buffer' },
+				'cat-file',
+				'--batch',
+			);
+			parseCatFileBatchForSshSigners(data.stdout, new Set(shas), result);
+		} catch (ex) {
+			scope?.error(ex);
+		}
+		return result;
+	}
+}
+
+/**
+ * Parses `git cat-file --batch` output, extracting the embedded SSH public key (if any) from each requested commit
+ * object. Each record is `<sha> <type> <size>` LF `<content>` LF (or `<sha> missing` LF), and the object's bytes are
+ * consumed using the header's `<size>` rather than scanned line-by-line — so a commit/tag body line that happens to
+ * look like an object header can never be misread as a boundary. Operates on the raw `Buffer` because `<size>` counts
+ * bytes, not decoded characters.
+ *
+ * Exported for unit testing.
+ */
+export function parseCatFileBatchForSshSigners(
+	stdout: Buffer,
+	requestedShas: Set<string>,
+	out: Map<string, SshSignedCommit>,
+): void {
+	const headerRegex = /^([0-9a-f]{40,64}) (commit|tag|blob|missing)(?: (\d+))?$/;
+
+	let offset = 0;
+	while (offset < stdout.length) {
+		const newline = stdout.indexOf(0x0a, offset);
+		if (newline === -1) break;
+
+		const match = headerRegex.exec(stdout.toString('utf8', offset, newline));
+		offset = newline + 1;
+		// A missing object (or an unrecognizable header) has no content body following its header line.
+		if (match == null || match[2] === 'missing') continue;
+
+		const sha = match[1];
+		const object = stdout.toString('utf8', offset, offset + Number(match[3]));
+		offset += Number(match[3]) + 1; // consume the object's bytes and the trailing newline that separates records
+
+		if (!requestedShas.has(sha)) continue;
+
+		const key = extractSshPublicKeyFromCommitObject(object);
+		if (key == null) continue;
+
+		const committer = extractCommitterFromCommitObject(object);
+		out.set(sha, { key: key, name: committer?.name, email: committer?.email });
+	}
 }
 
 function toCommit(c: ParsedCommit, repoPath: string, pathspec: string | undefined, currentUser: GitUser | undefined) {