@gitkraken/core-gitlens 0.2.0 → 0.3.1

package/src/git/watching/watchGroup.ts

@@ -54,6 +54,7 @@ export class WatchGroup implements UnifiedDisposable {
 	/** Dispose the entire group (common watcher + all root watchers). */
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const entry of this._sessions.values()) {
@@ -132,6 +133,7 @@ export class WatchGroup implements UnifiedDisposable {
 	private onCommonEvent(event: FileWatchEvent): void {
 		// Compute relative path from common git dir
 		if (!isDescendant(event.path, this.commonGitDir)) return;
+
 		const relativePath = relative(this.commonGitDir, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;
 
@@ -161,6 +163,7 @@ export class WatchGroup implements UnifiedDisposable {
 
 	private onRootEvent(event: FileWatchEvent, entry: SessionEntry): void {
 		if (!isDescendant(event.path, entry.gitDirPath)) return;
+
 		const relativePath = relative(entry.gitDirPath, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;
 

package/src/git/watching/watchService.ts

@@ -38,7 +38,16 @@ export interface WatchHandle {
 interface SessionRecord {
 	readonly session: RepositoryWatchSession;
 	readonly gitDir: GitDir;
-	readonly watchHooks?: WatchHooks;
+	/**
+	 * Hooks contributed by all current `watch()` callers for this repo path. Earlier
+	 * implementations stored just the first caller's hooks (`WatchHooks | undefined`) and
+	 * silently dropped subsequent callers' hooks — that broke the case where a low-level
+	 * subscriber (e.g. the Graph's secondary-worktree WIP watcher) opened the session
+	 * first without hooks, and a later `Repository.watch()` for the same path lost
+	 * its `markFetched` / `onIgnoresChanged` wiring. Each `watch()` call adds its hooks
+	 * to this set and removes them on dispose; fire sites iterate the set.
+	 */
+	readonly watchHooks: Set<WatchHooks>;
 	refCount: number;
 }
 
@@ -69,6 +78,8 @@ export class RepositoryWatchService implements UnifiedDisposable {
 	private readonly watchGroups = new Map<string, WatchGroup>();
 	private readonly wtWatchers = new Map<string, { watcher: FileWatcher; filter?: GitIgnoreFilter }>();
 	private _disposed = false;
+	/** Global suspend state (driven by window focus); inherited by sessions created via {@link watch}. */
+	private _suspended = false;
 
 	constructor(options: WatchServiceOptions) {
 		this.provider = options.watchingProvider;
@@ -83,6 +94,7 @@ export class RepositoryWatchService implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const record of this.sessionMap.values()) {
@@ -117,11 +129,15 @@ export class RepositoryWatchService implements UnifiedDisposable {
 		let record = this.sessionMap.get(repoPath);
 		if (record != null) {
 			record.refCount++;
+			if (watchHooks != null) {
+				record.watchHooks.add(watchHooks);
+			}
 		} else {
 			const session = new RepositoryWatchSession({
 				repoPath: repoPath,
 				defaultRepoDelayMs: this.defaultRepoDelayMs,
 				defaultWorkingTreeDelayMs: this.defaultWorkingTreeDelayMs,
+				suspended: this._suspended,
 				lifecycle: {
 					onFirstRepoSubscriber: (): void => {
 						const rec = this.sessionMap.get(repoPath);
@@ -150,10 +166,15 @@ export class RepositoryWatchService implements UnifiedDisposable {
 				},
 			});
 
+			const watchHooksSet = new Set<WatchHooks>();
+			if (watchHooks != null) {
+				watchHooksSet.add(watchHooks);
+			}
+
 			record = {
 				session: session,
 				gitDir: gitDir,
-				watchHooks: watchHooks,
+				watchHooks: watchHooksSet,
 				refCount: 1,
 			};
 			this.sessionMap.set(repoPath, record);
@@ -166,12 +187,16 @@ export class RepositoryWatchService implements UnifiedDisposable {
 			session: sessionRef,
 			dispose: (): void => {
 				if (handleDisposed) return;
+
 				handleDisposed = true;
 
 				const rec = this.sessionMap.get(repoPath);
 				if (rec == null) return;
 
 				rec.refCount--;
+				if (watchHooks != null) {
+					rec.watchHooks.delete(watchHooks);
+				}
 				if (rec.refCount <= 0) {
 					this.sessionMap.delete(repoPath);
 					this.disposeSessionRecord(rec);
@@ -185,15 +210,17 @@ export class RepositoryWatchService implements UnifiedDisposable {
 		return this.sessionMap.get(repoPath)?.session;
 	}
 
-	/** Suspend all sessions */
+	/** Suspend all sessions and mark the service suspended so late-joining sessions start suspended */
 	suspendAll(): void {
+		this._suspended = true;
 		for (const record of this.sessionMap.values()) {
 			record.session.suspend();
 		}
 	}
 
-	/** Resume all sessions, with optional per-session delay */
+	/** Resume all sessions (clearing the global suspend state), with optional per-session delay */
 	resumeAll(getDelay?: (session: RepositoryWatchSession) => number): void {
+		this._suspended = false;
 		for (const record of this.sessionMap.values()) {
 			const delayMs = getDelay?.(record.session);
 			record.session.resume(delayMs);
@@ -229,11 +256,18 @@ export class RepositoryWatchService implements UnifiedDisposable {
 				session.pushRepoChanges(changes);
 			},
 			onFetchHeadChanged: function (repoPath: string): void {
-				watchHooks?.onFetchHeadChanged?.(repoPath);
+				// Iterate at fire time so callers that joined after the group was wired up
+				// still receive events (e.g. a `Repository.watch()` whose hooks landed
+				// after a hookless `GitRepositoryService.watch` registered first).
+				for (const h of watchHooks) {
+					h.onFetchHeadChanged?.(repoPath);
+				}
 			},
 			onIgnoresChanged: (repoPath: string): void => {
 				this.refreshWorkingTreeFilter(repoPath);
-				watchHooks?.onIgnoresChanged?.(repoPath);
+				for (const h of watchHooks) {
+					h.onIgnoresChanged?.(repoPath);
+				}
 			},
 		};
 
@@ -293,7 +327,10 @@ export class RepositoryWatchService implements UnifiedDisposable {
 				if (filter != null) {
 					void filter.refresh();
 				}
-				watchHooks?.onGitIgnoreChanged?.(repoPath);
+				// See `connectToWatchGroup` for the iterate-at-fire-time rationale.
+				for (const h of watchHooks) {
+					h.onGitIgnoreChanged?.(repoPath);
+				}
 				// Don't push .gitignore itself as a working tree change
 				return;
 			}
@@ -341,6 +378,7 @@ function filterWorkingTreePaths(absolutePaths: string[], repoPath: string, filte
 	const result: string[] = [];
 	for (const p of absolutePaths) {
 		if (!isDescendant(p, repoPath)) continue;
+
 		const relativePath = relative(repoPath, p);
 		if (!filter.isIgnored(relativePath)) {
 			result.push(p);

package/src/git/watching/watchSession.ts

@@ -37,6 +37,8 @@ export interface WatchSessionOptions {
 	/** Default debounce for working tree changes. Default: 2500ms */
 	readonly defaultWorkingTreeDelayMs?: number;
 	readonly lifecycle?: WatchSessionLifecycle;
+	/** Initial suspended state — new sessions inherit the service-global suspend state. Default: false */
+	readonly suspended?: boolean;
 	/**
 	 * Called whenever a debounced repo change event is dispatched to subscribers.
 	 * Does NOT count as a subscriber — used by WatchService for
@@ -66,16 +68,16 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	private effectiveRepoMs: number;
 	private readonly defaultRepoMs: number;
 
-	private readonly wtEmitter = new Emitter<WorkingTreeChangeEvent>();
-	private readonly wtDelays = new Map<number, number>();
-	private wtNextId = 0;
-	private pendingWTPaths = new Set<string>();
-	private wtTimer: ReturnType<typeof setTimeout> | undefined;
-	private effectiveWTMs: number;
-	private readonly defaultWTMs: number;
+	private readonly workingTreeEmitter = new Emitter<WorkingTreeChangeEvent>();
+	private readonly workingTreeDelays = new Map<number, number>();
+	private workingTreeNextId = 0;
+	private pendingWorkingTreePaths = new Set<string>();
+	private workingTreeTimer: ReturnType<typeof setTimeout> | undefined;
+	private effectiveWorkingTreeMs: number;
+	private readonly defaultWorkingTreeMs: number;
 
 	private _etagWorkingTree = 0;
-	private _suspended = false;
+	private _suspended: boolean;
 	private _disposed = false;
 
 	private readonly lifecycle?: WatchSessionLifecycle;
@@ -84,11 +86,12 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	constructor(options: WatchSessionOptions) {
 		this.repoPath = options.repoPath;
 		this.defaultRepoMs = options.defaultRepoDelayMs ?? defaultRepoDelay;
-		this.defaultWTMs = options.defaultWorkingTreeDelayMs ?? defaultWorkingTreeDelay;
+		this.defaultWorkingTreeMs = options.defaultWorkingTreeDelayMs ?? defaultWorkingTreeDelay;
 		this.effectiveRepoMs = this.defaultRepoMs;
-		this.effectiveWTMs = this.defaultWTMs;
+		this.effectiveWorkingTreeMs = this.defaultWorkingTreeMs;
 		this.lifecycle = options.lifecycle;
 		this.onDidFireRepoChangeCallback = options.onDidFireRepoChange;
+		this._suspended = options.suspended ?? false;
 	}
 
 	[Symbol.dispose](): void {
@@ -97,18 +100,19 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		this.cancelRepoTimer();
-		this.cancelWTTimer();
+		this.cancelWorkingTreeTimer();
 
 		this.pendingRepoEvent = undefined;
-		this.pendingWTPaths.clear();
+		this.pendingWorkingTreePaths.clear();
 		this.repoDelays.clear();
-		this.wtDelays.clear();
+		this.workingTreeDelays.clear();
 
 		this.repoEmitter.dispose();
-		this.wtEmitter.dispose();
+		this.workingTreeEmitter.dispose();
 	}
 
 	get suspended(): boolean {
@@ -116,7 +120,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	}
 
 	get hasPendingChanges(): boolean {
-		return this.pendingRepoEvent != null || this.pendingWTPaths.size > 0;
+		return this.pendingRepoEvent != null || this.pendingWorkingTreePaths.size > 0;
 	}
 
 	get repoSubscriberCount(): number {
@@ -124,7 +128,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	}
 
 	get workingTreeSubscriberCount(): number {
-		return this.wtDelays.size;
+		return this.workingTreeDelays.size;
 	}
 
 	/**
@@ -175,6 +179,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		return Object.assign(
 			createDisposable(() => {
 				if (subDisposed) return;
+
 				subDisposed = true;
 
 				this.repoDelays.delete(id);
@@ -195,44 +200,45 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 			return Object.assign(
 				createDisposable(() => {}),
 				{
-					onDidChangeWorkingTree: this.wtEmitter.event,
+					onDidChangeWorkingTree: this.workingTreeEmitter.event,
 				},
 			);
 		}
 
-		const id = this.wtNextId++;
-		const delay = opts?.delayMs ?? this.defaultWTMs;
-		const wasEmpty = this.wtDelays.size === 0;
-		const prevDelay = this.effectiveWTMs;
+		const id = this.workingTreeNextId++;
+		const delay = opts?.delayMs ?? this.defaultWorkingTreeMs;
+		const wasEmpty = this.workingTreeDelays.size === 0;
+		const prevDelay = this.effectiveWorkingTreeMs;
 
-		this.wtDelays.set(id, delay);
-		this.recalcWTDelay();
+		this.workingTreeDelays.set(id, delay);
+		this.recalcWorkingTreeDelay();
 
 		if (wasEmpty) {
 			this.lifecycle?.onFirstWorkingTreeSubscriber?.();
 		}
 
 		// If the effective delay got shorter while a timer is running, reschedule sooner
-		if (this.effectiveWTMs < prevDelay && this.wtTimer != null) {
-			this.scheduleWTFlush();
+		if (this.effectiveWorkingTreeMs < prevDelay && this.workingTreeTimer != null) {
+			this.scheduleWorkingTreeFlush();
 		}
 
 		let subDisposed = false;
 		return Object.assign(
 			createDisposable(() => {
 				if (subDisposed) return;
+
 				subDisposed = true;
 
-				this.wtDelays.delete(id);
-				this.recalcWTDelay();
+				this.workingTreeDelays.delete(id);
+				this.recalcWorkingTreeDelay();
 
-				if (this.wtDelays.size === 0) {
-					this.cancelWTTimer();
-					this.pendingWTPaths.clear();
+				if (this.workingTreeDelays.size === 0) {
+					this.cancelWorkingTreeTimer();
+					this.pendingWorkingTreePaths.clear();
 					this.lifecycle?.onLastWorkingTreeSubscriber?.();
 				}
 			}),
-			{ onDidChangeWorkingTree: this.wtEmitter.event },
+			{ onDidChangeWorkingTree: this.workingTreeEmitter.event },
 		);
 	}
 
@@ -240,49 +246,55 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this._suspended = true;
 		// Cancel active timers — events continue to coalesce but don't fire
 		this.cancelRepoTimer();
-		this.cancelWTTimer();
+		this.cancelWorkingTreeTimer();
 	}
 
 	resume(delayMs?: number): void {
 		if (!this._suspended) return;
+
 		this._suspended = false;
 
 		// Flush accumulated changes
 		if (this.pendingRepoEvent != null) {
 			this.scheduleRepoFlush(delayMs);
 		}
-		if (this.pendingWTPaths.size > 0) {
-			this.scheduleWTFlush(delayMs);
+		if (this.pendingWorkingTreePaths.size > 0) {
+			this.scheduleWorkingTreeFlush(delayMs);
 		}
 	}
 
 	/** Inject changes (e.g., after a git operation the caller performed). Goes through debounce + suspend. */
 	fireChange(...changes: RepositoryChange[]): void {
 		if (this._disposed || changes.length === 0) return;
+
 		this.coalesceRepo(changes);
 	}
 
 	/** Immediate fire, bypassing debounce + suspend (for Closed/Opened). */
 	fireChangeImmediate(...changes: RepositoryChange[]): void {
 		if (this._disposed || changes.length === 0) return;
+
 		this.repoEmitter.fire(new WatcherRepoChangeEvent(this.repoPath, changes));
 	}
 
 	/** Push interpreted repo changes into the pipeline */
 	pushRepoChanges(changes: RepositoryChange[]): void {
 		if (this._disposed) return;
+
 		this.coalesceRepo(changes);
 	}
 
 	/** Push working tree file changes into the pipeline */
 	pushWorkingTreeChanges(paths: Iterable<string>): void {
 		if (this._disposed) return;
+
 		this._etagWorkingTree++;
-		this.coalesceWT(paths);
+		this.coalesceWorkingTrees(paths);
 	}
 
 	private static minDelay(delays: Map<number, number>, fallback: number): number {
 		if (delays.size === 0) return fallback;
+
 		let min = fallback;
 		for (const d of delays.values()) {
 			if (d < min) {
@@ -296,14 +308,18 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this.effectiveRepoMs = RepositoryWatchSession.minDelay(this.repoDelays, this.defaultRepoMs);
 	}
 
-	private recalcWTDelay(): void {
-		this.effectiveWTMs = RepositoryWatchSession.minDelay(this.wtDelays, this.defaultWTMs);
+	private recalcWorkingTreeDelay(): void {
+		this.effectiveWorkingTreeMs = RepositoryWatchSession.minDelay(
+			this.workingTreeDelays,
+			this.defaultWorkingTreeMs,
+		);
 	}
 
 	private flushRepo(): void {
 		this.repoTimer = undefined;
 		const event = this.pendingRepoEvent;
 		if (event == null) return;
+
 		this.pendingRepoEvent = undefined;
 		this.repoEmitter.fire(event);
 		this.onDidFireRepoChangeCallback?.(event);
@@ -329,29 +345,29 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this.scheduleRepoFlush();
 	}
 
-	private flushWT(): void {
-		this.wtTimer = undefined;
-		if (this.pendingWTPaths.size === 0) return;
+	private flushWorkingTree(): void {
+		this.workingTreeTimer = undefined;
+		if (this.pendingWorkingTreePaths.size === 0) return;
 
-		const paths = this.pendingWTPaths;
-		this.pendingWTPaths = new Set();
-		this.wtEmitter.fire({ repoPath: this.repoPath, paths: paths });
+		const paths = this.pendingWorkingTreePaths;
+		this.pendingWorkingTreePaths = new Set();
+		this.workingTreeEmitter.fire({ repoPath: this.repoPath, paths: paths });
 	}
 
-	private scheduleWTFlush(delayOverride?: number): void {
-		if (this._suspended || this.pendingWTPaths.size === 0) return;
+	private scheduleWorkingTreeFlush(delayOverride?: number): void {
+		if (this._suspended || this.pendingWorkingTreePaths.size === 0) return;
 
-		if (this.wtTimer != null) {
-			clearTimeout(this.wtTimer);
+		if (this.workingTreeTimer != null) {
+			clearTimeout(this.workingTreeTimer);
 		}
-		this.wtTimer = setTimeout(() => this.flushWT(), delayOverride ?? this.effectiveWTMs);
+		this.workingTreeTimer = setTimeout(() => this.flushWorkingTree(), delayOverride ?? this.effectiveWorkingTreeMs);
 	}
 
-	private coalesceWT(paths: Iterable<string>): void {
+	private coalesceWorkingTrees(paths: Iterable<string>): void {
 		for (const p of paths) {
-			this.pendingWTPaths.add(p);
+			this.pendingWorkingTreePaths.add(p);
 		}
-		this.scheduleWTFlush();
+		this.scheduleWorkingTreeFlush();
 	}
 
 	private cancelRepoTimer(): void {
@@ -361,10 +377,10 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		}
 	}
 
-	private cancelWTTimer(): void {
-		if (this.wtTimer != null) {
-			clearTimeout(this.wtTimer);
-			this.wtTimer = undefined;
+	private cancelWorkingTreeTimer(): void {
+		if (this.workingTreeTimer != null) {
+			clearTimeout(this.workingTreeTimer);
+			this.workingTreeTimer = undefined;
 		}
 	}
 }

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

@@ -1,8 +1,8 @@
 export type {
 	GitCommandPriority,
 	GitErrorHandling,
-	GitExecOptions,
+	GitRunOptions,
 	GitResult,
 	GitResultCache,
 	GitSpawnOptions,
-} from '../../git/exec.types.js';
+} from '../../git/run.types.js';

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

@@ -39,7 +39,7 @@ import { compare, fromString } from '../../utils/version.js';
 import { CancelledRunError, RunError } from './exec.errors.js';
 import type { RunOptions, RunResult } from './exec.js';
 import { fsExists, runSpawn } from './exec.js';
-import type { GitCommandPriority, GitExecOptions, GitResult, GitSpawnOptions } from './exec.types.js';
+import type { GitCommandPriority, GitResult, GitRunOptions, GitSpawnOptions } from './exec.types.js';
 import type { FilteredGitFeatures, GitFeatureOrPrefix, GitFeatures } from './features.js';
 import { gitFeaturesByVersion } from './features.js';
 import type { GitQueueConfig } from './gitQueue.js';
@@ -508,7 +508,7 @@ const trailingNewlineRegex = /[\r|\n]+$/;
 const uniqueCounterForStdin = getScopedCounter();
 const uniqueCounterForStream = getScopedCounter();
 
-type ExitCodeOnlyGitCommandOptions = GitExecOptions & { exitCodeOnly: true };
+type ExitCodeOnlyGitCommandOptions = GitRunOptions & { exitCodeOnly: true };
 
 export class Git {
 	/** Map of running git commands — avoids running duplicate overlapping commands */
@@ -636,11 +636,11 @@ export class Git {
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<unknown>>;
 	async run<T extends string | Buffer = string>(
-		options: GitExecOptions,
+		options: GitRunOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<T>>;
 	async run<T extends string | Buffer = string>(
-		options: GitExecOptions,
+		options: GitRunOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<T | unknown>> {
 		if (this.options.isTrusted?.() === false) throw new WorkspaceUntrustedError();
@@ -668,7 +668,7 @@ export class Git {
 	}
 
 	private async runCore<T extends string | Buffer>(
-		options: GitExecOptions,
+		options: GitRunOptions,
 		args: string[],
 		gitCommand: string,
 	): Promise<GitResult<T | unknown>> {
@@ -906,6 +906,7 @@ export class Git {
 		let cleanedUp = false;
 		const cleanup = () => {
 			if (cleanedUp) return;
+
 			cleanedUp = true;
 
 			try {

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

@@ -261,33 +261,62 @@ export class GitQueue {
 }
 
 /**
- * Infers priority from git command type.
- * Only downgrades to 'background' for expensive commands; never upgrades to 'interactive'.
+ * Git global options that consume the next positional arg as their value
+ * (e.g. `--work-tree <path>`). Long-form `--name=value` is already skipped by
+ * the leading-dash check, so only the separated form needs explicit handling.
+ */
+const optionsTakingValue = new Set([
+	'-c',
+	'-C',
+	'--git-dir',
+	'--work-tree',
+	'--namespace',
+	'--exec-path',
+	'--super-prefix',
+	'--config-env',
+	'--attr-source',
+	'--list-cmds',
+]);
+
+/**
+ * Infers a queue priority from the git command being invoked.
+ *
+ * Intentionally narrow: only returns 'background' for commands that are
+ * *always* read-only AND *always* potentially expensive. Polymorphic commands
+ * like `log` and `rev-list` (which can be quick bounded lookups or full-history
+ * walks) are deliberately omitted — call sites that perform heavy walks must
+ * pass `priority: 'background'` explicitly. Never upgrades to 'interactive'.
+ *
+ * No subcommand awareness (e.g. `stash list`, `branch -l`): the risk of
+ * misclassifying a write subcommand as background outweighs the gain.
  */
 export function inferGitCommandPriority(args: readonly (string | undefined)[]): GitCommandPriority {
-	let skip = false;
 	let command: string | undefined;
-	for (const a of args) {
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i];
 		if (a == null) continue;
-		if (skip) {
-			skip = false;
-			continue;
-		}
-		if (a === '-c' || a === '-C') {
-			skip = true;
+		if (optionsTakingValue.has(a)) {
+			const next = args[i + 1];
+			if (next != null && !next.startsWith('-')) {
+				i++;
+			}
 			continue;
 		}
 		if (a.startsWith('-')) continue;
+
 		command = a;
 		break;
 	}
 
 	switch (command) {
-		case 'log':
-		case 'rev-list':
 		case 'for-each-ref':
 		case 'shortlog':
 		case 'reflog':
+		case 'name-rev':
+		case 'describe':
+		case 'cherry':
+		case 'count-objects':
+		case 'fsck':
 			return 'background';
 		default:
 			return 'normal';

package/src/git-cli/parsers/blameParser.ts

@@ -342,6 +342,7 @@ export async function* parseGitBlameAsync(stream: AsyncIterable<string>): AsyncG
 			case 0x66 /* f — filename */:
 				entry.path = line.substring(valueStart);
 				yield entry;
+
 				entry = undefined;
 				break;
 

package/src/git-cli/parsers/logParser.ts

@@ -420,6 +420,7 @@ function createLogParserWithFilesAndStats<T extends Record<string, string> | voi
 
 				endIndex = line.indexOf(' ', startIndex);
 				if (endIndex === -1) continue;
+
 				const newMode = line.substring(startIndex, endIndex);
 
 				// Parse old_sha and new_sha positions