@gitkraken/core-gitlens 0.5.113 → 0.5.115

package/dist/git-cli/providers/maintenance.d.ts

@@ -0,0 +1,306 @@
+import type { Cache } from '../../git/cache.js';
+import type { GitServiceContext } from '../../git/context.js';
+import type { GitHealthDetails, GitHealthSnapshot, GitMaintenanceSubProvider, GitMaintenanceTask, GitOptimizationCapability, GitOptimizationId } from '../../git/providers/maintenance.js';
+import type { CliGitProviderInternal } from '../cliGitProvider.js';
+import type { Git } from '../exec/git.js';
+export declare class MaintenanceGitSubProvider implements GitMaintenanceSubProvider {
+    private readonly context;
+    private readonly git;
+    private readonly cache;
+    private readonly provider;
+    constructor(context: GitServiceContext, git: Git, cache: Cache, provider: CliGitProviderInternal);
+    private readonly commitGraphWrittenAt;
+    private readonly commitGraphWriteInflight;
+    request(repoPath: string, task: GitMaintenanceTask): Promise<boolean> | undefined;
+    /**
+     * Opportunistically refreshes git's commit-graph (the demand cadence behind `request('commit-graph')`).
+     * Without one that COVERS the history, any ordered walk (`--date-order`/`--topo-order` — exactly the
+     * graph's initial load) must inflate every commit object to sort BEFORE the first row can be emitted,
+     * costing a full-history walk per open; the commit-graph also accelerates `git log`, merge-base, and
+     * ahead/behind across the whole extension. It's a standard acceleration cache (`git gc`/`git maintenance`
+     * write it routinely) and is always safe to delete. Fire-and-forget: refreshed at most every few minutes
+     * per object database (a current chain makes the write a near-no-op), at background queue priority,
+     * failures swallowed. Cross-WINDOW writes aren't coordinated here — git's own `commit-graph-chain.lock`
+     * serializes them; a loser errors and is swallowed. Resolves `true` only when the write completes; the
+     * health service uses that signal for one post-write freshness probe, while graph consumers ignore it.
+     */
+    private ensureCommitGraph;
+    /** Shared opt-out gate for automatic and explicit writes. */
+    private isCommitGraphWriteDisabled;
+    /**
+     * The commit-graph write itself. Always a `--split` write: mere existence isn't enough (a stale or thin
+     * chain — e.g. one auto-gc increment — accelerates nothing); `--split` appends an incremental layer
+     * covering only the uncovered commits (near-no-op when current) and git self-merges layers by its
+     * geometric policy. Background priority: a first write on a huge repo can run for a while and must never
+     * hold a queue slot ahead of interactive work. Throws on failure — callers decide whether to swallow.
+     */
+    private writeCommitGraph;
+    /** Config-only partial/promisor detection; never examines an object and therefore cannot itself lazy-fetch. */
+    private isPartialClone;
+    /** Honors an explicit MIDX opt-out on both automatic and user-invoked incremental repacks. */
+    private isMultiPackIndexEnabled;
+    getHealthSnapshot(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthSnapshot>;
+    /**
+     * Reads all Git Health gk markers (not-applicable flags + `gk.applied.*` ownership) from ONE bulk
+     * `.git/gk/config` read (git lowercases the section + variable in `--get-regexp` output, preserving the
+     * `applied` subsection). A read failure degrades to all-false — the report just re-suggests, never crashes.
+     */
+    private probeGkMarkers;
+    getHealthDetails(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthDetails>;
+    private _capabilities;
+    getCapabilities(_repoPath: string): Promise<GitOptimizationCapability[]>;
+    private getCapabilitiesCore;
+    runMaintenanceTask(repoPath: string, task: GitMaintenanceTask, options?: {
+        readonly auto?: boolean;
+        readonly cancellation?: AbortSignal;
+    }): Promise<boolean>;
+    applyOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<boolean>;
+    revertOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<void>;
+    /**
+     * The Git Health per-repository commit-graph off switch (`gk.commitGraphDisabled`). Unlike the
+     * ownership markers above, this isn't a "record prior, then restore" lever — it's a plain flag with no
+     * underlying config value to protect — so it needs no marker lock; two windows toggling it concurrently
+     * just resolve to whichever write lands last.
+     */
+    setCommitGraphDisabled(repoPath: string, disabled: boolean, cancellation?: AbortSignal): Promise<void>;
+    private applyUntrackedCache;
+    /** Whether git's filesystem probe says the untracked cache can be used here (exit 0). */
+    private testUntrackedCacheSupport;
+    private applyFsmonitor;
+    private applyManyFiles;
+    /** Enables sparse-directory index entries for an existing cone-mode sparse checkout. */
+    private applySparseIndex;
+    /** Expands a sparse index only when this worktree's marker proves GitLens enabled it. */
+    private revertSparseIndex;
+    private runSparseCheckoutReapply;
+    /**
+     * The `git maintenance start` version gate for the current platform: launchctl/schtasks scheduling
+     * (win/mac) needs 2.31; Linux relies on a systemd timer (2.34), since 2.31–2.33 is cron-only and
+     * modern distros often ship without cron.
+     */
+    private get backgroundMaintenanceFeature();
+    private startBackgroundMaintenance;
+    private revertBackgroundMaintenance;
+    /**
+     * Records a config lever's prior LOCAL value (or the `unset` sentinel) under its ownership marker BEFORE
+     * mutating, so undo restores the exact prior and never a hardcoded inverse; the marker's presence also
+     * means "applied by GitLens" (so undo is never offered for a user-enabled lever).
+     */
+    private recordPriorAndMark;
+    /** The body of {@link recordPriorAndMark}, for callers already holding the marker lock. */
+    private recordPriorUnlocked;
+    /**
+     * Reconciles write-ahead records left by an interrupted direct config mutation. The cached namespace read
+     * keeps the normal probe free of extra subprocesses; an actual pending record is re-read under the marker
+     * lock before it is finalized or cleared.
+     */
+    private reconcilePendingConfigChanges;
+    /** Body of {@link reconcilePendingConfigChanges} for a caller already holding the marker lock. */
+    private reconcilePendingConfigChangesUnlocked;
+    /**
+     * Applies direct config levers for a caller holding the ownership-marker lock. A write-ahead record closes
+     * the crash gap between the local config and ownership files; an ordinary failure restores every config
+     * value and marker without cancellation.
+     */
+    private applyConfigChangesUnlocked;
+    claimMaintenancePass(repoPath: string, intervalMs: number): Promise<boolean>;
+    /** The `.git/gk/` directory (common dir, so worktrees of a repo share it). */
+    private getGkDir;
+    private getSparseIndexMarkerPaths;
+    /**
+     * Reconciles the sparse-index command's worktree-local write-ahead marker. The fast path is filesystem
+     * only; a pending or stale-applied marker takes the worktree's sparse-index operation lock and re-reads
+     * Git config before mutating anything, so it cannot act on a snapshot that raced another window's
+     * apply/undo. A live operation keeps that lock across the index rewrite, but snapshots never wait for it:
+     * they return the last committed marker state until the operation publishes its result.
+     */
+    private reconcileSparseIndexMarkers;
+    /** Body of {@link reconcileSparseIndexMarkers} for a caller already holding the ownership lock. */
+    private reconcileSparseIndexMarkersUnlocked;
+    /** Reads the effective worktree-scoped sparse-index switch without relying on a cached config map. */
+    private probeSparseIndexEnabled;
+    /** Reads an ownership marker straight from `.git/gk/config`, bypassing every cache. */
+    private readGkMarkerUncached;
+    /**
+     * Runs `fn` holding an exclusive on-disk lock over one ownership-marker scope. By default that is the
+     * repository family's config-marker scope; callers can provide a worktree-local lock location for an
+     * operation whose state is isolated per worktree. Two layers make this safe across processes:
+     *
+     * - **Exclusive-create ownership, with an identity record.** `open(lockPath, 'wx')` — the same `O_EXCL`
+     *   primitive git uses for its own `*.lock` files — is the only atomic step; a contender that loses the
+     *   race retries for up to `maxAttempts`, then fails loudly rather than proceeding unlocked (see below).
+     *   The winner immediately writes its host, pid, and a fresh random `ownerId` into the lock file — an
+     *   identity record, not a liveness lease, since nothing here ever acts on it while another holder is
+     *   still running.
+     * - **Ownership-verified release.** On the way out, the lock file is removed only if its `ownerId` still
+     *   matches the one this call wrote — a fresh random value per acquisition can't collide with a
+     *   re-created lock the way an inode COULD in principle on some filesystems, so it's the primary check;
+     *   the inode is also compared as a cheap secondary one.
+     *
+     * A lock left behind by a crashed window is deliberately NOT recovered automatically. Two designs were
+     * tried and rejected. Time-based leasing can't tell a dead owner from a slow one — an age alone doesn't
+     * distinguish them (git timeouts are user-configurable, and can be disabled entirely), and making it tell
+     * them apart takes a full lease-plus-fencing-token protocol this lock has no need for otherwise.
+     * Automatic stealing (rename the lock aside once a PID probe says its owner is provably dead) was tried
+     * next, and is unsound for a different reason: automatic recovery of an abandoned fixed-path lock cannot
+     * be made race-free using only the portable stock-Node primitives available here (exclusive-create and
+     * rename) — every recovery attempt separates observation from mutation, so a delayed stealer can rename
+     * away a NEW, live lock a fresh contender created in the gap between the probe and the rename, evicting a
+     * holder that was never dead. Kernel-managed advisory locking (`flock`) would close that gap, but Node
+     * exposes no portable interface to it and a native, platform-sensitive dependency is disproportionate
+     * here. Therefore a contender NEVER mutates an existing lock — only the creator removes one, and no stale
+     * observation can authorize mutation. Recovery is a guided MANUAL step instead: a give-up runs the same PID
+     * probe ONCE, purely to choose the error's wording. For the sparse-operation lock, a confirmed-live owner gets
+     * wait-only guidance, a confirmed-dead owner gets crash-recovery guidance, and an unverifiable owner gets the
+     * lock path plus guarded manual-recovery guidance. The shared marker lock retains its generic non-dead error.
+     * No verdict authorizes an automatic steal.
+     *
+     * Because a live holder can't lose its lock, `fn` needs no cancellation coupling to the lock itself — the
+     * critical section only ever ends on its own terms.
+     *
+     * Acquisition beyond the initial `open` is not atomic: the ownership record is written in a separate step
+     * just after. A crash landing exactly there — not caught by anything, since the process is gone — leaves
+     * a permanently-empty orphan lock; the give-up error's manual-deletion instructions are the only recovery
+     * for that case, same as for a confirmed-dead owner. A failure our OWN code can observe in that window
+     * (the post-`mkdir` setup, or the ownership write itself) is different: it fails closed, removing the
+     * lock it just created — ownership is certain there, since we hold the only handle — before rethrowing,
+     * so a transient error (e.g. `ENOSPC`) never strands a lock nothing can ever prove dead.
+     *
+     * Deliberately NOT named `config.lock` — that's the name git takes when writing `.git/gk/config` itself.
+     */
+    private withMarkerLock;
+    /**
+     * Diagnoses the process recorded in `lockPath` for the give-up error's wording ONLY — see
+     * `withMarkerLock`'s doc comment for why a verdict never causes an automatic steal. Returns 'dead' only when
+     * the OS kill-probe returns `ESRCH`, 'alive' when it succeeds, and 'unverifiable' for unreadable/malformed
+     * content, a lock recorded on another host, or a probe that fails with anything but `ESRCH`.
+     */
+    private probeLockOwner;
+    /**
+     * Reverts a config lever GitLens applied: restores its recorded prior LOCAL value (set it back, or unset
+     * when the prior was absent) and clears the marker. Returns `false` (a no-op) when no marker exists —
+     * a lever the user enabled themselves is never touched.
+     */
+    private revertConfigLever;
+    /** Restores a lever's config to its recorded prior after a failed apply, then drops the ownership marker. */
+    private restorePriorAndClear;
+    /** Sets a local config value back to a recorded prior, decoding the `unset`/`empty` sentinels. */
+    private restoreLocalConfig;
+    /** Writes a gk marker, swallowing+logging any failure — a marker write must never fail the apply itself. */
+    private markGkConfigSafe;
+    /**
+     * Throws when a run that swallowed its errors (`errors: 'ignore'`) was actually cancelled or never ran.
+     * Such a run resolves with no meaningful exit code, so `completion` — not `exitCode` — is the only thing
+     * that proves a command ran. Without this a timeout reads as a clean success, and a safety probe or an
+     * undo would act on a command that never happened.
+     */
+    private throwIfDidNotComplete;
+    /**
+     * Reads a config key's LOCAL-scope value (independent of global/system config). `undefined` when unset.
+     *
+     * Uses `--get-regex` (anchored to the exact key), not `--get`: `--get` exits 0 with EMPTY stdout for
+     * BOTH a bareword entry (`[section]\n\tkey`, valid syntax, git-boolean TRUE) and an explicit empty value
+     * (`key =`, git-boolean FALSE) — indistinguishable, which would record a bareword-true prior as the
+     * `unset` sentinel and let undo flip the user's true to false. `--get-regex` prints the two differently
+     * (a bareword line has no space; an empty value keeps a trailing one), which `parseConfigRegexOutput`'s
+     * `includeValueless` tells apart; for a multi-valued key it also prints every value in file order, so the
+     * LAST line in the map is still the `--get`-equivalent value.
+     */
+    private getLocalConfig;
+    /** Sets a LOCAL config value. Throws the git error on a genuine write failure (config refused). */
+    private setLocalConfig;
+    private unsetLocalConfig;
+    /** Best-effort run; returns the result so callers that must distinguish "didn't run" can check it. */
+    private runQuietly;
+    private probeConfig;
+    private _registeredMaintenanceRepos;
+    /** The global `maintenance.repo` list. Throws rather than reporting an unreadable list as "none". */
+    private readRegisteredMaintenancePaths;
+    /**
+     * `git maintenance register` stores the symlink-RESOLVED worktree path, while GitLens deliberately keeps
+     * the symlinked path as the repo path — so match against both spellings.
+     */
+    private matchesRegistered;
+    /** Each path plus its symlink-resolved spelling — `maintenance register` stores the resolved one. */
+    private resolveRegistrationCandidates;
+    /**
+     * Whether ANY worktree of this repo family is registered — the DETECTION question ("should we suggest
+     * this?"). Family-wide, because a sibling the user registered already covers the shared object database,
+     * and suggesting it again would leave two scheduled entries for one repo.
+     */
+    private isMaintenanceRegistered;
+    /**
+     * Whether ONE specific path is registered — the OWNERSHIP question ("did our unregister take?"). Never
+     * ask this family-wide: a sibling the user registered is theirs, and it would block undo forever.
+     */
+    private isPathRegistered;
+    private readonly _worktreePaths;
+    /**
+     * Every worktree path of this repo, MAIN FIRST — git's `worktree list` order, which holds regardless of
+     * which worktree it runs from, and lists the repo itself for a bare one.
+     *
+     * `git maintenance register` records the CURRENT worktree's path, so a repo family can accumulate
+     * several `maintenance.repo` entries — several scheduled runs over a single shared object database —
+     * while the `gk.applied.*` ownership marker lives in the shared common git dir and can only describe
+     * one of them. GitLens therefore REGISTERS the main worktree ({@link resolveMaintenanceRepoPath}) but
+     * DETECTS across the whole family, so a registration the user made from a sibling isn't missed.
+     */
+    private resolveWorktreePaths;
+    /** The path GitLens registers for background maintenance: the repo's MAIN worktree. */
+    private resolveMaintenanceRepoPath;
+    private probeCommitGraph;
+    /**
+     * Whether the NEWEST commit-graph layer carries changed-path Bloom filters (the `BIDX` chunk). Only the
+     * newest layer matters here — `--changed-paths` computes filters for the just-written batch, so an older
+     * base layer written without them says nothing about current coverage. Reads only the header + chunk
+     * lookup table (a handful of bytes), never the graph body. Never throws — any failure (missing file, a
+     * malformed chain, a truncated read) reads as "no filters", matching every other probe in this file.
+     */
+    private probeChangedPathFilters;
+    /** The newest graph layer's file path: the chain's last-listed layer when split, else the single file. */
+    private resolveNewestCommitGraphLayer;
+    /**
+     * Reads a commit-graph file's fixed 8-byte header (`CGPH` magic, version, hash version, chunk count,
+     * base-graph count) plus the chunk lookup table (`(chunkCount + 1)` entries of 4-byte id + 8-byte
+     * big-endian offset), and reports whether a `BIDX` (Bloom-filter-index) chunk id is present. Bounded to
+     * the header + table only — never reads the graph body.
+     */
+    private hasBloomFilterChunk;
+    /**
+     * Reads the pack names represented by the active classic or incremental MIDX. A classic MIDX wins when
+     * both layouts exist, matching Git's own lookup order. Malformed metadata is reported as unknown instead
+     * of treating every pack as uncovered and silently launching repair work.
+     */
+    private probeMultiPackIndex;
+    /** Reads and validates the `PNAM` chunk of one MIDX file. */
+    private readMultiPackIndexPackNames;
+    private probePacks;
+    private sampleLooseObjects;
+    /**
+     * Counts loose refs without traversing past the point where the recommendation decision is already made.
+     * `readDirectory` is a test seam for deterministic ref-layout races between parent and child reads.
+     */
+    private probeLooseRefs;
+    private statMtime;
+    /** Presence probe that distinguishes a missing path from an unreadable one. */
+    private probePathPresence;
+    private fileBytes;
+    /**
+     * Reads the index entry count straight from the index header — `DIRC` signature, version, entry count,
+     * all big-endian, the first 12 bytes of `.git/index` — for free, no `git` invocation needed.
+     * `undefined` on any failure (missing index, short read, wrong signature): never a guess, never a throw.
+     */
+    private probeIndexEntryCount;
+    /**
+     * Conservative split-index detection without spawning git or scanning index bodies. A shared-index file
+     * proves this worktree uses split indexes; its largest base file is included in the byte-size proxy. Stale
+     * bases can only make that explicitly-approximate signal larger.
+     */
+    private probeSharedIndex;
+    /**
+     * Conflict stages duplicate paths in the header count. Operation-state files conservatively suppress the
+     * exact claim without an unconditional `ls-files --unmerged` index scan on every staging event.
+     */
+    private probeConflictOperation;
+}
+//# sourceMappingURL=maintenance.d.ts.map

package/dist/git-cli/providers/maintenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maintenance.d.ts","sourceRoot":"","sources":["../../../src/git-cli/providers/maintenance.ts"],"names":[],"mappings":"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"}