@gitkraken/core-gitlens 0.15.2 → 0.15.4

package/CHANGELOG.md

@@ -6,6 +6,38 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.15.4] - 2026-10-22
+
+### Added
+
+- Adds an optional `getPushTarget` to `GitBranchesSubProvider`: where a branch (the checked-out one by default) pushes to and its upstream, each as a full ref name with its commit, read from the cached ref list so a warm call runs no git. The destination is git's own `%(push)`, which follows `push.default`, `remote.pushDefault`, `branch.<name>.pushRemote`, push refspecs and mirror remotes, and is named even before its ref exists (with no commit). `known: false` means the ref list couldn't be read; a detached HEAD has no destination. The shared `for-each-ref` now reads `%(push)` for every ref, so `RefRecord` gains a `push` field (git, git-cli)
+- Adds an optional `getAheadOfBaseConfigKey` to `GitBranchesSubProvider`, an opaque snapshot of the Git config inputs to `getAheadOfBase` (every branch's tracking, the remotes and `init.defaultBranch`, not the stored gk merge targets or base): two equal snapshots mean that config can't have changed the base. `undefined` means it couldn't be read; the CLI provider reads it once for every worktree of a repository, and a provider without it leaves a worktree summary re-reading its base on every config change (git, git-cli)
+
+### Changed
+
+- Changes the `ref` that `WatchGroupHooks.onRepoChanged` and `RepositoryWatchSession.pushRepoChanges` take to `string | false`, where `false` reports a `.git/config` (or `config.worktree`) change that moved no ref. Its change kinds (`config`, `remotes`) still clear caches as before, but the event's `mayHaveChangedRef` no longer answers `true` for every remote-tracking ref because of it. A poll now also reads the `refs/remotes` directory, which `git remote remove` and `git remote rename` change whether the remote's refs are loose or packed, so a polled repository still reports a removed or renamed remote's refs as possibly moved, while a config write alone, like `git branch --set-upstream-to`, names no ref (git)
+- Changes `getGkConfig`, `getGkConfigRegex`, `getStoredDetectedMergeTargetBranchName` and `getStoredUserMergeTargetBranchName` to log at trace level rather than debug, and a gk config lookup to no longer enter (and log) the one-time `.git/gk/config` migration once it ran for the repository: they are served from the cached map, and a cold read's `git config` still logs its own line (git-cli)
+
+### Fixed
+
+- Fixes Azure DevOps filtered work item searches failing across large sets of project workflows or when workflow metadata changes during pagination. Search and count queries stay within the server's query length limit, preserve its ordering, and can be canceled without interrupting other reads ([#6041](https://github.com/gitkraken/vscode-gitlens/issues/6041)).
+- Fixes every checkout sharing a `.git/gk/config` re-reading the whole file (a `git config --get-regex` each) when the watcher reports a change to it, core's own writes included, so a branch-activity stamp reported by three checkouts read it four times. A report of a file unchanged since the cached map was read (same inode, size and change times, with the read's stat taken safely after the file's last change: 2 seconds for a filesystem keeping whole-second times, 50 ms otherwise) now keeps the map, and still diffs it against the reconcile's baseline, so a read landing between another process's write and its report doesn't lose the change; a changed file is re-read as before (git, git-cli)
+- Fixes `getAheadOfBase` spawning a failing `git rev-parse <ref>@{u}` on every read whose candidate base is a remote-tracking ref or a tag (`origin/main`, the usual default branch), since git can't cache a failed lookup: a candidate the cached ref list shows can't have an upstream is no longer asked for one, and the result is unchanged. The base a branch's reflog says it was created from is checked the same way (git-cli)
+- Fixes a `.git/config` write making every subscribed worktree summary of the repository re-read its base at once, a full `getAheadOfBase` each: in a Kepler daemon over ~100 worktrees of one repository, one write cost ~65 reads in a burst. A summary now keeps its base when the config inputs to it (every branch's tracking, the remotes and `init.defaultBranch`), its stored merge targets, HEAD and upstream are unchanged, and at most four summaries of a repository, and eight across repositories, read at once, so a burst in one repository, or reads hung in it, never holds up another repository's summaries, and a start over many repositories never runs four reads for each. The config read itself (`git config --null --get-regexp`) is shared by every worktree of the repository rather than spawned by each, and any config change hard-evicts it, core's own writes included, so a read after the change never joins one that started before it (git, git-cli)
+- Fixes Azure DevOps Services account-wide pull request reads (`listPullRequestsPage`, the sweeps and the Launchpad search) returning no authored or review-requested pull requests, and failing the group read with "Azure DevOps returned no group membership for the current user", for accounts whose profile id differs from their identity in an organization: the creator and reviewer filters, the group read and each row's `viewer` and `authoredByMe` now use the user's identity in that organization, read from its `ConnectionData` once per credential and organization (in parallel, dropped on a re-sync), as Azure DevOps Server already did per collection; `getPullRequestsBatch` and `getPullRequestsForBranches` match authorship the same way. An organization whose identity can't be read is reported as a failure scoped to it while the others' pull requests are kept, as Azure DevOps Server already did per collection; an organization or collection refusing the credential (a 401 or 403) is now scoped the same way, where it failed the whole read, and a credential refused everywhere still fails it. A row with reviewers or assignees but no author now gets a `viewer`, and its `authoredByMe` is `undefined` rather than `false`, for every provider ([#6032](https://github.com/gitkraken/vscode-gitlens/issues/6032)) (plus/integrations)
+- Fixes Azure DevOps Server repository scopes that a caller parsed from a remote. Before, they were settled once to order `listIssuesPage` and then again for the read. Now the read gets the scopes that were counted, and a discovery that expires in between can't change them. Other fixes in the same reads:
+  - A scope that settles to a repository the connection doesn't serve is read as given and flagged as unsettled. A batch or branch miss for it is now rejected, and a list read reports it in a warning, instead of reporting a proven absence.
+  - When the connection addresses a collection, a scope naming that collection is read as given while the collection list can't be read. Before, it was flagged as unsettled, and its batch and branch misses were rejected. The address is presumed to name a collection when its collection list answers 404 and the collection's own connection data can't be read, for as long as that failed discovery is kept.
+  - A connection path segment with an encoded `/` no longer splits into two virtual directory segments, which left a scope below it unsettled.
+
+  `resolveRepositoryScopes` now returns `{ repos, unsettled }`. A failure to settle is reported as `{ error }` instead of returning the scopes as given ([#6040](https://github.com/gitkraken/vscode-gitlens/issues/6040)) (plus/integrations)
+
+## [0.15.3] - 2026-10-21
+
+### Fixed
+
+- Fixes Azure DevOps work items reporting an open state when their workflow category is unavailable and no closed date is known, including cheap etag reads. Filtered work item searches and counts now select by workflow category, so Removed work items without closed dates appear under Closed ([#6041](https://github.com/gitkraken/vscode-gitlens/issues/6041)).
+
 ## [0.15.2] - 2026-10-20
 
 ### Changed
@@ -798,7 +830,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.2...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.4...HEAD
+[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
 [0.15.1]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.15.0...gitkraken:releases/core/v0.15.1
 [0.15.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.14.0...gitkraken:releases/core/v0.15.0

package/dist/git/cache.d.ts

@@ -109,6 +109,7 @@ export declare class Cache implements Disposable {
   dispose(): void;
   /** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
   getResourceUsage(): ResourceUsage;
+  get aheadOfBaseConfigKey(): PromiseMap<RepoPath, string | undefined>;
   get bestRemotes(): PromiseMap<RepoPath, GitRemote<RemoteProvider>[]>;
   get blame(): RepoPromiseCacheMap<string, ProgressiveGitBlame | undefined>;
   get diff(): RepoPromiseCacheMap<string, ParsedGitDiffHunks | undefined>;
@@ -267,12 +268,12 @@ export declare class Cache implements Disposable {
     worktreeOnly?: boolean;
   }): CachedGitTypes[];
   /**
-   * Handles a watcher-observed `'gkConfig'` change. Always evicts the cached bulk map (forcing the
-   * next read to hit disk). If a reconciler is registered (see {@link setGkConfigReconciler}),
-   * defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it re-reads the
-   * map and diffs it against the snapshot captured here (i.e. as it stood right before this change),
-   * cascading only the refs whose merge-relevant keys actually changed. Falls back to the coarse
-   * clear when no reconciler is registered (e.g. the GitHub provider) so nothing can go stale.
+   * Handles a watcher-observed `'gkConfig'` change. If a reconciler is registered (see {@link setGkConfigReconciler}),
+   * defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it evicts the cached bulk map
+   * unless the file is unchanged since the map was read, reads it, and diffs it against the snapshot captured here
+   * (i.e. as it stood right before this change), cascading only the refs whose merge-relevant keys actually
+   * changed. Falls back to evicting the map and the coarse clear when no reconciler is registered (e.g. the GitHub
+   * provider) so nothing can go stale.
    */
   private handleGkConfigChanged;
   /**
@@ -298,9 +299,9 @@ export declare class Cache implements Disposable {
   /**
    * The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
    * per-namespace gk lookups are served from it in-memory (see `getGkConfigMap` in the CLI config
-   * sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by
-   * `handleGkConfigChanged` (reconciled precisely when a reconciler is registered, or the coarse
-   * clear otherwise). The first fresh read seeds the snapshot used by
+   * sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by the
+   * reconciler when the file changed since the map was read (see {@link setGkConfigReconciler}), or by
+   * `handleGkConfigChanged`'s coarse clear when none is registered. The first fresh read seeds the snapshot used by
    * `reconcileGkConfigMap`; later refreshes of that snapshot are owned by the reconcile itself.
    */
   getGkConfigMap(repoPath: string, factory: (cacheable: CacheController) => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>>;
@@ -343,11 +344,18 @@ export declare class Cache implements Disposable {
    * `'gkConfig'` change. Only one reconciler is kept — later registrations replace earlier ones,
    * which is harmless since every CLI config sub-provider sharing this `Cache` reconciles the same
    * underlying `.git/gk/config` file identically.
+   *
+   * The reconciler owns the cached bulk map: it is called synchronously as the change is reported, and must
+   * hard-delete the map ({@link deleteGkConfigMap}) before it returns unless it knows the map still reflects the
+   * file — a read after the change must see it, and the reconcile's own read must not ride a bulk read that
+   * started before it. Only the reconciler can inspect the file, and keeping the map spares a re-read for every
+   * report of an unchanged file (one per worktree sharing it, and one for each of core's own writes).
    */
   setGkConfigReconciler(reconciler: (repoPath: string, priorSnapshot: ReadonlyMap<string, string> | undefined) => PromiseOrValue<GkReconcileOutcome>): void;
   /**
-   * Diffs a freshly-read gk config map's tracked subset against `priorSnapshot` (captured by
-   * `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state), cascading
+   * Diffs the tracked subset of a gk config map (read after the change, or kept as still reflecting the file)
+   * against `priorSnapshot` (captured by `handleGkConfigChanged` before the reconcile started, so it reflects the
+   * pre-change state), cascading
    * `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed, then firing
    * {@link onDidChangeMergeTargets} naming those refs. Changed branch metadata keys (another process's
    * activity stamps or disposition) are patched into the cached branches in one call, and never fire the event.
@@ -415,6 +423,11 @@ 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>;
   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()([
+	"aheadOfBaseConfigKey",
 	"baseBranchName",
 	"branchMergedStatus",
 	"branchMetadataMap",
@@ -81,6 +82,7 @@ const sharedCacheKeys = new Set(exhaustiveArray()([
 ]));
 function createEmptyCaches() {
 	return {
+		aheadOfBaseConfigKey: void 0,
 		baseBranchName: void 0,
 		bestRemotes: void 0,
 		blame: void 0,
@@ -183,6 +185,9 @@ var Cache = class Cache {
 		usage["cache.gkConfigSnapshots.entries.count"] = this._gkConfigSnapshots.size;
 		return usage;
 	}
+	get aheadOfBaseConfigKey() {
+		return this._caches.aheadOfBaseConfigKey ??= new PromiseMap();
+	}
 	get bestRemotes() {
 		return this._caches.bestRemotes ??= new PromiseMap();
 	}
@@ -426,6 +431,7 @@ var Cache = class Cache {
 				keysToClear.add("refTips");
 			}
 			if (types.includes("config")) {
+				keysToClear.add("aheadOfBaseConfigKey");
 				keysToClear.add("baseBranchName");
 				keysToClear.add("configKeys");
 				keysToClear.add("configPatterns");
@@ -483,7 +489,7 @@ var Cache = class Cache {
 			if (cache == null) continue;
 			if (repoPath == null) cache.clear();
 			else if (sharedCacheKeys.has(key)) {
-				if (!worktreeOnly) this.evictShared(key, repoPath, inFlight);
+				if (!worktreeOnly) this.evictShared(key, repoPath, key === "aheadOfBaseConfigKey" ? "evict" : inFlight);
 			} else cache.delete(repoPath);
 		}
 	}
@@ -708,22 +714,30 @@ var Cache = class Cache {
 		return [...types];
 	}
 	/**
-	* Handles a watcher-observed `'gkConfig'` change. Always evicts the cached bulk map (forcing the
-	* next read to hit disk). If a reconciler is registered (see {@link setGkConfigReconciler}),
-	* defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it re-reads the
-	* map and diffs it against the snapshot captured here (i.e. as it stood right before this change),
-	* cascading only the refs whose merge-relevant keys actually changed. Falls back to the coarse
-	* clear when no reconciler is registered (e.g. the GitHub provider) so nothing can go stale.
+	* Handles a watcher-observed `'gkConfig'` change. If a reconciler is registered (see {@link setGkConfigReconciler}),
+	* defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it evicts the cached bulk map
+	* unless the file is unchanged since the map was read, reads it, and diffs it against the snapshot captured here
+	* (i.e. as it stood right before this change), cascading only the refs whose merge-relevant keys actually
+	* changed. Falls back to evicting the map and the coarse clear when no reconciler is registered (e.g. the GitHub
+	* provider) so nothing can go stale.
 	*/
 	handleGkConfigChanged(repoPath) {
 		const commonPath = this.getCommonPath(repoPath);
-		this._caches.gkConfigMap?.delete(commonPath);
 		if (this._gkConfigReconciler == null) {
+			this._caches.gkConfigMap?.delete(commonPath);
 			this.clearGkConfigCoarsely(repoPath);
 			return;
 		}
 		const priorSnapshot = this._gkConfigSnapshots.get(commonPath);
-		Promise.resolve(this._gkConfigReconciler(repoPath, priorSnapshot)).then((outcome) => {
+		let outcome;
+		try {
+			outcome = this._gkConfigReconciler(repoPath, priorSnapshot);
+		} catch {
+			this._caches.gkConfigMap?.delete(commonPath);
+			this.clearGkConfigCoarsely(repoPath);
+			return;
+		}
+		Promise.resolve(outcome).then((outcome) => {
 			if (outcome === "failed") this.clearGkConfigCoarsely(repoPath);
 		}, () => this.clearGkConfigCoarsely(repoPath));
 	}
@@ -798,9 +812,9 @@ var Cache = class Cache {
 	/**
 	* The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
 	* per-namespace gk lookups are served from it in-memory (see `getGkConfigMap` in the CLI config
-	* sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by
-	* `handleGkConfigChanged` (reconciled precisely when a reconciler is registered, or the coarse
-	* clear otherwise). The first fresh read seeds the snapshot used by
+	* sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by the
+	* reconciler when the file changed since the map was read (see {@link setGkConfigReconciler}), or by
+	* `handleGkConfigChanged`'s coarse clear when none is registered. The first fresh read seeds the snapshot used by
 	* `reconcileGkConfigMap`; later refreshes of that snapshot are owned by the reconcile itself.
 	*/
 	getGkConfigMap(repoPath, factory) {
@@ -877,13 +891,20 @@ var Cache = class Cache {
 	* `'gkConfig'` change. Only one reconciler is kept — later registrations replace earlier ones,
 	* which is harmless since every CLI config sub-provider sharing this `Cache` reconciles the same
 	* underlying `.git/gk/config` file identically.
+	*
+	* The reconciler owns the cached bulk map: it is called synchronously as the change is reported, and must
+	* hard-delete the map ({@link deleteGkConfigMap}) before it returns unless it knows the map still reflects the
+	* file — a read after the change must see it, and the reconcile's own read must not ride a bulk read that
+	* started before it. Only the reconciler can inspect the file, and keeping the map spares a re-read for every
+	* report of an unchanged file (one per worktree sharing it, and one for each of core's own writes).
 	*/
 	setGkConfigReconciler(reconciler) {
 		this._gkConfigReconciler = reconciler;
 	}
 	/**
-	* Diffs a freshly-read gk config map's tracked subset against `priorSnapshot` (captured by
-	* `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state), cascading
+	* Diffs the tracked subset of a gk config map (read after the change, or kept as still reflecting the file)
+	* against `priorSnapshot` (captured by `handleGkConfigChanged` before the reconcile started, so it reflects the
+	* pre-change state), cascading
 	* `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed, then firing
 	* {@link onDidChangeMergeTargets} naming those refs. Changed branch metadata keys (another process's
 	* activity stamps or disposition) are patched into the cached branches in one call, and never fire the event.
@@ -1083,6 +1104,13 @@ 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.
+	*/
+	getAheadOfBaseConfigKey(repoPath, factory, cancellation) {
+		return this.getSharedSimple(this.aheadOfBaseConfigKey, repoPath, factory, cancellation);
+	}
 	getBranchMetadataMap(repoPath, factory) {
 		return this.getSharedSimple(this.branchMetadataMap, repoPath, factory);
 	}
@@ -1176,10 +1204,10 @@ var Cache = class Cache {
 		}
 		return sharedPromise;
 	}
-	async getSharedSimple(cache, repoPath, factory) {
+	async getSharedSimple(cache, repoPath, factory, cancellation) {
 		const commonPath = this.getCommonPath(repoPath);
 		if (cache instanceof PromiseCache) return cache.getOrCreate(commonPath, (cacheable) => Promise.resolve(factory(commonPath, cacheable)));
-		return cache.getOrCreate(commonPath, (cacheable) => Promise.resolve(factory(commonPath, cacheable)));
+		return cache.getOrCreate(commonPath, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), cancellation);
 	}
 	async getSharedSimpleWithKey(cache, repoPath, cacheKey, factory, options) {
 		const commonPath = this.getCommonPath(repoPath);