@gitkraken/core-gitlens 0.2.0 → 0.3.1

package/src/git/providers/config.ts

@@ -1,3 +1,4 @@
+import type { GkConfigInvalidationTarget } from '../cache.js';
 import type { GitDir } from '../models/repository.js';
 import type { SigningConfig, ValidationResult } from '../models/signature.js';
 import type { GitUser } from '../models/user.js';
@@ -87,16 +88,13 @@ export interface GitConfigSubProvider {
 		| []
 	>;
 
-	getGkConfig?(
-		repoPath: string,
-		key: GkConfigKeys | DeprecatedGkConfigKeys,
-		options?: { type?: GitConfigType },
-	): Promise<string | undefined>;
+	getGkConfig?(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys): Promise<string | undefined>;
 	getGkConfigRegex?(repoPath: string, pattern: string): Promise<Map<string, string>>;
 	setGkConfig?(
 		repoPath: string,
 		key: GkConfigKeys | DeprecatedGkConfigKeys,
 		value: string | undefined,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
 	): Promise<void>;
 
 	getSigningConfig?(repoPath: string): Promise<SigningConfig>;

package/src/git/providers/operations.ts

@@ -1,5 +1,6 @@
 import type { GitBranchReference, GitReference } from '../models/reference.js';
 import type { GitConflictFile } from '../models/staging.js';
+import type { GitRunOptions } from '../run.types.js';
 
 export interface GitOperationResult {
 	readonly conflicted: boolean;
@@ -7,16 +8,34 @@ export interface GitOperationResult {
 	readonly conflicts?: GitConflictFile[];
 }
 
+/**
+ * Spawn-layer overrides callers can pass to user-initiated git operations to inject per-call
+ * environment variables, an `AbortSignal` for cancellation, or a custom `timeout`. Forwarded
+ * verbatim to the underlying `git.run(...)` invocation; cannot override op-owned fields like
+ * `cwd`, `configs`, `errors`, or `stdin`.
+ *
+ * Note: passing `timeout` overrides per-op safety defaults. `merge`, `rebase`, and `revert`
+ * intentionally disable the timeout (set it to 0) because those operations can take a long
+ * time; a caller-supplied `timeout` will replace that "no timeout" setting, so use with care.
+ */
+export type GitOperationRunOptions = Pick<GitRunOptions, 'env' | 'cancellation' | 'timeout'>;
+
 export interface GitOperationsSubProvider {
+	/**
+	 * Switches the repository to a branch or ref. Pure branch/ref switching — does not accept
+	 * a path. For path-level operations use {@link restore}.
+	 */
 	checkout(
 		repoPath: string,
 		ref: string,
-		options?: { createBranch?: string | undefined } | { path?: string | undefined },
+		options?: { createBranch?: string | undefined },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	cherryPick(
 		repoPath: string,
 		revs: string[],
 		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	commit(
 		repoPath: string,
@@ -30,6 +49,7 @@ export interface GitOperationsSubProvider {
 			signoff?: boolean;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	fetch(
 		repoPath: string,
@@ -40,11 +60,13 @@ export interface GitOperationsSubProvider {
 			pull?: boolean | undefined;
 			remote?: string | undefined;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	merge(
 		repoPath: string,
 		ref: string,
 		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	pull(
 		repoPath: string,
@@ -54,6 +76,7 @@ export interface GitOperationsSubProvider {
 			tags?: boolean | undefined;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	push(
 		repoPath: string,
@@ -62,6 +85,7 @@ export interface GitOperationsSubProvider {
 			force?: boolean | undefined;
 			publish?: { remote: string };
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	rebase(
 		repoPath: string,
@@ -69,21 +93,61 @@ export interface GitOperationsSubProvider {
 		options?: {
 			autoStash?: boolean;
 			branch?: string;
+			/** Command set as `sequence.editor` — edits the interactive rebase todo list. */
 			editor?: string;
 			interactive?: boolean;
+			/**
+			 * Set when the `editor` is a script that rewrites the todo by command word + SHA (e.g. the
+			 * Commit Graph's headless squash/drop/reword) rather than a human. Forces git to emit a plain,
+			 * natural-order todo by disabling `rebase.autosquash` (which would reorder commits and rewrite
+			 * `pick`→`fixup` for `fixup!`/`squash!` commits) and `rebase.abbreviateCommands` (which would
+			 * emit `p` instead of `pick`). Both honor the user's git config otherwise.
+			 */
+			programmaticEditor?: boolean;
+			/**
+			 * Command git uses to edit per-commit messages (the combined message a `squash` produces, or a
+			 * `reword`). Applied as `GIT_EDITOR` — which git's interactive-rebase `reword`/`squash` step honors,
+			 * unlike `core.editor` — with `core.editor` also set as a fallback. When omitted, git falls back to
+			 * the user's configured editor.
+			 */
+			messageEditor?: string;
 			onto?: string;
 			updateRefs?: boolean;
 			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 	reset(
 		repoPath: string,
 		rev: string,
 		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
+		runOptions?: GitOperationRunOptions,
+	): Promise<void>;
+	/**
+	 * Restores the working-tree copy of one or more paths. Single path or array; arrays are
+	 * chunked under the CLI length limit and dispatched as one git invocation per chunk
+	 * (typically one for normal-sized batches).
+	 *
+	 * Source selection — `options` is mutually exclusive (`side` wins if both are supplied):
+	 *
+	 * - **No options** (`git checkout -- <paths>`): copies the index to the working tree, leaving
+	 *   the index untouched. Use to drop unstaged changes (mixed-file partial discard preserves
+	 *   the staged portion this way).
+	 * - **`{ ref }`** (`git checkout <ref> -- <paths>`): resets BOTH the index and the working
+	 *   tree of the path(s) to `<ref>`. Use to fully revert files to HEAD, a specific commit, etc.
+	 * - **`{ side }`** (`git checkout --ours|--theirs -- <paths>`): conflict-resolution
+	 *   shortcut, valid only during a paused merge/rebase/cherry-pick. Leaves files unstaged.
+	 */
+	restore(
+		repoPath: string,
+		path: string | string[],
+		options?: { ref?: string; side?: 'ours' | 'theirs' },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	revert(
 		repoPath: string,
 		refs: string[],
 		options?: { editMessage?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult>;
 }

package/src/git/providers/pausedOperations.ts

@@ -3,6 +3,7 @@ import type { GitPausedOperationStatus } from '../models/pausedOperationStatus.j
 export interface GitPausedOperationsSubProvider {
 	getPausedOperationStatus(
 		repoPath: string,
+		options?: { force?: boolean },
 		cancellation?: AbortSignal,
 	): Promise<GitPausedOperationStatus | undefined>;
 	abortPausedOperation(repoPath: string, options?: { quit?: boolean }): Promise<void>;

package/src/git/providers/refs.ts

@@ -1,7 +1,8 @@
 import type { Uri } from '../../utils/uri.js';
 import type { GitBranch } from '../models/branch.js';
-import type { GitReference } from '../models/reference.js';
+import type { GitReference, GitRefTip } from '../models/reference.js';
 import type { GitTag } from '../models/tag.js';
+import type { GitCommandPriority } from '../run.types.js';
 
 export interface GitRefsSubProvider {
 	checkIfCouldBeValidBranchOrTagName(repoPath: string, ref: string): Promise<boolean>;
@@ -9,11 +10,39 @@ export interface GitRefsSubProvider {
 		repoPath: string,
 		ref1: string,
 		ref2: string,
-		options?: { forkPoint?: boolean | undefined },
+		options?: { forkPoint?: boolean | undefined; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined>;
 	getReference(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<GitReference | undefined>;
-	getSymbolicReferenceName?(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | undefined>;
+	/**
+	 * Lightweight enumeration of ref tips (heads/remotes/tags) — no enrichment.
+	 * Use this when you need a SHA-to-refs map; use `getBranches`/`getTags` for full models.
+	 */
+	getRefTips(
+		repoPath: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<GitRefTip[]>;
+	/**
+	 * Batch reachability — for each input SHA, the refs whose tips contain it.
+	 *
+	 * One bounded `git rev-list --topo-order --parents --all ^<oldestSha>^@` walk; ref-set
+	 * propagation runs in memory. Cost is O(walked subgraph), not O(N × refs) like the per-sha
+	 * `getBranchesWithCommits([sha])` pattern. Pass the oldest SHA in your dataset to bound the walk.
+	 */
+	getRefsContainingShas(
+		repoPath: string,
+		shas: ReadonlySet<string> | readonly string[],
+		oldestSha: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<Map<string, GitRefTip[]>>;
+	getSymbolicReferenceName?(
+		repoPath: string,
+		ref: string,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<string | undefined>;
 	hasBranchOrTag(
 		repoPath: string | undefined,
 		options?: {

package/src/git/providers/staging.ts

@@ -19,6 +19,18 @@ export interface GitStagingSubProvider {
 	unstageFile(repoPath: string, pathOrUri: string | Uri): Promise<void>;
 	unstageFiles(repoPath: string, pathsOrUris: (string | Uri)[]): Promise<void>;
 	unstageDirectory(repoPath: string, directoryOrUri: string | Uri): Promise<void>;
+	/**
+	 * Removes a file from both the working tree and the index in a single operation
+	 * (`git rm [-f] -- <path>`). Use during conflict resolution when the user has chosen a
+	 * side that is itself a deletion — atomic, so it can't leave a working-tree-modified
+	 * file accidentally staged with content. Pass `force: true` to discard local
+	 * modifications (required for conflicted files).
+	 */
+	removeFile(repoPath: string, pathOrUri: string | Uri, options?: { force?: boolean }): Promise<void>;
+	/**
+	 * Batched form of {@link removeFile}. Chunks paths to stay under the CLI length limit.
+	 */
+	removeFiles(repoPath: string, pathsOrUris: (string | Uri)[], options?: { force?: boolean }): Promise<void>;
 	stageAll(repoPath: string): Promise<void>;
 	unstageAll(repoPath: string): Promise<void>;
 }

package/src/git/providers/status.ts

@@ -3,6 +3,7 @@ import type { GitFile } from '../models/file.js';
 import type { GitConflictFile } from '../models/staging.js';
 import type { GitStatus } from '../models/status.js';
 import type { GitStatusFile } from '../models/statusFile.js';
+import type { GitCommandPriority } from '../run.types.js';
 
 export interface GitWorkingChangesState {
 	staged: boolean;
@@ -11,7 +12,11 @@ export interface GitWorkingChangesState {
 }
 
 export interface GitStatusSubProvider {
-	getStatus(repoPath: string | undefined, cancellation?: AbortSignal): Promise<GitStatus | undefined>;
+	getStatus(
+		repoPath: string | undefined,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined>;
 	getStatusForFile?(
 		repoPath: string,
 		pathOrUri: string | Uri,

package/src/git/remotes/azure-devops.ts

@@ -34,6 +34,7 @@ function parseVstsHttpsUrl(url: URL): [string, string, string] {
 	const owner = getVSTSOwner(url);
 	const match = azureProjectRepoRegex.exec(url.pathname);
 	if (match == null) throw new Error(`Invalid VSTS URL: ${url.toString()}`);
+
 	const [, project, repo] = match;
 	return [owner, project, repo];
 }
@@ -43,6 +44,7 @@ const azureHttpsUrlRegex2 = /([^/]+)\/([^/]+)\/_git\/([^/]+)/;
 function parseAzureNewStyleUrl(url: URL): [string, string, string] {
 	const match = azureHttpsUrlRegex2.exec(url.pathname);
 	if (match == null) throw new Error(`Invalid Azure URL: ${url.toString()}`);
+
 	const [, owner, project, repo] = match;
 	return [owner, project, repo];
 }

package/src/git/remotes/custom.ts

@@ -35,6 +35,29 @@ export class CustomRemoteProvider extends RemoteProvider {
 		return [];
 	}
 
+	get avatarUrlTemplate(): string | undefined {
+		return this.urls.avatar;
+	}
+
+	getUrlForAvatar(email: string, size: number): string | undefined {
+		if (this.urls.avatar == null) return undefined;
+
+		// Split on the last `@` so local-parts that contain `@` are preserved (per RFC 5322)
+		const at = email.lastIndexOf('@');
+		const emailName = at === -1 ? email : email.slice(0, at);
+		const domain = at === -1 ? '' : email.slice(at + 1);
+
+		// Component-encode identity values — commit emails are attacker-controllable and
+		// must never be able to inject URL-structural characters (`/`, `?`, `#`, ...) into the
+		// resulting URL
+		return interpolate(this.urls.avatar, {
+			email: encodeURIComponent(email),
+			emailName: encodeURIComponent(emailName),
+			domain: encodeURIComponent(domain),
+			size: String(size),
+		});
+	}
+
 	protected override getUrlForRepository(): string {
 		return this.getUrl(this.urls.repository, this.getContext());
 	}

package/src/git/{exec.types.ts → run.types.ts}

@@ -27,11 +27,11 @@ export interface GitResultCache {
  * Priority levels for git commands.
  * - `interactive`: User-initiated operations (blame, hover) - highest priority
  * - `normal`: Standard operations (status, config) - default priority
- * - `background`: Expensive operations (log, graph) - can be throttled
+ * - `background`: Expensive operations (graph rendering, full history walks) - can be throttled
  */
 export type GitCommandPriority = 'interactive' | 'normal' | 'background';
 
-export interface GitExecOptions {
+export interface GitRunOptions {
 	cancellation?: AbortSignal;
 	configs?: readonly string[];
 	readonly correlationKey?: string;
@@ -63,6 +63,26 @@ export interface GitExecOptions {
 	readonly timeout?: number;
 }
 
+/**
+ * Untyped escape hatch for raw `git <args>` invocation, returned by
+ * `GlGitProvider.createUnsafeGit`.
+ *
+ * "Unsafe" here means **bypasses the typed safety net** the rest of GitLens relies on
+ * — sub-provider cancellation/caching/decorator behaviors and signing-awareness do
+ * not apply when commands are issued through this object. It does NOT imply command
+ * injection risk; the caller still controls the args.
+ *
+ * Hand instances to libraries that need to issue arbitrary git commands
+ * (`@gitkraken/compose-tools`, `@gitkraken/shared-tools` undo). Inside GitLens
+ * itself, prefer the typed sub-providers on `RepositoryService` (`branches`,
+ * `commits`, `diff`, `staging`, `stash`, `status`, …). Holding an `UnsafeGit`
+ * just to call `run(...)` for an ad-hoc command is almost always wrong — the
+ * abstraction exists so it can be handed off, not used directly.
+ */
+export interface UnsafeGit {
+	run(args: readonly string[], options?: GitRunOptions): Promise<GitResult>;
+}
+
 export interface GitSpawnOptions {
 	cancellation?: AbortSignal;
 	configs?: readonly string[];

package/src/git/service.ts

@@ -77,6 +77,7 @@ export class GitService implements UnifiedDisposable {
 		if (GitService._instance != null) {
 			throw new Error('GitService already exists — only one instance is allowed');
 		}
+
 		const instance = new GitService(watchingProvider);
 		GitService._instance = instance;
 		return instance;

package/src/git/utils/autolink.utils.ts

@@ -179,6 +179,7 @@ export function getBranchAutolinks(
 			for (const regex of ref.branchNameRegexes) {
 				match = branchName.match(regex);
 				if (!match?.groups) continue;
+
 				num = match.groups.issueKeyNumber;
 				const linkUrl = ref.url?.replace(numRegex, num);
 				autolinks.set(linkUrl, {

package/src/git/utils/blame.utils.ts

@@ -249,6 +249,7 @@ export function buildDirtyBlame(cleanBlame: GitBlame, mapping: LineMappingResult
 	const lineCountsBySha = new Map<string, number>();
 	for (const blameLine of dirtyBlameLines) {
 		if (blameLine == null) continue;
+
 		lineCountsBySha.set(blameLine.sha, (lineCountsBySha.get(blameLine.sha) ?? 0) + 1);
 	}
 
@@ -276,6 +277,7 @@ export function buildDirtyBlame(cleanBlame: GitBlame, mapping: LineMappingResult
 	for (const [, c] of commits) {
 		if (!c.author.name) continue;
 		if (authors.has(c.author.name)) continue;
+
 		authors.set(c.author.name, { name: c.author.name, lineCount: 0, current: c.author.current });
 	}
 

package/src/git/utils/conflictResolution.utils.ts

@@ -0,0 +1,31 @@
+import type { GitFileConflictStatus } from '../models/fileStatus.js';
+
+export type ConflictResolutionAction = 'take-ours' | 'take-theirs' | 'delete' | 'unsupported';
+
+export function classifyConflictAction(
+	status: GitFileConflictStatus,
+	resolution: 'current' | 'incoming',
+): ConflictResolutionAction {
+	const takeCurrent = resolution === 'current';
+
+	if (status === 'DD') return 'delete';
+	if (status === 'UD' && !takeCurrent) return 'delete';
+	if (status === 'DU' && takeCurrent) return 'delete';
+
+	// `git checkout --{ours,theirs}` fails when the requested stage is absent.
+	// Single-file UI filters these out; bulk resolve surfaces them as failures.
+	if (status === 'UA' && takeCurrent) return 'unsupported';
+	if (status === 'AU' && !takeCurrent) return 'unsupported';
+
+	return takeCurrent ? 'take-ours' : 'take-theirs';
+}
+
+// Stage Current is invalid when the current side has no content to take (added/deleted only by them, or both deleted)
+export function canStageCurrent(status: GitFileConflictStatus): boolean {
+	return status !== 'UA' && status !== 'DD';
+}
+
+// Stage Incoming is invalid when the incoming side has no content to take (added/deleted only by us, or both deleted)
+export function canStageIncoming(status: GitFileConflictStatus): boolean {
+	return status !== 'AU' && status !== 'DD';
+}

package/src/git/utils/contributor.utils.ts

@@ -79,3 +79,27 @@ export function calculateDistribution<T extends string>(
 export function matchContributor(c: GitContributor, user: GitUser): boolean {
 	return c.name === user.name && c.email === user.email && c.username === user.username;
 }
+
+/** Appends `Co-authored-by:` trailers for the given coauthors to a commit message, replacing
+ *  any existing trailer block. Each coauthor is the `Name <email>` form (GitContributor.coauthor). */
+export function appendCoauthorsToMessage(message: string, coauthors: Iterable<string>): string {
+	const index = message.indexOf('Co-authored-by: ');
+	if (index !== -1) {
+		message = message.substring(0, index - 1).trimEnd();
+	}
+
+	for (const coauthor of coauthors) {
+		let newlines;
+		if (message.includes('Co-authored-by: ')) {
+			newlines = '\n';
+		} else if (message.length !== 0 && message.endsWith('\n')) {
+			newlines = '\n\n';
+		} else {
+			newlines = '\n\n\n';
+		}
+
+		message += `${newlines}Co-authored-by: ${coauthor}`;
+	}
+
+	return message;
+}

package/src/git/utils/fileStatus.utils.ts

@@ -1,4 +1,4 @@
-import type { GitFileStatus } from '../models/fileStatus.js';
+import type { GitFileConflictStatus, GitFileStatus } from '../models/fileStatus.js';
 
 const statusIconsMap = {
 	'.': undefined,
@@ -47,3 +47,9 @@ const statusTextMap = {
 export function getGitFileStatusText(status: GitFileStatus | keyof typeof statusTextMap): string {
 	return statusTextMap[status] ?? 'Unknown';
 }
+
+const conflictStatuses = new Set<string>(['U', 'AA', 'AU', 'UA', 'DD', 'DU', 'UD', 'UU']);
+
+export function isConflictStatus(status: string | undefined): status is 'U' | GitFileConflictStatus {
+	return status != null && conflictStatuses.has(status);
+}

package/src/git/utils/reachability.utils.ts

@@ -0,0 +1,109 @@
+import { base64, fromBase64 } from '../../utils/base64.js';
+import type { GraphReachabilityTable } from '../models/graph.js';
+import type { GitCommitReachability } from '../providers/commits.js';
+
+type ReachableRef = GitCommitReachability['refs'][number];
+
+/**
+ * Canonical dictionary key for a reachable ref. The `r`/`l` discriminator keeps a remote branch from
+ * colliding with a local branch of the same name; the `refType` prefix separates tags from branches.
+ * Single-sourced here so the encoder ({@link createReachabilityTableBuilder}) and any future consumer
+ * can't drift on the convention.
+ */
+export function reachableRefKey(ref: ReachableRef): string {
+	return `${ref.refType}:${ref.refType === 'branch' && ref.remote ? 'r' : 'l'}:${ref.name}`;
+}
+
+// Monotonic generation counter — each builder (i.e. each fresh graph walk) gets a distinct id, while a
+// builder reused across `more()` pagination keeps its id. Only ever incremented host-side (the encoder);
+// the webview treats the id as opaque. Module-scoped so ids are unique across a session's builders.
+let nextReachabilityTableId = 0;
+
+/**
+ * Builds a {@link GraphReachabilityTable} incrementally: interns refs into a shared dictionary and
+ * distinct membership bitmaps into a deduplicated set list. Kept next to {@link decodeReachabilitySet}
+ * (its exact inverse) so the wire format — first-seen dictionary indexing, LSB-first bit packing,
+ * base64 — has a single owner and a round-trippable test, rather than an encoder and decoder that can
+ * silently diverge across packages.
+ *
+ * Append-only by construction: an index, once assigned, is never reused — so a builder kept alive
+ * across paginated loads accumulates a table whose existing indices stay valid as it grows.
+ */
+export function createReachabilityTableBuilder(): {
+	intern: (refs: Iterable<ReachableRef> | undefined) => number | undefined;
+	build: () => GraphReachabilityTable | undefined;
+} {
+	const id = ++nextReachabilityTableId;
+	const dictionary: GitCommitReachability['refs'] = [];
+	const refKeyToIndex = new Map<string, number>();
+	const sets: string[] = [];
+	const setKeyToIndex = new Map<string, number>();
+
+	return {
+		/** Interns a ref set, returning its index into `sets`, or undefined when the set is empty. */
+		intern: (refs: Iterable<ReachableRef> | undefined): number | undefined => {
+			if (refs == null) return undefined;
+
+			let maxIndex = -1;
+			const indices: number[] = [];
+			for (const ref of refs) {
+				const key = reachableRefKey(ref);
+				let index = refKeyToIndex.get(key);
+				if (index == null) {
+					index = dictionary.length;
+					refKeyToIndex.set(key, index);
+					dictionary.push(ref);
+				}
+				indices.push(index);
+				if (index > maxIndex) {
+					maxIndex = index;
+				}
+			}
+			if (indices.length === 0) return undefined;
+
+			// Pack into a bitset sized to this set's high-water dictionary index, then intern by base64.
+			const bytes = new Uint8Array((maxIndex >> 3) + 1);
+			for (const index of indices) {
+				bytes[index >> 3] |= 1 << (index & 7);
+			}
+			const encoded = base64(bytes);
+			let setIndex = setKeyToIndex.get(encoded);
+			if (setIndex == null) {
+				setIndex = sets.length;
+				setKeyToIndex.set(encoded, setIndex);
+				sets.push(encoded);
+			}
+			return setIndex;
+		},
+
+		/** The accumulated table, or undefined when nothing was interned. */
+		build: (): GraphReachabilityTable | undefined =>
+			dictionary.length ? { id: id, dictionary: dictionary, sets: sets } : undefined,
+	};
+}
+
+/**
+ * Decodes the membership bitmap at `index` in a {@link GraphReachabilityTable} back into its list of
+ * reachable refs. Refs come back in the table's first-seen dictionary order — callers that need the
+ * canonical display order (current-first / local-before-remote / tags newest-first) sort the result
+ * with `compareReachableRefs`. Returns an empty array for an out-of-range/missing set index.
+ *
+ * The bitmap is at most `ceil(dictionary.length / 8)` bytes; earlier (shorter) bitmaps packed against
+ * a smaller dictionary stay valid — only bits actually present can be set, so the loop stops at the
+ * shorter of the dictionary length and the bitmap's bit count rather than scanning a guaranteed-zero tail.
+ */
+export function decodeReachabilitySet(table: GraphReachabilityTable, index: number): GitCommitReachability['refs'] {
+	const { dictionary, sets } = table;
+	const encoded = sets[index];
+	if (encoded == null) return [];
+
+	const bytes = fromBase64(encoded);
+	const refs: GitCommitReachability['refs'] = [];
+	const count = Math.min(dictionary.length, bytes.length * 8);
+	for (let i = 0; i < count; i++) {
+		if ((bytes[i >> 3] ?? 0) & (1 << (i & 7))) {
+			refs.push(dictionary[i]);
+		}
+	}
+	return refs;
+}

package/src/git/utils/search.utils.ts

@@ -274,6 +274,8 @@ export function parseSearchQueryGitCommand(
 							searchArgs.add('--no-walk');
 						} else if (value === 'tip') {
 							filters.type = 'tip';
+						} else if (value === 'wip') {
+							filters.type = 'wip';
 						}
 					}
 

package/src/git/utils/sorting.ts

@@ -46,6 +46,23 @@ export function compareReachableRefs(
 	return 0;
 }
 
+// Hoisted from `compareRefTips` so we don't re-allocate the lookup per sort iteration.
+const refTipTypeOrder = { branch: 0, remote: 1, tag: 2 } as const;
+
+/**
+ * Comparator for `GitRefTip` arrays — local branch < remote branch < tag, tags by version desc.
+ * Mirrors `compareReachableRefs` for the lighter ref-tip shape.
+ */
+export function compareRefTips(a: { type: 'branch' | 'remote' | 'tag'; name: string }, b: typeof a): number {
+	if (a.type !== b.type) {
+		return refTipTypeOrder[a.type] - refTipTypeOrder[b.type];
+	}
+	if (a.type === 'tag') {
+		return compareByVersionDescending(a.name, b.name);
+	}
+	return 0;
+}
+
 export function sortBranches(branches: GitBranch[], options?: BranchSortOptions): GitBranch[] {
 	options = { current: true, groupByType: true, orderBy: 'date:desc', ...options };
 

package/src/git/utils/status.utils.ts

@@ -69,6 +69,7 @@ export function getUpstreamStatus(
 	},
 ): string {
 	if (upstream == null) return options?.empty ?? '';
+
 	const {
 		state: { ahead, behind },
 	} = upstream;

package/src/git/watching/classifyChange.ts

@@ -17,6 +17,15 @@ const classifyRegex =
  *   handles it as a last-fetched timestamp).
  */
 export function classifyGitDirChange(relativePath: string): RepositoryChange[] | undefined {
+	// User-edited todo file (and its backup) — handled by VS Code's TextDocument
+	// events in the rebase webview (see `rebaseWebviewProvider.ts`). Suppress here
+	// to avoid thrashing the repo update path on every save during an interactive
+	// rebase; rebase lifecycle (start/stop/step) still fires from sibling files
+	// in `rebase-merge/` and the directory itself.
+	if (relativePath.endsWith('/git-rebase-todo') || relativePath.endsWith('/git-rebase-todo.backup')) {
+		return undefined;
+	}
+
 	const match = classifyRegex.exec(relativePath);
 	if (match == null) return undefined;
 

package/src/git/watching/gitIgnoreFilter.ts

@@ -1,7 +1,7 @@
-import { getScopedCounter } from '../../utils/counter.js';
-import { fileUri } from '../../utils/uri.js';
 import type { Ignore } from 'ignore';
 import ignore from 'ignore';
+import { getScopedCounter } from '../../utils/counter.js';
+import { fileUri } from '../../utils/uri.js';
 import type { FileSystemProvider } from '../context.js';
 
 export interface GitIgnoreFilterOptions {

package/src/git/watching/initWatcher.ts

@@ -36,6 +36,7 @@ export class RepositoryInitWatcher implements UnifiedDisposable {
 
 	dispose(): void {
 		if (this._disposed) return;
+
 		this._disposed = true;
 
 		for (const watcher of this.watchers.values()) {
@@ -60,6 +61,7 @@ export class RepositoryInitWatcher implements UnifiedDisposable {
 
 		const watcher = this.provider.createWatcher(basePath, gitInitGlob, event => {
 			if (event.reason !== 'create') return;
+
 			this.emitter.fire({ path: event.path, basePath: basePath });
 		});