@gitkraken/core-gitlens 0.1.0

package/src/git/providers/diff.ts

@@ -0,0 +1,127 @@
+import type { Uri } from '../../utils/uri.js';
+import type {
+	GitDiff,
+	GitDiffFiles,
+	GitDiffFilter,
+	GitDiffShortStat,
+	ParsedGitDiff,
+	ParsedGitDiffHunks,
+} from '../models/diff.js';
+import type { GitFile } from '../models/file.js';
+import type { GitRevisionRange, GitRevisionRangeNotation } from '../models/revision.js';
+import type { DisposableTemporaryGitIndex } from './staging.js';
+import type { DiffRange, RevisionUri } from './types.js';
+
+export interface NextComparisonUrisResult {
+	current: RevisionUri;
+	next: RevisionUri | undefined;
+	deleted?: boolean | undefined;
+}
+
+export interface PreviousComparisonUrisResult {
+	current: RevisionUri;
+	previous: RevisionUri | undefined;
+}
+
+export interface PreviousRangeComparisonUrisResult extends PreviousComparisonUrisResult {
+	range: DiffRange;
+}
+
+export interface GitDiffSubProvider {
+	getChangedFilesCount(
+		repoPath: string,
+		to?: string,
+		from?: string,
+		options?: { uris?: (string | Uri)[] },
+		cancellation?: AbortSignal,
+	): Promise<GitDiffShortStat | undefined>;
+	getDiff?(
+		repoPath: string,
+		to: string,
+		from?: string,
+		options?: {
+			context?: number;
+			index?: DisposableTemporaryGitIndex;
+			notation?: GitRevisionRangeNotation;
+			uris?: (string | Uri)[];
+		},
+		cancellation?: AbortSignal,
+	): Promise<GitDiff | undefined>;
+	/**
+	 * Runs `git diff` and returns the fully parsed structure (files with hunks together) in a
+	 * single call. Equivalent to `getDiff` followed by `parseGitDiff` on the resulting contents.
+	 *
+	 * For rendering-friendly line ordering, split each `hunk.content` on newlines and read the
+	 * `+`/`-`/` ` prefix on each line.
+	 */
+	getParsedDiff?(
+		repoPath: string,
+		to: string,
+		from?: string,
+		options?: {
+			context?: number;
+			notation?: GitRevisionRangeNotation;
+			uris?: (string | Uri)[];
+		},
+		cancellation?: AbortSignal,
+	): Promise<ParsedGitDiff | undefined>;
+	getDiffFiles?(repoPath: string, contents: string, cancellation?: AbortSignal): Promise<GitDiffFiles | undefined>;
+	getDiffStatus(
+		repoPath: string,
+		ref1OrRange: string | GitRevisionRange,
+		ref2?: string,
+		options?: { filters?: GitDiffFilter[]; path?: string; renameLimit?: number; similarityThreshold?: number },
+	): Promise<GitFile[] | undefined>;
+	getDiffTool?(repoPath?: string): Promise<string | undefined>;
+	getNextComparisonUris(
+		repoPath: string,
+		pathOrUri: string | Uri,
+		rev: string | undefined,
+		skip?: number,
+		options?: { ordering?: 'date' | 'author-date' | 'topo' | null },
+		cancellation?: AbortSignal,
+	): Promise<NextComparisonUrisResult | undefined>;
+	getPreviousComparisonUris(
+		repoPath: string,
+		pathOrUri: string | Uri,
+		rev: string | undefined,
+		skip?: number,
+		unsaved?: boolean,
+		options?: { ordering?: 'date' | 'author-date' | 'topo' | null },
+		cancellation?: AbortSignal,
+	): Promise<PreviousComparisonUrisResult | undefined>;
+	getPreviousComparisonUrisForRange(
+		repoPath: string,
+		pathOrUri: string | Uri,
+		rev: string | undefined,
+		range: DiffRange,
+		options?: { ordering?: 'date' | 'author-date' | 'topo' | null; skipFirstRev?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<PreviousRangeComparisonUrisResult | undefined>;
+	openDiffTool?(
+		repoPath: string,
+		pathOrUri: string | Uri,
+		options?: {
+			ref1?: string | undefined;
+			ref2?: string | undefined;
+			staged?: boolean | undefined;
+			tool?: string | undefined;
+		},
+	): Promise<void>;
+	openDirectoryCompare?(repoPath: string, ref1: string, ref2?: string, tool?: string): Promise<void>;
+
+	getDiffForFile?(
+		repoPath: string,
+		path: string,
+		ref1: string | undefined,
+		ref2?: string,
+		options?: { encoding?: string },
+	): Promise<ParsedGitDiffHunks | undefined>;
+	getDiffForFileContents?(
+		repoPath: string,
+		path: string,
+		ref: string,
+		contents: string,
+		options?: { encoding?: string },
+	): Promise<ParsedGitDiffHunks | undefined>;
+}

package/src/git/providers/graph.ts

@@ -0,0 +1,30 @@
+import type { GitGraph, GraphRowProcessor } from '../models/graph.js';
+import type {
+	GitGraphSearch,
+	GitGraphSearchCursor,
+	GitGraphSearchProgress,
+	GitGraphSearchResults,
+} from '../models/graphSearch.js';
+import type { SearchQuery } from '../models/search.js';
+
+export interface GitGraphSubProvider {
+	getGraph(
+		repoPath: string,
+		rev: string | undefined,
+		options?: { include?: { stats?: boolean }; limit?: number; rowProcessor?: GraphRowProcessor },
+		cancellation?: AbortSignal,
+	): Promise<GitGraph>;
+	searchGraph(
+		repoPath: string,
+		search: SearchQuery,
+		options?: { limit?: number; ordering?: 'date' | 'author-date' | 'topo' },
+		cancellation?: AbortSignal,
+	): AsyncGenerator<GitGraphSearchProgress, GitGraphSearch, void>;
+	continueSearchGraph(
+		repoPath: string,
+		cursor: GitGraphSearchCursor,
+		existingResults: GitGraphSearchResults,
+		options?: { limit?: number },
+		cancellation?: AbortSignal,
+	): AsyncGenerator<GitGraphSearchProgress, GitGraphSearch, void>;
+}

package/src/git/providers/operations.ts

@@ -0,0 +1,82 @@
+import type { GitBranchReference, GitReference } from '../models/reference.js';
+import type { GitConflictFile } from '../models/staging.js';
+
+export interface GitOperationResult {
+	readonly conflicted: boolean;
+	/** Populated when {@link conflicted} is `true`. May be empty if the conflict file list couldn't be read. */
+	readonly conflicts?: GitConflictFile[];
+}
+
+export interface GitOperationsSubProvider {
+	checkout(
+		repoPath: string,
+		ref: string,
+		options?: { createBranch?: string | undefined } | { path?: string | undefined },
+	): Promise<void>;
+	cherryPick(
+		repoPath: string,
+		revs: string[],
+		options?: { edit?: boolean; noCommit?: boolean },
+	): Promise<GitOperationResult>;
+	commit(
+		repoPath: string,
+		message: string,
+		options?: {
+			all?: boolean;
+			allowEmpty?: boolean;
+			amend?: boolean;
+			author?: string;
+			date?: string;
+			signoff?: boolean;
+		},
+	): Promise<void>;
+	fetch(
+		repoPath: string,
+		options?: {
+			all?: boolean | undefined;
+			branch?: GitBranchReference | undefined;
+			prune?: boolean | undefined;
+			pull?: boolean | undefined;
+			remote?: string | undefined;
+		},
+	): Promise<void>;
+	merge(
+		repoPath: string,
+		ref: string,
+		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean },
+	): Promise<GitOperationResult>;
+	pull(
+		repoPath: string,
+		options?: {
+			branch?: GitBranchReference | undefined;
+			rebase?: boolean | undefined;
+			tags?: boolean | undefined;
+		},
+	): Promise<void>;
+	push(
+		repoPath: string,
+		options?: {
+			reference?: GitReference | undefined;
+			force?: boolean | undefined;
+			publish?: { remote: string };
+		},
+	): Promise<void>;
+	rebase(
+		repoPath: string,
+		upstream: string,
+		options?: {
+			autoStash?: boolean;
+			branch?: string;
+			editor?: string;
+			interactive?: boolean;
+			onto?: string;
+			updateRefs?: boolean;
+		},
+	): Promise<GitOperationResult>;
+	reset(
+		repoPath: string,
+		rev: string,
+		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
+	): Promise<void>;
+	revert(repoPath: string, refs: string[], options?: { editMessage?: boolean }): Promise<GitOperationResult>;
+}

package/src/git/providers/patch.ts

@@ -0,0 +1,31 @@
+import type { GitCommit, GitCommitIdentityShape } from '../models/commit.js';
+
+export interface GitPatchSubProvider {
+	apply(repoPath: string, patch: string, options?: { threeWay?: boolean }): Promise<void>;
+	applyUnreachableCommitForPatch(
+		repoPath: string,
+		rev: string,
+		options?: {
+			branchName?: string;
+			createBranchIfNeeded?: boolean;
+			createWorktreePath?: string;
+			stash?: boolean;
+		},
+	): Promise<void>;
+	createUnreachableCommitForPatch(
+		repoPath: string,
+		base: string,
+		message: string,
+		patch: string,
+		options?: { sign?: boolean; source?: unknown },
+	): Promise<GitCommit | undefined>;
+	createUnreachableCommitsFromPatches(
+		repoPath: string,
+		base: string | undefined,
+		patches: { message: string; patch: string; author?: GitCommitIdentityShape }[],
+		options?: { sign?: boolean; source?: unknown },
+	): Promise<string[]>;
+	createEmptyInitialCommit(repoPath: string): Promise<string>;
+
+	validatePatch(repoPath: string | undefined, contents: string): Promise<boolean>;
+}

package/src/git/providers/pausedOperations.ts

@@ -0,0 +1,10 @@
+import type { GitPausedOperationStatus } from '../models/pausedOperationStatus.js';
+
+export interface GitPausedOperationsSubProvider {
+	getPausedOperationStatus(
+		repoPath: string,
+		cancellation?: AbortSignal,
+	): Promise<GitPausedOperationStatus | undefined>;
+	abortPausedOperation(repoPath: string, options?: { quit?: boolean }): Promise<void>;
+	continuePausedOperation(repoPath: string, options?: { skip?: boolean }): Promise<void>;
+}

package/src/git/providers/provider.ts

@@ -0,0 +1,62 @@
+import type { Uri } from '../../utils/uri.js';
+import type { GitIgnoreFilter } from '../watching/gitIgnoreFilter.js';
+import type { GitBlameSubProvider } from './blame.js';
+import type { GitBranchesSubProvider } from './branches.js';
+import type { GitCommitsSubProvider } from './commits.js';
+import type { GitConfigSubProvider } from './config.js';
+import type { GitContributorsSubProvider } from './contributors.js';
+import type { GitDiffSubProvider } from './diff.js';
+import type { GitGraphSubProvider } from './graph.js';
+import type { GitOperationsSubProvider } from './operations.js';
+import type { GitPatchSubProvider } from './patch.js';
+import type { GitPausedOperationsSubProvider } from './pausedOperations.js';
+import type { GitRefsSubProvider } from './refs.js';
+import type { GitRemotesSubProvider } from './remotes.js';
+import type { GitRevisionSubProvider } from './revision.js';
+import type { GitStagingSubProvider } from './staging.js';
+import type { GitStashSubProvider } from './stash.js';
+import type { GitStatusSubProvider } from './status.js';
+import type { GitTagsSubProvider } from './tags.js';
+import type { GitProviderDescriptor } from './types.js';
+import type { GitWorktreesSubProvider } from './worktrees.js';
+
+export type { GitProviderDescriptor } from './types.js';
+
+/**
+ * Common interface for all git providers (CLI, GitHub, etc.).
+ * Consumers can register multiple providers and route operations transparently.
+ *
+ * Core sub-providers are required; CLI-only sub-providers are optional.
+ */
+export interface GitProvider {
+	readonly descriptor: GitProviderDescriptor;
+
+	getAbsoluteUri(pathOrUri: string | Uri, base: string | Uri): Uri;
+	getRelativePath(pathOrUri: string | Uri, base: string | Uri): string;
+
+	clone?(url: string, parentPath: string): Promise<string | undefined>;
+	excludeIgnoredUris?(repoPath: string, uris: Uri[]): Promise<Uri[]>;
+	getIgnoreFilter?(repoPath: string, gitDirPath: string): GitIgnoreFilter;
+	getIgnoredUrisFilter?(repoPath: string): Promise<(uri: Uri) => boolean>;
+	getLastFetchedTimestamp?(repoPath: string): Promise<number | undefined>;
+
+	readonly branches: GitBranchesSubProvider;
+	readonly commits: GitCommitsSubProvider;
+	readonly config: GitConfigSubProvider;
+	readonly contributors: GitContributorsSubProvider;
+	readonly diff: GitDiffSubProvider;
+	readonly graph: GitGraphSubProvider;
+	readonly refs: GitRefsSubProvider;
+	readonly remotes: GitRemotesSubProvider;
+	readonly revision: GitRevisionSubProvider;
+	readonly status: GitStatusSubProvider;
+	readonly tags: GitTagsSubProvider;
+
+	readonly blame?: GitBlameSubProvider;
+	readonly ops?: GitOperationsSubProvider;
+	readonly patch?: GitPatchSubProvider;
+	readonly pausedOps?: GitPausedOperationsSubProvider;
+	readonly staging?: GitStagingSubProvider;
+	readonly stash?: GitStashSubProvider;
+	readonly worktrees?: GitWorktreesSubProvider;
+}

package/src/git/providers/refs.ts

@@ -0,0 +1,39 @@
+import type { Uri } from '../../utils/uri.js';
+import type { GitBranch } from '../models/branch.js';
+import type { GitReference } from '../models/reference.js';
+import type { GitTag } from '../models/tag.js';
+
+export interface GitRefsSubProvider {
+	checkIfCouldBeValidBranchOrTagName(repoPath: string, ref: string): Promise<boolean>;
+	getMergeBase(
+		repoPath: string,
+		ref1: string,
+		ref2: string,
+		options?: { forkPoint?: boolean | undefined },
+		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>;
+	hasBranchOrTag(
+		repoPath: string | undefined,
+		options?: {
+			filter?:
+				| { branches?: ((b: GitBranch) => boolean) | undefined; tags?: ((t: GitTag) => boolean) | undefined }
+				| undefined;
+		},
+		cancellation?: AbortSignal,
+	): Promise<boolean>;
+	isValidReference(
+		repoPath: string,
+		ref: string,
+		pathOrUri?: string | Uri,
+		cancellation?: AbortSignal,
+	): Promise<boolean>;
+	validateReference(
+		repoPath: string,
+		ref: string,
+		relativePath?: string,
+		cancellation?: AbortSignal,
+	): Promise<string | undefined>;
+	updateReference(repoPath: string, ref: string, newRef: string, cancellation?: AbortSignal): Promise<void>;
+}

package/src/git/providers/remotes.ts

@@ -0,0 +1,33 @@
+import type { GitRemote } from '../models/remote.js';
+import type { RemoteProvider } from '../models/remoteProvider.js';
+
+export interface GitRemotesSubProvider {
+	getRemote(repoPath: string | undefined, name: string, cancellation?: AbortSignal): Promise<GitRemote | undefined>;
+	getRemotes(
+		repoPath: string | undefined,
+		options?: { filter?: (remote: GitRemote) => boolean; sort?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<GitRemote[]>;
+
+	getDefaultRemote(repoPath: string, cancellation?: AbortSignal): Promise<GitRemote | undefined>;
+	getRemotesWithProviders(
+		repoPath: string,
+		options?: { sort?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<GitRemote<RemoteProvider>[]>;
+	getBestRemoteWithProvider(
+		repoPath: string,
+		cancellation?: AbortSignal,
+	): Promise<GitRemote<RemoteProvider> | undefined>;
+	getBestRemotesWithProviders(repoPath: string, cancellation?: AbortSignal): Promise<GitRemote<RemoteProvider>[]>;
+	addRemote?(repoPath: string, name: string, url: string, options?: { fetch?: boolean }): Promise<void>;
+	addRemoteWithResult?(
+		repoPath: string,
+		name: string,
+		url: string,
+		options?: { fetch?: boolean },
+	): Promise<GitRemote | undefined>;
+	pruneRemote?(repoPath: string, name: string): Promise<void>;
+	removeRemote?(repoPath: string, name: string): Promise<void>;
+	setRemoteAsDefault(repoPath: string, name: string, value?: boolean): Promise<void>;
+}

package/src/git/providers/revision.ts

@@ -0,0 +1,28 @@
+import type { Uri } from '../../utils/uri.js';
+import type { GitFileStatus } from '../models/fileStatus.js';
+import type { GitTreeEntry } from '../models/tree.js';
+
+export interface ResolvedRevision {
+	/** The SHA of the revision */
+	sha: string;
+	/** The "friendly" version of the revision, if applicable, otherwise the SHA */
+	revision: string;
+
+	/** Only set if the path is provided */
+	status?: GitFileStatus;
+	/** Only set if the path is provided */
+	path?: string;
+	/** Only set if the path is provided */
+	originalPath?: string;
+}
+
+export interface GitRevisionSubProvider {
+	exists?(repoPath: string, path: string, revOrOptions?: string | { untracked?: boolean }): Promise<boolean>;
+	getRevisionContent(repoPath: string, path: string, rev: string): Promise<Uint8Array | undefined>;
+	getSubmoduleHead?(repoPath: string, submodulePath: string): Promise<string | undefined>;
+	/** Gets tracked file paths from the index (reflects working tree state, even during rebase) */
+	getTrackedFiles(repoPath: string): Promise<string[]>;
+	getTreeEntryForRevision(repoPath: string, path: string, rev: string): Promise<GitTreeEntry | undefined>;
+	getTreeForRevision(repoPath: string, rev: string): Promise<GitTreeEntry[]>;
+	resolveRevision(repoPath: string, ref: string, pathOrUri?: string | Uri): Promise<ResolvedRevision>;
+}

package/src/git/providers/shared/remotes.ts

@@ -0,0 +1,95 @@
+import { debug } from '../../../utils/decorators/log.js';
+import { sortCompare } from '../../../utils/string.js';
+import type { Cache } from '../../cache.js';
+import type { GitServiceContext } from '../../context.js';
+import type { GitRemote } from '../../models/remote.js';
+import type { RemoteProvider } from '../../models/remoteProvider.js';
+import { getDefaultRemoteOrHighlander } from '../../utils/remote.utils.js';
+import type { GitProvider } from '../provider.js';
+import type { GitRemotesSubProvider } from '../remotes.js';
+
+export abstract class RemotesGitProviderBase implements GitRemotesSubProvider {
+	constructor(
+		protected readonly context: GitServiceContext,
+		protected readonly cache: Cache,
+		protected readonly provider: GitProvider,
+	) {}
+
+	abstract getRemotes(
+		repoPath: string | undefined,
+		options?: { filter?: (remote: GitRemote) => boolean; sort?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<GitRemote[]>;
+
+	@debug()
+	async getRemote(
+		repoPath: string | undefined,
+		name: string,
+		cancellation?: AbortSignal,
+	): Promise<GitRemote | undefined> {
+		if (repoPath == null) return undefined;
+
+		const remotes = await this.getRemotes(repoPath, undefined, cancellation);
+		return remotes.find(r => r.name === name);
+	}
+
+	@debug()
+	async getDefaultRemote(repoPath: string, cancellation?: AbortSignal): Promise<GitRemote | undefined> {
+		const remotes = await this.getRemotes(repoPath, undefined, cancellation);
+		return getDefaultRemoteOrHighlander(remotes);
+	}
+
+	@debug()
+	async getRemotesWithProviders(
+		repoPath: string,
+		options?: { sort?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<GitRemote<RemoteProvider>[]> {
+		const remotes = await this.getRemotes(repoPath, options, cancellation);
+		return remotes.filter((r): r is GitRemote<RemoteProvider> => r.provider != null);
+	}
+
+	@debug()
+	async getBestRemoteWithProvider(
+		repoPath: string,
+		cancellation?: AbortSignal,
+	): Promise<GitRemote<RemoteProvider> | undefined> {
+		const remotes = await this.getBestRemotesWithProviders(repoPath, cancellation);
+		return remotes[0];
+	}
+
+	@debug()
+	async getBestRemotesWithProviders(
+		repoPath: string,
+		cancellation?: AbortSignal,
+	): Promise<GitRemote<RemoteProvider>[]> {
+		if (!repoPath) return [];
+
+		const remotes = this.cache.bestRemotes.getOrCreate(
+			repoPath,
+			async (_cacheable, aggregateSignal) => {
+				const remotes = await this.getRemotesWithProviders(repoPath, { sort: true }, aggregateSignal);
+				if (remotes.length === 0) return [];
+				if (remotes.length === 1) return [...remotes];
+
+				if (this.context.remotes?.sort != null) {
+					return this.context.remotes.sort(remotes, aggregateSignal);
+				}
+
+				// Fallback: sort by name when no host sort is provided
+				return remotes.toSorted((a, b) => sortCompare(a.name, b.name));
+			},
+			cancellation,
+		);
+
+		return [...(await remotes)];
+	}
+
+	@debug()
+	async setRemoteAsDefault(repoPath: string, name: string, value: boolean = true): Promise<void> {
+		// setGkConfig is optional — providers that don't support git config (e.g. GitHub) silently skip persistence
+		await this.provider.config.setGkConfig?.(repoPath, 'gk.defaultRemote', value ? name : undefined);
+		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes');
+		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes', 'remoteProviders']);
+	}
+}

package/src/git/providers/staging.ts

@@ -0,0 +1,22 @@
+import type { UnifiedAsyncDisposable } from '../../utils/disposable.js';
+import type { Uri } from '../../utils/uri.js';
+
+export interface DisposableTemporaryGitIndex extends UnifiedAsyncDisposable {
+	path: string;
+	env: { GIT_INDEX_FILE: string };
+}
+
+export interface GitStagingSubProvider {
+	createTemporaryIndex(repoPath: string, from: 'empty' | 'current'): Promise<DisposableTemporaryGitIndex>;
+	createTemporaryIndex(repoPath: string, from: 'ref', ref: string): Promise<DisposableTemporaryGitIndex>;
+	stageFile(repoPath: string, pathOrUri: string | Uri): Promise<void>;
+	stageFiles(
+		repoPath: string,
+		pathsOrUris: (string | Uri)[],
+		options?: { index?: DisposableTemporaryGitIndex; intentToAdd?: boolean },
+	): Promise<void>;
+	stageDirectory(repoPath: string, directoryOrUri: string | Uri): Promise<void>;
+	unstageFile(repoPath: string, pathOrUri: string | Uri): Promise<void>;
+	unstageFiles(repoPath: string, pathsOrUris: (string | Uri)[]): Promise<void>;
+	unstageDirectory(repoPath: string, directoryOrUri: string | Uri): Promise<void>;
+}

package/src/git/providers/stash.ts

@@ -0,0 +1,51 @@
+import type { Uri } from '../../utils/uri.js';
+import type { GitFileChange } from '../models/fileChange.js';
+import type { GitStash } from '../models/stash.js';
+
+export interface StashApplyResult {
+	readonly conflicted: boolean;
+}
+
+export interface GitStashSubProvider {
+	/**
+	 * Applies a stash entry to the working tree.
+	 * @param stashNameOrSha Accepts `stash@{N}` (from the stash list) or a raw SHA (e.g. from
+	 * {@link createStash}). Note: `options.deleteAfter` (pop) requires a `stash@{N}` — git will
+	 * reject a raw SHA because pop can only drop list entries.
+	 */
+	applyStash(
+		repoPath: string,
+		stashNameOrSha: string,
+		options?: { deleteAfter?: boolean | undefined; index?: boolean | undefined },
+	): Promise<StashApplyResult>;
+	/**
+	 * Creates a stash commit without adding it to the stash list (plumbing — equivalent to
+	 * `git stash create`). Returns the created commit SHA, or `undefined` if there was nothing to
+	 * stash.
+	 */
+	createStash(repoPath: string, message?: string): Promise<string | undefined>;
+	getStash(
+		repoPath: string,
+		options?: {
+			includeFiles?: boolean;
+			reachableFrom?: string;
+			similarityThreshold?: number | null;
+		},
+		cancellation?: AbortSignal,
+	): Promise<GitStash | undefined>;
+	getStashCommitFiles(
+		repoPath: string,
+		ref: string,
+		options?: { similarityThreshold?: number | null },
+		cancellation?: AbortSignal,
+	): Promise<GitFileChange[]>;
+	deleteStash(repoPath: string, stashName: string, sha?: string): Promise<void>;
+	renameStash(repoPath: string, stashName: string, sha: string, message: string, stashOnRef?: string): Promise<void>;
+	saveStash(
+		repoPath: string,
+		message?: string,
+		pathsOrUris?: (string | Uri)[],
+		options?: { includeUntracked?: boolean; keepIndex?: boolean; onlyStaged?: boolean },
+	): Promise<void>;
+	saveSnapshot(repoPath: string, message?: string): Promise<void>;
+}

package/src/git/providers/status.ts

@@ -0,0 +1,42 @@
+import type { Uri } from '../../utils/uri.js';
+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';
+
+export interface GitWorkingChangesState {
+	staged: boolean;
+	unstaged: boolean;
+	untracked: boolean;
+}
+
+export interface GitStatusSubProvider {
+	getStatus(repoPath: string | undefined, cancellation?: AbortSignal): Promise<GitStatus | undefined>;
+	getStatusForFile?(
+		repoPath: string,
+		pathOrUri: string | Uri,
+		options?: { renames?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<GitStatusFile | undefined>;
+	getStatusForPath?(
+		repoPath: string,
+		pathOrUri: string | Uri,
+		options?: { renames?: boolean },
+		cancellation?: AbortSignal,
+	): Promise<GitStatusFile[] | undefined>;
+
+	hasWorkingChanges(
+		repoPath: string,
+		options?: {
+			staged?: boolean;
+			unstaged?: boolean;
+			untracked?: boolean;
+			throwOnError?: boolean;
+		},
+		cancellation?: AbortSignal,
+	): Promise<boolean>;
+	getWorkingChangesState(repoPath: string, cancellation?: AbortSignal): Promise<GitWorkingChangesState>;
+	hasConflictingFiles(repoPath: string, cancellation?: AbortSignal): Promise<boolean>;
+	getConflictingFiles(repoPath: string, cancellation?: AbortSignal): Promise<GitConflictFile[]>;
+	getUntrackedFiles(repoPath: string, cancellation?: AbortSignal): Promise<GitFile[]>;
+}