@gitkraken/core-gitlens 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -6,6 +6,36 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-09-29
+
+### Added
+
+- Adds `excluding` to `commits.getLogShas`, the same `GitRefExclusions` `getCommitCount` takes, for listing what `rev` has that other refs don't; GitHub returns no SHAs when it's set (git, git-cli, plus/git-github)
+- Adds `revision.getEmptyTreeSha(repoPath)`, the empty tree's id in the repository's own object format, SHA-1 or SHA-256, cached per repository. GitHub repositories are always SHA-1 (git, git-cli, plus/git-github)
+- Adds `excluding` to `commits.getCommitCount`, counting what `rev` has that other refs don't, such as what deleting a branch would orphan. `branches`, `remotes` and `tags` exclude a whole namespace, and `except` takes full ref names back out of it, which core converts to the short form git's `--exclude` actually matches (a raw `--exclude=refs/heads/x --branches` excludes nothing). GitHub returns `undefined` when `excluding` is set (git, git-cli, plus/git-github)
+- Adds `refs.getReflogEntries(repoPath, ref, { grep })`, a ref's reflog entries (sha and message, newest first) optionally filtered by git's `--grep-reflog` pattern. A failed read rejects rather than resolving `[]`, so "no match" is distinguishable from "never read" (git, git-cli)
+- Adds `untracked` (`'no'`, `'normal'` or `'all'`) and `branch: false` to `status.getStatus`, for a caller that only needs the file list: `branch: false` skips `--branch`, so no upstream ahead/behind is computed, and leaves the result's branch fields unset. Defaults are unchanged (git, git-cli)
+- Adds `folderName` and a trailing `runOptions` to `clone`. `folderName` is used exactly, with no auto-numbering, so git's own refusal of a non-empty folder surfaces; without it the folder is still derived from the URL and numbered past a taken one. `runOptions` carries the clone's `env`, `cancellation` and `timeout` (git, git-cli)
+- Adds `preserveFetchHead` to `ops.fetch` (`--no-write-fetch-head`), for a fetch that must not disturb `FETCH_HEAD` before a user's own `git pull` reads it. Ignored on git older than 2.29, leaving `FETCH_HEAD` written as before (git, git-cli)
+- Adds `refspecs` to `ops.fetch`, passed verbatim after `remote` (`git fetch <remote> <refspec>...`), for fetching one ref into a chosen destination. It never adds `-u`, so git still refuses to write into a checked-out branch. A refspec that writes a local branch or tag also announces `heads` or `tags` (git, git-cli)
+- Adds `notify` to `git.run`'s options, so a raw command announces its own change through `provider.notifyChanged` once it settles, whether it succeeded or failed. `'infer'` classifies the argv: read-only and object-store-only commands announce nothing; a write announces its verb's change kinds for the repository it ran in, the `-C` target when given, and run under `-C` it also announces the kinds every worktree sharing that `.git` sees, such as a branch, tag or stash it wrote, to the caller's own tree, dropping a repository's in-flight runs once however many of its worktrees are named. An explicit list announces exactly those kinds. Left unset, nothing is classified (git, git-cli)
+- Adds a trailing `runOptions` (`env`, `cancellation`, `timeout`) to `stash.applyStash`, `stash.saveStash` and `staging.clean`, as the other long-running operations already take, so a caller can lift the default timeout for a large stash or clean, or cancel one. Defaults are unchanged (git, git-cli)
+
+### Changed
+
+- **Breaking (git)** — `rootSha` is removed; use `revision.getEmptyTreeSha(repoPath)`
+- **Breaking (git, git-cli, plus/git-github)** — `commits.getCommitCount` takes `options` before `cancellation`, `getCommitCount(repoPath, rev, options?, cancellation?)`. A caller passing a cancellation positionally must move it
+- **Breaking (git)** — `GitRevisionSubProvider` requires `getEmptyTreeSha(repoPath)`, so a custom implementation must add it
+- **Breaking (git, git-cli)** — `provider.notifyChanged` without `cache` now resets only what its `changes` can have made stale — the caches a file watcher's change of the same kinds clears, status clock included — instead of every cache, and fires `cache.onReset` with those types. An empty `changes`, or one naming `unknown`, still resets everything; a kind no cache depends on, such as `starred`, resets nothing and fires no `cache.onReset`. Pass `cache: 'all'` for the old behavior (git, git-cli)
+
+### Fixed
+
+- Fixes `remotes.removeRemote`, and `remotes.addRemote` with `fetch`, leaving branch lists and history reads cached without the remote-tracking branches they deleted or created, so a count excluding remote branches kept its old answer (git-cli)
+- Fixes every typed write and `provider.notifyChanged` dropping the in-flight git runs of every repository, so identical reads running at once in other repositories each spawned their own process. Only the written repository's runs, its worktrees' included, are dropped now; `git.clearPendingCommands(repoPaths)` takes the paths to drop, and with none still drops all (git-cli)
+- Fixes diffs against a root commit's missing parent, and against a stash's untracked files, failing in a SHA-256 repository, which the hardcoded SHA-1 empty tree doesn't exist in (git-cli)
+- Fixes detecting a branch's base from its reflog failing for a branch named like a tracked file, or named `delete`, `expire` or `exists` (git-cli)
+- Fixes every git command core runs targeting the wrong repository when the host itself was launched by git — from a hook, a `rebase -x` step, or as `GIT_EDITOR` (a VS Code window opened by `git rebase -i`). The inherited `GIT_DIR`, `GIT_WORK_TREE`, `GIT_INDEX_FILE`, `GIT_COMMON_DIR`, `GIT_OBJECT_DIRECTORY`, `GIT_ALTERNATE_OBJECT_DIRECTORIES` and `GIT_NAMESPACE` overrode each command's working directory, and `GIT_CONFIG_PARAMETERS`, `GIT_EXEC_PATH`, `GIT_PREFIX` and `GIT_REFLOG_ACTION` carried the launching command's own state into all of them. They are now dropped from the inherited environment, and so are `GIT_AUTHOR_*` / `GIT_COMMITTER_*` when git launched the host (it always exports `GIT_EXEC_PATH`), since an editor opened for `commit --amend` inherits that commit's author and date; an identity set deliberately still applies. A host's `env` option or a call's own `env` can still set any of them (git-cli)
+
 ## [0.8.0] - 2026-09-27
 
 ### Added
@@ -417,7 +447,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.8.0...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.9.0...HEAD
+[0.9.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.8.0...gitkraken:releases/core/v0.9.0
 [0.8.0]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.7.2...gitkraken:releases/core/v0.8.0
 [0.7.2]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.7.1...gitkraken:releases/core/v0.7.2
 [0.7.1]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.7.0...gitkraken:releases/core/v0.7.1

package/dist/git/cache.d.ts

@@ -101,6 +101,7 @@ export declare class Cache implements Disposable {
   get contributorsStats(): RepoPromiseCacheMap<string, GitContributorsStats | undefined>;
   get currentUser(): Map<RepoPath, GitUser | null>;
   get defaultBranchName(): RepoPromiseCacheMap<string, string | undefined>;
+  get emptyTreeSha(): PromiseMap<RepoPath, string>;
   get gitDir(): Map<RepoPath, GitDir>;
   get gitIgnore(): Map<RepoPath, GitIgnoreFilter>;
   get gitResults(): RepoPromiseCacheMap<RepoPath, GitResult>;
@@ -207,7 +208,15 @@ export declare class Cache implements Disposable {
    */
   unregisterRepoPath(repoPath: string): void;
   reset(): void;
+  /** Applies a watcher-observed change, sharing reads still in flight (see {@link applyRepositoryChanges}). */
   onRepositoryChanged(repoPath: string, changes: Iterable<RepositoryChange>): void;
+  /**
+   * Clears what `changes` can have made stale for `repoPath`, advances its status clock, and reconciles a
+   * `'gkConfig'` change, returning the cache types it cleared. `inFlight` is as {@link clearCaches}
+   * (`'share'`) vs {@link evictCaches} (`'evict'`). `'unknown'` and `'closed'` map to nothing here: the
+   * watcher unregisters the path on them, and an announced write resets everything instead.
+   */
+  applyRepositoryChanges(repoPath: string, changes: Iterable<RepositoryChange>, inFlight: 'share' | 'evict'): 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}),
@@ -316,6 +325,8 @@ export declare class Cache implements Disposable {
   /** 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>;
+  /** A rejected factory is never cached (`PromiseMap` evicts on rejection) — a failed read retries next time. */
+  getEmptyTreeSha(repoPath: string, factory: (commonPath: string) => PromiseOrValue<string>): Promise<string>;
   getLastFetchedTimestamp(repoPath: string, factory: (commonPath: string) => PromiseOrValue<number | undefined>): Promise<number | undefined>;
   getRefs(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<RefRecord[]>, cancellation?: AbortSignal): Promise<RefRecord[]>;
   getRefTips(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitRefTip[]>, cancellation?: AbortSignal): Promise<GitRefTip[]>;

package/dist/git/cache.js

@@ -54,6 +54,7 @@ const sharedCacheKeys = new Set(exhaustiveArray()([
 	"contributorsLite",
 	"contributorsStats",
 	"defaultBranchName",
+	"emptyTreeSha",
 	"gitResults",
 	"gkConfigMap",
 	"initialCommitSha",
@@ -94,6 +95,7 @@ function createEmptyCaches() {
 		currentBranchReference: void 0,
 		currentUser: void 0,
 		defaultBranchName: void 0,
+		emptyTreeSha: void 0,
 		gitDir: void 0,
 		gitIgnore: void 0,
 		gitResults: void 0,
@@ -237,6 +239,9 @@ var Cache = class Cache {
 	get defaultBranchName() {
 		return this._caches.defaultBranchName ??= new RepoPromiseCacheMap();
 	}
+	get emptyTreeSha() {
+		return this._caches.emptyTreeSha ??= new PromiseMap();
+	}
 	get gitDir() {
 		return this._caches.gitDir ??= /* @__PURE__ */ new Map();
 	}
@@ -420,6 +425,7 @@ var Cache = class Cache {
 				keysToClear.add("refTips");
 				keysToClear.add("commit");
 				keysToClear.add("commitCount");
+				keysToClear.add("logShas");
 				keysToClear.add("resolvedRevisions");
 			}
 			if (types.includes("tracking")) {
@@ -599,13 +605,24 @@ var Cache = class Cache {
 		this._gkConfigReconciler = void 0;
 		this._caches = createEmptyCaches();
 	}
+	/** Applies a watcher-observed change, sharing reads still in flight (see {@link applyRepositoryChanges}). */
 	onRepositoryChanged(repoPath, changes) {
 		const changesSet = new Set(changes);
-		const hasAny = (...c) => c.some((ch) => changesSet.has(ch));
-		if (hasAny("unknown", "closed")) {
+		if (changesSet.has("unknown") || changesSet.has("closed")) {
 			this.unregisterRepoPath(repoPath);
 			return;
 		}
+		this.applyRepositoryChanges(repoPath, changesSet, "share");
+	}
+	/**
+	* Clears what `changes` can have made stale for `repoPath`, advances its status clock, and reconciles a
+	* `'gkConfig'` change, returning the cache types it cleared. `inFlight` is as {@link clearCaches}
+	* (`'share'`) vs {@link evictCaches} (`'evict'`). `'unknown'` and `'closed'` map to nothing here: the
+	* watcher unregisters the path on them, and an announced write resets everything instead.
+	*/
+	applyRepositoryChanges(repoPath, changes, inFlight) {
+		const changesSet = new Set(changes);
+		const hasAny = (...c) => c.some((ch) => changesSet.has(ch));
 		if (hasAny("index", "head", "heads", "remotes", "ignores", "config")) this.incrementStatusGeneration(repoPath);
 		const types = /* @__PURE__ */ new Set();
 		if (hasAny("head")) types.add("branch");
@@ -638,7 +655,8 @@ var Cache = class Cache {
 		if (hasAny("stash")) types.add("stashes");
 		if (hasAny("tags")) types.add("tags");
 		if (hasAny("worktrees")) types.add("worktrees");
-		if (types.size) this.clearCaches(repoPath, ...types);
+		if (types.size) this.clearCachesCore(inFlight, repoPath, ...types);
+		return [...types];
 	}
 	/**
 	* Handles a watcher-observed `'gkConfig'` change. Always evicts the cached bulk map (forcing the
@@ -882,6 +900,10 @@ var Cache = class Cache {
 	getInitialCommitSha(repoPath, factory) {
 		return this.getSharedSimple(this.initialCommitSha, repoPath, factory);
 	}
+	/** A rejected factory is never cached (`PromiseMap` evicts on rejection) — a failed read retries next time. */
+	getEmptyTreeSha(repoPath, factory) {
+		return this.getSharedSimple(this.emptyTreeSha, repoPath, factory);
+	}
 	getLastFetchedTimestamp(repoPath, factory) {
 		return this.getSharedSimple(this.lastFetched, repoPath, factory);
 	}
@@ -972,6 +994,7 @@ __decorate([debug({ onlyExit: true })], Cache.prototype, "clearCaches", null);
 __decorate([debug({ onlyExit: true })], Cache.prototype, "unregisterRepoPath", null);
 __decorate([debug({ onlyExit: true })], Cache.prototype, "reset", null);
 __decorate([debug({ onlyExit: true })], Cache.prototype, "onRepositoryChanged", null);
+__decorate([debug({ onlyExit: true })], Cache.prototype, "applyRepositoryChanges", null);
 //#endregion
 export { Cache, areUriScopedCachedGitTypes, shouldEvictBlameCacheEntry };