@gitkraken/core-gitlens 0.1.0 → 0.3.0

package/src/plus/git-github/providers/github/diff.ts

@@ -22,6 +22,7 @@ import { encodeGitLensRevisionUriAuthority } from '../../../../git/utils/uriAuth
 import { debug } from '../../../../utils/decorators/log.js';
 import { union } from '../../../../utils/iterable.js';
 import { getScopedLogger } from '../../../../utils/logger.scoped.js';
+import { getSettledValue } from '../../../../utils/promise.js';
 import type { Uri } from '../../../../utils/uri.js';
 import { fromUri } from '../../../../utils/uri.js';
 import { toTokenInfo } from '../../api/tokenUtils.js';
@@ -58,12 +59,18 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 	async getChangedFilesCount(
 		repoPath: string,
 		to?: string,
-		_from?: string,
-		_options?: { uris?: (string | Uri)[] },
+		from?: string,
+		_options?: { uris?: (string | Uri)[]; includeUntracked?: boolean },
 		_cancellation?: AbortSignal,
 	): Promise<GitDiffShortStat | undefined> {
-		// TODO@eamodio if there is no ref we can't return anything, until we can get at the change store from RemoteHub
-		if (!to) return undefined;
+		// Virtual GitHub repos have no working tree, so no working changes can exist.
+		// Without any refs, return empty stats rather than undefined to avoid "uncertain state" callers.
+		if (!to && !from) return { additions: 0, deletions: 0, files: 0 };
+
+		// If only `from` is provided, compare against HEAD
+		if (!to) {
+			to = 'HEAD';
+		}
 
 		const commit = await this.provider.commits.getCommit(repoPath, to);
 		if (commit?.stats == null) return undefined;
@@ -79,7 +86,13 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		repoPath: string,
 		ref1OrRange: string | GitRevisionRange,
 		ref2?: string,
-		_options?: { filters?: GitDiffFilter[]; path?: string; renameLimit?: number; similarityThreshold?: number },
+		_options?: {
+			filters?: GitDiffFilter[];
+			includeUntracked?: boolean;
+			path?: string;
+			renameLimit?: number;
+			similarityThreshold?: number;
+		},
 	): Promise<GitFile[] | undefined> {
 		if (repoPath == null) return undefined;
 
@@ -109,27 +122,28 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		}
 
 		try {
-			let result = await github.getComparison(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				stripOrigin(range),
-			);
-
-			const files1 = result?.files;
+			const token = toTokenInfo(this.provider.authenticationProviderId, session);
 
-			let files = files1;
+			let files;
 			if (range2) {
-				result = await github.getComparison(
-					toTokenInfo(this.provider.authenticationProviderId, session),
-					metadata.repo.owner,
-					metadata.repo.name,
-					stripOrigin(range2),
-				);
+				// GitHub doesn't support `..`, so issue both `...` comparisons in parallel and union the results.
+				const [result1, result2] = await Promise.allSettled([
+					github.getComparison(token, metadata.repo.owner, metadata.repo.name, stripOrigin(range)),
+					github.getComparison(token, metadata.repo.owner, metadata.repo.name, stripOrigin(range2)),
+				]);
 
-				const files2 = result?.files;
+				const files1 = getSettledValue(result1)?.files;
+				const files2 = getSettledValue(result2)?.files;
 
 				files = [...new Set(union(files1, files2))];
+			} else {
+				const result = await github.getComparison(
+					token,
+					metadata.repo.owner,
+					metadata.repo.name,
+					stripOrigin(range),
+				);
+				files = result?.files;
 			}
 
 			return files?.map(f => ({

package/src/plus/git-github/providers/github/refs.ts

@@ -1,9 +1,10 @@
 import type { Cache } from '../../../../git/cache.js';
 import type { GitBranch } from '../../../../git/models/branch.js';
-import type { GitReference } from '../../../../git/models/reference.js';
+import type { GitReference, GitRefTip } from '../../../../git/models/reference.js';
 import { deletedOrMissing } from '../../../../git/models/revision.js';
 import type { GitTag } from '../../../../git/models/tag.js';
 import type { GitRefsSubProvider } from '../../../../git/providers/refs.js';
+import type { GitCommandPriority } from '../../../../git/run.types.js';
 import { createReference } from '../../../../git/utils/reference.utils.js';
 import {
 	createRevisionRange,
@@ -31,32 +32,42 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	}
 
 	@debug()
-	async getMergeBase(
+	getMergeBase(
 		repoPath: string,
 		ref1: string,
 		ref2: string,
-		_options?: { forkPoint?: boolean },
+		_options?: { forkPoint?: boolean; priority?: GitCommandPriority },
 		_cancellation?: AbortSignal,
 	): Promise<string | undefined> {
-		if (repoPath == null) return undefined;
-
-		const scope = getScopedLogger();
-
-		const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
-
-		try {
-			const result = await github.getComparison(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-				createRevisionRange(stripOrigin(ref1), stripOrigin(ref2), '...'),
-			);
-			return result?.merge_base_commit?.sha;
-		} catch (ex) {
-			scope?.error(ex);
-			debugger;
-			return undefined;
-		}
+		if (repoPath == null) return Promise.resolve(undefined);
+
+		const a = stripOrigin(ref1);
+		const b = stripOrigin(ref2);
+		// `merge-base` is symmetric, so normalize ref order in the cache key to coalesce
+		// `(A, B)` and `(B, A)` lookups onto a single entry.
+		const [left, right] = a < b ? [a, b] : [b, a];
+		const cacheKey = `${left}...${right}`;
+		const queryRange = createRevisionRange(a, b, '...');
+
+		return this.cache.mergeBase.getOrCreate(repoPath, cacheKey, async () => {
+			const scope = getScopedLogger();
+
+			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+
+			try {
+				const result = await github.getComparison(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+					queryRange,
+				);
+				return result?.merge_base_commit?.sha;
+			} catch (ex) {
+				scope?.error(ex);
+				debugger;
+				return undefined;
+			}
+		});
 	}
 
 	@debug()
@@ -90,6 +101,30 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 		return createReference(ref, repoPath, { refType: 'revision' });
 	}
 
+	@debug()
+	getRefTips(
+		_repoPath: string,
+		_options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		_cancellation?: AbortSignal,
+	): Promise<GitRefTip[]> {
+		// Not implemented for GitHub virtual repos — current consumers (timeline slice-by-branch)
+		// gate this off via `!repo.virtual`. A future implementation can use GraphQL `refs` /
+		// `commit.associatedRefs`.
+		return Promise.resolve([]);
+	}
+
+	@debug()
+	getRefsContainingShas(
+		_repoPath: string,
+		_shas: ReadonlySet<string> | readonly string[],
+		_oldestSha: string,
+		_options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		_cancellation?: AbortSignal,
+	): Promise<Map<string, GitRefTip[]>> {
+		// See `getRefTips` — gated off for virtual repos until GraphQL `commit.associatedRefs` lands.
+		return Promise.resolve(new Map<string, GitRefTip[]>());
+	}
+
 	@debug()
 	async hasBranchOrTag(
 		repoPath: string | undefined,

package/src/plus/git-github/providers/github/revision.ts

@@ -98,8 +98,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 			});
 		}
 
-		// TODO@eamodio: Implement this
-		return [];
+		return result;
 	}
 
 	@debug()

package/src/plus/git-github/providers/github/status.ts

@@ -2,6 +2,7 @@ import type { GitFile } from '../../../../git/models/file.js';
 import type { GitConflictFile } from '../../../../git/models/staging.js';
 import { GitStatus } from '../../../../git/models/status.js';
 import type { GitStatusSubProvider, GitWorkingChangesState } from '../../../../git/providers/status.js';
+import type { GitCommandPriority } from '../../../../git/run.types.js';
 import { gate } from '../../../../utils/decorators/gate.js';
 import { debug } from '../../../../utils/decorators/log.js';
 import { HeadType } from '../../context.js';
@@ -12,7 +13,11 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 
 	@gate()
 	@debug()
-	async getStatus(repoPath: string | undefined, _cancellation?: AbortSignal): Promise<GitStatus | undefined> {
+	async getStatus(
+		repoPath: string | undefined,
+		_options?: { priority?: GitCommandPriority },
+		_cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined> {
 		if (repoPath == null) return undefined;
 
 		const context = await this.provider.ensureRepositoryContext(repoPath);

package/src/plus/git-github/providers/github/tags.ts

@@ -33,72 +33,71 @@ export class TagsGitSubProvider implements GitTagsSubProvider {
 	): Promise<PagedResult<GitTag>> {
 		if (repoPath == null) return emptyPagedResult;
 
+		const path = repoPath;
+
 		const scope = getScopedLogger();
 
-		const tagsPromise = options?.paging?.cursor
-			? undefined
-			: this.cache.tags.getOrCreate(
-					repoPath,
-					async cancellable => {
-						try {
-							const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
-
-							const tags: GitTag[] = [];
-
-							let cursor = options?.paging?.cursor;
-							const loadAll = cursor == null;
-
-							let authoredDate;
-							let committedDate;
-
-							while (true) {
-								const result = await github.getTags(
-									toTokenInfo(this.provider.authenticationProviderId, session),
-									metadata.repo.owner,
-									metadata.repo.name,
-									{ cursor: cursor },
-								);
-
-								for (const tag of result.values) {
-									authoredDate =
-										tag.target.authoredDate ??
-										tag.target.target?.authoredDate ??
-										tag.target.tagger?.date;
-									committedDate =
-										tag.target.committedDate ??
-										tag.target.target?.committedDate ??
-										tag.target.tagger?.date;
-
-									tags.push(
-										new GitTag(
-											repoPath,
-											tag.name,
-											tag.target.target?.oid ?? tag.target.oid,
-											tag.target.message ?? tag.target.target?.message ?? '',
-											authoredDate != null ? new Date(authoredDate) : undefined,
-											committedDate != null ? new Date(committedDate) : undefined,
-										),
-									);
-								}
-
-								if (!result.paging?.more || !loadAll) return { ...result, values: tags };
-
-								cursor = result.paging.cursor;
-							}
-						} catch (ex) {
-							cancellable.invalidate();
-							scope?.error(ex);
-							debugger;
-
-							return emptyPagedResult;
+		// Compose cache key with cursor so re-loads of the same page hit the cache;
+		// `repoPath` (no suffix) is reserved for the full "all tags" entry.
+		// TODO: `cache.tags` is `PromiseMap<RepoPath, ...>` keyed exactly by repoPath, so
+		// `clearCaches('tags')` / `unregisterRepoPath` will not invalidate composite-key entries.
+		// Acceptable today because tags rarely move during a virtual-repo session, but the entries
+		// leak in memory until provider GC. Long-term: switch to RepoPromiseCacheMap or add prefix-invalidate.
+		const cacheKey = options?.paging?.cursor != null ? `${path}#${options.paging.cursor}` : path;
+		const tagsPromise = this.cache.tags.getOrCreate(
+			cacheKey,
+			async cancellable => {
+				try {
+					const { metadata, github, session } = await this.provider.ensureRepositoryContext(path);
+
+					const tags: GitTag[] = [];
+
+					let cursor = options?.paging?.cursor;
+					const loadAll = cursor == null;
+
+					let authoredDate;
+					let committedDate;
+
+					while (true) {
+						const result = await github.getTags(
+							toTokenInfo(this.provider.authenticationProviderId, session),
+							metadata.repo.owner,
+							metadata.repo.name,
+							{ cursor: cursor },
+						);
+
+						for (const tag of result.values) {
+							authoredDate =
+								tag.target.authoredDate ?? tag.target.target?.authoredDate ?? tag.target.tagger?.date;
+							committedDate =
+								tag.target.committedDate ?? tag.target.target?.committedDate ?? tag.target.tagger?.date;
+
+							tags.push(
+								new GitTag(
+									path,
+									tag.name,
+									tag.target.target?.oid ?? tag.target.oid,
+									tag.target.message ?? tag.target.target?.message ?? '',
+									authoredDate != null ? new Date(authoredDate) : undefined,
+									committedDate != null ? new Date(committedDate) : undefined,
+								),
+							);
 						}
-					},
-					cancellation,
-				);
 
-		if (tagsPromise == null) {
-			return emptyPagedResult;
-		}
+						if (!result.paging?.more || !loadAll) return { ...result, values: tags };
+
+						cursor = result.paging.cursor;
+					}
+				} catch (ex) {
+					cancellable.invalidate();
+					scope?.error(ex);
+					debugger;
+
+					return emptyPagedResult;
+				}
+			},
+			cancellation,
+		);
 
 		let result = await tagsPromise;
 		if (options?.filter != null) {

package/src/plus/git-github/providers/githubGitProvider.ts

@@ -152,6 +152,7 @@ export class GitHubGitProvider implements GitHubGitProviderInternal, GitProvider
 
 	getPagingLimit(limit?: number): number {
 		if (limit === 0) return 0;
+
 		limit = Math.min(limit ?? this.context.config?.paging?.limit ?? 100, 100);
 		if (limit !== 0 && limit < 100) {
 			limit = Math.max(limit, 1);

package/src/utils/color.ts

@@ -568,6 +568,7 @@ export class Color {
 		if (of.isLighterThan(relative)) {
 			return of;
 		}
+
 		factor = factor ? factor : 0.5;
 		const lum1 = of.getRelativeLuminance();
 		const lum2 = relative.getRelativeLuminance();
@@ -579,6 +580,7 @@ export class Color {
 		if (of.isDarkerThan(relative)) {
 			return of;
 		}
+
 		factor = factor ? factor : 0.5;
 		const lum1 = of.getRelativeLuminance();
 		const lum2 = relative.getRelativeLuminance();

package/src/utils/decorators/log.ts

@@ -265,7 +265,7 @@ function log<T extends (...arg: any[]) => any>(
 					}
 
 					if (result != null && isPromise(result)) {
-						result.then(logResult, logError);
+						void result.then(logResult, logError).catch(() => {});
 					} else {
 						logResult(result);
 					}

package/src/utils/decorators/sequentialize.ts

@@ -103,12 +103,14 @@ export function sequentialize<T extends (...args: any[]) => any>(
 			}
 
 			// Cleanup when done
-			void promise.finally(() => {
-				const s = this[prop];
-				if (s?.promise === promise && s.waiting == null) {
-					this[prop] = undefined;
-				}
-			});
+			void promise
+				.finally(() => {
+					const s = this[prop];
+					if (s?.promise === promise && s.waiting == null) {
+						this[prop] = undefined;
+					}
+				})
+				.catch(() => {});
 
 			return promise;
 		};

package/src/utils/decorators/serializable.ts

@@ -18,6 +18,7 @@ export function serializable(target: Function): void {
 	while (proto != null && proto !== Object.prototype) {
 		for (const key of Object.getOwnPropertyNames(proto)) {
 			if (key === 'constructor') continue;
+
 			const desc = Object.getOwnPropertyDescriptor(proto, key);
 			if (desc?.get != null) {
 				getterKeys.add(key);

package/src/utils/dedupedAsyncCache.ts

@@ -0,0 +1,74 @@
+/**
+ * Per-key cache for async resolution that dedupes concurrent first-time callers and caches the
+ * resolved value (including `undefined`) for subsequent reads.
+ *
+ * Two internal Maps drive the semantics:
+ * - `_resolved` holds settled values. `has(key)` distinguishes a cached `undefined` from "never
+ *   resolved", so callers can intentionally cache "no result" without re-running the resolver.
+ * - `_resolving` holds in-flight Promises. While a key resolves, concurrent `getOrResolve` callers
+ *   share the same Promise instead of each invoking the resolver.
+ *
+ * Failed resolutions do not poison the cache — the entry is removed when the in-flight Promise
+ * rejects, so the next call retries.
+ */
+export class DedupedAsyncCache<K, V> {
+	private readonly _resolved = new Map<K, V>();
+	private readonly _resolving = new Map<K, Promise<V>>();
+
+	/** True iff `key` has a settled value cached. Distinct from "currently resolving". */
+	has(key: K): boolean {
+		return this._resolved.has(key);
+	}
+
+	/** Settled value for `key`, or `undefined` when not yet cached. May also legitimately return
+	 *  `undefined` for a key whose cached value is `undefined`; use `has` to disambiguate. */
+	get(key: K): V | undefined {
+		return this._resolved.get(key);
+	}
+
+	/** Populates the cache directly, bypassing the resolver. Used by callers that already know the
+	 *  value (e.g. event payloads, post-write reconciles) and want subsequent reads to hit. */
+	set(key: K, value: V): void {
+		this._resolved.set(key, value);
+	}
+
+	/** Removes both the settled value and any in-flight Promise for `key`. */
+	delete(key: K): void {
+		this._resolved.delete(key);
+		this._resolving.delete(key);
+	}
+
+	/** Clears everything — both settled values and in-flight Promises. */
+	clear(): void {
+		this._resolved.clear();
+		this._resolving.clear();
+	}
+
+	/**
+	 * Returns the cached value for `key`, invoking `resolver` only on a cache miss. Concurrent
+	 * cache-miss callers for the same key share the same in-flight Promise — `resolver` is invoked
+	 * exactly once per cache fill. If `resolver` rejects, the entry is removed so subsequent calls
+	 * retry rather than receiving a permanently cached failure.
+	 */
+	getOrResolve(key: K, resolver: () => Promise<V>): Promise<V> {
+		if (this._resolved.has(key)) {
+			// Map.get returns `V | undefined`; `has` confirmed presence, so the value (even if it
+			// is `undefined` by intent) is the cached one. Cast pins the return type.
+			return Promise.resolve(this._resolved.get(key) as V);
+		}
+
+		const existing = this._resolving.get(key);
+		if (existing != null) return existing;
+
+		const pending = resolver()
+			.then(value => {
+				this._resolved.set(key, value);
+				return value;
+			})
+			.finally(() => {
+				this._resolving.delete(key);
+			});
+		this._resolving.set(key, pending);
+		return pending;
+	}
+}

package/src/utils/diff.ts

@@ -0,0 +1,61 @@
+// Annotates diff to make is easier for agentic reference to line number.
+// Brackets sit AFTER the line-type marker so file-level diff parsers
+// (e.g. `filterDiffFiles`) that key off `diff --git` / `+++` / `---` headers still work.
+export function annotateDiffWithNewLineNumbers(diff: string): string {
+	if (!diff) return diff;
+
+	const lines = diff.split('\n');
+	const out: string[] = new Array(lines.length);
+	let newLine = 0;
+	let inHunk = false;
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+
+		if (line.startsWith('@@')) {
+			const match = /\+(\d+)(?:,\d+)?\s/.exec(line);
+			newLine = match != null ? parseInt(match[1], 10) : 0;
+			inHunk = true;
+			out[i] = line;
+			continue;
+		}
+
+		if (
+			line.startsWith('diff --git') ||
+			line.startsWith('index ') ||
+			line.startsWith('--- ') ||
+			line.startsWith('+++ ') ||
+			line.startsWith('new file') ||
+			line.startsWith('deleted file') ||
+			line.startsWith('rename ') ||
+			line.startsWith('copy ') ||
+			line.startsWith('similarity ') ||
+			line.startsWith('dissimilarity ') ||
+			line.startsWith('Binary files')
+		) {
+			inHunk = false;
+			out[i] = line;
+			continue;
+		}
+
+		if (!inHunk || line.startsWith('\\')) {
+			out[i] = line;
+			continue;
+		}
+
+		const marker = line[0];
+		if (marker === '-') {
+			out[i] = `-[     ]${line.slice(1)}`;
+			continue;
+		}
+		if (marker === '+' || marker === ' ') {
+			out[i] = `${marker}[${String(newLine).padStart(5, ' ')}]${line.slice(1)}`;
+			newLine++;
+			continue;
+		}
+
+		out[i] = line;
+	}
+
+	return out.join('\n');
+}

package/src/utils/disposable.ts

@@ -13,6 +13,7 @@ export function createDisposable(
 	options?: { once?: boolean },
 ): UnifiedDisposable | undefined {
 	if (dispose == null) return undefined;
+
 	if (options?.once) {
 		dispose = once(dispose);
 	}
@@ -61,6 +62,7 @@ export function fromDisposables(
 	let disposed = false;
 	const dispose = () => {
 		if (disposed) return;
+
 		disposed = true;
 
 		for (const d of disposables) {

package/src/utils/env/node/base64.ts

@@ -5,7 +5,7 @@ export function base64(data: string | Uint8Array): string {
 }
 
 export function fromBase64(s: string): Uint8Array {
-	return Buffer.from(s, 'base64') as unknown as Uint8Array;
+	return Buffer.from(s, 'base64');
 }
 
 /**

package/src/utils/env/node/exec.ts

@@ -287,6 +287,7 @@ export function run<T extends number | string>(
 								`Non-UTF-8 encoding '${encoding}' requested but no decode function configured`,
 							);
 						}
+
 						stdoutDecoded = await decode(
 							Buffer.from(stdout, 'binary'),
 							encoding ? { encoding: encoding } : undefined,
@@ -311,6 +312,7 @@ export function run<T extends number | string>(
 					if (decode == null) {
 						throw new Error(`Non-UTF-8 encoding '${encoding}' requested but no decode function configured`);
 					}
+
 					resolve(
 						(await decode(
 							Buffer.from(stdout, 'binary'),
@@ -373,8 +375,8 @@ export function runSpawn<T extends string | Buffer>(
 		function getStdio<T>(
 			encoding: BufferEncoding | 'buffer' | string,
 		): { stdout: T; stderr: T } | Promise<{ stdout: T; stderr: T }> {
-			const stdout = Buffer.concat(stdoutBuffers as ReadonlyArray<Uint8Array>);
-			const stderr = Buffer.concat(stderrBuffers as ReadonlyArray<Uint8Array>);
+			const stdout = Buffer.concat(stdoutBuffers);
+			const stderr = Buffer.concat(stderrBuffers);
 			if (encoding === 'utf8' || encoding === 'binary') {
 				return { stdout: stdout.toString(encoding) as T, stderr: stderr.toString(encoding) as T };
 			}

package/src/utils/error.ts

@@ -7,6 +7,7 @@
 export function isErrorLike(v: unknown): v is { name: string; message: string; stack?: string } {
 	if (v == null || typeof v !== 'object') return false;
 	if (v instanceof Error) return true;
+
 	const o = v as { name?: unknown; message?: unknown };
 	return typeof o.name === 'string' && typeof o.message === 'string';
 }

package/src/utils/formatter.ts

@@ -176,23 +176,16 @@ export abstract class Formatter<Item = any, Options extends FormatOptions = Form
 			options.tokenOptions = tokenOptions;
 		}
 
-		if (this._formatter == null) {
-			this._formatter = new formatter(item, options);
-		} else {
-			this._formatter.reset(item, options);
-		}
-
-		return interpolateAsync(template, this._formatter);
+		// Always allocate a fresh formatter: `interpolateAsync` awaits between tokens, so a
+		// concurrent call that reset a shared instance would poison in-flight token resolution.
+		return interpolateAsync(template, new formatter(item, options));
 	}
 
 	static has<TOptions extends FormatOptions>(
 		template: string,
 		...tokens: (keyof NonNullable<TOptions['tokenOptions']>)[]
 	): boolean {
-		const token =
-			tokens.length === 1
-				? (tokens[0] as string)
-				: (`(${tokens.join('|')})` as keyof NonNullable<TOptions['tokenOptions']> as string);
+		const token = tokens.length === 1 ? (tokens[0] as string) : `(${tokens.join('|')})`;
 
 		let regex = hasTokenRegexMap.get(token);
 		if (regex == null) {