@gitkraken/core-gitlens 0.10.7 → 0.11.1

package/CHANGELOG.md

@@ -6,6 +6,42 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.11.1] - 2026-10-16
+
+### Added
+
+- Adds tip commits to `WorktreeSummary`: `sha` is HEAD's commit (`undefined` before the first commit) and `base.sha` is the base ref's tip, so a host can key on commits rather than counts. A commit and a fast-forward of the base that leave every count the same now change the summary and fire. `getAheadOfBase` answers the tip as `base.sha`, resolved from the cached ref list in git's own order (a tag before a same-named branch), and its `dependsOn` now names that tag too, so the tag moving recomputes the base. Both come from reads the summary already does, except that a recompute of only the base re-reads the shared ref list when the ref move that triggered it cleared that list (git, git-cli)
+- Adds `baseDependsOn` to `WorktreeSummary`: the full ref names whose movement can change the base answer, as `getAheadOfBase` reports them, taken from the summary's own base read and given with or without a base. A host can narrow a watch subscription's `relevantRefs` to it without reading the base again, and a change to the list alone fires (git)
+- Adds `targetKeys` to `ProviderWarning`: a batch read's warning (`getPullRequestsBatch`, `getIssuesBatch`, `getPullRequestsForBranches`) names the keys of the targets it concerns — the target that was refused or failed, or every target of an integration call that failed as a whole — so a caller that merges several callers' targets into one call can hand each failure only to its own targets. A warning without it refused the whole call before any target was read. Equal warnings merge their keys rather than one being dropped (plus/integrations)
+
+### Fixed
+
+- Fixes `getAheadOfBase` answering a stale count against a tag-named base after the tag moved: a tag change now clears the cached commit counts and merge bases, which are keyed by ref name, as a branch move already did (git)
+
+## [0.11.0] - 2026-10-15
+
+### Added
+
+- Adds `maxWaitMs` to `RepositoryWatchSession.subscribe` and `subscribeToWorkingTree`, and `defaultRepoMaxWaitMs` / `defaultWorkingTreeMaxWaitMs` to `RepositoryWatchService`'s options: a flush happens no later than that long after the first pending change, however long activity continues. Across subscribers the shortest delay and the shortest max-wait win; `Infinity` opts a subscriber out of the cap (git)
+- Adds which refs moved to `WatcherRepoChangeEvent`: `refs` holds the full ref names (or ref directories, or `HEAD`/`ORIG_HEAD`) whose files changed, and `mayHaveChangedRef(ref)` answers conservatively, treating a change with no name (a `packed-refs` rewrite, a `config` change, an injected change) as moving every ref of its kind. `RepositoryWatchSession.subscribe` takes `relevantRefs`, a list read at delivery, which narrows that subscription's events to changes that may move a listed ref, so a linked worktree's subscriber can skip sibling branches' commits; other subscribers and cache invalidation still see every change (git)
+- Adds `branches.getAheadOfBase(branch)`: how far HEAD has moved past the base its branch was cut from, and which ref it was measured against. Bases are tried in trust order (the user's merge target, the detected one, the recorded `gk-merge-base`, then the local default branch), only recorded values count (never a reflog guess), and a target that no longer resolves falls through. Each is measured as itself or its tracking ref, whichever forked nearer HEAD, so a stale local `main` doesn't count commits `origin/main` already has. A base that is the branch itself, by name or as its copy on one of the repo's remotes, at HEAD's own commit answers no base rather than 0 ahead. It answers `{ base, dependsOn }`: `base` is the ref and count, `undefined` when there is no base (also on a detached HEAD or one with no commit yet), and `dependsOn` lists the refs whose movement can change the answer, given even without a base so a watcher learns when one appears. A count that can't be read rejects with git's error rather than answering no base (git, git-cli)
+- Adds an exclude set to the file-watcher seam, so a native watcher can prune ignored directories before making any OS watch: `FileWatchingProvider.createWatcher` takes `options.excludes` (directories relative to the base path, each pruned with its subtree; globs or literal paths), and a provider that prunes natively sets `supportsExcludes`. Core always passes `**/node_modules` and `**/.git` for the working tree and the `.git` subtrees nothing reads (`objects`, `logs`, `hooks`, …) for `.git` watchers; for a `supportsExcludes` provider it adds the directories an ignore rule matches, read from git (new `GitProvider.getIgnoredDirectories`), and re-creates the working-tree watcher, new before old, when ignore rules change or an ignored directory appears after it started (a first build's `dist/`) (git, git-cli)
+- Adds an `overflow` reason to `FileWatchEvent`, so a watcher that dropped events can make core resync: on the working tree it becomes an incomplete change (consumers refresh everything) and reloads the ignore rules, since a lost `.gitignore` edit would leave them stale; on a `.git` watcher every kind a watcher can report, which clears every cache type and refreshes every subscriber without unregistering the repository; and on `RepositoryInitWatcher` an `onDidCreate` for the overflowed path so the host rescans it for repositories. A reported directory now stands for everything beneath it, and `RepositoryWorkingTreeChangeEvent.changed(uri)` matches a file under a changed directory, since a native watcher can miss the files of a just-created directory (git)
+- Adds `WorktreeSummaryService` (`GitService.summaries`, present when a `watchingProvider` is): a cached summary of each subscribed worktree (branch, detached, upstream, ahead/behind, dirty, and ahead-of-base from `getAheadOfBase`), kept current by the watch layer. An event re-reads only the fields it can affect (an edit runs only the dirty probe; an unrelated branch moving reads nothing), one read runs per worktree at a time, `onDidChange` / `onDidChangeSummary` fire only when a value changes, and a failed read keeps the last values marked `stale`; when only the base can't be read, the other fields still update. It watches only while subscribed (git)
+- Adds `onDidChangeMergeTargets` (`GitService`, `GitProvider`, `Cache`): fires when an external `.git/gk/config` write changed a branch's merge-relevant keys (`gk-merge-base`, `gk-merge-target`, `gk-merge-target-user`, `gk-target-base`), naming those branches, once per repository (`repoPath` is its common path) and after the derived caches were cleared. It never fires for a rewrite that only touches activity timestamps, nor for core's own writes, including a branch delete's or rename's section rewrite; `refs` is `undefined` (any branch may have changed) for the coarse fallback (no reconciler, or a failed reconcile) or when there was no earlier snapshot to diff against (git, git-cli)
+
+### Changed
+
+- Changes the watch debounce to flush during continuous activity: repository changes flush at least every 2 s and working-tree changes at least every 10 s by default, where a steady stream of events (a long rebase, a build writing into the working tree) used to defer every flush until it stopped. Recording an event no longer re-arms a timer or allocates an event object (git)
+
+- Changes the `worktrees` repository change to mean only that the worktree list, or what `git worktree list` reports per worktree (its HEAD, lock or location), changed. A linked worktree's own index, paused-operation and HEAD writes reach only that worktree's session, through its own gitdir watcher, instead of waking every worktree sharing the repository as `worktrees`; a sibling's HEAD change still reaches the others as `worktrees`. A main checkout no longer receives each shared `.git` change twice once a linked worktree is watched (git)
+
+### Fixed
+
+- Fixes the watch layer's gitignore filter answering differently from git, which let ignored output reach subscribers as working-tree changes or, worse, dropped real changes: it now honours nested `.gitignore` files (deeper ones overriding, nothing re-included beneath an ignored directory), reads `info/exclude` from the common git dir for a linked worktree, applies `core.excludesFile` < `info/exclude` < `.gitignore` in that order rather than in whichever order the reads finished, resolves `core.excludesFile` as git does (a `~/` path expanded, and `$XDG_CONFIG_HOME/git/ignore` or `~/.config/git/ignore` when unset), and matches case the way git does (`core.ignorecase`, else the platform default). An edited nested `.gitignore` reloads it, and a burst of edits costs one trailing reload rather than one per file. Where its matcher can't tell, it answers "not ignored", which costs a refresh rather than a missed change (git, git-cli)
+- Fixes a standalone `createCliGitService` with a `watchingProvider` never re-reading the last-fetched time after a fetch: FETCH_HEAD reached only the per-watch `onFetchHeadChanged` hook. `RepositoryWatchService` now has a global `onDidChangeFetchHead` event, and the standalone service bridges it to the cache's `lastFetched` (git, git-cli)
+- Fixes working-tree and repository change events advancing the wrong status clock when a host passed a path spelled differently from the cache's key (a Windows drive-letter case, backslashes or a trailing separator): `RepositoryWatchService.watch` and `getSession` key sessions by `getRepositoryKey`, so every session, event and hook carries the same key status reads fence on, and two spellings of one repository share a session (git)
+
 ## [0.10.7] - 2026-10-15
 
 ### Changed
@@ -613,7 +649,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.10.7...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.11.1...HEAD
+[0.11.1]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.11.0...gitkraken:releases/core/v0.11.1
+[0.11.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.10.7...gitkraken:releases/core/v0.11.0
 [0.10.7]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.10.6...gitkraken:releases/core/v0.10.7
 [0.10.6]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.10.5...gitkraken:releases/core/v0.10.6
 [0.10.5]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.10.4...gitkraken:releases/core/v0.10.5

package/dist/git/cache.d.ts

@@ -1,5 +1,6 @@
-import { PagedResult } from "../utils/paging.js";
 import { PromiseOrValue } from "../utils/promise.js";
+import { Event } from "../utils/event.js";
+import { PagedResult } from "../utils/paging.js";
 import { CacheController, PromiseCache, PromiseMap, RepoPromiseCacheMap } from "../utils/promiseCache.js";
 import { ResourceUsage } from "../utils/resourceUsage.js";
 import { Uri } from "../utils/uri.js";
@@ -39,6 +40,20 @@ export type CachedGitTypes = UriScopedCachedGitTypes | 'branch' | 'branches' | '
  * the churn the key-aware reconcile replaced.
  */
 export type GkReconcileOutcome = 'reconciled' | 'deferred' | 'failed';
+/** Fired by {@link Cache.onDidChangeMergeTargets} */
+export interface MergeTargetsChangeEvent {
+  /**
+   * The repository's common path (the main worktree's, once registered). Merge keys live in the shared
+   * `.git/gk/config`, so this fires once per change for the whole repository, not once per worktree.
+   */
+  readonly repoPath: string;
+  /**
+   * Branches whose merge-relevant keys (`gk-merge-base`, `gk-merge-target`, `gk-merge-target-user`,
+   * `gk-target-base`) changed. `undefined` when it can't be told, so any branch's may have: the coarse fallback
+   * (no reconciler, or a failed reconcile), or a change with no earlier snapshot to diff against.
+   */
+  readonly refs: ReadonlySet<string> | undefined;
+}
 export type ConflictDetectionCacheKey = `apply:${string}:${string}:${string}` | `merge:${string}:${string}` | `reapply:${string}:${string}`;
 export declare function shouldEvictBlameCacheEntry(progressive: ProgressiveGitBlame | undefined): Promise<boolean>;
 /**
@@ -64,6 +79,14 @@ export declare class Cache implements Disposable {
    * `baseBranchName`/`branchOverviews` on every gk write. Absent means "never observed".
    */
   private _gkConfigMergeSnapshots;
+  private readonly _onDidChangeMergeTargets;
+  /**
+   * Fires when an external `.git/gk/config` write changed a branch's merge-relevant keys — never for a write that
+   * only touched other keys (activity timestamps), and never for core's own writes, which
+   * {@link recordGkConfigWrite} folds into the snapshot before the watcher reports them. Fires after the derived
+   * caches were cleared, so a listener's re-read sees the new values.
+   */
+  get onDidChangeMergeTargets(): Event<MergeTargetsChangeEvent>;
   /**
    * Reconciler registered by the CLI config sub-provider (see {@link setGkConfigReconciler}),
    * invoked on a watcher-observed `'gkConfig'` change instead of the coarse `clearCaches(repoPath,
@@ -234,6 +257,8 @@ export declare class Cache implements Disposable {
    * clear when no reconciler is registered (e.g. the GitHub provider) so nothing can go stale.
    */
   private handleGkConfigChanged;
+  /** The coarse fallback: every derived merge cache is cleared, so any branch's merge targets may have changed */
+  private clearGkConfigCoarsely;
   /** Hard-evicts the cached bulk `.git/gk/config` map so the next read hits disk. */
   deleteGkConfigMap(repoPath: string): void;
   /** The merge-relevant gk config snapshot currently serving as the reconcile baseline. */
@@ -276,6 +301,12 @@ export declare class Cache implements Disposable {
    * the next real read (`getGkConfigMap`) populates one from scratch.
    */
   recordGkConfigWrite(repoPath: string, key: string, value: string | undefined): void;
+  /**
+   * {@link recordGkConfigWrite} for a whole `branch.<ref>` section: our own `--remove-section` (a branch delete) or
+   * `--rename-section` (a branch rename, to `renamedTo`), so the reconcile that follows doesn't report it as an
+   * external merge-target change.
+   */
+  recordGkConfigSectionWrite(repoPath: string, ref: string, renamedTo?: string): void;
   /**
    * Registers the reconciler invoked by {@link handleGkConfigChanged} on a watcher-observed
    * `'gkConfig'` change. Only one reconciler is kept — later registrations replace earlier ones,
@@ -287,7 +318,8 @@ export declare class Cache implements Disposable {
    * Diffs a freshly-read gk config map's merge-relevant subset against `priorSnapshot` (captured by
    * `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state even
    * though this call's own re-read already raced ahead and refreshed the live snapshot), cascading
-   * `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed.
+   * `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed, then firing
+   * {@link onDidChangeMergeTargets} naming those refs.
    * `priorSnapshot` of `undefined` (never observed before this reconcile) is treated as "everything
    * may have changed" — a full coarse clear, same as the pre-existing watcher behavior. Returns
    * whether anything changed (i.e. whether a follow-up repository-changed event is warranted).

package/dist/git/cache.js

@@ -2,6 +2,7 @@ import { exhaustiveArray } from "../utils/array.js";
 import { raceWithSignal } from "../utils/cancellation.js";
 import { debug } from "../utils/decorators/log.js";
 import { invalidateMemoized } from "../utils/decorators/memoize.js";
+import { Emitter } from "../utils/event.js";
 import { getBranchId } from "../utils/gitRefs.js";
 import { normalizePath } from "../utils/path.js";
 import { PromiseCache, PromiseMap, RepoPromiseCacheMap } from "../utils/promiseCache.js";
@@ -133,6 +134,16 @@ var Cache = class Cache {
 	* `baseBranchName`/`branchOverviews` on every gk write. Absent means "never observed".
 	*/
 	_gkConfigMergeSnapshots = /* @__PURE__ */ new Map();
+	_onDidChangeMergeTargets = new Emitter();
+	/**
+	* Fires when an external `.git/gk/config` write changed a branch's merge-relevant keys — never for a write that
+	* only touched other keys (activity timestamps), and never for core's own writes, which
+	* {@link recordGkConfigWrite} folds into the snapshot before the watcher reports them. Fires after the derived
+	* caches were cleared, so a listener's re-read sees the new values.
+	*/
+	get onDidChangeMergeTargets() {
+		return this._onDidChangeMergeTargets.event;
+	}
 	/**
 	* Reconciler registered by the CLI config sub-provider (see {@link setGkConfigReconciler}),
 	* invoked on a watcher-observed `'gkConfig'` change instead of the coarse `clearCaches(repoPath,
@@ -145,6 +156,7 @@ var Cache = class Cache {
 	}
 	dispose() {
 		this.reset();
+		this._onDidChangeMergeTargets.dispose();
 	}
 	/** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
 	getResourceUsage() {
@@ -441,6 +453,8 @@ var Cache = class Cache {
 				keysToClear.add("commitCount");
 				keysToClear.add("logShas");
 				keysToClear.add("resolvedRevisions");
+				keysToClear.add("leftRightCommitCount");
+				keysToClear.add("mergeBase");
 			}
 			if (types.includes("tracking")) {
 				keysToClear.add("fileExistence");
@@ -684,13 +698,21 @@ var Cache = class Cache {
 		const commonPath = this.getCommonPath(repoPath);
 		this._caches.gkConfigMap?.delete(commonPath);
 		if (this._gkConfigReconciler == null) {
-			this.clearCaches(repoPath, "gkConfig");
+			this.clearGkConfigCoarsely(repoPath);
 			return;
 		}
 		const priorSnapshot = this._gkConfigMergeSnapshots.get(commonPath);
 		Promise.resolve(this._gkConfigReconciler(repoPath, priorSnapshot)).then((outcome) => {
-			if (outcome === "failed") this.clearCaches(repoPath, "gkConfig");
-		}, () => this.clearCaches(repoPath, "gkConfig"));
+			if (outcome === "failed") this.clearGkConfigCoarsely(repoPath);
+		}, () => this.clearGkConfigCoarsely(repoPath));
+	}
+	/** The coarse fallback: every derived merge cache is cleared, so any branch's merge targets may have changed */
+	clearGkConfigCoarsely(repoPath) {
+		this.clearCaches(repoPath, "gkConfig");
+		this._onDidChangeMergeTargets.fire({
+			repoPath: this.getCommonPath(repoPath),
+			refs: void 0
+		});
 	}
 	/** Hard-evicts the cached bulk `.git/gk/config` map so the next read hits disk. */
 	deleteGkConfigMap(repoPath) {
@@ -795,6 +817,21 @@ var Cache = class Cache {
 		this._gkConfigMergeSnapshots.set(commonPath, next);
 	}
 	/**
+	* {@link recordGkConfigWrite} for a whole `branch.<ref>` section: our own `--remove-section` (a branch delete) or
+	* `--rename-section` (a branch rename, to `renamedTo`), so the reconcile that follows doesn't report it as an
+	* external merge-target change.
+	*/
+	recordGkConfigSectionWrite(repoPath, ref, renamedTo) {
+		const commonPath = this.getCommonPath(repoPath);
+		const snapshot = this._gkConfigMergeSnapshots.get(commonPath);
+		if (snapshot == null) return;
+		const prefixLength = `branch.${ref}.`.length;
+		const next = /* @__PURE__ */ new Map();
+		for (const [key, value] of snapshot) if (branchOverviewGkConfigKeysRegex.exec(key)?.[1] !== ref) next.set(key, value);
+		else if (renamedTo != null) next.set(`branch.${renamedTo}.${key.substring(prefixLength)}`, value);
+		this._gkConfigMergeSnapshots.set(commonPath, next);
+	}
+	/**
 	* Registers the reconciler invoked by {@link handleGkConfigChanged} on a watcher-observed
 	* `'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
@@ -807,7 +844,8 @@ var Cache = class Cache {
 	* Diffs a freshly-read gk config map's merge-relevant subset against `priorSnapshot` (captured by
 	* `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state even
 	* though this call's own re-read already raced ahead and refreshed the live snapshot), cascading
-	* `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed.
+	* `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed, then firing
+	* {@link onDidChangeMergeTargets} naming those refs.
 	* `priorSnapshot` of `undefined` (never observed before this reconcile) is treated as "everything
 	* may have changed" — a full coarse clear, same as the pre-existing watcher behavior. Returns
 	* whether anything changed (i.e. whether a follow-up repository-changed event is warranted).
@@ -819,14 +857,24 @@ var Cache = class Cache {
 		if (priorSnapshot == null) {
 			this.evictShared("baseBranchName", repoPath);
 			this.evictShared("branchOverviews", repoPath);
+			this._onDidChangeMergeTargets.fire({
+				repoPath: commonPath,
+				refs: void 0
+			});
 			return true;
 		}
-		let changed = false;
+		let refs;
 		for (const key of /* @__PURE__ */ new Set([...priorSnapshot.keys(), ...newSubset.keys()])) if (priorSnapshot.get(key) !== newSubset.get(key)) {
-			changed = true;
 			this.cascadeGkConfigKeyChange(commonPath, key);
+			const ref = branchOverviewGkConfigKeysRegex.exec(key)?.[1];
+			if (ref != null) (refs ??= /* @__PURE__ */ new Set()).add(ref);
 		}
-		return changed;
+		if (refs == null) return false;
+		this._onDidChangeMergeTargets.fire({
+			repoPath: commonPath,
+			refs
+		});
+		return true;
 	}
 	/**
 	* Shared per-ref cascade for a changed `branch.<ref>.gk-...` key: invalidates `baseBranchName` (for