@gitkraken/core-gitlens 0.15.4 → 0.15.6

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

@@ -2,10 +2,12 @@ import { chunkByStringLength } from "../../utils/iterable.js";
 import { Logger as _logger } from "../../utils/logger.js";
 import { getScopedLogger } from "../../utils/logger.scoped.js";
 import { debug } from "../../utils/decorators/log.js";
+import { joinUriPath } from "../../utils/uri.js";
 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 { getRefChangeKind } from "../../git/watching/changeEvent.js";
 import { mayWriteTracking } from "../exec/commandClassifier.js";
 import { GitErrors, classifySigningError, getGitCommandError, gitConfigsPull, inferSigningFormatFromError, isRunHookFailure, maxGitCliLength } from "../exec/git.js";
 import { resolveBranchRemote } from "./branchRemote.js";
@@ -13,6 +15,51 @@ 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
+/** The ref kinds a fetch can move, in the order its announcement lists them */
+const fetchRefChangeKinds = [
+	"remotes",
+	"heads",
+	"tags",
+	"stash"
+];
+/** The destinations a fetch's snapshot covers when the remotes' configured refspecs can't be read */
+const broadFetchDestinations = ["refs/heads", "refs/remotes"];
+/**
+* The ref a fetch refspec stores into, qualified as git's fetch does — `heads/`, `tags/` and `remotes/` get `refs/`,
+* and any other unqualified name is a local branch — or `undefined` when it stores nothing (no `:`, or nothing after
+* it). A glob destination keeps its glob.
+*/
+function getRefspecDestination(refspec) {
+	const stripped = refspec.startsWith("+") ? refspec.slice(1) : refspec;
+	const colonIndex = stripped.indexOf(":");
+	if (colonIndex === -1) return void 0;
+	const destination = stripped.slice(colonIndex + 1);
+	if (!destination) return void 0;
+	if (destination.startsWith("refs/")) return destination;
+	return /^(?:heads|tags|remotes)\//.test(destination) ? `refs/${destination}` : `refs/heads/${destination}`;
+}
+/**
+* The for-each-ref patterns covering `destinations` (the refs a fetch may store into) and tags, which a fetch follows
+* into what it fetched. A pattern's `*` doesn't match across `/`, so a glob destination is widened to the directory
+* above its first glob.
+*/
+function getFetchSnapshotPatterns(destinations) {
+	const patterns = ["refs/tags"];
+	for (let destination of destinations) {
+		const globIndex = destination.search(/[*?[]/);
+		if (globIndex !== -1) destination = destination.substring(0, destination.lastIndexOf("/", globIndex));
+		if (patterns.some((p) => destination === p || destination.startsWith(`${p}/`))) continue;
+		patterns.push(destination);
+	}
+	return patterns;
+}
+/** The refs created, moved, retargeted or deleted between two snapshots */
+function getMovedRefs(before, after) {
+	const moved = [];
+	for (const [ref, sha] of after) if (before.get(ref) !== sha) moved.push(ref);
+	for (const ref of before.keys()) if (!after.has(ref)) moved.push(ref);
+	return moved;
+}
 var OperationsGitSubProvider = class {
 	context;
 	git;
@@ -53,7 +100,7 @@ var OperationsGitSubProvider = class {
 				}
 			}, ex));
 		} finally {
-			this.announceHeadChanged(repoPath, Boolean(options?.createBranch) && mayWriteTracking(ref, options?.noTracking));
+			this.announceHeadChanged(repoPath, options?.createBranch ? `refs/heads/${options.createBranch}` : void 0, Boolean(options?.createBranch) && mayWriteTracking(ref, options?.noTracking));
 		}
 	}
 	async cherryPick(repoPath, revs, options, runOptions) {
@@ -111,6 +158,7 @@ var OperationsGitSubProvider = class {
 		const sign = this.context.config?.signing?.enabled === true;
 		if (sign) params.push("-S");
 		params.push("-F", "-");
+		const headBranchBefore = await this.readHeadBranchRef(repoPath);
 		try {
 			try {
 				await this.git.run({
@@ -121,7 +169,8 @@ var OperationsGitSubProvider = class {
 					...runOptions
 				}, ...params);
 			} finally {
-				this.announceHeadChanged(repoPath);
+				const headBranch = await this.readHeadBranchRef(repoPath);
+				this.announceHeadChanged(repoPath, headBranch === headBranchBefore ? headBranch : void 0);
 			}
 			if (sign) {
 				let format;
@@ -148,10 +197,16 @@ var OperationsGitSubProvider = class {
 		const { branch, ...opts } = options ?? {};
 		let ran = false;
 		let fetched;
+		let snapshot;
 		try {
 			if (isBranchReference(branch)) {
 				const resolved = await resolveBranchRemote(this.provider, repoPath, branch, runOptions?.cancellation);
 				if (resolved.remote == null) return;
+				const patterns = await this.getFetchSnapshotPatterns(repoPath, resolved.remote, options?.pull ? [`${resolved.upstream}:${resolved.name}`] : void 0);
+				snapshot = {
+					patterns,
+					before: await this.snapshotRefs(repoPath, patterns)
+				};
 				ran = true;
 				await this.fetchCore(repoPath, {
 					branch: resolved.name,
@@ -161,6 +216,11 @@ var OperationsGitSubProvider = class {
 					preserveFetchHead: options?.preserveFetchHead
 				}, runOptions);
 			} else {
+				const patterns = await this.getFetchSnapshotPatterns(repoPath, opts.remote, opts.refspecs);
+				snapshot = {
+					patterns,
+					before: await this.snapshotRefs(repoPath, patterns)
+				};
 				ran = true;
 				await this.fetchCore(repoPath, opts, runOptions);
 				if (!opts.refspecs?.length) fetched = opts.remote != null ? { remote: opts.remote } : opts.all ? "all" : "default";
@@ -169,10 +229,7 @@ var OperationsGitSubProvider = class {
 			scope?.error(ex);
 			throw ex;
 		} finally {
-			if (ran) {
-				this.context.hooks?.cache?.onReset?.(repoPath, "branches", "tags");
-				this.context.hooks?.repository?.onChanged?.(repoPath, this.getFetchChanges(branch, options));
-			}
+			if (ran) await this.announceFetch(repoPath, snapshot, () => this.getFetchChanges(branch, options));
 			if (fetched != null) this.followRemoteHeads(repoPath, fetched);
 		}
 	}
@@ -213,18 +270,97 @@ var OperationsGitSubProvider = class {
 		const remotes = await this.provider.remotes.getRemotes(repoPath);
 		return remotes.length === 1 ? remotes[0].name : "origin";
 	}
+	/**
+	* The for-each-ref patterns covering every ref a fetch from `remote` (`undefined`: from any remote) may write: the
+	* destinations of `refspecs`, those of the remote's configured `remote.<name>.fetch` refspecs (which a fetch of
+	* explicit refspecs still updates opportunistically, and which may store into local branches, as a mirror's do),
+	* and tags. A `remote` with no refspecs of its own may be a remote group (`remotes.<group>`), which fetches each of
+	* its remotes, so every remote's destinations stand for it. When the configuration can't be read, all local and
+	* remote-tracking branches stand for the configured destinations.
+	*/
+	async getFetchSnapshotPatterns(repoPath, remote, refspecs) {
+		const destinations = [];
+		const add = (refspec) => {
+			const destination = getRefspecDestination(refspec);
+			if (destination != null) destinations.push(destination);
+		};
+		for (const refspec of refspecs ?? []) add(refspec);
+		let configured;
+		try {
+			configured = await this.provider.config.getConfigRegexAll(repoPath, "^remote\\..+\\.fetch$");
+		} catch {
+			destinations.unshift(...broadFetchDestinations);
+		}
+		const ownKey = remote != null ? `remote.${remote}.fetch` : void 0;
+		const onlyKey = ownKey != null && configured?.has(ownKey) ? ownKey : void 0;
+		for (const [key, values] of configured ?? []) {
+			if (onlyKey != null && key !== onlyKey) continue;
+			for (const refspec of values) add(refspec);
+		}
+		return getFetchSnapshotPatterns(destinations);
+	}
+	/**
+	* Announces what a fetch moved. Its refs are compared with the snapshot taken before it ran, so a fetch that
+	* brought nothing new announces nothing (and resets nothing), and one that did names exactly the refs it moved,
+	* letting every worktree that doesn't track them skip its refresh. When either snapshot is missing, it announces
+	* `fallback()`'s kinds unnamed, as if every ref of them may have moved; when a ref moved outside the kinds an
+	* announcement can name (`refs/notes/*`), the kinds it did see, together with `fallback()`'s, unnamed.
+	*/
+	async announceFetch(repoPath, snapshot, fallback) {
+		const after = snapshot?.before != null ? await this.snapshotRefs(repoPath, snapshot.patterns) : void 0;
+		let changes;
+		let moved;
+		if (snapshot?.before != null && after != null) {
+			moved = getMovedRefs(snapshot.before, after);
+			if (!moved.length) return;
+			const kinds = /* @__PURE__ */ new Set();
+			let unnameable = false;
+			for (const ref of moved) {
+				const kind = ref.startsWith("refs/") ? getRefChangeKind(ref) : void 0;
+				if (kind != null) kinds.add(kind);
+				else unnameable = true;
+			}
+			if (unnameable) {
+				for (const kind of fallback()) kinds.add(kind);
+				moved = void 0;
+			}
+			changes = fetchRefChangeKinds.filter((k) => kinds.has(k));
+		}
+		this.context.hooks?.cache?.onReset?.(repoPath, "branches", "tags");
+		if (changes != null && moved != null) this.context.hooks?.repository?.onChanged?.(repoPath, changes, moved);
+		else this.context.hooks?.repository?.onChanged?.(repoPath, changes ?? fallback());
+	}
+	/**
+	* Each ref under `patterns` (for-each-ref patterns) with its object and, for a symbolic ref, its target (a remote's
+	* `HEAD` can move to another branch at the same commit), or `undefined` when git couldn't answer. A read, so it
+	* announces nothing.
+	*/
+	async snapshotRefs(repoPath, patterns) {
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				errors: "ignore"
+			}, "for-each-ref", "--format=%(refname)%00%(objectname)%00%(symref)", ...patterns);
+			if (result.completion.status !== "exited" || result.exitCode !== 0) return void 0;
+			const refs = /* @__PURE__ */ new Map();
+			for (const line of result.stdout.split("\n")) {
+				const index = line.indexOf("\0");
+				if (index === -1) continue;
+				refs.set(line.substring(0, index), line.substring(index + 1).trim());
+			}
+			return refs;
+		} catch {
+			return;
+		}
+	}
 	/** `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"];
 		if (!options?.refspecs?.length) return ["remotes"];
 		const changes = ["remotes"];
 		for (const refspec of options.refspecs) {
-			const stripped = refspec.startsWith("+") ? refspec.slice(1) : refspec;
-			const colonIndex = stripped.indexOf(":");
-			if (colonIndex === -1) continue;
-			let destination = stripped.slice(colonIndex + 1);
-			if (!destination) continue;
-			if (!destination.startsWith("refs/")) destination = /^(?:heads|tags|remotes)\//.test(destination) ? `refs/${destination}` : `refs/heads/${destination}`;
+			const destination = getRefspecDestination(refspec);
+			if (destination == null) continue;
 			if (destination.startsWith("refs/tags/")) {
 				if (!changes.includes("tags")) changes.push("tags");
 			} else if (destination.startsWith("refs/heads/")) {
@@ -772,10 +908,14 @@ 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) {
+	/**
+	* Called once git has run, success or not — a rejected write can still have moved HEAD or left state behind.
+	* `branchRef` is the full name of the one branch the write could have moved, when it knows it; `wroteTracking`
+	* says it wrote that branch's tracking, to its own config section.
+	*/
+	announceHeadChanged(repoPath, branchRef, wroteTracking) {
 		this.context.hooks?.cache?.onReset?.(repoPath, "branches", "status");
-		this.context.hooks?.repository?.onChanged?.(repoPath, wroteTracking ? [
+		const changes = wroteTracking ? [
 			"config",
 			"head",
 			"heads",
@@ -784,7 +924,26 @@ var OperationsGitSubProvider = class {
 			"head",
 			"heads",
 			"index"
-		]);
+		];
+		if (branchRef == null) this.context.hooks?.repository?.onChanged?.(repoPath, changes);
+		else if (wroteTracking) this.context.hooks?.repository?.onChanged?.(repoPath, changes, [branchRef], { configConfinedToRefs: true });
+		else this.context.hooks?.repository?.onChanged?.(repoPath, changes, [branchRef]);
+	}
+	/**
+	* The full name of the branch HEAD is on, from the worktree's own `HEAD` file (`ref: refs/heads/main`): read around
+	* a write, so it names the branch that write moved, whatever a switch outside core left in the caches; no git
+	* runs. `undefined` when HEAD is detached, unreadable, or not a branch name git allows — a reftable repository's
+	* `HEAD` file holds the placeholder `refs/heads/.invalid`, and its real HEAD is in the tables.
+	*/
+	async readHeadBranchRef(repoPath) {
+		try {
+			const gitDir = await this.provider.config.getGitDir(repoPath);
+			const head = new TextDecoder().decode(await this.context.fs.readFile(joinUriPath(gitDir.uri, "HEAD")));
+			const ref = /^ref:\s*(refs\/heads\/\S+)\s*$/.exec(head)?.[1];
+			return ref != null && !ref.split("/").some((part) => part.startsWith(".")) ? ref : void 0;
+		} catch {
+			return;
+		}
 	}
 	/** The caller has already announced the change — the conflict is what the failed run left behind */
 	async createConflictResult(repoPath, command) {