@gitkraken/core-gitlens 0.8.0 → 0.9.1

package/CHANGELOG.md

@@ -6,6 +6,46 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+## [0.9.1] - 2026-09-29
+
+### Added
+
+- Adds GitHub and GitHub Enterprise to the refusals `resolveRepository` names. An organization with OAuth App access restrictions that has not approved the OAuth app a token belongs to hides its private repositories from every listing and search without an error, and GraphQL answers a lookup of one exactly as it answers a missing repository, so such a repository resolved as `not-found`, indistinguishable from a deleted one. A GitHub miss is now confirmed over REST (the new `GitHubApi.getRepositoryAccess`), which refuses such a repository with a `403` saying why; the resolution is then `unauthorized` with a warning scoped to the repository (`scope.repositoryId`) and, once the credential is confirmed with a profile read (the new GitHub `validateCredential`), `cause: { reason: 'oauth-app-not-allowed', remedyUrl }`, where `remedyUrl` is the app's page in the user's authorized OAuth apps, addressed by the client id GitHub reports in `X-OAuth-Client-Id`. A REST read that cannot confirm either way keeps the `not-found`, and any other `403` stays scoped with GitHub's own words and no cause. Neither the confirming read nor the credential check raises the reauthentication prompt (`GitHubApi.getCurrentAccount` takes `silent`). A refusal's facts now also read Octokit's `{ status, headers, data }` response, and carry the refused token's OAuth client id (plus/integrations, plus/git-github)
+
+### Changed
+
+- Changes `resolveRepository`'s `unauthorized` on Azure DevOps, Azure DevOps Server, Bitbucket and Bitbucket Data Center: a `401`/`403` for the repository now settles as a batch read's refused target does, so once the credential checks out, the warning is scoped to that repository (and, on Azure DevOps, named by its `cause`) instead of reported for the connection. GitLab, which has no credential check, is unchanged. Also, a GitHub batch read whose every target is refused now checks the credential once and, when it passes, publishes each refusal scoped to its repository, spending no strike and keeping the session, instead of failing as the connection's (plus/integrations)
+
+## [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 +457,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.8.0...HEAD
+[unreleased]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.9.1...HEAD
+[0.9.1]: https://github.com/gitkraken/vscode-gitlens/compare/releases/core/v0.9.0...gitkraken:releases/core/v0.9.1
+[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 };