@gitkraken/core-gitlens 0.16.0 → 0.16.1

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

@@ -1,3 +1,4 @@
+import { getRefChangeKind } from "../../git/watching/changeEvent.js";
 import { isAbsolute, join } from "node:path";
 //#region ../git-cli/src/exec/commandClassifier.ts
 /**
@@ -86,7 +87,11 @@ const readOnlySubcommands = {
 		"show",
 		"get-ref"
 	]),
-	stash: /* @__PURE__ */ new Set(["list", "show"]),
+	stash: /* @__PURE__ */ new Set([
+		"list",
+		"show",
+		"create"
+	]),
 	tag: /* @__PURE__ */ new Set([
 		"",
 		"-l",
@@ -187,6 +192,7 @@ const globalOptionsWithValue = /* @__PURE__ */ new Set([
 */
 function leadingCommand(args) {
 	let pathOverride;
+	let configs;
 	let i = 0;
 	while (i < args.length) {
 		const arg = args[i];
@@ -197,6 +203,7 @@ function leadingCommand(args) {
 			continue;
 		}
 		if (globalOptionsWithValue.has(arg)) {
+			if (arg === "-c" && args[i + 1] != null) (configs ??= []).push(args[i + 1]);
 			i += 2;
 			continue;
 		}
@@ -213,7 +220,8 @@ function leadingCommand(args) {
 		readOnly: !hasWriteOption(verb, rest) && (readOnlyVerbs.has(verb) || (readOnlySubcommands[verb]?.has(rest[0] ?? "") ?? false) || verb === "config" && isConfigRead(rest) || verb === "reflog" && !reflogWriteSubcommands.has(rest[0] ?? "") || verb === "symbolic-ref" && !rest.includes("-d") && !rest.includes("--delete") && rest.filter((a) => !a.startsWith("-")).length < 2),
 		subcommand: rest[0],
 		rest,
-		pathOverride
+		pathOverride,
+		configs
 	};
 }
 /**
@@ -250,6 +258,9 @@ const objectOnlyVerbs = /* @__PURE__ */ new Set([
 * table and {@link objectOnlyVerbs} announces `[]` — the conservative default for an unclassified
 * mutation: the caller still learns something changed, just not what. An entry covers at least what the
 * verb's typed mutator announces; `update-ref` and `symbolic-ref` name every kind their target ref could be.
+* {@link getNamedChanges} narrows the forms whose argv proves what moved, which can announce less: the typed
+* checkout announces `heads` for any target, but a `--detach` or full-SHA checkout moves only this tree's HEAD,
+* no shared ref.
 * The kinds decide which caches the announcement resets, so a verb that can start or end a paused operation
 * names `pausedOp`: `commit` concludes a merge, cherry-pick or revert, `reset` aborts one, and `am` runs in
 * `rebase-apply`.
@@ -339,11 +350,7 @@ const changesByVerb = {
 		"tags",
 		"stash"
 	],
-	branch: [
-		"heads",
-		"remotes",
-		"tags"
-	],
+	branch: ["heads", "remotes"],
 	"symbolic-ref": [
 		"head",
 		"heads",
@@ -396,8 +403,7 @@ const branchConfigOptions = [
 const branchConfigChanges = [
 	"config",
 	"heads",
-	"remotes",
-	"tags"
+	"remotes"
 ];
 /**
 * Whether creating a branch from `startPoint` may write its tracking to `.git/config`, as git's default
@@ -412,20 +418,560 @@ function mayWriteTracking(startPoint, noTracking) {
 }
 const worktreeChanges = ["worktrees", "heads"];
 const emptyChanges = [];
+const configHeadsChanges = ["config", "heads"];
+const headsChanges = ["heads"];
+const remotesChanges = ["remotes"];
+const tagsChanges = ["tags"];
+const stashChanges = ["stash"];
+const stashIndexChanges = ["stash", "index"];
+const stashBranchChanges = [
+	"head",
+	"heads",
+	"index",
+	"stash"
+];
+const indexChanges = ["index"];
+const headHeadsChanges = ["head", "heads"];
+const headIndexChanges = ["head", "index"];
+const checkoutChanges = [
+	"head",
+	"heads",
+	"index"
+];
+const checkoutTrackingChanges = [
+	"config",
+	"head",
+	"heads",
+	"index"
+];
+const worktreeOnlyChanges = ["worktrees"];
+const worktreeTrackingChanges = [
+	"config",
+	"worktrees",
+	"heads"
+];
+const stashRefs = ["refs/stash"];
+/** A full object name, which `checkout` and `worktree add` never DWIM into a new branch */
+const fullShaRegex = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
+/**
+* Whether a branch name in argv is the branch it names. Git expands `@{-<n>}` (and `@`) wherever it takes a branch
+* name, `branch -d @{-1}` deleting the previous branch, and no ref name can hold `@{` or be `@`
+*/
+function isLiteralBranchName(name) {
+	return name !== "@" && !name.includes("@{");
+}
+/**
+* Splits a verb's arguments by its own option table, since one letter means different things to different verbs
+* (`-m` moves, merges or sets a message). An option outside the table returns `undefined` rather than a guess at
+* whether it takes a value. A valued option accepts `--opt=<v>`, `--opt <v>`, `-o <v>` and `-o<v>`.
+*/
+function parseArgs(args, flags, valued) {
+	const options = [];
+	const positionals = [];
+	let dashDash;
+	let optionsEnded = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--" && dashDash == null) {
+			dashDash = positionals.length;
+			optionsEnded = true;
+			continue;
+		}
+		if (optionsEnded || arg === "-" || !arg.startsWith("-")) {
+			positionals.push(arg);
+			continue;
+		}
+		if (arg === "--end-of-options") {
+			optionsEnded = true;
+			continue;
+		}
+		if (flags.has(arg)) {
+			options.push([arg, void 0]);
+			continue;
+		}
+		if (valued.has(arg)) {
+			const value = args[i + 1];
+			if (value == null) return void 0;
+			options.push([arg, value]);
+			i++;
+			continue;
+		}
+		const long = arg.startsWith("--");
+		const name = long ? arg.split("=", 1)[0] : arg.slice(0, 2);
+		if (name === arg || !valued.has(name)) return void 0;
+		options.push([name, arg.slice(long ? name.length + 1 : name.length)]);
+	}
+	return {
+		options,
+		positionals,
+		dashDash
+	};
+}
+function hasParsedOption(parsed, ...names) {
+	return parsed.options.some(([option]) => names.includes(option));
+}
+const updateRefFlags = /* @__PURE__ */ new Set([
+	"-d",
+	"--delete",
+	"--no-deref",
+	"--create-reflog"
+]);
+const updateRefValued = /* @__PURE__ */ new Set(["-m", "--message"]);
+/**
+* `update-ref` moves the one ref it names, or the ref a symbolic one points to without `--no-deref`, so `HEAD` and a
+* remote's `HEAD` stay unnamed. `null` means a ref outside the namespaces core reads, which the typed
+* `updateReference` doesn't announce either. `git log --all` (graph, search, contributors) does walk such a ref when
+* it points at a commit, and argv can't tell that from a blob ref, so a row it adds or drops can stay stale until the
+* next heads change: the trade the typed write makes not to refresh every worktree on each bookkeeping write. A packed
+* ref's delete rewrites `packed-refs`, which the watcher still reports.
+*/
+function getUpdateRefChanges(args) {
+	const parsed = parseArgs(args, updateRefFlags, updateRefValued);
+	if (parsed == null) return void 0;
+	const [ref] = parsed.positionals;
+	if (!ref) return void 0;
+	if (ref === "HEAD") return { changes: headHeadsChanges };
+	if (!ref.startsWith("refs/")) return void 0;
+	if (ref.endsWith("/HEAD") && !hasParsedOption(parsed, "--no-deref")) return void 0;
+	const kind = getRefChangeKind(ref);
+	if (kind != null) return {
+		changes: [kind],
+		refs: [ref]
+	};
+	if (ref.startsWith("refs/replace/") || ref.startsWith("refs/notes/")) return { changes: headsChanges };
+	return null;
+}
+const branchFlags = /* @__PURE__ */ new Set([
+	"-f",
+	"--force",
+	"--no-track",
+	"-d",
+	"-D",
+	"--delete",
+	"-m",
+	"-M",
+	"--move",
+	"-c",
+	"-C",
+	"--copy",
+	"-r",
+	"--remotes",
+	"-q",
+	"--quiet",
+	"--create-reflog"
+]);
+const noValuedOptions = /* @__PURE__ */ new Set();
+/**
+* The create, delete, rename and copy forms of `branch` name every branch they write. A delete removes a local
+* branch's `branch.<name>` section and a rename or copy moves it; a create writes it only for tracking.
+*/
+function getBranchChanges(args) {
+	const parsed = parseArgs(args, branchFlags, noValuedOptions);
+	if (parsed == null) return void 0;
+	let mode;
+	let remote = false;
+	let noTrack = false;
+	for (const [option] of parsed.options) switch (option) {
+		case "-d":
+		case "-D":
+		case "--delete":
+			if (mode === "move") return void 0;
+			mode = "delete";
+			break;
+		case "-m":
+		case "-M":
+		case "--move":
+		case "-c":
+		case "-C":
+		case "--copy":
+			if (mode === "delete") return void 0;
+			mode = "move";
+			break;
+		case "-r":
+		case "--remotes":
+			remote = true;
+			break;
+		case "--no-track": noTrack = true;
+	}
+	const names = parsed.positionals;
+	if (mode === "delete") {
+		if (!names.length || !names.every(isLiteralBranchName)) return void 0;
+		if (remote) return {
+			changes: remotesChanges,
+			refs: names.map((n) => `refs/remotes/${n}`)
+		};
+		return {
+			changes: configHeadsChanges,
+			refs: names.map((n) => `refs/heads/${n}`),
+			configConfinedToRefs: true
+		};
+	}
+	if (remote) return void 0;
+	if (mode === "move") {
+		if (names.length !== 2 || !names.every(isLiteralBranchName)) return void 0;
+		return {
+			changes: configHeadsChanges,
+			refs: names.map((n) => `refs/heads/${n}`),
+			configConfinedToRefs: true
+		};
+	}
+	if (names.length !== 1 && names.length !== 2 || !isLiteralBranchName(names[0])) return void 0;
+	const refs = [`refs/heads/${names[0]}`];
+	if (mayWriteTracking(names[1], noTrack)) return {
+		changes: configHeadsChanges,
+		refs,
+		configConfinedToRefs: true
+	};
+	return {
+		changes: headsChanges,
+		refs
+	};
+}
+const tagFlags = /* @__PURE__ */ new Set([
+	"-f",
+	"--force",
+	"-d",
+	"--delete",
+	"-a",
+	"--annotate",
+	"-s",
+	"--sign",
+	"--no-sign",
+	"-e",
+	"--edit",
+	"--create-reflog"
+]);
+const tagValued = /* @__PURE__ */ new Set([
+	"-m",
+	"--message",
+	"-F",
+	"--file",
+	"-u",
+	"--local-user",
+	"--cleanup"
+]);
+function getTagChanges(args) {
+	const parsed = parseArgs(args, tagFlags, tagValued);
+	if (parsed == null) return void 0;
+	const names = parsed.positionals;
+	if (hasParsedOption(parsed, "-d", "--delete")) {
+		if (!names.length) return void 0;
+		return {
+			changes: tagsChanges,
+			refs: names.map((n) => `refs/tags/${n}`)
+		};
+	}
+	if (names.length !== 1 && names.length !== 2) return void 0;
+	return {
+		changes: tagsChanges,
+		refs: [`refs/tags/${names[0]}`]
+	};
+}
+/** The `worktree` subcommands other than `add` and `list`; none writes a branch */
+const worktreeEditSubcommands = /* @__PURE__ */ new Set([
+	"remove",
+	"prune",
+	"lock",
+	"unlock",
+	"move",
+	"repair"
+]);
+const worktreeAddFlags = /* @__PURE__ */ new Set([
+	"-f",
+	"--force",
+	"-d",
+	"--detach",
+	"--checkout",
+	"--no-checkout",
+	"--lock",
+	"-q",
+	"--quiet",
+	"--track",
+	"--no-track",
+	"--guess-remote",
+	"--no-guess-remote",
+	"--orphan"
+]);
+const worktreeAddValued = /* @__PURE__ */ new Set([
+	"-b",
+	"-B",
+	"--reason"
+]);
+/**
+* `worktree add` is the only subcommand that can create a branch: the `-b`/`-B` one it names or, without either, one
+* git DWIMs from a short commit-ish (or from the path, given none), which argv can't name. A detached or full-SHA add
+* creates none.
+*/
+function getWorktreeChanges(args) {
+	const [subcommand, ...rest] = args;
+	if (subcommand != null && worktreeEditSubcommands.has(subcommand)) return { changes: worktreeOnlyChanges };
+	if (subcommand !== "add") return void 0;
+	const parsed = parseArgs(rest, worktreeAddFlags, worktreeAddValued);
+	if (parsed == null) return void 0;
+	let branch;
+	let detach = false;
+	let orphan = false;
+	let track;
+	for (const [option, value] of parsed.options) switch (option) {
+		case "-b":
+		case "-B":
+			branch = value;
+			break;
+		case "-d":
+		case "--detach":
+			detach = true;
+			break;
+		case "--orphan":
+			orphan = true;
+			break;
+		case "--track":
+			track = true;
+			break;
+		case "--no-track": track = false;
+	}
+	const [path, commitish, ...extra] = parsed.positionals;
+	if (orphan || path == null || extra.length) return void 0;
+	if (branch) {
+		if (!isLiteralBranchName(branch)) return void 0;
+		const refs = [`refs/heads/${branch}`];
+		if (track === true || mayWriteTracking(commitish, track === false)) return {
+			changes: worktreeTrackingChanges,
+			refs,
+			configConfinedToRefs: true
+		};
+		return {
+			changes: worktreeChanges,
+			refs
+		};
+	}
+	if (detach || commitish != null && fullShaRegex.test(commitish)) return { changes: worktreeOnlyChanges };
+}
+const checkoutFlags = /* @__PURE__ */ new Set([
+	"-q",
+	"--quiet",
+	"-f",
+	"--force",
+	"--detach",
+	"--no-track",
+	"-m",
+	"--merge",
+	"--progress",
+	"--no-progress",
+	"--ignore-other-worktrees",
+	"--overwrite-ignore",
+	"--no-overwrite-ignore",
+	"--recurse-submodules",
+	"--no-recurse-submodules"
+]);
+const checkoutValued = /* @__PURE__ */ new Set(["-b", "-B"]);
+const switchFlags = /* @__PURE__ */ new Set([
+	...checkoutFlags,
+	"-d",
+	"--discard-changes"
+]);
+const switchValued = /* @__PURE__ */ new Set([
+	"-c",
+	"-C",
+	"--create",
+	"--force-create"
+]);
+/**
+* `checkout`/`switch` moves no existing branch, so the only shared ref it writes is one it creates: the `-b`/`-c` one
+* it names, or the one git DWIMs from a remote branch named like its lone argument. A detached or full-SHA checkout
+* creates none, and a pathspec checkout writes only the index and working tree.
+*/
+function getCheckoutChanges(verb, args) {
+	const parsed = verb === "switch" ? parseArgs(args, switchFlags, switchValued) : parseArgs(args, checkoutFlags, checkoutValued);
+	if (parsed == null) return void 0;
+	let branch;
+	let detach = false;
+	let noTrack = false;
+	for (const [option, value] of parsed.options) if (value != null) branch = value;
+	else if (option === "-d" || option === "--detach") detach = true;
+	else if (option === "--no-track") noTrack = true;
+	const { positionals, dashDash } = parsed;
+	const revs = dashDash == null ? positionals : positionals.slice(0, dashDash);
+	const hasPaths = dashDash != null && dashDash < positionals.length;
+	if (branch != null) {
+		if (hasPaths || revs.length > 1 || !isLiteralBranchName(branch)) return void 0;
+		const refs = [`refs/heads/${branch}`];
+		if (mayWriteTracking(revs[0], noTrack)) return {
+			changes: checkoutTrackingChanges,
+			refs,
+			configConfinedToRefs: true
+		};
+		return {
+			changes: checkoutChanges,
+			refs
+		};
+	}
+	if (hasPaths) return verb === "checkout" ? { changes: indexChanges } : void 0;
+	if (revs.length > 1) return void 0;
+	if (detach) return { changes: headIndexChanges };
+	const [rev] = revs;
+	if (rev == null || rev === "-" || rev.startsWith("@{-")) return void 0;
+	if (fullShaRegex.test(rev)) return { changes: headIndexChanges };
+	return {
+		changes: checkoutTrackingChanges,
+		refs: [`refs/heads/${rev}`],
+		configConfinedToRefs: true
+	};
+}
+/**
+* A stash write moves only `refs/stash` (or its reflog, the rest of the list), save `branch`, which also creates the
+* branch it names from a commit and checks it out; `apply` moves no ref
+*/
+function getStashChanges(subcommand, rest) {
+	switch (subcommand) {
+		case "branch": {
+			const name = rest[1];
+			if (!name || name.startsWith("-") || !isLiteralBranchName(name)) return void 0;
+			return {
+				changes: stashBranchChanges,
+				refs: [`refs/heads/${name}`, ...stashRefs]
+			};
+		}
+		case void 0:
+		case "push":
+		case "save":
+		case "pop": return {
+			changes: stashIndexChanges,
+			refs: stashRefs
+		};
+		case "drop":
+		case "clear":
+		case "store": return {
+			changes: stashChanges,
+			refs: stashRefs
+		};
+		case "apply": return { changes: indexChanges };
+		default: return subcommand.startsWith("-") ? {
+			changes: stashIndexChanges,
+			refs: stashRefs
+		} : void 0;
+	}
+}
+/** A `reset` given paths, or `-p`, restores index entries and moves no ref */
+function isPathspecReset(args) {
+	const dashDash = args.indexOf("--");
+	if (dashDash >= 0 && dashDash < args.length - 1) return true;
+	return args.some((arg) => arg === "-p" || arg === "--patch" || arg === "--pathspec-from-file" || arg.startsWith("--pathspec-from-file="));
+}
+const falseConfigValues = /* @__PURE__ */ new Set([
+	"false",
+	"no",
+	"off",
+	"0",
+	""
+]);
+/**
+* The `rebase` options that take the refs it writes out of argv's hands: the update-refs list was fixed when the
+* rebase started, whatever this argv says, an interactive or `--exec` todo list can write any ref, and `--update-refs`
+* spelled any other way than in full turns update-refs on
+*/
+const unprovableRebaseOptions = [
+	"--continue",
+	"--skip",
+	"--edit-todo",
+	"--interactive",
+	"--exec",
+	"--update-refs"
+];
+/**
+* Whether `arg` is one of {@link unprovableRebaseOptions}, `-i` or `-x`, however git lets it be written: any unique
+* prefix of a long option, before any `=<value>` (`--cont`, `--update-ref`, `--exe=make`), and short ones bundled
+* (`-ri`, `-xmake`)
+*/
+function isUnprovableRebaseOption(arg) {
+	if (arg.startsWith("--")) {
+		const name = arg.split("=", 1)[0];
+		return name.length > 2 && unprovableRebaseOptions.some((o) => o.startsWith(name));
+	}
+	return arg.length > 1 && arg.startsWith("-") && /[ix]/.test(arg.slice(1));
+}
+/**
+* Whether a `rebase` moves only the branch being rebased. Update-refs would rewrite every branch in the rebased range,
+* so it must be provably off: the last of `--update-refs`/`--no-update-refs`, else the last `-c rebase.updateRefs`
+* before the verb. An interactive or `--exec` rebase can write any ref from its todo list. Git writes the listed refs
+* only when the rebase finishes, so an abort or quit moves none.
+*/
+function isHeadBranchRebase(command) {
+	let off;
+	for (const arg of command.rest) {
+		if (arg === "--" || arg === "--end-of-options") break;
+		if (arg === "--abort" || arg === "--quit") return true;
+		if (arg === "--no-update-refs") off = true;
+		else if (arg === "--update-refs") off = false;
+		else if (isUnprovableRebaseOption(arg)) return false;
+	}
+	if (off != null) return off;
+	for (const config of command.configs ?? []) {
+		const separator = config.indexOf("=");
+		if ((separator < 0 ? config : config.slice(0, separator)).toLowerCase() !== "rebase.updaterefs") continue;
+		off = separator >= 0 && falseConfigValues.has(config.slice(separator + 1).toLowerCase());
+	}
+	return off ?? false;
+}
+/** Verbs that move only the branch HEAD is on, or none from a detached HEAD */
+const headBranchVerbs = /* @__PURE__ */ new Set([
+	"commit",
+	"merge",
+	"cherry-pick",
+	"revert",
+	"am"
+]);
+/**
+* What argv proves more precisely than {@link changesByVerb}: the refs a write moved, or fewer kinds. `undefined`
+* keeps the verb's table entry; `null` means the write moved nothing cached.
+*/
+function getNamedChanges(command) {
+	switch (command.verb) {
+		case "update-ref": return getUpdateRefChanges(command.rest);
+		case "branch": return getBranchChanges(command.rest);
+		case "tag": return getTagChanges(command.rest);
+		case "worktree": return getWorktreeChanges(command.rest);
+		case "checkout":
+		case "switch": return getCheckoutChanges(command.verb, command.rest);
+		case "stash": return getStashChanges(command.subcommand, command.rest);
+		case "reset":
+			if (isPathspecReset(command.rest)) return { changes: indexChanges };
+			return {
+				changes: changesByVerb.reset,
+				movesHeadBranch: true
+			};
+		case "rebase":
+			if (!isHeadBranchRebase(command)) return void 0;
+			return {
+				changes: changesByVerb.rebase,
+				movesHeadBranch: true
+			};
+		default:
+			if (!headBranchVerbs.has(command.verb)) return void 0;
+			return {
+				changes: changesByVerb[command.verb],
+				movesHeadBranch: true
+			};
+	}
+}
 /**
 * Classifies a raw git argv for the notification `git.run`'s `notify: 'infer'` applies after the run
-* settles. Returns `undefined` for a read-only or object-only command — nothing to announce — otherwise
-* the {@link RepositoryChange} kinds the verb announces, the `-C` re-scope target (if any), and which of
-* those kinds every worktree sees.
+* settles. Returns `undefined` for a command with nothing to announce — read-only, object-only, or a write to a
+* ref nothing cached reads — otherwise the {@link RepositoryChange} kinds it announces, the refs it names when argv
+* proves them, the `-C` re-scope target (if any), and which of those kinds every worktree sees.
 */
 function getChangesForCommand(args) {
 	const command = leadingCommand(args);
 	if (command.readOnly || objectOnlyVerbs.has(command.verb)) return void 0;
-	let changes;
-	if (command.verb === "worktree") changes = worktreeChanges;
-	else if (command.verb === "branch" && hasOption(command.rest, branchConfigOptions)) changes = branchConfigChanges;
-	else changes = changesByVerb[command.verb] ?? emptyChanges;
+	const named = getNamedChanges(command);
+	if (named === null) return void 0;
+	let changes = named?.changes;
+	if (changes == null) {
+		if (command.verb === "worktree") changes = worktreeChanges;
+		else if (command.verb === "branch" && hasOption(command.rest, branchConfigOptions)) changes = branchConfigChanges;
+		else changes = changesByVerb[command.verb] ?? emptyChanges;
+	}
 	return {
+		...named,
 		changes,
 		pathOverride: command.pathOverride,
 		sharedChanges: changes.filter((c) => worktreeSharedChanges.has(c))