@gitkraken/core-gitlens 0.2.0 → 0.3.1

package/src/git/cache.ts

@@ -8,19 +8,15 @@ import type { PromiseOrValue } from '../utils/promise.js';
 import type { CacheController } from '../utils/promiseCache.js';
 import { PromiseCache, PromiseMap, RepoPromiseCacheMap } from '../utils/promiseCache.js';
 import type { Uri } from '../utils/uri.js';
-import { getBranchId } from './utils/branch.utils.js';
-import { createReference } from './utils/reference.utils.js';
-import { getCommonRepositoryPath, getRepositoryOrWorktreePath } from './utils/repository.utils.js';
-import type { GitResult } from './exec.types.js';
 import type { ProgressiveGitBlame } from './models/blame.js';
 import type { BranchMetadata, GitBranch } from './models/branch.js';
-import type { GitStashCommit } from './models/commit.js';
+import type { GitCommit, GitStashCommit } from './models/commit.js';
 import type { GitContributor, GitContributorsStats } from './models/contributor.js';
 import type { ParsedGitDiffHunks } from './models/diff.js';
 import type { GitLog } from './models/log.js';
 import type { ConflictDetectionResult } from './models/mergeConflicts.js';
 import type { GitPausedOperationStatus } from './models/pausedOperationStatus.js';
-import type { GitBranchReference } from './models/reference.js';
+import type { GitBranchReference, GitRefTip, RefRecord } from './models/reference.js';
 import type { GitRemote } from './models/remote.js';
 import type { RemoteProvider } from './models/remoteProvider.js';
 import type { GitDir, RepositoryChange } from './models/repository.js';
@@ -32,6 +28,10 @@ import type { BranchContributionsOverview, GitBranchMergedStatus } from './provi
 import type { GitCommitReachability, LeftRightCommitCountResult } from './providers/commits.js';
 import type { GitContributorsResult } from './providers/contributors.js';
 import type { ResolvedRevision } from './providers/revision.js';
+import type { GitResult } from './run.types.js';
+import { getBranchId } from './utils/branch.utils.js';
+import { createReference } from './utils/reference.utils.js';
+import { getCommonRepositoryPath, getRepositoryOrWorktreePath } from './utils/repository.utils.js';
 import type { GitIgnoreFilter } from './watching/gitIgnoreFilter.js';
 
 type RepoPath = string;
@@ -67,13 +67,23 @@ export type ConflictDetectionCacheKey = `apply:${string}:${string}:${string}` |
  * gkConfig keys that participate in the `branchOverviews` cache's mergeTarget/mergeBase lineage.
  * Capture group 1 is the ref name (which may itself contain `.`/`/`).
  */
-const branchOverviewGkConfigKeyPattern = /^branch\.(.+)\.(?:gk-merge-(?:base|target(?:-user)?)|gk-target-base)$/;
+const branchOverviewGkConfigKeysRegex = /^branch\.(.+)\.(?:gk-merge-(?:base|target(?:-user)?)|gk-target-base)$/;
+
+/**
+ * Downstream caches that `deleteGkConfig` may invalidate when a `branch.<ref>.gk-...` key changes.
+ * Callers performing a "self-write" (where the value being written matches what they just resolved,
+ * so the about-to-be-evicted entry is exactly the entry they want to preserve) can opt out by
+ * naming the targets to skip via `skipInvalidation`.
+ */
+export type GkConfigInvalidationTarget = 'branchOverviews' | 'baseBranchName';
 
 /** Per-worktree caches — cleared by repoPath directly */
 interface Caches {
 	bestRemotes: PromiseMap<RepoPath, GitRemote<RemoteProvider>[]> | undefined;
 	blame: RepoPromiseCacheMap<string, ProgressiveGitBlame | undefined> | undefined;
 	branch: PromiseMap<RepoPath, GitBranch | undefined> | undefined;
+	commit: RepoPromiseCacheMap<string, GitCommit | undefined> | undefined;
+	commitCount: RepoPromiseCacheMap<string, number | undefined> | undefined;
 	conflictDetection: RepoPromiseCacheMap<ConflictDetectionCacheKey, ConflictDetectionResult> | undefined;
 	currentBranchReference: PromiseCache<RepoPath, GitBranchReference | undefined> | undefined;
 	currentUser: Map<RepoPath, GitUser | null> | undefined;
@@ -83,8 +93,8 @@ interface Caches {
 	gitDir: Map<RepoPath, GitDir> | undefined;
 	gitIgnore: Map<RepoPath, GitIgnoreFilter> | undefined;
 	ignoreRevsFile: PromiseCache<string, boolean> | undefined;
-	lastFetched: PromiseCache<RepoPath, number | undefined> | undefined;
 	leftRightCommitCount: RepoPromiseCacheMap<string, LeftRightCommitCountResult | undefined> | undefined;
+	mergeBase: RepoPromiseCacheMap<string, string | undefined> | undefined;
 	pausedOperationStatus: PromiseMap<RepoPath, GitPausedOperationStatus | undefined> | undefined;
 	reachability: RepoPromiseCacheMap<string, GitCommitReachability | undefined> | undefined;
 	resolvedRevisions: RepoPromiseCacheMap<string, ResolvedRevision> | undefined;
@@ -105,10 +115,13 @@ interface SharedCaches {
 	contributorsStats: RepoPromiseCacheMap<string, GitContributorsStats | undefined> | undefined;
 	defaultBranchName: RepoPromiseCacheMap<string, string | undefined> | undefined;
 	gitResults: RepoPromiseCacheMap<string, GitResult> | undefined;
-	gkConfigKeys: RepoPromiseCacheMap<string, string | undefined> | undefined;
-	gkConfigPatterns: RepoPromiseCacheMap<string, Map<string, string>> | undefined;
+	gkConfigMap: PromiseMap<RepoPath, Map<string, string>> | undefined;
 	initialCommitSha: PromiseMap<RepoPath, string | undefined> | undefined;
+	/** Keyed by commonPath — `FETCH_HEAD` lives in the common git dir, shared across worktrees. */
+	lastFetched: PromiseCache<RepoPath, number | undefined> | undefined;
 	logShas: RepoPromiseCacheMap<string, string[]> | undefined;
+	refs: PromiseMap<RepoPath, RefRecord[]> | undefined;
+	refTips: PromiseMap<RepoPath, GitRefTip[]> | undefined;
 	remotes: PromiseMap<RepoPath, GitRemote[]> | undefined;
 	sharedBranches: PromiseMap<RepoPath, PagedResult<GitBranch>> | undefined;
 	stashes: RepoPromiseCacheMap<string, GitStash> | undefined;
@@ -133,10 +146,12 @@ const sharedCacheKeys: ReadonlySet<keyof AllCaches> = new Set(
 		'contributorsStats',
 		'defaultBranchName',
 		'gitResults',
-		'gkConfigKeys',
-		'gkConfigPatterns',
+		'gkConfigMap',
 		'initialCommitSha',
+		'lastFetched',
 		'logShas',
+		'refs',
+		'refTips',
 		'remotes',
 		'sharedBranches',
 		'stashes',
@@ -155,9 +170,12 @@ function createEmptyCaches(): AllCaches {
 		branchMetadataMap: undefined,
 		branchOverviews: undefined,
 		branches: undefined,
+		commit: undefined,
+		commitCount: undefined,
 		fileExistence: undefined,
 		ignoreRevsFile: undefined,
 		leftRightCommitCount: undefined,
+		mergeBase: undefined,
 		configKeys: undefined,
 		configPatterns: undefined,
 		conflictDetection: undefined,
@@ -172,14 +190,15 @@ function createEmptyCaches(): AllCaches {
 		gitDir: undefined,
 		gitIgnore: undefined,
 		gitResults: undefined,
-		gkConfigKeys: undefined,
-		gkConfigPatterns: undefined,
+		gkConfigMap: undefined,
 		initialCommitSha: undefined,
 		lastFetched: undefined,
 		logShas: undefined,
 		pausedOperationStatus: undefined,
 		resolvedRevisions: undefined,
 		reachability: undefined,
+		refs: undefined,
+		refTips: undefined,
 		remotes: undefined,
 		sharedBranches: undefined,
 		stashes: undefined,
@@ -279,12 +298,8 @@ export class Cache implements Disposable {
 		}));
 	}
 
-	private get gkConfigKeys(): RepoPromiseCacheMap<string, string | undefined> {
-		return (this._caches.gkConfigKeys ??= new RepoPromiseCacheMap<string, string | undefined>());
-	}
-
-	private get gkConfigPatterns(): RepoPromiseCacheMap<string, Map<string, string>> {
-		return (this._caches.gkConfigPatterns ??= new RepoPromiseCacheMap<string, Map<string, string>>());
+	private get gkConfigMap(): PromiseMap<RepoPath, Map<string, string>> {
+		return (this._caches.gkConfigMap ??= new PromiseMap<RepoPath, Map<string, string>>());
 	}
 
 	get currentBranchReference(): PromiseCache<RepoPath, GitBranchReference | undefined> {
@@ -364,17 +379,25 @@ export class Cache implements Disposable {
 		}));
 	}
 
-	getLeftRightCommitCount(
-		repoPath: string,
-		key: string,
-		factory: () => PromiseOrValue<LeftRightCommitCountResult | undefined>,
-	): Promise<LeftRightCommitCountResult | undefined> {
-		const cached = this.leftRightCommitCount.get(repoPath, key);
-		if (cached != null) return cached;
+	get commit(): RepoPromiseCacheMap<string, GitCommit | undefined> {
+		return (this._caches.commit ??= new RepoPromiseCacheMap<string, GitCommit | undefined>({
+			accessTTL: 1000 * 60 * 60, // 60 minutes
+			capacity: 100, // Limit to 100 commits per repo
+		}));
+	}
 
-		const factoryPromise = Promise.resolve(factory());
-		this.leftRightCommitCount.set(repoPath, key, factoryPromise);
-		return factoryPromise;
+	get commitCount(): RepoPromiseCacheMap<string, number | undefined> {
+		return (this._caches.commitCount ??= new RepoPromiseCacheMap<string, number | undefined>({
+			accessTTL: 1000 * 60 * 60, // 60 minutes
+			capacity: 50,
+		}));
+	}
+
+	get mergeBase(): RepoPromiseCacheMap<string, string | undefined> {
+		return (this._caches.mergeBase ??= new RepoPromiseCacheMap<string, string | undefined>({
+			accessTTL: 1000 * 60 * 60, // 60 minutes
+			capacity: 50,
+		}));
 	}
 
 	get logShas(): RepoPromiseCacheMap<string, string[]> {
@@ -398,6 +421,14 @@ export class Cache implements Disposable {
 		}));
 	}
 
+	get refs(): PromiseMap<RepoPath, RefRecord[]> {
+		return (this._caches.refs ??= new PromiseMap<RepoPath, RefRecord[]>());
+	}
+
+	get refTips(): PromiseMap<RepoPath, GitRefTip[]> {
+		return (this._caches.refTips ??= new PromiseMap<RepoPath, GitRefTip[]>());
+	}
+
 	get reachability(): RepoPromiseCacheMap<string, GitCommitReachability | undefined> {
 		return (this._caches.reachability ??= new RepoPromiseCacheMap<string, GitCommitReachability | undefined>({
 			accessTTL: 1000 * 60 * 60, // 60 minutes
@@ -479,9 +510,15 @@ export class Cache implements Disposable {
 				keysToClear.add('branch');
 				keysToClear.add('branchMergedStatus');
 				keysToClear.add('branchOverviews');
+				// `commit`/`commitCount` are keyed by symbolic ref or SHA — symbolic-ref entries
+				// can drift when branches move; cascade-clear conservatively.
+				keysToClear.add('commit');
+				keysToClear.add('commitCount');
 				keysToClear.add('conflictDetection');
 				keysToClear.add('currentBranchReference');
 				keysToClear.add('leftRightCommitCount');
+				// `mergeBase` keyed by ref-pairs — symbolic refs can move; cascade-clear.
+				keysToClear.add('mergeBase');
 				keysToClear.add('reachability');
 				keysToClear.add('resolvedRevisions');
 			}
@@ -495,6 +532,8 @@ export class Cache implements Disposable {
 				keysToClear.add('defaultBranchName');
 				keysToClear.add('initialCommitSha');
 				keysToClear.add('logShas');
+				keysToClear.add('refs');
+				keysToClear.add('refTips');
 			}
 
 			if (types.includes('config')) {
@@ -502,7 +541,10 @@ export class Cache implements Disposable {
 				keysToClear.add('configPatterns');
 				keysToClear.add('currentBranchReference');
 				keysToClear.add('currentUser');
-				keysToClear.add('gitDir');
+				// `gitDir` is immutable repo topology (toplevel/git-dir/common-dir/superproject) — a
+				// `.git/config` content change never relocates it, and it's owned by the repo lifecycle
+				// (registerRepoPath/unregisterRepoPath). Clearing it here forced a redundant `git rev-parse`
+				// re-spawn (gitDir is read by getGkConfigPath→getGitDir on every gk op), so leave it warm.
 			}
 
 			if (types.includes('contributors')) {
@@ -517,13 +559,12 @@ export class Cache implements Disposable {
 			}
 
 			if (types.includes('gkConfig')) {
-				keysToClear.add('gkConfigKeys');
-				keysToClear.add('gkConfigPatterns');
+				keysToClear.add('gkConfigMap');
 				// Derived from `branch.<ref>.gk-merge-base`/`vscode-merge-base`; clear so external
 				// gkConfig mutations don't leave stale base-branch resolutions cached.
 				keysToClear.add('baseBranchName');
-				// Cached overviews use Tier 1's stored merge target as their key-stability anchor;
-				// stored-target changes must invalidate or readers see stale `mergeTarget`/stats.
+				// Cached overviews are keyed by `${ref}|${mergeTarget}`; bulk gkConfig changes can
+				// affect any of the merge-target sources (stored, base, default), so clear all.
 				keysToClear.add('branchOverviews');
 			}
 
@@ -551,6 +592,8 @@ export class Cache implements Disposable {
 			}
 			if (types.includes('tags')) {
 				keysToClear.add('tags');
+				keysToClear.add('refs');
+				keysToClear.add('refTips');
 			}
 
 			if (types.includes('tracking')) {
@@ -587,12 +630,14 @@ export class Cache implements Disposable {
 					invalidate.call(cache, commonPath);
 					for (const worktreePath of this.getWorktreePaths(commonPath)) {
 						if (worktreePath === commonPath) continue;
+
 						invalidate.call(cache, worktreePath);
 					}
 				} else {
 					cache.delete(commonPath);
 					for (const worktreePath of this.getWorktreePaths(commonPath)) {
 						if (worktreePath === commonPath) continue;
+
 						cache.delete(worktreePath);
 					}
 				}
@@ -825,14 +870,18 @@ export class Cache implements Disposable {
 				// On factory invalidation, propagate to the derived per-worktree mapper entries
 				// via soft-invalidate — existing waiters on the mapper complete, and the entry
 				// self-evicts on mapper settle so the next callers build fresh derived entries.
-				void p.finally(() => {
-					if (cacheable.invalidated) {
-						this.branches.invalidate(commonPath);
-						for (const worktreePath of this.getWorktreePaths(commonPath)) {
-							this.branches.invalidate(worktreePath);
+				void p
+					.finally(() => {
+						if (cacheable.invalidated) {
+							this.branches.invalidate(commonPath);
+							for (const worktreePath of this.getWorktreePaths(commonPath)) {
+								this.branches.invalidate(worktreePath);
+							}
 						}
-					}
-				});
+					})
+					// Swallow the cleanup chain's rejection so a rejected factory (e.g. cancellation)
+					// doesn't surface as an unhandled rejection; the caller-facing promise handles it.
+					.catch(() => {});
 				return p;
 			},
 			cancellation,
@@ -894,49 +943,56 @@ export class Cache implements Disposable {
 		this._caches.configPatterns?.delete(cacheKey);
 	}
 
-	getGkConfig(
-		repoPath: string,
-		key: string,
-		factory: () => PromiseOrValue<string | undefined>,
-	): Promise<string | undefined> {
-		const cacheKey = this.getCommonPath(repoPath);
-
-		const result = this.gkConfigKeys.get(cacheKey, key);
-		if (result != null) return result;
-
-		const factoryPromise = Promise.resolve(factory());
-		this.gkConfigKeys.set(cacheKey, key, factoryPromise);
-		return factoryPromise;
+	/**
+	 * The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
+	 * per-namespace gk lookups are served from it in-memory (see `getGkConfigMap` in the CLI config
+	 * sub-provider). Invalidated by `deleteGkConfig` (write) and the coarse `'gkConfig'` clear (watcher).
+	 */
+	getGkConfigMap(repoPath: string, factory: () => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>> {
+		return this.getSharedSimple(this.gkConfigMap, repoPath, factory);
 	}
 
-	getGkConfigRegex(
+	/**
+	 * Clears the cached `.git/gk/config` map and invalidates the derived caches
+	 * (`baseBranchName`/`branchOverviews`) for the written key's ref.
+	 *
+	 * @param options.skipInvalidation Downstream caches the caller wants preserved despite this
+	 * write. Use when the value being written is exactly what was just resolved — e.g. the Tier 2
+	 * `storeMergeTargetBranchName` self-write inside `getBranchContributionsOverview` (skip
+	 * `'branchOverviews'`) or the Tier 3 `storeBaseBranchName` self-write inside `getBaseBranchName`
+	 * (skip both `'baseBranchName'` and `'branchOverviews'`). The bulk `gkConfigMap` map always
+	 * invalidates so subsequent reads see the new value.
+	 */
+	deleteGkConfig(
 		repoPath: string,
-		pattern: string,
-		factory: () => PromiseOrValue<Map<string, string>>,
-	): Promise<Map<string, string>> {
+		key: string,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): void {
 		const cacheKey = this.getCommonPath(repoPath);
+		this._caches.gkConfigMap?.delete(cacheKey);
 
-		const result = this.gkConfigPatterns.get(cacheKey, pattern);
-		if (result != null) return result;
+		const refMatch = key.match(branchOverviewGkConfigKeysRegex);
+		if (refMatch == null) return;
 
-		const factoryPromise = Promise.resolve(factory());
-		this.gkConfigPatterns.set(cacheKey, pattern, factoryPromise);
-		return factoryPromise;
-	}
+		const ref = refMatch[1];
+		const skip = options?.skipInvalidation;
 
-	deleteGkConfig(repoPath: string, key: string): void {
-		const cacheKey = this.getCommonPath(repoPath);
-		this._caches.gkConfigKeys?.delete(cacheKey, key);
-		this._caches.gkConfigPatterns?.delete(cacheKey);
+		// `getBaseBranchName` reads `branch.<ref>.gk-merge-base` and caches the resolved value
+		// per-ref. A write to that key must invalidate the cached base or Tier 3 of
+		// `getBranchContributionsOverview` will resolve `mergeTarget` against the pre-write value.
+		if (key.endsWith('.gk-merge-base') && !skip?.includes('baseBranchName')) {
+			this._caches.baseBranchName?.delete(cacheKey, ref);
+		}
+
+		if (skip?.includes('branchOverviews')) return;
 
 		// When the change affects a branch's merge-target/base lineage, invalidate that branch's
-		// cached overview so subsequent reads pick up the new stored value rather than stale data.
-		// `getBranchContributionsOverview` keys `branchOverviews` by ref, with Tier 1's stored
-		// target as the key-stability anchor — so any write to those keys must invalidate.
-		const refMatch = key.match(branchOverviewGkConfigKeyPattern);
-		if (refMatch != null) {
-			this._caches.branchOverviews?.delete(cacheKey, refMatch[1]);
-		}
+		// cached overviews so subsequent reads pick up the new stored value rather than stale data.
+		// `getBranchContributionsOverview` keys `branchOverviews` by `${ref}|${mergeTarget}`, so
+		// invalidate every entry for the affected ref regardless of which target it resolved to.
+		// Uses `invalidateByKeyPrefix` (not `deleteByKeyPrefix`) so an in-flight factory is still
+		// shared with new callers instead of triggering a duplicate fetch.
+		this._caches.branchOverviews?.invalidateByKeyPrefix(cacheKey, `${ref}|`);
 	}
 
 	async getBranchOverview(
@@ -1094,6 +1150,42 @@ export class Cache implements Disposable {
 		return this.getSharedSimple(this.lastFetched, repoPath, factory);
 	}
 
+	getRefs(
+		repoPath: string,
+		factory: (
+			commonPath: string,
+			cacheable: CacheController,
+			cancellation?: AbortSignal,
+		) => PromiseOrValue<RefRecord[]>,
+		cancellation?: AbortSignal,
+	): Promise<RefRecord[]> {
+		// Raw ref records are repoPath-agnostic (no per-worktree binding to remap), so we key only
+		// by commonPath and skip the per-worktree mapper that `getBranches`/`getTags` need.
+		const commonPath = this.getCommonPath(repoPath);
+		return this.refs.getOrCreate(
+			commonPath,
+			(cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)),
+			cancellation,
+		);
+	}
+
+	getRefTips(
+		repoPath: string,
+		factory: (
+			commonPath: string,
+			cacheable: CacheController,
+			cancellation?: AbortSignal,
+		) => PromiseOrValue<GitRefTip[]>,
+		cancellation?: AbortSignal,
+	): Promise<GitRefTip[]> {
+		const commonPath = this.getCommonPath(repoPath);
+		return this.refTips.getOrCreate(
+			commonPath,
+			(cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)),
+			cancellation,
+		);
+	}
+
 	async getRemotes(
 		repoPath: string,
 		factory: (
@@ -1196,14 +1288,19 @@ export class Cache implements Disposable {
 				// On factory invalidation (without rejection), propagate to the derived per-worktree
 				// mapper entries so they don't persist past the shared factory's settle. Mapper
 				// entries cached via `cache.set()` have no controller, so `invalidate` hard-deletes.
-				void p.finally(() => {
-					if (cacheable.invalidated) {
-						for (const worktreePath of this.getWorktreePaths(commonPath)) {
-							if (worktreePath === commonPath) continue;
-							cache.invalidate(worktreePath);
+				void p
+					.finally(() => {
+						if (cacheable.invalidated) {
+							for (const worktreePath of this.getWorktreePaths(commonPath)) {
+								if (worktreePath === commonPath) continue;
+
+								cache.invalidate(worktreePath);
+							}
 						}
-					}
-				});
+					})
+					// Swallow the cleanup chain's rejection so a rejected factory (e.g. cancellation)
+					// doesn't surface as an unhandled rejection; the caller-facing promise handles it.
+					.catch(() => {});
 				return p;
 			},
 			cancellation,
@@ -1252,14 +1349,19 @@ export class Cache implements Disposable {
 				// mapper entries for this `cacheKey` so they don't persist past the shared factory's
 				// settle. Mapper entries cached via `cache.set()` have no controller, so `invalidate`
 				// hard-deletes.
-				void p.finally(() => {
-					if (cacheable.invalidated) {
-						for (const worktreePath of this.getWorktreePaths(commonPath)) {
-							if (worktreePath === commonPath) continue;
-							cache.invalidate(worktreePath, cacheKey);
+				void p
+					.finally(() => {
+						if (cacheable.invalidated) {
+							for (const worktreePath of this.getWorktreePaths(commonPath)) {
+								if (worktreePath === commonPath) continue;
+
+								cache.invalidate(worktreePath, cacheKey);
+							}
 						}
-					}
-				});
+					})
+					// Swallow the cleanup chain's rejection so a rejected factory (e.g. cancellation)
+					// doesn't surface as an unhandled rejection; the caller-facing promise handles it.
+					.catch(() => {});
 				return p;
 			},
 			options,

package/src/git/context.ts

@@ -85,6 +85,27 @@ export interface GitServiceConfig {
 		/** Maximum search items (0 = unlimited). */
 		readonly maxSearchItems?: number;
 	};
+
+	/** Force-push preferences. */
+	readonly push?: {
+		/** Whether to use `--force-with-lease` instead of a plain `--force` when force-pushing. Defaults to `true`. */
+		readonly useForceWithLease?: boolean;
+		/**
+		 * Whether to add `--force-if-includes` when force-pushing. Only applies when `useForceWithLease` is `true`
+		 * and the installed Git supports it. Defaults to `true`.
+		 */
+		readonly useForceIfIncludes?: boolean;
+	};
+
+	/** Commit-signing preferences. */
+	readonly signing?: {
+		/**
+		 * Host-level override for whether commit signing is enabled (e.g. VS Code's `git.enableCommitSigning`).
+		 * When `true`, signing is treated as enabled even if the repo's `commit.gpgsign` is unset/false. It never
+		 * forces signing off.
+		 */
+		readonly enabled?: boolean;
+	};
 }
 
 /** Git command types that can produce conflicts. */

package/src/git/features.ts

@@ -1,5 +1,6 @@
 // GitFeature's must start with `git:` to be recognized in all usages
 export type GitFeatures =
+	| 'git:checkout:pathspec-from-file'
 	| 'git:for-each-ref:worktreePath'
 	| 'git:ignoreRevsFile'
 	| 'git:merge-tree'
@@ -28,6 +29,7 @@ export type FilteredGitFeatures<T extends GitFeatureOrPrefix> = T extends GitFea
 
 export const gitMinimumVersion = '2.7.2';
 export const gitFeaturesByVersion = new Map<GitFeatures, string>([
+	['git:checkout:pathspec-from-file', '2.26'],
 	['git:for-each-ref:worktreePath', '2.23'],
 	['git:ignoreRevsFile', '2.23'],
 	['git:merge-tree', '2.33'],

package/src/git/models/commit.ts

@@ -521,6 +521,7 @@ export class GitCommit implements GitRevisionReference {
 
 	protected computeFileStats(): void {
 		if (!this._recomputeStats || this._fileset == null) return;
+
 		this._recomputeStats = false;
 
 		const changedFiles = { added: 0, deleted: 0, changed: 0 };