@gitkraken/core-gitlens 0.1.0 → 0.3.0

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

@@ -27,6 +27,7 @@ import type { DiffRange } from '../../git/providers/types.js';
 import { createUncommittedChangesCommit } from '../../git/utils/commit.utils.js';
 import { isRevisionRange, isSha, isUncommitted, isUncommittedStaged } from '../../git/utils/revision.utils.js';
 import { parseSearchQueryGitCommand } from '../../git/utils/search.utils.js';
+import { compareReachableRefs } from '../../git/utils/sorting.js';
 import { isUserMatch } from '../../git/utils/user.utils.js';
 import { CancellationError, isCancellationError } from '../../utils/cancellation.js';
 import { debug, trace } from '../../utils/decorators/log.js';
@@ -40,7 +41,7 @@ import { escapeRegex } from '../../utils/string.js';
 import type { Uri } from '../../utils/uri.js';
 import { fileUri, joinUriPath, toFsPath } from '../../utils/uri.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
-import type { GitExecOptions, GitResult } from '../exec/exec.types.js';
+import type { GitResult, GitRunOptions } from '../exec/exec.types.js';
 import type { Git } from '../exec/git.js';
 import { gitConfigsLog, gitConfigsLogWithFiles, GitErrors } from '../exec/git.js';
 import type {
@@ -49,7 +50,12 @@ import type {
 	CommitsWithFilesLogParser,
 	ParsedCommit,
 } from '../parsers/logParser.js';
-import { getCommitsLogParser, getShaAndFilesAndStatsLogParser, getShaLogParser } from '../parsers/logParser.js';
+import {
+	getCommitsLogParser,
+	getShaAndDatesLogParser,
+	getShaAndFilesAndStatsLogParser,
+	getShaLogParser,
+} from '../parsers/logParser.js';
 import { getReflogParser, parseGitRefLog } from '../parsers/reflogParser.js';
 import { parseSignatureOutput, signatureFormat } from '../parsers/signatureParser.js';
 import { createCommitFileset } from './commitFilesetUtils.js';
@@ -74,7 +80,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		message: string,
 		cancellation?: AbortSignal,
 	): Promise<string> {
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath, cancellation: cancellation, errors: 'throw' },
 			'commit-tree',
 			tree,
@@ -105,7 +111,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 
 	@debug({ exit: true })
 	async getCommitCount(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<number | undefined> {
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 			'rev-list',
 			'--count',
@@ -123,10 +129,49 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		return isNaN(count) ? undefined : count;
 	}
 
+	@debug({ exit: true })
+	async getCommitDates(
+		repoPath: string,
+		rev: string,
+		cancellation?: AbortSignal,
+	): Promise<{ authorDate: Date; committerDate: Date } | undefined> {
+		const parser = getShaAndDatesLogParser();
+		const result = await this.git.run(
+			{
+				cwd: repoPath,
+				cancellation: cancellation,
+				errors: 'ignore',
+				// Why: full SHAs identify immutable commits (5-min TTL is safe). Non-SHA refs rely on
+				// gitResults being cleared on 'head'/'heads'/'remotes' events; the 60s TTL is the
+				// failsafe for watcher latency / web (no fs watcher).
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: isSha(rev) ? 5 * 60 * 1000 : 60 * 1000 },
+				},
+			},
+			'log',
+			'-1',
+			...parser.arguments,
+			rev,
+		);
+		if (result.cancelled || cancellation?.aborted) return undefined;
+
+		for (const entry of parser.parse(result.stdout)) {
+			const authorSeconds = Number(entry.authorDate);
+			const committerSeconds = Number(entry.committerDate);
+			if (!Number.isFinite(authorSeconds) || !Number.isFinite(committerSeconds)) return undefined;
+			return {
+				authorDate: new Date(authorSeconds * 1000),
+				committerDate: new Date(committerSeconds * 1000),
+			};
+		}
+		return undefined;
+	}
+
 	@debug()
 	async getCommitFiles(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<GitFileChange[]> {
 		const parser = getShaAndFilesAndStatsLogParser();
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
 			'log',
 			...parser.arguments,
@@ -204,7 +249,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		const getCore = async (cacheable?: CacheController) => {
 			try {
 				// Use for-each-ref with %(HEAD) to mark current branch with *
-				const result = await this.git.exec(
+				const result = await this.git.run(
 					{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 					'for-each-ref',
 					'--contains',
@@ -255,8 +300,9 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 					}
 				}
 
-				// Sort to move tags to the end, preserving order within each type
-				refs.sort((a, b) => (a.refType !== b.refType ? (a.refType === 'tag' ? 1 : -1) : 0));
+				// git already returns sorted by -HEAD, -committerdate, -version:refname;
+				// compareReachableRefs refines by current-first / local-before-remote / tag-version.
+				refs.sort(compareReachableRefs);
 
 				return { refs: refs };
 			} catch (ex) {
@@ -305,8 +351,8 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		}
 
 		try {
-			const result = await this.git.exec(
-				{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
+			const result = await this.git.run(
+				{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog, priority: 'background' },
 				'log',
 				...args,
 			);
@@ -363,7 +409,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		// Initial commit SHA is shared across all worktrees
 		return this.cache.getInitialCommitSha(repoPath, async commonPath => {
 			try {
-				const result = await this.git.exec(
+				const result = await this.git.run(
 					{ cwd: commonPath, cancellation: cancellation, errors: 'ignore' },
 					'rev-list',
 					`--max-parents=0`,
@@ -395,7 +441,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			: [];
 
 		const run = async (): Promise<LeftRightCommitCountResult | undefined> => {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 				'rev-list',
 				'--left-right',
@@ -431,7 +477,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		// Cache key: range + excludeMerges. RepositoryChange events affecting branches/remotes
 		// invalidate this cache via clearCaches('branches').
 		const cacheKey = `${range}\x1f${options?.excludeMerges ? 'no-merges' : ''}`;
-		return this.cache.getLeftRightCommitCount(repoPath, cacheKey, run);
+		return this.cache.leftRightCommitCount.getOrCreate(repoPath, cacheKey, run);
 	}
 
 	@debug()
@@ -525,24 +571,15 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				args.push(`-n${isSingleCommit ? 1 : limit + 1}`);
 			}
 
-			let stashes: Map<string, GitStashCommit> | undefined;
-			let stdin: string | undefined;
+			let stashes: ReadonlyMap<string, GitStashCommit> | undefined;
 
-			if (!isSingleCommit) {
-				if (options?.stashes) {
-					// There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
-					({ stdin, stashes } = convertStashesToStdin(
-						typeof options.stashes === 'boolean'
-							? await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation)
-							: options.stashes,
-					));
-					if (stashes.size) {
-						rev ??= 'HEAD';
-					}
-				}
-
-				if (stdin) {
-					args.push('--stdin');
+			if (!isSingleCommit && options?.stashes) {
+				stashes =
+					typeof options.stashes === 'boolean'
+						? (await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation))?.stashes
+						: options.stashes;
+				if (stashes?.size) {
+					rev ??= 'HEAD';
 				}
 			}
 
@@ -580,19 +617,30 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			const currentUser = await currentUserPromise.catch(() => undefined);
 			if (cancellation?.aborted) throw new CancellationError();
 
-			const cmdOpts: GitExecOptions = {
+			const cmdOpts: GitRunOptions = {
 				cwd: repoPath,
 				cancellation: cancellation,
 				configs: gitConfigsLogWithFiles,
-				stdin: stdin,
+				// Single-commit log serves user-initiated reads (commit details, hover, etc.).
+				// Mirrors getCommitDates: full SHAs are immutable so a 5-min TTL is safe; non-SHA refs
+				// rely on gitResults being cleared on head/heads/remotes events (60s is the failsafe
+				// for watcher latency / web with no fs watcher).
+				...(isSingleCommit && rev
+					? {
+							caching: {
+								cache: this.cache.gitResults,
+								options: { accessTTL: isSha(rev) ? 5 * 60 * 1000 : 60 * 1000 },
+							},
+						}
+					: undefined),
 			};
-			let { commits, count, countStashChildCommits } = await parseCommits(
+			let { commits, count } = await parseCommits(
 				parser,
-				isSingleCommit ? this.git.exec(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
+				isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
 				repoPath,
 				pathspec,
 				limit,
-				stashes,
+				undefined,
 				currentUser,
 			);
 
@@ -614,25 +662,67 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 						args.splice(args.length - 1, 1, pathspec);
 					}
 
-					({ commits, count, countStashChildCommits } = await parseCommits(
+					({ commits, count } = await parseCommits(
 						parser,
-						isSingleCommit ? this.git.exec(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
+						isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
 						repoPath,
 						pathspec,
 						limit,
-						stashes,
+						undefined,
 						currentUser,
 					));
 				}
 			}
 
+			// Merge stashes in-memory rather than via `git log --stdin <stash>` — git would
+			// walk each stash's parent chains and pull in pre-rebase ancestors that aren't
+			// reachable from <rev>. Slot each stash directly above its first parent; stashes
+			// whose parent isn't in the result (rebased away, or below the current limit) are
+			// dropped — the Stashes view still surfaces them, and they reappear here if the
+			// parent loads via "Load more".
+			if (stashes?.size) {
+				// `stashes` arrives in `git stash list` order (newest @{0} first), so per-parent
+				// groups naturally land newest-first without an explicit sort
+				const stashesByParent = new Map<string, GitStashCommit[]>();
+				for (const stash of stashes.values()) {
+					const parentSha = stash.parents[0];
+					if (parentSha == null || !commits.has(parentSha)) continue;
+
+					const group = stashesByParent.get(parentSha);
+					if (group != null) {
+						group.push(stash);
+					} else {
+						stashesByParent.set(parentSha, [stash]);
+					}
+				}
+
+				if (stashesByParent.size) {
+					const cap = limit > 0 ? limit + 1 : Number.POSITIVE_INFINITY;
+					const merged = new Map<string, GitCommit>();
+					outer: for (const c of commits.values()) {
+						const group = stashesByParent.get(c.sha);
+						if (group != null) {
+							for (const s of group) {
+								if (merged.size >= cap) break outer;
+
+								merged.set(s.sha, s);
+							}
+						}
+						if (merged.size >= cap) break;
+
+						merged.set(c.sha, c);
+					}
+					commits = merged;
+				}
+			}
+
 			const log: GitLog = {
 				repoPath: repoPath,
 				commits: commits,
 				sha: isRevisionRange(rev) ? undefined : rev,
 				count: commits.size,
 				limit: limit,
-				hasMore: overrideHasMore ?? count - countStashChildCommits > commits.size,
+				hasMore: overrideHasMore ?? (limit > 0 && count > limit),
 			};
 
 			if (!isSingleCommit) {
@@ -897,6 +987,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 							filterMap<[string, GitCommit], [string, GitCommit]>(log.commits.entries(), ([sha, c]) => {
 								if (skip) {
 									if (sha !== rev) return undefined;
+
 									skip = false;
 								}
 
@@ -1058,7 +1149,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 					args.push(pathspec);
 				}
 
-				const result = await this.git.exec(
+				const result = await this.git.run(
 					{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
 					'log',
 					...args,
@@ -1067,6 +1158,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			} catch (ex) {
 				scope?.error(ex);
 				if (isCancellationError(ex)) throw ex;
+
 				debugger;
 
 				return [];
@@ -1100,7 +1192,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 
 			const parser = getShaLogParser();
 
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
 				'log',
 				...parser.arguments,
@@ -1114,6 +1206,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		} catch (ex) {
 			scope?.error(ex);
 			if (isCancellationError(ex)) throw ex;
+
 			debugger;
 
 			return undefined;
@@ -1131,7 +1224,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 	async isAncestorOf(repoPath: string, rev1: string, rev2: string, cancellation?: AbortSignal): Promise<boolean> {
 		if (repoPath == null) return false;
 
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 			'merge-base',
 			'--is-ancestor',
@@ -1310,11 +1403,14 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		const scope = getScopedLogger();
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{
 					cwd: repoPath,
 					errors: 'ignore',
-					caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+					caching: {
+						cache: this.cache.gitResults,
+						options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
+					},
 					configs: gitConfigsLog,
 				},
 				'log',
@@ -1337,11 +1433,14 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		const scope = getScopedLogger();
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{
 					cwd: repoPath,
 					errors: 'ignore',
-					caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+					caching: {
+						cache: this.cache.gitResults,
+						options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
+					},
 				},
 				'cat-file',
 				'commit',

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

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { hostname, userInfo } from 'os';
 import { env as process_env } from 'process';
-import type { Cache } from '../../git/cache.js';
+import type { Cache, GkConfigInvalidationTarget } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import { WorkspaceUntrustedError } from '../../git/errors.js';
 import type { GitDir } from '../../git/models/repository.js';
@@ -34,6 +34,8 @@ const emptyArray: readonly never[] = Object.freeze([]);
  */
 const gkConfigCacheableSets: readonly { match: RegExp; pattern: string }[] = [
 	{ match: /^branch\..+\.gk-associated-issues$/, pattern: '^branch\\..+\\.gk-associated-issues$' },
+	{ match: /^branch\..+\.gk-merge-base$/, pattern: '^branch\\..+\\.gk-merge-base$' },
+	{ match: /^branch\..+\.gk-merge-target$/, pattern: '^branch\\..+\\.gk-merge-target$' },
 	{ match: /^branch\..+\.gk-merge-target-user$/, pattern: '^branch\\..+\\.gk-merge-target-user$' },
 ];
 
@@ -59,6 +61,7 @@ function parseConfigRegexOutput(data: string | undefined): Map<string, string> {
 
 function parseGitBoolean(value: string | undefined): boolean {
 	if (value == null) return false;
+
 	const normalized = value.toLowerCase().trim();
 	return normalized === 'true' || normalized === 'yes' || normalized === 'on' || normalized === '1';
 }
@@ -71,6 +74,13 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		private readonly provider: CliGitProviderInternal,
 	) {}
 
+	/**
+	 * Pending `setGkConfig` writes keyed by `(commonPath, key, value, skip-option)`. Concurrent
+	 * callers writing the same `(key, value)` pair share the in-flight Promise so only one
+	 * `git config --set` subprocess actually runs. Cleared on settle.
+	 */
+	private readonly _pendingGkConfigWrites = new Map<string, Promise<void>>();
+
 	@trace()
 	getConfig(
 		repoPath: string | undefined,
@@ -99,7 +109,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		}
 		args.push(key);
 
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath ?? '', errors: 'ignore', runLocally: options?.runGitLocally },
 			...args,
 		);
@@ -131,7 +141,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		}
 		args.push(pattern);
 
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath ?? '', errors: 'ignore', runLocally: options?.runGitLocally },
 			...args,
 		);
@@ -169,7 +179,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 			args.push(key, value);
 		}
 
-		await this.git.exec({ cwd: repoPath ?? '', runLocally: true }, ...args);
+		await this.git.run({ cwd: repoPath ?? '', runLocally: true }, ...args);
 
 		// Only invalidate cache when not using a custom file (custom files aren't cached)
 		if (!options?.file) {
@@ -218,7 +228,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 			const author = `${user.name} <${user.email}>`;
 			// Check if there is a mailmap for the current user
-			const result = await this.git.exec({ cwd: repoPath, errors: 'ignore' }, 'check-mailmap', author);
+			const result = await this.git.run({ cwd: repoPath, errors: 'ignore' }, 'check-mailmap', author);
 
 			if (result.stdout && result.stdout !== author) {
 				const match = mappedAuthorRegex.exec(result.stdout);
@@ -243,6 +253,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	async getDefaultWorktreePath(repoPath: string): Promise<string | undefined> {
 		const gitDir = await this.getGitDir(repoPath);
 		if (gitDir == null) return undefined;
+
 		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
 		return getBestPath(normalizePath(joinPaths(basePath, '..')));
 	}
@@ -291,6 +302,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	private async getGkConfigPath(repoPath: string): Promise<string | undefined> {
 		const gitDir = await this.getGitDir(repoPath);
 		if (gitDir == null) return undefined;
+
 		// Use commonUri (main .git dir) for worktrees, otherwise use uri
 		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
 		return joinPaths(basePath, 'gk', 'config');
@@ -349,6 +361,31 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		repoPath: string,
 		key: GkConfigKeys | DeprecatedGkConfigKeys,
 		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void> {
+		// Encode the skip-invalidation option in the dedup key: a self-write (with skip targets)
+		// and a user-driven write of the same `(key, value)` (no skip targets) have different
+		// cache-invalidation semantics, so sharing their Promise would silently let the user-driven
+		// write skip invalidation. Sort the array so callers passing the same targets in different
+		// orders share a single in-flight write.
+		const commonPath = this.cache.getCommonPath(repoPath);
+		const skipKey = options?.skipInvalidation?.length ? options.skipInvalidation.toSorted().join(',') : '';
+		const dedupKey = `${commonPath}\0${key}\0${value ?? ''}\0${skipKey}`;
+
+		const pending = this._pendingGkConfigWrites.get(dedupKey);
+		if (pending != null) return pending;
+
+		const promise = this.setGkConfigCore(repoPath, key, value, options);
+		this._pendingGkConfigWrites.set(dedupKey, promise);
+		void promise.finally(() => this._pendingGkConfigWrites.delete(dedupKey));
+		return promise;
+	}
+
+	private async setGkConfigCore(
+		repoPath: string,
+		key: GkConfigKeys | DeprecatedGkConfigKeys,
+		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -362,7 +399,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
 
 		// Invalidate the cached value for this key and clear all regex patterns for this scope
-		this.cache.deleteGkConfig(repoPath, key);
+		this.cache.deleteGkConfig(repoPath, key, options);
 	}
 
 	@debug()
@@ -475,7 +512,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		if (this.context.workspace?.isTrusted === false) {
 			try {
 				await fs.stat(joinPaths(cwd, 'HEAD'));
-				result = await this.git.exec(
+				result = await this.git.run(
 					{ cwd: cwd, errors: 'throw', configs: ['-C', cwd] },
 					'rev-parse',
 					'--show-cdup',
@@ -490,7 +527,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		}
 
 		try {
-			result = await this.git.exec(
+			result = await this.git.run(
 				{ cwd: cwd, errors: 'throw' },
 				'rev-parse',
 				'--show-toplevel',
@@ -551,7 +588,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 			const inDotGit = /this operation must be run in a work tree/.test(ex.stderr);
 			if (inDotGit && this.context.workspace?.isTrusted !== false) {
-				result = await this.git.exec({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
+				result = await this.git.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
 				if (result.stdout.trim() === 'true') {
 					const result = await this.revParseGitDir(cwd);
 					const repoPath = result?.commonPath ?? result?.path;
@@ -578,12 +615,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	}
 
 	private async revParseGitDir(cwd: string): Promise<{ path: string; commonPath?: string } | undefined> {
-		const result = await this.git.exec(
-			{ cwd: cwd, errors: 'ignore' },
-			'rev-parse',
-			'--git-dir',
-			'--git-common-dir',
-		);
+		const result = await this.git.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--git-dir', '--git-common-dir');
 		if (!result.stdout) return undefined;
 
 		let [dotGitPath, commonDotGitPath] = result.stdout.split('\n').map(r => r.trimStart());
@@ -653,6 +685,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 			this._migratedRepos.add(repoPath);
 			return;
 		}
+
 		const gkConfigFolder = joinPaths(gkConfigPath, '..');
 
 		// If .git/gk/config already exists, consider migration done — it was either
@@ -667,6 +700,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 		// If .git/gk/config doesn't exist, create an empty file to prevent multiple migration attempts in future sessions
 		if (!(await this.ensureGkConfigFolder(gkConfigFolder, scope))) return;
+
 		try {
 			await fs.writeFile(gkConfigPath, new Uint8Array());
 		} catch (ex) {
@@ -704,7 +738,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		// Remove legacy keys from regular git config (use --unset-all defensively)
 		for (const [key] of migrateConfig) {
 			try {
-				await this.git.exec(
+				await this.git.run(
 					{ cwd: repoPath, errors: 'ignore', runLocally: true },
 					'config',
 					'--local',

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

@@ -260,7 +260,7 @@ export class ContributorsGitSubProvider implements GitContributorsSubProvider {
 				}
 
 				const currentUserPromise = this.provider.config.getCurrentUser(repoPath).catch(() => undefined);
-				const result = await this.git.exec({ cwd: repoPath, cancellation: signal }, ...args);
+				const result = await this.git.run({ cwd: repoPath, cancellation: signal }, ...args);
 				if (!result.stdout) return [];
 
 				const shortlog = parseShortlog(result.stdout, commonPath, await currentUserPromise);
@@ -301,7 +301,7 @@ export class ContributorsGitSubProvider implements GitContributorsSubProvider {
 
 		const scope = getScopedLogger();
 
-		const getCore = async (commonPath: string): Promise<GitContributorsStats | undefined> => {
+		const getCore = async (commonPath: string, signal?: AbortSignal): Promise<GitContributorsStats | undefined> => {
 			try {
 				const args = ['shortlog', '-s', '--all'];
 
@@ -316,10 +316,7 @@ export class ContributorsGitSubProvider implements GitContributorsSubProvider {
 					args.push(`--since=${options.since}`);
 				}
 
-				const result = await this.git.exec(
-					{ cwd: commonPath, cancellation: cancellation, timeout: timeout },
-					...args,
-				);
+				const result = await this.git.run({ cwd: commonPath, cancellation: signal, timeout: timeout }, ...args);
 				if (!result.stdout) return undefined;
 
 				const contributions = result.stdout
@@ -351,11 +348,9 @@ export class ContributorsGitSubProvider implements GitContributorsSubProvider {
 			customCacheTTL = timeout * 2;
 		}
 
-		return this.cache.getContributorsStats(
-			repoPath,
-			cacheKey,
-			getCore,
-			customCacheTTL ? { accessTTL: customCacheTTL } : undefined,
-		);
+		return this.cache.getContributorsStats(repoPath, cacheKey, getCore, {
+			accessTTL: customCacheTTL,
+			cancellation: cancellation,
+		});
 	}
 }