@gitkraken/core-gitlens 0.5.109 → 0.5.111

package/src/git/watching/classifyChange.ts

@@ -1,7 +1,7 @@
 import type { RepositoryChange } from '../models/repository.js';
 
 const classifyRegex =
-	/(worktrees|index|HEAD|FETCH_HEAD|ORIG_HEAD|CHERRY_PICK_HEAD|MERGE_HEAD|REBASE_HEAD|rebase-merge|rebase-apply|sequencer|REVERT_HEAD|config|gk\/config|info\/exclude|refs\/(?:heads|remotes|stash|tags))/;
+	/(worktrees|index|HEAD|FETCH_HEAD|ORIG_HEAD|CHERRY_PICK_HEAD|MERGE_HEAD|REBASE_HEAD|rebase-merge|rebase-apply|sequencer|REVERT_HEAD|config|gk\/config|info\/exclude|refs\/(?:heads|remotes|stash|tags)|packed-refs)/;
 
 /**
  * Maps a path relative to a `.git` directory to the corresponding
@@ -69,6 +69,13 @@ export function classifyGitDirChange(relativePath: string): RepositoryChange[] |
 		case 'sequencer':
 			return ['pausedOp'];
 
+		// `'heads'` is deliberately the ONLY thing a `refs/heads/*` event yields, including a create. It is
+		// tempting to read a create as "a new branch exists under this name" and use it to drop anything
+		// derived from the old branch's identity (its base, its merge target). That signal does not mean
+		// what it looks like: git rewrites an EXISTING loose ref by writing `<name>.lock` and renaming it
+		// over the file, which watchers report as a create of the destination — so every ordinary commit
+		// would look like a new branch and discard a live branch's metadata. Nothing here can distinguish
+		// the two; identity changes are handled where GitLens performs the operation itself.
 		case 'refs/heads':
 			return ['heads'];
 
@@ -81,6 +88,13 @@ export function classifyGitDirChange(relativePath: string): RepositoryChange[] |
 		case 'refs/tags':
 			return ['tags'];
 
+		// A `packed-refs` rewrite (after `git pack-refs` or `git gc`) changes ref state
+		// WITHOUT any `refs/**` file event — deleting a packed branch, for example, only
+		// rewrites this file. The file content is not inspected here, so classification
+		// is deliberately broad: it can add, remove, or move refs of any of these types.
+		case 'packed-refs':
+			return ['heads', 'remotes', 'tags'];
+
 		case 'worktrees':
 			return ['worktrees'];
 

package/src/git/watching/watchService.ts

@@ -11,6 +11,13 @@ import type { WatchGroupHooks } from './watchGroup.js';
 import { WatchGroup } from './watchGroup.js';
 import { RepositoryWatchSession } from './watchSession.js';
 
+/**
+ * Cap on paths held while the gitignore filter loads. Higher than the session's own cap because these are
+ * pre-filter — most of a build's output is typically gitignored and would be discarded on replay, so a
+ * tighter bound here would mark batches incomplete when they filter down to almost nothing.
+ */
+const maxBufferedWorkingTreePaths = 5000;
+
 export interface WatchServiceOptions {
 	readonly watchingProvider: FileWatchingProvider;
 	/** Default debounce for repo changes when subscriber doesn't specify. Default: 250ms */
@@ -308,6 +315,7 @@ export class RepositoryWatchService implements UnifiedDisposable {
 		// Buffer events while the gitignore filter loads, then replay
 		let filterReady = filter == null;
 		let buffered: string[] | undefined = filter != null ? [] : undefined;
+		let bufferIncomplete = false;
 
 		if (filter != null) {
 			void filter
@@ -316,11 +324,12 @@ export class RepositoryWatchService implements UnifiedDisposable {
 					filterReady = true;
 					if (buffered?.length) {
 						const paths = filterWorkingTreePaths(buffered, repoPath, filter);
-						if (paths.length > 0) {
-							session.pushWorkingTreeChanges(paths);
+						if (paths.length > 0 || bufferIncomplete) {
+							session.pushWorkingTreeChanges(paths, bufferIncomplete);
 						}
 					}
 					buffered = undefined;
+					bufferIncomplete = false;
 				})
 				.catch(() => {
 					filterReady = true;
@@ -351,7 +360,15 @@ export class RepositoryWatchService implements UnifiedDisposable {
 			}
 
 			if (!filterReady) {
-				// Buffer until gitignore filter is ready
+				// Buffer until the gitignore filter is ready. Capped: `ready()` awaits a `core.excludesFile`
+				// read, which queues behind every other git command, so this window can stay open for a long
+				// time — and these paths haven't been gitignore-filtered yet, so a build's output all lands
+				// here. Past the cap, stop retaining and mark the batch partial rather than growing.
+				if (buffered != null && buffered.length >= maxBufferedWorkingTreePaths) {
+					bufferIncomplete = true;
+					return;
+				}
+
 				buffered?.push(event.path);
 				return;
 			}

package/src/git/watching/watchSession.ts

@@ -56,6 +56,15 @@ export interface WatchSessionOptions {
 const defaultRepoDelay = 250;
 const defaultWorkingTreeDelay = 2500;
 
+/**
+ * Cap on retained working-tree paths per flush. The set otherwise grows without bound — while the window
+ * is unfocused the session is suspended, so a branch switch or build accumulates every touched path until
+ * refocus. Set low deliberately: ordinary edits are a handful of paths, anything past this was a
+ * refresh-everything event anyway, and dropping past it only costs the matching consumers a
+ * conservative refresh.
+ */
+const maxWorkingTreePaths = 1000;
+
 /**
  * Per-repository session that owns the debounce/coalesce/suspend
  * pipeline for both repo (.git) and working-tree changes.
@@ -78,6 +87,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	private readonly workingTreeDelays = new Map<number, number>();
 	private workingTreeNextId = 0;
 	private pendingWorkingTreePaths = new Set<string>();
+	private pendingWorkingTreeIncomplete = false;
 	private workingTreeTimer: ReturnType<typeof setTimeout> | undefined;
 	private effectiveWorkingTreeMs: number;
 	private readonly defaultWorkingTreeMs: number;
@@ -116,6 +126,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 
 		this.pendingRepoEvent = undefined;
 		this.pendingWorkingTreePaths.clear();
+		this.pendingWorkingTreeIncomplete = false;
 		this.repoDelays.clear();
 		this.workingTreeDelays.clear();
 
@@ -128,7 +139,15 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	}
 
 	get hasPendingChanges(): boolean {
-		return this.pendingRepoEvent != null || this.pendingWorkingTreePaths.size > 0;
+		return this.pendingRepoEvent != null || this.hasPendingWorkingTreeChanges;
+	}
+
+	/**
+	 * An incomplete batch with no surviving paths still has to fire: the caller dropped paths we never saw, so
+	 * gating the pipeline on the retained set alone would swallow the change entirely.
+	 */
+	private get hasPendingWorkingTreeChanges(): boolean {
+		return this.pendingWorkingTreePaths.size > 0 || this.pendingWorkingTreeIncomplete;
 	}
 
 	get repoSubscriberCount(): number {
@@ -243,6 +262,9 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 				if (this.workingTreeDelays.size === 0) {
 					this.cancelWorkingTreeTimer();
 					this.pendingWorkingTreePaths.clear();
+					// Dropped with the paths it describes — a stale flag would make the next subscriber's
+					// first ordinary flush claim a partial set and force needless full refreshes.
+					this.pendingWorkingTreeIncomplete = false;
 					this.lifecycle?.onLastWorkingTreeSubscriber?.();
 				}
 			}),
@@ -266,7 +288,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		if (this.pendingRepoEvent != null) {
 			this.scheduleRepoFlush(delayMs);
 		}
-		if (this.pendingWorkingTreePaths.size > 0) {
+		if (this.hasPendingWorkingTreeChanges) {
 			this.scheduleWorkingTreeFlush(delayMs);
 		}
 	}
@@ -298,10 +320,14 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	}
 
 	/** Push working tree file changes into the pipeline */
-	pushWorkingTreeChanges(paths: Iterable<string>): void {
+	/** `incomplete` marks the batch as partial when the caller already dropped paths of its own. */
+	pushWorkingTreeChanges(paths: Iterable<string>, incomplete?: boolean): void {
 		if (this._disposed) return;
 
 		this._etagWorkingTree++;
+		if (incomplete) {
+			this.pendingWorkingTreeIncomplete = true;
+		}
 		this.coalesceWorkingTrees(paths);
 	}
 
@@ -362,18 +388,20 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 
 	private flushWorkingTree(): void {
 		this.workingTreeTimer = undefined;
-		if (this.pendingWorkingTreePaths.size === 0) return;
+		if (!this.hasPendingWorkingTreeChanges) return;
 
 		const paths = this.pendingWorkingTreePaths;
+		const incomplete = this.pendingWorkingTreeIncomplete;
 		this.pendingWorkingTreePaths = new Set();
+		this.pendingWorkingTreeIncomplete = false;
 		// Advance the cache's status clock (via WatchService's global forwarding) BEFORE notifying subscribers,
 		// so a subscriber that synchronously reads status sees the post-change generation, not a joinable pre-change run.
 		this.onDidFireWorkingTreeChangeCallback?.(this.repoPath);
-		this.workingTreeEmitter.fire({ repoPath: this.repoPath, paths: paths });
+		this.workingTreeEmitter.fire({ repoPath: this.repoPath, paths: paths, incomplete: incomplete });
 	}
 
 	private scheduleWorkingTreeFlush(delayOverride?: number): void {
-		if (this._suspended || this.pendingWorkingTreePaths.size === 0) return;
+		if (this._suspended || !this.hasPendingWorkingTreeChanges) return;
 
 		if (this.workingTreeTimer != null) {
 			clearTimeout(this.workingTreeTimer);
@@ -383,6 +411,13 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 
 	private coalesceWorkingTrees(paths: Iterable<string>): void {
 		for (const p of paths) {
+			// Stop retaining paths past the cap, but keep draining the iterable — the flag is what makes the
+			// partial set safe to consume, and dropping out early would leave later paths for the next window.
+			if (this.pendingWorkingTreePaths.size >= maxWorkingTreePaths && !this.pendingWorkingTreePaths.has(p)) {
+				this.pendingWorkingTreeIncomplete = true;
+				continue;
+			}
+
 			this.pendingWorkingTreePaths.add(p);
 		}
 		this.scheduleWorkingTreeFlush();

package/src/git/watching/watcherPatterns.ts

@@ -8,7 +8,7 @@ const dotGitFiles =
 const dotGitWorktreeFiles =
 	'worktrees/*,worktrees/**/index,worktrees/**/HEAD,worktrees/**/*_HEAD,worktrees/**/MERGE_*,worktrees/**/rebase-merge,worktrees/**/rebase-merge/**,worktrees/**/rebase-apply,worktrees/**/rebase-apply/**,worktrees/**/sequencer,worktrees/**/sequencer/**';
 
-const dotGitCommonFiles = `config,gk/config,refs/**,info/exclude,FETCH_HEAD,${dotGitWorktreeFiles}`;
+const dotGitCommonFiles = `config,gk/config,refs/**,packed-refs,info/exclude,FETCH_HEAD,${dotGitWorktreeFiles}`;
 
 /** For standard repos (no worktrees): single watcher covering all .git files */
 export const dotGitGlobCombined = `{${dotGitFiles},${dotGitCommonFiles}}`;

package/src/git-cli/exec/git.ts

@@ -71,7 +71,6 @@ export const GitErrors = {
 	changesWouldBeOverwritten:
 		/Your local changes to the following files would be overwritten|Your local changes would be overwritten|overwritten by checkout/i,
 	cherryPickAborted: /cherry-pick.*aborted/i,
-	cherryPickEmptyPrevious: /The previous cherry-pick is now empty/i,
 	cherryPickInProgress: /cherry-pick is already in progress|You have not concluded your cherry-pick/i,
 	commitChangesFirst: /Please, commit your changes before you can/i,
 	conflict: /^CONFLICT \([^)]+\): \b/m,
@@ -100,6 +99,7 @@ export const GitErrors = {
 	noPausedOperation:
 		/no merge (?:in progress|to abort)|no cherry-pick(?: or revert)? in progress|no rebase in progress/i,
 	permissionDenied: /Permission.*denied/i,
+	previousOperationEmpty: /The previous (?:cherry-pick|revert) is now empty/i,
 	pushRejected: /^error:\s*failed to push some refs to\b/m,
 	pushRejectedRefDoesNotExists: /error:\s*unable to delete '(.*?)': remote ref does not exist/m,
 	rebaseAborted: /Nothing to do|rebase.*aborted/i,
@@ -242,7 +242,7 @@ const errorToReasonMap = new Map<GitCommand, [RegExp, GitCommandToReasonMap[GitC
 			[GitErrors.cherryPickAborted, 'aborted'],
 			[GitErrors.cherryPickInProgress, 'alreadyInProgress'],
 			[GitErrors.conflict, 'conflicts'],
-			[GitErrors.cherryPickEmptyPrevious, 'emptyCommit'],
+			[GitErrors.previousOperationEmpty, 'emptyCommit'],
 			[GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
 		],
 	],
@@ -277,13 +277,23 @@ const errorToReasonMap = new Map<GitCommand, [RegExp, GitCommandToReasonMap[GitC
 	[
 		'paused-operation-continue',
 		[
-			[GitErrors.cherryPickEmptyPrevious, 'emptyCommit'],
+			[GitErrors.previousOperationEmpty, 'emptyCommit'],
 			[GitErrors.noPausedOperation, 'nothingToContinue'],
 			[GitErrors.uncommittedChanges, 'uncommittedChanges'],
 			[GitErrors.unmergedFiles, 'unmergedFiles'],
 			[GitErrors.unresolvedConflicts, 'conflicts'],
 			[GitErrors.unstagedChanges, 'unstagedChanges'],
 			[GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
+			// A single (non-sequencer) revert resolved to a no-op never gets git's "previous revert is now
+			// empty" message — its `--continue` falls through to the commit, which reports having nothing to
+			// commit. Mid-paused-op that means the step became empty, so it earns the same choice.
+			//
+			// Kept LAST because the pattern is deliberately broad: it also matches "no changes added to
+			// commit" and "nothing added to commit", which appear alongside the more specific unmerged /
+			// conflict / unstaged messages. Matching first would shadow those. It isn't narrowed to the
+			// "working tree clean" variant because an empty step with untracked files present instead reports
+			// "nothing added to commit but untracked files present".
+			[GitErrors.nothingToCommit, 'emptyCommit'],
 		],
 	],
 	[