@gitkraken/core-gitlens 0.8.0 → 0.9.1

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
@@ -364,6 +366,46 @@ 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]+$/;
@@ -380,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",
@@ -435,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() {
@@ -492,6 +557,14 @@ var Git = class {
 	async run(options, ...args) {
 		if (this.options.isTrusted?.() === false) throw new WorkspaceUntrustedError();
 		const runArgs = args.filter((a) => a != null);
+		if (options.notify != null) try {
+			return await this.run({
+				...options,
+				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;
@@ -511,6 +584,34 @@ var Git = class {
 		}
 		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();
@@ -529,12 +630,15 @@ var Git = class {
 		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;
@@ -544,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;
@@ -750,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,
@@ -807,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);