@gitkraken/core-gitlens 0.16.0 → 0.16.1

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

@@ -0,0 +1,78 @@
+import { fileUri, joinUriPath } from "../../utils/uri.js";
+import { FileType } from "../../git/context.js";
+import { resolve } from "node:path";
+//#region ../git-cli/src/exec/headState.ts
+const headBranchRegex = /^ref:\s*(refs\/heads\/\S+)\s*$/;
+const headShaRegex = /^(?:[0-9a-f]{40}|[0-9a-f]{64})\s*$/;
+const gitFileRegex = /^gitdir:\s*(.+?)\s*$/m;
+/**
+* Reads `repoPath`'s HEAD from the worktree's own `HEAD` file, without running git: read around a write, it says which
+* branch that write moved, whatever a switch outside core left in the caches. The git dir is the cached one, else the
+* one `<repoPath>/.git` is or points to, so a worktree core never registered is read without spawning git either.
+* A reftable repository's `HEAD` file holds the placeholder `refs/heads/.invalid` (its real HEAD is in the tables),
+* which is no branch name git allows, so it reads as unknown, as does a branch that is a symbolic ref to another (a
+* `master` kept pointing at `main`), since git follows it and a write moves the target. An object id is detached only
+* when the git dir's listing doesn't flag `HEAD` as a symlink (a host's `stat` may follow the link): read as detached,
+* a symlinked HEAD would say a write on its branch moved no branch. Never rejects.
+*/
+async function readHeadState(repoPath, fs, cache) {
+	try {
+		const cached = cache.gitDir.get(repoPath);
+		const gitDir = cached != null ? {
+			uri: cached.uri,
+			commonUri: cached.commonUri
+		} : await findGitDir(repoPath, fs);
+		if (gitDir == null) return void 0;
+		const decoder = new TextDecoder();
+		const head = decoder.decode(await fs.readFile(joinUriPath(gitDir.uri, "HEAD")));
+		if (headShaRegex.test(head)) return (await fs.readDirectory(gitDir.uri)).some(([name, type]) => name === "HEAD" && (type & FileType.SymbolicLink) !== 0) ? void 0 : "detached";
+		const ref = headBranchRegex.exec(head)?.[1];
+		if (ref == null || ref.split("/").some((part) => part.startsWith("."))) return void 0;
+		let target;
+		try {
+			target = decoder.decode(await fs.readFile(joinUriPath(gitDir.commonUri ?? gitDir.uri, ref)));
+		} catch {}
+		return target?.startsWith("ref:") ? void 0 : { branch: ref };
+	} catch {
+		return;
+	}
+}
+/**
+* The git dir `<repoPath>/.git` is: the folder itself, or the one a linked worktree's `gitdir:` file names, whose
+* `commondir` file names the repository's shared one
+*/
+async function findGitDir(repoPath, fs) {
+	const dotGit = joinUriPath(fileUri(repoPath), ".git");
+	const stat = await fs.stat(dotGit);
+	if (stat == null) return void 0;
+	if (stat.type & FileType.Directory) return {
+		uri: dotGit,
+		commonUri: void 0
+	};
+	const dir = gitFileRegex.exec(new TextDecoder().decode(await fs.readFile(dotGit)))?.[1];
+	if (dir == null) return void 0;
+	const gitDir = resolve(repoPath, dir);
+	let commonDir;
+	try {
+		commonDir = new TextDecoder().decode(await fs.readFile(joinUriPath(fileUri(gitDir), "commondir"))).trim();
+	} catch {}
+	return {
+		uri: fileUri(gitDir),
+		commonUri: commonDir ? fileUri(resolve(gitDir, commonDir)) : void 0
+	};
+}
+/**
+* Which branch a write that moves only HEAD's branch moved, from HEAD read before and after it: that branch when HEAD
+* was on the same one both times, `'detached'` (no branch) when it was detached both times, otherwise `undefined` — a
+* hook or an outside switch moved HEAD meanwhile, or a read failed, so the moved branch is unknown.
+*/
+function getMovedHead(before, after) {
+	if (before == null || after == null) return void 0;
+	if (before === "detached") return after === "detached" ? "detached" : void 0;
+	if (after === "detached") return void 0;
+	return before.branch === after.branch ? before : void 0;
+}
+//#endregion
+export { getMovedHead, readHeadState };
+
+//# sourceMappingURL=headState.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headState.js","names":["resolvePath"],"sources":["../../../../git-cli/src/exec/headState.ts"],"sourcesContent":["import { resolve as resolvePath } from 'node:path';\nimport type { Cache } from '@gitlens/git/cache.js';\nimport type { FileSystemProvider } from '@gitlens/git/context.js';\nimport { FileType } from '@gitlens/git/context.js';\nimport type { Uri } from '@gitlens/utils/uri.js';\nimport { fileUri, joinUriPath } from '@gitlens/utils/uri.js';\n\n/**\n * What a worktree's HEAD is on: the full name of its branch (`refs/heads/main`), `'detached'`, or `undefined` when\n * unknown — unreadable, not a branch name git allows, or a HEAD kept as a symlink to its branch\n * (`core.preferSymlinkRefs`). Reading such a HEAD follows the link to the branch's object id, as a detached HEAD\n * reads, so it is unknown when the git dir's listing flags it as a link, and `'detached'` on a host whose listing\n * doesn't.\n */\nexport type HeadState = { readonly branch: string } | 'detached' | undefined;\n\nconst headBranchRegex = /^ref:\\s*(refs\\/heads\\/\\S+)\\s*$/;\nconst headShaRegex = /^(?:[0-9a-f]{40}|[0-9a-f]{64})\\s*$/;\nconst gitFileRegex = /^gitdir:\\s*(.+?)\\s*$/m;\n\n/**\n * Reads `repoPath`'s HEAD from the worktree's own `HEAD` file, without running git: read around a write, it says which\n * branch that write moved, whatever a switch outside core left in the caches. The git dir is the cached one, else the\n * one `<repoPath>/.git` is or points to, so a worktree core never registered is read without spawning git either.\n * A reftable repository's `HEAD` file holds the placeholder `refs/heads/.invalid` (its real HEAD is in the tables),\n * which is no branch name git allows, so it reads as unknown, as does a branch that is a symbolic ref to another (a\n * `master` kept pointing at `main`), since git follows it and a write moves the target. An object id is detached only\n * when the git dir's listing doesn't flag `HEAD` as a symlink (a host's `stat` may follow the link): read as detached,\n * a symlinked HEAD would say a write on its branch moved no branch. Never rejects.\n */\nexport async function readHeadState(repoPath: string, fs: FileSystemProvider, cache: Cache): Promise<HeadState> {\n\ttry {\n\t\tconst cached = cache.gitDir.get(repoPath);\n\t\tconst gitDir =\n\t\t\tcached != null ? { uri: cached.uri, commonUri: cached.commonUri } : await findGitDir(repoPath, fs);\n\t\tif (gitDir == null) return undefined;\n\n\t\tconst decoder = new TextDecoder();\n\t\tconst head = decoder.decode(await fs.readFile(joinUriPath(gitDir.uri, 'HEAD')));\n\t\tif (headShaRegex.test(head)) {\n\t\t\tconst entries = await fs.readDirectory(gitDir.uri);\n\t\t\tconst linked = entries.some(([name, type]) => name === 'HEAD' && (type & FileType.SymbolicLink) !== 0);\n\t\t\treturn linked ? undefined : 'detached';\n\t\t}\n\n\t\tconst ref = headBranchRegex.exec(head)?.[1];\n\t\tif (ref == null || ref.split('/').some(part => part.startsWith('.'))) return undefined;\n\n\t\t// Packed refs can't hold a symbolic ref, so a missing loose file is a plain branch\n\t\tlet target: string | undefined;\n\t\ttry {\n\t\t\ttarget = decoder.decode(await fs.readFile(joinUriPath(gitDir.commonUri ?? gitDir.uri, ref)));\n\t\t} catch {}\n\t\treturn target?.startsWith('ref:') ? undefined : { branch: ref };\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\n/**\n * The git dir `<repoPath>/.git` is: the folder itself, or the one a linked worktree's `gitdir:` file names, whose\n * `commondir` file names the repository's shared one\n */\nasync function findGitDir(\n\trepoPath: string,\n\tfs: FileSystemProvider,\n): Promise<{ readonly uri: Uri; readonly commonUri: Uri | undefined } | undefined> {\n\tconst dotGit = joinUriPath(fileUri(repoPath), '.git');\n\tconst stat = await fs.stat(dotGit);\n\tif (stat == null) return undefined;\n\tif (stat.type & FileType.Directory) return { uri: dotGit, commonUri: undefined };\n\n\tconst dir = gitFileRegex.exec(new TextDecoder().decode(await fs.readFile(dotGit)))?.[1];\n\tif (dir == null) return undefined;\n\n\tconst gitDir = resolvePath(repoPath, dir);\n\tlet commonDir: string | undefined;\n\ttry {\n\t\tcommonDir = new TextDecoder().decode(await fs.readFile(joinUriPath(fileUri(gitDir), 'commondir'))).trim();\n\t} catch {}\n\treturn { uri: fileUri(gitDir), commonUri: commonDir ? fileUri(resolvePath(gitDir, commonDir)) : undefined };\n}\n\n/**\n * Which branch a write that moves only HEAD's branch moved, from HEAD read before and after it: that branch when HEAD\n * was on the same one both times, `'detached'` (no branch) when it was detached both times, otherwise `undefined` — a\n * hook or an outside switch moved HEAD meanwhile, or a read failed, so the moved branch is unknown.\n */\nexport function getMovedHead(before: HeadState, after: HeadState): HeadState {\n\tif (before == null || after == null) return undefined;\n\tif (before === 'detached') return after === 'detached' ? 'detached' : undefined;\n\tif (after === 'detached') return undefined;\n\n\treturn before.branch === after.branch ? before : undefined;\n}\n"],"mappings":";;;;AAgBA,MAAM,kBAAkB;AACxB,MAAM,eAAe;AACrB,MAAM,eAAe;;;;;;;;;;;AAYrB,eAAsB,cAAc,UAAkB,IAAwB,OAAkC;CAC/G,IAAI;EACH,MAAM,SAAS,MAAM,OAAO,IAAI,QAAQ;EACxC,MAAM,SACL,UAAU,OAAO;GAAE,KAAK,OAAO;GAAK,WAAW,OAAO;EAAU,IAAI,MAAM,WAAW,UAAU,EAAE;EAClG,IAAI,UAAU,MAAM,OAAO,KAAA;EAE3B,MAAM,UAAU,IAAI,YAAY;EAChC,MAAM,OAAO,QAAQ,OAAO,MAAM,GAAG,SAAS,YAAY,OAAO,KAAK,MAAM,CAAC,CAAC;EAC9E,IAAI,aAAa,KAAK,IAAI,GAGzB,QADe,MADO,GAAG,cAAc,OAAO,GAAG,EAAA,CAC1B,MAAM,CAAC,MAAM,UAAU,SAAS,WAAW,OAAO,SAAS,kBAAkB,CACxF,IAAI,KAAA,IAAY;EAG7B,MAAM,MAAM,gBAAgB,KAAK,IAAI,CAAC,GAAG;EACzC,IAAI,OAAO,QAAQ,IAAI,MAAM,GAAG,CAAC,CAAC,MAAK,SAAQ,KAAK,WAAW,GAAG,CAAC,GAAG,OAAO,KAAA;EAG7E,IAAI;EACJ,IAAI;GACH,SAAS,QAAQ,OAAO,MAAM,GAAG,SAAS,YAAY,OAAO,aAAa,OAAO,KAAK,GAAG,CAAC,CAAC;EAC5F,QAAQ,CAAC;EACT,OAAO,QAAQ,WAAW,MAAM,IAAI,KAAA,IAAY,EAAE,QAAQ,IAAI;CAC/D,QAAQ;EACP;CACD;AACD;;;;;AAMA,eAAe,WACd,UACA,IACkF;CAClF,MAAM,SAAS,YAAY,QAAQ,QAAQ,GAAG,MAAM;CACpD,MAAM,OAAO,MAAM,GAAG,KAAK,MAAM;CACjC,IAAI,QAAQ,MAAM,OAAO,KAAA;CACzB,IAAI,KAAK,OAAO,SAAS,WAAW,OAAO;EAAE,KAAK;EAAQ,WAAW,KAAA;CAAU;CAE/E,MAAM,MAAM,aAAa,KAAK,IAAI,YAAY,CAAC,CAAC,OAAO,MAAM,GAAG,SAAS,MAAM,CAAC,CAAC,CAAC,GAAG;CACrF,IAAI,OAAO,MAAM,OAAO,KAAA;CAExB,MAAM,SAASA,QAAY,UAAU,GAAG;CACxC,IAAI;CACJ,IAAI;EACH,YAAY,IAAI,YAAY,CAAC,CAAC,OAAO,MAAM,GAAG,SAAS,YAAY,QAAQ,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK;CACzG,QAAQ,CAAC;CACT,OAAO;EAAE,KAAK,QAAQ,MAAM;EAAG,WAAW,YAAY,QAAQA,QAAY,QAAQ,SAAS,CAAC,IAAI,KAAA;CAAU;AAC3G;;;;;;AAOA,SAAgB,aAAa,QAAmB,OAA6B;CAC5E,IAAI,UAAU,QAAQ,SAAS,MAAM,OAAO,KAAA;CAC5C,IAAI,WAAW,YAAY,OAAO,UAAU,aAAa,aAAa,KAAA;CACtE,IAAI,UAAU,YAAY,OAAO,KAAA;CAEjC,OAAO,OAAO,WAAW,MAAM,SAAS,SAAS,KAAA;AAClD"}

package/dist/git-cli/providers/branches.js

@@ -14,6 +14,7 @@ import { createReference } from "../../git/utils/reference.utils.js";
 import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
 import { BranchError, GitWarnings } from "../../git/errors.js";
 import { mayWriteTracking } from "../exec/commandClassifier.js";
+import { readHeadState } from "../exec/headState.js";
 import { KeyedSequencer } from "../exec/indexLock.js";
 import { GitError, GitErrors, getGitCommandError, gitConfigsBranch, gitConfigsLog } from "../exec/git.js";
 import { maybeStopWatch } from "../../utils/stopwatch.js";
@@ -763,14 +764,23 @@ var BranchesGitSubProvider = class {
 		const records = await this.provider.refs.getRefs(repoPath, cancellation);
 		if (!records.length) return { known: false };
 		if (branch == null) {
-			const current = await this.getCurrentBranchReference(repoPath, cancellation);
-			if (current == null) return { known: false };
-			if (current.remote || isDetachedHead(current.name)) return {
+			const head = await readHeadState(repoPath, this.context.fs, this.cache);
+			if (head === "detached") return {
 				known: true,
 				push: void 0,
 				upstream: void 0
 			};
-			branch = current.name;
+			if (head != null) branch = head.branch;
+			else {
+				const current = await this.getCurrentBranchReference(repoPath, cancellation);
+				if (current == null) return { known: false };
+				if (current.remote || isDetachedHead(current.name)) return {
+					known: true,
+					push: void 0,
+					upstream: void 0
+				};
+				branch = current.name;
+			}
 		}
 		const record = findRefRecord(records, branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`);
 		return {