@gitkraken/core-gitlens 0.5.113 → 0.5.115

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

@@ -57,7 +57,7 @@ import { getScopedLogger } from '../../utils/logger.scoped.js';
 import { getSettledValue } from '../../utils/promise.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { Git } from '../exec/git.js';
-import { gitConfigsLog } from '../exec/git.js';
+import { classifySearchError, gitConfigsLog } from '../exec/git.js';
 import {
 	getGraphParser,
 	getShaAndDatesLogParser,
@@ -307,7 +307,24 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		return session;
 	}
 
-	@debug()
+	@debug({
+		// The seed params (`incrementalSeed`, `reachabilitySeed`, `rowsStatsSeed`) hold cached rows/stats
+		// for potentially thousands of commits — logging them via the default formatting would dump
+		// megabytes per call, so only log their presence (and key summary fields).
+		args: (repoPath, rev, options) => ({
+			repoPath: repoPath,
+			rev: rev,
+			limit: options?.limit,
+			stats: options?.include?.stats,
+			incrementalSeed: options?.incrementalSeed && {
+				rows: options.incrementalSeed.rows.length,
+				tips: options.incrementalSeed.tips.size,
+				ordering: options.incrementalSeed.ordering,
+			},
+			reachabilitySeed: options?.reachabilitySeed != null,
+			rowsStatsSeed: options?.rowsStatsSeed != null,
+		}),
+	})
 	async getGraph(
 		repoPath: string,
 		rev: string | undefined,
@@ -1591,6 +1608,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 				options.onIncrementalResult?.({ path: 'fallback', reason: 'error' });
 			}
 			if (fast != null) {
+				void this.provider.maintenance?.request(repoPath, 'commit-graph');
 				return fast;
 			}
 
@@ -1620,6 +1638,11 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 			graph = await getCommitsForGraphCore.call(this, defaultLimit, selectSha, undefined, cancellation);
 		}
 
+		// After the first load, hint the maintenance service to backfill the commit-graph file (background)
+		// so the NEXT open's ordered walk starts emitting rows immediately instead of sorting the whole
+		// history first. Fire-and-forget — the service's demand throttle decides whether it actually runs.
+		void this.provider.maintenance?.request(repoPath, 'commit-graph');
+
 		return graph;
 	}
 
@@ -1661,6 +1684,55 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		return yield* this.searchGraphCore(repoPath, cursor.search, cursor, existingResults, options, cancellation);
 	}
 
+	/**
+	 * Cheap commit count for `search`, no result materialization — used to probe a candidate relaxed
+	 * query before offering it. Never throws: any failure (including a sha-only `commit:` query, which
+	 * can't be meaningfully "relaxed") returns 0, since this is a probe, not a search.
+	 */
+	async countSearchResults(
+		repoPath: string,
+		search: SearchQuery,
+		options?: { maxCount?: number },
+		cancellation?: AbortSignal,
+	): Promise<number> {
+		try {
+			search = { matchAll: false, matchCase: false, matchRegex: true, matchWholeWord: false, ...search };
+
+			const currentUser = search.query.includes('@me')
+				? await this.provider.config.getCurrentUser(repoPath)
+				: undefined;
+
+			const { args: searchArgs, files, shas, filters } = parseSearchQueryGitCommand(search, currentUser);
+			// An exact sha lookup can't be relaxed by dropping filter groups — nothing to count.
+			if (shas?.size) return 0;
+
+			// `--merges` matches stash commits too (they have 2-3 parents). `rev-list` gets no stdin, so the
+			// only stash that can leak in here is refs/stash's tip via `--all` -- exclude it up front
+			if (filters.type === 'merge') {
+				const allIndex = searchArgs.indexOf('--all');
+				if (allIndex !== -1) {
+					searchArgs.splice(allIndex, 0, '--exclude=refs/stash');
+				}
+			}
+
+			const maxCount = options?.maxCount ?? 1000;
+			const result = await this.git.run(
+				{ cwd: repoPath, configs: gitConfigsLog, cancellation: cancellation, errors: 'ignore' },
+				'rev-list',
+				'--count',
+				`--max-count=${maxCount}`,
+				...searchArgs,
+				'--',
+				...files,
+			);
+
+			const count = Number.parseInt(result.stdout.trim(), 10);
+			return Number.isFinite(count) ? count : 0;
+		} catch {
+			return 0;
+		}
+	}
+
 	private async *searchGraphCore(
 		repoPath: string,
 		search: SearchQuery,
@@ -1680,6 +1752,11 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 			const { args: searchArgs, files, shas, filters } = parseSearchQueryGitCommand(search, currentUser);
 
 			const tipsOnly = filters.type === 'tip';
+			// Stash commits have 2-3 parents, so `--merges` matches them; excluded from results below.
+			// Derived from the args git actually runs rather than `filters.type`, since a multi-value
+			// `type:` query (e.g. `type:merge type:tip`) leaves `--merges` in the args while
+			// `filters.type` reflects only the last value parsed
+			const mergesOnly = searchArgs.includes('--merges');
 			const parser = filters.files
 				? getShaAndDatesWithFilesLogParser(tipsOnly)
 				: getShaAndDatesLogParser(tipsOnly);
@@ -1733,9 +1810,25 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 			} else if (!filters.refs) {
 				// 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(
+				const converted = convertStashesToStdin(
 					await this.provider.stash?.getStash(repoPath, { includeFiles: false }, cancellation),
-				));
+				);
+				stashes = converted.stashes;
+				remappedIds = converted.remappedIds;
+				// `--all` already surfaces refs/stash's tip on its own, so when merges-only there's no need
+				// to walk the rest of the stash stack via stdin -- the results filter below still excludes
+				// any stash sha that slips through via refs/stash
+				stdin = mergesOnly ? undefined : converted.stdin;
+			} else if (mergesOnly) {
+				// `ref:` skips walking stashes into the results (they're unrelated to the ref), but a
+				// stash's tip can still leak in via `--merges` if the ref reaches refs/stash -- fetch
+				// stashes here purely so the results filter below can exclude them, without widening
+				// the walk via stdin
+				const converted = convertStashesToStdin(
+					await this.provider.stash?.getStash(repoPath, { includeFiles: false }, cancellation),
+				);
+				stashes = converted.stashes;
+				remappedIds = converted.remappedIds;
 			} else {
 				remappedIds = new Map();
 			}
@@ -1819,7 +1912,12 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					}
 
 					sha = remappedIds.get(r.sha) ?? r.sha;
-					if (results.has(sha) || (stashesOnly && !stashes?.has(sha)) || (tipsOnly && !r.tips)) {
+					if (
+						results.has(sha) ||
+						(stashesOnly && !stashes?.has(sha)) ||
+						(mergesOnly && stashes?.has(sha)) ||
+						(tipsOnly && !r.tips)
+					) {
 						continue;
 					}
 
@@ -1933,12 +2031,14 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					};
 				}
 
-				throw new GitSearchError(ex);
+				const classified = classifySearchError(ex);
+				throw new GitSearchError(ex, classified?.reason, classified?.detail);
 			}
 		} catch (ex) {
 			if (ex instanceof GitSearchError) throw ex;
 
-			throw new GitSearchError(ex);
+			const classified = classifySearchError(ex);
+			throw new GitSearchError(ex, classified?.reason, classified?.detail);
 		}
 	}
 }