@gitkraken/core-gitlens 0.7.2 → 0.9.0

package/dist/git-cli/exec/git.js

@@ -4,13 +4,15 @@ import { getDurationMilliseconds, hrtime } from "../../utils/hrtime.js";
 import { Logger as _logger } from "../../utils/logger.js";
 import { formatLoggableScopeBlock } from "../../utils/logger.scoped.js";
 import { defer } from "../../utils/promise.js";
-import { dirname, isAbsolute, joinPaths, normalizePath } from "../../utils/path.js";
+import { arePathsEqual, dirname as dirname$1, isAbsolute as isAbsolute$1, isDescendant, joinPaths, normalizePath } from "../../utils/path.js";
 import { GitWarnings, WorkspaceUntrustedError } from "../../git/errors.js";
 import { gitFeaturesByVersion } from "../../git/features.js";
 import { CancelledRunError, RunError, fsExists, runSpawn } from "../../utils/env/node/exec.js";
 import { compare, fromString } from "../../utils/version.js";
+import { getChangesForCommand, leadingCommand } from "./commandClassifier.js";
 import { EventLoopMonitor } from "./eventLoopMonitor.js";
 import { GitQueue, getPrimaryGitCommand, inferGitCommandPriority } from "./gitQueue.js";
+import { resolve } from "path";
 import { spawn } from "child_process";
 import * as process from "process";
 //#region ../git-cli/src/exec/git.ts
@@ -75,7 +77,9 @@ const GitErrors = {
 	noRemoteReference: /unable to delete '.+?': remote ref does not exist/i,
 	noRemoteRepositorySpecified: /No remote repository specified\./i,
 	noUpstream: /^fatal:\s*The current branch .* has no upstream branch/i,
+	noTrackingInformation: /There is no tracking information for the current branch/i,
 	notAValidObjectName: /Not a valid object name/i,
+	notPossibleToFastForward: /Not possible to fast-forward/i,
 	notAWorkingTree: /'(.*?)' is not a working tree/i,
 	noUserNameConfigured: /Please tell me who you are\./i,
 	nothingToCommit: /nothing(?: added)? to commit|no changes added to commit/i,
@@ -91,7 +95,13 @@ const GitErrors = {
 	rebaseMultipleBranches: /cannot rebase onto multiple branches/i,
 	revertAborted: /revert.*aborted/i,
 	revertInProgress: /^(error: )?(revert|cherry-pick) is already in progress/i,
+	refAlreadyExists: /cannot lock ref '.*?': reference already exists/i,
+	refBadName: /refusing to update ref with bad name/i,
 	refLocked: /fatal:\s*cannot lock ref ['"].+['"]: unable to create file/i,
+	refNonexistentObject: /trying to write ref '.*?' with nonexistent object/i,
+	refNotAValidSha: /not a valid (?:old )?SHA1/i,
+	refUnableToResolve: /cannot lock ref '.*?': unable to resolve reference/i,
+	refValueMismatch: /cannot lock ref '.*?': is at [0-9a-f]+ but expected/i,
 	remoteAhead: /rejected because the remote contains work/i,
 	remoteConnectionFailed: /Could not read from remote repository/i,
 	remoteRejected: /rejected because the remote contains work/i,
@@ -199,7 +209,9 @@ const errorToReasonMap = /* @__PURE__ */ new Map([
 		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"],
 		[GitErrors.cantLockRef, "refLocked"],
 		[GitErrors.rebaseMultipleBranches, "rebaseMultipleBranches"],
-		[GitErrors.tagConflict, "tagConflict"]
+		[GitErrors.tagConflict, "tagConflict"],
+		[GitErrors.notPossibleToFastForward, "noFastForward"],
+		[GitErrors.noTrackingInformation, "noUpstream"]
 	]],
 	["push", [
 		[GitErrors.remoteAhead, "remoteAhead"],
@@ -255,6 +267,22 @@ const errorToReasonMap = /* @__PURE__ */ new Map([
 		[GitErrors.remoteRejected, "remoteRejected"],
 		[GitErrors.tagConflict, "tagConflict"]
 	]],
+	["update-ref", [
+		[GitErrors.refBadName, "invalidRef"],
+		[GitErrors.refNonexistentObject, "invalidObject"],
+		[GitErrors.refNotAValidSha, "invalidObject"],
+		[GitErrors.refValueMismatch, "conflict"],
+		[GitErrors.refAlreadyExists, "conflict"],
+		[GitErrors.refUnableToResolve, "conflict"],
+		[GitErrors.cantLockRef, "conflict"]
+	]],
+	["update-ref-delete", [
+		[GitErrors.refBadName, "invalidRef"],
+		[GitErrors.refNotAValidSha, "invalidObject"],
+		[GitErrors.refUnableToResolve, "notFound"],
+		[GitErrors.refValueMismatch, "conflict"],
+		[GitErrors.cantLockRef, "conflict"]
+	]],
 	["worktree-create", [[GitErrors.alreadyCheckedOut, "alreadyCheckedOut"], [GitErrors.alreadyExists, "alreadyExists"]]],
 	["worktree-delete", [
 		[GitErrors.worktreeLocked, "locked"],
@@ -338,10 +366,50 @@ function classifySearchError(ex) {
 	};
 	if (/unknown revision/i.test(stderr)) return { reason: "invalidRef" };
 }
+/**
+* Keys dropped from the INHERITED `process.env` before it seeds the base git environment. git hands these
+* to anything it launches (a hook, `rebase -x`, an editor invoked as `GIT_EDITOR`) to describe the command
+* it is running; a host started that way would otherwise run every command against THAT repository with
+* THAT command's settings, whatever `cwd` we pass. None is worth keeping when set deliberately either: a
+* `GIT_DIR` would point every repository the host opens at one. `options.env`, `options.getEnvironment()`
+* and a per-call `env` are merged in afterwards, so any of them can still set these keys (e.g. a temporary
+* `GIT_INDEX_FILE` for a call).
+*/
+const inheritedEnvKeysToDrop = /* @__PURE__ */ new Set([
+	"GIT_DIR",
+	"GIT_WORK_TREE",
+	"GIT_INDEX_FILE",
+	"GIT_COMMON_DIR",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_NAMESPACE",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_EXEC_PATH",
+	"GIT_PREFIX",
+	"GIT_REFLOG_ACTION"
+]);
+/**
+* Dropped only when git launched the host, which it always marks by exporting `GIT_EXEC_PATH`: an editor
+* opened for `commit --amend` gets that commit's author and date, while an identity set deliberately (e.g.
+* by direnv) must still reach our commits.
+*/
+const inheritedIdentityKeysToDrop = /* @__PURE__ */ new Set([
+	"GIT_AUTHOR_NAME",
+	"GIT_AUTHOR_EMAIL",
+	"GIT_AUTHOR_DATE",
+	"GIT_COMMITTER_NAME",
+	"GIT_COMMITTER_EMAIL",
+	"GIT_COMMITTER_DATE"
+]);
+/** `process.env` with {@link inheritedEnvKeysToDrop} removed, and {@link inheritedIdentityKeysToDrop} when git launched us. */
+function getInheritedEnv() {
+	const launchedByGit = process.env.GIT_EXEC_PATH != null;
+	return Object.fromEntries(Object.entries(process.env).filter(([key]) => !inheritedEnvKeysToDrop.has(key) && !(launchedByGit && inheritedIdentityKeysToDrop.has(key))));
+}
 const emptyArray = Object.freeze([]);
 const emptyObj = Object.freeze({});
 const trailingNewlineRegex = /[\r|\n]+$/;
-const uniqueCounterForStdin = getScopedCounter();
+const unsharedRunCounter = getScopedCounter();
 const uniqueCounterForStream = getScopedCounter();
 var Git = class {
 	_locator;
@@ -354,25 +422,37 @@ var Git = class {
 	_eventLoopMonitor = new EventLoopMonitor();
 	/** Count of git commands currently in flight, across both the exec and streaming paths */
 	_activeCommandCount = 0;
-	/** Cached base environment: process.env + static options.env + GCM/LC_ALL vars */
+	/** Cached base environment: process.env (minus {@link inheritedEnvKeysToDrop}) + static options.env + GCM/LC_ALL vars */
 	_baseEnv;
 	/** Cached full environment: base + dynamic getEnvironment() result */
 	_fullEnv;
 	/** Last dynamic env reference, used to detect when getEnvironment() returns a new object */
 	_lastDynamicEnv;
+	/** Bound via {@link bindChangeNotifier}; announces a `notify`-flagged run's changes. No-op until bound. */
+	_changeNotifier;
 	constructor(_locator, options = {}) {
 		this._locator = _locator;
 		this.options = options;
 		this._queue = new GitQueue(options.queue, { onSlowQueue: options.hooks?.onSlowQueue });
 	}
 	/**
+	* Binds the callback a `notify`-flagged {@link run} calls once it settles. `CliGitProvider` wires this
+	* to its own `notifyChanged` from its constructor — including when it's handed a pre-built `Git` via
+	* `options.git`, so a host-supplied instance gets bound too. With nothing bound, `notify` is a no-op.
+	* `repoPaths` holds more than one path only for a `-C`-scoped shared-state verb: the `-C` target, then the
+	* caller's own `cwd`.
+	*/
+	bindChangeNotifier(fn) {
+		this._changeNotifier = fn;
+	}
+	/**
 	* Returns the base environment for git commands. Cached to avoid spreading
 	* process.env (30-100+ keys) on every call. Includes static options.env and
 	* GCM/LC_ALL vars but NOT dynamic getEnvironment() or per-call env overrides.
 	*/
 	getBaseEnv() {
 		return this._baseEnv ??= {
-			...process.env,
+			...getInheritedEnv(),
 			...this.options.env ?? emptyObj,
 			GCM_INTERACTIVE: "NEVER",
 			GCM_PRESERVE_CREDS: "TRUE",
@@ -409,9 +489,20 @@ var Git = class {
 		this._queue.dispose();
 		this._eventLoopMonitor.dispose();
 	}
-	/** Clear pending commands (e.g. on cache reset) */
-	clearPendingCommands() {
-		this.pendingCommands.clear();
+	/**
+	* Drops in-flight commands so a later identical call spawns its own run instead of joining one that
+	* started before a change. With `repoPaths`, drops only runs whose `cwd` is one of them or inside one;
+	* without, drops every run.
+	*/
+	clearPendingCommands(repoPaths) {
+		if (repoPaths == null) {
+			this.pendingCommands.clear();
+			return;
+		}
+		for (const [key, { cwd }] of this.pendingCommands) {
+			if (cwd == null) continue;
+			if (repoPaths.some((p) => arePathsEqual(cwd, p) || isDescendant(cwd, p))) this.pendingCommands.delete(key);
+		}
 	}
 	/** Marks one more git command as in flight; starts the event-loop monitor on the first. */
 	beginActiveCommand() {
@@ -466,21 +557,61 @@ var Git = class {
 	async run(options, ...args) {
 		if (this.options.isTrusted?.() === false) throw new WorkspaceUntrustedError();
 		const runArgs = args.filter((a) => a != null);
-		const gitCommand = `git ${runArgs.join(" ")}`;
-		if (options.caching != null) return options.caching.cache.getOrCreate(options.caching.commonPath ?? options.cwd, gitCommand, async (cacheable, signal) => {
-			const result = await this.runCore({
+		if (options.notify != null) try {
+			return await this.run({
 				...options,
-				caching: void 0,
-				cancellation: signal ?? options.cancellation
-			}, runArgs, gitCommand);
-			if (result.completion.status !== "exited" || result.exitCode !== 0 || signal?.aborted) cacheable.invalidate();
-			return result;
-		}, {
-			...options.caching.options,
-			cancellation: options.cancellation
-		});
+				notify: void 0
+			}, ...args);
+		} finally {
+			this.applyNotify(options, runArgs);
+		}
+		const gitCommand = `git ${runArgs.join(" ")}`;
+		if (options.caching != null) {
+			const cachePath = options.caching.commonPath ?? options.cwd;
+			if (options.caching.force) options.caching.cache.delete(cachePath, gitCommand);
+			return options.caching.cache.getOrCreate(cachePath, gitCommand, async (cacheable, signal) => {
+				const result = await this.runCore({
+					...options,
+					caching: void 0,
+					cancellation: signal ?? options.cancellation
+				}, runArgs, gitCommand);
+				if (result.completion.status !== "exited" || result.exitCode !== 0 || signal?.aborted) cacheable.invalidate();
+				return result;
+			}, {
+				...options.caching.options,
+				cancellation: options.cancellation
+			});
+		}
 		return this.runCore(options, runArgs, gitCommand);
 	}
+	/**
+	* Applies `options.notify` once a {@link run} has settled — a no-op unless both `notify` and a
+	* {@link bindChangeNotifier bound} notifier are present, so an unflagged caller pays nothing.
+	*/
+	applyNotify(options, args) {
+		const notify = options.notify;
+		if (notify == null || this._changeNotifier == null || options.cwd == null) return;
+		if (notify !== "infer") {
+			this._changeNotifier([this.resolveNotifyPath(options.cwd, leadingCommand(args).pathOverride)], notify);
+			return;
+		}
+		const command = getChangesForCommand(args);
+		if (command == null) return;
+		const ranIn = this.resolveNotifyPath(options.cwd, command.pathOverride);
+		const cwd = normalizePath(options.cwd);
+		if (command.pathOverride != null && cwd !== ranIn && (command.sharedChanges.length || !command.changes.length)) {
+			if (command.sharedChanges.length === command.changes.length) this._changeNotifier([ranIn, cwd], command.changes);
+			else {
+				this._changeNotifier([ranIn], command.changes);
+				this._changeNotifier([cwd], command.sharedChanges);
+			}
+			return;
+		}
+		this._changeNotifier([ranIn], command.changes);
+	}
+	resolveNotifyPath(cwd, pathOverride) {
+		return normalizePath(pathOverride != null ? resolve(cwd, pathOverride) : cwd);
+	}
 	async runCore(options, args, gitCommand) {
 		const start = hrtime();
 		const startEpochMs = Date.now();
@@ -495,15 +626,19 @@ var Git = class {
 			env: this.buildEnv(options.env),
 			quiet: errorHandling === "ignore"
 		};
-		const cacheKey = `${correlationKey !== void 0 ? `${correlationKey}:` : ""}${options?.stdin != null ? `${uniqueCounterForStdin.next()}:` : ""}${cancellation != null ? `${getAbortSignalId(cancellation)}:` : ""}${gitCommand}`;
+		const unshared = options?.stdin != null || options?.env != null && Object.keys(options.env).length > 0;
+		const cacheKey = `${correlationKey !== void 0 ? `${correlationKey}:` : ""}${unshared ? `${unsharedRunCounter.next()}:` : ""}${cancellation != null ? `${getAbortSignalId(cancellation)}:` : ""}${gitCommand}`;
 		let execStart;
 		let waiting;
-		let promise = this.pendingCommands.get(cacheKey);
+		let promise = this.pendingCommands.get(cacheKey)?.promise;
 		if (promise == null) {
 			waiting = false;
 			const deferred = defer();
 			promise = deferred.promise;
-			this.pendingCommands.set(cacheKey, promise);
+			this.pendingCommands.set(cacheKey, {
+				cwd: options.cwd,
+				promise
+			});
 			args.unshift("-c", "core.quotepath=false", "-c", "color.ui=false", ...configs ?? emptyArray);
 			if (process.platform === "win32") args.unshift("-c", "core.longpaths=true");
 			if (cancellation != null) runOpts.cancellation = cancellation;
@@ -513,7 +648,7 @@ var Git = class {
 				execStart = hrtime();
 				return runSpawn(gitPath, args, encoding ?? "utf8", runOpts);
 			}, cancellation).then(deferred.fulfill, (e) => deferred.cancel(e instanceof Error ? e : new Error(String(e)))).finally(() => {
-				this.pendingCommands.delete(cacheKey);
+				if (this.pendingCommands.get(cacheKey)?.promise === deferred.promise) this.pendingCommands.delete(cacheKey);
 			}).catch(() => {});
 		} else {
 			waiting = true;
@@ -594,7 +729,7 @@ var Git = class {
 					}
 				};
 			}
-			if (ex instanceof CancelledRunError) exception = new CancellationError(ex);
+			if (ex instanceof CancelledRunError || !(ex instanceof RunError) && cancellation?.aborted) exception = new CancellationError(ex instanceof Error ? ex : void 0);
 			else exception = new GitError(ex);
 			if (errorHandling === "throw") throw exception;
 			const swallowed = exception;
@@ -719,10 +854,10 @@ var Git = class {
 		}, "rev-parse", "--git-dir", "--git-common-dir");
 		if (!result.stdout) return void 0;
 		let [dotGitPath, commonDotGitPath] = result.stdout.split("\n").map((r) => r.trimStart());
-		if (!isAbsolute(dotGitPath)) dotGitPath = joinPaths(cwd, dotGitPath);
+		if (!isAbsolute$1(dotGitPath)) dotGitPath = joinPaths(cwd, dotGitPath);
 		dotGitPath = normalizePath(dotGitPath);
 		if (commonDotGitPath) {
-			if (!isAbsolute(commonDotGitPath)) commonDotGitPath = joinPaths(cwd, commonDotGitPath);
+			if (!isAbsolute$1(commonDotGitPath)) commonDotGitPath = joinPaths(cwd, commonDotGitPath);
 			commonDotGitPath = normalizePath(commonDotGitPath);
 			return {
 				path: dotGitPath,
@@ -776,7 +911,7 @@ var Git = class {
 				let exists = inDotGit ? false : await fsExists(cwd);
 				if (!exists) {
 					do {
-						const parent = dirname(cwd);
+						const parent = dirname$1(cwd);
 						if (parent === cwd || parent.length === 0) return emptyArray;
 						cwd = parent;
 						exists = await fsExists(cwd);