@gitkraken/core-gitlens 0.1.0 → 0.3.0

package/src/git/watching/watchSession.ts

@@ -97,6 +97,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		this.cancelRepoTimer();
@@ -175,6 +176,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		return Object.assign(
 			createDisposable(() => {
 				if (subDisposed) return;
+
 				subDisposed = true;
 
 				this.repoDelays.delete(id);
@@ -221,6 +223,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		return Object.assign(
 			createDisposable(() => {
 				if (subDisposed) return;
+
 				subDisposed = true;
 
 				this.wtDelays.delete(id);
@@ -245,6 +248,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 
 	resume(delayMs?: number): void {
 		if (!this._suspended) return;
+
 		this._suspended = false;
 
 		// Flush accumulated changes
@@ -259,30 +263,35 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 	/** 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);
 	}
 
 	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) {
@@ -304,6 +313,7 @@ export class RepositoryWatchSession implements UnifiedDisposable {
 		this.repoTimer = undefined;
 		const event = this.pendingRepoEvent;
 		if (event == null) return;
+
 		this.pendingRepoEvent = undefined;
 		this.repoEmitter.fire(event);
 		this.onDidFireRepoChangeCallback?.(event);

package/src/git-cli/cliGitProvider.ts

@@ -146,7 +146,7 @@ export class CliGitProvider implements GitProvider {
 			folderPath = joinPaths(parentPath, `${remoteName}-${count}`);
 		}
 
-		await this._git.exec({ cwd: parentPath }, 'clone', url, folderPath);
+		await this._git.run({ cwd: parentPath }, 'clone', url, folderPath);
 
 		return folderPath;
 	}

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

@@ -17,6 +17,7 @@ import type {
 	ResetErrorReason,
 	RevertErrorReason,
 	ShowErrorReason,
+	SigningErrorReason,
 	StashApplyErrorReason,
 	StashPushErrorReason,
 	TagErrorReason,
@@ -24,6 +25,7 @@ import type {
 	WorktreeDeleteErrorReason,
 } from '../../git/errors.js';
 import { WorkspaceUntrustedError } from '../../git/errors.js';
+import type { SigningFormat } from '../../git/models/signature.js';
 import { CancellationError, getAbortSignalId, isCancellationError } from '../../utils/cancellation.js';
 import { getScopedCounter } from '../../utils/counter.js';
 import { getDurationMilliseconds, hrtime } from '../../utils/hrtime.js';
@@ -37,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';
@@ -74,6 +76,8 @@ export const GitErrors = {
 	detachedHead: /You are in 'detached HEAD' state/i,
 	entryNotUpToDate: /error:\s*Entry ['"].+['"] not uptodate\. Cannot merge\./i,
 	failedToDeleteDirectoryNotEmpty: /failed to delete '(.*?)': Directory not empty/i,
+	gpgNotFound: /gpg:?\s*(?:command\s+)?not found|'gpg' is not recognized as|cannot run gpg:/i,
+	gpgSignFailed: /^error:\s*gpg failed to sign the data/im,
 	invalidName: /fatal:\s*'.+?' is not a valid branch name/i,
 	invalidLineCount: /file .+? has only (\d+) lines/i,
 	invalidObjectName: /invalid object name: (.*)\s/i,
@@ -106,6 +110,8 @@ export const GitErrors = {
 	remoteAhead: /rejected because the remote contains work/i,
 	remoteConnectionFailed: /Could not read from remote repository/i,
 	remoteRejected: /rejected because the remote contains work/i,
+	signingKeyNotAvailable: /secret key not available|no secret key|no signing key/i,
+	sshNotFound: /ssh-keygen[^\n]*(?:not found|No such file or directory|is not recognized)/i,
 	stashConflictingStagedAndUnstagedLines: /Cannot remove worktree changes/i,
 	stashNothingToSave: /No local changes to save/i,
 	stashSavedWorkingDirAndIndexState: /Saved working directory and index state/i,
@@ -413,6 +419,52 @@ export function getGitCommandError<T extends GitCommand, TReturn extends GitComm
 	return creator(undefined);
 }
 
+function extractSigningErrorText(ex: unknown): string {
+	if (ex == null) return '';
+	if (ex instanceof GitError) return ex.stderr || ex.stdout || ex.message || '';
+	if (ex instanceof Error) return ex.message || '';
+	if (typeof ex === 'string') return ex;
+	if (typeof ex === 'number' || typeof ex === 'boolean' || typeof ex === 'bigint') return String(ex);
+	if (typeof ex === 'object' && 'message' in ex && typeof ex.message === 'string') return ex.message;
+	return '';
+}
+
+/**
+ * Classifies a Git error as a signing-related failure using the {@link GitErrors}
+ * signing regexes. Returns the matched {@link SigningErrorReason}, or `undefined`
+ * when the error is not a recognized signing failure.
+ *
+ * Precedence is significant: `passphraseFailed` (gpg sign failure) is checked
+ * before `noKey`, matching the ordering used historically in patch.ts — a
+ * combined stderr like "error: gpg failed to sign … gpg: No secret key"
+ * resolves to `passphraseFailed`, the outer cause.
+ */
+export function classifySigningError(ex: unknown): SigningErrorReason | undefined {
+	const text = extractSigningErrorText(ex);
+	if (!text) return undefined;
+	if (GitErrors.gpgSignFailed.test(text)) return 'passphraseFailed';
+	if (GitErrors.signingKeyNotAvailable.test(text)) return 'noKey';
+	if (GitErrors.gpgNotFound.test(text)) return 'gpgNotFound';
+	if (GitErrors.sshNotFound.test(text)) return 'sshNotFound';
+	return undefined;
+}
+
+/**
+ * Infers the {@link SigningFormat} from stderr hints (e.g., mentions of
+ * `ssh-keygen` or `gpg.ssh.*` config keys). Returns `undefined` when no hints
+ * are present so callers can supply their own default (typically `'gpg'`).
+ *
+ * Used as a fallback when `config.getSigningConfig` is unavailable or rejects
+ * on the error path.
+ */
+export function inferSigningFormatFromError(ex: unknown): SigningFormat | undefined {
+	const text = extractSigningErrorText(ex);
+	if (!text) return undefined;
+	if (/\bssh-keygen\b|gpg\.ssh\.(?:program|allowedsignersfile)/i.test(text)) return 'ssh';
+	if (/\bgpg\b/i.test(text)) return 'gpg';
+	return undefined;
+}
+
 export interface GitOptions {
 	/** Custom environment variables to add to every git command */
 	env?: Record<string, string | undefined>;
@@ -456,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 */
@@ -579,16 +631,16 @@ export class Git {
 		);
 	}
 
-	async exec(
+	async run(
 		options: ExitCodeOnlyGitCommandOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<unknown>>;
-	async exec<T extends string | Buffer = string>(
-		options: GitExecOptions,
+	async run<T extends string | Buffer = string>(
+		options: GitRunOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<T>>;
-	async exec<T extends string | Buffer = string>(
-		options: GitExecOptions,
+	async run<T extends string | Buffer = string>(
+		options: GitRunOptions,
 		...args: readonly (string | undefined)[]
 	): Promise<GitResult<T | unknown>> {
 		if (this.options.isTrusted?.() === false) throw new WorkspaceUntrustedError();
@@ -602,7 +654,7 @@ export class Git {
 				options.caching.commonPath ?? options.cwd!,
 				gitCommand,
 				async cacheable => {
-					const result = await this.execCore<T>({ ...options, caching: undefined }, runArgs, gitCommand);
+					const result = await this.runCore<T>({ ...options, caching: undefined }, runArgs, gitCommand);
 					if (result.exitCode !== 0) {
 						cacheable.invalidate();
 					}
@@ -612,11 +664,11 @@ export class Git {
 			);
 		}
 
-		return this.execCore<T>(options, runArgs, gitCommand);
+		return this.runCore<T>(options, runArgs, gitCommand);
 	}
 
-	private async execCore<T extends string | Buffer>(
-		options: GitExecOptions,
+	private async runCore<T extends string | Buffer>(
+		options: GitRunOptions,
 		args: string[],
 		gitCommand: string,
 	): Promise<GitResult<T | unknown>> {
@@ -679,7 +731,7 @@ export class Git {
 			// Execute through the queue (interactive/normal run immediately, background is throttled)
 			const gitPath = await this.path();
 			void this._queue
-				.execute(priority, () => runSpawn<T>(gitPath, args, encoding ?? 'utf8', runOpts))
+				.run(priority, () => runSpawn<T>(gitPath, args, encoding ?? 'utf8', runOpts), cancellation)
 				.then(deferred.fulfill, (e: unknown) => deferred.cancel(e instanceof Error ? e : new Error(String(e))))
 				.finally(() => {
 					this.pendingCommands.delete(cacheKey);
@@ -695,8 +747,8 @@ export class Git {
 		try {
 			result = await promise;
 			return {
-				stdout: result.stdout as T,
-				stderr: result.stderr as T | undefined,
+				stdout: result.stdout,
+				stderr: result.stderr,
 				exitCode: result.exitCode ?? 0,
 			};
 		} catch (ex) {
@@ -723,15 +775,15 @@ export class Git {
 			if (errorHandling === 'ignore') {
 				if (ex instanceof RunError) {
 					return {
-						stdout: ex.stdout as T,
-						stderr: ex.stderr as T | undefined,
+						stdout: ex.stdout,
+						stderr: ex.stderr,
 						exitCode: ex.code != null ? (typeof ex.code === 'number' ? ex.code : parseInt(ex.code, 10)) : 0,
 						cancelled: ex instanceof CancelledRunError,
 					};
 				}
 
 				return {
-					stdout: '' as T,
+					stdout: '',
 					stderr: undefined,
 					exitCode: 0,
 					cancelled: ex instanceof CancelledRunError,
@@ -747,7 +799,7 @@ export class Git {
 
 			defaultExceptionHandler(exception, options.cwd, start);
 			exception = undefined;
-			return { stdout: '' as T, stderr: result?.stderr as T | undefined, exitCode: result?.exitCode ?? 0 };
+			return { stdout: '', stderr: result?.stderr, exitCode: result?.exitCode ?? 0 };
 		} finally {
 			this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), waiting);
 		}
@@ -854,6 +906,7 @@ export class Git {
 		let cleanedUp = false;
 		const cleanup = () => {
 			if (cleanedUp) return;
+
 			cleanedUp = true;
 
 			try {
@@ -888,7 +941,7 @@ export class Git {
 						for await (const chunk of proc.stdout) {
 							buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
 						}
-						yield await decode(Buffer.concat(buffers as ReadonlyArray<Uint8Array>), { encoding: enc });
+						yield await decode(Buffer.concat(buffers), { encoding: enc });
 					}
 				}
 			} finally {
@@ -914,7 +967,7 @@ export class Git {
 	}
 
 	async rev_parse__git_dir(cwd: string): Promise<{ path: string; commonPath?: string } | undefined> {
-		const result = await this.exec({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--git-dir', '--git-common-dir');
+		const result = await this.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--git-dir', '--git-common-dir');
 		if (!result.stdout) return undefined;
 
 		// Keep trailing spaces which are part of the directory name
@@ -946,7 +999,7 @@ export class Git {
 			// Check if the folder is a bare clone: if it has a file named HEAD && `rev-parse --show-cdup` is empty
 			if (await fsExists(joinPaths(cwd, 'HEAD'))) {
 				try {
-					result = await this.exec(
+					result = await this.run(
 						{ cwd: cwd, errors: 'throw', configs: ['-C', cwd] },
 						'rev-parse',
 						'--show-cdup',
@@ -962,7 +1015,7 @@ export class Git {
 		}
 
 		try {
-			result = await this.exec({ cwd: cwd, errors: 'throw' }, 'rev-parse', '--show-toplevel');
+			result = await this.run({ cwd: cwd, errors: 'throw' }, 'rev-parse', '--show-toplevel');
 			// Make sure to normalize: https://github.com/git-for-windows/git/issues/2478
 			// Keep trailing spaces which are part of the directory name
 			return !result.stdout
@@ -985,7 +1038,7 @@ export class Git {
 			const inDotGit = GitWarnings.mustRunInWorkTree.test(ex.stderr ?? '');
 			// Check if we are in a bare clone
 			if (inDotGit && this.options.isTrusted?.() !== false) {
-				result = await this.exec({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
+				result = await this.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
 				if (result.stdout.trim() === 'true') {
 					const result = await this.rev_parse__git_dir(cwd);
 					const repoPath = result?.commonPath ?? result?.path;

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

@@ -1,11 +1,13 @@
 import type { GitCommandPriority } from './exec.types.js';
 
 interface QueuedCommand {
-	execute: () => Promise<unknown>;
+	run: () => Promise<unknown>;
 	resolve: (value: unknown) => void;
 	reject: (reason: unknown) => void;
 	queuedAt: number;
 	priority: GitCommandPriority;
+	signal?: AbortSignal;
+	abortHandler?: () => void;
 }
 
 /** Priority levels in descending order (highest first) */
@@ -14,6 +16,10 @@ const priorities: GitCommandPriority[] = ['interactive', 'normal', 'background']
 /** How many extra slots interactive commands can use when at capacity */
 const interactiveBurstCapacity = 2;
 
+function abortReason(signal: AbortSignal): Error {
+	return signal.reason instanceof Error ? signal.reason : new Error('Aborted');
+}
+
 export interface GitQueueConfig {
 	/** Maximum number of concurrent git processes. Defaults to 7. */
 	maxConcurrent?: number;
@@ -67,6 +73,9 @@ export class GitQueue {
 		this._disposed = true;
 		for (const queue of this._queues.values()) {
 			for (const cmd of queue) {
+				if (cmd.signal != null && cmd.abortHandler != null) {
+					cmd.signal.removeEventListener('abort', cmd.abortHandler);
+				}
 				cmd.reject(new Error('GitQueue disposed'));
 			}
 			queue.length = 0;
@@ -89,7 +98,7 @@ export class GitQueue {
 	}
 
 	/** Check if a command at the given priority can execute immediately */
-	private canExecuteNow(priority: GitCommandPriority): boolean {
+	private canRunNow(priority: GitCommandPriority): boolean {
 		// Must yield to higher priority waiting
 		if (this.hasHigherPriorityWaiting(priority)) return false;
 
@@ -115,20 +124,32 @@ export class GitQueue {
 		return false;
 	}
 
-	/** Execute a git command with the specified priority */
-	execute<T>(priority: GitCommandPriority, fn: () => Promise<T>): Promise<T> {
+	/**
+	 * Execute a git command with the specified priority.
+	 *
+	 * When `signal` is provided:
+	 * - If already aborted, rejects immediately without running.
+	 * - If aborted while queued, the command is removed from the queue and rejected before it ever runs.
+	 * - If aborted while running, the in-flight spawn must honor the same signal separately
+	 *   (callers pass it via `runOpts.cancellation`); the queue does not interrupt running work.
+	 */
+	run<T>(priority: GitCommandPriority, fn: () => Promise<T>, signal?: AbortSignal): Promise<T> {
 		if (this._disposed) {
 			return Promise.reject(new Error('GitQueue disposed'));
 		}
 
-		if (!this.canExecuteNow(priority)) {
-			return this.enqueue(fn, priority);
+		if (signal?.aborted) {
+			return Promise.reject(abortReason(signal));
 		}
 
-		return this.run(fn);
+		if (!this.canRunNow(priority)) {
+			return this.enqueue(fn, priority, signal);
+		}
+
+		return this.runcore(fn);
 	}
 
-	private async run<T>(fn: () => Promise<T>): Promise<T> {
+	private async runcore<T>(fn: () => Promise<T>): Promise<T> {
 		this._activeCount++;
 		try {
 			return await fn();
@@ -138,7 +159,7 @@ export class GitQueue {
 		}
 	}
 
-	private enqueue<T>(fn: () => Promise<T>, priority: GitCommandPriority): Promise<T> {
+	private enqueue<T>(fn: () => Promise<T>, priority: GitCommandPriority, signal?: AbortSignal): Promise<T> {
 		const queue = this._queues.get(priority)!;
 		const maxDepth = this._config.maxQueueDepth ?? 500;
 		if (maxDepth > 0 && queue.length >= maxDepth) {
@@ -146,13 +167,29 @@ export class GitQueue {
 		}
 
 		return new Promise<T>((resolve, reject) => {
-			queue.push({
-				execute: fn as () => Promise<unknown>,
+			const cmd: QueuedCommand = {
+				run: fn,
 				resolve: resolve as (value: unknown) => void,
 				reject: reject,
 				queuedAt: Date.now(),
 				priority: priority,
-			});
+				signal: signal,
+			};
+
+			if (signal != null) {
+				cmd.abortHandler = () => {
+					const idx = queue.indexOf(cmd);
+					// If still queued, remove and reject so it never runs.
+					// If already dequeued, the running command should honor the signal at its own layer.
+					if (idx !== -1) {
+						queue.splice(idx, 1);
+						cmd.reject(abortReason(signal));
+					}
+				};
+				signal.addEventListener('abort', cmd.abortHandler, { once: true });
+			}
+
+			queue.push(cmd);
 		});
 	}
 
@@ -172,6 +209,13 @@ export class GitQueue {
 	}
 
 	private runQueued(cmd: QueuedCommand): void {
+		// Detach the abort listener now that the command has left the queue — any subsequent
+		// abort must be handled by the running spawn itself (via runOpts.cancellation).
+		if (cmd.signal != null && cmd.abortHandler != null) {
+			cmd.signal.removeEventListener('abort', cmd.abortHandler);
+			cmd.abortHandler = undefined;
+		}
+
 		const waitTime = Date.now() - cmd.queuedAt;
 		if (waitTime > 1000) {
 			this._hooks.onSlowQueue?.({
@@ -189,7 +233,7 @@ export class GitQueue {
 
 		this._activeCount++;
 		try {
-			cmd.execute()
+			cmd.run()
 				.then(cmd.resolve, cmd.reject)
 				.finally(() => {
 					this._activeCount--;
@@ -217,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

@@ -176,6 +176,10 @@ const stashMapping = {
 	parents: '%P',
 	stashName: '%gd',
 	summary: '%gs',
+	// %s (commit subject) is git's authoritative `On <branch>: …` / `WIP on <branch>: …` record,
+	// present even when the reflog message (%gs) was customized (autostash, `git stash store -m`).
+	// Used downstream to extract `stashOnRef` reliably.
+	commitSubject: '%s',
 };
 
 type StashLogParser = LogParser<typeof stashMapping>;
@@ -416,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
@@ -882,7 +887,7 @@ function createLogParserWithPatch<T extends Record<string, string>>(
 		}
 
 		return {
-			status: (fileMatch[1] === 'rename' ? 'R' : 'M') as GitFileIndexStatus,
+			status: (fileMatch[1] === 'rename' ? 'R' : 'M') satisfies GitFileIndexStatus,
 			path: fileMatch[2],
 			originalPath: fileMatch[1] === 'rename' ? fileMatch[3] : undefined,
 			range: range,