@gitkraken/core-gitlens 0.12.0 → 0.14.0

package/dist/git-cli/providers/operations.d.ts

@@ -10,6 +10,8 @@ export declare class OperationsGitSubProvider implements GitOperationsSubProvide
   private readonly git;
   private readonly cache;
   private readonly provider;
+  /** The `commonPath\0remote` pairs {@link followRemoteHeads} has handled */
+  private readonly followedRemoteHeads;
   constructor(context: GitServiceContext, git: Git, cache: Cache, provider: CliGitProviderInternal);
   checkout(repoPath: string, ref: string, options?: {
     createBranch?: string;
@@ -46,6 +48,18 @@ export declare class OperationsGitSubProvider implements GitOperationsSubProvide
     refspecs: readonly string[];
     preserveFetchHead?: boolean;
   }, runOptions?: GitOperationRunOptions): Promise<void>;
+  /**
+   * Writes the missing `refs/remotes/<remote>/HEAD` (the default branch the base reads) of each remote a fetch just
+   * read with its configured refspecs, once per remote, on git < 2.48 — newer git's fetch creates it itself. A bare
+   * fetch/pull reads every remote when `fetch.all` is set (git 2.44+), else its default remote. Right after the
+   * fetch, so the credentials it used are still cached. Never awaited; never rejects, failures not retried.
+   */
+  private followRemoteHeads;
+  /**
+   * The remote a bare `fetch`/`pull` reads: the current branch's `branch.<name>.remote` (none for `.`, the local
+   * repository), else the sole remote, else `origin`
+   */
+  private getDefaultFetchRemote;
   /** `remotes`, plus `heads`/`tags` for any local branch or tag the fetch writes — a `pull` fetch writes `<upstream>:<branch>` */
   private getFetchChanges;
   private fetchCore;
@@ -107,6 +121,9 @@ export declare class OperationsGitSubProvider implements GitOperationsSubProvide
    * the final default.
    */
   private throwIfSigningError;
+  /** Called once git has run, success or not — a rejected write can still have moved HEAD or left state behind */
+  private announceHeadChanged;
+  /** The caller has already announced the change — the conflict is what the failed run left behind */
   private createConflictResult;
 }
 //#endregion

package/dist/git-cli/providers/operations.js

@@ -6,8 +6,10 @@ import { normalizePath, splitPath } from "../../utils/path.js";
 import { isBranchReference } from "../../git/utils/reference.utils.js";
 import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
 import { CheckoutError, CherryPickError, CommitError, FetchError, MergeError, PullError, PushError, RebaseError, ResetError, RevertError, SigningError } from "../../git/errors.js";
+import { mayWriteTracking } from "../exec/commandClassifier.js";
 import { GitErrors, classifySigningError, getGitCommandError, gitConfigsPull, inferSigningFormatFromError, maxGitCliLength } from "../exec/git.js";
-import { getBranchNameAndRemote, getBranchTrackingWithoutRemote } from "../../git/utils/branch.utils.js";
+import { resolveBranchRemote } from "./branchRemote.js";
+import { parseGitBoolean } from "./config.js";
 import { sequentialize } from "../../utils/decorators/sequentialize.js";
 import * as l10n from "@vscode/l10n";
 //#region ../git-cli/src/providers/operations.ts
@@ -16,6 +18,8 @@ var OperationsGitSubProvider = class {
 	git;
 	cache;
 	provider;
+	/** The `commonPath\0remote` pairs {@link followRemoteHeads} has handled */
+	followedRemoteHeads = /* @__PURE__ */ new Set();
 	constructor(context, git, cache, provider) {
 		this.context = context;
 		this.git = git;
@@ -37,12 +41,6 @@ var OperationsGitSubProvider = class {
 				...runOptions
 			}, ...params);
 			if (options?.createBranch) this.cache.deleteBaseBranchName(repoPath, options.createBranch);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, [
-				"head",
-				"heads",
-				"index"
-			]);
 		} catch (ex) {
 			scope?.error(ex);
 			throw getGitCommandError("checkout", ex, (reason) => new CheckoutError({
@@ -53,6 +51,8 @@ var OperationsGitSubProvider = class {
 					args: params
 				}
 			}, ex));
+		} finally {
+			this.announceHeadChanged(repoPath, Boolean(options?.createBranch) && mayWriteTracking(ref, options?.noTracking));
 		}
 	}
 	async cherryPick(repoPath, revs, options, runOptions) {
@@ -72,17 +72,15 @@ var OperationsGitSubProvider = class {
 		}
 		args.push(...revs);
 		try {
-			await this.git.run({
-				cwd: repoPath,
-				errors: "throw",
-				...runOptions
-			}, ...args);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, [
-				"head",
-				"heads",
-				"index"
-			]);
+			try {
+				await this.git.run({
+					cwd: repoPath,
+					errors: "throw",
+					...runOptions
+				}, ...args);
+			} finally {
+				this.announceHeadChanged(repoPath);
+			}
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
@@ -112,19 +110,17 @@ var OperationsGitSubProvider = class {
 		if (sign) params.push("-S");
 		params.push("-F", "-");
 		try {
-			await this.git.run({
-				cwd: repoPath,
-				stdin: message,
-				stdinEncoding: "utf8",
-				errors: "throw",
-				...runOptions
-			}, ...params);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, [
-				"head",
-				"heads",
-				"index"
-			]);
+			try {
+				await this.git.run({
+					cwd: repoPath,
+					stdin: message,
+					stdinEncoding: "utf8",
+					errors: "throw",
+					...runOptions
+				}, ...params);
+			} finally {
+				this.announceHeadChanged(repoPath);
+			}
 			if (sign) {
 				let format;
 				try {
@@ -148,21 +144,23 @@ var OperationsGitSubProvider = class {
 		const scope = getScopedLogger();
 		const { branch, ...opts } = options ?? {};
 		let ran = false;
+		let fetched;
 		try {
 			if (isBranchReference(branch)) {
-				const [branchName, remoteName] = getBranchNameAndRemote(branch);
-				if (remoteName == null) return;
+				const resolved = await resolveBranchRemote(this.provider, repoPath, branch, runOptions?.cancellation);
+				if (resolved.remote == null) return;
 				ran = true;
 				await this.fetchCore(repoPath, {
-					branch: branchName,
-					remote: remoteName,
-					upstream: getBranchTrackingWithoutRemote(branch),
+					branch: resolved.name,
+					remote: resolved.remote,
+					upstream: resolved.upstream,
 					pull: options?.pull,
 					preserveFetchHead: options?.preserveFetchHead
 				}, runOptions);
 			} else {
 				ran = true;
 				await this.fetchCore(repoPath, opts, runOptions);
+				if (!opts.refspecs?.length) fetched = opts.remote != null ? { remote: opts.remote } : opts.all ? "all" : "default";
 			}
 		} catch (ex) {
 			scope?.error(ex);
@@ -172,8 +170,46 @@ var OperationsGitSubProvider = class {
 				this.context.hooks?.cache?.onReset?.(repoPath, "branches", "tags");
 				this.context.hooks?.repository?.onChanged?.(repoPath, this.getFetchChanges(branch, options));
 			}
+			if (fetched != null) this.followRemoteHeads(repoPath, fetched);
 		}
 	}
+	/**
+	* Writes the missing `refs/remotes/<remote>/HEAD` (the default branch the base reads) of each remote a fetch just
+	* read with its configured refspecs, once per remote, on git < 2.48 — newer git's fetch creates it itself. A bare
+	* fetch/pull reads every remote when `fetch.all` is set (git 2.44+), else its default remote. Right after the
+	* fetch, so the credentials it used are still cached. Never awaited; never rejects, failures not retried.
+	*/
+	async followRemoteHeads(repoPath, fetched) {
+		try {
+			if (await this.git.supports("git:fetch:follow-remote-head")) return;
+			const commonPath = this.cache.getCommonPath(repoPath);
+			const pending = (names) => names.filter((r) => !this.followedRemoteHeads.has(`${commonPath}\0${r}`));
+			const config = await this.provider.config.getConfigRegex(repoPath, "^(fetch\\.all|remote\\..+\\.skipfetchall|branch\\..+\\.remote)$");
+			if (fetched === "default" && parseGitBoolean(config.get("fetch.all")) && await this.git.supports("git:fetch:all-config")) fetched = "all";
+			let remotes;
+			if (fetched === "all") remotes = pending((await this.provider.remotes.getRemotes(repoPath)).map((r) => r.name).filter((r) => !parseGitBoolean(config.get(`remote.${r}.skipfetchall`))));
+			else if (fetched === "default") {
+				const remote = await this.getDefaultFetchRemote(repoPath, config);
+				remotes = pending(remote != null ? [remote] : []);
+			} else remotes = pending([fetched.remote]);
+			if (!remotes.length) return;
+			for (const remote of remotes) this.followedRemoteHeads.add(`${commonPath}\0${remote}`);
+			for (const remote of remotes) try {
+				await this.provider.branches.setRemoteHeadIfMissing(repoPath, remote);
+			} catch {}
+		} catch {}
+	}
+	/**
+	* The remote a bare `fetch`/`pull` reads: the current branch's `branch.<name>.remote` (none for `.`, the local
+	* repository), else the sole remote, else `origin`
+	*/
+	async getDefaultFetchRemote(repoPath, config) {
+		const current = await this.provider.branches.getBranch(repoPath);
+		const configured = current != null ? config.get(`branch.${current.name}.remote`) : void 0;
+		if (configured) return configured === "." ? void 0 : configured;
+		const remotes = await this.provider.remotes.getRemotes(repoPath);
+		return remotes.length === 1 ? remotes[0].name : "origin";
+	}
 	/** `remotes`, plus `heads`/`tags` for any local branch or tag the fetch writes — a `pull` fetch writes `<upstream>:<branch>` */
 	getFetchChanges(branch, options) {
 		if (isBranchReference(branch)) return options?.pull ? ["heads", "remotes"] : ["remotes"];
@@ -234,18 +270,16 @@ var OperationsGitSubProvider = class {
 		if (options?.noCommit) args.push("--no-commit");
 		args.push(ref);
 		try {
-			await this.git.run({
-				cwd: repoPath,
-				errors: "throw",
-				timeout: 0,
-				...runOptions
-			}, ...args);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, [
-				"head",
-				"heads",
-				"index"
-			]);
+			try {
+				await this.git.run({
+					cwd: repoPath,
+					errors: "throw",
+					timeout: 0,
+					...runOptions
+				}, ...args);
+			} finally {
+				this.announceHeadChanged(repoPath);
+			}
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
@@ -265,6 +299,7 @@ var OperationsGitSubProvider = class {
 	async pull(repoPath, options, runOptions) {
 		const scope = getScopedLogger();
 		let announce;
+		let fetched;
 		try {
 			if (isBranchReference(options?.branch)) {
 				const branch = options.branch;
@@ -283,12 +318,15 @@ var OperationsGitSubProvider = class {
 							tags: options?.tags,
 							source: options?.source
 						}, runOptions);
+						fetched = {
+							repoPath: worktreePath,
+							remotes: "default"
+						};
 					} finally {
 						this.context.hooks?.operations?.onRebaseCapableOperation?.(worktreePath, "pull", "ended");
 					}
 				} else if (options?.fastForward === "only") {
-					const [branchName, remoteName] = getBranchNameAndRemote(branch);
-					const upstream = getBranchTrackingWithoutRemote(branch);
+					const { name: branchName, remote: remoteName, upstream } = await resolveBranchRemote(this.provider, repoPath, branch, runOptions?.cancellation);
 					if (remoteName == null || upstream == null) throw new PullError({
 						reason: "noUpstream",
 						gitCommand: {
@@ -331,6 +369,10 @@ var OperationsGitSubProvider = class {
 					tags: options?.tags,
 					source: options?.source
 				}, runOptions);
+				fetched = {
+					repoPath,
+					remotes: "default"
+				};
 			} finally {
 				this.context.hooks?.operations?.onRebaseCapableOperation?.(repoPath, "pull", "ended");
 			}
@@ -339,6 +381,7 @@ var OperationsGitSubProvider = class {
 			throw ex;
 		} finally {
 			announce?.();
+			if (fetched != null) this.followRemoteHeads(fetched.repoPath, fetched.remotes);
 		}
 	}
 	announcePull(repoPath) {
@@ -378,27 +421,34 @@ var OperationsGitSubProvider = class {
 		let branchName;
 		let remoteName;
 		let upstreamName;
+		let trackUpstream = options?.publish != null;
 		let setUpstream;
 		if (isBranchReference(options?.reference)) {
+			const resolved = await resolveBranchRemote(this.provider, repoPath, options.reference, runOptions?.cancellation);
 			if (options.publish != null) {
 				branchName = options.reference.name;
 				remoteName = options.publish.remote;
-			} else [branchName, remoteName] = getBranchNameAndRemote(options.reference);
-			upstreamName = getBranchTrackingWithoutRemote(options.reference);
+			} else {
+				branchName = resolved.name;
+				remoteName = resolved.remote;
+			}
+			upstreamName = resolved.upstream;
+			trackUpstream ||= options.reference.upstream?.missing === true;
 		} else {
 			const branch = await this.provider.branches.getBranch(repoPath);
 			if (branch == null) return;
-			if (options?.reference != null) branchName = `${options.reference.ref}:${options?.publish != null ? "refs/heads/" : ""}${branch.nameWithoutRemote}`;
+			const resolved = await resolveBranchRemote(this.provider, repoPath, branch, runOptions?.cancellation);
+			if (options?.reference != null) branchName = `${options.reference.ref}:${options?.publish != null ? "refs/heads/" : ""}${resolved.name}`;
 			else {
-				const tracking = options?.publish == null ? branch.trackingWithoutRemote : void 0;
-				branchName = tracking != null && tracking !== branch.nameWithoutRemote ? `${branch.name}:${tracking}` : branch.name;
+				const tracking = options?.publish == null ? resolved.upstream : void 0;
+				branchName = tracking != null && tracking !== resolved.name ? `${branch.name}:${tracking}` : branch.name;
 			}
-			remoteName = branch.remoteName ?? options?.publish?.remote;
+			remoteName = resolved.remote ?? options?.publish?.remote;
 			upstreamName = options?.reference == null && options?.publish != null ? branch.name : void 0;
 			if (options?.publish?.remote != null && options?.reference != null) setUpstream = {
-				branch: branch.nameWithoutRemote,
+				branch: resolved.name,
 				remote: remoteName,
-				remoteBranch: branch.nameWithoutRemote
+				remoteBranch: resolved.name
 			};
 		}
 		if (options?.publish == null && remoteName == null && upstreamName == null) throw new PushError({ reason: "other" });
@@ -413,7 +463,7 @@ var OperationsGitSubProvider = class {
 				remote: remoteName,
 				upstream: upstreamName,
 				force: forceOpts,
-				publish: options?.publish != null
+				setUpstream: trackUpstream
 			}, runOptions);
 			if (setUpstream != null) try {
 				await this.git.run({
@@ -428,11 +478,11 @@ var OperationsGitSubProvider = class {
 			throw ex;
 		} finally {
 			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, options?.publish != null ? [
-				"config",
-				"heads",
-				"remotes"
-			] : ["remotes"]);
+			const changes = [];
+			if (trackUpstream || setUpstream != null) changes.push("config");
+			if (options?.publish != null) changes.push("heads");
+			changes.push("remotes");
+			this.context.hooks?.repository?.onChanged?.(repoPath, changes);
 		}
 	}
 	async pushCore(repoPath, options, runOptions) {
@@ -446,8 +496,10 @@ var OperationsGitSubProvider = class {
 			} else params.push("--force");
 		}
 		if (options.branch && options.remote) {
-			if (options.upstream) params.push("-u", options.remote, `${options.branch}:${options.upstream}`);
-			else if (options.publish) params.push("--set-upstream", options.remote, options.branch);
+			if (options.upstream) {
+				if (options.setUpstream) params.push("-u");
+				params.push(options.remote, `${options.branch}:${options.upstream}`);
+			} else if (options.setUpstream) params.push("--set-upstream", options.remote, options.branch);
 			else params.push(options.remote, options.branch);
 		} else if (options.remote) params.push(options.remote);
 		else if (options.delete) params.push(options.delete.remote, `:${options.delete.branch}`);
@@ -528,20 +580,18 @@ var OperationsGitSubProvider = class {
 		if (options?.branch) args.push(options.branch);
 		this.context.hooks?.operations?.onRebaseCapableOperation?.(repoPath, "rebase", "started");
 		try {
-			await this.git.run({
-				cwd: repoPath,
-				errors: "throw",
-				configs,
-				timeout: 0,
-				...runOptions,
-				env
-			}, ...args);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, [
-				"head",
-				"heads",
-				"index"
-			]);
+			try {
+				await this.git.run({
+					cwd: repoPath,
+					errors: "throw",
+					configs,
+					timeout: 0,
+					...runOptions,
+					env
+				}, ...args);
+			} finally {
+				this.announceHeadChanged(repoPath);
+			}
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
@@ -564,15 +614,11 @@ var OperationsGitSubProvider = class {
 		const scope = getScopedLogger();
 		try {
 			await this.resetCore(repoPath, rev, options?.mode, runOptions);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, [
-				"head",
-				"heads",
-				"index"
-			]);
 		} catch (ex) {
 			scope?.error(ex);
 			throw ex;
+		} finally {
+			this.announceHeadChanged(repoPath);
 		}
 	}
 	async resetCore(repoPath, rev, mode, runOptions) {
@@ -606,11 +652,13 @@ var OperationsGitSubProvider = class {
 			selector,
 			"--"
 		] : ["checkout", "--"];
+		let ran = false;
 		try {
 			if (await this.git.supports("git:checkout:pathspec-from-file")) {
 				const args = ["checkout"];
 				if (selector != null) args.push(selector);
 				args.push("--pathspec-from-file=-", "--pathspec-file-nul");
+				ran = true;
 				await this.git.run({
 					cwd: repoPath,
 					errors: "throw",
@@ -620,14 +668,15 @@ var OperationsGitSubProvider = class {
 			} else {
 				const perArgOverhead = 3;
 				const prefixLength = prefix.reduce((sum, arg) => sum + arg.length + perArgOverhead, 0);
-				for (const batch of chunkByStringLength(normalized, maxGitCliLength - prefixLength, perArgOverhead)) await this.git.run({
-					cwd: repoPath,
-					errors: "throw",
-					...runOptions
-				}, ...prefix, ...batch);
+				for (const batch of chunkByStringLength(normalized, maxGitCliLength - prefixLength, perArgOverhead)) {
+					ran = true;
+					await this.git.run({
+						cwd: repoPath,
+						errors: "throw",
+						...runOptions
+					}, ...prefix, ...batch);
+				}
 			}
-			this.context.hooks?.cache?.onReset?.(repoPath, "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["index"]);
 		} catch (ex) {
 			scope?.error(ex);
 			throw getGitCommandError("checkout", ex, (reason) => new CheckoutError({
@@ -638,6 +687,11 @@ var OperationsGitSubProvider = class {
 					args: [...prefix, ...normalized]
 				}
 			}, ex));
+		} finally {
+			if (ran) {
+				this.context.hooks?.cache?.onReset?.(repoPath, "status");
+				this.context.hooks?.repository?.onChanged?.(repoPath, ["index"]);
+			}
 		}
 	}
 	async revert(repoPath, refs, options, runOptions) {
@@ -647,18 +701,16 @@ var OperationsGitSubProvider = class {
 		else if (options?.editMessage === false) args.push("--no-edit");
 		args.push(...refs);
 		try {
-			await this.git.run({
-				cwd: repoPath,
-				errors: "throw",
-				timeout: 0,
-				...runOptions
-			}, ...args);
-			this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-			this.context.hooks?.repository?.onChanged?.(repoPath, [
-				"head",
-				"heads",
-				"index"
-			]);
+			try {
+				await this.git.run({
+					cwd: repoPath,
+					errors: "throw",
+					timeout: 0,
+					...runOptions
+				}, ...args);
+			} finally {
+				this.announceHeadChanged(repoPath);
+			}
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
@@ -702,6 +754,21 @@ var OperationsGitSubProvider = class {
 			}
 		}, ex instanceof Error ? ex : void 0);
 	}
+	/** Called once git has run, success or not — a rejected write can still have moved HEAD or left state behind */
+	announceHeadChanged(repoPath, wroteTracking) {
+		this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
+		this.context.hooks?.repository?.onChanged?.(repoPath, wroteTracking ? [
+			"config",
+			"head",
+			"heads",
+			"index"
+		] : [
+			"head",
+			"heads",
+			"index"
+		]);
+	}
+	/** The caller has already announced the change — the conflict is what the failed run left behind */
 	async createConflictResult(repoPath, command) {
 		let conflicts;
 		try {
@@ -709,12 +776,6 @@ var OperationsGitSubProvider = class {
 		} catch (ex) {
 			_logger.warn(`Unable to read conflicting files after ${command}: ${ex}`);
 		}
-		this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-		this.context.hooks?.repository?.onChanged?.(repoPath, [
-			"head",
-			"heads",
-			"index"
-		]);
 		this.context.hooks?.operations?.onConflicted?.(command, conflicts);
 		return {
 			conflicted: true,