@gitkraken/core-gitlens 0.5.109 → 0.5.111

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

@@ -24,7 +24,7 @@ import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { Git } from '../exec/git.js';
 import { getGitCommandError } from '../exec/git.js';
 
-const todoCommitRegex = /^(?:p(?:ick)?|revert)\s+([a-f0-9]+)/i;
+const todoCommitRegex = /^(?:p(?:ick)?|revert)\s+([a-f0-9]+)(?:\s+(.+))?$/i;
 
 type Operation = 'cherry-pick' | 'merge' | 'rebase-apply' | 'rebase-merge' | 'revert' | 'sequencer';
 
@@ -134,22 +134,25 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 						return undefined;
 					}
 
-					const [branchResult, mergeBaseResult] = await Promise.allSettled([
+					const [branchResult, mergeBaseResult, messageResult] = await Promise.allSettled([
 						this.provider.branches.getCurrentBranchReference(repoPath, cancellation),
 						this.provider.refs.getMergeBase(repoPath, 'CHERRY_PICK_HEAD', 'HEAD', undefined, cancellation),
+						this.getCommitMessage(repoPath, cherryPickHead, cancellation),
 					]);
 					if (cancellation?.aborted) throw new CancellationError();
 
 					const current = getSettledValue(branchResult)!;
 					const mergeBase = getSettledValue(mergeBaseResult);
+					// Names the commit being applied, so consumers can say which one a skip would drop
+					const message = getSettledValue(messageResult);
 
 					return {
 						type: 'cherry-pick',
 						repoPath: repoPath,
 						mergeBase: mergeBase,
-						HEAD: createReference(cherryPickHead, repoPath, { refType: 'revision' }),
+						HEAD: createReference(cherryPickHead, repoPath, { refType: 'revision', message: message }),
 						current: current,
-						incoming: createReference(cherryPickHead, repoPath, { refType: 'revision' }),
+						incoming: createReference(cherryPickHead, repoPath, { refType: 'revision', message: message }),
 					} satisfies GitCherryPickStatus;
 				}
 				case 'merge': {
@@ -222,22 +225,25 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 						return undefined;
 					}
 
-					const [branchResult, mergeBaseResult] = await Promise.allSettled([
+					const [branchResult, mergeBaseResult, messageResult] = await Promise.allSettled([
 						this.provider.branches.getCurrentBranchReference(repoPath, cancellation),
 						this.provider.refs.getMergeBase(repoPath, 'REVERT_HEAD', 'HEAD', undefined, cancellation),
+						this.getCommitMessage(repoPath, revertHead, cancellation),
 					]);
 					if (cancellation?.aborted) throw new CancellationError();
 
 					const current = getSettledValue(branchResult)!;
 					const mergeBase = getSettledValue(mergeBaseResult);
+					// Names the commit being reverted, so consumers can say which one a skip would drop
+					const message = getSettledValue(messageResult);
 
 					return {
 						type: 'revert',
 						repoPath: repoPath,
 						mergeBase: mergeBase,
-						HEAD: createReference(revertHead, repoPath, { refType: 'revision' }),
+						HEAD: createReference(revertHead, repoPath, { refType: 'revision', message: message }),
 						current: current,
-						incoming: createReference(revertHead, repoPath, { refType: 'revision' }),
+						incoming: createReference(revertHead, repoPath, { refType: 'revision', message: message }),
 					} satisfies GitRevertStatus;
 				}
 				case 'rebase-apply':
@@ -407,6 +413,10 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 						return undefined;
 					}
 
+					// The todo line carries only the commit's SUBJECT (the other producers carry the full
+					// message) — good enough to name the commit a skip would drop, without another git call
+					const message = match?.[2]?.trim() || undefined;
+
 					const [branchResult, mergeBaseResult] = await Promise.allSettled([
 						this.provider.branches.getCurrentBranchReference(repoPath, cancellation),
 						this.provider.refs.getMergeBase(repoPath, currentCommitSha, 'HEAD', undefined, cancellation),
@@ -421,9 +431,15 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 							type: 'cherry-pick',
 							repoPath: repoPath,
 							mergeBase: mergeBase,
-							HEAD: createReference(currentCommitSha, repoPath, { refType: 'revision' }),
+							HEAD: createReference(currentCommitSha, repoPath, {
+								refType: 'revision',
+								message: message,
+							}),
 							current: current,
-							incoming: createReference(currentCommitSha, repoPath, { refType: 'revision' }),
+							incoming: createReference(currentCommitSha, repoPath, {
+								refType: 'revision',
+								message: message,
+							}),
 						} satisfies GitCherryPickStatus;
 					}
 
@@ -431,9 +447,12 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 						type: 'revert',
 						repoPath: repoPath,
 						mergeBase: mergeBase,
-						HEAD: createReference(currentCommitSha, repoPath, { refType: 'revision' }),
+						HEAD: createReference(currentCommitSha, repoPath, { refType: 'revision', message: message }),
 						current: current,
-						incoming: createReference(currentCommitSha, repoPath, { refType: 'revision' }),
+						incoming: createReference(currentCommitSha, repoPath, {
+							refType: 'revision',
+							message: message,
+						}),
 					} satisfies GitRevertStatus;
 				}
 			}
@@ -442,6 +461,33 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 		return status;
 	}
 
+	/** Memoized per repo by sha — forced status re-reads on FS noise (every file save while resolving
+	 *  conflicts) would otherwise re-spawn `git log` for an unchanging commit. */
+	private readonly _commitMessageCache = new Map<string, { sha: string; message: string | undefined }>();
+
+	private async getCommitMessage(
+		repoPath: string,
+		sha: string,
+		cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		const cached = this._commitMessageCache.get(repoPath);
+		if (cached?.sha === sha) return cached.message;
+
+		const result = await this.git.run(
+			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
+			'log',
+			'-1',
+			'--format=%B',
+			sha,
+		);
+		const message = result.stdout.trim() || undefined;
+		// Don't cache a miss — a transient failure would otherwise stick for the operation's lifetime
+		if (message != null) {
+			this._commitMessageCache.set(repoPath, { sha: sha, message: message });
+		}
+		return message;
+	}
+
 	private async readDotGitFile(
 		gitDir: GitDir,
 		pathParts: string[],
@@ -487,7 +533,9 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 		const args = [status.type, options?.quit ? '--quit' : '--abort'];
 
 		try {
-			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
+			// Unbounded like the operations it undoes — an abort of a large rebase can outrun the default
+			// command timeout, and being SIGTERM'd partway through would leave the repo mid-abort.
+			await this.git.run({ cwd: repoPath, errors: 'throw', timeout: 0 }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -511,7 +559,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 	@debug()
 	async continuePausedOperation(
 		repoPath: string,
-		options?: { skip?: boolean; messageEditor?: string },
+		options?: { allowEmpty?: boolean; skip?: boolean; messageEditor?: string },
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -535,12 +583,42 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 		}
 
 		try {
+			if (options?.allowEmpty) {
+				const commitArgs = ['commit', '--allow-empty', '--no-edit'];
+				try {
+					// Git won't record the empty commit on its own; making it explicitly (`--no-edit` reuses the
+					// message git already prepared) is what lets the operation move past it.
+					await this.git.run({ cwd: repoPath, errors: 'throw' }, ...commitArgs);
+				} catch (ex) {
+					scope?.error(ex);
+					// Same reason taxonomy, but attributed to the commit that actually failed
+					throw getGitCommandError(
+						'paused-operation-continue',
+						ex,
+						reason =>
+							new PausedOperationContinueError(
+								{
+									reason: reason,
+									operation: status,
+									skip: false,
+									gitCommand: { repoPath: repoPath, args: commitArgs },
+								},
+								ex,
+							),
+					);
+				}
+			}
+
 			await this.git.run(
 				{
 					cwd: repoPath,
 					errors: 'throw',
 					configs: configs,
 					env: env,
+					// A `--continue` that opens the commit-message editor blocks for as long as the user leaves
+					// that tab open, which is unbounded — the default `advanced.git.timeout` would SIGTERM it
+					// mid-operation. The start paths (merge/rebase/revert) opt out for the same reason.
+					timeout: 0,
 					// The runner dedups in-flight commands by args only — it ignores per-call `configs`/`env`.
 					// A headless continue (with `GIT_EDITOR`) and a plain `--continue` would therefore collapse
 					// into one execution, so the plain one could silently run headless (auto-accepting a commit
@@ -550,11 +628,10 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 				},
 				...args,
 			);
-			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
-			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
-			scope?.error(ex);
-			throw getGitCommandError(
+			if (PausedOperationContinueError.is(ex)) throw ex;
+
+			const error = getGitCommandError(
 				'paused-operation-continue',
 				ex,
 				reason =>
@@ -568,6 +645,21 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 						ex,
 					),
 			);
+
+			// An empty commit concludes a single-commit cherry-pick/revert outright, leaving its
+			// `--continue` nothing to continue — the operation finished either way.
+			if (!options?.allowEmpty || !PausedOperationContinueError.is(error, 'nothingToContinue')) {
+				scope?.error(ex);
+				throw error;
+			}
+		} finally {
+			// Notify unconditionally rather than only on success: a throwing `--continue` can still have
+			// mutated the repo (committing the resolved step, then stopping on the NEXT step's conflict or
+			// empty commit), and the error alone can't distinguish that from a no-op failure. Invalidating
+			// after a genuine no-op only costs a re-read; not invalidating after a real advance leaves
+			// consumers rendering a stale step.
+			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
+			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		}
 	}
 }

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

@@ -42,17 +42,30 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	}
 
 	/**
-	 * Raw `git for-each-ref` records covering branches, remotes, and tags in a single pass.
-	 * CLI-internal — siblings call via `this.provider.refs.getRefs(...)`. The `RefRecord` shape
+	 * Raw `git for-each-ref` records covering branches, remotes, tags, and replace-refs in a single
+	 * pass. CLI-internal — siblings call via `this.provider.refs.getRefs(...)`. The `RefRecord` shape
 	 * is `for-each-ref`-specific and intentionally absent from the public `GitRefsSubProvider`
 	 * interface.
 	 */
 	@debug()
-	async getRefs(repoPath: string, cancellation?: AbortSignal): Promise<RefRecord[]> {
+	async getRefs(repoPath: string, cancellation?: AbortSignal, options?: { force?: boolean }): Promise<RefRecord[]> {
 		if (!repoPath) return [];
 
 		const scope = getScopedLogger();
 
+		// Forces a fresh enumeration: evicts the shared cache entry (and the derived `refTips` projection,
+		// which would otherwise still answer from the old records) so the factory below re-runs and
+		// repopulates both from one spawn. Deliberately `delete`, not `invalidate` — soft-invalidation
+		// leaves an in-flight entry rideable, so a caller needing a point-in-time read (the graph's tip
+		// gate) could join an enumeration that started before the change it's trying to detect. Evicting
+		// is safe mid-flight: the in-flight factory's settle is ownership-guarded and won't evict the
+		// successor installed here.
+		if (options?.force) {
+			const commonPath = this.cache.getCommonPath(repoPath);
+			this.cache.refs.delete(commonPath);
+			this.cache.refTips.delete(commonPath);
+		}
+
 		return this.cache.getRefs(
 			repoPath,
 			async (commonPath, cacheable, signal) => {
@@ -66,7 +79,24 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 						'refs/heads/',
 						'refs/remotes/',
 						'refs/tags/',
+						// `git replace`/grafts — not surfaced to branch/tag/refTip consumers (filtered by
+						// refname prefix), but needed by the graph's replace-ref change gate (graph.ts).
+						'refs/replace/',
 					);
+					// Under `errors: 'ignore'` a cancelled run RESOLVES empty rather than throwing, so the
+					// catch below never sees it and an empty enumeration would be cached as a real answer —
+					// permanently, since this map has no TTL. Same guard `git.run`'s own caching path uses.
+					// The graph's tip gate calls this with `force: true` and supersedes itself freely, so it
+					// is routinely the sole registrant on the aggregate whose abort kills the spawn.
+					// Covers a FAILED enumeration too, not just a cancelled one: a transient `for-each-ref`
+					// failure (a lingering `index.lock`, EMFILE, the git dir briefly unavailable) also
+					// resolves empty, and caching that `[]` would blank every branch, tag and ref-tip
+					// consumer for the rest of the session. A genuinely ref-less repo still exits cleanly
+					// with empty stdout, so it caches as before.
+					if (result.completion.status !== 'exited' || result.exitCode !== 0 || signal?.aborted) {
+						cacheable?.invalidate();
+						return [];
+					}
 					if (!result?.stdout) return [];
 
 					using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });

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

@@ -286,7 +286,13 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 	@debug()
 	hasWorkingChanges(
 		repoPath: string,
-		options?: { staged?: boolean; unstaged?: boolean; untracked?: boolean; throwOnError?: boolean },
+		options?: {
+			staged?: boolean;
+			unstaged?: boolean;
+			untracked?: boolean;
+			throwOnError?: boolean;
+			priority?: GitCommandPriority;
+		},
 		cancellation?: AbortSignal,
 	): Promise<boolean> {
 		const scope = getScopedLogger();
@@ -296,16 +302,28 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 		const untracked = options?.untracked ?? true;
 		// `throwOnError` is in the key because it changes the RESULT on git failure (throw vs `false`) — a
 		// throwing caller must not join, and be silently satisfied by, a non-throwing caller's graceful run.
+		// `priority` is in the key for a different reason: it doesn't change the answer, but a joiner INHERITS
+		// the in-flight run's scheduling. `GitQueue` refuses to start background work while anything is
+		// waiting at normal/interactive, so letting a foreground caller (the overview's dirty pill, the
+		// Worktrees view) join a `background` probe would strand it for the whole graph load. Splitting the
+		// two lanes costs at most one extra spawn; joining costs unbounded foreground latency.
 		const throwOnError = options?.throwOnError ?? false;
+		const priority = options?.priority ?? 'default';
 
 		return this.dedupeByStatusGeneration(
 			repoPath,
-			`hasWorkingChanges:${staged}:${unstaged}:${untracked}:${throwOnError}`,
+			`hasWorkingChanges:${staged}:${unstaged}:${untracked}:${throwOnError}:${priority}`,
 			async (correlationKey, signal) => {
 				try {
 					if (staged || unstaged) {
 						const result = await this.git.run(
-							{ cwd: repoPath, cancellation: signal, errors: 'ignore', correlationKey: correlationKey },
+							{
+								cwd: repoPath,
+								cancellation: signal,
+								errors: 'ignore',
+								correlationKey: correlationKey,
+								...(options?.priority != null ? { priority: options.priority } : undefined),
+							},
 							'diff',
 							'--quiet',
 							staged && unstaged ? 'HEAD' : staged ? '--staged' : undefined,
@@ -322,7 +340,10 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 						}
 					}
 
-					// Check for untracked files
+					// Check for untracked files. NOTE: this runs through `git.stream`, which spawns directly
+					// and never enters the queue — so `priority` above doesn't reach it. Only clean worktrees
+					// get this far (a dirty one already returned above), and callers fanning out across many
+					// worktrees are expected to bound their own concurrency.
 					if (untracked) {
 						const hasUntracked = await this.hasUntrackedFiles(repoPath, signal);
 						if (hasUntracked) {

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

@@ -65,6 +65,11 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 		try {
 			await this.git.run({ cwd: repoPath }, ...args);
 
+			if (options?.createBranch) {
+				// Evict the cached base only — see `checkout -b` for why the persisted keys are left alone.
+				this.cache.deleteBaseBranchName(repoPath, options.createBranch);
+			}
+
 			this.context.hooks?.cache?.onReset?.(
 				repoPath,
 				...(options?.createBranch ? (['branches', 'worktrees'] as const) : (['worktrees'] as const)),

package/src/git-cli/service.ts

@@ -78,6 +78,5 @@ export function createCliGitService(options: CliGitServiceOptions): GitService {
 	// miss. Subscriptions are torn down with the service (its `watchService`'s emitters are disposed on dispose).
 	service.watchService?.onDidChangeWorkingTree(repoPath => provider.cache.onWorkingTreeChanged(repoPath));
 	service.watchService?.onDidChangeRepository(e => provider.cache.onRepositoryChanged(e.repoPath, e.changes));
-
 	return service;
 }