@gitkraken/core-gitlens 0.11.1 → 0.13.0

package/dist/git-cli/exec/indexLock.d.ts

@@ -0,0 +1,38 @@
+//#region ../git-cli/src/exec/indexLock.d.ts
+/** How long to wait before each retry of a run that found `index.lock` held; its length is the retry count. */
+export declare const indexLockRetryDelays: readonly number[];
+/**
+ * Whether the argv is a command that writes the index (`apply` only does with `--index`, `--cached` or `--3way`,
+ * which implies `--index`, and never with `--check`).
+ */
+export declare function isIndexWriteCommand(args: readonly string[]): boolean;
+/** Whether a run failed because another process held `index.lock`. */
+export declare function isIndexLockHeldError(ex: unknown): boolean;
+/**
+ * Whether the argv is `git config`. Only that verb: others that write config (`branch -m`, `remote add`) can
+ * fail after a partial change, so a blind retry isn't safe.
+ */
+export declare function isConfigCommand(args: readonly string[]): boolean;
+/** Whether a run failed because another process may hold the config file's `.lock`: the reason is `File exists` or absent. */
+export declare function isConfigLockHeldError(ex: unknown): boolean;
+/**
+ * Runs `attempt`, and runs it again after each of {@link indexLockRetryDelays} while it fails on a held
+ * `index.lock`. Any other failure, or the last lock failure, is rethrown as is.
+ */
+export declare function retryWhileIndexLocked<T>(attempt: () => Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+/**
+ * Like {@link retryWhileIndexLocked}, for a config write that loses the race for the file's `.lock` to another
+ * process — git fails at once rather than waiting.
+ */
+export declare function retryWhileConfigLocked<T>(attempt: () => Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+/**
+ * Runs the work for each key one at a time, in arrival order. A failing run doesn't hold up the next one, and a
+ * run whose signal aborts while it waits rejects at once without ever starting.
+ */
+export declare class KeyedSequencer {
+  /** The tail of each key's chain — settles once everything queued so far has finished or been dropped. */
+  private readonly _tails;
+  run<T>(key: string, signal: AbortSignal | undefined, fn: () => Promise<T>): Promise<T>;
+}
+//#endregion
+//# sourceMappingURL=indexLock.d.ts.map

package/dist/git-cli/exec/indexLock.js

@@ -0,0 +1,150 @@
+import { leadingCommand } from "./commandClassifier.js";
+import { CancelledRunError, RunError } from "../../utils/env/node/exec.js";
+import { abortReason } from "./gitQueue.js";
+import { setTimeout } from "timers/promises";
+//#region ../git-cli/src/exec/indexLock.ts
+/**
+* Verbs that take `<gitdir>/index.lock` before changing anything, so a run that loses the race fails at once
+* with nothing half-done and is safe to retry. `stash` is left out because it is multi-step and can fail part
+* way, and the long or interactive verbs (`merge`, `rebase`, `cherry-pick`, `revert`, `am`, `pull`) because
+* holding the lock-ordering chain for their whole run would stall every other write to the checkout.
+*/
+const indexWritingVerbs = /* @__PURE__ */ new Set([
+	"add",
+	"checkout",
+	"commit",
+	"mv",
+	"read-tree",
+	"reset",
+	"restore",
+	"rm",
+	"switch",
+	"update-index"
+]);
+const applyIndexOptions = /* @__PURE__ */ new Set([
+	"--index",
+	"--cached",
+	"--3way",
+	"-3"
+]);
+/** Matches git's `Unable to create '<path>/index.lock': File exists.` — the wording varies a little by version. */
+const indexLockHeldRegex = /index\.lock': File exists/i;
+/** How long to wait before each retry of a run that found `index.lock` held; its length is the retry count. */
+const indexLockRetryDelays = [
+	100,
+	200,
+	400
+];
+/**
+* Whether the argv is a command that writes the index (`apply` only does with `--index`, `--cached` or `--3way`,
+* which implies `--index`, and never with `--check`).
+*/
+function isIndexWriteCommand(args) {
+	const { verb, rest } = leadingCommand(args);
+	if (verb === "apply") return !rest.includes("--check") && rest.some((a) => applyIndexOptions.has(a));
+	return indexWritingVerbs.has(verb);
+}
+/** Whether a run failed because another process held `index.lock`. */
+function isIndexLockHeldError(ex) {
+	return ex instanceof RunError && !(ex instanceof CancelledRunError) && indexLockHeldRegex.test(ex.stderr);
+}
+/** Resolves after `ms`, or rejects as soon as `signal` aborts. */
+async function delay(ms, signal) {
+	try {
+		await setTimeout(ms, void 0, { signal });
+	} catch (ex) {
+		if (signal?.aborted) throw abortReason(signal);
+		throw ex;
+	}
+}
+/**
+* Captures the rest of git's `error: could not lock config file <path>[: <reason>]` line. A held lock reads
+* `: File exists`, except `--remove-section`/`--rename-section` print no reason (for any failure); permanent
+* failures (`Permission denied`, `No such file or directory`, ...) must not be retried.
+*/
+const configLockFailureRegex = /could not lock config file ([^\r\n]*)/i;
+/**
+* Whether the argv is `git config`. Only that verb: others that write config (`branch -m`, `remote add`) can
+* fail after a partial change, so a blind retry isn't safe.
+*/
+function isConfigCommand(args) {
+	return leadingCommand(args).verb === "config";
+}
+/** Whether a run failed because another process may hold the config file's `.lock`: the reason is `File exists` or absent. */
+function isConfigLockHeldError(ex) {
+	if (!(ex instanceof RunError) || ex instanceof CancelledRunError) return false;
+	const rest = configLockFailureRegex.exec(ex.stderr)?.[1];
+	if (rest == null) return false;
+	return /: File exists\s*$/i.test(rest) || !rest.includes(": ");
+}
+/**
+* Runs `attempt`, and runs it again after each of {@link indexLockRetryDelays} while it fails with an error
+* `isHeldError` accepts. Any other failure, or the last lock failure, is rethrown as is.
+*/
+async function retryWhileHeld(attempt, signal, isHeldError) {
+	for (let retry = 0;; retry++) {
+		try {
+			return await attempt();
+		} catch (ex) {
+			if (retry >= indexLockRetryDelays.length || !isHeldError(ex)) throw ex;
+		}
+		await delay(indexLockRetryDelays[retry], signal);
+	}
+}
+/**
+* Runs `attempt`, and runs it again after each of {@link indexLockRetryDelays} while it fails on a held
+* `index.lock`. Any other failure, or the last lock failure, is rethrown as is.
+*/
+function retryWhileIndexLocked(attempt, signal) {
+	return retryWhileHeld(attempt, signal, isIndexLockHeldError);
+}
+/**
+* Like {@link retryWhileIndexLocked}, for a config write that loses the race for the file's `.lock` to another
+* process — git fails at once rather than waiting.
+*/
+function retryWhileConfigLocked(attempt, signal) {
+	return retryWhileHeld(attempt, signal, isConfigLockHeldError);
+}
+/**
+* Runs the work for each key one at a time, in arrival order. A failing run doesn't hold up the next one, and a
+* run whose signal aborts while it waits rejects at once without ever starting.
+*/
+var KeyedSequencer = class {
+	/** The tail of each key's chain — settles once everything queued so far has finished or been dropped. */
+	_tails = /* @__PURE__ */ new Map();
+	async run(key, signal, fn) {
+		const previous = this._tails.get(key);
+		let release;
+		const tail = new Promise((resolve) => release = resolve);
+		this._tails.set(key, tail);
+		const finish = () => {
+			release();
+			if (this._tails.get(key) === tail) this._tails.delete(key);
+		};
+		let started = false;
+		try {
+			if (previous != null) await waitFor(previous, signal);
+			started = true;
+			return await fn();
+		} finally {
+			if (started || previous == null) finish();
+			else previous.then(finish);
+		}
+	}
+};
+function waitFor(promise, signal) {
+	if (signal == null) return promise;
+	if (signal.aborted) return Promise.reject(abortReason(signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(abortReason(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		});
+	});
+}
+//#endregion
+export { KeyedSequencer, indexLockRetryDelays, isConfigCommand, isConfigLockHeldError, isIndexLockHeldError, isIndexWriteCommand, retryWhileConfigLocked, retryWhileIndexLocked };
+
+//# sourceMappingURL=indexLock.js.map

package/dist/git-cli/exec/indexLock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexLock.js","names":["wait"],"sources":["../../../../git-cli/src/exec/indexLock.ts"],"sourcesContent":["import { setTimeout as wait } from 'timers/promises';\nimport { leadingCommand } from './commandClassifier.js';\nimport { CancelledRunError, RunError } from './exec.errors.js';\nimport { abortReason } from './gitQueue.js';\n\n/**\n * Verbs that take `<gitdir>/index.lock` before changing anything, so a run that loses the race fails at once\n * with nothing half-done and is safe to retry. `stash` is left out because it is multi-step and can fail part\n * way, and the long or interactive verbs (`merge`, `rebase`, `cherry-pick`, `revert`, `am`, `pull`) because\n * holding the lock-ordering chain for their whole run would stall every other write to the checkout.\n */\nconst indexWritingVerbs: ReadonlySet<string> = new Set([\n\t'add',\n\t'checkout',\n\t'commit',\n\t'mv',\n\t'read-tree',\n\t'reset',\n\t'restore',\n\t'rm',\n\t'switch',\n\t'update-index',\n]);\n\nconst applyIndexOptions: ReadonlySet<string> = new Set(['--index', '--cached', '--3way', '-3']);\n\n/** Matches git's `Unable to create '<path>/index.lock': File exists.` — the wording varies a little by version. */\nconst indexLockHeldRegex = /index\\.lock': File exists/i;\n\n/** How long to wait before each retry of a run that found `index.lock` held; its length is the retry count. */\nexport const indexLockRetryDelays: readonly number[] = [100, 200, 400];\n\n/**\n * Whether the argv is a command that writes the index (`apply` only does with `--index`, `--cached` or `--3way`,\n * which implies `--index`, and never with `--check`).\n */\nexport function isIndexWriteCommand(args: readonly string[]): boolean {\n\tconst { verb, rest } = leadingCommand(args);\n\tif (verb === 'apply') return !rest.includes('--check') && rest.some(a => applyIndexOptions.has(a));\n\n\treturn indexWritingVerbs.has(verb);\n}\n\n/** Whether a run failed because another process held `index.lock`. */\nexport function isIndexLockHeldError(ex: unknown): boolean {\n\treturn ex instanceof RunError && !(ex instanceof CancelledRunError) && indexLockHeldRegex.test(ex.stderr);\n}\n\n/** Resolves after `ms`, or rejects as soon as `signal` aborts. */\nasync function delay(ms: number, signal: AbortSignal | undefined): Promise<void> {\n\ttry {\n\t\tawait wait(ms, undefined, { signal: signal });\n\t} catch (ex) {\n\t\tif (signal?.aborted) throw abortReason(signal);\n\n\t\tthrow ex;\n\t}\n}\n\n/**\n * Captures the rest of git's `error: could not lock config file <path>[: <reason>]` line. A held lock reads\n * `: File exists`, except `--remove-section`/`--rename-section` print no reason (for any failure); permanent\n * failures (`Permission denied`, `No such file or directory`, ...) must not be retried.\n */\nconst configLockFailureRegex = /could not lock config file ([^\\r\\n]*)/i;\n\n/**\n * Whether the argv is `git config`. Only that verb: others that write config (`branch -m`, `remote add`) can\n * fail after a partial change, so a blind retry isn't safe.\n */\nexport function isConfigCommand(args: readonly string[]): boolean {\n\treturn leadingCommand(args).verb === 'config';\n}\n\n/** Whether a run failed because another process may hold the config file's `.lock`: the reason is `File exists` or absent. */\nexport function isConfigLockHeldError(ex: unknown): boolean {\n\tif (!(ex instanceof RunError) || ex instanceof CancelledRunError) return false;\n\n\tconst rest = configLockFailureRegex.exec(ex.stderr)?.[1];\n\tif (rest == null) return false;\n\n\treturn /: File exists\\s*$/i.test(rest) || !rest.includes(': ');\n}\n\n/**\n * Runs `attempt`, and runs it again after each of {@link indexLockRetryDelays} while it fails with an error\n * `isHeldError` accepts. Any other failure, or the last lock failure, is rethrown as is.\n */\nasync function retryWhileHeld<T>(\n\tattempt: () => Promise<T>,\n\tsignal: AbortSignal | undefined,\n\tisHeldError: (ex: unknown) => boolean,\n): Promise<T> {\n\tfor (let retry = 0; ; retry++) {\n\t\ttry {\n\t\t\treturn await attempt();\n\t\t} catch (ex) {\n\t\t\tif (retry >= indexLockRetryDelays.length || !isHeldError(ex)) throw ex;\n\t\t}\n\n\t\tawait delay(indexLockRetryDelays[retry], signal);\n\t}\n}\n\n/**\n * Runs `attempt`, and runs it again after each of {@link indexLockRetryDelays} while it fails on a held\n * `index.lock`. Any other failure, or the last lock failure, is rethrown as is.\n */\nexport function retryWhileIndexLocked<T>(attempt: () => Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n\treturn retryWhileHeld(attempt, signal, isIndexLockHeldError);\n}\n\n/**\n * Like {@link retryWhileIndexLocked}, for a config write that loses the race for the file's `.lock` to another\n * process — git fails at once rather than waiting.\n */\nexport function retryWhileConfigLocked<T>(attempt: () => Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n\treturn retryWhileHeld(attempt, signal, isConfigLockHeldError);\n}\n\n/**\n * Runs the work for each key one at a time, in arrival order. A failing run doesn't hold up the next one, and a\n * run whose signal aborts while it waits rejects at once without ever starting.\n */\nexport class KeyedSequencer {\n\t/** The tail of each key's chain — settles once everything queued so far has finished or been dropped. */\n\tprivate readonly _tails = new Map<string, Promise<void>>();\n\n\tasync run<T>(key: string, signal: AbortSignal | undefined, fn: () => Promise<T>): Promise<T> {\n\t\tconst previous = this._tails.get(key);\n\n\t\tlet release!: () => void;\n\t\tconst tail = new Promise<void>(resolve => (release = resolve));\n\t\tthis._tails.set(key, tail);\n\n\t\tconst finish = () => {\n\t\t\trelease();\n\t\t\tif (this._tails.get(key) === tail) {\n\t\t\t\tthis._tails.delete(key);\n\t\t\t}\n\t\t};\n\n\t\tlet started = false;\n\t\ttry {\n\t\t\tif (previous != null) {\n\t\t\t\tawait waitFor(previous, signal);\n\t\t\t}\n\n\t\t\tstarted = true;\n\t\t\treturn await fn();\n\t\t} finally {\n\t\t\tif (started || previous == null) {\n\t\t\t\tfinish();\n\t\t\t} else {\n\t\t\t\t// Dropped while waiting: whoever is queued behind still has to wait for the run ahead of us,\n\t\t\t\t// so the chain can only be released once that run is done.\n\t\t\t\tvoid previous.then(finish);\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction waitFor(promise: Promise<void>, signal: AbortSignal | undefined): Promise<void> {\n\tif (signal == null) return promise;\n\tif (signal.aborted) return Promise.reject(abortReason(signal));\n\n\treturn new Promise<void>((resolve, reject) => {\n\t\tconst onAbort = () => reject(abortReason(signal));\n\t\tsignal.addEventListener('abort', onAbort, { once: true });\n\t\tvoid promise.then(() => {\n\t\t\tsignal.removeEventListener('abort', onAbort);\n\t\t\tresolve();\n\t\t});\n\t});\n}\n"],"mappings":"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"}

package/dist/git-cli/parsers/worktreeParser.js

@@ -59,9 +59,9 @@ function parseGitWorktrees(data, repoPath, branches, getWorkspaceFolder) {
 					entry.detached = true;
 					break;
 				case "locked":
-					entry.locked = value.trim() || true;
+					entry.locked = unquoteCString(value.trim()) || true;
 					break;
-				case "prunable": entry.prunable = value.trim() || true;
+				case "prunable": entry.prunable = unquoteCString(value.trim()) || true;
 			}
 		}
 		sw?.stop({ suffix: ` parsed ${worktrees.length} worktrees` });
@@ -72,6 +72,46 @@ function parseGitWorktrees(data, repoPath, branches, getWorkspaceFolder) {
 		_usingCtx$1.d();
 	}
 }
+const cEscapes = {
+	a: 7,
+	b: 8,
+	f: 12,
+	n: 10,
+	r: 13,
+	t: 9,
+	v: 11,
+	"\\": 92,
+	"\"": 34
+};
+/** Reverses Git's C-style quoting (`"a\nb"`, `\303\251` octal UTF-8 bytes); returns unquoted values as-is */
+function unquoteCString(value) {
+	if (!value.startsWith("\"")) return value;
+	const end = value.length > 1 && value.endsWith("\"") ? value.length - 1 : value.length;
+	const encoder = new TextEncoder();
+	const bytes = [];
+	let i = 1;
+	while (i < end) {
+		if (value[i] !== "\\" || i + 1 >= end) {
+			const cp = String.fromCodePoint(value.codePointAt(i));
+			bytes.push(...encoder.encode(cp));
+			i += cp.length;
+			continue;
+		}
+		const next = value[i + 1];
+		if (next >= "0" && next <= "7") {
+			let j = i + 1;
+			while (j < i + 4 && j < end && value[j] >= "0" && value[j] <= "7") j++;
+			bytes.push(Number.parseInt(value.substring(i + 1, j), 8) & 255);
+			i = j;
+			continue;
+		}
+		const code = cEscapes[next];
+		if (code != null) bytes.push(code);
+		else bytes.push(...encoder.encode(next));
+		i += 2;
+	}
+	return new TextDecoder().decode(new Uint8Array(bytes));
+}
 //#endregion
 export { parseGitWorktrees };
 

package/dist/git-cli/parsers/worktreeParser.js.map

@@ -1 +1 @@
-{"version":3,"file":"worktreeParser.js","names":[],"sources":["../../../../git-cli/src/parsers/worktreeParser.ts"],"sourcesContent":["import type { GitBranch } from '@gitlens/git/models/branch.js';\nimport type { WorkspaceFolderResolver } from '@gitlens/git/models/worktree.js';\nimport { GitWorktree } from '@gitlens/git/models/worktree.js';\nimport { normalizePath } from '@gitlens/utils/path.js';\nimport { maybeStopWatch } from '@gitlens/utils/stopwatch.js';\nimport { iterateByDelimiter } from '@gitlens/utils/string.js';\nimport { fileUri } from '@gitlens/utils/uri.js';\n\ninterface WorktreeEntry {\n\tpath: string;\n\tsha?: string;\n\tbranch?: string;\n\tbare: boolean;\n\tdetached: boolean;\n\tlocked?: boolean | string;\n\tprunable?: boolean | string;\n}\n\nexport function parseGitWorktrees(\n\tdata: string | undefined,\n\trepoPath: string,\n\tbranches: GitBranch[],\n\tgetWorkspaceFolder?: WorkspaceFolderResolver,\n): GitWorktree[] {\n\tusing sw = maybeStopWatch(`Git.parseWorktrees(${repoPath})`, { log: { onlyExit: true, level: 'debug' } });\n\n\tconst worktrees: GitWorktree[] = [];\n\tif (!data) {\n\t\tsw?.stop({ suffix: ` no data` });\n\t\treturn worktrees;\n\t}\n\n\tif (repoPath != null) {\n\t\trepoPath = normalizePath(repoPath);\n\t}\n\n\tlet entry: Partial<WorktreeEntry> | undefined = undefined;\n\tlet line: string;\n\tlet index: number;\n\tlet key: string;\n\tlet value: string;\n\tlet main = true; // the first worktree is the main worktree\n\n\tfor (line of iterateByDelimiter(data, '\\n')) {\n\t\tindex = line.indexOf(' ');\n\t\tif (index === -1) {\n\t\t\tkey = line;\n\t\t\tvalue = '';\n\t\t} else {\n\t\t\tkey = line.substring(0, index);\n\t\t\tvalue = line.substring(index + 1);\n\t\t}\n\n\t\tif (!key && entry != null) {\n\t\t\t// oxlint-disable-next-line no-loop-func\n\t\t\tconst branch = entry.branch ? branches?.find(b => b.name === entry!.branch) : undefined;\n\t\t\tconst uri = fileUri(entry.path!);\n\n\t\t\tworktrees.push(\n\t\t\t\tnew GitWorktree(\n\t\t\t\t\tmain,\n\t\t\t\t\tentry.bare ? 'bare' : entry.detached ? 'detached' : 'branch',\n\t\t\t\t\trepoPath,\n\t\t\t\t\turi,\n\t\t\t\t\tentry.locked ?? false,\n\t\t\t\t\tentry.prunable ?? false,\n\t\t\t\t\tentry.sha,\n\t\t\t\t\tbranch,\n\t\t\t\t\tgetWorkspaceFolder?.(uri),\n\t\t\t\t),\n\t\t\t);\n\n\t\t\tentry = undefined;\n\t\t\tmain = false;\n\t\t\tcontinue;\n\t\t}\n\n\t\tentry ??= {};\n\n\t\tswitch (key) {\n\t\t\tcase 'worktree':\n\t\t\t\tentry.path = value;\n\t\t\t\tbreak;\n\t\t\tcase 'bare':\n\t\t\t\tentry.bare = true;\n\t\t\t\tbreak;\n\t\t\tcase 'HEAD':\n\t\t\t\tentry.sha = value;\n\t\t\t\tbreak;\n\t\t\tcase 'branch':\n\t\t\t\t// Strip off refs/heads/\n\t\t\t\tentry.branch = value.substring(11);\n\t\t\t\tbreak;\n\t\t\tcase 'detached':\n\t\t\t\tentry.detached = true;\n\t\t\t\tbreak;\n\t\t\t// `value` is the whole reason, which is only present when the locker/Git provides one.\n\t\t\t// Reasons with unusual characters (e.g. newlines) come through C-quoted, per `core.quotePath`\n\t\t\tcase 'locked':\n\t\t\t\tentry.locked = value.trim() || true;\n\t\t\t\tbreak;\n\t\t\tcase 'prunable':\n\t\t\t\tentry.prunable = value.trim() || true;\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tsw?.stop({ suffix: ` parsed ${worktrees.length} worktrees` });\n\n\treturn worktrees;\n}\n"],"mappings":";;;;;;;AAkBA,SAAgB,kBACf,MACA,UACA,UACA,oBACgB;;;EAChB,MAAM,KAAA,YAAA,EAAK,eAAe,sBAAsB,SAAS,IAAI,EAAE,KAAK;GAAE,UAAU;GAAM,OAAO;EAAQ,EAAE,CAAC,CAAA;EAExG,MAAM,YAA2B,CAAC;EAClC,IAAI,CAAC,MAAM;GACV,IAAI,KAAK,EAAE,QAAQ,WAAW,CAAC;GAC/B,OAAO;EACR;EAEA,IAAI,YAAY,MACf,WAAW,cAAc,QAAQ;EAGlC,IAAI,QAA4C,KAAA;EAChD,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI,OAAO;EAEX,KAAK,QAAQ,mBAAmB,MAAM,IAAI,GAAG;GAC5C,QAAQ,KAAK,QAAQ,GAAG;GACxB,IAAI,UAAU,IAAI;IACjB,MAAM;IACN,QAAQ;GACT,OAAO;IACN,MAAM,KAAK,UAAU,GAAG,KAAK;IAC7B,QAAQ,KAAK,UAAU,QAAQ,CAAC;GACjC;GAEA,IAAI,CAAC,OAAO,SAAS,MAAM;IAE1B,MAAM,SAAS,MAAM,SAAS,UAAU,MAAK,MAAK,EAAE,SAAS,MAAO,MAAM,IAAI,KAAA;IAC9E,MAAM,MAAM,QAAQ,MAAM,IAAK;IAE/B,UAAU,KACT,IAAI,YACH,MACA,MAAM,OAAO,SAAS,MAAM,WAAW,aAAa,UACpD,UACA,KACA,MAAM,UAAU,OAChB,MAAM,YAAY,OAClB,MAAM,KACN,QACA,qBAAqB,GAAG,CACzB,CACD;IAEA,QAAQ,KAAA;IACR,OAAO;IACP;GACD;GAEA,UAAU,CAAC;GAEX,QAAQ,KAAR;IACC,KAAK;KACJ,MAAM,OAAO;KACb;IACD,KAAK;KACJ,MAAM,OAAO;KACb;IACD,KAAK;KACJ,MAAM,MAAM;KACZ;IACD,KAAK;KAEJ,MAAM,SAAS,MAAM,UAAU,EAAE;KACjC;IACD,KAAK;KACJ,MAAM,WAAW;KACjB;IAGD,KAAK;KACJ,MAAM,SAAS,MAAM,KAAK,KAAK;KAC/B;IACD,KAAK,YACJ,MAAM,WAAW,MAAM,KAAK,KAAK;GAEnC;EACD;EAEA,IAAI,KAAK,EAAE,QAAQ,WAAW,UAAU,OAAO,YAAY,CAAC;EAE5D,OAAO;;;;;;AACR"}
+{"version":3,"file":"worktreeParser.js","names":[],"sources":["../../../../git-cli/src/parsers/worktreeParser.ts"],"sourcesContent":["import type { GitBranch } from '@gitlens/git/models/branch.js';\nimport type { WorkspaceFolderResolver } from '@gitlens/git/models/worktree.js';\nimport { GitWorktree } from '@gitlens/git/models/worktree.js';\nimport { normalizePath } from '@gitlens/utils/path.js';\nimport { maybeStopWatch } from '@gitlens/utils/stopwatch.js';\nimport { iterateByDelimiter } from '@gitlens/utils/string.js';\nimport { fileUri } from '@gitlens/utils/uri.js';\n\ninterface WorktreeEntry {\n\tpath: string;\n\tsha?: string;\n\tbranch?: string;\n\tbare: boolean;\n\tdetached: boolean;\n\tlocked?: boolean | string;\n\tprunable?: boolean | string;\n}\n\nexport function parseGitWorktrees(\n\tdata: string | undefined,\n\trepoPath: string,\n\tbranches: GitBranch[],\n\tgetWorkspaceFolder?: WorkspaceFolderResolver,\n): GitWorktree[] {\n\tusing sw = maybeStopWatch(`Git.parseWorktrees(${repoPath})`, { log: { onlyExit: true, level: 'debug' } });\n\n\tconst worktrees: GitWorktree[] = [];\n\tif (!data) {\n\t\tsw?.stop({ suffix: ` no data` });\n\t\treturn worktrees;\n\t}\n\n\tif (repoPath != null) {\n\t\trepoPath = normalizePath(repoPath);\n\t}\n\n\tlet entry: Partial<WorktreeEntry> | undefined = undefined;\n\tlet line: string;\n\tlet index: number;\n\tlet key: string;\n\tlet value: string;\n\tlet main = true; // the first worktree is the main worktree\n\n\tfor (line of iterateByDelimiter(data, '\\n')) {\n\t\tindex = line.indexOf(' ');\n\t\tif (index === -1) {\n\t\t\tkey = line;\n\t\t\tvalue = '';\n\t\t} else {\n\t\t\tkey = line.substring(0, index);\n\t\t\tvalue = line.substring(index + 1);\n\t\t}\n\n\t\tif (!key && entry != null) {\n\t\t\t// oxlint-disable-next-line no-loop-func\n\t\t\tconst branch = entry.branch ? branches?.find(b => b.name === entry!.branch) : undefined;\n\t\t\tconst uri = fileUri(entry.path!);\n\n\t\t\tworktrees.push(\n\t\t\t\tnew GitWorktree(\n\t\t\t\t\tmain,\n\t\t\t\t\tentry.bare ? 'bare' : entry.detached ? 'detached' : 'branch',\n\t\t\t\t\trepoPath,\n\t\t\t\t\turi,\n\t\t\t\t\tentry.locked ?? false,\n\t\t\t\t\tentry.prunable ?? false,\n\t\t\t\t\tentry.sha,\n\t\t\t\t\tbranch,\n\t\t\t\t\tgetWorkspaceFolder?.(uri),\n\t\t\t\t),\n\t\t\t);\n\n\t\t\tentry = undefined;\n\t\t\tmain = false;\n\t\t\tcontinue;\n\t\t}\n\n\t\tentry ??= {};\n\n\t\tswitch (key) {\n\t\t\tcase 'worktree':\n\t\t\t\tentry.path = value;\n\t\t\t\tbreak;\n\t\t\tcase 'bare':\n\t\t\t\tentry.bare = true;\n\t\t\t\tbreak;\n\t\t\tcase 'HEAD':\n\t\t\t\tentry.sha = value;\n\t\t\t\tbreak;\n\t\t\tcase 'branch':\n\t\t\t\t// Strip off refs/heads/\n\t\t\t\tentry.branch = value.substring(11);\n\t\t\t\tbreak;\n\t\t\tcase 'detached':\n\t\t\t\tentry.detached = true;\n\t\t\t\tbreak;\n\t\t\t// `value` is the whole reason, which is only present when the locker/Git provides one (Git < 2.31\n\t\t\t// prints a bare `locked` regardless). Without `-z`, a reason with unusual characters (e.g. newlines)\n\t\t\t// comes through C-quoted, with UTF-8 bytes as octal escapes unless `core.quotePath` is off (as core runs it)\n\t\t\tcase 'locked':\n\t\t\t\tentry.locked = unquoteCString(value.trim()) || true;\n\t\t\t\tbreak;\n\t\t\tcase 'prunable':\n\t\t\t\tentry.prunable = unquoteCString(value.trim()) || true;\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tsw?.stop({ suffix: ` parsed ${worktrees.length} worktrees` });\n\n\treturn worktrees;\n}\n\nconst cEscapes: Record<string, number> = { a: 7, b: 8, f: 12, n: 10, r: 13, t: 9, v: 11, '\\\\': 92, '\"': 34 };\n\n/** Reverses Git's C-style quoting (`\"a\\nb\"`, `\\303\\251` octal UTF-8 bytes); returns unquoted values as-is */\nfunction unquoteCString(value: string): string {\n\tif (!value.startsWith('\"')) return value;\n\n\tconst end = value.length > 1 && value.endsWith('\"') ? value.length - 1 : value.length;\n\tconst encoder = new TextEncoder();\n\tconst bytes: number[] = [];\n\n\tlet i = 1;\n\twhile (i < end) {\n\t\tconst ch = value[i];\n\t\tif (ch !== '\\\\' || i + 1 >= end) {\n\t\t\t// A whole code point, so surrogate pairs encode correctly\n\t\t\tconst cp = String.fromCodePoint(value.codePointAt(i)!);\n\t\t\tbytes.push(...encoder.encode(cp));\n\t\t\ti += cp.length;\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst next = value[i + 1];\n\t\tif (next >= '0' && next <= '7') {\n\t\t\tlet j = i + 1;\n\t\t\twhile (j < i + 4 && j < end && value[j] >= '0' && value[j] <= '7') {\n\t\t\t\tj++;\n\t\t\t}\n\t\t\tbytes.push(Number.parseInt(value.substring(i + 1, j), 8) & 0xff);\n\t\t\ti = j;\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst code = cEscapes[next];\n\t\tif (code != null) {\n\t\t\tbytes.push(code);\n\t\t} else {\n\t\t\tbytes.push(...encoder.encode(next));\n\t\t}\n\t\ti += 2;\n\t}\n\n\treturn new TextDecoder().decode(new Uint8Array(bytes));\n}\n"],"mappings":"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"}

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

@@ -15,6 +15,23 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
   private readonly git;
   private readonly cache;
   private readonly provider;
+  /** Ahead/behind counts by `<baseSha>...<tipSha>` range, from the per-tip fallback; a pair of commits always counts the same */
+  private readonly aheadBehindBySha;
+  /**
+   * When each `commonPath\0branch\0key` was last stamped by this process. Bounded: a dropped entry only costs a
+   * read of the stored stamp, which still holds off a write under 5 minutes old
+   */
+  private readonly _branchActivityStamps;
+  /** One call per `commonPath\0branch` at a time, so a call held off by another's write in flight settles after it */
+  private readonly _branchActivityCalls;
+  /**
+   * What each `commonPath\0branch`'s reflog says it was created from, as git wrote it; `undefined` when it says
+   * nothing. A branch's creation never changes, so the base read, which reruns on every commit and ref move, reads
+   * it once
+   */
+  private readonly _branchCreatedFrom;
+  /** Bumped each time a key's created-from is forgotten, so a reflog read in flight across that doesn't store it */
+  private readonly _branchCreatedFromGenerations;
   constructor(context: GitServiceContext, git: Git, cache: Cache, provider: CliGitProviderInternal);
   getBranch(repoPath: string, name?: string, options?: {
     force?: boolean;
@@ -55,6 +72,12 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
     priority?: GitCommandPriority;
     local?: boolean;
   }, cancellation?: AbortSignal): Promise<string | undefined>;
+  /**
+   * Writes the missing `refs/remotes/<remote>/HEAD` symref from the remote (`remote set-head -a`) in the background,
+   * never prompting for credentials; nothing runs past the cached local check when the symref exists. Rejects when
+   * the remote can't be read.
+   */
+  setRemoteHeadIfMissing(repoPath: string, remote: string): Promise<void>;
   createBranch(repoPath: string, name: string, ref: string, options?: {
     noTracking?: boolean;
   }): Promise<void>;
@@ -99,16 +122,65 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
    * caches the former forever and must not cache the latter.
    */
   private getBaseBranchFromReflog;
-  getAheadOfBase(repoPath: string, branch: string, cancellation?: AbortSignal): Promise<AheadOfBase>;
+  /**
+   * The start point `ref`'s own reflog says it was created from (`branch: Created from <name>`), as git wrote it:
+   * a branch, `HEAD`, a sha, a tag or any other revision. `undefined` unless exactly one entry says so. Rejects
+   * when the reflog can't be read, including for a ref that doesn't exist.
+   */
+  private getReflogCreatedFrom;
+  /**
+   * The branch `branch` was created from, as a base for {@link getAheadOfBaseInOrder}: the name its own reflog
+   * gives, when that is a local or remote-tracking branch in the cached ref list and not `branch` itself or its
+   * copy on a remote (`git switch <branch>` creates it from `<remote>/<branch>`). Never the checkout history in
+   * HEAD's reflog, which on a long-lived checkout names whatever was checked out last.
+   */
+  private getCreatedFromTarget;
+  getAheadOfBase(repoPath: string, branch: string | undefined, options?: {
+    skipUserTarget?: boolean;
+    preferredTarget?: string;
+  }, cancellation?: AbortSignal): Promise<AheadOfBase>;
+  /**
+   * Resolves the base from the recorded candidates, then the branch it was created from or the default branch, for
+   * {@link getAheadOfBase}
+   */
+  private getAheadOfBaseInOrder;
+  /**
+   * The base for a branch created from `createdFrom`: that branch, unless the default branch forked strictly nearer
+   * HEAD, as it does once `createdFrom` merged into it and the branch was rebased onto it. A stacked branch's
+   * unmerged parent forked nearer, and stays its base. `undefined` when neither is usable.
+   */
+  private getCreatedFromForkTarget;
+  /** Counts HEAD's commits past `target` for {@link getAheadOfBase} */
+  private measureAheadOfBase;
+  /** Counts the default branch's own commits past its upstream (see {@link getSelfUpstreamTarget}) for {@link getAheadOfBase} */
+  private measureAheadOfSelfUpstream;
+  /**
+   * HEAD's count against `ref` from their merge base: `left` only `ref` has, `right` only HEAD has. `undefined`
+   * before HEAD's first commit, when there is nothing to count; any other failure rejects with git's error.
+   */
+  private countAgainstBase;
+  getAheadBehindCounts(repoPath: string, base: string, options?: {
+    remotes?: boolean;
+    refs?: readonly string[];
+  }, cancellation?: AbortSignal): Promise<Map<string, {
+    ahead: number;
+    behind: number;
+  }>>;
+  getMergedBranches(repoPath: string, into: string, options?: {
+    remotes?: boolean;
+  }, cancellation?: AbortSignal): Promise<Set<string>>;
   /** Counts `range` with a fresh `rev-list`, bypassing the cached count. Rejects on any failure, with git's error */
   private getLeftRightCountUncached;
   /** Whether HEAD names a branch with no commit yet. Rejects when that can't be read, so a failure isn't taken for an empty branch */
   private isUnbornHead;
   /**
-   * Whether `ref` names `branch` itself: the same name, or `<remote>/<branch>` for one of the repo's actual remotes.
-   * Splitting at the first slash instead would call a local `release/main` the same branch as `main`.
+   * Whether `ref` names `branch` itself: the same name, or `<remote>/<branch>` for one of the repo's actual remotes,
+   * short or as a full ref. Splitting at the first slash instead would call a local `release/main` the same branch
+   * as `main`.
    */
   private isSelfRef;
+  /** The repo's remote names from the cached remote list; empty when it can't be read */
+  private getRemoteNames;
   /** Whether `ref` names `branch` itself (see {@link isSelfRef}) and sits at HEAD's commit; tips are read only after the name matched */
   private isSelfAtHead;
   /**
@@ -118,16 +190,41 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
    */
   private getRecordedBaseCandidates;
   /**
-   * The repo's default branch from local refs only: the `origin/HEAD` symref as its local name, else
-   * `init.defaultBranch`, else `main`, else `master` — each only if it names a commit.
+   * The repo's default branch from local refs only, never the network: the `HEAD` symref of the `upstream` remote,
+   * else of `origin`, else of the first remote, as its local branch or else as the remote ref; then, in the same
+   * remote order, `<remote>/main` or `<remote>/master`, again as the local branch of that name or else the remote
+   * ref; then `init.defaultBranch`, `main`, `master` — each only if it names a commit.
    */
   private getLocalDefaultBranchName;
+  /**
+   * `upstream/<name>` for a created-from or default base `<name>` (or `<remote>/<name>`), as another ref that base
+   * is measured against: in a fork whose `main` tracks `origin/main`, a branch taken off (or since rebased onto) a
+   * newer `upstream/main` would otherwise count the commits `origin` hasn't caught up on. Read from the cached
+   * remote and ref lists; `undefined` when there is no `upstream` remote, it lacks the branch, or the base is that
+   * ref itself.
+   */
+  private getUpstreamContender;
+  /** {@link getNearestForkTarget} with the `upstream` remote's copy of `candidate` as its contender */
+  private getUpstreamNearestForkTarget;
   /**
    * A candidate base as the ref HEAD is measured against: the candidate or its tracking ref, whichever forked
    * nearer HEAD, so a stale local base defers to its upstream while one carrying unpushed work wins over it. A
-   * candidate neither forks from is used as-is if it names a commit. `undefined` when the candidate is unusable.
+   * `contender` other than the tracking ref is taken only when it forked strictly nearer than both, so a tie keeps
+   * the candidate's own pick. A candidate none forks from is used as-is if it names a commit. `undefined` when the
+   * candidate is unusable.
    */
   private getNearestForkTarget;
+  /**
+   * The base for a branch that is itself the default branch, with its tip: its own upstream, `upstream/<branch>`
+   * when an `upstream` remote has it, else `<branch>@{u}`. Read from the cached ref and branch lists; only a
+   * `<branch>` that isn't checked out spawns, for its `@{u}`. `undefined` when there is neither, or its ref is gone.
+   */
+  private getSelfUpstreamTarget;
+  /**
+   * {@link findRefTip} in `records`, the cached ref list. `getRefs` answers a failed enumeration with an empty list,
+   * so an empty one is asked of git instead, rather than read as every ref being absent.
+   */
+  private getRefTip;
   /** The merge base of HEAD and `ref`, preferring git's fork-point reading of `ref`'s reflog when it has one */
   private getForkPoint;
   /**
@@ -142,12 +239,15 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
   private resolveStoredMergeTarget;
   getStoredDetectedMergeTargetBranchName(repoPath: string, ref: string): Promise<string | undefined>;
   getStoredUserMergeTargetBranchName(repoPath: string, ref: string): Promise<string | undefined>;
-  /** Updates the last accessed timestamp for the current branch */
   onCurrentBranchAccessed(repoPath: string): Promise<void>;
-  /** Updates the last accessed and modified timestamp for the current branch */
   onCurrentBranchModified(repoPath: string): Promise<void>;
-  /** Updates the agent last activity timestamp for the current branch */
   onCurrentBranchAgentActivity(repoPath: string): Promise<void>;
+  private getBranchActivityKey;
+  private forgetBranchCreatedFrom;
+  /** Forgets this process's throttle marks for `name`, so its next activity re-reads the stored stamps */
+  private clearBranchActivityStamps;
+  /** Never rejects — activity stamps are bookkeeping and callers fire them without a catch */
+  private recordBranchActivity;
   renameBranch(repoPath: string, oldName: string, newName: string): Promise<void>;
   setUpstreamBranch(repoPath: string, name: string, upstream: string | undefined): Promise<void>;
   storeBaseBranchName(repoPath: string, ref: string, base: string, options?: {
@@ -162,7 +262,6 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
    * @returns A map of branch name to metadata.
    */
   private getBranchMetadataMap;
-  private storeBranchMetadata;
   setBranchDisposition(repoPath: string, branchName: string, disposition: BranchDisposition | undefined): Promise<void>;
 }
 //#endregion