@gitkraken/core-gitlens 0.15.4 → 0.15.6

package/CHANGELOG.md

@@ -6,6 +6,28 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.15.6] - 2026-10-22
+
+### Fixed
+
+- Fixes integration warnings carrying internal JavaScript error text (`response.body.map is not a function`, `Cannot read properties of undefined (reading 'id')`) when a provider answers a read with a 2xx whose JSON is not the shape the read expects, such as a gateway's JSON error on Jira Cloud's site list, Trello's boards or Linear's organization. The warning now reads "Expected data but the provider returned an unexpected response" and carries the new `cause.reason: 'unexpected-response'` on an `other` warning with `isAuth: false`; a scope failure of a fan-out core runs itself, such as Jira's per-site project reads, names the same cause. The read still fails as before, with the same `fetchFailed` and retry cursor, and the original error is logged. HTML pages, Linear GraphQL errors, transport failures and authentication, rate-limit and not-found failures keep their warnings ([#6046](https://github.com/gitkraken/vscode-gitlens/issues/6046)) (plus/integrations)
+
+## [0.15.5] - 2026-10-22
+
+### Added
+
+- Adds optional `refs` and `options.configConfinedToRefs` to `GitServiceHooks.repository.onChanged`: `refs` are the full ref names a write created, moved or deleted, and a ref kind with names among them is fully described by them, so a host can skip work for refs it doesn't follow; `configConfinedToRefs` says the write changed `.git/config` only in the `branch.<name>` sections of the local branches `refs` names. Siblings sharing the repository hear the names and the flag with the shared kinds. Branch create, delete, rename and upstream changes, `checkout -b`, a worktree's new branch, a commit (its branch, read from the worktree's `HEAD` before and after the run, and named only when both agree) and stash writes (`refs/stash`, by a pop only when it dropped the entry) name their refs; a host that ignores them treats every kind as unnamed, as before (git, git-cli)
+
+### Changed
+
+- Changes how the watch layer tells a write's own reports from outside changes once announcements name refs: a raw report is the write's echo only when every ref it names, or every branch whose config section it changed, is among those the write announced (or it reports `HEAD`, which a commit locks, under a write that announced `head`), and it arrives within the debounce delay of the announcement, so an outside change to another ref or config section, or a later change to the same ref, is kept and reaches its subscribers unannounced. A watch group now diffs the shared `.git/config` by section on each report (one read for every worktree of the repository) and delivers a change confined to `branch.<name>` sections as confined to those branches (`WatcherRepoChangeEvent.configBranches`, `mayHaveChangedConfig`), whoever wrote it; anything else, an unreadable or unparsable file, a read that doesn't settle within 5 seconds, or another config file is unconfined. Ref-filtered subscriptions and worktree summaries narrow a confined change like a named ref (git)
+
+### Fixed
+
+- Fixes worktree summaries keeping an outdated ahead-of-base target after checkout-specific Git configuration changes. Each checkout now compares its effective configuration, including branch-conditional includes, with the configuration used for its current base.
+- Fixes a fetch announcing `remotes` to every worktree of the repository, and resetting the branch and tag caches, whether or not anything moved, so each worktree summary re-read its base after every fetch: in a Kepler daemon with ~60 worktrees one task launch cost ~490 git processes. A fetch now compares the refs it can write (its refspecs' destinations, the fetched remotes' configured destinations, symref targets included, and tags) before and after it runs, announces nothing when none moved, and otherwise names exactly what moved; a snapshot it can't read falls back to the previous announcement (git-cli)
+- Fixes deleting, creating or renaming a branch making every worktree of the repository re-read its base, since the write's `.git/config` change and the watcher's later report of it reached every subscriber; one task removal cost ~460 git processes over ~60 worktrees (git, git-cli)
+
 ## [0.15.4] - 2026-10-22
 
 ### Added
@@ -830,7 +852,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.4...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.6...HEAD
+[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
 [0.15.4]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.3...gitkraken:releases/core/v0.15.4
 [0.15.3]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.2...gitkraken:releases/core/v0.15.3
 [0.15.2]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.1...gitkraken:releases/core/v0.15.2

package/dist/git/cache.d.ts

@@ -238,17 +238,17 @@ export declare class Cache implements Disposable {
    * Call this when a worktree is deleted or a repo is closed so stale registry entries
    * and derived cache entries don't persist.
    *
-   * Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. The
-   * shared commonPath entry in each shared cache is only evicted when unregistering the
-   * last remaining worktree for that commonPath (otherwise siblings still depend on it).
-   *
-   * Uses soft-invalidate where supported so any in-flight factory/mapper keeps its abort
+   * Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. Shared caches
+   * stay warm until the last worktree closes, except raw git results co-located with a closing main
+   * checkout: those must retire with its config fingerprint so reopening cannot attest an old command
+   * with new config. Detached promises keep their existing callers and abort wiring. Other entries
+   * use soft-invalidate where supported so any in-flight factory/mapper keeps its abort
    * wiring intact — a caller whose signal aborts after unregister can still propagate
    * cancellation into the underlying work rather than leaving it orphaned. Controller-backed
    * entries self-evict on settle; plain `.set()`-based entries hard-delete immediately.
    *
-   * Cache eviction is a no-op if `repoPath` is not registered, but the status clock is advanced
-   * unconditionally (a fresh registration must not let a post-reopen read join a pre-close one).
+   * The status clock advances even for an unregistered path so a fresh registration cannot join a
+   * status read that started before it.
    */
   unregisterRepoPath(repoPath: string): void;
   reset(): void;
@@ -423,11 +423,8 @@ export declare class Cache implements Disposable {
    */
   deleteBranchMetadata(repoPath: string): void;
   getBranchMergedStatus(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitBranchMergedStatus>, cancellation?: AbortSignal): Promise<GitBranchMergedStatus>;
-  /**
-   * The `getAheadOfBase` config snapshot, read once per commonPath for every worktree. Any config change hard-evicts
-   * it (see {@link clearCaches}), so a read issued after the change never joins one that started before it.
-   */
-  getAheadOfBaseConfigKey(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
+  /** 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>;
   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,7 +54,6 @@ 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()([
-	"aheadOfBaseConfigKey",
 	"baseBranchName",
 	"branchMergedStatus",
 	"branchMetadataMap",
@@ -419,7 +418,10 @@ var Cache = class Cache {
 				keysToClear.add("reachability");
 				keysToClear.add("resolvedRevisions");
 			}
-			if (types.includes("branch")) keysToClear.add("baseBranchName");
+			if (types.includes("branch")) {
+				keysToClear.add("aheadOfBaseConfigKey");
+				keysToClear.add("baseBranchName");
+			}
 			if (types.includes("branches")) {
 				keysToClear.add("branchMetadataMap");
 				keysToClear.add("branches");
@@ -488,8 +490,12 @@ var Cache = class Cache {
 			const cache = this._caches[key];
 			if (cache == null) continue;
 			if (repoPath == null) cache.clear();
+			else if (key === "aheadOfBaseConfigKey" && !worktreeOnly && (!types.length || types.includes("config"))) this.evictShared(key, repoPath, "evict");
 			else if (sharedCacheKeys.has(key)) {
-				if (!worktreeOnly) this.evictShared(key, repoPath, key === "aheadOfBaseConfigKey" ? "evict" : inFlight);
+				if (!worktreeOnly) {
+					const hardEvict = key === "gitResults" && (types.includes("config") || types.includes("branch"));
+					this.evictShared(key, repoPath, hardEvict ? "evict" : inFlight);
+				}
 			} else cache.delete(repoPath);
 		}
 	}
@@ -596,6 +602,12 @@ var Cache = class Cache {
 	registerRepoPath(repoPath, gitDir) {
 		const normalizedPath = getRepositoryOrWorktreePath(repoPath);
 		const commonPath = gitDir.commonUri != null ? getCommonRepositoryPath(gitDir.commonUri) : normalizedPath;
+		const previousCommonPath = this._commonPathRegistry.get(normalizedPath);
+		if (previousCommonPath != null && previousCommonPath !== commonPath) this.unregisterRepoPath(normalizedPath);
+		if (previousCommonPath !== commonPath) {
+			this._caches.aheadOfBaseConfigKey?.delete(normalizedPath);
+			this._caches.gitResults?.delete(normalizedPath);
+		}
 		this._commonPathRegistry.set(normalizedPath, commonPath);
 		let worktrees = this._worktreesByCommonPath.get(commonPath);
 		if (worktrees == null) {
@@ -611,17 +623,17 @@ var Cache = class Cache {
 	* Call this when a worktree is deleted or a repo is closed so stale registry entries
 	* and derived cache entries don't persist.
 	*
-	* Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. The
-	* shared commonPath entry in each shared cache is only evicted when unregistering the
-	* last remaining worktree for that commonPath (otherwise siblings still depend on it).
-	*
-	* Uses soft-invalidate where supported so any in-flight factory/mapper keeps its abort
+	* Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. Shared caches
+	* stay warm until the last worktree closes, except raw git results co-located with a closing main
+	* checkout: those must retire with its config fingerprint so reopening cannot attest an old command
+	* with new config. Detached promises keep their existing callers and abort wiring. Other entries
+	* use soft-invalidate where supported so any in-flight factory/mapper keeps its abort
 	* wiring intact — a caller whose signal aborts after unregister can still propagate
 	* cancellation into the underlying work rather than leaving it orphaned. Controller-backed
 	* entries self-evict on settle; plain `.set()`-based entries hard-delete immediately.
 	*
-	* Cache eviction is a no-op if `repoPath` is not registered, but the status clock is advanced
-	* unconditionally (a fresh registration must not let a post-reopen read join a pre-close one).
+	* The status clock advances even for an unregistered path so a fresh registration cannot join a
+	* status read that started before it.
 	*/
 	unregisterRepoPath(repoPath) {
 		this.incrementStatusGeneration(repoPath);
@@ -632,6 +644,11 @@ var Cache = class Cache {
 		for (const key of Object.keys(this._caches)) {
 			const cache = this._caches[key];
 			if (cache == null) continue;
+			if (key === "aheadOfBaseConfigKey" || key === "gitResults") {
+				cache.delete(repoPath);
+				if (key === "gitResults" && isLastWorktree && repoPath !== commonPath) 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)) {
@@ -687,7 +704,11 @@ var Cache = class Cache {
 			types.add("fileLog");
 		}
 		if (hasAny("index")) types.add("tracking");
-		if (hasAny("config")) types.add("config");
+		if (hasAny("config")) {
+			types.add("config");
+			types.add("branches");
+			types.add("worktrees");
+		}
 		if (hasAny("heads")) {
 			types.add("branches");
 			types.add("contributors");
@@ -1104,12 +1125,9 @@ var Cache = class Cache {
 			};
 		}, { cancellation });
 	}
-	/**
-	* The `getAheadOfBase` config snapshot, read once per commonPath for every worktree. Any config change hard-evicts
-	* it (see {@link clearCaches}), so a read issued after the change never joins one that started before it.
-	*/
+	/** Config can differ by checkout through config.worktree and conditional includes. */
 	getAheadOfBaseConfigKey(repoPath, factory, cancellation) {
-		return this.getSharedSimple(this.aheadOfBaseConfigKey, repoPath, factory, cancellation);
+		return this.aheadOfBaseConfigKey.getOrCreate(repoPath, (cacheable, signal) => Promise.resolve(factory(repoPath, cacheable, signal)), cancellation);
 	}
 	getBranchMetadataMap(repoPath, factory) {
 		return this.getSharedSimple(this.branchMetadataMap, repoPath, factory);