@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/src/git/providers/contributors.ts

@@ -1,34 +0,0 @@
-import type { GitContributor, GitContributorsStats } from '../models/contributor.js';
-
-export interface GitContributorsResult {
-	readonly contributors: GitContributor[];
-	readonly cancelled?: { reason: 'cancelled' | 'timedout' } | undefined;
-}
-
-export interface GitContributorsSubProvider {
-	getContributors(
-		repoPath: string,
-		rev?: string,
-		options?: {
-			all?: boolean;
-			merges?: boolean | 'first-parent';
-			pathspec?: string;
-			since?: string;
-			stats?: boolean;
-		},
-		cancellation?: AbortSignal,
-		timeout?: number,
-	): Promise<GitContributorsResult>;
-	getContributorsLite(
-		repoPath: string,
-		rev?: string,
-		options?: { all?: boolean; merges?: boolean | 'first-parent'; since?: string },
-		cancellation?: AbortSignal,
-	): Promise<GitContributor[]>;
-	getContributorsStats(
-		repoPath: string,
-		options?: { merges?: boolean | 'first-parent'; since?: string },
-		cancellation?: AbortSignal,
-		timeout?: number,
-	): Promise<GitContributorsStats | undefined>;
-}

package/src/git/providers/diff.ts

@@ -1,133 +0,0 @@
-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)[]; includeUntracked?: boolean },
-		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[];
-			includeUntracked?: boolean;
-			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

@@ -1,95 +0,0 @@
-import type {
-	GitGraph,
-	GitGraphRowsStats,
-	GraphIncrementalSeed,
-	GraphReachabilityTable,
-	GraphRowProcessor,
-	IncrementalGraphOutcome,
-} from '../models/graph.js';
-import type {
-	GitGraphSearch,
-	GitGraphSearchCursor,
-	GitGraphSearchProgress,
-	GitGraphSearchResults,
-} from '../models/graphSearch.js';
-import type { GitGraphSession } from '../models/graphSession.js';
-import type { SearchQuery } from '../models/search.js';
-
-export interface GitGraphSubProvider {
-	/**
-	 * Opens a stateful {@link GitGraphSession} for `repoPath` — the canonical accumulated graph window and
-	 * the single builder of incremental rebuild seeds. Performs the initial walk (equivalent to a first
-	 * `getGraph` with no seed); subsequent rebuilds go through `session.refresh()`, pagination through
-	 * `session.more()`. Prefer this over `getGraph` for a live, repeatedly-refreshed window; `getGraph`
-	 * remains for one-shot walks (and is what the session is built on).
-	 */
-	openGraphSession(
-		repoPath: string,
-		options?: {
-			rowProcessor?: GraphRowProcessor;
-			rev?: string;
-			limit?: number;
-			include?: { stats?: boolean };
-		},
-		cancellation?: AbortSignal,
-	): Promise<GitGraphSession>;
-	getGraph(
-		repoPath: string,
-		rev: string | undefined,
-		options?: {
-			include?: { stats?: boolean };
-			limit?: number;
-			rowProcessor?: GraphRowProcessor;
-			/**
-			 * Prior generation's reachability table to CONTINUE (same repo rebuilds only). Keeps
-			 * `reachabilityIndex` values stable for unchanged rows, which is what lets the caller ship a
-			 * rows splice-delta instead of the full row set. See `createReachabilityTableBuilder`.
-			 */
-			reachabilitySeed?: GraphReachabilityTable;
-			/**
-			 * Prior generation's per-sha stats to CONTINUE (same-repo rebuilds only). Stats are immutable per
-			 * sha, so the deferred stats query recomputes only shas absent from the seed.
-			 */
-			rowsStatsSeed?: GitGraphRowsStats;
-			/**
-			 * R6b incremental head-walk seed. When present (and the gate holds) the Node provider walks only the
-			 * changed head region, stitches the seed's cached tail, and re-derives flags/reachability in memory
-			 * instead of re-walking every loaded row. Any structural change (ref deletion, non-fast-forward move,
-			 * stash-set change, old-dated interleave, …) degrades to the full walk. See {@link GraphIncrementalSeed}.
-			 */
-			incrementalSeed?: GraphIncrementalSeed;
-			/**
-			 * Observational callback invoked once per seeded call reporting whether the fast path was taken or a
-			 * full fallback occurred (with the reason). Never affects the returned graph. See
-			 * {@link IncrementalGraphOutcome}.
-			 */
-			onIncrementalResult?: (outcome: IncrementalGraphOutcome) => void;
-		},
-		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>;
-	/**
-	 * Counts commits matching `search` without materializing results — used to probe whether a relaxed
-	 * (broadened) variant of a zero-result search would actually find anything, before offering it as a
-	 * calm inline chip. Optional: providers that can't cheaply count (e.g. GitHub) simply omit it, and
-	 * callers treat a missing implementation the same as "no relaxations available" (never an error).
-	 */
-	countSearchResults?(
-		repoPath: string,
-		search: SearchQuery,
-		options?: { maxCount?: number },
-		cancellation?: AbortSignal,
-	): Promise<number>;
-}

package/src/git/providers/maintenance.ts

@@ -1,224 +0,0 @@
-/**
- * Git maintenance / optimization sub-provider — the data plane behind the Git Health feature.
- *
- * Two tiers of levers (see `.work/dev/git-health/spec.md`):
- * - **Auto tier** — inert, repo-local maintenance applied silently: the demand-cadence commit-graph
- *   write and `git maintenance run` one-shots. No config levers — the auto tier never rewrites config.
- * - **Ask tier** — config levers surfaced for one-click apply/undo (`core.untrackedCache`,
- *   `core.fsmonitor`, `git maintenance start`, `feature.manyFiles`).
- *
- * The commit-graph is a task OF this service, not a thing beside it: `MaintenanceGitSubProvider` owns its
- * implementation (a direct `git commit-graph write --reachable --split` — usable at 2.24, unlike the 2.30
- * `maintenance run --task=commit-graph`), its policy, and its demand cadence (minutes throttle + single-flight
- * keyed by common git dir). `GraphGitSubProvider` and the repo-open shape probe merely `request(...)` it.
- *
- * Every method is repo-path-first (so the `RepositoryService` proxy can auto-inject `repoPath`) and
- * `AbortSignal`-able. The provider is optional — it exists only on the desktop CLI provider, so web
- * builds and virtual repos never register it (availability is a per-repo capability, `repo.git.maintenance`).
- */
-
-/**
- * Auto-tier maintenance tasks. `commit-graph` runs a DIRECT `git commit-graph write --reachable --split`
- * (2.24+); the others run their native `git maintenance run --task=…` implementations.
- */
-export type GitMaintenanceTask = 'commit-graph' | 'loose-objects' | 'incremental-repack' | 'pack-refs';
-
-/** The uniform apply/revert surface for every optimization lever (auto + ask). */
-export type GitOptimizationId = 'untrackedCache' | 'fsmonitor' | 'backgroundMaintenance' | 'manyFiles' | 'sparseIndex';
-
-/**
- * Cheap per-session shape probe — filesystem stats + config reads only, no expensive git walks. Shared
- * across worktrees (keyed by common path). Everything here is derivable without inflating objects.
- */
-export interface GitHealthSnapshot {
-	/** Repository shape that changes how the remaining measurements should be interpreted. */
-	readonly repository: {
-		/** Whether local history stops at an intentional shallow boundary; `undefined` when detection failed. */
-		readonly shallow: boolean | undefined;
-		/** Whether missing objects may be supplied by a promisor remote; `undefined` when detection failed. */
-		readonly partial: boolean | undefined;
-		/** Whether the worktree is populated from a sparse specification; `undefined` when config was unreadable. */
-		readonly sparseCheckout: boolean | undefined;
-		/** Whether sparse checkout uses directory-based cone mode; `undefined` when config was unreadable. */
-		readonly sparseCheckoutCone: boolean | undefined;
-		/** Whether the index is configured to use sparse-directory entries; `undefined` when config was unreadable. */
-		readonly sparseIndex: boolean | undefined;
-		/** Whether this worktree uses a split index; `undefined` when detection failed. */
-		readonly splitIndex: boolean | undefined;
-		/** Reference storage selected by the repository format. */
-		readonly refFormat: 'files' | 'reftable' | 'unknown';
-	};
-	/** Bounded loose-reference count for the files ref backend; exact unless the probe reached its cap. */
-	readonly looseRefs: { readonly count: number; readonly exact: boolean };
-	/** Presence + mtime of `objects/info/commit-graph` (or the split `commit-graphs/` chain), and changed-path Bloom filter state. */
-	readonly commitGraph: {
-		readonly present: boolean;
-		readonly mtime: number | undefined;
-		/** Whether the NEWEST graph layer carries changed-path Bloom filters (`BIDX` chunk). */
-		readonly changedPaths: boolean;
-		/** Whether this repo can write them (Git 2.31+ and not a partial clone). */
-		readonly changedPathsSupported: boolean;
-		/** `true` once the user disabled GitLens's automatic commit-graph maintenance for this repo (`gk.commitGraphDisabled`). */
-		readonly disabled: boolean;
-		/**
-		 * `true` when `core.commitGraph` is EXPLICITLY false in the user's git config — git won't read the
-		 * cache, and `ensureCommitGraph` honors the same setting as a write opt-out, so the view must not
-		 * claim the graph is (or will be) maintained.
-		 */
-		readonly readDisabled: boolean;
-	};
-	/** Presence of a classic or incremental multi-pack-index. */
-	readonly multiPackIndex: boolean;
-	/** Whether Git is configured to read/write the multi-pack-index; `undefined` when config was unreadable. */
-	readonly multiPackIndexEnabled: boolean | undefined;
-	/** Count of `*.pack` files in `objects/pack`. */
-	readonly packCount: number;
-	/** Pack files not represented by the active multi-pack-index; `undefined` when it could not be established. */
-	readonly packsOutsideMultiPackIndex: number | undefined;
-	/** Effective `maintenance.incremental-repack.auto` threshold; `undefined` when invalid or unreadable. */
-	readonly incrementalRepackAutoThreshold: number | undefined;
-	/** Total bytes of all `*.pack` files. */
-	readonly packBytes: number;
-	/** Raw loose-object sample (a handful of the 256 fanout dirs); the host extrapolates the estimate. */
-	readonly looseObjects: { readonly objectsInSampledDirs: number; readonly dirsSampled: number };
-	/** Size of the worktree index in bytes (including the largest shared base for a split index). */
-	readonly indexBytes: number;
-	/**
-	 * Entry count from the index header (`DIRC`, version, count — all big-endian). For a normal index this is
-	 * the exact tracked-file count; for a sparse index it counts the populated working set plus sparse-directory
-	 * entries. It is deliberately `undefined` for a split index, whose header covers only its mutable layer,
-	 * and during conflicts, whose stage entries duplicate paths.
-	 */
-	readonly indexEntryCount: number | undefined;
-	/** How {@link indexEntryCount} should be interpreted. */
-	readonly indexEntryCountType: 'full' | 'sparse' | 'split' | 'conflicted' | 'unavailable';
-	/** Current state of the config levers this feature toggles. */
-	readonly config: {
-		readonly fsmonitor: boolean;
-		readonly untrackedCache: boolean;
-		/**
-		 * Whether `core.untrackedCache` carries an explicit value in ANY scope (local/global/system).
-		 * {@link untrackedCache} alone can't tell "unset" from a deliberate `false`/`keep`, and this is the
-		 * one lever the auto tier applies silently — so it only ever fills in an unset value.
-		 */
-		readonly untrackedCacheConfigured: boolean;
-		readonly manyFiles: boolean;
-	};
-	/**
-	 * Whether this repo is registered for system-scheduled `git maintenance` (global `maintenance.repo`).
-	 * `undefined` when the registration list could not be read — never treat that as "not registered": a
-	 * repo the user registered themselves would read as unregistered, get suggested again, and a later
-	 * Undo would silently remove their registration.
-	 */
-	readonly maintenanceRegistered: boolean | undefined;
-	/** `true` once FSMonitor failed to enable here (from the `gk.fsmonitorNotApplicable` marker) — never re-suggest. */
-	readonly fsmonitorNotApplicable: boolean;
-	/** `true` once the untracked cache failed git's filesystem probe here (`gk.untrackedCacheNotApplicable`) — never re-suggest. */
-	readonly untrackedCacheNotApplicable: boolean;
-	/**
-	 * Which levers GitLens itself applied (from the `gk.applied.*` ownership markers). Lets the view render a
-	 * lever the user turned on themselves as "already enabled" (no Undo) versus one GitLens applied (Apply/Undo).
-	 * Distinct from {@link config}, which reports the effective state regardless of who set it.
-	 */
-	readonly applied: {
-		readonly untrackedCache: boolean;
-		readonly fsmonitor: boolean;
-		readonly manyFiles: boolean;
-		readonly backgroundMaintenance: boolean;
-		/** Worktree-scoped ownership; sparse indexes are not shared between linked worktrees. */
-		readonly sparseIndex: boolean;
-	};
-	/** Whether the installed git supports `git maintenance run` (2.30+) — gates the auto-tier tasks. */
-	readonly supportsMaintenanceRun: boolean;
-	/** Whether the installed git includes the `pack-refs` maintenance task (2.31+). */
-	readonly supportsPackRefsMaintenance: boolean;
-}
-
-/** On-demand detail computed only when the Git Health view opens (cheap-ish git walks). */
-export interface GitHealthDetails {
-	/** `git rev-list --count --all` — total reachable commits. `undefined` if the walk failed. */
-	readonly commitCount: number | undefined;
-	/**
-	 * Parsed `git count-objects -v` breakdown. `undefined` if it failed. The `size`, `sizePack`, and
-	 * `sizeGarbage` fields are normalized to BYTES — git itself reports them in KiB.
-	 */
-	readonly countObjects:
-		| {
-				readonly count: number;
-				readonly size: number;
-				readonly inPack: number;
-				readonly packs: number;
-				readonly sizePack: number;
-				readonly prunePackable: number;
-				readonly garbage: number;
-				readonly sizeGarbage: number;
-		  }
-		| undefined;
-}
-
-/** Whether a given optimization lever is available for a repo, with a user-facing reason when it isn't. */
-export interface GitOptimizationCapability {
-	readonly id: GitOptimizationId;
-	readonly supported: boolean;
-	/** Present only when `supported` is `false` — why (git version, platform, virtual FS). */
-	readonly reason?: string;
-	/** Optional caveat to surface even when supported (e.g. `manyFiles` enabling an index older tools can't read). */
-	readonly note?: string;
-}
-
-export interface GitMaintenanceSubProvider {
-	/** Cheap filesystem + config probe of the repo's object store and lever states. */
-	getHealthSnapshot(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthSnapshot>;
-	/** On-demand commit count + `count-objects` breakdown (only when the view opens). */
-	getHealthDetails(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthDetails>;
-	/** Availability of each optimization lever (git version + platform gated). */
-	getCapabilities(repoPath: string): Promise<GitOptimizationCapability[]>;
-	/**
-	 * Hint that a task's cache is worth refreshing now, applying that task's cadence policy. Callers normally
-	 * ignore the returned promise; consumers that need freshness may await it. It resolves `true` only when a
-	 * write completed and `false` when a supported request was gated or failed, and never rejects.
-	 * `commit-graph` runs the demand cadence (minutes throttle + single-flight, both keyed by common git dir),
-	 * fully gated on the auto-tier switches; `loose-objects`/`incremental-repack` are no-ops here (the daily
-	 * pass owns them) and return `undefined`.
-	 */
-	request(repoPath: string, task: GitMaintenanceTask): Promise<boolean> | undefined;
-	/**
-	 * Atomically claims the once-per-`intervalMs` maintenance pass for this repo, stamping the shared
-	 * `gk.maintenanceLastRun` if and only if the claim succeeds. Returns `false` when another window already
-	 * holds it. Read-then-write from the host would not be atomic across VS Code windows, so the claim lives
-	 * here where it can be taken under a real file lock.
-	 */
-	claimMaintenancePass(repoPath: string, intervalMs: number): Promise<boolean>;
-	/**
-	 * Runs a single maintenance task. Resolves `true` when a supported invocation completed and `false` when
-	 * it is not applicable. With `auto`, Git evaluates its native condition and may intentionally do no work.
-	 * A genuine command failure THROWS. `commit-graph` writes directly (2.24+); other tasks go through
-	 * `git maintenance run --task=…` (2.30+).
-	 */
-	runMaintenanceTask(
-		repoPath: string,
-		task: GitMaintenanceTask,
-		options?: { readonly auto?: boolean; readonly cancellation?: AbortSignal },
-	): Promise<boolean>;
-	/**
-	 * Applies an optimization lever. Returns `true` when it took effect; `false` for a legitimate
-	 * not-applicable outcome (e.g. the FSMonitor daemon wouldn't start, or the untracked cache failed git's
-	 * filesystem probe — the config is restored and the repo recorded not-applicable so it's never
-	 * re-suggested). A genuine command failure (config write refused, `maintenance start` errored) THROWS.
-	 * Before mutating, the lever's prior value is recorded so {@link revertOptimization} can restore it.
-	 */
-	applyOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<boolean>;
-	/**
-	 * Reverts a lever GitLens applied back to its recorded prior value (never a hardcoded inverse). A no-op
-	 * when GitLens didn't apply it (no ownership marker) — a user-enabled lever is never touched. A genuine
-	 * command failure THROWS.
-	 */
-	revertOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<void>;
-	/**
-	 * Enables or disables GitLens's automatic commit-graph maintenance for this repo — a per-repository off
-	 * switch, distinct from the global `gitlens.gitOptimizations.enabled` master switch. Writes the
-	 * `gk.commitGraphDisabled` marker when disabling; clears it when re-enabling (tolerating an
-	 * already-absent marker). User-clicked, so a genuine write failure THROWS.
-	 */
-	setCommitGraphDisabled(repoPath: string, disabled: boolean, cancellation?: AbortSignal): Promise<void>;
-}

package/src/git/providers/operations.ts

@@ -1,164 +0,0 @@
-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;
-	/** Populated when {@link conflicted} is `true`. May be empty if the conflict file list couldn't be read. */
-	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; noTracking?: boolean },
-		runOptions?: GitOperationRunOptions,
-	): Promise<void>;
-	cherryPick(
-		repoPath: string,
-		revs: string[],
-		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
-		runOptions?: GitOperationRunOptions,
-	): Promise<GitOperationResult>;
-	commit(
-		repoPath: string,
-		message: string,
-		options?: {
-			all?: boolean;
-			allowEmpty?: boolean;
-			amend?: boolean;
-			author?: string;
-			date?: string;
-			signoff?: boolean;
-			source?: unknown;
-		},
-		runOptions?: GitOperationRunOptions,
-	): Promise<void>;
-	fetch(
-		repoPath: string,
-		options?: {
-			all?: boolean | undefined;
-			branch?: GitBranchReference | undefined;
-			prune?: boolean | undefined;
-			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,
-		options?: {
-			branch?: GitBranchReference | undefined;
-			rebase?: boolean | undefined;
-			tags?: boolean | undefined;
-			source?: unknown;
-		},
-		runOptions?: GitOperationRunOptions,
-	): Promise<void>;
-	push(
-		repoPath: string,
-		options?: {
-			reference?: GitReference | undefined;
-			force?: boolean | undefined;
-			publish?: { remote: string };
-		},
-		runOptions?: GitOperationRunOptions,
-	): Promise<void>;
-	rebase(
-		repoPath: string,
-		upstream: string,
-		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;
-			/**
-			 * Tri-state autosquash control. `true` passes `--autosquash`, folding every pending
-			 * `fixup!`/`squash!` commit into its target and reordering the todo accordingly; `false` passes
-			 * `--no-autosquash`, explicitly overriding a `rebase.autosquash=true` git config (omitting the
-			 * flag would let the config fold anyway); `undefined` passes neither, deferring to git config.
-			 * `true` is mutually exclusive with {@link programmaticEditor}, which forces
-			 * `rebase.autosquash=false` so its script-based editor sees a plain, natural-order todo —
-			 * combining them is a programmer error; the CLI provider throws rather than silently dropping one.
-			 */
-			autosquash?: 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;
-			/** `true` → `--update-refs`, `false` → `--no-update-refs`, omitted → git config (`rebase.updateRefs`) decides. */
-			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/patch.ts

@@ -1,31 +0,0 @@
-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>;
-}