@gitkraken/core-gitlens 0.16.5 → 0.17.0

package/dist/git/watching/worktreeSummary.js

@@ -3,7 +3,9 @@ import { CancellationError, isCancellationError, raceWithSignal } from "../../ut
 import { Logger as _logger } from "../../utils/logger.js";
 import { Emitter } from "../../utils/event.js";
 import { getRepositoryKey } from "../../utils/uri.js";
+import { joinPaths } from "../../utils/path.js";
 import { getRefChangeKind } from "./changeEvent.js";
+import { LruMap } from "../../utils/lruMap.js";
 //#region ../git/src/watching/worktreeSummary.ts
 /** Read groups, as bit flags so a pending set is a number rather than an allocation per event */
 const dirtyField = 1;
@@ -22,12 +24,32 @@ const baseMoveField = 32;
 const allFields = 7;
 const maxConcurrentReadsPerRepository = 4;
 const maxConcurrentReads = 8;
+const maxUnwatchedReads = 256;
 const emptyRefs = Object.freeze([]);
 const noBaseKeys = [
 	void 0,
 	void 0,
 	void 0
 ];
+/** A read of a worktree without a subscription, which concurrent callers share */
+var UnwatchedFlight = class {
+	key;
+	probeDirty;
+	disposed;
+	abort = new AbortController();
+	/** Callers waiting for it; the read is aborted once none is */
+	callers = 0;
+	/** Read groups made due while it ran, carried into what it stores */
+	due = 0;
+	promise;
+	constructor(key, probeDirty, disposed, read) {
+		this.key = key;
+		this.probeDirty = probeDirty;
+		this.disposed = disposed;
+		this.promise = Promise.resolve().then(() => read(this));
+		this.promise.catch(noop);
+	}
+};
 var SummarySubscription = class {
 	entry;
 	options;
@@ -107,6 +129,18 @@ var SummarySubscription = class {
 * fire only when some field's value differs from the previous summary — a recompute that reads the same answer is
 * silent, so a consumer can re-render on every event without diffing. A failed recompute keeps the last values and
 * sets `stale` (firing once); the next successful one clears it.
+*
+* **Worktrees without a subscription.** {@link getSummary} and {@link getSummarySnapshot} answer one from its last read
+* (kept for the {@link maxUnwatchedReads} most recently asked), re-reading only the groups whose inputs moved since:
+* HEAD's branch or commit reads all of them; the upstream's tip, or its name, reads `branch`; a ref the base depends on
+* (where a remote's `HEAD` symref points, for one) reads `base`, re-measured from the previous one where that can
+* answer; the config inputs its base read consulted read `branch` and the base when they changed; and the worktree's
+* index file reads `dirty`. The inputs come from core's caches, so nothing moved means no git at all; only a `.git`
+* watch of the worktree (or core's own writes) keeps them current, so a host must watch the `.git` of a worktree it
+* asks about this way for others' changes to show. Its working tree is unwatched, so an edit that leaves the index
+* alone goes unseen until `dirty` is read again: the snapshot says when that was, and `probeDirty` reads it anyway.
+* Concurrent reads of a worktree share one, and take no read slot: each is a caller's foreground read, which never
+* waits behind subscribed worktrees' runs.
 */
 var WorktreeSummaryService = class {
 	_onDidChangeSummary = new Emitter();
@@ -120,9 +154,14 @@ var WorktreeSummaryService = class {
 	activeReads = 0;
 	/** Entries waiting for a read slot, oldest first */
 	readWaiters = /* @__PURE__ */ new Map();
+	/** The last read of each worktree without a subscription, by repository key */
+	unwatchedReads = new LruMap(maxUnwatchedReads);
+	/** The read in flight for each worktree without a subscription, by repository key */
+	unwatchedFlights = /* @__PURE__ */ new Map();
 	watchService;
 	getRepository;
 	getCommonPath;
+	stat;
 	verifyBaseRemeasure;
 	mergeTargetsListener;
 	_disposed = false;
@@ -130,6 +169,7 @@ var WorktreeSummaryService = class {
 		this.watchService = options.watchService;
 		this.getRepository = options.getRepository;
 		this.getCommonPath = options.getCommonPath;
+		this.stat = options.stat;
 		this.verifyBaseRemeasure = options.verifyBaseRemeasure;
 		this.mergeTargetsListener = options.onDidChangeMergeTargets?.((e) => this.onMergeTargetsChanged(e));
 	}
@@ -141,6 +181,12 @@ var WorktreeSummaryService = class {
 		this._disposed = true;
 		for (const resolve of this.readWaiters.values()) resolve(false);
 		this.readWaiters.clear();
+		for (const flight of this.unwatchedFlights.values()) {
+			flight.disposed = true;
+			flight.abort.abort();
+		}
+		this.unwatchedFlights.clear();
+		this.unwatchedReads.clear();
 		this.mergeTargetsListener?.dispose();
 		for (const entry of [...this.entries.values()]) for (const subscription of [...entry.subscribers]) subscription.dispose();
 		this.entries.clear();
@@ -161,6 +207,8 @@ var WorktreeSummaryService = class {
 		target.subscribers.add(subscription);
 		if (isNew) {
 			if (!target.disposed) {
+				this.unwatchedReads.delete(key);
+				this.unwatchedFlights.delete(key);
 				target.pending = 23;
 				target.running = this.start(target);
 			}
@@ -173,21 +221,183 @@ var WorktreeSummaryService = class {
 	}
 	/**
 	* Returns a worktree's summary. For a subscribed worktree, the cached value — after waiting for any run in flight
-	* or pending; it rejects with the read's error when there is still no value. Otherwise a one-off full read that
-	* is neither cached nor watched.
+	* or pending; it rejects with the read's error when there is still no value. Otherwise the last read of it,
+	* re-reading what moved since (see {@link getSummarySnapshot}).
 	*/
 	async getSummary(repoPath, cancellation) {
 		const key = getRepositoryKey(repoPath);
 		const entry = this.entries.get(key);
-		if (entry == null) {
-			const repo = this.getRepository(key);
-			if (repo == null) throw new Error(`No repository found for '${key}'`);
-			return (await readSummary(repo, key, allFields, void 0, void 0, void 0, void 0, void 0, cancellation, this.verifyBaseRemeasure)).summary;
-		}
+		if (entry == null) return (await this.getUnwatchedSnapshot(key, false, cancellation)).summary;
+		return this.getSubscribedSummary(entry, cancellation);
+	}
+	/**
+	* Returns a worktree's summary, with when its dirty flag was read. A subscribed worktree answers as
+	* {@link getSummary} does, with `dirtyReadAt` `undefined`, since its summary follows its working tree. Any other
+	* answers from its last read, re-reading only the groups whose inputs moved since (no git when none did), and in
+	* full the first time, or after a failed or stale read. Its working tree is unwatched, so the dirty flag is re-read
+	* only when the index file moved, or with `probeDirty`; a rejection drops the last read. Its inputs are core's
+	* cached answers, which only a `.git` watch of the worktree (or core's own writes) keeps current.
+	*/
+	async getSummarySnapshot(repoPath, options) {
+		const key = getRepositoryKey(repoPath);
+		const entry = this.entries.get(key);
+		if (entry == null) return this.getUnwatchedSnapshot(key, options?.probeDirty ?? false, options?.cancellation);
+		return {
+			summary: await this.getSubscribedSummary(entry, options?.cancellation),
+			dirtyReadAt: void 0
+		};
+	}
+	async getSubscribedSummary(entry, cancellation) {
 		if (entry.running != null) await (cancellation != null ? raceWithSignal(entry.running, cancellation) : entry.running);
 		if (entry.disposed) throw new CancellationError();
 		if (entry.value != null) return entry.value;
-		throw entry.error ?? /* @__PURE__ */ new Error(`No summary available for '${key}'`);
+		throw entry.error ?? /* @__PURE__ */ new Error(`No summary available for '${entry.key}'`);
+	}
+	/** Joins the read in flight for `key`, or starts one; the read is aborted only once no caller waits for it */
+	async getUnwatchedSnapshot(key, probeDirty, cancellation) {
+		if (cancellation?.aborted) throw new CancellationError();
+		let flight = this.getJoinableFlight(key);
+		if (probeDirty) {
+			while (flight != null && !flight.probeDirty) {
+				const waited = flight;
+				try {
+					await (cancellation != null ? raceWithSignal(waited.promise, cancellation) : waited.promise);
+				} catch (ex) {
+					if (cancellation?.aborted) throw ex;
+				}
+				flight = this.getJoinableFlight(key);
+				if (flight === waited) flight = void 0;
+			}
+			const entry = this.entries.get(key);
+			if (entry != null) return {
+				summary: await this.getSubscribedSummary(entry, cancellation),
+				dirtyReadAt: void 0
+			};
+		}
+		if (flight == null) {
+			flight = new UnwatchedFlight(key, probeDirty, this._disposed, (f) => this.readUnwatched(f));
+			if (!this._disposed) this.unwatchedFlights.set(key, flight);
+		}
+		const current = flight;
+		current.callers++;
+		try {
+			const read = await (cancellation != null ? raceWithSignal(current.promise, cancellation) : current.promise);
+			return {
+				summary: read.result.summary,
+				dirtyReadAt: read.dirtyReadAt
+			};
+		} finally {
+			current.callers--;
+			if (current.callers === 0) {
+				if (this.unwatchedFlights.get(key) === current) this.unwatchedFlights.delete(key);
+				current.disposed = true;
+				current.abort.abort();
+			}
+		}
+	}
+	/**
+	* The read in flight for `key`, unless core wrote a merge target or base while it ran: it may have read the stored
+	* values before the write, and a caller after an awaited write sees them, as one of a subscribed worktree does
+	*/
+	getJoinableFlight(key) {
+		const flight = this.unwatchedFlights.get(key);
+		return flight?.due === 0 ? flight : void 0;
+	}
+	async readUnwatched(flight) {
+		const { key } = flight;
+		const signal = flight.abort.signal;
+		if (flight.disposed) throw new CancellationError();
+		let last = this.unwatchedReads.get(key);
+		if (last?.result.summary.stale) last = void 0;
+		try {
+			const repo = this.getRepository(key);
+			if (repo == null) throw new Error(`No repository found for '${key}'`);
+			const headRemotes = last != null ? getHeadRemotes(last.result.summary.baseDependsOn) : void 0;
+			const probe = await this.probeUnwatched(repo, headRemotes, signal);
+			if (flight.disposed) throw new CancellationError();
+			let fields;
+			let baseMoves;
+			if (last == null) fields = 23;
+			else {
+				fields = last.due;
+				const { inputs } = last;
+				const previous = last.result.summary;
+				if (probe.branch !== inputs.branch || probe.detached !== inputs.detached || probe.sha !== inputs.sha) fields |= allFields;
+				else {
+					if (probe.upstream !== inputs.upstream) fields |= 18;
+					else if (getUpstreamTips(probe.tips, probe.upstream) !== inputs.upstreamTips) fields |= branchField;
+					for (const ref of previous.baseDependsOn) {
+						const value = getBaseInput(probe, ref);
+						if (value !== null && value === inputs.baseTips.get(ref)) continue;
+						baseMoves ??= /* @__PURE__ */ new Set();
+						baseMoves.add(ref);
+					}
+					if (baseMoves != null) fields |= baseMoveField;
+					if ((fields & baseConfigField) === 0 && last.result.baseConfigKey != null && repo.branches.getAheadOfBase != null && (probe.detached || probe.branch != null)) {
+						const configKey = getBaseConfigKey(await readBaseConfig(repo, signal), previous);
+						if (flight.disposed) throw new CancellationError();
+						if (configKey != null && configKey !== last.result.baseConfigKey) fields |= 18;
+					}
+				}
+				if (flight.probeDirty || probe.index == null || probe.index !== inputs.index) fields |= dirtyField;
+				if (fields === 0) {
+					this.unwatchedReads.touch(key);
+					return last;
+				}
+			}
+			if (headRemotes != null && (fields & 60) !== 0) {
+				await readRemoteHeads(repo, probe.remoteHeads, void 0, signal);
+				if (flight.disposed) throw new CancellationError();
+			}
+			let result = await readSummary(repo, key, fields, last?.result.summary, last?.result.baseKeys, last?.result.baseConfigKey, last?.result.baseDefaultBranch, baseMoves, signal, this.verifyBaseRemeasure);
+			const kept = last?.result.summary;
+			if (kept != null && summariesEqual(kept, result.summary)) result = {
+				...result,
+				summary: kept
+			};
+			const read = {
+				result,
+				dirtyReadAt: result.dirtyReadAt ?? last?.dirtyReadAt ?? Date.now(),
+				inputs: toUnwatchedInputs(probe, result.summary),
+				due: flight.due
+			};
+			if (this.unwatchedFlights.get(key) === flight && !this.entries.has(key)) this.unwatchedReads.set(key, read);
+			return read;
+		} catch (ex) {
+			if (!isCancellationError(ex) && this.unwatchedFlights.get(key) === flight) this.unwatchedReads.delete(key);
+			throw ex;
+		}
+	}
+	/**
+	* Reads an unwatched read's inputs: cached answers but for the index file's stat (see {@link UnwatchedInputs}), with
+	* the `HEAD` symrefs of `remotes` (every remote's when `undefined`)
+	*/
+	async probeUnwatched(repo, remotes, signal) {
+		const remoteHeads = /* @__PURE__ */ new Map();
+		const [current, tips, gitDir] = await Promise.all([
+			repo.branches.getBranch(void 0, void 0, signal),
+			repo.refs.getRefTips(void 0, signal),
+			getGitDir(repo),
+			readRemoteHeads(repo, remoteHeads, remotes, signal)
+		]);
+		let index;
+		const stat = this.stat;
+		if (stat != null && gitDir != null) try {
+			const stats = await stat(joinPaths(gitDir.uri.fsPath, "index"));
+			index = stats != null ? `${stats.size}:${stats.mtime}` : "";
+		} catch {
+			index = void 0;
+		}
+		const detached = current?.detached ?? false;
+		return {
+			branch: detached ? void 0 : current?.name || void 0,
+			detached,
+			sha: current?.sha,
+			upstream: current?.upstream?.name,
+			tips: getTipsByName(tips),
+			remoteHeads,
+			index
+		};
 	}
 	getResourceUsage() {
 		return { "worktreeSummary.entries.count": this.entries.size };
@@ -267,10 +477,23 @@ var WorktreeSummaryService = class {
 			if (entry.handle == null) continue;
 			const value = entry.value;
 			if (value != null && (value.branch == null || e.refs != null && !e.refs.has(value.branch))) continue;
-			const commonPath = this.getCommonPath?.(entry.key);
-			if (commonPath != null && commonPath !== e.repoPath) continue;
+			if (!this.isInRepository(entry.key, e.repoPath)) continue;
 			this.queue(entry, baseKeysField);
 		}
+		for (const read of this.unwatchedReads.values()) {
+			const value = read.result.summary;
+			if (value.branch == null || e.refs != null && !e.refs.has(value.branch)) continue;
+			if (!this.isInRepository(value.repoPath, e.repoPath)) continue;
+			read.due |= baseKeysField;
+		}
+		for (const flight of this.unwatchedFlights.values()) {
+			if (!this.isInRepository(flight.key, e.repoPath)) continue;
+			flight.due |= baseKeysField;
+		}
+	}
+	isInRepository(key, commonPath) {
+		const path = this.getCommonPath?.(key);
+		return path == null || path === commonPath;
 	}
 	queue(entry, fields, baseMoves) {
 		if (entry.disposed || fields === 0) return;
@@ -443,7 +666,12 @@ function createEntry(key) {
 */
 async function readSummary(repo, key, fields, previous, previousBaseKeys, previousBaseConfigKey, previousBaseDefaultBranch, baseMoves, signal, verifyBaseRemeasure) {
 	if (previous == null) fields |= allFields;
-	let dirtyRead = fields & dirtyField ? readDirty(repo, signal) : void 0;
+	let dirtyReadAt;
+	const startDirtyRead = () => {
+		dirtyReadAt = Date.now();
+		return readDirty(repo, signal);
+	};
+	let dirtyRead = fields & dirtyField ? startDirtyRead() : void 0;
 	let branch = previous?.branch;
 	let detached = previous?.detached ?? false;
 	let sha = previous?.sha;
@@ -460,7 +688,7 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		behind = current?.upstream?.state.behind ?? 0;
 		if (previous != null && (branch !== previous.branch || detached !== previous.detached)) {
 			fields |= baseField;
-			dirtyRead ??= readDirty(repo, signal);
+			dirtyRead ??= startDirtyRead();
 		}
 	}
 	let base = previous?.base;
@@ -555,7 +783,92 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		baseKeys,
 		baseConfigKey,
 		baseDefaultBranch,
-		baseError
+		baseError,
+		dirtyReadAt
+	};
+}
+async function getGitDir(repo) {
+	try {
+		return await repo.config.getGitDir?.();
+	} catch (ex) {
+		if (isCancellationError(ex)) throw ex;
+		return;
+	}
+}
+/** Each ref list's tips by full name, built once per list, which core's cache shares across a repository's worktrees */
+const tipsByNameCache = /* @__PURE__ */ new WeakMap();
+function getTipsByName(tips) {
+	let byName = tipsByNameCache.get(tips);
+	if (byName == null) {
+		const map = /* @__PURE__ */ new Map();
+		for (const tip of tips) map.set(tip.fullName, tip.sha);
+		byName = map;
+		tipsByNameCache.set(tips, byName);
+	}
+	return byName;
+}
+/** The upstream's tips as a remote-tracking and as a local branch, since its short name doesn't say which */
+function getUpstreamTips(tips, upstream) {
+	if (upstream == null) return void 0;
+	return `${tips.get(`refs/remotes/${upstream}`) ?? ""}\0${tips.get(`refs/heads/${upstream}`) ?? ""}`;
+}
+/**
+* Reads where the `HEAD` symref of each of `remotes` (every remote's when `undefined`) points (`origin/main`) into
+* `heads`, as core's cached local reads answer it, skipping those already there: `undefined` when it has none (a
+* remote since removed included), `null` when the read failed
+*/
+async function readRemoteHeads(repo, heads, remotes, signal) {
+	if (remotes?.size === 0) return;
+	const names = remotes ?? (await repo.remotes.getRemotes(void 0, signal)).map((r) => r.name);
+	await Promise.all(Array.from(names, async (name) => {
+		if (heads.has(name)) return;
+		let target;
+		try {
+			target = await repo.branches.getDefaultBranchName(name, { local: true }, signal);
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			target = null;
+		}
+		heads.set(name, target);
+	}));
+}
+/** The remote whose `HEAD` symref `ref` is; `undefined` for any other ref */
+function getHeadRemote(ref) {
+	if (!ref.startsWith("refs/remotes/") || !ref.endsWith("/HEAD")) return void 0;
+	return ref.slice(13, -5);
+}
+/** The remotes whose `HEAD` symref is among `refs` */
+function getHeadRemotes(refs) {
+	const remotes = /* @__PURE__ */ new Set();
+	for (const ref of refs) {
+		const remote = getHeadRemote(ref);
+		if (remote != null) remotes.add(remote);
+	}
+	return remotes;
+}
+/**
+* What `probe` found of `ref`, a ref the base depends on: for a remote's `HEAD` symref, which the ref tips leave out,
+* the ref it points at, since its tip follows that ref's, itself a dependency; else its tip. `null` for a symref of a
+* remote it didn't read: only when the read found HEAD elsewhere than the probe did and read the base for that, which
+* the next probe sees as HEAD moving anyway
+*/
+function getBaseInput(probe, ref) {
+	const remote = getHeadRemote(ref);
+	if (remote == null) return probe.tips.get(ref);
+	return probe.remoteHeads.has(remote) ? probe.remoteHeads.get(remote) : null;
+}
+/** The inputs `summary` was read from, as the probe before its read found them */
+function toUnwatchedInputs(probe, summary) {
+	const baseTips = /* @__PURE__ */ new Map();
+	for (const ref of summary.baseDependsOn) baseTips.set(ref, getBaseInput(probe, ref));
+	return {
+		branch: probe.branch,
+		detached: probe.detached,
+		sha: probe.sha,
+		upstream: probe.upstream,
+		upstreamTips: getUpstreamTips(probe.tips, probe.upstream),
+		baseTips,
+		index: probe.index
 	};
 }
 async function readBaseConfig(repo, signal) {