@gitkraken/core-gitlens 0.1.0 → 0.2.0

package/src/git/cache.ts

@@ -8,10 +8,12 @@ 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 { GitBranch } from './models/branch.js';
+import type { BranchMetadata, GitBranch } from './models/branch.js';
 import type { GitStashCommit } from './models/commit.js';
 import type { GitContributor, GitContributorsStats } from './models/contributor.js';
 import type { ParsedGitDiffHunks } from './models/diff.js';
@@ -26,6 +28,7 @@ import type { GitStash } from './models/stash.js';
 import type { GitTag } from './models/tag.js';
 import type { GitUser } from './models/user.js';
 import type { GitWorktree } from './models/worktree.js';
+import type { BranchContributionsOverview, GitBranchMergedStatus } from './providers/branches.js';
 import type { GitCommitReachability, LeftRightCommitCountResult } from './providers/commits.js';
 import type { GitContributorsResult } from './providers/contributors.js';
 import type { ResolvedRevision } from './providers/revision.js';
@@ -49,6 +52,7 @@ export type CachedGitTypes =
 	| 'contributors'
 	| 'gitignore'
 	| 'gkConfig'
+	| 'lastFetched'
 	| 'providers'
 	| 'remotes'
 	| 'stashes'
@@ -59,6 +63,12 @@ export type CachedGitTypes =
 
 export type ConflictDetectionCacheKey = `apply:${string}:${string}:${string}` | `merge:${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)$/;
+
 /** Per-worktree caches — cleared by repoPath directly */
 interface Caches {
 	bestRemotes: PromiseMap<RepoPath, GitRemote<RemoteProvider>[]> | undefined;
@@ -83,6 +93,10 @@ interface Caches {
 
 /** Shared caches — cleared via commonPath + all worktree paths */
 interface SharedCaches {
+	baseBranchName: RepoPromiseCacheMap<string, string | undefined> | undefined;
+	branchMergedStatus: RepoPromiseCacheMap<string, GitBranchMergedStatus> | undefined;
+	branchMetadataMap: PromiseMap<RepoPath, Map<string, BranchMetadata>> | undefined;
+	branchOverviews: RepoPromiseCacheMap<string, BranchContributionsOverview | undefined> | undefined;
 	branches: PromiseMap<RepoPath, PagedResult<GitBranch>> | undefined;
 	configKeys: RepoPromiseCacheMap<string, string | undefined> | undefined;
 	configPatterns: RepoPromiseCacheMap<string, Map<string, string>> | undefined;
@@ -97,7 +111,7 @@ interface SharedCaches {
 	logShas: RepoPromiseCacheMap<string, string[]> | undefined;
 	remotes: PromiseMap<RepoPath, GitRemote[]> | undefined;
 	sharedBranches: PromiseMap<RepoPath, PagedResult<GitBranch>> | undefined;
-	stashes: PromiseMap<RepoPath, GitStash> | undefined;
+	stashes: RepoPromiseCacheMap<string, GitStash> | undefined;
 	tags: PromiseMap<RepoPath, PagedResult<GitTag>> | undefined;
 	worktrees: PromiseMap<RepoPath, GitWorktree[]> | undefined;
 }
@@ -107,6 +121,10 @@ type AllCaches = Caches & SharedCaches;
 /** Compile-time enforced: adding a key to SharedCaches without listing it here is a type error */
 const sharedCacheKeys: ReadonlySet<keyof AllCaches> = new Set(
 	exhaustiveArray<keyof SharedCaches>()([
+		'baseBranchName',
+		'branchMergedStatus',
+		'branchMetadataMap',
+		'branchOverviews',
 		'branches',
 		'configKeys',
 		'configPatterns',
@@ -129,9 +147,13 @@ const sharedCacheKeys: ReadonlySet<keyof AllCaches> = new Set(
 
 function createEmptyCaches(): AllCaches {
 	return {
+		baseBranchName: undefined,
 		bestRemotes: undefined,
 		blame: undefined,
 		branch: undefined,
+		branchMergedStatus: undefined,
+		branchMetadataMap: undefined,
+		branchOverviews: undefined,
 		branches: undefined,
 		fileExistence: undefined,
 		ignoreRevsFile: undefined,
@@ -206,10 +228,33 @@ export class Cache implements Disposable {
 		}));
 	}
 
+	private get baseBranchName(): RepoPromiseCacheMap<string, string | undefined> {
+		return (this._caches.baseBranchName ??= new RepoPromiseCacheMap<string, string | undefined>());
+	}
+
 	get branch(): PromiseMap<RepoPath, GitBranch | undefined> {
 		return (this._caches.branch ??= new PromiseMap<RepoPath, GitBranch | undefined>());
 	}
 
+	get branchMergedStatus(): RepoPromiseCacheMap<string, GitBranchMergedStatus> {
+		return (this._caches.branchMergedStatus ??= new RepoPromiseCacheMap<string, GitBranchMergedStatus>({
+			createTTL: 1000 * 60 * 5, // 5 minutes
+		}));
+	}
+
+	private get branchMetadataMap(): PromiseMap<RepoPath, Map<string, BranchMetadata>> {
+		return (this._caches.branchMetadataMap ??= new PromiseMap<RepoPath, Map<string, BranchMetadata>>());
+	}
+
+	private get branchOverviews(): RepoPromiseCacheMap<string, BranchContributionsOverview | undefined> {
+		return (this._caches.branchOverviews ??= new RepoPromiseCacheMap<
+			string,
+			BranchContributionsOverview | undefined
+		>(
+			{ accessTTL: 1000 * 60 * 60 }, // 60 minutes
+		));
+	}
+
 	get branches(): PromiseMap<RepoPath, PagedResult<GitBranch>> {
 		return (this._caches.branches ??= new PromiseMap<RepoPath, PagedResult<GitBranch>>());
 	}
@@ -364,8 +409,10 @@ export class Cache implements Disposable {
 		return (this._caches.remotes ??= new PromiseMap<RepoPath, GitRemote[]>());
 	}
 
-	get stashes(): PromiseMap<RepoPath, GitStash> {
-		return (this._caches.stashes ??= new PromiseMap<RepoPath, GitStash>());
+	get stashes(): RepoPromiseCacheMap<string, GitStash> {
+		return (this._caches.stashes ??= new RepoPromiseCacheMap<string, GitStash>({
+			accessTTL: 1000 * 60 * 60, // 60 minutes
+		}));
 	}
 
 	get tags(): PromiseMap<RepoPath, PagedResult<GitTag>> {
@@ -424,9 +471,14 @@ export class Cache implements Disposable {
 				keysToClear.add('fileLog');
 			}
 
-			// Per-worktree branch caches (current branch / HEAD sensitive)
+			// Branch caches affected by HEAD/heads changes — `branchMergedStatus` is shared
+			// (the answer is invariant across worktrees of the same common repo) but is invalidated
+			// here because branch-tip movement in any worktree can change the merge status; the
+			// shared-clear logic below routes shared keys via commonPath.
 			if (types.includes('branch') || types.includes('branches')) {
 				keysToClear.add('branch');
+				keysToClear.add('branchMergedStatus');
+				keysToClear.add('branchOverviews');
 				keysToClear.add('conflictDetection');
 				keysToClear.add('currentBranchReference');
 				keysToClear.add('leftRightCommitCount');
@@ -436,6 +488,8 @@ export class Cache implements Disposable {
 
 			// Shared branch caches (branch list, metadata)
 			if (types.includes('branches')) {
+				keysToClear.add('baseBranchName');
+				keysToClear.add('branchMetadataMap');
 				keysToClear.add('branches');
 				keysToClear.add('sharedBranches');
 				keysToClear.add('defaultBranchName');
@@ -452,6 +506,7 @@ export class Cache implements Disposable {
 			}
 
 			if (types.includes('contributors')) {
+				keysToClear.add('branchOverviews');
 				keysToClear.add('contributors');
 				keysToClear.add('contributorsLite');
 				keysToClear.add('contributorsStats');
@@ -464,6 +519,16 @@ export class Cache implements Disposable {
 			if (types.includes('gkConfig')) {
 				keysToClear.add('gkConfigKeys');
 				keysToClear.add('gkConfigPatterns');
+				// 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.
+				keysToClear.add('branchOverviews');
+			}
+
+			if (types.includes('lastFetched')) {
+				keysToClear.add('lastFetched');
 			}
 
 			if (types.includes('providers')) {
@@ -700,6 +765,10 @@ export class Cache implements Disposable {
 			types.add('gkConfig');
 		}
 
+		if (hasAny('lastFetched')) {
+			types.add('lastFetched');
+		}
+
 		if (hasAny('remoteProviders')) {
 			types.add('providers');
 		}
@@ -859,6 +928,42 @@ export class Cache implements Disposable {
 		const cacheKey = this.getCommonPath(repoPath);
 		this._caches.gkConfigKeys?.delete(cacheKey, key);
 		this._caches.gkConfigPatterns?.delete(cacheKey);
+
+		// 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]);
+		}
+	}
+
+	async getBranchOverview(
+		repoPath: string,
+		cacheKey: string,
+		factory: (
+			commonPath: string,
+			cacheable: CacheController,
+			cancellation?: AbortSignal,
+		) => PromiseOrValue<BranchContributionsOverview | undefined>,
+		options?: { accessTTL?: number; cancellation?: AbortSignal },
+	): Promise<BranchContributionsOverview | undefined> {
+		return this.getSharedOrCreateWithKey(
+			this.branchOverviews,
+			repoPath,
+			cacheKey,
+			factory,
+			(data, newRepoPath) =>
+				data == null
+					? data
+					: {
+							...data,
+							repoPath: newRepoPath,
+							contributors: data.contributors.map(c => c.withRepoPath(newRepoPath)),
+						},
+			options,
+		);
 	}
 
 	async getContributors(
@@ -907,12 +1012,66 @@ export class Cache implements Disposable {
 	getContributorsStats(
 		repoPath: string,
 		cacheKey: string,
-		factory: (commonPath: string) => PromiseOrValue<GitContributorsStats | undefined>,
-		options?: { accessTTL?: number },
+		factory: (commonPath: string, cancellation?: AbortSignal) => PromiseOrValue<GitContributorsStats | undefined>,
+		options?: { accessTTL?: number; cancellation?: AbortSignal },
 	): Promise<GitContributorsStats | undefined> {
 		return this.getSharedSimpleWithKey(this.contributorsStats, repoPath, cacheKey, factory, options);
 	}
 
+	getBaseBranchName(
+		repoPath: string,
+		ref: string,
+		factory: (commonPath: string, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>,
+		cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		return this.getSharedSimpleWithKey(this.baseBranchName, repoPath, ref, factory, {
+			cancellation: cancellation,
+		});
+	}
+
+	getBranchMergedStatus(
+		repoPath: string,
+		cacheKey: string,
+		factory: (
+			commonPath: string,
+			cacheable: CacheController,
+			cancellation?: AbortSignal,
+		) => PromiseOrValue<GitBranchMergedStatus>,
+		cancellation?: AbortSignal,
+	): Promise<GitBranchMergedStatus> {
+		return this.getSharedOrCreateWithKey(
+			this.branchMergedStatus,
+			repoPath,
+			cacheKey,
+			factory,
+			(data, newRepoPath) => {
+				if (!data.merged) return data;
+				if (data.localBranchOnly == null) return data;
+
+				const lbo = data.localBranchOnly;
+				return {
+					...data,
+					localBranchOnly: createReference(lbo.ref, newRepoPath, {
+						id: getBranchId(newRepoPath, lbo.remote, lbo.name),
+						refType: 'branch',
+						name: lbo.name,
+						remote: lbo.remote,
+						upstream: lbo.upstream,
+						sha: lbo.sha,
+					}),
+				};
+			},
+			{ cancellation: cancellation },
+		);
+	}
+
+	getBranchMetadataMap(
+		repoPath: string,
+		factory: (commonPath: string) => PromiseOrValue<Map<string, BranchMetadata>>,
+	): Promise<Map<string, BranchMetadata>> {
+		return this.getSharedSimple(this.branchMetadataMap, repoPath, factory);
+	}
+
 	getDefaultBranchName(
 		repoPath: string,
 		remote: string,
@@ -955,16 +1114,18 @@ export class Cache implements Disposable {
 
 	async getStash(
 		repoPath: string,
+		cacheKey: string,
 		factory: (
 			commonPath: string,
 			cacheable: CacheController,
 			cancellation?: AbortSignal,
 		) => PromiseOrValue<GitStash>,
-		cancellation?: AbortSignal,
+		options?: { accessTTL?: number; cancellation?: AbortSignal },
 	): Promise<GitStash> {
-		return this.getSharedOrCreate(
+		return this.getSharedOrCreateWithKey(
 			this.stashes,
 			repoPath,
+			cacheKey,
 			factory,
 			(data, newRepoPath) => ({
 				repoPath: newRepoPath,
@@ -975,7 +1136,7 @@ export class Cache implements Disposable {
 					]),
 				),
 			}),
-			cancellation,
+			options,
 		);
 	}
 
@@ -1142,11 +1303,16 @@ export class Cache implements Disposable {
 		cache: RepoPromiseCacheMap<string, T>,
 		repoPath: string,
 		cacheKey: string,
-		factory: (commonPath: string) => PromiseOrValue<T>,
-		options?: { accessTTL?: number },
+		factory: (commonPath: string, cancellation?: AbortSignal) => PromiseOrValue<T>,
+		options?: { accessTTL?: number; cancellation?: AbortSignal },
 	): Promise<T> {
 		const commonPath = this.getCommonPath(repoPath);
 
-		return cache.getOrCreate(commonPath, cacheKey, () => Promise.resolve(factory(commonPath)), options);
+		return cache.getOrCreate(
+			commonPath,
+			cacheKey,
+			(_cacheable, signal) => Promise.resolve(factory(commonPath, signal)),
+			options,
+		);
 	}
 }

package/src/git/context.ts

@@ -113,9 +113,18 @@ export interface GitServiceHooks {
 	};
 	/** Commit lifecycle hooks */
 	readonly commits?: {
-		/** Called when a commit is signed successfully */
+		/**
+		 * Called when a commit is signed successfully.
+		 *
+		 * Note: currently fired only from explicit-sign paths in the patch provider
+		 * (where signing is requested via `-S` and confirmed up front). Operations
+		 * that sign implicitly via `commit.gpgsign=true` (`commit`, `merge`, `pull`,
+		 * `rebase`, `revert`, `cherryPick`) do not fire this hook because the
+		 * library cannot cheaply confirm that signing actually occurred without an
+		 * extra `git config`/`log --show-signature` call.
+		 */
 		onSigned?(format: SigningFormat, source?: unknown): void;
-		/** Called when commit signing fails */
+		/** Called when commit signing fails — fired from all signing-capable paths. */
 		onSigningFailed?(reason: SigningErrorReason, format: SigningFormat, source?: unknown): void;
 	};
 	/** Git operation hooks */

package/src/git/models/branch.ts

@@ -21,6 +21,7 @@ export type BranchDisposition = 'starred' | 'archived';
 export interface BranchMetadata {
 	lastAccessedAt?: string;
 	lastModifiedAt?: string;
+	agentLastActivityAt?: string;
 	disposition?: BranchDisposition;
 }
 

package/src/git/models/commit.ts

@@ -177,10 +177,7 @@ export class GitCommit implements GitRevisionReference {
 
 			const stashFiles = getSettledValue(stashFilesResult);
 			if (stashFiles?.length) {
-				commit.applyFileset({
-					files: stashFiles as readonly GitFileChange[],
-					filtered: commit.fileset?.filtered,
-				});
+				commit.applyFileset({ files: stashFiles, filtered: commit.fileset?.filtered });
 			}
 			enrichCommit(commit, { stashUntrackedFilesLoaded: true });
 		} else {
@@ -218,7 +215,6 @@ export class GitCommit implements GitRevisionReference {
 	readonly stashNumber: string | undefined;
 	readonly stashOnRef: string | undefined;
 	readonly tips: string[] | undefined;
-	readonly parentTimestamps?: GitStashParentInfo[] | undefined;
 
 	constructor(
 		public readonly repoPath: string,
@@ -234,13 +230,11 @@ export class GitCommit implements GitRevisionReference {
 		tips?: string[],
 		stashName?: string | undefined,
 		stashOnRef?: string | undefined,
-		parentTimestamps?: GitStashParentInfo[] | undefined,
 		shaLength: number = getAbbreviatedShaLength(),
 	) {
 		this.ref = sha;
 		this.shortSha = sha.substring(0, shaLength);
 		this.tips = tips;
-		this.parentTimestamps = parentTimestamps;
 
 		if (stashName) {
 			this.refType = 'stash';
@@ -457,7 +451,6 @@ export class GitCommit implements GitRevisionReference {
 		stats?: GitCommitStats | null;
 		stashUntrackedFilesLoaded?: boolean;
 		resolvedPreviousSha?: string;
-		parentTimestamps?: GitStashParentInfo[] | null;
 	}): T {
 		const commit = new GitCommit(
 			this.repoPath,
@@ -473,7 +466,6 @@ export class GitCommit implements GitRevisionReference {
 			this.tips,
 			this.stashName,
 			this.stashOnRef,
-			this.getChangedValue(changes.parentTimestamps, this.parentTimestamps),
 			this.shortSha.length,
 		);
 		commit._etagWorkingTree = this._etagWorkingTree;
@@ -522,7 +514,6 @@ export class GitCommit implements GitRevisionReference {
 			this.tips,
 			this.stashName,
 			this.stashOnRef,
-			this.parentTimestamps,
 		);
 		commit._etagWorkingTree = this._etagWorkingTree;
 		return commit as T;
@@ -672,17 +663,10 @@ export interface GitCommitStats<Files extends number | GitDiffFileStats = number
 	readonly deletions: number;
 }
 
-export interface GitStashParentInfo {
-	readonly sha: string;
-	readonly authorDate?: number;
-	readonly committerDate?: number;
-}
-
 export interface GitStashCommit extends GitCommit {
 	readonly refType: GitStashReference['refType'];
 	readonly stashName: string;
 	readonly stashNumber: string;
-	readonly parentTimestamps?: GitStashParentInfo[];
 }
 
 export type GitCommitWithFullDetails = GitCommit & { message: string; fileset: GitCommitFileset };

package/src/git/models/graph.ts

@@ -1,3 +1,4 @@
+import type { GitCommitReachability } from '../providers/commits.js';
 import type { GitBranch } from './branch.js';
 import type { GitStashCommit } from './commit.js';
 import type { GitRemote } from './remote.js';
@@ -77,7 +78,7 @@ export interface GitGraphRow {
 	tags?: GitGraphRowTag[];
 	contexts?: GitGraphRowContexts;
 	stats?: GitGraphRowStats;
-	reachableFromBranches?: string[];
+	reachability?: GitCommitReachability;
 	isCurrentUser?: boolean;
 }
 
@@ -97,8 +98,6 @@ export interface GitGraph {
 
 	/** SHAs reachable from HEAD (for enrichment: marking commits on the current branch) */
 	readonly reachableFromHEAD?: ReadonlySet<string>;
-	/** Map of SHA → set of branch names reachable from that SHA (for enrichment: branch context) */
-	readonly reachableFromBranches?: ReadonlyMap<string, ReadonlySet<string>>;
 
 	/** The rows for the set of commits requested */
 	readonly rows: GitGraphRow[];
@@ -179,6 +178,5 @@ export interface GraphContext {
 	readonly branchIdOfMainWorktree: string | undefined;
 	readonly stashes: ReadonlyMap<string, GitStashCommit> | undefined;
 	readonly reachableFromHEAD: ReadonlySet<string>;
-	readonly reachableFromBranches: ReadonlyMap<string, ReadonlySet<string>>;
 	readonly avatars: Map<string, string>;
 }

package/src/git/models/repository.ts

@@ -48,7 +48,8 @@ export type RepositoryChange =
 	| 'remoteProviders'
 	| 'starred'
 	| 'opened'
-	| 'gkConfig';
+	| 'gkConfig'
+	| 'lastFetched';
 
 export const repositoryChanges = exhaustiveArray<RepositoryChange>()([
 	'unknown',
@@ -71,6 +72,7 @@ export const repositoryChanges = exhaustiveArray<RepositoryChange>()([
 	'starred',
 	'opened',
 	'gkConfig',
+	'lastFetched',
 ]);
 
 export interface RepositoryInit {
@@ -123,6 +125,7 @@ export class Repository {
 	protected readonly _watchService: RepositoryWatchService;
 
 	private _pendingWorkingTreeChange?: RepositoryWorkingTreeChangeEvent;
+	private _pendingWorkingTreeFlush = false;
 	private _repoChangeListener: UnifiedDisposable | undefined;
 
 	constructor(init: RepositoryInit) {
@@ -356,6 +359,9 @@ export class Repository {
 	/** Called when the watch service notifies of FETCH_HEAD changes. */
 	protected onFetchHeadChanged(): void {
 		this._lastFetched = undefined;
+		// Force-fire so the event arrives immediately (no debounce); downstream consumers must
+		// invalidate any cached fetch timestamp before reading a fresh value.
+		this.fireChange('lastFetched', true);
 	}
 
 	/** Called when .gitignore changes in the working tree. */
@@ -374,7 +380,15 @@ export class Repository {
 		this._onDidChange.fire(extEvent);
 	}
 
-	/** Called by the session when debounced working tree changes arrive */
+	/**
+	 * Called by every {@link watchWorkingTree} subscription when its debounced batch arrives. Each
+	 * call to {@link watchWorkingTree} adds a separate bridge listener on the underlying watch
+	 * session, so a single fs change can invoke this method multiple times in the same microtask —
+	 * once per active subscription. We accumulate paths into a single pending event and defer the
+	 * actual fire to a microtask so back-to-back synchronous bridge calls collapse into ONE
+	 * `_onDidChangeWorkingTree` emission. Without this coalescing, every WIP-dependent listener
+	 * (graph, file history, compare branch, etc.) would fire N times for N active subscriptions.
+	 */
 	protected onWorkingTreeChanged(paths: ReadonlySet<string>): void {
 		this._updatedAt = Date.now();
 
@@ -384,10 +398,16 @@ export class Repository {
 		}
 
 		if (this._suspended) return;
-
-		const e = this._pendingWorkingTreeChange;
-		this._pendingWorkingTreeChange = undefined;
-		this._onDidChangeWorkingTree.fire(e);
+		if (this._pendingWorkingTreeFlush) return;
+
+		this._pendingWorkingTreeFlush = true;
+		queueMicrotask(() => {
+			this._pendingWorkingTreeFlush = false;
+			const e = this._pendingWorkingTreeChange;
+			if (e == null || this._suspended) return;
+			this._pendingWorkingTreeChange = undefined;
+			this._onDidChangeWorkingTree.fire(e);
+		});
 	}
 
 	@trace({ onlyExit: true })

package/src/git/models/worktree.ts

@@ -135,10 +135,10 @@ export class GitWorktree {
 			: GitWorktree.formatDateFromNow(worktree);
 	}
 
-	static async getStatus(worktree: GitWorktree): Promise<GitStatus | undefined> {
+	static async getStatus(worktree: GitWorktree, cancellation?: AbortSignal): Promise<GitStatus | undefined> {
 		if (worktree.type === 'bare') return undefined;
 		const repo = getRepositoryService(worktree.path);
-		return repo?.status.getStatus();
+		return repo?.status.getStatus(cancellation);
 	}
 
 	static async hasWorkingChanges(

package/src/git/parsers/diffParser.ts

@@ -364,43 +364,6 @@ export function parseGitFileDiff(data: string, includeRawContent = false): Parse
 	};
 }
 
-export function parseGitDiffNameStatusFiles(data: string, repoPath: string): GitFile[] | undefined {
-	using sw = maybeStopWatch('Git.parseDiffNameStatusFiles', { log: { onlyExit: true, level: 'debug' } });
-	if (!data) {
-		sw?.stop({ suffix: ` no data` });
-		return undefined;
-	}
-
-	const files: GitFile[] = [];
-
-	let status;
-
-	const fields = data.split('\0');
-	for (let i = 0; i < fields.length - 1; i++) {
-		status = fields[i][0];
-		if (status === '.') {
-			status = '?';
-		}
-
-		let originalPath;
-		// Renamed files are old followed by the new path
-		if (status === 'R' || status === 'C') {
-			if (i + 1 >= fields.length - 1) break;
-
-			originalPath = fields[++i];
-		}
-		if (i + 1 >= fields.length) break;
-
-		const path = fields[++i];
-
-		files.push({ status: status as GitFileStatus, path: path, originalPath: originalPath, repoPath: repoPath });
-	}
-
-	sw?.stop({ suffix: ` parsed ${files.length} files` });
-
-	return files;
-}
-
 /**
  * Parses the output of `git diff --numstat --summary -z`.
  *
@@ -477,7 +440,7 @@ export function parseGitDiffNumStatFiles(data: string, repoPath: string): GitFil
 			repoPath: repoPath,
 			path: path,
 			originalPath: originalPath,
-			status: (originalPath ? 'R' : 'M') as GitFileStatus,
+			status: originalPath ? 'R' : 'M',
 			stats: { additions: additions, deletions: deletions, changes: additions + deletions },
 		});
 
@@ -514,14 +477,14 @@ export function parseGitDiffNumStatFiles(data: string, repoPath: string): GitFil
 			if (createOrDelete != null) {
 				const file = files.get(normalizePath(createOrDeletePath));
 				if (file != null) {
-					file.status = (createOrDelete === 'create' ? 'A' : 'D') as GitFileStatus;
+					file.status = createOrDelete === 'create' ? 'A' : 'D';
 				}
 			} else if (renameOrCopy === 'copy') {
 				// Numstat defaulted to R; promote to C. Reconstruct the full new-side path by
 				// concatenating prefix + new-leaf + suffix, covering all compact and non-compact forms.
 				const file = files.get(normalizePath(renameRoot + renameNewLeaf + renameSuffix));
 				if (file != null) {
-					file.status = 'C' as GitFileStatus;
+					file.status = 'C';
 				}
 			} else if (modeChangePath != null) {
 				// File-type boundary: 100xxx = regular file, 120000 = symlink, 160000 = gitlink.
@@ -529,7 +492,7 @@ export function parseGitDiffNumStatFiles(data: string, repoPath: string): GitFil
 				if (oldMode.substring(0, 2) !== newMode.substring(0, 2)) {
 					const file = files.get(normalizePath(modeChangePath));
 					if (file != null) {
-						file.status = 'T' as GitFileStatus;
+						file.status = 'T';
 					}
 				}
 			}
@@ -564,7 +527,7 @@ export function parseGitApplyFiles(data: string, repoPath: string): GitFileChang
 		const [insertions, deletions, path] = line.split('\t');
 		files.set(
 			normalizePath(path),
-			new GitFileChange(repoPath, path, 'M' as GitFileStatus, getUri(path), undefined, undefined, undefined, {
+			new GitFileChange(repoPath, path, 'M', getUri(path), undefined, undefined, undefined, {
 				changes: 0,
 				additions: parseInt(insertions, 10),
 				deletions: parseInt(deletions, 10),
@@ -603,7 +566,7 @@ export function parseGitApplyFiles(data: string, repoPath: string): GitFileChang
 				new GitFileChange(
 					repoPath,
 					newPath,
-					(renameOrCopy === 'copy' ? 'C' : 'R') as GitFileStatus,
+					renameOrCopy === 'copy' ? 'C' : 'R',
 					getUri(newPath),
 					originalPath,
 					getUri(originalPath),
@@ -618,7 +581,7 @@ export function parseGitApplyFiles(data: string, repoPath: string): GitFileChang
 				new GitFileChange(
 					repoPath,
 					file.path,
-					(createOrDelete === 'create' ? 'A' : 'D') as GitFileStatus,
+					createOrDelete === 'create' ? 'A' : 'D',
 					getUri(file.path),
 					undefined,
 					undefined,