@gitkraken/core-gitlens 0.16.3 → 0.16.4

package/CHANGELOG.md

@@ -6,6 +6,29 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.16.4] - 2026-10-23
+
+### Added
+
+- Adds `branches.getMergeTarget(branch, options?)`: the ref any branch, checked out or not, is measured against, by `getAheadOfBase`'s rules, so every host names the same target. It answers `{ ref, forkPoint, tier }`, where `tier` adds `'pr'` and `'inferred'` to `AheadOfBaseTier`. Beyond `skipUserTarget` and `preferredTarget` it takes a host's sources: `getAssociatedPullRequest` (read only when no stored target is usable, tried after the detected target and recorded as it unless the pull request is stacked or the branch is a remote-tracking one), `inferBase` (VS Code's `vscode-merge-base`, and for a branch created from `HEAD` the branch HEAD was on when it was first checked out, read from that branch's worktree and never stored), `defaultBranch: 'remote'` (asks the remote only when local refs name no default), `getFallbackDefaultBranch` and `keepSelfAtTip`. Answers are cached against the ref tips, stored keys and config they were read from, so a warm call runs no git and a branch moving elsewhere re-measures nothing (git, git-cli, git-github)
+- Adds `getFallbackDefaultBranch` to `getBranchContributionsOverview`'s options (git, git-cli, git-github)
+
+### Changed
+
+- Changes `getBranchContributionsOverview` to measure against `getMergeTarget`, so its target follows `getAheadOfBase`'s rules: an out-of-date local target defers to its upstream, the default branch is read from local refs (`upstream`, then `origin`) before the remote, the default branch measures against its own upstream, and a branch is measured against the branch it was created from until that branch merges (git-cli, git-github)
+- Changes `getAheadOfBase` to keep a candidate whose check failed or timed out, rather than one git confirms is gone, so its count rejects instead of quietly measuring against the next candidate (git-cli)
+- Changes `getBaseBranchName` to no longer record its reflog guess as `gk-merge-base`, where every host read it as a base the branch was launched from (git-cli)
+
+### Removed
+
+- Removes `BranchTargetInfo` from `git/models/branch.js`; `branches.getMergeTarget` answers the merge target it described (git)
+
+### Fixed
+
+- Fixes `getReflogEntries`' `grep` matching nothing when the user's `grep.patternType` is `fixed`, which left `getBaseBranchName` with no reflog guess: the pattern is now always read as a basic regular expression (git-cli)
+- Fixes `getBaseBranchName` overwriting a recorded `gk-merge-base` with a reflog guess when checking the recorded branch failed rather than found it gone, and reading the checkout guess from the main worktree's HEAD reflog instead of the branch's own worktree (git-cli)
+- Fixes `getAheadOfBase` measuring a branch created from a full ref (`git switch -c topic refs/heads/develop`) against that ref as-is, never against its fresher upstream: the base is now its short name (`develop`), weighed against its tracking ref like any other (git-cli)
+
 ## [0.16.3] - 2026-10-23
 
 ### Fixed
@@ -897,7 +920,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.16.3...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.16.4...HEAD
+[0.16.4]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.16.3...gitkraken:releases/core/v0.16.4
 [0.16.3]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.16.2...gitkraken:releases/core/v0.16.3
 [0.16.2]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.16.1...gitkraken:releases/core/v0.16.2
 [0.16.1]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.16.0...gitkraken:releases/core/v0.16.1

package/dist/git/cache.d.ts

@@ -23,7 +23,7 @@ import { GitUser } from "./models/user.js";
 import { GitResult } from "./run.types.js";
 import { GitWorktree } from "./models/worktree.js";
 import { GitCommitReachability, LeftRightCommitCountResult } from "./providers/commits.js";
-import { BranchContributionsOverview, GitBranchMergedStatus } from "./providers/branches.js";
+import { BranchContributionsOverview, GitBranchMergedStatus, MergeTarget } from "./providers/branches.js";
 import { GitContributorsResult } from "./providers/contributors.js";
 import { ResolvedRevision } from "./providers/revision.js";
 //#region ../git/src/cache.d.ts
@@ -64,6 +64,45 @@ export declare function shouldEvictBlameCacheEntry(progressive: ProgressiveGitBl
  * naming the targets to skip via `skipInvalidation`.
  */
 export type GkConfigInvalidationTarget = 'branchOverviews' | 'baseBranchName';
+/**
+ * A `getMergeTarget` answer with what it was read from, so a later call can confirm it from cached reads rather than
+ * resolve it again (see {@link Cache.getMergeTarget})
+ */
+export interface CachedMergeTarget {
+  /** The answer before `keepSelfAtTip` is applied */
+  readonly result: MergeTarget | undefined;
+  /** Whether `result` is the branch itself at the branch's own commit */
+  readonly selfAtTip: boolean;
+  /** Every full ref name whose presence or tip the answer depends on, with the commit it named then (`undefined` when absent) */
+  readonly tips: ReadonlyArray<readonly [ref: string, tip: string | undefined]>;
+  /**
+   * The replace refs as read, as sorted `<name>\0<sha>` lines ('' for none): replacing a commit moves merge bases
+   * while every tip stands
+   */
+  readonly replaced: string;
+  /**
+   * The common git directory's `shallow` file as `<size>\0<mtime>`, or `null` when the repo wasn't shallow: deepening
+   * a shallow clone moves merge bases while every tip stands
+   */
+  readonly shallow: string | null;
+  /** The `getAheadOfBaseConfigKey` snapshot the answer was read under */
+  readonly configKey: string | undefined;
+  /** The branch's stored merge keys as read, raw; `undefined` for a remote-tracking branch, which has none */
+  readonly stored: readonly (string | undefined)[] | undefined;
+  /** Set only when resolution reached the pull request and stored nothing: the base candidate it named, or `null` for none */
+  readonly pullRequest?: string | null;
+  /** Set only when the default branch was read: the name local refs gave, or `null` for none */
+  readonly localDefault?: string | null;
+  /** Set only when the remote was asked for its default branch: that remote, and its answer or `null` for none */
+  readonly remoteDefault?: {
+    readonly remote: string;
+    readonly name: string | null;
+  };
+  /** Set only when the caller's fallback default branch was asked: its answer, or `null` for none */
+  readonly fallbackDefault?: string | null;
+  /** The answer read HEAD's reflog for the branch it was created from and found none, which a later checkout can write */
+  readonly evictOnCheckout: boolean;
+}
 /** A changed `branch.<branch>.<key>` gk config value for {@link Cache.patchBranchMetadata}; `undefined` is a removal */
 export interface BranchMetadataChange {
   readonly branch: string;
@@ -79,6 +118,12 @@ export declare class Cache implements Disposable {
   private _statusGenerations;
   /** Monotonic per-path "close clock" — see {@link getCloseGeneration}. */
   private _closeGenerations;
+  /** Per commonPath, the `mergeTargets` keys a checkout evicts (see {@link CachedMergeTarget.evictOnCheckout}) */
+  private _mergeTargetsEvictedOnCheckout;
+  /** Bumped on each checkout eviction, so a merge target resolved across one isn't kept for the next */
+  private _mergeTargetCheckoutGeneration;
+  /** Each merge target answer's entry as `mergeTargets` stored it, so dropping a stale answer can't drop its successor */
+  private _mergeTargetStored;
   /**
    * Per-commonPath snapshot of the subset of `.git/gk/config` that derived caches depend on — merge-relevant keys
    * ({@link branchOverviewGkConfigKeysRegex}) and branch metadata keys ({@link parseBranchMetadataGkConfigKey}) —
@@ -115,6 +160,7 @@ export declare class Cache implements Disposable {
   get blame(): RepoPromiseCacheMap<string, ProgressiveGitBlame | undefined>;
   get diff(): RepoPromiseCacheMap<string, ParsedGitDiffHunks | undefined>;
   get fileLog(): RepoPromiseCacheMap<string, GitLog | undefined>;
+  private get mergeTargets();
   private get baseBranchName();
   get branch(): PromiseMap<RepoPath, GitBranch | undefined>;
   get branchMergedStatus(): RepoPromiseCacheMap<string, GitBranchMergedStatus>;
@@ -319,10 +365,10 @@ export declare class Cache implements Disposable {
    * (`baseBranchName`/`branchOverviews`) for the written key's ref.
    *
    * @param options.skipInvalidation Downstream caches the caller wants preserved despite this
-   * write. Use when the value being written is exactly what was just resolved — e.g. the Tier 2
-   * `storeMergeTargetBranchName` self-write inside `getBranchContributionsOverview` (skip
-   * `'branchOverviews'`) or the Tier 3 `storeBaseBranchName` self-write inside `getBaseBranchName`
-   * (skip both `'baseBranchName'` and `'branchOverviews'`). The bulk `gkConfigMap` map always
+   * write. Use when the value being written is exactly what was just resolved — e.g. the pull request's
+   * `storeMergeTargetBranchName` self-write inside `getMergeTarget` (skip `'branchOverviews'`) or the
+   * `vscode-merge-base` migration's `storeBaseBranchName` self-write (skip both `'baseBranchName'` and
+   * `'branchOverviews'`). The bulk `gkConfigMap` map always
    * invalidates so subsequent reads see the new value.
    */
   deleteGkConfig(repoPath: string, key: string, options?: {
@@ -440,6 +486,19 @@ export declare class Cache implements Disposable {
   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>;
+  /** The cached default branch for one `remote` key, without reading it; `undefined` when none is cached */
+  peekDefaultBranchName(repoPath: string, remote: string): Promise<string | undefined> | undefined;
+  /**
+   * No TTL and not cleared by a ref or config change: the caller confirms a hit against what the answer was read from
+   * (see {@link CachedMergeTarget}). A checkout evicts only the entries marked `evictOnCheckout`
+   */
+  getMergeTarget(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<CachedMergeTarget>, cancellation?: AbortSignal): Promise<CachedMergeTarget>;
+  /**
+   * Drops `stale`, an answer {@link getMergeTarget} gave for `cacheKey`, unless it was already replaced: callers that
+   * found the same answer stale then share the one that replaced it rather than each resolving their own
+   */
+  deleteMergeTarget(repoPath: string, cacheKey: string, stale: CachedMergeTarget): void;
+  private evictMergeTargetsOnCheckout;
   /** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */
   deleteDefaultBranchName(repoPath: string, remote: string): void;
   getInitialCommitSha(repoPath: string, factory: (commonPath: string) => PromiseOrValue<string | undefined>): Promise<string | undefined>;

package/dist/git/cache.js

@@ -72,6 +72,7 @@ const sharedCacheKeys = new Set(exhaustiveArray()([
 	"initialCommitSha",
 	"lastFetched",
 	"logShas",
+	"mergeTargets",
 	"refs",
 	"refTips",
 	"remotes",
@@ -98,6 +99,7 @@ function createEmptyCaches() {
 		ignoreRevsFile: void 0,
 		leftRightCommitCount: void 0,
 		mergeBase: void 0,
+		mergeTargets: void 0,
 		patchIds: void 0,
 		configKeys: void 0,
 		configPatterns: void 0,
@@ -140,6 +142,12 @@ var Cache = class Cache {
 	_statusGenerations = /* @__PURE__ */ new Map();
 	/** Monotonic per-path "close clock" — see {@link getCloseGeneration}. */
 	_closeGenerations = /* @__PURE__ */ new Map();
+	/** Per commonPath, the `mergeTargets` keys a checkout evicts (see {@link CachedMergeTarget.evictOnCheckout}) */
+	_mergeTargetsEvictedOnCheckout = /* @__PURE__ */ new Map();
+	/** Bumped on each checkout eviction, so a merge target resolved across one isn't kept for the next */
+	_mergeTargetCheckoutGeneration = 0;
+	/** Each merge target answer's entry as `mergeTargets` stored it, so dropping a stale answer can't drop its successor */
+	_mergeTargetStored = /* @__PURE__ */ new WeakMap();
 	/**
 	* Per-commonPath snapshot of the subset of `.git/gk/config` that derived caches depend on — merge-relevant keys
 	* ({@link branchOverviewGkConfigKeysRegex}) and branch metadata keys ({@link parseBranchMetadataGkConfigKey}) —
@@ -213,6 +221,9 @@ var Cache = class Cache {
 			capacity: 50
 		});
 	}
+	get mergeTargets() {
+		return this._caches.mergeTargets ??= new RepoPromiseCacheMap();
+	}
 	get baseBranchName() {
 		return this._caches.baseBranchName ??= new RepoPromiseCacheMap();
 	}
@@ -407,6 +418,7 @@ var Cache = class Cache {
 			for (const key of Object.keys(this._caches)) keysToClear.add(key);
 			invalidateMemoized("providers");
 			this.incrementStatusGenerations(repoPath);
+			if (!worktreeOnly) this.evictMergeTargetsOnCheckout(repoPath);
 		} else {
 			if (types.includes("blame")) keysToClear.add("blame");
 			if (types.includes("diff")) keysToClear.add("diff");
@@ -428,6 +440,7 @@ var Cache = class Cache {
 				keysToClear.add("aheadOfBaseConfigListing");
 				keysToClear.add("baseBranchName");
 			}
+			if (!worktreeOnly && (types.includes("branch") || types.includes("worktrees"))) this.evictMergeTargetsOnCheckout(repoPath);
 			if (types.includes("branches")) {
 				keysToClear.add("branchMetadataMap");
 				keysToClear.add("branches");
@@ -668,7 +681,10 @@ var Cache = class Cache {
 				if (isLastWorktree) evict(commonPath);
 			} else evict(repoPath);
 		}
-		if (isLastWorktree) this._gkConfigSnapshots.delete(commonPath);
+		if (isLastWorktree) {
+			this._gkConfigSnapshots.delete(commonPath);
+			this._mergeTargetsEvictedOnCheckout.delete(commonPath);
+		}
 		this._commonPathRegistry.delete(repoPath);
 		if (worktrees != null) {
 			worktrees.delete(repoPath);
@@ -681,6 +697,7 @@ var Cache = class Cache {
 		this._worktreesByCommonPath.clear();
 		this._statusGenerations.clear();
 		this._gkConfigSnapshots.clear();
+		this._mergeTargetsEvictedOnCheckout.clear();
 		this._gkConfigReconciler = void 0;
 		this._caches = createEmptyCaches();
 	}
@@ -885,10 +902,10 @@ var Cache = class Cache {
 	* (`baseBranchName`/`branchOverviews`) for the written key's ref.
 	*
 	* @param options.skipInvalidation Downstream caches the caller wants preserved despite this
-	* write. Use when the value being written is exactly what was just resolved — e.g. the Tier 2
-	* `storeMergeTargetBranchName` self-write inside `getBranchContributionsOverview` (skip
-	* `'branchOverviews'`) or the Tier 3 `storeBaseBranchName` self-write inside `getBaseBranchName`
-	* (skip both `'baseBranchName'` and `'branchOverviews'`). The bulk `gkConfigMap` map always
+	* write. Use when the value being written is exactly what was just resolved — e.g. the pull request's
+	* `storeMergeTargetBranchName` self-write inside `getMergeTarget` (skip `'branchOverviews'`) or the
+	* `vscode-merge-base` migration's `storeBaseBranchName` self-write (skip both `'baseBranchName'` and
+	* `'branchOverviews'`). The bulk `gkConfigMap` map always
 	* invalidates so subsequent reads see the new value.
 	*/
 	deleteGkConfig(repoPath, key, options) {
@@ -1172,6 +1189,59 @@ var Cache = class Cache {
 	getDefaultBranchName(repoPath, remote, factory, cancellation) {
 		return this.getSharedSimpleWithKey(this.defaultBranchName, repoPath, remote, factory, { cancellation });
 	}
+	/** The cached default branch for one `remote` key, without reading it; `undefined` when none is cached */
+	peekDefaultBranchName(repoPath, remote) {
+		return this._caches.defaultBranchName?.get(this.getCommonPath(repoPath), remote);
+	}
+	/**
+	* No TTL and not cleared by a ref or config change: the caller confirms a hit against what the answer was read from
+	* (see {@link CachedMergeTarget}). A checkout evicts only the entries marked `evictOnCheckout`
+	*/
+	getMergeTarget(repoPath, cacheKey, factory, cancellation) {
+		const pending = this.getSharedSimpleWithKey(this.mergeTargets, repoPath, cacheKey, async (commonPath, cacheable, signal) => {
+			const generation = this._mergeTargetCheckoutGeneration;
+			const entry = await factory(commonPath, cacheable, signal);
+			if (entry.evictOnCheckout) {
+				if (this._mergeTargetCheckoutGeneration !== generation) {
+					cacheable.invalidate();
+					return entry;
+				}
+				let keys = this._mergeTargetsEvictedOnCheckout.get(commonPath);
+				if (keys == null) {
+					keys = /* @__PURE__ */ new Set();
+					this._mergeTargetsEvictedOnCheckout.set(commonPath, keys);
+				}
+				keys.add(cacheKey);
+			}
+			return entry;
+		}, { cancellation });
+		const stored = this.mergeTargets.get(this.getCommonPath(repoPath), cacheKey);
+		if (stored == null) return pending;
+		return pending.then((entry) => {
+			this._mergeTargetStored.set(entry, stored);
+			return entry;
+		});
+	}
+	/**
+	* Drops `stale`, an answer {@link getMergeTarget} gave for `cacheKey`, unless it was already replaced: callers that
+	* found the same answer stale then share the one that replaced it rather than each resolving their own
+	*/
+	deleteMergeTarget(repoPath, cacheKey, stale) {
+		const commonPath = this.getCommonPath(repoPath);
+		const stored = this._mergeTargetStored.get(stale);
+		if (stored != null && this._caches.mergeTargets?.get(commonPath, cacheKey) !== stored) return;
+		this._caches.mergeTargets?.delete(commonPath, cacheKey);
+	}
+	evictMergeTargetsOnCheckout(repoPath) {
+		this._mergeTargetCheckoutGeneration++;
+		const commonPaths = repoPath != null ? [this.getCommonPath(repoPath)] : [...this._mergeTargetsEvictedOnCheckout.keys()];
+		for (const commonPath of commonPaths) {
+			const keys = this._mergeTargetsEvictedOnCheckout.get(commonPath);
+			if (keys == null) continue;
+			this._mergeTargetsEvictedOnCheckout.delete(commonPath);
+			for (const key of keys) this._caches.mergeTargets?.delete(commonPath, key);
+		}
+	}
 	/** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */
 	deleteDefaultBranchName(repoPath, remote) {
 		this._caches.defaultBranchName?.delete(this.getCommonPath(repoPath), remote);