@gitkraken/core-gitlens 0.12.0 → 0.13.0

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

@@ -3,11 +3,13 @@ import { Logger as _logger } from "../../utils/logger.js";
 import { getScopedLogger } from "../../utils/logger.scoped.js";
 import { debug } from "../../utils/decorators/log.js";
 import { normalizePath, splitPath } from "../../utils/path.js";
+import { getBranchNameAndRemote, getBranchTrackingWithoutRemote } from "../../git/utils/branch.utils.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 { 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,6 +144,7 @@ var OperationsGitSubProvider = class {
 		const scope = getScopedLogger();
 		const { branch, ...opts } = options ?? {};
 		let ran = false;
+		let fetched;
 		try {
 			if (isBranchReference(branch)) {
 				const [branchName, remoteName] = getBranchNameAndRemote(branch);
@@ -163,6 +160,7 @@ var OperationsGitSubProvider = class {
 			} 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,6 +318,10 @@ var OperationsGitSubProvider = class {
 							tags: options?.tags,
 							source: options?.source
 						}, runOptions);
+						fetched = {
+							repoPath: worktreePath,
+							remotes: "default"
+						};
 					} finally {
 						this.context.hooks?.operations?.onRebaseCapableOperation?.(worktreePath, "pull", "ended");
 					}
@@ -331,6 +370,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 +382,7 @@ var OperationsGitSubProvider = class {
 			throw ex;
 		} finally {
 			announce?.();
+			if (fetched != null) this.followRemoteHeads(fetched.repoPath, fetched.remotes);
 		}
 	}
 	announcePull(repoPath) {
@@ -378,6 +422,7 @@ var OperationsGitSubProvider = class {
 		let branchName;
 		let remoteName;
 		let upstreamName;
+		let trackUpstream = options?.publish != null;
 		let setUpstream;
 		if (isBranchReference(options?.reference)) {
 			if (options.publish != null) {
@@ -385,6 +430,7 @@ var OperationsGitSubProvider = class {
 				remoteName = options.publish.remote;
 			} else [branchName, remoteName] = getBranchNameAndRemote(options.reference);
 			upstreamName = getBranchTrackingWithoutRemote(options.reference);
+			trackUpstream ||= options.reference.upstream?.missing === true;
 		} else {
 			const branch = await this.provider.branches.getBranch(repoPath);
 			if (branch == null) return;
@@ -413,7 +459,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 +474,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 +492,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 +576,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 +610,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 +648,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 +664,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 +683,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 +697,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 +750,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 +772,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,