Closes #4737 adds reachability to detail views

 - Adds ability to see which branches and tags contain a specific commit

Author: eamodio

docs/telemetry-events.md

@@ -885,6 +885,29 @@ or
 }
 ```
 
+### commitDetails/reachability/failed
+
+> Sent when commit reachability fails to load
+
+```typescript
+{
+  'duration': number,
+  'failed.error': string,
+  'failed.reason': 'unknown' | 'git-error' | 'timeout'
+}
+```
+
+### commitDetails/reachability/loaded
+
+> Sent when commit reachability is successfully loaded
+
+```typescript
+{
+  'duration': number,
+  'refs.count': number
+}
+```
+
 ### commitDetails/showAborted
 
 ```typescript
@@ -2264,6 +2287,29 @@ or
 }
 ```
 
+### graphDetails/reachability/failed
+
+> Sent when commit reachability fails to load in Graph Details
+
+```typescript
+{
+  'duration': number,
+  'failed.error': string,
+  'failed.reason': 'unknown' | 'git-error' | 'timeout'
+}
+```
+
+### graphDetails/reachability/loaded
+
+> Sent when commit reachability is successfully loaded in Graph Details
+
+```typescript
+{
+  'duration': number,
+  'refs.count': number
+}
+```
+
 ### graphDetails/showAborted
 
 ```typescript

src/constants.telemetry.ts

@@ -133,9 +133,13 @@ export interface TelemetryEvents extends WebviewShowAbortedEvents, WebviewShownE
 	'command/core': CoreCommandEvent;
 
 	/** Sent when the Inspect view is shown */
-	'commitDetails/shown': CommitDetailsShownEvent;
+	'commitDetails/shown': DetailsShownEvent;
 	/** Sent when the user changes the selected tab (mode) on the Graph Details view */
-	'commitDetails/mode/changed': CommitDetailsModeChangedEvent;
+	'commitDetails/mode/changed': DetailsModeChangedEvent;
+	/** Sent when commit reachability is successfully loaded */
+	'commitDetails/reachability/loaded': DetailsReachabilityLoadedEvent;
+	/** Sent when commit reachability fails to load */
+	'commitDetails/reachability/failed': DetailsReachabilityFailedEvent;
 
 	/** Sent when the Commit Composer is first loaded with repo data */
 	'composer/loaded': ComposerEvent;
@@ -203,9 +207,13 @@ export interface TelemetryEvents extends WebviewShowAbortedEvents, WebviewShownE
 	'graph/searched': GraphSearchedEvent;
 
 	/** Sent when the Graph Details view is shown */
-	'graphDetails/shown': GraphDetailsShownEvent;
+	'graphDetails/shown': DetailsShownEvent;
 	/** Sent when the user changes the selected tab (mode) on the Graph Details view */
-	'graphDetails/mode/changed': GraphDetailsModeChangedEvent;
+	'graphDetails/mode/changed': DetailsModeChangedEvent;
+	/** Sent when commit reachability is successfully loaded in Graph Details */
+	'graphDetails/reachability/loaded': DetailsReachabilityLoadedEvent;
+	/** Sent when commit reachability fails to load in Graph Details */
+	'graphDetails/reachability/failed': DetailsReachabilityFailedEvent;
 
 	/** Sent when a Home command is executed */
 	'home/command': CommandEventData;
@@ -646,13 +654,24 @@ interface CoreCommandEvent {
 	command: string;
 }
 
-type CommitDetailsShownEvent = WebviewShownEventData & InspectShownEventData;
+type DetailsShownEvent = WebviewShownEventData & InspectShownEventData;
 
-type CommitDetailsModeChangedEvent = InspectContextEventData & {
+type DetailsModeChangedEvent = InspectContextEventData & {
 	'mode.old': 'wip' | 'commit';
 	'mode.new': 'wip' | 'commit';
 };
 
+interface DetailsReachabilityLoadedEvent {
+	'refs.count': number;
+	duration: number;
+}
+
+interface DetailsReachabilityFailedEvent {
+	duration: number;
+	'failed.reason': 'git-error' | 'timeout' | 'unknown';
+	'failed.error'?: string;
+}
+
 export type FeaturePreviewDayEventData = Record<`day.${number}.startedOn`, string>;
 export type FeaturePreviewEventData = {
 	feature: FeaturePreviews;
@@ -729,12 +748,6 @@ interface GraphSearchedEvent extends GraphContextEventData {
 	'failed.error.detail'?: string;
 }
 
-type GraphDetailsShownEvent = WebviewShownEventData & InspectShownEventData;
-type GraphDetailsModeChangedEvent = InspectContextEventData & {
-	'mode.old': 'wip' | 'commit';
-	'mode.new': 'wip' | 'commit';
-};
-
 export type HomeTelemetryContext = WebviewTelemetryContext & {
 	'context.preview': string | undefined;
 };

src/env/node/git/sub-providers/commits.ts

@@ -7,6 +7,7 @@ import type { GitCache } from '../../../../git/cache';
 import type { GitCommandOptions } from '../../../../git/commandOptions';
 import { GitErrorHandling } from '../../../../git/commandOptions';
 import type {
+	GitCommitReachability,
 	GitCommitsSubProvider,
 	GitLogForPathOptions,
 	GitLogOptions,
@@ -53,6 +54,9 @@ import { filterMap, first, join, last, some } from '../../../../system/iterable'
 import { Logger } from '../../../../system/logger';
 import { getLogScope } from '../../../../system/logger.scope';
 import { isFolderGlob, stripFolderGlob } from '../../../../system/path';
+import { wait } from '../../../../system/promise';
+import type { Cancellable } from '../../../../system/promiseCache';
+import { PromiseCache } from '../../../../system/promiseCache';
 import { maybeStopWatch } from '../../../../system/stopwatch';
 import type { CachedLog, TrackedGitDocument } from '../../../../trackers/trackedDocument';
 import { GitDocumentState } from '../../../../trackers/trackedDocument';
@@ -174,6 +178,104 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		}
 	}
 
+	@log()
+	async getCommitReachability(
+		repoPath: string,
+		rev: string,
+		cancellation?: CancellationToken,
+	): Promise<GitCommitReachability | undefined> {
+		if (repoPath == null || isUncommitted(rev)) return undefined;
+
+		const scope = getLogScope();
+
+		const getCore = async (cancellable?: Cancellable) => {
+			try {
+				// Use for-each-ref with %(HEAD) to mark current branch with *
+				const result = await this.git.exec(
+					{ cwd: repoPath, cancellation: cancellation, errors: GitErrorHandling.Ignore },
+					'for-each-ref',
+					'--contains',
+					rev,
+					'--format=%(HEAD)%(refname)',
+					'--sort=-version:refname',
+					'--sort=-committerdate',
+					'--sort=-HEAD',
+					'refs/heads/',
+					'refs/remotes/',
+					'refs/tags/',
+				);
+				if (cancellation?.isCancellationRequested) throw new CancellationError();
+
+				const refs: GitCommitReachability['refs'] = [];
+
+				// Parse branches from refs/heads/ and refs/remotes/
+				if (result?.stdout) {
+					const lines = result.stdout.split('\n');
+
+					for (let line of lines) {
+						line = line.trim();
+						if (!line) continue;
+
+						// %(HEAD) outputs '*' for current branch, ' ' for others
+						const isCurrent = line.startsWith('*');
+						const refname = isCurrent ? line.substring(1) : line; // Skip the HEAD marker
+
+						// Skip HEADs
+						if (refname.endsWith('/HEAD')) continue;
+
+						if (refname.startsWith('refs/heads/')) {
+							// Remove 'refs/heads/'
+							const name = refname.substring(11);
+							refs.push({
+								refType: 'branch',
+								name: name,
+								remote: false,
+								current: isCurrent,
+							});
+						} else if (refname.startsWith('refs/remotes/')) {
+							// Remove 'refs/remotes/'
+							refs.push({ refType: 'branch', name: refname.substring(13), remote: true });
+						} else if (refname.startsWith('refs/tags/')) {
+							// Remove 'refs/tags/'
+							refs.push({ refType: 'tag', name: refname.substring(10) });
+						}
+					}
+				}
+
+				// Sort to move tags to the end, preserving order within each type
+				refs.sort((a, b) => (a.refType !== b.refType ? (a.refType === 'tag' ? 1 : -1) : 0));
+
+				await wait(20000);
+
+				return { refs: refs };
+			} catch (ex) {
+				cancellable?.cancelled();
+				debugger;
+				if (isCancellationError(ex)) throw ex;
+
+				Logger.error(ex, scope);
+
+				return undefined;
+			}
+		};
+
+		const cache = this.cache.reachability;
+		if (cache == null) return getCore();
+
+		let reachabilityCache = cache.get(repoPath);
+		if (reachabilityCache == null) {
+			cache.set(
+				repoPath,
+				(reachabilityCache = new PromiseCache<string, GitCommitReachability | undefined>({
+					accessTTL: 1000 * 60 * 60, // 60 minutes
+					capacity: 25, // Limit to 25 commits per repo
+				})),
+			);
+		}
+
+		return reachabilityCache.get(rev, getCore);
+	}
+
 	@log()
 	async getIncomingActivity(
 		repoPath: string,

src/git/cache.ts

@@ -6,7 +6,7 @@ import type { PromiseOrValue } from '../system/promise';
 import type { PromiseCache } from '../system/promiseCache';
 import { PromiseMap } from '../system/promiseCache';
 import { PathTrie } from '../system/trie';
-import type { CachedGitTypes, GitContributorsResult, GitDir, PagedResult } from './gitProvider';
+import type { CachedGitTypes, GitCommitReachability, GitContributorsResult, GitDir, PagedResult } from './gitProvider';
 import type { GitBranch } from './models/branch';
 import type { GitContributor } from './models/contributor';
 import type { GitPausedOperationStatus } from './models/pausedOperationStatus';
@@ -105,6 +105,13 @@ export class GitCache implements Disposable {
 			: undefined;
 	}
 
+	private _reachabilityCache: Map<RepoPath, PromiseCache<string, GitCommitReachability | undefined>> | undefined;
+	get reachability(): Map<RepoPath, PromiseCache<string, GitCommitReachability | undefined>> | undefined {
+		return this.useCaching
+			? (this._reachabilityCache ??= new Map<RepoPath, PromiseCache<string, GitCommitReachability | undefined>>())
+			: undefined;
+	}
+
 	private _remotesCache: PromiseMap<RepoPath, GitRemote[]> | undefined;
 	get remotes(): PromiseMap<RepoPath, GitRemote[]> | undefined {
 		return this.useCaching ? (this._remotesCache ??= new PromiseMap<RepoPath, GitRemote[]>()) : undefined;
@@ -145,6 +152,7 @@ export class GitCache implements Disposable {
 			cachesToClear.add(this._branchCache);
 			cachesToClear.add(this._branchesCache);
 			cachesToClear.add(this._defaultBranchNameCache);
+			cachesToClear.add(this._reachabilityCache);
 		}
 
 		if (!types.length || types.includes('contributors')) {
@@ -204,6 +212,8 @@ export class GitCache implements Disposable {
 		this._contributorsLiteCache = undefined;
 		this._pausedOperationStatusCache?.clear();
 		this._pausedOperationStatusCache = undefined;
+		this._reachabilityCache?.clear();
+		this._reachabilityCache = undefined;
 		this._remotesCache?.clear();
 		this._remotesCache = undefined;
 		this._stashesCache?.clear();

src/git/gitProvider.ts

@@ -306,6 +306,13 @@ export interface IncomingActivityOptions extends GitLogOptionsBase {
 	skip?: number;
 }
 
+export interface GitCommitReachability {
+	readonly refs: (
+		| { readonly refType: 'branch'; readonly name: string; readonly remote: boolean; readonly current?: boolean }
+		| { readonly refType: 'tag'; readonly name: string; readonly current?: never }
+	)[];
+}
+
 export interface GitCommitsSubProvider {
 	getCommit(repoPath: string, rev: string, cancellation?: CancellationToken): Promise<GitCommit | undefined>;
 	getCommitCount(repoPath: string, rev: string, cancellation?: CancellationToken): Promise<number | undefined>;
@@ -362,6 +369,11 @@ export interface GitCommitsSubProvider {
 		options?: GitSearchCommitsOptions,
 		cancellation?: CancellationToken,
 	): Promise<SearchCommitsResult>;
+	getCommitReachability?(
+		repoPath: string,
+		rev: string,
+		cancellation?: CancellationToken,
+	): Promise<GitCommitReachability | undefined>;
 }
 
 export interface GitOperationsSubProvider {

src/system/promiseCache.ts

@@ -18,6 +18,8 @@ interface PromiseCacheOptions {
 	accessTTL?: number;
 	/** Whether to expire the entry if the promise fails (default: true) */
 	expireOnError?: boolean;
+	/** Maximum number of entries in the cache (LRU eviction when exceeded) */
+	capacity?: number;
 }
 
 export class PromiseCache<K, V> {
@@ -72,9 +74,9 @@ export class PromiseCache<K, V> {
 		};
 		this.cache.set(key, entry);
 
-		// Clean up other expired entries
+		// Clean up expired entries and enforce capacity limit in one pass
 		if (this.cache.size > 1) {
-			queueMicrotask(() => this.cleanupExpired());
+			queueMicrotask(() => this.cleanup());
 		}
 
 		if (options?.expireOnError ?? true) {
@@ -84,14 +86,39 @@ export class PromiseCache<K, V> {
 		return promise;
 	}
 
-	private cleanupExpired(): void {
+	private cleanup(): void {
 		const now = Date.now();
+		const capacity = this.options.capacity;
 
+		// If no capacity limit, just remove expired entries
+		if (capacity == null) {
+			for (const [key, entry] of this.cache.entries()) {
+				if (this.expired(entry, now)) {
+					this.cache.delete(key);
+				}
+			}
+			return;
+		}
+
+		// Single pass: collect non-expired entries and find LRU candidates
+		const entries: Array<[K, CacheEntry<V>]> = [];
 		for (const [key, entry] of this.cache.entries()) {
-			if (this.expired(entry, now)) {
+			if (!this.expired(entry, now)) {
+				entries.push([key, entry]);
+			} else {
 				this.cache.delete(key);
 			}
 		}
+
+		// If still over capacity, remove LRU entries
+		const excess = entries.length - capacity;
+		if (excess > 0) {
+			// Sort by accessed time (oldest first) and remove the excess
+			entries.sort((a, b) => a[1].accessed - b[1].accessed);
+			for (let i = 0; i < excess; i++) {
+				this.cache.delete(entries[i][0]);
+			}
+		}
 	}
 
 	private expired(entry: CacheEntry<V>, now: number): boolean {