@gitkraken/core-gitlens 0.1.0 → 0.3.0

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

@@ -60,7 +60,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		repoPath: string,
 		to?: string,
 		from?: string,
-		options?: { uris?: (string | Uri)[] },
+		options?: { uris?: (string | Uri)[]; includeUntracked?: boolean },
 		_cancellation?: AbortSignal,
 	): Promise<GitDiffShortStat | undefined> {
 		const scope = getScopedLogger();
@@ -76,7 +76,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		}
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{ cwd: repoPath, configs: gitConfigsDiff },
 				'diff',
 				'--shortstat',
@@ -85,12 +85,27 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 				'--',
 				...(options?.uris?.map(p => this.provider.getRelativePath(p, repoPath)) ?? []),
 			);
-			if (!result.stdout) return undefined;
 
-			return parseGitDiffShortStat(result.stdout);
+			const stat = result.stdout ? parseGitDiffShortStat(result.stdout) : undefined;
+
+			// Merge in untracked files when the comparison involves the working tree.
+			// Skip when a pathspec filter is active — mixing a path-filtered diff count with an
+			// unfiltered untracked count would silently produce wrong totals.
+			if (options?.includeUntracked && !options.uris?.length && isWorkingTreeComparison(to, from)) {
+				const untracked = (await this.provider.status?.getUntrackedFiles?.(repoPath)) ?? [];
+				if (untracked.length) {
+					return {
+						files: (stat?.files ?? 0) + untracked.length,
+						additions: stat?.additions ?? 0,
+						deletions: stat?.deletions ?? 0,
+					};
+				}
+			}
+
+			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;
 			}
 
@@ -134,7 +149,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 
 		let result;
 		try {
-			result = await this.git.exec(
+			result = await this.git.run(
 				{ cwd: repoPath, configs: gitConfigsDiff, errors: 'throw', env: options?.index?.env },
 				'diff',
 				...args,
@@ -173,7 +188,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		contents: string,
 		_cancellation?: AbortSignal,
 	): Promise<GitDiffFiles | undefined> {
-		const result = await this.git.exec(
+		const result = await this.git.run(
 			{ cwd: repoPath, configs: gitConfigsLog, stdin: contents },
 			'apply',
 			'--numstat',
@@ -194,7 +209,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> {
 		try {
 			const similarityThreshold = options?.similarityThreshold;
@@ -202,7 +223,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 				options?.renameLimit != null
 					? [...gitConfigsDiff, '-c', `diff.renameLimit=${options.renameLimit}`]
 					: gitConfigsDiff;
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{ cwd: repoPath, configs: configs },
 				'diff',
 				'--numstat',
@@ -216,9 +237,34 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 				'--',
 				options?.path ? options.path : undefined,
 			);
-			if (!result.stdout) return undefined;
 
-			return parseGitDiffNumStatFiles(result.stdout, repoPath);
+			const files = result.stdout ? (parseGitDiffNumStatFiles(result.stdout, repoPath) ?? []) : [];
+
+			// Merge in untracked files when the comparison involves the working tree.
+			// Skip when `filters` excludes additions (untracked entries are semantically 'A'/added),
+			// or when `path` is a non-exact pathspec we can't reliably match against the untracked list.
+			if (
+				options?.includeUntracked &&
+				ref2 == null &&
+				typeof ref1OrRange === 'string' &&
+				!isRevisionRange(ref1OrRange) &&
+				!isUncommittedStaged(ref1OrRange) &&
+				filtersAllowUntracked(options.filters) &&
+				!isNonExactPathspec(options.path)
+			) {
+				const untracked = (await this.provider.status?.getUntrackedFiles?.(repoPath)) ?? [];
+				if (untracked.length) {
+					const seen = new Set(files.map(f => f.path));
+					for (const file of untracked) {
+						if (seen.has(file.path)) continue;
+						if (options.path && options.path !== file.path) continue;
+
+						files.push(file);
+					}
+				}
+			}
+
+			return files.length ? files : undefined;
 		} catch (_ex) {
 			return undefined;
 		}
@@ -283,7 +329,12 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 			// Follow file history and specify the file path
 			args.push('--follow', '--', relativePath);
 
-			const result = await this.git.exec({ 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;
@@ -511,7 +562,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 
 			args.push('--follow', rev!, '--', relativePath);
 
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{
 					cwd: repoPath,
 					configs: gitConfigsLog,
@@ -636,7 +687,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 
 			let result: GitResult;
 			try {
-				result = await this.git.exec({ cwd: repoPath, configs: gitConfigsLog }, ...args);
+				result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog }, ...args);
 			} catch (ex) {
 				if (rev && !isUncommittedStaged(rev)) throw ex;
 
@@ -659,7 +710,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 				};
 
 				args.splice(index, 1, `-L${range.startLine},${range.endLine}:${relativePath}`);
-				result = await this.git.exec({ cwd: repoPath, configs: gitConfigsLog }, ...args);
+				result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog }, ...args);
 			}
 
 			let currentRange;
@@ -761,7 +812,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		}
 
 		try {
-			return await this.git.exec(
+			return await this.git.run(
 				{ cwd: repoPath, configs: gitConfigsDiff, encoding: options?.encoding },
 				...params,
 				'--',
@@ -805,7 +856,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		params.push('--no-index');
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{
 					cwd: repoPath,
 					configs: gitConfigsDiff,
@@ -939,7 +990,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 				scope?.debug(`Using tool=${tool}`);
 			}
 
-			await this.git.exec(
+			await this.git.run(
 				{ cwd: root },
 				'difftool',
 				'--no-prompt',
@@ -978,7 +1029,7 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 				scope?.debug(`Using tool=${tool}`);
 			}
 
-			await this.git.exec({ cwd: repoPath }, 'difftool', '--dir-diff', `--tool=${tool}`, ref1, ref2);
+			await this.git.run({ cwd: repoPath }, 'difftool', '--dir-diff', `--tool=${tool}`, ref1, ref2);
 		} catch (ex) {
 			const msg: string = ex?.toString() ?? '';
 			if (msg === 'No diff tool found' || /Unknown .+? tool/.test(msg)) {
@@ -993,6 +1044,42 @@ export class DiffGitSubProvider implements GitDiffSubProvider {
 		}
 	}
 }
+// Returns true when no --diff-filter is active or when it includes additions ('A' or '*').
+// Untracked files are semantically "added" — if a caller restricts filters to e.g. ['M'],
+// honor that and omit untracked.
+function filtersAllowUntracked(filters: GitDiffFilter[] | undefined): boolean {
+	if (!filters?.length) return true;
+	return filters.includes('A') || filters.includes('*');
+}
+
+// Returns true when the path is a git pathspec we can't match with simple equality
+// (directory prefix, glob, or magic pathspec). In that case, skip the untracked merge
+// rather than risk excluding legitimate matches or including wrong ones.
+function isNonExactPathspec(path: string | undefined): boolean {
+	if (!path) return false;
+	return path.endsWith('/') || /[*?[\]]|^:/.test(path);
+}
+
+// Returns true when the `git diff` invocation shape includes the working tree
+// (i.e. `git diff`, `git diff HEAD`, or `git diff <ref>` with no `from`), and
+// therefore untracked files are a meaningful addition to the result.
+function isWorkingTreeComparison(to: string | undefined, from: string | undefined): boolean {
+	if (to == null) return true;
+	if (isRevisionRange(to) || isUncommittedStaged(to)) return false;
+
+	// `to === uncommitted` always targets the working tree (`prepareToFromDiffArgs` sets
+	// `from = 'HEAD'` when omitted, or diffs against the caller-supplied `from`).
+	if (isUncommitted(to)) return true;
+
+	// `git diff <from>` — `to === ''` means the caller explicitly asked for working tree vs `from`
+	if (to === '') return from == null || !isUncommittedStaged(from);
+
+	// `getChangedFilesCount` uses `prepareToFromDiffArgs`, which translates `to` (with no `from`)
+	// to `${to}^ ${to}` UNLESS `to` is HEAD or empty.
+	if (to.toUpperCase() === 'HEAD' && from == null) return true;
+	return false;
+}
+
 function prepareToFromDiffArgs(
 	to: string,
 	from: string | undefined,
@@ -1063,7 +1150,7 @@ export async function findPathStatusChanged(
 
 	const ordering = options?.ordering;
 
-	const result = await git.exec(
+	const result = await git.run(
 		{ cwd: repoPath, configs: gitConfigsLog },
 		'log',
 		...parser.arguments,

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

@@ -24,6 +24,7 @@ import type {
 import type { GitRemote } from '../../git/models/remote.js';
 import type { SearchQuery } from '../../git/models/search.js';
 import type { GitWorktree } from '../../git/models/worktree.js';
+import type { GitCommitReachability } from '../../git/providers/commits.js';
 import type { GitGraphSubProvider } from '../../git/providers/graph.js';
 import {
 	getBranchId,
@@ -33,6 +34,7 @@ import {
 import { getChangedFilesCount } from '../../git/utils/commit.utils.js';
 import { isUncommitted } from '../../git/utils/revision.utils.js';
 import { getSearchQueryComparisonKey, parseSearchQueryGitCommand } from '../../git/utils/search.utils.js';
+import { compareReachableRefs } from '../../git/utils/sorting.js';
 import { getTagId } from '../../git/utils/tag.utils.js';
 import { isUserMatch } from '../../git/utils/user.utils.js';
 import { getWorktreeId, groupWorktreesByBranch } from '../../git/utils/worktree.utils.js';
@@ -56,6 +58,8 @@ import { convertStashesToStdin } from './stash.js';
 
 const progressiveSearchResultsBatchTimeMs = 500; // Send updates every 500ms (2 updates/second)
 
+type ReachableRef = GitCommitReachability['refs'][number];
+
 export class GraphGitSubProvider implements GitGraphSubProvider {
 	constructor(
 		private readonly context: GitServiceContext,
@@ -87,7 +91,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		const [shaResult, stashResult, branchesResult, remotesResult, currentUserResult, worktreesResult] =
 			await Promise.allSettled([
 				!isUncommitted(rev, true)
-					? this.git.exec(
+					? this.git.run(
 							{ cwd: repoPath, configs: gitConfigsLog },
 							'log',
 							...shaParser.arguments,
@@ -96,7 +100,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							'--',
 						)
 					: undefined,
-				this.provider.stash?.getStash(repoPath, undefined, cancellation),
+				this.provider.stash?.getStash(repoPath, { includeFiles: false }, cancellation),
 				this.provider.branches.getBranches(repoPath, undefined, cancellation),
 				this.provider.remotes.getRemotes(repoPath, undefined, cancellation),
 				this.provider.config.getCurrentUser(repoPath),
@@ -138,7 +142,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		const avatars = new Map<string, string>();
 		const ids = new Set<string>();
 		const reachableFromHEAD = new Set<string>();
-		const reachableFromBranches = new Map<string, Set<string>>();
+
+		// Map<sha, Map<refKey, ref>> — inner map deduplicates refs during propagation
+		const reachableRefs = new Map<string, Map<string, ReachableRef>>();
 		const rowStats: GitGraphRowsStats = new Map<string, GitGraphRowStats>();
 		let pendingRowsStatsCount = 0;
 		let iterations = 0;
@@ -218,7 +224,6 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 								branchIdOfMainWorktree: branchIdOfMainWorktree,
 								stashes: gitStash?.stashes,
 								reachableFromHEAD: reachableFromHEAD,
-								reachableFromBranches: reachableFromBranches,
 								avatars: avatars,
 							}
 						: undefined;
@@ -229,7 +234,14 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					// - SHA + limit = 0: Find SHA, stop immediately
 					// - No SHA + limit > 0: Load exactly `limit` commits
 					// - No SHA + limit = 0: Load everything remaining
-					if ((limit && count >= limit && (!sha || found)) || (!limit && sha && found)) {
+					// - SHA + limit > 0 + still unfound past 10× limit: defensive cap so an unreachable
+					//   SHA (e.g. a stale merge-base the webview hasn't yet seen invalidated) can't
+					//   walk the entire history. `hasMore=true` lets callers retry; the graph-wrapper
+					//   side deduplicates re-requests so the cap doesn't loop.
+					if (
+						(limit && count >= limit && (!sha || found || count >= limit * 10)) ||
+						(!limit && sha && found)
+					) {
 						hasMore = true;
 						aborter.abort();
 						break;
@@ -245,6 +257,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					total++;
 					shaOrRemapped = remappedIds.get(commit.sha);
 					if (shaOrRemapped && ids.has(shaOrRemapped)) continue;
+
 					shaOrRemapped ??= commit.sha;
 
 					ids.add(shaOrRemapped);
@@ -340,34 +353,46 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 						}
 					}
 
-					if (refHeads.length > 0) {
-						let branches = reachableFromBranches.get(shaOrRemapped);
-						if (branches == null) {
-							branches = new Set<string>();
-							reachableFromBranches.set(shaOrRemapped, branches);
+					// Seed reachability from all ref types on this commit
+					if (refHeads.length > 0 || refRemoteHeads.length > 0 || refTags.length > 0) {
+						let refs = reachableRefs.get(shaOrRemapped);
+						if (refs == null) {
+							refs = new Map<string, ReachableRef>();
+							reachableRefs.set(shaOrRemapped, refs);
+						}
+						for (const h of refHeads) {
+							const key = `b:${h.name}`;
+							refs.set(key, { refType: 'branch', name: h.name, remote: false, current: h.isCurrentHead });
+						}
+						for (const r of refRemoteHeads) {
+							const name = `${r.owner}/${r.name}`;
+							refs.set(`r:${name}`, { refType: 'branch', name: name, remote: true });
 						}
-						for (const refHead of refHeads) {
-							branches.add(refHead.name);
+						for (const t of refTags) {
+							refs.set(`t:${t.name}`, { refType: 'tag', name: t.name });
 						}
 					}
 
-					const currentBranches = reachableFromBranches.get(shaOrRemapped);
-					if (currentBranches != null && currentBranches.size > 0) {
+					// Propagate reachability to parents
+					const currentRefs = reachableRefs.get(shaOrRemapped);
+					if (currentRefs != null && currentRefs.size > 0) {
 						for (parent of parents) {
-							let parentBranches = reachableFromBranches.get(parent);
-							if (parentBranches == null) {
-								parentBranches = new Set<string>();
-								reachableFromBranches.set(parent, parentBranches);
+							let parentRefs = reachableRefs.get(parent);
+							if (parentRefs == null) {
+								parentRefs = new Map<string, ReachableRef>();
+								reachableRefs.set(parent, parentRefs);
 							}
-							for (const branchName of currentBranches) {
-								parentBranches.add(branchName);
+							for (const [key, ref] of currentRefs) {
+								if (!parentRefs.has(key)) {
+									parentRefs.set(key, ref);
+								}
 							}
 						}
 					}
 
 					stash = gitStash?.stashes.get(shaOrRemapped);
 					if (stash != null) {
-						const branches = reachableFromBranches.get(shaOrRemapped);
+						const refs = reachableRefs.get(shaOrRemapped);
 						const row: GitGraphRow = {
 							sha: shaOrRemapped,
 							// Always only return the first parent for stashes, as it is a Git implementation for the index and untracked files
@@ -381,7 +406,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							heads: refHeads,
 							remotes: refRemoteHeads,
 							tags: refTags,
-							reachableFromBranches: branches ? [...branches] : undefined,
+							reachability: refs?.size
+								? { partial: true, refs: [...refs.values()].sort(compareReachableRefs) }
+								: undefined,
 							isCurrentUser: true,
 						};
 						rowProcessor?.processRow(row, graphCtx!);
@@ -397,7 +424,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					} else {
 						isCurrentUser = isUserMatch(currentUser, commit.author, commit.authorEmail);
 
-						const branches = reachableFromBranches.get(shaOrRemapped);
+						const refs = reachableRefs.get(shaOrRemapped);
 						const row: GitGraphRow = {
 							sha: shaOrRemapped,
 							parents: onlyFollowFirstParent ? parents.slice(0, 1) : parents,
@@ -410,7 +437,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							heads: refHeads,
 							remotes: refRemoteHeads,
 							tags: refTags,
-							reachableFromBranches: branches ? [...branches] : undefined,
+							reachability: refs?.size
+								? { partial: true, refs: [...refs.values()].sort(compareReachableRefs) }
+								: undefined,
 							isCurrentUser: isCurrentUser || undefined,
 						};
 						rowProcessor?.processRow(row, graphCtx!);
@@ -442,8 +471,8 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							}
 							args.push(`--${ordering}-order`, '--all');
 
-							const statsResult = await this.git.exec(
-								{ cwd: repoPath, configs: gitConfigsLog, stdin: stdin },
+							const statsResult = await this.git.run(
+								{ cwd: repoPath, configs: gitConfigsLog, stdin: stdin, priority: 'background' },
 								'log',
 								stdin ? '--stdin' : undefined,
 								...args,
@@ -455,7 +484,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 								for (const stat of statsParser.parse(statsResult.stdout)) {
 									statShaOrRemapped = remappedIds.get(stat.sha) ?? stat.sha;
 
-									// If we already have the stats for this sha, skip it (e.g. stashes)
+									// Don't overwrite stats already populated for this sha
 									if (rowStats.has(statShaOrRemapped)) continue;
 
 									rowStats.set(statShaOrRemapped, stat.stats);
@@ -485,7 +514,6 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					worktrees: worktrees,
 					worktreesByBranch: worktreesByBranch,
 					reachableFromHEAD: reachableFromHEAD,
-					reachableFromBranches: reachableFromBranches,
 					rows: rows,
 					id: sha ?? rev,
 					rowsStats: rowStats,
@@ -595,7 +623,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 				// Don't include stashes when using ref: filter, as they would add unrelated commits
 				// There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
 				({ stdin, stashes, remappedIds } = convertStashesToStdin(
-					await this.provider.stash?.getStash(repoPath, undefined, cancellation),
+					await this.provider.stash?.getStash(repoPath, { includeFiles: false }, cancellation),
 				));
 			} else {
 				remappedIds = new Map();
@@ -705,6 +733,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							runningTotal: results.size,
 							hasMore: true,
 						};
+
 						batch.length = 0;
 						lastProgressTime = Date.now();
 					}