@gitkraken/core-gitlens 0.2.0 → 0.3.1

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

@@ -41,7 +41,7 @@ import { escapeRegex } from '../../utils/string.js';
 import type { Uri } from '../../utils/uri.js';
 import { fileUri, joinUriPath, toFsPath } from '../../utils/uri.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
-import type { GitExecOptions, GitResult } from '../exec/exec.types.js';
+import type { GitResult, GitRunOptions } from '../exec/exec.types.js';
 import type { Git } from '../exec/git.js';
 import { gitConfigsLog, gitConfigsLogWithFiles, GitErrors } from '../exec/git.js';
 import type {
@@ -129,6 +129,30 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		return isNaN(count) ? undefined : count;
 	}
 
+	@debug({ exit: true })
+	async hasUnpublishedCommits(
+		repoPath: string,
+		rev: string,
+		cancellation?: AbortSignal,
+	): Promise<boolean | undefined> {
+		// `<rev> --not --remotes` = commits reachable from `rev` but not from any remote-tracking ref.
+		// `--max-count=1` early-exits at the first such commit, so this is a presence probe, not a count.
+		const result = await this.git.run(
+			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
+			'rev-list',
+			'--max-count=1',
+			rev,
+			'--not',
+			'--remotes',
+			'--',
+		);
+		if (result.cancelled || cancellation?.aborted) {
+			throw new CancellationError();
+		}
+
+		return result.stdout.trim().length > 0;
+	}
+
 	@debug({ exit: true })
 	async getCommitDates(
 		repoPath: string,
@@ -172,9 +196,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 	async getCommitFiles(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<GitFileChange[]> {
 		const parser = getShaAndFilesAndStatsLogParser();
 		const result = await this.git.run(
-			// Single-commit log is cheap and almost always serves a user-initiated read; override
-			// the inferred 'background' priority so it doesn't queue behind heavier graph/log work.
-			{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog, priority: 'normal' },
+			{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
 			'log',
 			...parser.arguments,
 			'-n1',
@@ -354,7 +376,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 
 		try {
 			const result = await this.git.run(
-				{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog },
+				{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog, priority: 'background' },
 				'log',
 				...args,
 			);
@@ -479,7 +501,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		// Cache key: range + excludeMerges. RepositoryChange events affecting branches/remotes
 		// invalidate this cache via clearCaches('branches').
 		const cacheKey = `${range}\x1f${options?.excludeMerges ? 'no-merges' : ''}`;
-		return this.cache.getLeftRightCommitCount(repoPath, cacheKey, run);
+		return this.cache.leftRightCommitCount.getOrCreate(repoPath, cacheKey, run);
 	}
 
 	@debug()
@@ -573,24 +595,15 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				args.push(`-n${isSingleCommit ? 1 : limit + 1}`);
 			}
 
-			let stashes: Map<string, GitStashCommit> | undefined;
-			let stdin: string | undefined;
+			let stashes: ReadonlyMap<string, GitStashCommit> | undefined;
 
-			if (!isSingleCommit) {
-				if (options?.stashes) {
-					// There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
-					({ stdin, stashes } = convertStashesToStdin(
-						typeof options.stashes === 'boolean'
-							? await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation)
-							: options.stashes,
-					));
-					if (stashes.size) {
-						rev ??= 'HEAD';
-					}
-				}
-
-				if (stdin) {
-					args.push('--stdin');
+			if (!isSingleCommit && options?.stashes) {
+				stashes =
+					typeof options.stashes === 'boolean'
+						? (await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation))?.stashes
+						: options.stashes;
+				if (stashes?.size) {
+					rev ??= 'HEAD';
 				}
 			}
 
@@ -628,24 +641,30 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			const currentUser = await currentUserPromise.catch(() => undefined);
 			if (cancellation?.aborted) throw new CancellationError();
 
-			const cmdOpts: GitExecOptions = {
+			const cmdOpts: GitRunOptions = {
 				cwd: repoPath,
 				cancellation: cancellation,
 				configs: gitConfigsLogWithFiles,
-				stdin: stdin,
-				// Single-commit log is cheap (typically <50ms) and almost always serves a user-
-				// initiated read (commit details, hover, etc.). Override the inferred 'background'
-				// priority so it doesn't queue behind heavier graph/log work — without this, a click
-				// on a commit while the graph is still loading can wait seconds for files to appear.
-				...(isSingleCommit ? { priority: 'normal' as const } : undefined),
+				// Single-commit log serves user-initiated reads (commit details, hover, etc.).
+				// Mirrors getCommitDates: full SHAs are immutable so a 5-min TTL is safe; non-SHA refs
+				// rely on gitResults being cleared on head/heads/remotes events (60s is the failsafe
+				// for watcher latency / web with no fs watcher).
+				...(isSingleCommit && rev
+					? {
+							caching: {
+								cache: this.cache.gitResults,
+								options: { accessTTL: isSha(rev) ? 5 * 60 * 1000 : 60 * 1000 },
+							},
+						}
+					: undefined),
 			};
-			let { commits, count, countStashChildCommits } = await parseCommits(
+			let { commits, count } = await parseCommits(
 				parser,
 				isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
 				repoPath,
 				pathspec,
 				limit,
-				stashes,
+				undefined,
 				currentUser,
 			);
 
@@ -667,25 +686,67 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 						args.splice(args.length - 1, 1, pathspec);
 					}
 
-					({ commits, count, countStashChildCommits } = await parseCommits(
+					({ commits, count } = await parseCommits(
 						parser,
 						isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args),
 						repoPath,
 						pathspec,
 						limit,
-						stashes,
+						undefined,
 						currentUser,
 					));
 				}
 			}
 
+			// Merge stashes in-memory rather than via `git log --stdin <stash>` — git would
+			// walk each stash's parent chains and pull in pre-rebase ancestors that aren't
+			// reachable from <rev>. Slot each stash directly above its first parent; stashes
+			// whose parent isn't in the result (rebased away, or below the current limit) are
+			// dropped — the Stashes view still surfaces them, and they reappear here if the
+			// parent loads via "Load more".
+			if (stashes?.size) {
+				// `stashes` arrives in `git stash list` order (newest @{0} first), so per-parent
+				// groups naturally land newest-first without an explicit sort
+				const stashesByParent = new Map<string, GitStashCommit[]>();
+				for (const stash of stashes.values()) {
+					const parentSha = stash.parents[0];
+					if (parentSha == null || !commits.has(parentSha)) continue;
+
+					const group = stashesByParent.get(parentSha);
+					if (group != null) {
+						group.push(stash);
+					} else {
+						stashesByParent.set(parentSha, [stash]);
+					}
+				}
+
+				if (stashesByParent.size) {
+					const cap = limit > 0 ? limit + 1 : Number.POSITIVE_INFINITY;
+					const merged = new Map<string, GitCommit>();
+					outer: for (const c of commits.values()) {
+						const group = stashesByParent.get(c.sha);
+						if (group != null) {
+							for (const s of group) {
+								if (merged.size >= cap) break outer;
+
+								merged.set(s.sha, s);
+							}
+						}
+						if (merged.size >= cap) break;
+
+						merged.set(c.sha, c);
+					}
+					commits = merged;
+				}
+			}
+
 			const log: GitLog = {
 				repoPath: repoPath,
 				commits: commits,
 				sha: isRevisionRange(rev) ? undefined : rev,
 				count: commits.size,
 				limit: limit,
-				hasMore: overrideHasMore ?? count - countStashChildCommits > commits.size,
+				hasMore: overrideHasMore ?? (limit > 0 && count > limit),
 			};
 
 			if (!isSingleCommit) {
@@ -950,6 +1011,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 							filterMap<[string, GitCommit], [string, GitCommit]>(log.commits.entries(), ([sha, c]) => {
 								if (skip) {
 									if (sha !== rev) return undefined;
+
 									skip = false;
 								}
 
@@ -1120,6 +1182,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 			} catch (ex) {
 				scope?.error(ex);
 				if (isCancellationError(ex)) throw ex;
+
 				debugger;
 
 				return [];
@@ -1167,6 +1230,7 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 		} catch (ex) {
 			scope?.error(ex);
 			if (isCancellationError(ex)) throw ex;
+
 			debugger;
 
 			return undefined;
@@ -1367,7 +1431,10 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				{
 					cwd: repoPath,
 					errors: 'ignore',
-					caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+					caching: {
+						cache: this.cache.gitResults,
+						options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
+					},
 					configs: gitConfigsLog,
 				},
 				'log',
@@ -1394,7 +1461,10 @@ export class CommitsGitSubProvider implements GitCommitsSubProvider {
 				{
 					cwd: repoPath,
 					errors: 'ignore',
-					caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+					caching: {
+						cache: this.cache.gitResults,
+						options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
+					},
 				},
 				'cat-file',
 				'commit',

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

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { hostname, userInfo } from 'os';
 import { env as process_env } from 'process';
-import type { Cache } from '../../git/cache.js';
+import type { Cache, GkConfigInvalidationTarget } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import { WorkspaceUntrustedError } from '../../git/errors.js';
 import type { GitDir } from '../../git/models/repository.js';
@@ -27,15 +27,24 @@ import type { Git } from '../exec/git.js';
 const mappedAuthorRegex = /(.+)\s<(.+)>/;
 const emptyArray: readonly never[] = Object.freeze([]);
 
+/** Catch-all pattern matching every key in `.git/gk/config` for the one-shot bulk read. */
+const gkConfigAllPattern = '.';
+
 /**
- * Namespaces whose individual reads should be served from one --get-regex fetch instead
- * of one `git config --get` per key. The regex cache backing getGkConfigRegex dedupes
- * concurrent callers so a burst of per-branch reads produces a single subprocess.
+ * Canonicalizes a git config key for lookup against `--get-regexp` output, which git emits with the
+ * section and variable-name lowercased and only the subsection case-preserved. Without this a
+ * subsection-less key like `gk.defaultRemote` would miss the lowercased `gk.defaultremote` in the map.
  */
-const gkConfigCacheableSets: readonly { match: RegExp; pattern: string }[] = [
-	{ match: /^branch\..+\.gk-associated-issues$/, pattern: '^branch\\..+\\.gk-associated-issues$' },
-	{ match: /^branch\..+\.gk-merge-target-user$/, pattern: '^branch\\..+\\.gk-merge-target-user$' },
-];
+function canonicalizeGitConfigKey(key: string): string {
+	const first = key.indexOf('.');
+	if (first === -1) return key.toLowerCase();
+
+	const last = key.lastIndexOf('.');
+	// `section.name` (no subsection) → fully lowercased; `section.subsection.name` → lowercase
+	// section + name, preserve the case-sensitive subsection in the middle.
+	if (first === last) return key.toLowerCase();
+	return `${key.slice(0, first).toLowerCase()}${key.slice(first, last)}${key.slice(last).toLowerCase()}`;
+}
 
 /**
  * Parses git config --get-regex output into a Map.
@@ -59,6 +68,7 @@ function parseConfigRegexOutput(data: string | undefined): Map<string, string> {
 
 function parseGitBoolean(value: string | undefined): boolean {
 	if (value == null) return false;
+
 	const normalized = value.toLowerCase().trim();
 	return normalized === 'true' || normalized === 'yes' || normalized === 'on' || normalized === '1';
 }
@@ -71,6 +81,13 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		private readonly provider: CliGitProviderInternal,
 	) {}
 
+	/**
+	 * Pending `setGkConfig` writes keyed by `(commonPath, key, value, skip-option)`. Concurrent
+	 * callers writing the same `(key, value)` pair share the in-flight Promise so only one
+	 * `git config --set` subprocess actually runs. Cleared on settle.
+	 */
+	private readonly _pendingGkConfigWrites = new Map<string, Promise<void>>();
+
 	@trace()
 	getConfig(
 		repoPath: string | undefined,
@@ -243,6 +260,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	async getDefaultWorktreePath(repoPath: string): Promise<string | undefined> {
 		const gitDir = await this.getGitDir(repoPath);
 		if (gitDir == null) return undefined;
+
 		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
 		return getBestPath(normalizePath(joinPaths(basePath, '..')));
 	}
@@ -291,51 +309,56 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 	private async getGkConfigPath(repoPath: string): Promise<string | undefined> {
 		const gitDir = await this.getGitDir(repoPath);
 		if (gitDir == null) return undefined;
+
 		// Use commonUri (main .git dir) for worktrees, otherwise use uri
 		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
 		return joinPaths(basePath, 'gk', 'config');
 	}
 
 	@debug()
-	async getGkConfig(
-		repoPath: string,
-		key: GkConfigKeys | DeprecatedGkConfigKeys,
-		options?: { type?: GitConfigType },
-	): Promise<string | undefined> {
-		await this.migrateGkConfigFromGitConfig(this.cache.getCommonPath(repoPath));
+	async getGkConfig(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys): Promise<string | undefined> {
+		// Served in-memory from a single bulk read of the whole `.git/gk/config` (no gk read needs `--type`).
+		// Canonicalize the key the way git does for `--get-regexp` output so subsection-less keys
+		// (e.g. `gk.defaultRemote`) match, and coerce an empty value to undefined to match the old
+		// `git config --get` (`.trim() || undefined`) contract.
+		return (await this.getGkConfigMap(repoPath)).get(canonicalizeGitConfigKey(key)) || undefined;
+	}
 
-		// Per-branch keys are commonly read in fan-out loops (e.g. Home overview enrichment).
-		// Satisfy the read from a single --get-regex over the namespace instead of spawning
-		// one `git config --get` per branch.
-		const set = gkConfigCacheableSets.find(s => s.match.test(key));
-		if (set != null) {
-			return this.cache.getGkConfig(repoPath, key, async () => {
-				const entries = await this.getGkConfigRegex(repoPath, set.pattern);
-				return entries.get(key);
-			});
-		}
+	@debug()
+	async getGkConfigRegex(repoPath: string, pattern: string): Promise<Map<string, string>> {
+		const all = await this.getGkConfigMap(repoPath);
 
-		return this.cache.getGkConfig(repoPath, key, () => this.getGkConfigCore(repoPath, key, options));
-	}
+		// Filter the bulk map in-memory. The old path passed `pattern` to `git config --get-regex`
+		// (errors ignored → empty result on a bad pattern); preserve that no-throw contract here
+		// rather than letting an invalid-JS pattern reject the read.
+		let re: RegExp;
+		try {
+			re = new RegExp(pattern);
+		} catch {
+			return new Map();
+		}
 
-	private async getGkConfigCore(
-		repoPath: string,
-		key: string,
-		options?: { type?: GitConfigType },
-	): Promise<string | undefined> {
-		const gkConfigPath = await this.getGkConfigPath(repoPath);
-		if (!gkConfigPath) return undefined;
-		return this.getConfigCore(repoPath, key, {
-			...options,
-			runGitLocally: true,
-			file: gkConfigPath,
-		});
+		const result = new Map<string, string>();
+		for (const [k, v] of all) {
+			if (re.test(k)) {
+				result.set(k, v);
+			}
+		}
+		return result;
 	}
 
-	@debug()
-	async getGkConfigRegex(repoPath: string, pattern: string): Promise<Map<string, string>> {
+	/**
+	 * Reads the entire `.git/gk/config` in one `git config --get-regexp` and caches the parsed map
+	 * per commonPath. Per-key (getGkConfig) and per-namespace (getGkConfigRegex) lookups are served
+	 * from this single cached read — so a branch-overview render that fans out across several gk
+	 * namespaces costs one `git config` call instead of one per namespace.
+	 */
+	private async getGkConfigMap(repoPath: string): Promise<Map<string, string>> {
+		// Migrate BEFORE populating the cache, not inside the factory: a first-time migration calls
+		// clearCaches('gkConfig'), which would otherwise evict the in-flight gkConfigMap entry the
+		// cache wrapper synchronously stored and force a redundant bulk re-read.
 		await this.migrateGkConfigFromGitConfig(this.cache.getCommonPath(repoPath));
-		return this.cache.getGkConfigRegex(repoPath, pattern, () => this.getGkConfigRegexCore(repoPath, pattern));
+		return this.cache.getGkConfigMap(repoPath, () => this.getGkConfigRegexCore(repoPath, gkConfigAllPattern));
 	}
 
 	private async getGkConfigRegexCore(repoPath: string, pattern: string): Promise<Map<string, string>> {
@@ -349,6 +372,33 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		repoPath: string,
 		key: GkConfigKeys | DeprecatedGkConfigKeys,
 		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void> {
+		// Encode the skip-invalidation option in the dedup key: a self-write (with skip targets)
+		// and a user-driven write of the same `(key, value)` (no skip targets) have different
+		// cache-invalidation semantics, so sharing their Promise would silently let the user-driven
+		// write skip invalidation. Sort the array so callers passing the same targets in different
+		// orders share a single in-flight write.
+		const commonPath = this.cache.getCommonPath(repoPath);
+		const skipKey = options?.skipInvalidation?.length ? options.skipInvalidation.toSorted().join(',') : '';
+		const dedupKey = `${commonPath}\0${key}\0${value ?? ''}\0${skipKey}`;
+
+		const pending = this._pendingGkConfigWrites.get(dedupKey);
+		if (pending != null) return pending;
+
+		const promise = this.setGkConfigCore(repoPath, key, value, options);
+		this._pendingGkConfigWrites.set(dedupKey, promise);
+		// Swallow the cleanup chain's rejection so a failed write doesn't surface as an unhandled
+		// rejection separate from the caller's own handling of the returned promise.
+		void promise.finally(() => this._pendingGkConfigWrites.delete(dedupKey)).catch(() => {});
+		return promise;
+	}
+
+	private async setGkConfigCore(
+		repoPath: string,
+		key: GkConfigKeys | DeprecatedGkConfigKeys,
+		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -361,8 +411,10 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 		await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
 
-		// Invalidate the cached value for this key and clear all regex patterns for this scope
-		this.cache.deleteGkConfig(repoPath, key);
+		// Invalidate the bulk map (so the next read re-fetches) and the derived caches for this key's
+		// ref. The `.git/gk/config` file-watcher also fires `'gkConfig'` shortly after, which clears
+		// the same caches coarsely — both paths are idempotent.
+		this.cache.deleteGkConfig(repoPath, key, options);
 	}
 
 	@debug()
@@ -381,11 +433,10 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 		const sshProgram = configMap.get('gpg.ssh.program');
 		const allowedSignersFile = configMap.get('gpg.ssh.allowedsignersfile');
 
-		// Check if git config has commit signing enabled
-		const isEnabled = parseGitBoolean(enabledRaw);
-
-		// Note: To override commit signing, pass it via the host/caller.
-		// The library no longer reads a config for this.
+		// Check if git config has commit signing enabled, falling back to the host-level override
+		// (e.g. VS Code's `git.enableCommitSigning`) when `commit.gpgsign` is unset/false. The host
+		// override can only enable signing, never force it off.
+		const isEnabled = parseGitBoolean(enabledRaw) || this.context.config?.signing?.enabled === true;
 
 		return {
 			enabled: isEnabled,
@@ -648,6 +699,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 			this._migratedRepos.add(repoPath);
 			return;
 		}
+
 		const gkConfigFolder = joinPaths(gkConfigPath, '..');
 
 		// If .git/gk/config already exists, consider migration done — it was either
@@ -662,6 +714,7 @@ export class ConfigGitSubProvider implements GitConfigSubProvider {
 
 		// If .git/gk/config doesn't exist, create an empty file to prevent multiple migration attempts in future sessions
 		if (!(await this.ensureGkConfigFolder(gkConfigFolder, scope))) return;
+
 		try {
 			await fs.writeFile(gkConfigPath, new Uint8Array());
 		} catch (ex) {

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

@@ -105,7 +105,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 			return stat;
 		} catch (ex) {
 			const msg: string = ex?.toString() ?? '';
-			if (GitErrors.noMergeBase.test(msg)) {
+			if (GitErrors.noMergeBase.test(msg) || GitErrors.badRevision.test(msg)) {
 				return undefined;
 			}
 
@@ -218,7 +218,8 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		},
 	): Promise<GitFile[] | undefined> {
 		try {
-			const similarityThreshold = options?.similarityThreshold;
+			const similarityThreshold =
+				options?.similarityThreshold ?? this.context.config?.commits.similarityThreshold;
 			const configs =
 				options?.renameLimit != null
 					? [...gitConfigsDiff, '-c', `diff.renameLimit=${options.renameLimit}`]
@@ -258,6 +259,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 					for (const file of untracked) {
 						if (seen.has(file.path)) continue;
 						if (options.path && options.path !== file.path) continue;
+
 						files.push(file);
 					}
 				}
@@ -328,7 +330,12 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 			// Follow file history and specify the file path
 			args.push('--follow', '--', relativePath);
 
-			const result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog }, ...args);
+			// Unbounded --follow walk over file history can be slow on long histories — queue as background
+			// so it doesn't compete with interactive work.
+			const result = await this.git.run(
+				{ cwd: repoPath, configs: gitConfigsLog, priority: 'background' },
+				...args,
+			);
 
 			let currentSha;
 			let currentPath;