@gitkraken/core-gitlens 0.15.7 → 0.16.1

package/CHANGELOG.md

@@ -6,6 +6,28 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.16.1] - 2026-10-23
+
+### Added
+
+- Adds `GitOptions.spawn`, which launches the git process of every run and stream in place of Node's `spawn` (locating git still uses `execFile`), so a host whose process is large can start git from a helper process: on Linux a spawn forks the calling process, blocking its event loop for a time that grows with its memory. Exports `ProcessSpawner`, `ProcessSpawnOptions` and `SpawnedProcess` for it (git-cli, utils)
+
+### Fixed
+
+- Fixes a fetch that moves a remote-tracking ref making every worktree that asks for its push target re-run `rev-parse` to find its checked-out branch, one git process per worktree on top of the one shared ref list read: `getPushTarget` without a branch now takes the branch from the worktree's own `HEAD` file, so it runs no git process and is never older than the file. A `HEAD` file that can't say (reftable, an unreadable file, a branch that is a symbolic ref to another, such as a `master` kept pointing at `main`, or a HEAD kept as a symlink by `core.preferSymlinkRefs`, which reads as an object id like a detached HEAD but which the git dir's listing flags as a link) resolves the branch with git as before (git, git-cli)
+- Fixes a raw git write run with `notify: 'infer'` (a sync rebase, a compose run or an undo) making every worktree of the repository re-read its refs, because it announced whole ref kinds with no names: such a write now names the refs its argv proves it moved, as typed writes do since 0.15.5, so a host can skip worktrees that don't follow them. `update-ref` names its ref, and a write to a ref outside `refs/heads`, `refs/tags`, `refs/remotes` and `refs/stash` (a tool's own bookkeeping, such as `refs/undo/*`) announces nothing, as `updateReference` already did, and the file watcher no longer reports such a ref as an index, config or `HEAD` change when its name holds one of those words (`refs/kepler/sync/resolved/fix-index`); `branch`, `tag`, `checkout -b`/`switch -c`, `worktree add -b` and a plain `checkout <name>` name their branch or tag, with a branch's config change confined to its own section; `stash` writes name `refs/stash` (and `stash branch` the branch it creates), and `stash create` and `stash apply` move no ref; a detached checkout, a full-SHA checkout and every `worktree` subcommand other than `add` announce no branch. A `commit`, `reset`, `merge`, `cherry-pick`, `revert` or `am`, and a `rebase` with update-refs provably off, read the worktree's `HEAD` file before and after the run, without running git: on one branch both times they name it, and detached both times (a sync's scratch worktree) they announce no branch move at all; a `HEAD` kept as a symlink by `core.preferSymlinkRefs`, which reads as its branch's object id as a detached one does, counts as neither, so its branch move is announced unnamed. Anything the argv can't prove (`update-ref --stdin`, a rename of the current branch, a rebase that may update other branches) stays unnamed. With 60 linked worktrees, a sync rebase and apply of one branch went from ~420 git processes to ~65 and its undo from ~385 to ~30, none of them in the other worktrees (git, git-cli)
+- Fixes `updateReference` and `deleteReference` announcing their ref unnamed (a remote's `HEAD`, which an update moves through to the branch it points to, stays unnamed), and typed `reset`, `merge`, `cherryPick` and `revert` announcing their branch unnamed: they now name it, as `commit` does, and a detached HEAD's move announces no branch move. Such a move, raw or typed, still resets that worktree's branch and worktree lists, blame, diffs and contributors (git, git-cli)
+- Fixes `Git.stream` rejecting a stream its own `timeout` killed with a `CancelledRunError` whose reason is `'unknown'` rather than `'timeout'`, so a caller that branches on the reason read it as an outside kill; `run` already reported `'timeout'` (git-cli)
+
+## [0.16.0] - 2026-10-22
+
+### Fixed
+
+- Fixes a fetch that moves a worktree's base (usually `origin/main`) making every worktree summary based on it re-read its base, four or five git processes each: when the base ref is the only dependency that moved, by name, and it only fast-forwarded since the last read (by its reflog, since a commit of the branch's that the base held in between moves the fork point), the summary recounts ahead with one `rev-list --count`, past the new tip, the previous fork point and whatever the base's reflog reaches off the new tip's history, and, when the count is unchanged, keeps the target, tier and fork point, updating only the base's commit. The reflog and ancestry check is shared by every worktree of the repository, and anything else (the branch landing, a force-push, another dependency or an unnamed ref change moving, a base name another ref now also answers to, a remote `HEAD` retargeted so the default branch resolves differently, a fork point the base's reflog supplied, possibly since expired, a reflog entry holding the branch's commits, a shallow repository) re-reads the base in full. Adds an optional `GitBranchesSubProvider.getAheadOfBaseAfterBaseMove` for it, and an optional `AheadOfBase.defaultBranch`, the default branch a read resolved (`null` for none), which the re-measure compares and keeps (git, git-cli)
+- Fixes a `.git/config` write that leaves a worktree's base alone making its summary re-read it anyway, and every checkout list its config: a write confined to another branch's section (a task's new branch) woke no summary but left each one's config key stale, so the next unrelated write (`core.*`) re-read every base, 46 git processes over 8 linked worktrees, and any unconfined write listed the config once per checkout. A summary now keys its base on the remotes, `init.defaultBranch`, conditional includes and the tracking of only the branches its base read depended on, and the checkouts of a repository share one `git config` listing, read in the main checkout, unless it shows config that can differ by checkout (`extensions.worktreeConfig`, or an `includeIf` other than `hasconfig:` and `gitdir:`, such as `onbranch:`), when each checkout lists its own as before. A `gitdir:` include stays shared, as the common identity setup, so an edit to a file only some checkouts include goes unseen there until a change the shared listing sees. That write now costs 3 git processes, an unrelated write lists the config once rather than once per checkout, and a fetch after a write to another branch's section costs each linked worktree 1 process rather than 2 or 3. Adds an optional `GitBranchesSubProvider.getAheadOfBaseConfigEntries`, the entries `getAheadOfBaseConfigKey` is taken from, which a summary filters; with a provider without it, a summary keys on the whole snapshot as before (git, git-cli)
+- Fixes `getConfig` and `getConfigRegex` serving every worktree of a repository the answer of whichever one read first, so with `extensions.worktreeConfig` a worktree's own `config.worktree` values (its user identity or signing settings, read by `getCurrentUser` and `getSigningConfig`, or its pull and rebase settings) were missed or taken from another worktree: both are now cached per worktree, and a config write clears every worktree's entries (git, git-cli)
+- Fixes `createWorktree` announcing nothing about a branch git created on its own, from a branch name that exists only on a remote or, with no commitish, named after the path: it now announces `heads` with the branch's `refs/heads/<name>` and resets the branch and config caches, as with `createBranch`, and leaves the tracking config to the watcher's `.git/config` report. An add cancelled, timed out or refused a retry by the host, whose output (and so the name of any branch git created) is lost, announces `heads` unnamed (git-cli)
+
 ## [0.15.7] - 2026-10-22
 
 ### Added
@@ -862,7 +884,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 - Initial release. Bundles `@gitlens/utils`, `@gitlens/git`, `@gitlens/git-cli`, `@gitlens/ai`, and `@gitlens/git-github` into a single core npm package with subpath exports.
 
-[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.7...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.16.1...HEAD
+[0.16.1]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.16.0...gitkraken:releases/core/v0.16.1
+[0.16.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.7...gitkraken:releases/core/v0.16.0
 [0.15.7]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.6...gitkraken:releases/core/v0.15.7
 [0.15.6]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.5...gitkraken:releases/core/v0.15.6
 [0.15.5]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.4...gitkraken:releases/core/v0.15.5

package/dist/git/cache.d.ts

@@ -110,6 +110,7 @@ export declare class Cache implements Disposable {
   /** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
   getResourceUsage(): ResourceUsage;
   get aheadOfBaseConfigKey(): PromiseMap<RepoPath, string | undefined>;
+  get aheadOfBaseConfigListing(): PromiseMap<RepoPath, string | undefined>;
   get bestRemotes(): PromiseMap<RepoPath, GitRemote<RemoteProvider>[]>;
   get blame(): RepoPromiseCacheMap<string, ProgressiveGitBlame | undefined>;
   get diff(): RepoPromiseCacheMap<string, ParsedGitDiffHunks | undefined>;
@@ -293,7 +294,13 @@ export declare class Cache implements Disposable {
   getGkConfigSnapshot(repoPath: string): ReadonlyMap<string, string> | undefined;
   getBranches(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitBranch>>, mapper: (branches: PagedResult<GitBranch>, targetRepoPath: string, commonPath: string, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitBranch>>, cancellation?: AbortSignal): Promise<PagedResult<GitBranch>>;
   private static readonly globalConfigKey;
+  /**
+   * Keyed by `repoPath` itself, not its common path: git reads a worktree's own `config.worktree` too, so worktrees
+   * of one repository can see different values. A read that is the same for all of them runs from, and passes, the
+   * common path. The same holds for {@link getConfigRegex}.
+   */
   getConfig(repoPath: string | undefined, key: string, factory: () => PromiseOrValue<string | undefined>): Promise<string | undefined>;
+  /** Keyed by `repoPath` itself, as {@link getConfig} is */
   getConfigRegex(repoPath: string | undefined, pattern: string, factory: () => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>>;
   deleteConfig(repoPath: string | undefined, key: string): void;
   /**
@@ -425,6 +432,12 @@ export declare class Cache implements Disposable {
   getBranchMergedStatus(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitBranchMergedStatus>, cancellation?: AbortSignal): Promise<GitBranchMergedStatus>;
   /** Config can differ by checkout through config.worktree and conditional includes. */
   getAheadOfBaseConfigKey(repoPath: string, factory: (repoPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
+  /**
+   * One listing for every checkout of a repository, which serves a checkout's {@link getAheadOfBaseConfigKey} while
+   * nothing makes config differ by checkout. Evicted with it, hard, so a read after a change never joins one from
+   * before it.
+   */
+  getAheadOfBaseConfigListing(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
   getBranchMetadataMap(repoPath: string, factory: (commonPath: string) => PromiseOrValue<Map<string, BranchMetadata>>): Promise<Map<string, BranchMetadata>>;
   getDefaultBranchName(repoPath: string, remote: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
   /** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */

package/dist/git/cache.js

@@ -54,6 +54,7 @@ function getSettledOrPending(cache, key) {
 }
 /** Compile-time enforced: adding a key to SharedCaches without listing it here is a type error */
 const sharedCacheKeys = new Set(exhaustiveArray()([
+	"aheadOfBaseConfigListing",
 	"baseBranchName",
 	"branchMergedStatus",
 	"branchMetadataMap",
@@ -82,6 +83,7 @@ const sharedCacheKeys = new Set(exhaustiveArray()([
 function createEmptyCaches() {
 	return {
 		aheadOfBaseConfigKey: void 0,
+		aheadOfBaseConfigListing: void 0,
 		baseBranchName: void 0,
 		bestRemotes: void 0,
 		blame: void 0,
@@ -187,6 +189,9 @@ var Cache = class Cache {
 	get aheadOfBaseConfigKey() {
 		return this._caches.aheadOfBaseConfigKey ??= new PromiseMap();
 	}
+	get aheadOfBaseConfigListing() {
+		return this._caches.aheadOfBaseConfigListing ??= new PromiseMap();
+	}
 	get bestRemotes() {
 		return this._caches.bestRemotes ??= new PromiseMap();
 	}
@@ -420,6 +425,7 @@ var Cache = class Cache {
 			}
 			if (types.includes("branch")) {
 				keysToClear.add("aheadOfBaseConfigKey");
+				keysToClear.add("aheadOfBaseConfigListing");
 				keysToClear.add("baseBranchName");
 			}
 			if (types.includes("branches")) {
@@ -434,6 +440,7 @@ var Cache = class Cache {
 			}
 			if (types.includes("config")) {
 				keysToClear.add("aheadOfBaseConfigKey");
+				keysToClear.add("aheadOfBaseConfigListing");
 				keysToClear.add("baseBranchName");
 				keysToClear.add("configKeys");
 				keysToClear.add("configPatterns");
@@ -493,7 +500,7 @@ var Cache = class Cache {
 			else if (key === "aheadOfBaseConfigKey" && !worktreeOnly && (!types.length || types.includes("config"))) this.evictShared(key, repoPath, "evict");
 			else if (sharedCacheKeys.has(key)) {
 				if (!worktreeOnly) {
-					const hardEvict = key === "gitResults" && (types.includes("config") || types.includes("branch"));
+					const hardEvict = key === "aheadOfBaseConfigListing" || key === "gitResults" && (types.includes("config") || types.includes("branch"));
 					this.evictShared(key, repoPath, hardEvict ? "evict" : inFlight);
 				}
 			} else cache.delete(repoPath);
@@ -606,6 +613,7 @@ var Cache = class Cache {
 		if (previousCommonPath != null && previousCommonPath !== commonPath) this.unregisterRepoPath(normalizedPath);
 		if (previousCommonPath !== commonPath) {
 			this._caches.aheadOfBaseConfigKey?.delete(normalizedPath);
+			if (normalizedPath === commonPath) this._caches.aheadOfBaseConfigListing?.delete(commonPath);
 			this._caches.gitResults?.delete(normalizedPath);
 		}
 		this._commonPathRegistry.set(normalizedPath, commonPath);
@@ -649,6 +657,10 @@ var Cache = class Cache {
 				if (key === "gitResults" && isLastWorktree && repoPath !== commonPath) cache.delete(commonPath);
 				continue;
 			}
+			if (key === "aheadOfBaseConfigListing") {
+				if (repoPath === commonPath || isLastWorktree) cache.delete(commonPath);
+				continue;
+			}
 			const invalidate = cache.invalidate;
 			const evict = typeof invalidate === "function" ? (k) => invalidate.call(cache, k) : (k) => cache.delete(k);
 			if (sharedCacheKeys.has(key)) {
@@ -698,7 +710,7 @@ var Cache = class Cache {
 		if (hasAny("index", "head", "heads", "remotes", "ignores", "config")) this.incrementStatusGeneration(repoPath);
 		const types = /* @__PURE__ */ new Set();
 		if (hasAny("head")) types.add("branch");
-		if (hasAny("index", "heads", "pausedOp")) {
+		if (hasAny("index", "head", "heads", "pausedOp")) {
 			types.add("blame");
 			types.add("diff");
 			types.add("fileLog");
@@ -709,7 +721,7 @@ var Cache = class Cache {
 			types.add("branches");
 			types.add("worktrees");
 		}
-		if (hasAny("heads")) {
+		if (hasAny("head", "heads")) {
 			types.add("branches");
 			types.add("contributors");
 			types.add("worktrees");
@@ -809,16 +821,22 @@ var Cache = class Cache {
 		}, cancellation);
 	}
 	static globalConfigKey = "";
+	/**
+	* Keyed by `repoPath` itself, not its common path: git reads a worktree's own `config.worktree` too, so worktrees
+	* of one repository can see different values. A read that is the same for all of them runs from, and passes, the
+	* common path. The same holds for {@link getConfigRegex}.
+	*/
 	getConfig(repoPath, key, factory) {
-		const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
+		const cacheKey = repoPath ?? Cache.globalConfigKey;
 		const result = this.configKeys.get(cacheKey, key);
 		if (result != null) return result;
 		const factoryPromise = Promise.resolve(factory());
 		this.configKeys.set(cacheKey, key, factoryPromise);
 		return factoryPromise;
 	}
+	/** Keyed by `repoPath` itself, as {@link getConfig} is */
 	getConfigRegex(repoPath, pattern, factory) {
-		const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
+		const cacheKey = repoPath ?? Cache.globalConfigKey;
 		const result = this.configPatterns.get(cacheKey, pattern);
 		if (result != null) return result;
 		const factoryPromise = Promise.resolve(factory());
@@ -826,9 +844,20 @@ var Cache = class Cache {
 		return factoryPromise;
 	}
 	deleteConfig(repoPath, key) {
-		const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
-		this._caches.configKeys?.delete(cacheKey, key);
-		this._caches.configPatterns?.delete(cacheKey);
+		if (repoPath == null) {
+			this._caches.configKeys?.delete(Cache.globalConfigKey, key);
+			this._caches.configPatterns?.delete(Cache.globalConfigKey);
+			return;
+		}
+		const commonPath = this.getCommonPath(repoPath);
+		for (const path of /* @__PURE__ */ new Set([
+			commonPath,
+			repoPath,
+			...this.getWorktreePaths(commonPath)
+		])) {
+			this._caches.configKeys?.delete(path, key);
+			this._caches.configPatterns?.delete(path);
+		}
 	}
 	/**
 	* The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
@@ -1129,6 +1158,14 @@ var Cache = class Cache {
 	getAheadOfBaseConfigKey(repoPath, factory, cancellation) {
 		return this.aheadOfBaseConfigKey.getOrCreate(repoPath, (cacheable, signal) => Promise.resolve(factory(repoPath, cacheable, signal)), cancellation);
 	}
+	/**
+	* One listing for every checkout of a repository, which serves a checkout's {@link getAheadOfBaseConfigKey} while
+	* nothing makes config differ by checkout. Evicted with it, hard, so a read after a change never joins one from
+	* before it.
+	*/
+	getAheadOfBaseConfigListing(repoPath, factory, cancellation) {
+		return this.getSharedSimple(this.aheadOfBaseConfigListing, repoPath, factory, cancellation);
+	}
 	getBranchMetadataMap(repoPath, factory) {
 		return this.getSharedSimple(this.branchMetadataMap, repoPath, factory);
 	}