@gitkraken/core-gitlens 0.2.0 → 0.3.0

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

@@ -1,19 +1,27 @@
 import type { Cache } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import type { GitBranch } from '../../git/models/branch.js';
-import type { GitReference } from '../../git/models/reference.js';
+import type { GitReference, GitRefTip, RefRecord } from '../../git/models/reference.js';
 import { deletedOrMissing } from '../../git/models/revision.js';
 import type { GitTag } from '../../git/models/tag.js';
 import type { GitRefsSubProvider } from '../../git/providers/refs.js';
+import type { GitCommandPriority } from '../../git/run.types.js';
+import { isRemoteHEAD } from '../../git/utils/branch.utils.js';
 import { createReference } from '../../git/utils/reference.utils.js';
 import { isSha, isShaWithOptionalRevisionSuffix, isUncommitted } from '../../git/utils/revision.utils.js';
-import { isCancellationError } from '../../utils/cancellation.js';
+import { compareRefTips } from '../../git/utils/sorting.js';
+import { CancellationError, isCancellationError } from '../../utils/cancellation.js';
 import { debug, trace } from '../../utils/decorators/log.js';
+import { createDisposable } from '../../utils/disposable.js';
 import { getScopedLogger } from '../../utils/logger.scoped.js';
+import { maybeStopWatch } from '../../utils/stopwatch.js';
+import { iterateAsyncByDelimiter } from '../../utils/string.js';
 import type { Uri } from '../../utils/uri.js';
 import { toFsPath } from '../../utils/uri.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { Git } from '../exec/git.js';
+import { gitConfigsBranch } from '../exec/git.js';
+import { getRefParser } from '../parsers/refParser.js';
 
 export class RefsGitSubProvider implements GitRefsSubProvider {
 	constructor(
@@ -33,12 +41,245 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 		}
 	}
 
+	/**
+	 * Raw `git for-each-ref` records covering branches, remotes, and tags in a single pass.
+	 * CLI-internal — siblings call via `this.provider.refs.getRefs(...)`. The `RefRecord` shape
+	 * is `for-each-ref`-specific and intentionally absent from the public `GitRefsSubProvider`
+	 * interface.
+	 */
+	@debug()
+	async getRefs(repoPath: string, cancellation?: AbortSignal): Promise<RefRecord[]> {
+		if (!repoPath) return [];
+
+		const scope = getScopedLogger();
+
+		return this.cache.getRefs(
+			repoPath,
+			async (commonPath, cacheable, signal) => {
+				try {
+					const supported = await this.git.supported('git:for-each-ref');
+					const parser = getRefParser(supported);
+					const result = await this.git.run(
+						{ cwd: commonPath, cancellation: signal, configs: gitConfigsBranch, errors: 'ignore' },
+						'for-each-ref',
+						...parser.arguments,
+						'refs/heads/',
+						'refs/remotes/',
+						'refs/tags/',
+					);
+					if (!result?.stdout) return [];
+
+					using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
+
+					const records = [...parser.parse(result.stdout)];
+
+					sw?.stop({ suffix: ` parsed ${records.length} ref records` });
+
+					return records;
+				} catch (ex) {
+					cacheable?.invalidate();
+					if (isCancellationError(ex)) throw ex;
+
+					scope?.error(ex);
+					return [];
+				}
+			},
+			cancellation,
+		);
+	}
+
+	@debug()
+	async getRefTips(
+		repoPath: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<GitRefTip[]> {
+		if (!repoPath) return [];
+
+		const scope = getScopedLogger();
+
+		// Cache always holds the full set; subset filtering is applied on read so callers asking
+		// for different subsets share one cache entry.
+		const all = await this.cache.getRefTips(
+			repoPath,
+			async (_commonPath, _cacheable, signal) => {
+				const records = await this.getRefs(repoPath, signal);
+
+				using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
+
+				const tips: GitRefTip[] = [];
+				for (const record of records) {
+					const fullName = record.name;
+					if (!fullName) continue;
+					// Skip refs/remotes/<remote>/HEAD — symbolic, not a real tip.
+					if (isRemoteHEAD(fullName)) continue;
+
+					let type: GitRefTip['type'];
+					let name: string;
+					if (fullName.startsWith('refs/heads/')) {
+						type = 'branch';
+						name = fullName.substring(11);
+					} else if (fullName.startsWith('refs/remotes/')) {
+						type = 'remote';
+						name = fullName.substring(13);
+					} else if (fullName.startsWith('refs/tags/')) {
+						type = 'tag';
+						name = fullName.substring(10);
+					} else {
+						continue;
+					}
+
+					// Annotated tags: peeledObjectname is the commit SHA; objectname is the tag-object SHA.
+					// Lightweight tags / branches: peeledObjectname is empty; objectname is already the commit SHA.
+					const sha = record.peeledObjectname || record.objectname;
+
+					tips.push({ type: type, name: name, fullName: fullName, sha: sha });
+				}
+
+				sw?.stop({ suffix: ` projected ${tips.length} ref tips` });
+
+				return tips;
+			},
+			cancellation,
+		);
+
+		const include = options?.include;
+		if (include == null || (include.includes('heads') && include.includes('remotes') && include.includes('tags'))) {
+			return all;
+		}
+
+		return all.filter(r => {
+			switch (r.type) {
+				case 'branch':
+					return include.includes('heads');
+				case 'remote':
+					return include.includes('remotes');
+				case 'tag':
+					return include.includes('tags');
+			}
+		});
+	}
+
+	@debug()
+	async getRefsContainingShas(
+		repoPath: string,
+		shas: ReadonlySet<string> | readonly string[],
+		oldestSha: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<Map<string, GitRefTip[]>> {
+		const targetShas = shas instanceof Set ? shas : new Set(shas);
+		if (!targetShas.size || !oldestSha) return new Map();
+
+		const scope = getScopedLogger();
+
+		const tips = await this.getRefTips(repoPath, options, cancellation);
+		if (cancellation?.aborted) throw new CancellationError();
+		if (!tips.length) return new Map();
+
+		// Index tips by full ref name (for projection back to GitRefTip later) and seed the
+		// propagation map by tip SHA. Multiple refs sharing a tip (e.g. local + remote-tracking)
+		// collapse into one Set entry whose union covers all of them.
+		const tipsByName = new Map<string, GitRefTip>();
+		const propMap = new Map<string, Set<string>>();
+		for (const tip of tips) {
+			tipsByName.set(tip.fullName, tip);
+			let names = propMap.get(tip.sha);
+			if (names == null) {
+				names = new Set();
+				propMap.set(tip.sha, names);
+			}
+			names.add(tip.fullName);
+		}
+
+		using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
+
+		// `^<oldestSha>^@` excludes the parents of <oldestSha> and everything older. When <oldestSha>
+		// is a root commit, `^@` resolves to nothing and the walk is naturally unbounded — git
+		// doesn't error in that case (no negative refs to apply).
+		const stream = this.git.stream(
+			{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsBranch },
+			'rev-list',
+			'--topo-order',
+			'--parents',
+			'--all',
+			`^${oldestSha}^@`,
+		);
+		using _streamDisposer = createDisposable(() => void stream.return?.(undefined));
+
+		// Topological propagation: `--topo-order` emits all children of X before X's own line, so
+		// by the time we process "X P1 P2..." every child has already merged its set into X. We
+		// then forward X's accumulated set to each parent — one-pass and correct.
+		try {
+			for await (const line of iterateAsyncByDelimiter(stream, '\n')) {
+				if (cancellation?.aborted) throw new CancellationError();
+				if (!line) continue;
+
+				const firstSpace = line.indexOf(' ');
+				const sha = firstSpace === -1 ? line : line.substring(0, firstSpace);
+				if (!sha) continue;
+
+				const refs = propMap.get(sha);
+				if (!refs?.size) continue;
+
+				if (firstSpace === -1) continue; // No parents — nothing to propagate to
+
+				// Walk parent SHAs by index without splitting the whole line.
+				let start = firstSpace + 1;
+				while (start < line.length) {
+					const next = line.indexOf(' ', start);
+					const parentSha = next === -1 ? line.substring(start) : line.substring(start, next);
+					if (parentSha) {
+						let parentRefs = propMap.get(parentSha);
+						if (parentRefs == null) {
+							parentRefs = new Set(refs);
+							propMap.set(parentSha, parentRefs);
+						} else {
+							for (const name of refs) {
+								parentRefs.add(name);
+							}
+						}
+					}
+					if (next === -1) break;
+
+					start = next + 1;
+				}
+			}
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+
+			scope?.error(ex);
+			return new Map();
+		}
+
+		// Project to targets, materialize GitRefTip[], sort.
+		const result = new Map<string, GitRefTip[]>();
+		for (const sha of targetShas) {
+			const names = propMap.get(sha);
+			if (!names?.size) continue;
+
+			const refs: GitRefTip[] = [];
+			for (const name of names) {
+				const tip = tipsByName.get(name);
+				if (tip != null) {
+					refs.push(tip);
+				}
+			}
+			refs.sort(compareRefTips);
+			result.set(sha, refs);
+		}
+
+		sw?.stop({ suffix: ` resolved ${result.size}/${targetShas.size} target shas` });
+
+		return result;
+	}
+
 	@debug()
 	async getMergeBase(
 		repoPath: string,
 		ref1: string,
 		ref2: string,
-		options?: { forkPoint?: boolean },
+		options?: { forkPoint?: boolean; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		const scope = getScopedLogger();
@@ -52,6 +293,7 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 					// cleared on 'heads'/'remotes' events when refs move. Web (no fs watcher) sees up to
 					// `accessTTL` of staleness — acceptable trade-off for the perf win on graph/branch reads.
 					caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
+					...(options?.priority != null ? { priority: options.priority } : undefined),
 				},
 				'merge-base',
 				options?.forkPoint ? '--fork-point' : undefined,
@@ -104,6 +346,7 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	async getSymbolicReferenceName(
 		repoPath: string,
 		ref: string,
+		options?: { priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
@@ -117,6 +360,7 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 				// gitResults cache is cleared on 'head' events. 60s TTL is the failsafe for watcher
 				// latency / web — matches the other "resolve symbolic state" calls in commits.ts.
 				caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+				...(options?.priority != null ? { priority: options.priority } : undefined),
 			},
 			'rev-parse',
 			'--verify',

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

@@ -19,7 +19,7 @@ import { splitPath } from '../../utils/path.js';
 import type { Uri } from '../../utils/uri.js';
 import { toFsPath } from '../../utils/uri.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
-import type { GitErrorHandling, GitExecOptions } from '../exec/exec.types.js';
+import type { GitErrorHandling, GitRunOptions } from '../exec/exec.types.js';
 import type { Git } from '../exec/git.js';
 import { defaultExceptionHandler, getGitCommandError, gitConfigsLog, GitErrors } from '../exec/git.js';
 import { parseGitLsFilesStaged } from '../parsers/indexParser.js';
@@ -165,7 +165,7 @@ export class RevisionGitSubProvider implements GitRevisionSubProvider {
 		}
 		if (isUncommitted(rev)) throw new Error(`ref=${rev} is uncommitted`);
 
-		const opts: GitExecOptions = {
+		const opts: GitRunOptions = {
 			configs: gitConfigsLog,
 			cwd: root,
 			encoding: options?.encoding ?? 'utf8',

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

@@ -56,6 +56,7 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 					// Copy the current index to preserve staged state
 					const gitDir = await this.provider.config.getGitDir?.(repoPath);
 					if (gitDir == null) throw new Error(`Unable to determine git directory for ${repoPath}`);
+
 					const currentIndex = joinPaths(gitDir.uri.fsPath, 'index');
 					await fs.copyFile(currentIndex, tempIndex);
 					break;
@@ -158,6 +159,38 @@ export class StagingGitSubProvider implements GitStagingSubProvider {
 		await this.git.run({ cwd: repoPath }, 'reset', '-q', '--', toFsPath(directoryOrUri));
 	}
 
+	@debug()
+	async removeFile(repoPath: string, pathOrUri: string | Uri, options?: { force?: boolean }): Promise<void> {
+		const args = ['rm'];
+		if (options?.force) {
+			args.push('-f');
+		}
+		args.push('--', toFsPath(pathOrUri));
+		await this.git.run({ cwd: repoPath }, ...args);
+	}
+
+	@debug()
+	async removeFiles(repoPath: string, pathsOrUris: (string | Uri)[], options?: { force?: boolean }): Promise<void> {
+		const paths = pathsOrUris.map(toFsPath);
+		if (!paths.length) return;
+
+		const args: string[] = ['rm'];
+		if (options?.force) {
+			args.push('-f');
+		}
+		args.push('--');
+
+		// Calculate a safe batch size based on average path length
+		const avgPathLength = countStringLength(paths) / paths.length;
+		const batchSize = Math.max(1, Math.floor(maxGitCliLength / avgPathLength));
+
+		// Process files in batches (will be a single batch if under the limit)
+		const batches = chunk(paths, batchSize);
+		for (const batch of batches) {
+			await this.git.run({ cwd: repoPath }, ...args, ...batch);
+		}
+	}
+
 	@debug()
 	async stageAll(repoPath: string): Promise<void> {
 		await this.git.run({ cwd: repoPath }, 'add', '-A');

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

@@ -6,6 +6,7 @@ import type { GitConflictFile } from '../../git/models/staging.js';
 import { GitStatus } from '../../git/models/status.js';
 import type { GitStatusFile } from '../../git/models/statusFile.js';
 import type { GitStatusSubProvider, GitWorkingChangesState } from '../../git/providers/status.js';
+import type { GitCommandPriority } from '../../git/run.types.js';
 import { isCancellationError } from '../../utils/cancellation.js';
 import { gate } from '../../utils/decorators/gate.js';
 import { debug } from '../../utils/decorators/log.js';
@@ -33,19 +34,27 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 
 	@gate(rp => rp ?? '')
 	@debug()
-	async getStatus(repoPath: string | undefined, cancellation?: AbortSignal): Promise<GitStatus | undefined> {
+	async getStatus(
+		repoPath: string | undefined,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined> {
 		if (repoPath == null) return undefined;
 
 		const porcelainVersion = (await this.git.supports('git:status:porcelain-v2')) ? 2 : 1;
 
-		const result = await this.statusCore(repoPath, porcelainVersion, {}, cancellation);
+		const result = await this.statusCore(repoPath, porcelainVersion, { priority: options?.priority }, cancellation);
 		const repoUri = fileUri(normalizePath(repoPath));
 		const status = parseGitStatus(result.stdout, repoPath, porcelainVersion, p =>
 			joinUriPath(repoUri, normalizePath(p)),
 		);
 
 		if (status?.detached) {
-			const pausedOpStatus = await this.provider.pausedOps?.getPausedOperationStatus?.(repoPath, cancellation);
+			const pausedOpStatus = await this.provider.pausedOps?.getPausedOperationStatus?.(
+				repoPath,
+				undefined,
+				cancellation,
+			);
 			if (pausedOpStatus?.type === 'rebase') {
 				return new GitStatus(
 					repoPath,
@@ -126,7 +135,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 	private async statusCore(
 		repoPath: string,
 		porcelainVersion: number = 1,
-		options?: { similarityThreshold?: number },
+		options?: { similarityThreshold?: number; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 		...pathspecs: string[]
 	): Promise<GitResult> {
@@ -148,6 +157,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 				cancellation: cancellation,
 				configs: gitConfigsStatus,
 				env: { GIT_OPTIONAL_LOCKS: '0' },
+				...(options?.priority != null ? { priority: options.priority } : undefined),
 			},
 			...params,
 			'--',
@@ -247,6 +257,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 			return result;
 		} catch (ex) {
 			if (isCancellationError(ex)) throw ex;
+
 			scope?.error(ex);
 			scope?.addExitInfo('error checking for changes');
 			// Return all false on error for graceful degradation

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

@@ -16,7 +16,6 @@ import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { GitResult } from '../exec/exec.types.js';
 import type { Git, GitError } from '../exec/git.js';
 import { getGitCommandError, gitConfigsBranch } from '../exec/git.js';
-import { getTagParser } from '../parsers/refParser.js';
 
 export class TagsGitSubProvider implements GitTagsSubProvider {
 	constructor(
@@ -54,29 +53,29 @@ export class TagsGitSubProvider implements GitTagsSubProvider {
 				// Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
 				signal ??= cancellation;
 				try {
-					const parser = getTagParser();
-
-					const result = await this.git.run(
-						{ cwd: repoPath, cancellation: signal },
-						'for-each-ref',
-						...parser.arguments,
-						'refs/tags/',
-					);
-					if (!result.stdout) return emptyPagedResult;
+					const records = await this.provider.refs.getRefs(commonPath, signal);
+					if (!records.length) return emptyPagedResult;
 
 					using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
 
 					const tags: GitTag[] = [];
 
-					for (const entry of parser.parse(result.stdout)) {
+					for (const record of records) {
+						const fullName = record.name;
+						if (!fullName.startsWith('refs/tags/')) continue;
+
+						// Annotated tags: peeledObjectname is the commit SHA; objectname is the tag-object SHA.
+						// Lightweight tags: peeledObjectname is empty; objectname is already the commit SHA.
+						const sha = record.peeledObjectname || record.objectname;
+
 						tags.push(
 							new GitTag(
 								commonPath,
-								entry.name,
-								entry.sha || entry.tagSha,
-								entry.message,
-								entry.date ? new Date(entry.date) : undefined,
-								entry.commitDate ? new Date(entry.commitDate) : undefined,
+								fullName,
+								sha,
+								record.subject,
+								record.creatorDate ? new Date(record.creatorDate) : undefined,
+								record.authorDate ? new Date(record.authorDate) : undefined,
 							),
 						);
 					}

package/src/ipc/discovery.ts

@@ -0,0 +1,56 @@
+import { mkdir, unlink, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { ppid } from 'process';
+
+/**
+ * Directory scanned by `gk` binaries (and `@gitkraken/core-gitlens` consumers) for the
+ * extension's CLI-capable IPC server discovery file. Anything written here is assumed
+ * by older `gk` versions to be a CLI server — do NOT write agent-only files here.
+ */
+export const cliDiscoveryDir = join(tmpdir(), 'gitkraken', 'gitlens');
+
+/**
+ * Directory scanned by peer GitLens windows for agent-session-capable IPC servers.
+ * Stable across GitLens versions; older windows still scan it, so don't move it.
+ */
+export const agentDiscoveryDir = join(tmpdir(), 'gitkraken', 'gitlens', 'agents');
+
+export interface IpcDiscoveryData {
+	token: string;
+	address: string;
+	port: number;
+	workspacePaths: string[];
+	// Optional fields — present when the writing capability needs them.
+	// Old gk binaries ignore unknown fields, so this stays back-compat.
+	ideName?: string;
+	ideDisplayName?: string;
+	scheme?: string;
+	pid?: number;
+	createdAt: string;
+}
+
+export function getDiscoveryFileName(port: number): string {
+	return `gitlens-ipc-server-${ppid}-${port}.json`;
+}
+
+export function getDiscoveryFilePath(dir: string, port: number): string {
+	return join(dir, getDiscoveryFileName(port));
+}
+
+export async function writeDiscoveryFile(dir: string, data: IpcDiscoveryData): Promise<string> {
+	const filePath = getDiscoveryFilePath(dir, data.port);
+	await mkdir(dir, { recursive: true, mode: 0o700 });
+	await writeFile(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+	return filePath;
+}
+
+export async function cleanupDiscoveryFile(filePath: string | undefined): Promise<void> {
+	if (filePath == null) return;
+
+	try {
+		await unlink(filePath);
+	} catch {
+		// Ignore cleanup errors
+	}
+}