@gitkraken/core-gitlens 0.15.7 → 0.16.0

package/CHANGELOG.md

@@ -6,6 +6,15 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [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 +871,8 @@ 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.0...HEAD
+[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)) {
@@ -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);
 	}