@gitkraken/core-gitlens 0.2.0 → 0.3.0

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.setupWatching` 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;
 }
 
@@ -83,6 +92,7 @@ export class RepositoryWatchService implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const record of this.sessionMap.values()) {
@@ -117,6 +127,9 @@ 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,
@@ -150,10 +163,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 +184,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);
@@ -229,11 +251,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.setupWatching` 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 +322,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 +373,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

@@ -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/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

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

@@ -1,52 +1,51 @@
 import type { FilteredGitFeatures } from '../../git/features.js';
+import type { RefRecord } from '../../git/models/reference.js';
 import { maybeStopWatch } from '../../utils/stopwatch.js';
 import { iterateByDelimiter } from '../../utils/string.js';
 import type { ExtractAll } from '../../utils/types.js';
 import type { Parser } from './logParser.js';
 
-const branchMapping = {
-	current: `%(HEAD)`, // HEAD indicator (current branch)
-	name: `%(refname)`, // Full reference name
-	upstream: `%(upstream)`, // Upstream branch, if any
-	upstreamTracking: `%(upstream:track)`, // Tracking status
-	sha: `%(objectname)`, // SHA
-	date: `%(committerdate:iso8601)`, // Date
+/**
+ * Unified `for-each-ref` mapping covering branches, remotes, and tags in a single pass.
+ * Fields inapplicable to a given ref-type come back as empty strings from git.
+ *
+ * NOTE: When adding a new field that is gated on a git feature flag, mirror the entry in
+ * `refMappingSupportsWorktreePath` (and any future variants) — both maps MUST stay aligned
+ * so callers can switch parsers based on `git.supported('git:for-each-ref')` without losing
+ * field positions.
+ */
+const refMapping = {
+	current: `%(HEAD)`,
+	name: `%(refname)`,
+	objectname: `%(objectname)`,
+	peeledObjectname: `%(*objectname)`,
+	upstream: `%(upstream)`,
+	upstreamTracking: `%(upstream:track)`,
+	committerDate: `%(committerdate:iso8601)`,
+	creatorDate: `%(creatordate:iso8601)`,
+	authorDate: `%(authordate:iso8601)`,
+	subject: `%(subject)`,
 	worktreePath: undefined,
 };
 
-const branchMappingSupportsWorktreePath = {
-	...branchMapping,
-	worktreePath: '%(worktreepath)', // Worktree path
+const refMappingSupportsWorktreePath = {
+	...refMapping,
+	worktreePath: '%(worktreepath)',
 };
 
-type BranchParser = Parser<typeof branchMapping> | Parser<typeof branchMappingSupportsWorktreePath>;
+type RefParser = Parser<RefRecord>;
 
-let _branchParser: BranchParser | undefined;
-let _branchParserWithWorktree: BranchParser | undefined;
-export function getBranchParser(supportedFeatures: FilteredGitFeatures<'git:for-each-ref'>[]): BranchParser {
+let _refParser: RefParser | undefined;
+let _refParserWithWorktree: RefParser | undefined;
+
+export function getRefParser(supportedFeatures: FilteredGitFeatures<'git:for-each-ref'>[]): RefParser {
 	if (supportedFeatures.includes('git:for-each-ref:worktreePath')) {
-		_branchParserWithWorktree ??= createRefParser(branchMappingSupportsWorktreePath);
-		return _branchParserWithWorktree;
+		_refParserWithWorktree ??= createRefParser(refMappingSupportsWorktreePath);
+		return _refParserWithWorktree;
 	}
-	_branchParser ??= createRefParser(branchMapping);
-	return _branchParser;
-}
-
-const tagMapping = {
-	name: `%(refname)`, // Full reference name
-	tagSha: `%(objectname)`, // sha of the tag
-	sha: `%(*objectname)`, // sha of the commit the tag points to, if any
-	date: `%(creatordate:iso8601)`, // date the tag was created
-	commitDate: `%(authordate:iso8601)`, // author date of the commit the tag points to
-	message: `%(subject)`, // message
-};
-
-type TagParser = Parser<typeof tagMapping>;
-let _tagParser: TagParser | undefined;
 
-export function getTagParser(): TagParser {
-	_tagParser ??= createRefParser(tagMapping);
-	return _tagParser;
+	_refParser ??= createRefParser(refMapping);
+	return _refParser;
 }
 
 const recordSep = '\x1E'; // ASCII Record Separator character

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

@@ -234,6 +234,7 @@ export class BlameGitSubProvider implements GitBlameSubProvider {
 			let blameLine = blame.lines[editorLine];
 			if (blameLine == null) {
 				if (blame.lines.length !== editorLine) return undefined;
+
 				blameLine = blame.lines[editorLine - 1];
 			}