@gitkraken/core-gitlens 0.1.0

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

@@ -0,0 +1,193 @@
+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 { deletedOrMissing } from '../../git/models/revision.js';
+import type { GitTag } from '../../git/models/tag.js';
+import type { GitRefsSubProvider } from '../../git/providers/refs.js';
+import { createReference } from '../../git/utils/reference.utils.js';
+import { isShaWithOptionalRevisionSuffix, isUncommitted } from '../../git/utils/revision.utils.js';
+import { isCancellationError } from '../../utils/cancellation.js';
+import { debug, trace } from '../../utils/decorators/log.js';
+import { getScopedLogger } from '../../utils/logger.scoped.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';
+
+export class RefsGitSubProvider implements GitRefsSubProvider {
+	constructor(
+		private readonly context: GitServiceContext,
+		private readonly git: Git,
+		private readonly cache: Cache,
+		private readonly provider: CliGitProviderInternal,
+	) {}
+
+	@debug()
+	async checkIfCouldBeValidBranchOrTagName(repoPath: string, ref: string): Promise<boolean> {
+		try {
+			const result = await this.git.exec({ cwd: repoPath, errors: 'throw' }, 'check-ref-format', '--branch', ref);
+			return Boolean(result.stdout.trim());
+		} catch {
+			return false;
+		}
+	}
+
+	@debug()
+	async getMergeBase(
+		repoPath: string,
+		ref1: string,
+		ref2: string,
+		options?: { forkPoint?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		const scope = getScopedLogger();
+
+		try {
+			const result = await this.git.exec(
+				{
+					cwd: repoPath,
+					cancellation: cancellation,
+					caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
+				},
+				'merge-base',
+				options?.forkPoint ? '--fork-point' : undefined,
+				ref1,
+				ref2,
+			);
+			if (!result.stdout) return undefined;
+
+			return result.stdout.split('\n')[0].trim() || undefined;
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+
+			return undefined;
+		}
+	}
+
+	@debug()
+	async getReference(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<GitReference | undefined> {
+		if (!ref || ref === deletedOrMissing) return undefined;
+
+		if (!(await this.isValidReference(repoPath, ref, undefined, cancellation))) return undefined;
+
+		if (ref !== 'HEAD' && !isShaWithOptionalRevisionSuffix(ref)) {
+			const branch = await this.provider.branches.getBranch(repoPath, ref, cancellation);
+			if (branch != null) {
+				return createReference(branch.ref, repoPath, {
+					id: branch.id,
+					refType: 'branch',
+					name: branch.name,
+					remote: branch.remote,
+					upstream: branch.upstream,
+				});
+			}
+
+			const tag = await this.provider.tags.getTag(repoPath, ref, cancellation);
+			if (tag != null) {
+				return createReference(tag.ref, repoPath, {
+					id: tag.id,
+					refType: 'tag',
+					name: tag.name,
+				});
+			}
+		}
+
+		return createReference(ref, repoPath, { refType: 'revision' });
+	}
+
+	@debug()
+	async getSymbolicReferenceName(
+		repoPath: string,
+		ref: string,
+		cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
+
+		const result = await this.git.exec(
+			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
+			'rev-parse',
+			'--verify',
+			'--quiet',
+			'--symbolic-full-name',
+			'--abbrev-ref',
+			supportsEndOfOptions ? '--end-of-options' : undefined,
+			ref,
+		);
+		return result.stdout.trim() || undefined;
+	}
+
+	@debug({ args: repoPath => ({ repoPath: repoPath }) })
+	async hasBranchOrTag(
+		repoPath: string | undefined,
+		options?: {
+			filter?: { branches?: (b: GitBranch) => boolean; tags?: (t: GitTag) => boolean };
+		},
+		cancellation?: AbortSignal,
+	): Promise<boolean> {
+		if (repoPath == null) return false;
+
+		const [{ values: branches }, { values: tags }] = await Promise.all([
+			this.provider.branches.getBranches(
+				repoPath,
+				{ filter: options?.filter?.branches, sort: false },
+				cancellation,
+			),
+			this.provider.tags.getTags(repoPath, { filter: options?.filter?.tags, sort: false }, cancellation),
+		]);
+
+		return branches.length !== 0 || tags.length !== 0;
+	}
+
+	@debug()
+	async isValidReference(
+		repoPath: string,
+		ref: string,
+		pathOrUri?: string | Uri,
+		cancellation?: AbortSignal,
+	): Promise<boolean> {
+		const path = pathOrUri != null ? toFsPath(pathOrUri) : undefined;
+		const relativePath = path ? this.provider.getRelativePath(path, repoPath) : undefined;
+		return Boolean((await this.validateReference(repoPath, ref, relativePath, cancellation))?.length);
+	}
+
+	@trace()
+	async validateReference(
+		repoPath: string,
+		ref: string,
+		relativePath?: string,
+		cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		if (!ref) return undefined;
+		if (ref === deletedOrMissing || isUncommitted(ref)) return ref;
+
+		const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
+
+		const result = await this.git.exec(
+			{
+				cwd: repoPath,
+				cancellation: cancellation,
+				errors: 'ignore',
+				caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
+			},
+			'rev-parse',
+			'--verify',
+			supportsEndOfOptions ? '--end-of-options' : undefined,
+			relativePath ? `${ref}:./${relativePath}` : `${ref}^{commit}`,
+		);
+		return result.stdout.trim() || undefined;
+	}
+
+	@debug()
+	async updateReference(repoPath: string, ref: string, newRef: string, cancellation?: AbortSignal): Promise<void> {
+		const scope = getScopedLogger();
+
+		try {
+			await this.git.exec({ cwd: repoPath, cancellation: cancellation }, 'update-ref', ref, newRef);
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+		}
+	}
+}

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

@@ -0,0 +1,115 @@
+import type { Cache } from '../../git/cache.js';
+import type { GitServiceContext } from '../../git/context.js';
+import type { GitRemote } from '../../git/models/remote.js';
+import type { GitRemotesSubProvider } from '../../git/providers/remotes.js';
+import { RemotesGitProviderBase } from '../../git/providers/shared/remotes.js';
+import { createRemoteProviderMatcher } from '../../git/remotes/matcher.js';
+import { sortRemotes } from '../../git/utils/sorting.js';
+import { gate } from '../../utils/decorators/gate.js';
+import { debug } from '../../utils/decorators/log.js';
+import { getScopedLogger } from '../../utils/logger.scoped.js';
+import type { CliGitProviderInternal } from '../cliGitProvider.js';
+import type { Git } from '../exec/git.js';
+import { parseGitRemotes } from '../parsers/remoteParser.js';
+
+export class RemotesGitSubProvider extends RemotesGitProviderBase implements GitRemotesSubProvider {
+	constructor(
+		context: GitServiceContext,
+		private readonly git: Git,
+		cache: Cache,
+		provider: CliGitProviderInternal,
+	) {
+		super(context, cache, provider);
+	}
+
+	@debug({ args: repoPath => ({ repoPath: repoPath }) })
+	async getRemotes(
+		repoPath: string | undefined,
+		options?: { filter?: (remote: GitRemote) => boolean; sort?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<GitRemote[]> {
+		if (repoPath == null) return [];
+
+		const scope = getScopedLogger();
+
+		let remotes = await this.cache.getRemotes(
+			repoPath,
+			async (commonPath, cacheable, signal) => {
+				// Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
+				signal ??= cancellation;
+				const configs = await this.context.remotes?.getCustomProviders?.(repoPath);
+				const remoteProviderMatcher = createRemoteProviderMatcher(configs, this.context.remotes);
+
+				try {
+					const result = await this.git.exec(
+						{
+							cwd: repoPath,
+							cancellation: signal,
+							caching: { cache: this.cache.gitResults, commonPath: commonPath },
+						},
+						'remote',
+						'-v',
+					);
+
+					// Fetch default remote name from GK config before parsing so it's set at construction time
+					const defaultName = await this.provider.config.getGkConfig?.(repoPath, 'gk.defaultRemote');
+					const remotes = parseGitRemotes(result.stdout, commonPath, remoteProviderMatcher, defaultName);
+
+					return remotes;
+				} catch (ex) {
+					cacheable.invalidate();
+					scope?.error(ex);
+					return [];
+				}
+			},
+			cancellation,
+		);
+
+		if (options?.filter != null) {
+			remotes = remotes.filter(options.filter);
+		}
+
+		if (options?.sort) {
+			sortRemotes(remotes);
+		}
+
+		return remotes;
+	}
+
+	@gate()
+	@debug()
+	async addRemote(repoPath: string, name: string, url: string, options?: { fetch?: boolean }): Promise<void> {
+		await this.git.exec({ cwd: repoPath }, 'remote', 'add', options?.fetch ? '-f' : undefined, name, url);
+		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes');
+		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
+	}
+
+	@gate()
+	@debug()
+	async addRemoteWithResult(
+		repoPath: string,
+		name: string,
+		url: string,
+		options?: { fetch?: boolean },
+	): Promise<GitRemote | undefined> {
+		await this.addRemote(repoPath, name, url, options);
+		const [remote] = await this.getRemotes(repoPath, { filter: r => r.url === url });
+		return remote;
+	}
+
+	@gate()
+	@debug()
+	async pruneRemote(repoPath: string, name: string): Promise<void> {
+		await this.git.exec({ cwd: repoPath }, 'remote', 'prune', name);
+		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes', 'branches');
+		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
+	}
+
+	@gate()
+	@debug()
+	async removeRemote(repoPath: string, name: string): Promise<void> {
+		await this.git.exec({ cwd: repoPath }, 'remote', 'remove', name);
+		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes');
+		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
+	}
+}

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

@@ -0,0 +1,334 @@
+import type { Cache } from '../../git/cache.js';
+import type { GitServiceContext } from '../../git/context.js';
+import { ShowError } from '../../git/errors.js';
+import type { GitFileStatus } from '../../git/models/fileStatus.js';
+import { deletedOrMissing } from '../../git/models/revision.js';
+import type { GitTreeEntry } from '../../git/models/tree.js';
+import type { GitRevisionSubProvider, ResolvedRevision } from '../../git/providers/revision.js';
+import {
+	isRevisionWithSuffix,
+	isSha,
+	isUncommitted,
+	isUncommittedStaged,
+	isUncommittedWithParentSuffix,
+} from '../../git/utils/revision.utils.js';
+import { gate } from '../../utils/decorators/gate.js';
+import { debug } from '../../utils/decorators/log.js';
+import { first } from '../../utils/iterable.js';
+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 { Git } from '../exec/git.js';
+import { defaultExceptionHandler, getGitCommandError, gitConfigsLog, GitErrors } from '../exec/git.js';
+import { parseGitLsFilesStaged } from '../parsers/indexParser.js';
+import { getShaAndFileSummaryLogParser } from '../parsers/logParser.js';
+import { parseGitTree } from '../parsers/treeParser.js';
+
+const emptyArray: readonly GitTreeEntry[] = Object.freeze([]);
+
+export class RevisionGitSubProvider implements GitRevisionSubProvider {
+	constructor(
+		private readonly context: GitServiceContext,
+		private readonly git: Git,
+		private readonly cache: Cache,
+		private readonly provider: CliGitProviderInternal,
+	) {}
+
+	exists(repoPath: string, path: string, revOrOptions?: string | { untracked?: boolean }): Promise<boolean> {
+		let rev: string | undefined;
+		let untracked: boolean | undefined;
+		if (typeof revOrOptions === 'string') {
+			rev = revOrOptions;
+		} else if (revOrOptions != null) {
+			untracked = revOrOptions.untracked;
+		}
+
+		const cacheKey = `${path}\0${rev ?? ''}\0${untracked ? 'u' : ''}`;
+		return this.cache.fileExistence.getOrCreate(repoPath, cacheKey, async () => {
+			const args = ['ls-files'];
+			if (rev) {
+				if (!isUncommitted(rev)) {
+					args.push(`--with-tree=${rev}`);
+				} else if (isUncommittedStaged(rev)) {
+					args.push('--stage');
+				}
+			} else if (untracked) {
+				args.push('-o');
+			}
+
+			const result = await this.git.exec({ cwd: repoPath, errors: 'ignore' }, ...args, '--', path);
+			return Boolean(result.stdout.trim());
+		});
+	}
+
+	@gate()
+	@debug()
+	getRevisionContent(repoPath: string, path: string, rev: string): Promise<Uint8Array | undefined> {
+		const [relativePath, root] = splitPath(path, repoPath);
+		return this.showContentCore<Buffer>(root, relativePath, rev, { encoding: 'buffer', errors: 'throw' });
+	}
+
+	@debug()
+	async getSubmoduleHead(repoPath: string, submodulePath: string): Promise<string | undefined> {
+		// Verify the path is a submodule (gitlink commit) in the parent tree, not just a regular directory
+		const treeEntry = await this.getTreeEntryForRevision(repoPath, submodulePath, 'HEAD');
+		if (treeEntry?.type !== 'commit') return undefined;
+
+		const [relativePath, root] = splitPath(submodulePath, repoPath);
+		const submoduleFullPath = this.provider.getAbsoluteUri(relativePath, root).fsPath;
+
+		const result = await this.git.exec({ cwd: submoduleFullPath, errors: 'ignore' }, 'rev-parse', 'HEAD');
+		const sha = result.stdout.trim();
+		return sha || undefined;
+	}
+
+	@gate()
+	@debug()
+	async getTreeEntryForRevision(repoPath: string, path: string, rev: string): Promise<GitTreeEntry | undefined> {
+		if (!repoPath || !path) return undefined;
+
+		const [relativePath, root] = splitPath(path, repoPath);
+
+		if (isUncommittedStaged(rev)) {
+			let result = await this.git.exec(
+				{ cwd: root, errors: 'ignore' },
+				'ls-files',
+				'-z',
+				'--stage',
+				'--',
+				relativePath,
+			);
+
+			const entries = parseGitLsFilesStaged(result.stdout, true);
+			if (entries.length === 0) return undefined;
+
+			const entry = entries[0];
+			result = await this.git.exec({ cwd: root }, 'cat-file', '-s', entry.oid);
+			const size = parseInt(result.stdout.trim(), 10) || 0;
+
+			return { ref: rev, oid: entry.oid, path: relativePath, size: size, type: 'blob' };
+		}
+
+		const [entry] = await this.getTreeForRevisionCore(repoPath, rev, path);
+		return entry;
+	}
+
+	@debug()
+	async getTrackedFiles(repoPath: string): Promise<string[]> {
+		if (!repoPath) return [];
+
+		const result = await this.git.exec({ cwd: repoPath, errors: 'ignore' }, 'ls-files', '-z');
+		const data = result.stdout;
+		if (!data) return [];
+
+		return [...new Set(data.split('\0').filter(Boolean))];
+	}
+
+	@debug()
+	async getTreeForRevision(repoPath: string, rev: string): Promise<GitTreeEntry[]> {
+		return repoPath ? this.getTreeForRevisionCore(repoPath, rev) : [];
+	}
+
+	@gate()
+	private async getTreeForRevisionCore(repoPath: string, rev: string, path?: string): Promise<GitTreeEntry[]> {
+		const hasPath = Boolean(path);
+		const args = hasPath ? ['ls-tree', '-l', rev, '--', path] : ['ls-tree', '-lrt', rev, '--'];
+		const result = await this.git.exec({ cwd: repoPath, errors: 'ignore' }, ...args);
+		const data = result.stdout.trim();
+		if (!data) return emptyArray as GitTreeEntry[];
+
+		return parseGitTree(data, rev, hasPath);
+	}
+
+	private async showContentCore<T extends string | Buffer>(
+		repoPath: string | undefined,
+		path: string,
+		rev: string,
+		options?: {
+			encoding?: string;
+			errors?: GitErrorHandling;
+		},
+	): Promise<T | undefined> {
+		const [file, root] = splitPath(path, repoPath, true);
+
+		if (isUncommittedStaged(rev)) {
+			rev = ':';
+		}
+		if (isUncommitted(rev)) throw new Error(`ref=${rev} is uncommitted`);
+
+		const opts: GitExecOptions = {
+			configs: gitConfigsLog,
+			cwd: root,
+			encoding: options?.encoding ?? 'utf8',
+			errors: 'throw',
+		};
+		const args = rev.endsWith(':') ? `${rev}./${file}` : `${rev}:./${file}`;
+		const params = ['show', '--textconv', args, '--'];
+
+		try {
+			const result = await this.git.exec<T>(opts, ...params);
+			return result.stdout;
+		} catch (ex) {
+			const msg: string = ex?.toString() ?? '';
+			if (rev === ':' && GitErrors.badRevision.test(msg)) {
+				return this.showContentCore<T>(repoPath, path, 'HEAD:', options);
+			}
+
+			const error = getGitCommandError(
+				'show',
+				ex,
+				reason =>
+					new ShowError(
+						{
+							reason: reason ?? 'other',
+							rev: rev,
+							path: path,
+							gitCommand: { repoPath: repoPath ?? '', args: params },
+						},
+						ex,
+					),
+			);
+			if (options?.errors === 'throw') throw error;
+
+			if (
+				ShowError.is(error, 'invalidObject') ||
+				ShowError.is(error, 'invalidRevision') ||
+				ShowError.is(error, 'notFound') ||
+				ShowError.is(error, 'notInRevision')
+			) {
+				return undefined;
+			}
+
+			defaultExceptionHandler(ex, opts.cwd);
+			return '' as T;
+		}
+	}
+
+	@debug()
+	async resolveRevision(repoPath: string, ref: string, pathOrUri?: string | Uri): Promise<ResolvedRevision> {
+		const path = pathOrUri != null ? toFsPath(pathOrUri) : undefined;
+		if (!ref || ref === deletedOrMissing) return { sha: ref, revision: ref };
+
+		if (path == null) {
+			if (isSha(ref)) return { sha: ref, revision: ref };
+			if (ref.endsWith('^3')) return { sha: ref, revision: ref };
+		} else if (isUncommitted(ref)) {
+			// Uncommitted refs depend on index/working-tree state — resolve without caching
+			return this.resolveRevisionCore(repoPath, ref, path);
+		}
+
+		const key = path != null ? `${ref}|${this.provider.getRelativePath(path, repoPath)}` : ref;
+		return this.cache.resolvedRevisions.getOrCreate(repoPath, key, () =>
+			this.resolveRevisionCore(repoPath, ref, path),
+		);
+	}
+
+	private async resolveRevisionCore(
+		repoPath: string,
+		ref: string,
+		path: string | undefined,
+	): Promise<ResolvedRevision> {
+		if (path == null) {
+			const sha = await this.provider.refs.validateReference(repoPath, ref);
+			if (sha == null) return { sha: ref, revision: ref };
+
+			return {
+				sha: sha,
+				// If it looks like non-sha like then preserve it as the friendly name
+				revision: isRevisionWithSuffix(ref) ? sha : ref,
+			};
+		}
+
+		if (isUncommittedWithParentSuffix(ref)) {
+			ref = 'HEAD';
+		}
+		const relativePath = this.provider.getRelativePath(path, repoPath);
+
+		if (isUncommitted(ref)) {
+			if (!isUncommittedStaged(ref)) {
+				return { sha: ref, revision: ref };
+			}
+
+			// Ensure that the file is actually staged
+			const status = await this.provider.status.getStatusForFile?.(repoPath, relativePath, { renames: false });
+			if (status?.indexStatus) return { sha: ref, revision: ref };
+
+			ref = 'HEAD';
+		}
+
+		const resolvedRevisionCaching = { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } };
+
+		const parser = getShaAndFileSummaryLogParser();
+		let result = await this.git.exec(
+			{ cwd: repoPath, errors: 'ignore', caching: resolvedRevisionCaching },
+			'log',
+			...parser.arguments,
+			'-n1',
+			ref,
+			'--',
+			relativePath,
+		);
+
+		let commit = first(parser.parse(result.stdout));
+		let file = commit?.files.find(f => f.path === relativePath);
+		if (file == null) {
+			return {
+				sha: commit?.sha ?? deletedOrMissing,
+				// If it looks like non-sha like then preserve it as the friendly name
+				revision: isRevisionWithSuffix(ref) ? (commit?.sha ?? ref) : ref,
+			};
+		}
+
+		if (file.status === 'A') {
+			return {
+				sha: commit?.sha ?? deletedOrMissing,
+				// If it looks like non-sha like then preserve it as the friendly name
+				revision: isRevisionWithSuffix(ref) ? (commit?.sha ?? ref) : ref,
+				status: file.status as GitFileStatus,
+				originalPath: file.originalPath,
+			};
+		}
+
+		if (file.status === 'D') {
+			// If the file was deleted, check if it was moved or renamed
+			result = await this.git.exec(
+				{ cwd: repoPath, errors: 'ignore', caching: resolvedRevisionCaching },
+				'log',
+				...parser.arguments,
+				'-n1',
+
+				commit!.sha,
+				'--',
+			);
+
+			commit = first(parser.parse(result.stdout));
+			file = commit?.files.find(f => f.path === relativePath || f.originalPath === relativePath);
+			if (file == null) {
+				return {
+					sha: commit?.sha ?? deletedOrMissing,
+					// If it looks like non-sha like then preserve it as the friendly name
+					revision: isRevisionWithSuffix(ref) ? (commit?.sha ?? ref) : ref,
+				};
+			}
+
+			return {
+				sha: commit?.sha ?? deletedOrMissing,
+				// If it looks like non-sha like without a suffix then preserve it as the friendly name
+				revision: isRevisionWithSuffix(ref) ? (commit?.sha ?? ref) : ref,
+				status: file.status as GitFileStatus,
+				path: file.path,
+				originalPath: file.originalPath,
+			};
+		}
+
+		return {
+			sha: commit?.sha ?? deletedOrMissing,
+			// If it looks like non-sha like then preserve it as the friendly name
+			revision: isRevisionWithSuffix(ref) ? (commit?.sha ?? ref) : ref,
+			status: file.status as GitFileStatus,
+			originalPath: file.originalPath,
+		};
+	}
+}