@gitkraken/core-gitlens 0.6.0 → 0.7.1

package/src/git/features.ts

@@ -1,98 +0,0 @@
-// GitFeature's must start with `git:` to be recognized in all usages
-export type GitFeatures =
-	| 'git:checkout:pathspec-from-file'
-	| 'git:commit-graph'
-	| 'git:commit-graph:changed-paths'
-	| 'git:for-each-ref:worktreePath'
-	| 'git:fsmonitor'
-	| 'git:fsmonitor:linux'
-	| 'git:ignoreRevsFile'
-	| 'git:index:skipHash'
-	| 'git:maintenance'
-	| 'git:maintenance:pack-refs'
-	| 'git:maintenance:start'
-	| 'git:maintenance:start:systemd'
-	| 'git:manyFiles'
-	| 'git:merge-tree'
-	| 'git:merge-tree:write-tree'
-	| 'git:push:force-if-includes'
-	| 'git:rebase:autosquash'
-	| 'git:rev-parse:end-of-options'
-	| 'git:signing:ssh'
-	| 'git:signing:x509'
-	| 'git:sparse-index'
-	| 'git:stash:push:pathspecs'
-	| 'git:stash:push:staged'
-	| 'git:stash:push:stdin'
-	| 'git:status:find-renames'
-	| 'git:status:porcelain-v2'
-	| 'git:untrackedCache'
-	| 'git:worktrees';
-
-type ExtractPrefix<T> = T extends `${infer Prefix}:${infer Rest}`
-	? Rest extends `${infer SubPrefix}:${string}`
-		? T | `${Prefix}:${SubPrefix}` | Prefix
-		: T | Prefix
-	: never;
-
-export type GitFeatureOrPrefix = ExtractPrefix<GitFeatures>;
-export type FilteredGitFeatures<T extends GitFeatureOrPrefix> = T extends GitFeatures
-	? T
-	: Extract<GitFeatures, T | `${T}:${string}`>;
-
-export const gitMinimumVersion = '2.7.2';
-export const gitFeaturesByVersion = new Map<GitFeatures, string>([
-	['git:checkout:pathspec-from-file', '2.26'],
-	// 2.24 is when git READS the commit-graph file by default (core.commitGraph on); writing it for
-	// older gits would be dead weight.
-	['git:commit-graph', '2.24'],
-	// Changed-path Bloom filters (`--changed-paths`), the v2 filter format — pre-2.31 shipped Bloom filters
-	// with real correctness bugs (bad results for merge commits), so 2.31 is the safe floor to write them.
-	['git:commit-graph:changed-paths', '2.31'],
-	['git:for-each-ref:worktreePath', '2.23'],
-	// `core.fsmonitor=true` selects the built-in FSMonitor daemon (accepting a bool rather than only a
-	// hook path). This 2.37 floor is the Windows + macOS one.
-	['git:fsmonitor', '2.37'],
-	// Linux got its own FSMonitor backend (inotify) only in 2.55, hence a separate floor. Note the backend
-	// places a watch on EVERY directory, so a large repo can exhaust `fs.inotify.max_user_watches` and the
-	// daemon fails at runtime even on a new enough git — the apply path must still probe, not just gate.
-	['git:fsmonitor:linux', '2.55'],
-	['git:ignoreRevsFile', '2.23'],
-	// `index.skipHash` (skip the trailing index checksum for faster writes); part of `feature.manyFiles`.
-	['git:index:skipHash', '2.40'],
-	// `git maintenance run --task=…`. The `maintenance` builtin + `commit-graph`/`gc` tasks are 2.29, but
-	// the loose-objects + incremental-repack tasks the auto tier uses landed in 2.30 (and `core.multiPackIndex`
-	// is default-on from 2.30, so no separate midx config write is needed) — 2.30 is the safe floor.
-	['git:maintenance', '2.30'],
-	// The pack-refs maintenance task landed one release after the maintenance builtin.
-	['git:maintenance:pack-refs', '2.31'],
-	// `git maintenance start` — the subcommands exist from 2.30 (cron only); launchctl (macOS) + schtasks
-	// (Windows) scheduling arrived in 2.31, so 2.31 is the cross-platform-safe floor.
-	['git:maintenance:start', '2.31'],
-	// `git maintenance start` systemd-timer scheduling. On Linux, 2.31–2.33 is cron-only and modern distros
-	// often ship without cron (scheduling then silently fails); the systemd fallback arrived in 2.34.
-	['git:maintenance:start:systemd', '2.34'],
-	// `feature.manyFiles` umbrella (index v4 + untracked cache + skipHash where available).
-	['git:manyFiles', '2.24'],
-	['git:merge-tree', '2.33'],
-	['git:merge-tree:write-tree', '2.38'],
-	['git:push:force-if-includes', '2.30.0'],
-	// `--autosquash` WITHOUT `-i` (folding `fixup!`/`squash!` commits into a plain/automatic rebase).
-	// Interactive rebases support autosquash on every git version GitLens supports, so this floor only
-	// gates the non-interactive path.
-	['git:rebase:autosquash', '2.44'],
-	['git:rev-parse:end-of-options', '2.30'],
-	['git:signing:ssh', '2.34.0'],
-	['git:signing:x509', '2.19.0'],
-	// Sparse-index support debuted earlier, but 2.33 shipped a corruption fix and 2.34 broadened command
-	// support. Use 2.34 as the conservative floor before offering a repository mutation.
-	['git:sparse-index', '2.34'],
-	['git:stash:push:pathspecs', '2.13.2'],
-	['git:stash:push:staged', '2.35.0'],
-	['git:stash:push:stdin', '2.30.0'],
-	['git:status:find-renames', '2.18'],
-	['git:status:porcelain-v2', '2.11'],
-	// `core.untrackedCache=true` (repo-local cache of untracked-file scans — the auto-tier config lever).
-	['git:untrackedCache', '2.8'],
-	['git:worktrees', '2.17.0'],
-]);

package/src/git/gitHealth.ts

@@ -1,522 +0,0 @@
-import type {
-	GitHealthSnapshot,
-	GitMaintenanceTask,
-	GitOptimizationCapability,
-	GitOptimizationId,
-} from './providers/maintenance.js';
-
-/**
- * Pure recommendation engine for the Git Health feature — no vscode imports, trivially unit-testable.
- * Thresholds are initial, tunable, telemetry-informed values (see `.work/dev/git-health/spec.md`).
- */
-
-/** Working-tree size (via the index-bytes proxy) at/above which untracked-cache/fsmonitor/manyFiles help. */
-export const trackedFilesThreshold = 10_000;
-/** Loose-object estimate at/above which the `loose-objects` maintenance task is worth running. */
-export const looseObjectsThreshold = 5_000;
-/** Git's default uncovered-pack threshold for the `incremental-repack` auto condition. */
-export const packsOutsideMultiPackIndexThreshold = 10;
-/** Loose refs at/above which packing the files ref backend avoids repeated filesystem traversal. */
-export const looseRefsThreshold = 256;
-/** Total pack bytes at/above which a repo counts as "clearly large" for the banner gate (~1 GiB). */
-export const largePackBytesThreshold = 1024 ** 3;
-/** Rough bytes-per-entry of a git v2 index — turns `.git/index` size into a tracked-file-count proxy. */
-export const approxBytesPerIndexEntry = 80;
-/** Duration (ms) above which a git command is "slow" — mirrors the exec-layer slow-call threshold. */
-export const slowCommandThresholdMs = 2000;
-
-/** Git operation families whose runtime maps to a distinct repository optimization surface. */
-export type GitHealthSlownessCategory = 'worktree' | 'history' | 'refs' | 'objects';
-
-/** Persisted passive-slowness sample for one operation family. */
-export interface GitHealthSlownessSample {
-	/** Number of slow git commands observed for this repo. */
-	readonly count: number;
-	/** Epoch ms of the most recent slow command. */
-	readonly lastAt: number;
-	/** Longest single slow-command duration observed (ms). */
-	readonly maxDurationMs: number;
-}
-
-/** Per-repo passive-slowness summary, split so recommendations only target the affected operation family. */
-export type GitHealthSlowness = Partial<Record<GitHealthSlownessCategory, GitHealthSlownessSample>>;
-
-export type GitOptimizationTier = 'auto' | 'ask';
-
-/** Coarse duration buckets for maintenance telemetry. */
-export type GitHealthDurationBucket = '<1s' | '1-5s' | '5-15s' | '15-60s' | '>60s';
-
-/** Which measured signal tripped a finding (drives view copy + telemetry buckets). */
-export type GitHealthFindingReason =
-	| 'looseObjects'
-	| 'looseRefs'
-	| 'packsOutsideMultiPackIndex'
-	| 'trackedFiles'
-	| 'largePacks'
-	| 'worktreeSlowness';
-
-/** A single recommendation: a lever to apply, its tier, and the evidence that triggered it. */
-export interface GitHealthFinding {
-	readonly tier: GitOptimizationTier;
-	readonly reason: GitHealthFindingReason;
-	/** The measured value that crossed the threshold. */
-	readonly value: number;
-	/** The threshold it crossed. */
-	readonly threshold: number;
-	/** The concrete action this finding recommends. */
-	readonly action:
-		| { readonly kind: 'maintenance'; readonly task: GitMaintenanceTask }
-		| { readonly kind: 'optimization'; readonly id: GitOptimizationId };
-}
-
-export interface GitHealthReport {
-	readonly findings: readonly GitHealthFinding[];
-	/** Repository shape that scopes local history, object, and working-tree measurements. */
-	readonly repository: GitHealthSnapshot['repository'];
-	/** Whether the repo is "clearly large" (any working-tree threshold met, or pack bytes ≥ ~1 GiB). */
-	readonly clearlyLarge: boolean;
-	/** Extrapolated loose-object count (from the probe sample). */
-	readonly estimatedLooseObjects: number;
-	/** Loose refs found by the bounded files-backend probe. */
-	readonly looseRefs: { readonly count: number; readonly exact: boolean };
-	/** Repository-size signal from the index; see {@link trackedFilesScope} for how to interpret it. */
-	readonly estimatedTrackedFiles: number;
-	/** `true` when {@link estimatedTrackedFiles} is the exact repository-wide count from a normal index. */
-	readonly trackedFilesExact: boolean;
-	/** Whether the displayed count covers the repository, a sparse working set, or is only a byte-size estimate. */
-	readonly trackedFilesScope: 'repository' | 'sparseWorkingTree' | 'estimate';
-	readonly packCount: number;
-	readonly packsOutsideMultiPackIndex: number | undefined;
-	readonly packBytes: number;
-	readonly commitGraph: {
-		readonly present: boolean;
-		readonly mtime: number | undefined;
-		readonly changedPaths: boolean;
-		readonly changedPathsSupported: boolean;
-		readonly disabled: boolean;
-		/** `core.commitGraph` explicitly false in git config — git won't read the cache, GitLens won't write it. */
-		readonly readDisabled: boolean;
-	};
-}
-
-/**
- * Extrapolates total loose-object count from a uniform sample of the 256 object fanout dirs. Loose
- * objects distribute uniformly by sha prefix, so `(objectsInSampled / dirsSampled) * 256` is sound.
- */
-export function estimateLooseObjects(objectsInSampled: number, dirsSampled: number): number {
-	if (dirsSampled <= 0) return 0;
-
-	return Math.round((objectsInSampled / dirsSampled) * 256);
-}
-
-/** Turns `.git/index` byte size into an approximate tracked-file count. */
-export function estimateTrackedFiles(indexBytes: number): number {
-	if (indexBytes <= 0) return 0;
-
-	return Math.round(indexBytes / approxBytesPerIndexEntry);
-}
-
-/**
- * Computes the {@link GitHealthReport} from a cheap probe, passive slowness, and capabilities. Findings
- * are only emitted for levers that are supported, not already applied, and past their threshold.
- */
-export function computeHealthReport(
-	snapshot: GitHealthSnapshot,
-	slowness: GitHealthSlowness | undefined,
-	capabilities: readonly GitOptimizationCapability[],
-): GitHealthReport {
-	const estimatedLooseObjects = estimateLooseObjects(
-		snapshot.looseObjects.objectsInSampledDirs,
-		snapshot.looseObjects.dirsSampled,
-	);
-	// A normal index header is the exact tracked-file count. A sparse index header is still a useful exact
-	// count of its populated working set, but not of the whole repository. A split index header covers only
-	// the mutable layer and conflict stages duplicate paths, so neither raw count is used.
-	const useIndexEntryCount =
-		snapshot.indexEntryCount != null &&
-		(snapshot.indexEntryCountType === 'full' || snapshot.indexEntryCountType === 'sparse');
-	const estimatedTrackedFiles = useIndexEntryCount
-		? snapshot.indexEntryCount
-		: estimateTrackedFiles(snapshot.indexBytes);
-	const trackedFilesExact = useIndexEntryCount && snapshot.indexEntryCountType === 'full';
-	const trackedFilesScope = trackedFilesExact
-		? 'repository'
-		: useIndexEntryCount && snapshot.indexEntryCountType === 'sparse'
-			? 'sparseWorkingTree'
-			: 'estimate';
-	const largeWorkingTree = estimatedTrackedFiles >= trackedFilesThreshold;
-	const clearlyLarge = largeWorkingTree || snapshot.packBytes >= largePackBytesThreshold;
-
-	const supported = (id: GitOptimizationId): boolean => capabilities.find(c => c.id === id)?.supported === true;
-
-	const findings: GitHealthFinding[] = [];
-
-	// Auto tier — safe `git maintenance run` one-shots (gated on `git maintenance` support).
-	if (snapshot.supportsMaintenanceRun) {
-		if (estimatedLooseObjects >= looseObjectsThreshold) {
-			findings.push({
-				tier: 'auto',
-				reason: 'looseObjects',
-				value: estimatedLooseObjects,
-				threshold: looseObjectsThreshold,
-				action: { kind: 'maintenance', task: 'loose-objects' },
-			});
-		}
-		const incrementalRepackThreshold = snapshot.incrementalRepackAutoThreshold;
-		const incrementalRepackDue =
-			snapshot.multiPackIndexEnabled === true &&
-			snapshot.packsOutsideMultiPackIndex != null &&
-			incrementalRepackThreshold != null &&
-			incrementalRepackThreshold !== 0 &&
-			(incrementalRepackThreshold < 0
-				? snapshot.packCount > 0
-				: snapshot.packsOutsideMultiPackIndex >= incrementalRepackThreshold);
-		if (incrementalRepackDue) {
-			findings.push({
-				tier: 'auto',
-				reason: 'packsOutsideMultiPackIndex',
-				value: snapshot.packsOutsideMultiPackIndex,
-				threshold: incrementalRepackThreshold,
-				action: { kind: 'maintenance', task: 'incremental-repack' },
-			});
-		}
-	}
-	if (
-		snapshot.supportsPackRefsMaintenance &&
-		snapshot.repository.refFormat === 'files' &&
-		snapshot.looseRefs.count >= looseRefsThreshold
-	) {
-		findings.push({
-			tier: 'auto',
-			reason: 'looseRefs',
-			value: snapshot.looseRefs.count,
-			threshold: looseRefsThreshold,
-			action: { kind: 'maintenance', task: 'pack-refs' },
-		});
-	}
-
-	// Large-working-tree levers share the same evidence; they differ only in tier and eligibility.
-	const trackedFilesEvidence = {
-		reason: 'trackedFiles',
-		value: estimatedTrackedFiles,
-		threshold: trackedFilesThreshold,
-	} as const;
-	const workingTreeLevers: { id: GitOptimizationId; tier: GitOptimizationTier; eligible: boolean }[] = [
-		{
-			id: 'untrackedCache',
-			tier: 'ask',
-			// Skip if already on, if it previously failed git's filesystem probe for this repo, or if the
-			// user set the key themselves — an explicit `false`/`keep` is a decision (often made after bad
-			// `git status` results), and this lever respects it rather than overriding it.
-			eligible:
-				!snapshot.config.untrackedCache &&
-				!snapshot.config.untrackedCacheConfigured &&
-				!snapshot.untrackedCacheNotApplicable,
-		},
-		{
-			id: 'fsmonitor',
-			tier: 'ask',
-			// Skip if already on or it previously failed to start for this repo.
-			eligible: !snapshot.config.fsmonitor && !snapshot.fsmonitorNotApplicable,
-		},
-		{
-			id: 'manyFiles',
-			tier: 'ask',
-			// `manyFiles` defaults the untracked cache on, so a repo whose filesystem already failed that
-			// probe must not be offered it either — unless the user's own explicit `core.untrackedCache`
-			// setting overrides the default, in which case the probe result is moot.
-			eligible:
-				!snapshot.config.manyFiles &&
-				!(snapshot.untrackedCacheNotApplicable && !snapshot.config.untrackedCacheConfigured),
-		},
-		{
-			id: 'sparseIndex',
-			tier: 'ask',
-			// Sparse-directory entries are safe only in cone mode. Require a normal full index so this
-			// recommendation is based on the repository-wide path count, not a split/conflicted approximation.
-			eligible:
-				snapshot.repository.sparseCheckout === true &&
-				snapshot.repository.sparseCheckoutCone === true &&
-				snapshot.repository.sparseIndex === false &&
-				snapshot.repository.splitIndex === false &&
-				snapshot.indexEntryCountType === 'full',
-		},
-	];
-	const worktreeSlowness = slowness?.worktree;
-	const worktreeSlownessObserved = (worktreeSlowness?.count ?? 0) > 0;
-	if (largeWorkingTree || worktreeSlownessObserved) {
-		const evidence: Pick<GitHealthFinding, 'reason' | 'value' | 'threshold'> = largeWorkingTree
-			? trackedFilesEvidence
-			: {
-					reason: 'worktreeSlowness',
-					value: worktreeSlowness?.maxDurationMs ?? 0,
-					threshold: slowCommandThresholdMs,
-				};
-		for (const lever of workingTreeLevers) {
-			if (!lever.eligible || !supported(lever.id)) continue;
-
-			findings.push({
-				tier: lever.tier,
-				...evidence,
-				action: { kind: 'optimization', id: lever.id },
-			});
-		}
-	}
-
-	// Ask tier — system-scheduled background maintenance. Suggested for a not-yet-registered repo that's
-	// clearly large. Passive slowness is deliberately NOT enough: worktree slowness maps to the worktree
-	// levers above, history is already covered by demand commit-graph writes, and ref/object maintenance has
-	// its own measured auto-tier conditions. A generic scheduler recommendation would promise the wrong fix.
-	// `=== false`, not falsy: `undefined` means the registration list couldn't be read, and an unknown state
-	// must never be suggested away — that's how a user's own registration gets silently reclaimed by Undo.
-	if (clearlyLarge && snapshot.maintenanceRegistered === false && supported('backgroundMaintenance')) {
-		// Resolve the evidence once so reason/value/threshold can never drift apart. Ordered so each
-		// suggestion argues from its most DISTINCTIVE signal rather than whichever crossed first: a repo
-		// large by both file count and pack bytes would otherwise attach the same tracked-files evidence to
-		// this finding as to the fsmonitor/manyFiles findings, and the view would show two identical meters.
-		let evidence: Pick<GitHealthFinding, 'reason' | 'value' | 'threshold'>;
-		if (snapshot.packBytes >= largePackBytesThreshold) {
-			evidence = { reason: 'largePacks', value: snapshot.packBytes, threshold: largePackBytesThreshold };
-		} else {
-			evidence = trackedFilesEvidence;
-		}
-		findings.push({
-			tier: 'ask',
-			...evidence,
-			action: { kind: 'optimization', id: 'backgroundMaintenance' },
-		});
-	}
-
-	return {
-		findings: findings,
-		repository: snapshot.repository,
-		clearlyLarge: clearlyLarge,
-		estimatedLooseObjects: estimatedLooseObjects,
-		looseRefs: snapshot.looseRefs,
-		estimatedTrackedFiles: estimatedTrackedFiles,
-		trackedFilesExact: trackedFilesExact,
-		trackedFilesScope: trackedFilesScope,
-		packCount: snapshot.packCount,
-		packsOutsideMultiPackIndex: snapshot.packsOutsideMultiPackIndex,
-		packBytes: snapshot.packBytes,
-		commitGraph: snapshot.commitGraph,
-	};
-}
-
-/**
- * What the view shows for one lever. Ownership is the load-bearing distinction: `applied` offers Undo
- * because GitLens recorded the exact prior; `userEnabled` offers nothing at all — there is nothing for
- * GitLens to undo, and a disabled control would imply otherwise.
- */
-export type GitHealthLeverStatus =
-	| 'suggested'
-	| 'applied'
-	| 'userEnabled'
-	/** Supported and usable here, just not worth recommending for this repo — NOT a failure. */
-	| 'available'
-	| 'unavailable'
-	| 'notApplicable';
-
-export interface GitHealthLever {
-	readonly id: GitOptimizationId;
-	readonly status: GitHealthLeverStatus;
-	readonly tier: GitOptimizationTier;
-	/** Why it can't be used here — rendered verbatim, never flattened to "unsupported". */
-	readonly reason?: string;
-	/** A consequence the person must see BEFORE choosing, not after. */
-	readonly note?: string;
-	/**
-	 * `true` when this lever's state could not be DETERMINED (e.g. the registration list was unreadable), as
-	 * opposed to a lever this git/platform doesn't support.
-	 */
-	readonly checkFailed?: boolean;
-}
-
-/** Consequences that reach beyond GitLens, surfaced on the apply action itself. */
-const leverNotes: Partial<Record<GitOptimizationId, string>> = {
-	backgroundMaintenance:
-		'Adds a task to your operating system’s scheduler. Undo unregisters this repository, but leaves the scheduler itself in place.',
-};
-
-/**
- * Collapses a snapshot + capabilities + report into the per-lever rows the Git Health view renders.
- * Pure, so the webview never re-derives ownership or eligibility rules that already live here.
- */
-export function computeLevers(
-	snapshot: GitHealthSnapshot,
-	capabilities: readonly GitOptimizationCapability[],
-	report: GitHealthReport,
-): GitHealthLever[] {
-	const suggested = new Set<GitOptimizationId>(
-		report.findings.flatMap(f => (f.action.kind === 'optimization' ? [f.action.id] : [])),
-	);
-
-	const enabled: Record<GitOptimizationId, boolean> = {
-		untrackedCache: snapshot.config.untrackedCache,
-		fsmonitor: snapshot.config.fsmonitor,
-		manyFiles: snapshot.config.manyFiles,
-		// `=== true`, not the raw (possibly `undefined`) value — an unreadable registration is handled as its
-		// own status below, and must never fall through to "enabled".
-		backgroundMaintenance: snapshot.maintenanceRegistered === true,
-		sparseIndex: snapshot.repository.sparseIndex === true,
-	};
-	const blocked: Partial<Record<GitOptimizationId, boolean>> = {
-		untrackedCache: snapshot.untrackedCacheNotApplicable,
-		fsmonitor: snapshot.fsmonitorNotApplicable,
-		manyFiles: snapshot.untrackedCacheNotApplicable && !snapshot.config.untrackedCacheConfigured,
-	};
-
-	return capabilities.map<GitHealthLever>(capability => {
-		const id = capability.id;
-		const note = capability.note ?? leverNotes[id];
-		// Every optimization lever is ask-tier now — the auto tier only ever runs maintenance tasks.
-		const tier: GitOptimizationTier = 'ask';
-
-		// Unavailable outranks everything: a lever the installed git or platform cannot do is never
-		// "suggested", whatever the thresholds say.
-		if (!capability.supported) {
-			return { id: id, status: 'unavailable', tier: tier, reason: capability.reason, note: note };
-		}
-		// An unreadable maintenance registration can't answer the ownership/suggestion questions below, so
-		// it gets its own status rather than falling through and being guessed as "not registered".
-		if (id === 'backgroundMaintenance' && snapshot.maintenanceRegistered === undefined) {
-			return {
-				id: id,
-				status: 'unavailable',
-				tier: tier,
-				reason: "Couldn't read Git's maintenance registration — try reopening the repository",
-				note: note,
-				checkFailed: true,
-			};
-		}
-		// Then ownership, which is what decides whether Undo is offered at all.
-		if (enabled[id]) {
-			return { id: id, status: snapshot.applied[id] ? 'applied' : 'userEnabled', tier: tier, note: note };
-		}
-		if (id === 'sparseIndex') {
-			if (
-				snapshot.repository.sparseCheckout == null ||
-				snapshot.repository.sparseCheckoutCone == null ||
-				snapshot.repository.sparseIndex == null ||
-				snapshot.repository.splitIndex == null
-			) {
-				return {
-					id: id,
-					status: 'unavailable',
-					tier: tier,
-					reason: "Couldn't determine this worktree’s sparse-checkout and index configuration",
-					note: note,
-					checkFailed: true,
-				};
-			}
-			if (!snapshot.repository.sparseCheckout) {
-				return {
-					id: id,
-					status: 'notApplicable',
-					tier: tier,
-					reason: 'This worktree is not using sparse checkout.',
-					note: note,
-				};
-			}
-			if (!snapshot.repository.sparseCheckoutCone) {
-				return {
-					id: id,
-					status: 'notApplicable',
-					tier: tier,
-					reason: 'Sparse indexes require cone-mode sparse checkout.',
-					note: note,
-				};
-			}
-			if (snapshot.repository.splitIndex || snapshot.indexEntryCountType === 'split') {
-				return {
-					id: id,
-					status: 'notApplicable',
-					tier: tier,
-					reason: 'This worktree uses a split index; disable it before enabling a sparse index.',
-					note: note,
-				};
-			}
-			if (snapshot.indexEntryCountType === 'conflicted') {
-				return {
-					id: id,
-					status: 'notApplicable',
-					tier: tier,
-					reason: 'Finish the current merge or rebase before enabling a sparse index.',
-					note: note,
-				};
-			}
-		}
-		// `notApplicable` means GitLens TRIED here and this repo can't use it — the gk marker records that.
-		// `capability.note` is the supported-with-caveat field, not an unavailability reason, so the
-		// explanation has to come from the marker's meaning instead.
-		if (blocked[id]) {
-			return {
-				id: id,
-				status: 'notApplicable',
-				tier: tier,
-				reason:
-					id === 'fsmonitor'
-						? 'The file system monitor could not start for this repository.'
-						: id === 'manyFiles'
-							? 'This would enable the untracked cache, but this file system does not report directory changes reliably, so Git would return incorrect status results.'
-							: 'This file system does not report directory changes reliably, so Git would return incorrect status results.',
-				note: note,
-			};
-		}
-
-		// Supported and usable, just below the thresholds — `available`, never `notApplicable`. Reporting
-		// a healthy repo's levers as unavailable tells the user something false.
-		return { id: id, status: suggested.has(id) ? 'suggested' : 'available', tier: tier, note: note };
-	});
-}
-
-/** Auto-tier maintenance tasks the daily pass should run right now (deduped, order-stable). */
-export function getAutoMaintenanceTasks(report: GitHealthReport): GitMaintenanceTask[] {
-	const tasks: GitMaintenanceTask[] = [];
-	for (const finding of report.findings) {
-		if (finding.tier === 'auto' && finding.action.kind === 'maintenance' && !tasks.includes(finding.action.task)) {
-			tasks.push(finding.action.task);
-		}
-	}
-	return tasks;
-}
-
-/** Auto-tier optimization levers the daily pass should silently apply — none today; the auto tier currently
- * applies only maintenance tasks, but this stays in place for future levers. */
-export function getAutoOptimizations(report: GitHealthReport): GitOptimizationId[] {
-	const ids: GitOptimizationId[] = [];
-	for (const finding of report.findings) {
-		if (finding.tier === 'auto' && finding.action.kind === 'optimization' && !ids.includes(finding.action.id)) {
-			ids.push(finding.action.id);
-		}
-	}
-	return ids;
-}
-
-/**
- * Banner rule: fire only when the report contains an ask-tier fix and the repo is clearly large or slow in
- * the working-tree family. History/ref/object slowness must not advertise unrelated worktree levers.
- */
-export function isBannerEligible(report: GitHealthReport, slowness: GitHealthSlowness | undefined): boolean {
-	const hasAskTierFix = report.findings.some(f => f.tier === 'ask');
-	const worktreeSlownessObserved = (slowness?.worktree?.count ?? 0) > 0;
-	return hasAskTierFix && (report.clearlyLarge || worktreeSlownessObserved);
-}
-
-/** Evidence-gated banner state for one repository — undefined when the banner has nothing to say. */
-export interface GitHealthBannerState {
-	/** Show the in-graph banner strip (eligible and not explicitly dismissed). */
-	readonly banner: boolean;
-	/** Show the evidence dot on the Visualizations & Health toggle (eligible, view not visited recently). */
-	readonly indicator: boolean;
-	/** Which evidence family armed it — measured worktree slowness, or repo scale alone. */
-	readonly reason: 'slowness' | 'large';
-	/** Worst observed slow-command duration (ms); present when reason is 'slowness'. */
-	readonly maxDurationMs?: number;
-	/** Tracked-file count evidence; present when reason is 'large'. */
-	readonly trackedFiles?: number;
-	/** Whether trackedFiles is exact (report.trackedFilesScope !== 'estimate'). */
-	readonly trackedFilesExact?: boolean;
-	/** Count of levers the health view will show as "suggested" — keep in sync with its verdict. */
-	readonly suggestedCount: number;
-}

package/src/git/models/author.ts

@@ -1,19 +0,0 @@
-import type { ProviderReference } from './remoteProvider.js';
-
-export interface CommitAuthor {
-	provider: ProviderReference;
-	readonly id: string | undefined;
-	readonly username: string | undefined;
-	name: string | undefined;
-	email: string | undefined;
-	avatarUrl: string | undefined;
-}
-
-export interface UnidentifiedAuthor extends CommitAuthor {
-	readonly id: undefined;
-	readonly username: undefined;
-}
-
-export interface Account extends CommitAuthor {
-	readonly id: string;
-}