@gitkraken/core-gitlens 0.1.0 → 0.2.0

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

@@ -24,6 +24,7 @@ import type {
 import type { GitRemote } from '../../git/models/remote.js';
 import type { SearchQuery } from '../../git/models/search.js';
 import type { GitWorktree } from '../../git/models/worktree.js';
+import type { GitCommitReachability } from '../../git/providers/commits.js';
 import type { GitGraphSubProvider } from '../../git/providers/graph.js';
 import {
 	getBranchId,
@@ -33,6 +34,7 @@ import {
 import { getChangedFilesCount } from '../../git/utils/commit.utils.js';
 import { isUncommitted } from '../../git/utils/revision.utils.js';
 import { getSearchQueryComparisonKey, parseSearchQueryGitCommand } from '../../git/utils/search.utils.js';
+import { compareReachableRefs } from '../../git/utils/sorting.js';
 import { getTagId } from '../../git/utils/tag.utils.js';
 import { isUserMatch } from '../../git/utils/user.utils.js';
 import { getWorktreeId, groupWorktreesByBranch } from '../../git/utils/worktree.utils.js';
@@ -56,6 +58,8 @@ import { convertStashesToStdin } from './stash.js';
 
 const progressiveSearchResultsBatchTimeMs = 500; // Send updates every 500ms (2 updates/second)
 
+type ReachableRef = GitCommitReachability['refs'][number];
+
 export class GraphGitSubProvider implements GitGraphSubProvider {
 	constructor(
 		private readonly context: GitServiceContext,
@@ -87,7 +91,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		const [shaResult, stashResult, branchesResult, remotesResult, currentUserResult, worktreesResult] =
 			await Promise.allSettled([
 				!isUncommitted(rev, true)
-					? this.git.exec(
+					? this.git.run(
 							{ cwd: repoPath, configs: gitConfigsLog },
 							'log',
 							...shaParser.arguments,
@@ -96,7 +100,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							'--',
 						)
 					: undefined,
-				this.provider.stash?.getStash(repoPath, undefined, cancellation),
+				this.provider.stash?.getStash(repoPath, { includeFiles: false }, cancellation),
 				this.provider.branches.getBranches(repoPath, undefined, cancellation),
 				this.provider.remotes.getRemotes(repoPath, undefined, cancellation),
 				this.provider.config.getCurrentUser(repoPath),
@@ -138,7 +142,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		const avatars = new Map<string, string>();
 		const ids = new Set<string>();
 		const reachableFromHEAD = new Set<string>();
-		const reachableFromBranches = new Map<string, Set<string>>();
+
+		// Map<sha, Map<refKey, ref>> — inner map deduplicates refs during propagation
+		const reachableRefs = new Map<string, Map<string, ReachableRef>>();
 		const rowStats: GitGraphRowsStats = new Map<string, GitGraphRowStats>();
 		let pendingRowsStatsCount = 0;
 		let iterations = 0;
@@ -218,7 +224,6 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 								branchIdOfMainWorktree: branchIdOfMainWorktree,
 								stashes: gitStash?.stashes,
 								reachableFromHEAD: reachableFromHEAD,
-								reachableFromBranches: reachableFromBranches,
 								avatars: avatars,
 							}
 						: undefined;
@@ -340,34 +345,46 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 						}
 					}
 
-					if (refHeads.length > 0) {
-						let branches = reachableFromBranches.get(shaOrRemapped);
-						if (branches == null) {
-							branches = new Set<string>();
-							reachableFromBranches.set(shaOrRemapped, branches);
+					// Seed reachability from all ref types on this commit
+					if (refHeads.length > 0 || refRemoteHeads.length > 0 || refTags.length > 0) {
+						let refs = reachableRefs.get(shaOrRemapped);
+						if (refs == null) {
+							refs = new Map<string, ReachableRef>();
+							reachableRefs.set(shaOrRemapped, refs);
+						}
+						for (const h of refHeads) {
+							const key = `b:${h.name}`;
+							refs.set(key, { refType: 'branch', name: h.name, remote: false, current: h.isCurrentHead });
+						}
+						for (const r of refRemoteHeads) {
+							const name = `${r.owner}/${r.name}`;
+							refs.set(`r:${name}`, { refType: 'branch', name: name, remote: true });
 						}
-						for (const refHead of refHeads) {
-							branches.add(refHead.name);
+						for (const t of refTags) {
+							refs.set(`t:${t.name}`, { refType: 'tag', name: t.name });
 						}
 					}
 
-					const currentBranches = reachableFromBranches.get(shaOrRemapped);
-					if (currentBranches != null && currentBranches.size > 0) {
+					// Propagate reachability to parents
+					const currentRefs = reachableRefs.get(shaOrRemapped);
+					if (currentRefs != null && currentRefs.size > 0) {
 						for (parent of parents) {
-							let parentBranches = reachableFromBranches.get(parent);
-							if (parentBranches == null) {
-								parentBranches = new Set<string>();
-								reachableFromBranches.set(parent, parentBranches);
+							let parentRefs = reachableRefs.get(parent);
+							if (parentRefs == null) {
+								parentRefs = new Map<string, ReachableRef>();
+								reachableRefs.set(parent, parentRefs);
 							}
-							for (const branchName of currentBranches) {
-								parentBranches.add(branchName);
+							for (const [key, ref] of currentRefs) {
+								if (!parentRefs.has(key)) {
+									parentRefs.set(key, ref);
+								}
 							}
 						}
 					}
 
 					stash = gitStash?.stashes.get(shaOrRemapped);
 					if (stash != null) {
-						const branches = reachableFromBranches.get(shaOrRemapped);
+						const refs = reachableRefs.get(shaOrRemapped);
 						const row: GitGraphRow = {
 							sha: shaOrRemapped,
 							// Always only return the first parent for stashes, as it is a Git implementation for the index and untracked files
@@ -381,7 +398,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							heads: refHeads,
 							remotes: refRemoteHeads,
 							tags: refTags,
-							reachableFromBranches: branches ? [...branches] : undefined,
+							reachability: refs?.size
+								? { partial: true, refs: [...refs.values()].sort(compareReachableRefs) }
+								: undefined,
 							isCurrentUser: true,
 						};
 						rowProcessor?.processRow(row, graphCtx!);
@@ -397,7 +416,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					} else {
 						isCurrentUser = isUserMatch(currentUser, commit.author, commit.authorEmail);
 
-						const branches = reachableFromBranches.get(shaOrRemapped);
+						const refs = reachableRefs.get(shaOrRemapped);
 						const row: GitGraphRow = {
 							sha: shaOrRemapped,
 							parents: onlyFollowFirstParent ? parents.slice(0, 1) : parents,
@@ -410,7 +429,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							heads: refHeads,
 							remotes: refRemoteHeads,
 							tags: refTags,
-							reachableFromBranches: branches ? [...branches] : undefined,
+							reachability: refs?.size
+								? { partial: true, refs: [...refs.values()].sort(compareReachableRefs) }
+								: undefined,
 							isCurrentUser: isCurrentUser || undefined,
 						};
 						rowProcessor?.processRow(row, graphCtx!);
@@ -442,7 +463,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							}
 							args.push(`--${ordering}-order`, '--all');
 
-							const statsResult = await this.git.exec(
+							const statsResult = await this.git.run(
 								{ cwd: repoPath, configs: gitConfigsLog, stdin: stdin },
 								'log',
 								stdin ? '--stdin' : undefined,
@@ -455,7 +476,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 								for (const stat of statsParser.parse(statsResult.stdout)) {
 									statShaOrRemapped = remappedIds.get(stat.sha) ?? stat.sha;
 
-									// If we already have the stats for this sha, skip it (e.g. stashes)
+									// Don't overwrite stats already populated for this sha
 									if (rowStats.has(statShaOrRemapped)) continue;
 
 									rowStats.set(statShaOrRemapped, stat.stats);
@@ -485,7 +506,6 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					worktrees: worktrees,
 					worktreesByBranch: worktreesByBranch,
 					reachableFromHEAD: reachableFromHEAD,
-					reachableFromBranches: reachableFromBranches,
 					rows: rows,
 					id: sha ?? rev,
 					rowsStats: rowStats,
@@ -595,7 +615,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 				// Don't include stashes when using ref: filter, as they would add unrelated commits
 				// There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
 				({ stdin, stashes, remappedIds } = convertStashesToStdin(
-					await this.provider.stash?.getStash(repoPath, undefined, cancellation),
+					await this.provider.stash?.getStash(repoPath, { includeFiles: false }, cancellation),
 				));
 			} else {
 				remappedIds = new Map();

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

@@ -11,8 +11,10 @@ import {
 	RebaseError,
 	ResetError,
 	RevertError,
+	SigningError,
 } from '../../git/errors.js';
 import type { GitBranchReference, GitReference } from '../../git/models/reference.js';
+import type { SigningFormat } from '../../git/models/signature.js';
 import type { GitConflictFile } from '../../git/models/staging.js';
 import type { GitOperationResult, GitOperationsSubProvider } from '../../git/providers/operations.js';
 import { getBranchNameAndRemote, getBranchTrackingWithoutRemote } from '../../git/utils/branch.utils.js';
@@ -24,7 +26,13 @@ import { getScopedLogger } from '../../utils/logger.scoped.js';
 import { normalizePath, splitPath } from '../../utils/path.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { Git, PushForceOptions } from '../exec/git.js';
-import { getGitCommandError, gitConfigsPull, GitErrors } from '../exec/git.js';
+import {
+	classifySigningError,
+	getGitCommandError,
+	gitConfigsPull,
+	GitErrors,
+	inferSigningFormatFromError,
+} from '../exec/git.js';
 
 export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	constructor(
@@ -70,7 +78,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'checkout',
@@ -89,7 +97,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async cherryPick(
 		repoPath: string,
 		revs: string[],
-		options?: { edit?: boolean; noCommit?: boolean },
+		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -104,7 +112,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		if (revs.length > 1) {
 			// Sort commits in topological order (oldest ancestor first) so cherry-pick applies them correctly
 			const revsSet = new Set(revs);
-			const result = await this.git.exec({ cwd: repoPath }, 'rev-list', '--topo-order', '--reverse', ...revs);
+			const result = await this.git.run({ cwd: repoPath }, 'rev-list', '--topo-order', '--reverse', ...revs);
 
 			const ordered: string[] = [];
 			for (const sha of result.stdout.trim().split('\n')) {
@@ -123,12 +131,13 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		args.push(...revs);
 
 		try {
-			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 			const mapped = getGitCommandError(
 				'cherry-pick',
 				ex,
@@ -157,6 +166,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			author?: string;
 			date?: string;
 			signoff?: boolean;
+			source?: unknown;
 		},
 	): Promise<void> {
 		const scope = getScopedLogger();
@@ -184,11 +194,12 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		params.push('-F', '-');
 
 		try {
-			await this.git.exec({ cwd: repoPath, stdin: message, stdinEncoding: 'utf8', errors: 'throw' }, ...params);
+			await this.git.run({ cwd: repoPath, stdin: message, stdinEncoding: 'utf8', errors: 'throw' }, ...params);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, params, ex, options?.source);
 			throw getGitCommandError(
 				'commit',
 				ex,
@@ -265,7 +276,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'fetch',
@@ -289,7 +300,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async merge(
 		repoPath: string,
 		ref: string,
-		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean },
+		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean; source?: unknown },
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -312,7 +323,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		args.push(ref);
 
 		try {
-			await this.git.exec(
+			await this.git.run(
 				// Avoid a timeout since merges can take a long time (set to 0 to disable)
 				{ cwd: repoPath, errors: 'throw', timeout: 0 },
 				...args,
@@ -323,6 +334,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 			const mapped = getGitCommandError(
 				'merge',
 				ex,
@@ -343,7 +355,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	@debug()
 	async pull(
 		repoPath: string,
-		options?: { branch?: GitBranchReference; rebase?: boolean; tags?: boolean },
+		options?: { branch?: GitBranchReference; rebase?: boolean; tags?: boolean; source?: unknown },
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -360,6 +372,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 					await this.pullCore(normalizePath(worktree.uri.fsPath), {
 						rebase: options?.rebase,
 						tags: options?.tags,
+						source: options?.source,
 					});
 					this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status', 'tags');
 					this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'remotes', 'index']);
@@ -373,6 +386,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			await this.pullCore(repoPath, {
 				rebase: options?.rebase,
 				tags: options?.tags,
+				source: options?.source,
 			});
 
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status', 'tags');
@@ -383,7 +397,10 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 	}
 
-	private async pullCore(repoPath: string, options: { rebase?: boolean; tags?: boolean }): Promise<void> {
+	private async pullCore(
+		repoPath: string,
+		options: { rebase?: boolean; tags?: boolean; source?: unknown },
+	): Promise<void> {
 		const params = ['pull'];
 
 		if (options.tags) {
@@ -395,8 +412,9 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath, configs: gitConfigsPull }, ...params);
+			await this.git.run({ cwd: repoPath, configs: gitConfigsPull }, ...params);
 		} catch (ex) {
+			await this.throwIfSigningError(repoPath, params, ex, options.source);
 			throw getGitCommandError(
 				'pull',
 				ex,
@@ -479,7 +497,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 
 			// Since Git can't setup upstream tracking when publishing a new branch to a specific commit, do it now
 			if (setUpstream != null) {
-				await this.git.exec(
+				await this.git.run(
 					{ cwd: repoPath },
 					'branch',
 					'--set-upstream-to',
@@ -537,7 +555,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath }, ...params);
 		} catch (ex) {
 			const error = getGitCommandError(
 				'push',
@@ -609,6 +627,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			interactive?: boolean;
 			onto?: string;
 			updateRefs?: boolean;
+			source?: unknown;
 		},
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
@@ -643,7 +662,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec(
+			await this.git.run(
 				// Avoid a timeout since rebases can take a long time (set to 0 to disable)
 				{ cwd: repoPath, errors: 'throw', configs: configs, timeout: 0 },
 				...args,
@@ -653,6 +672,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 			const mapped = getGitCommandError(
 				'rebase',
 				ex,
@@ -703,7 +723,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		params.push(rev, '--');
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'reset',
@@ -716,7 +736,11 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 
 	@sequentialize({ getQueueKey: rp => rp })
 	@debug()
-	async revert(repoPath: string, refs: string[], options?: { editMessage?: boolean }): Promise<GitOperationResult> {
+	async revert(
+		repoPath: string,
+		refs: string[],
+		options?: { editMessage?: boolean; source?: unknown },
+	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
 		const args = ['revert'];
@@ -730,7 +754,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		args.push(...refs);
 
 		try {
-			await this.git.exec(
+			await this.git.run(
 				// Avoid a timeout since reverts can take a long time (set to 0 to disable)
 				{ cwd: repoPath, errors: 'throw', timeout: 0 },
 				...args,
@@ -741,6 +765,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 
 			const mapped = getGitCommandError(
 				'revert',
@@ -758,6 +783,40 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 	}
 
+	/**
+	 * Classifies `ex` as a signing failure; if so, fires the `commits.onSigningFailed`
+	 * hook and throws a typed {@link SigningError}. Callers should invoke this first
+	 * in their catch blocks, before falling through to command-specific error mapping
+	 * via {@link getGitCommandError}.
+	 *
+	 * `SigningFormat` is read opportunistically from `config.getSigningConfig`, with
+	 * {@link inferSigningFormatFromError} as a stderr-based fallback and `'gpg'` as
+	 * the final default.
+	 */
+	private async throwIfSigningError(
+		repoPath: string,
+		args: readonly (string | undefined)[],
+		ex: unknown,
+		source?: unknown,
+	): Promise<void> {
+		const reason = classifySigningError(ex);
+		if (reason == null) return;
+
+		let format: SigningFormat | undefined;
+		try {
+			format = (await this.provider.config.getSigningConfig?.(repoPath))?.format;
+		} catch {
+			// Fall through — config read failed; use stderr-inferred format or gpg default
+		}
+		format ??= inferSigningFormatFromError(ex) ?? 'gpg';
+
+		this.context.hooks?.commits?.onSigningFailed?.(reason, format, source);
+		throw new SigningError(
+			{ reason: reason, gitCommand: { repoPath: repoPath, args: args } },
+			ex instanceof Error ? ex : undefined,
+		);
+	}
+
 	private async createConflictResult(repoPath: string, command: GitConflictCommand): Promise<GitOperationResult> {
 		let conflicts: GitConflictFile[] | undefined;
 		try {

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

@@ -11,7 +11,7 @@ import { getSettledValue } from '../../utils/promise.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import { RunError } from '../exec/exec.errors.js';
 import type { Git } from '../exec/git.js';
-import { gitConfigsLog, GitError } from '../exec/git.js';
+import { classifySigningError, gitConfigsLog, GitError } from '../exec/git.js';
 
 export class PatchGitSubProvider implements GitPatchSubProvider {
 	constructor(
@@ -27,7 +27,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 		if (options?.threeWay) {
 			args.push('--3way');
 		}
-		await this.git.exec({ cwd: repoPath, stdin: patch }, ...args);
+		await this.git.run({ cwd: repoPath, stdin: patch }, ...args);
 	}
 
 	@debug()
@@ -209,7 +209,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			const [signingConfigResult, applyResult] = await Promise.allSettled([
 				this.provider.config.getSigningConfig?.(repoPath),
 				// Apply the patch to our temp index, without touching the working directory
-				this.git.exec(
+				this.git.run(
 					{ cwd: repoPath, configs: gitConfigsLog, env: env, stdin: patch },
 					'apply',
 					'--cached',
@@ -224,7 +224,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			_signingFormat = signingConfig?.format ?? 'gpg';
 
 			// Create a new tree from our patched index
-			let result = await this.git.exec({ cwd: repoPath, env: env }, 'write-tree');
+			let result = await this.git.run({ cwd: repoPath, env: env }, 'write-tree');
 			const tree = result.stdout.trim();
 
 			// Set the author if provided
@@ -247,7 +247,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			args.push('-m', message);
 
 			// Create new commit from the tree
-			result = await this.git.exec({ cwd: repoPath, env: finalEnv }, ...args);
+			result = await this.git.run({ cwd: repoPath, env: finalEnv }, ...args);
 			const sha = result.stdout.trim();
 
 			if (shouldSign) {
@@ -260,33 +260,11 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 
 			// Handle signing-specific errors
 			if (shouldSign && ex instanceof Error) {
-				const errorMessage = ex.message.toLowerCase();
-				const gitCommand: GitCommandContext = { repoPath: repoPath, args: ['commit-tree'] };
-				let signingError: SigningError | undefined;
-
-				if (errorMessage.includes('gpg failed to sign') || errorMessage.includes('error: gpg')) {
-					signingError = new SigningError({ reason: 'passphraseFailed', gitCommand: gitCommand }, ex);
-				} else if (
-					errorMessage.includes('secret key not available') ||
-					errorMessage.includes('no secret key') ||
-					errorMessage.includes('no signing key')
-				) {
-					signingError = new SigningError({ reason: 'noKey', gitCommand: gitCommand }, ex);
-				} else if (
-					errorMessage.includes('gpg: command not found') ||
-					(errorMessage.includes('gpg') && errorMessage.includes('not found'))
-				) {
-					signingError = new SigningError({ reason: 'gpgNotFound', gitCommand: gitCommand }, ex);
-				} else if (errorMessage.includes('ssh-keygen') && errorMessage.includes('not found')) {
-					signingError = new SigningError({ reason: 'sshNotFound', gitCommand: gitCommand }, ex);
-				}
-
-				if (signingError != null) {
-					this.context.hooks?.commits?.onSigningFailed?.(
-						signingError.details.reason ?? 'unknown',
-						_signingFormat,
-						options?.source,
-					);
+				const reason = classifySigningError(ex);
+				if (reason != null) {
+					const gitCommand: GitCommandContext = { repoPath: repoPath, args: ['commit-tree'] };
+					const signingError = new SigningError({ reason: reason, gitCommand: gitCommand }, ex);
+					this.context.hooks?.commits?.onSigningFailed?.(reason, _signingFormat, options?.source);
 					throw signingError;
 				}
 			}
@@ -296,19 +274,19 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 	}
 
 	async createEmptyInitialCommit(repoPath: string): Promise<string> {
-		const emptyTree = await this.git.exec({ cwd: repoPath, stdin: '' }, 'hash-object', '-t', 'tree', '--stdin');
-		const result = await this.git.exec({ cwd: repoPath }, 'commit-tree', emptyTree.stdout.trim(), '-m', 'temp');
+		const emptyTree = await this.git.run({ cwd: repoPath, stdin: '' }, 'hash-object', '-t', 'tree', '--stdin');
+		const result = await this.git.run({ cwd: repoPath }, 'commit-tree', emptyTree.stdout.trim(), '-m', 'temp');
 		// create refs/heads/main and point to it
-		await this.git.exec({ cwd: repoPath }, 'update-ref', 'refs/heads/main', result.stdout.trim());
+		await this.git.run({ cwd: repoPath }, 'update-ref', 'refs/heads/main', result.stdout.trim());
 		// point HEAD to the branch
-		await this.git.exec({ cwd: repoPath }, 'symbolic-ref', 'HEAD', 'refs/heads/main');
+		await this.git.run({ cwd: repoPath }, 'symbolic-ref', 'HEAD', 'refs/heads/main');
 		return result.stdout.trim();
 	}
 
 	@debug({ args: repoPath => ({ repoPath: repoPath }) })
 	async validatePatch(repoPath: string | undefined, contents: string): Promise<boolean> {
 		try {
-			await this.git.exec({ cwd: repoPath, configs: gitConfigsLog, stdin: contents }, 'apply', '--check', '-');
+			await this.git.run({ cwd: repoPath, configs: gitConfigsLog, stdin: contents }, 'apply', '--check', '-');
 			return true;
 		} catch (ex) {
 			if (ex instanceof RunError || ex instanceof GitError) {

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

@@ -109,7 +109,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 			const operation = sortedOperations[0];
 			switch (operation) {
 				case 'cherry-pick': {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 						'rev-parse',
 						'--quiet',
@@ -145,7 +145,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 					} satisfies GitCherryPickStatus;
 				}
 				case 'merge': {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 						'rev-parse',
 						'--quiet',
@@ -197,7 +197,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 					} satisfies GitMergeStatus;
 				}
 				case 'revert': {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 						'rev-parse',
 						'--quiet',
@@ -249,7 +249,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 						stepsMessageResult,
 						isInteractiveResult,
 					] = await Promise.allSettled([
-						this.git.exec(
+						this.git.run(
 							{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 							'rev-parse',
 							'--quiet',
@@ -479,7 +479,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 		const args = [status.type, options?.quit ? '--quit' : '--abort'];
 
 		try {
-			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -514,7 +514,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 		const args = [status.type, options?.skip ? '--skip' : '--continue'];
 
 		try {
-			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {