neon 3.0.0 → 3.1.0

package/dist/context.js

@@ -1,268 +1,216 @@
+import { log } from "./log.js";
 import { accessSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, normalize, resolve } from "node:path";
-import { log } from "./log.js";
+import { homedir } from "node:os";
+//#region src/context.ts
 /**
- * The branch pinned in a context, reading the current `branch` field and
- * falling back to the legacy `branchId` so pre-migration `.neon` files keep
- * working.
- */
-export const contextBranch = (context) => context.branch ?? context.branchId;
+* The branch pinned in a context, reading the current `branch` field and
+* falling back to the legacy `branchId` so pre-migration `.neon` files keep
+* working.
+*/
+const contextBranch = (context) => context.branch ?? context.branchId;
 /**
- * True when the invocation is the offline "current branch" probe:
- * `(config) status --current-branch`. This mode only reads the pinned branch
- * from the local `.neon` file (for shell prompts like starship), so it MUST
- * NOT touch the network — several middlewares (auth, analytics, single-project
- * resolution) consult this to early-return and skip their API calls / login.
- *
- * Gated on the exact command as well as the flag so an accidental
- * `--current-branch` on an unrelated command (e.g. `config plan`, where the flag
- * is undefined but non-strict yargs still parses it) can't silently skip
- * auth/analytics. The probe is only `status` (the top-level alias) or
- * `config status` (`_ = ['config', 'status']`).
- */
-export const isCurrentBranchProbe = (args) => args.currentBranch === true &&
-    (args._[0] === "status" ||
-        (args._[0] === "config" && args._[1] === "status"));
+* True when the invocation is the offline "current branch" probe:
+* `(config) status --current-branch`. This mode only reads the pinned branch
+* from the local `.neon` file (for shell prompts like starship), so it MUST
+* NOT touch the network — several middlewares (auth, analytics, single-project
+* resolution) consult this to early-return and skip their API calls / login.
+*
+* Gated on the exact command as well as the flag so an accidental
+* `--current-branch` on an unrelated command (e.g. `config plan`, where the flag
+* is undefined but non-strict yargs still parses it) can't silently skip
+* auth/analytics. The probe is only `status` (the top-level alias) or
+* `config status` (`_ = ['config', 'status']`).
+*/
+const isCurrentBranchProbe = (args) => args.currentBranch === true && (args._[0] === "status" || args._[0] === "config" && args._[1] === "status");
 /**
- * `config init` only scaffolds a local `neon.ts` and installs npm packages — it
- * never calls the Neon API. Gated on the exact command path so the global auth
- * middleware and the single-project resolver can skip it (it runs with no API
- * client), mirroring {@link isCurrentBranchProbe}.
- *
- * `--from-branch` is the exception: it seeds the policy from a branch's live state, so it
- * needs both credentials and a resolved project. The raw argv is checked alongside the parsed
- * flag because this runs from middleware that executes before validation, where the parsed
- * value may not be populated yet (the same reason `analytics.ts` scans argv for
- * `--current-branch`).
- */
-export const isConfigInit = (args) => args._[0] === "config" &&
-    args._[1] === "init" &&
-    args.fromBranch !== true &&
-    !process.argv.includes("--from-branch");
+* `config init` only scaffolds a local `neon.ts` and installs npm packages — it
+* never calls the Neon API. Gated on the exact command path so the global auth
+* middleware and the single-project resolver can skip it (it runs with no API
+* client), mirroring {@link isCurrentBranchProbe}.
+*
+* `--from-branch` is the exception: it seeds the policy from a branch's live state, so it
+* needs both credentials and a resolved project. The raw argv is checked alongside the parsed
+* flag because this runs from middleware that executes before validation, where the parsed
+* value may not be populated yet (the same reason `analytics.ts` scans argv for
+* `--current-branch`).
+*/
+const isConfigInit = (args) => args._[0] === "config" && args._[1] === "init" && args.fromBranch !== true && !process.argv.includes("--from-branch");
 /**
- * `neon profile …` manages credentials on disk and never calls the Neon API, so the global
- * auth middleware must skip it — mirroring {@link isConfigInit}.
- *
- * More than a nicety: without this, listing your profiles would launch a browser login, and
- * removing a broken profile would demand you sign into it first. Removing a profile whose
- * access has already lapsed is the main reason to remove one.
- */
-export const isProfileCommand = (args) => args._[0] === "profile" || args._[0] === "profiles";
+* `neon profile …` manages credentials on disk and never calls the Neon API, so the global
+* auth middleware must skip it — mirroring {@link isConfigInit}.
+*
+* More than a nicety: without this, listing your profiles would launch a browser login, and
+* removing a broken profile would demand you sign into it first. Removing a profile whose
+* access has already lapsed is the main reason to remove one.
+*/
+const isProfileCommand = (args) => args._[0] === "profile" || args._[0] === "profiles";
 /**
- * `neon api-keys …`, under either spelling. Exempts the group from context enrichment: how
- * far a credential reaches must come from an explicit flag, never from `.neon`.
- */
-export const isApiKeysCommand = (args) => args._[0] === "api-keys" || args._[0] === "api-key";
+* `neon api-keys …`, under either spelling. Exempts the group from context enrichment: how
+* far a credential reaches must come from an explicit flag, never from `.neon`.
+*/
+const isApiKeysCommand = (args) => args._[0] === "api-keys" || args._[0] === "api-key";
 const CONTEXT_FILE = ".neon";
 const GITIGNORE_FILE = ".gitignore";
 const canAccessFile = (file) => {
-    try {
-        accessSync(file);
-        return true;
-    }
-    catch {
-        return false;
-    }
+	try {
+		accessSync(file);
+		return true;
+	} catch {
+		return false;
+	}
 };
 /**
- * Walk upward to find an existing `.neon` file.
- *
- * The walk keeps the established home and POSIX-root boundaries, then also
- * stops when resolving a parent makes no progress. That second guard handles
- * Windows drive and UNC-share roots, whose paths do not equal `normalize("/")`.
- */
-export const walkContextFile = (cwd, root, home, resolvePath, canAccess) => {
-    let currentDir = cwd;
-    while (currentDir !== root && currentDir !== home) {
-        const contextFile = resolvePath(currentDir, CONTEXT_FILE);
-        if (canAccess(contextFile)) {
-            return contextFile;
-        }
-        const parentDir = resolvePath(currentDir, "..");
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return resolvePath(cwd, CONTEXT_FILE);
+* Walk upward to find an existing `.neon` file.
+*
+* The walk keeps the established home and POSIX-root boundaries, then also
+* stops when resolving a parent makes no progress. That second guard handles
+* Windows drive and UNC-share roots, whose paths do not equal `normalize("/")`.
+*/
+const walkContextFile = (cwd, root, home, resolvePath, canAccess) => {
+	let currentDir = cwd;
+	while (currentDir !== root && currentDir !== home) {
+		const contextFile = resolvePath(currentDir, CONTEXT_FILE);
+		if (canAccess(contextFile)) return contextFile;
+		const parentDir = resolvePath(currentDir, "..");
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return resolvePath(cwd, CONTEXT_FILE);
 };
 /**
- * Resolve the default `.neon` path for the current working directory.
- *
- * Walks UP from `cwd` looking ONLY for an already-existing `.neon` file so
- * commands run from a sub-directory of a linked project still pick up the
- * project's context. If no `.neon` is found, the path defaults to
- * `<cwd>/.neon`, which makes `neonctl link` and `neonctl set-context`
- * predictable: they always write the context file into the directory they
- * were invoked from.
- *
- * Historically the walk also considered `package.json` and `.git` as project
- * markers, but that led to surprising behaviour when running `link` from a
- * fresh sub-directory inside an unrelated repo (the new link would land in
- * the parent repo's root instead of the cwd).
- *
- * `cwd` is overridable so tests can exercise the walk-up without mutating
- * `process.cwd()` (which would race with other tests running in parallel).
- */
-export const currentContextFile = (cwd = process.cwd()) => walkContextFile(cwd, normalize("/"), homedir(), resolve, canAccessFile);
-export const readContextFile = (file) => {
-    try {
-        return JSON.parse(readFileSync(file, "utf-8"));
-    }
-    catch {
-        return {};
-    }
+* Resolve the default `.neon` path for the current working directory.
+*
+* Walks UP from `cwd` looking ONLY for an already-existing `.neon` file so
+* commands run from a sub-directory of a linked project still pick up the
+* project's context. If no `.neon` is found, the path defaults to
+* `<cwd>/.neon`, which makes `neonctl link` and `neonctl set-context`
+* predictable: they always write the context file into the directory they
+* were invoked from.
+*
+* Historically the walk also considered `package.json` and `.git` as project
+* markers, but that led to surprising behaviour when running `link` from a
+* fresh sub-directory inside an unrelated repo (the new link would land in
+* the parent repo's root instead of the cwd).
+*
+* `cwd` is overridable so tests can exercise the walk-up without mutating
+* `process.cwd()` (which would race with other tests running in parallel).
+*/
+const currentContextFile = (cwd = process.cwd()) => walkContextFile(cwd, normalize("/"), homedir(), resolve, canAccessFile);
+const readContextFile = (file) => {
+	try {
+		return JSON.parse(readFileSync(file, "utf-8"));
+	} catch {
+		return {};
+	}
 };
-export const enrichFromContext = (args) => {
-    // `link` and the deprecated `set-context` manage the context file themselves
-    // and must see the raw flags rather than values pre-filled from an existing
-    // `.neon`, so skip enrichment for both.
-    if (args._[0] === "link" || args._[0] === "set-context") {
-        return;
-    }
-    // `api-keys` mints credentials, and how far a credential reaches must be something the
-    // user typed — never something inherited from whichever project happens to be checked
-    // out. Enriched here, `api-keys create --name ci` in a linked directory would quietly
-    // produce a key scoped to that project instead of the account key it asked for.
-    if (isApiKeysCommand(args)) {
-        return;
-    }
-    // `profile create --mint` mints one too, and for the same reason must take its scope only
-    // from what was typed: enriched here, running it inside a linked directory would quietly
-    // produce a key scoped to that project rather than the account or organization asked for.
-    // No `profile` subcommand has any use for a project or branch.
-    if (isProfileCommand(args)) {
-        return;
-    }
-    const context = readContextFile(args.contextFile);
-    if (!args.orgId) {
-        args.orgId = context.orgId;
-    }
-    if (!args.projectId) {
-        args.projectId = context.projectId;
-    }
-    if (!args.branch &&
-        !args.id &&
-        !args.name &&
-        context.projectId === args.projectId) {
-        args.branch = contextBranch(context);
-    }
+const enrichFromContext = (args) => {
+	if (args._[0] === "link" || args._[0] === "set-context") return;
+	if (isApiKeysCommand(args)) return;
+	if (isProfileCommand(args)) return;
+	const context = readContextFile(args.contextFile);
+	if (!args.orgId) args.orgId = context.orgId;
+	if (!args.projectId) args.projectId = context.projectId;
+	if (!args.branch && !args.id && !args.name && context.projectId === args.projectId) args.branch = contextBranch(context);
 };
-export const updateContextFile = (file, context) => {
-    writeFileSync(file, JSON.stringify(context, null, 2));
+const updateContextFile = (file, context) => {
+	writeFileSync(file, JSON.stringify(context, null, 2));
 };
 /**
- * Shared primitive used by `link`, the deprecated `set-context`, and `checkout`
- * to persist context. Mirrors the destructive write semantics of
- * `updateContextFile` — any field not present in `context` is dropped from the
- * file.
- *
- * `.gitignore` scaffolding only happens when the context file is being
- * *created* (it didn't exist before this write). On updates to an existing
- * `.neon` we never touch `.gitignore`, so a user who deliberately un-ignored
- * the file (e.g. to commit shared context) won't have the entry re-added on
- * every subsequent command.
- */
-export const applyContext = (file, context) => {
-    const isNewFile = !existsSync(file);
-    updateContextFile(file, context);
-    if (isNewFile) {
-        ensureGitignored(file);
-    }
+* Shared primitive used by `link`, the deprecated `set-context`, and `checkout`
+* to persist context. Mirrors the destructive write semantics of
+* `updateContextFile` — any field not present in `context` is dropped from the
+* file.
+*
+* `.gitignore` scaffolding only happens when the context file is being
+* *created* (it didn't exist before this write). On updates to an existing
+* `.neon` we never touch `.gitignore`, so a user who deliberately un-ignored
+* the file (e.g. to commit shared context) won't have the entry re-added on
+* every subsequent command.
+*/
+const applyContext = (file, context) => {
+	const isNewFile = !existsSync(file);
+	updateContextFile(file, context);
+	if (isNewFile) ensureGitignored(file);
 };
 /**
- * Low-level writer for callers that already hold the resolved identifiers and
- * just need to record them — e.g. `init` or `projects create`, which create a
- * project and want to link it without the resolution, verification, prompting,
- * or env-pull that `link` performs.
- *
- * Unlike the loose {@link applyContext}, this enforces at the type level that
- * `orgId` and `projectId` are present, so the `.neon` file never ends up with a
- * dangling project that has no org. The branch stays optional. It writes through
- * {@link applyContext}, so the same `.gitignore` scaffolding applies.
- */
-export const setContext = (file, context) => {
-    applyContext(file, {
-        orgId: context.orgId,
-        projectId: context.projectId,
-        branch: context.branch,
-    });
+* Low-level writer for callers that already hold the resolved identifiers and
+* just need to record them — e.g. `init` or `projects create`, which create a
+* project and want to link it without the resolution, verification, prompting,
+* or env-pull that `link` performs.
+*
+* Unlike the loose {@link applyContext}, this enforces at the type level that
+* `orgId` and `projectId` are present, so the `.neon` file never ends up with a
+* dangling project that has no org. The branch stays optional. It writes through
+* {@link applyContext}, so the same `.gitignore` scaffolding applies.
+*/
+const setContext = (file, context) => {
+	applyContext(file, {
+		orgId: context.orgId,
+		projectId: context.projectId,
+		branch: context.branch
+	});
 };
 /**
- * Make sure the `.gitignore` next to `file` covers the file's basename — used for the `.neon`
- * context file and for a `.env` we create (both carry credentials that must not be committed).
- * Creates the `.gitignore` if it doesn't exist, otherwise appends the entry only when nothing
- * there already covers it: an exact line, or a basename glob such as `.env*` / `*.local`
- * (see {@link gitignoreCovers}), so a repo that already ignores env files doesn't collect a
- * redundant line per pull.
- *
- * Best-effort: a failure here (e.g. read-only filesystem) is logged at debug
- * level and swallowed; persisting the context file is the primary goal and
- * must not be blocked by a `.gitignore` write error.
- */
-export const ensureGitignored = (file) => {
-    try {
-        const dir = dirname(file);
-        const entry = basenameOf(file);
-        const gitignorePath = resolve(dir, GITIGNORE_FILE);
-        if (!existsSync(gitignorePath)) {
-            writeFileSync(gitignorePath, `${entry}\n`);
-            return;
-        }
-        const current = readFileSync(gitignorePath, "utf-8");
-        if (hasGitignoreEntry(current, entry)) {
-            return;
-        }
-        const needsLeadingNewline = current.length > 0 && !current.endsWith("\n");
-        const addition = `${needsLeadingNewline ? "\n" : ""}${entry}\n`;
-        writeFileSync(gitignorePath, current + addition);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log.debug("Failed to update .gitignore next to %s: %s", file, message);
-    }
+* Make sure the `.gitignore` next to `file` covers the file's basename — used for the `.neon`
+* context file and for a `.env` we create (both carry credentials that must not be committed).
+* Creates the `.gitignore` if it doesn't exist, otherwise appends the entry only when nothing
+* there already covers it: an exact line, or a basename glob such as `.env*` / `*.local`
+* (see {@link gitignoreCovers}), so a repo that already ignores env files doesn't collect a
+* redundant line per pull.
+*
+* Best-effort: a failure here (e.g. read-only filesystem) is logged at debug
+* level and swallowed; persisting the context file is the primary goal and
+* must not be blocked by a `.gitignore` write error.
+*/
+const ensureGitignored = (file) => {
+	try {
+		const dir = dirname(file);
+		const entry = basenameOf(file);
+		const gitignorePath = resolve(dir, GITIGNORE_FILE);
+		if (!existsSync(gitignorePath)) {
+			writeFileSync(gitignorePath, `${entry}\n`);
+			return;
+		}
+		const current = readFileSync(gitignorePath, "utf-8");
+		if (hasGitignoreEntry(current, entry)) return;
+		const addition = `${current.length > 0 && !current.endsWith("\n") ? "\n" : ""}${entry}\n`;
+		writeFileSync(gitignorePath, current + addition);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		log.debug("Failed to update .gitignore next to %s: %s", file, message);
+	}
 };
 const basenameOf = (file) => {
-    const parts = file.split(/[\\/]/);
-    return parts[parts.length - 1] || CONTEXT_FILE;
+	const parts = file.split(/[\\/]/);
+	return parts[parts.length - 1] || CONTEXT_FILE;
 };
 const hasGitignoreEntry = (content, entry) => {
-    return content
-        .split(/\r?\n/)
-        .some((line) => gitignoreCovers(line.trim(), entry));
+	return content.split(/\r?\n/).some((line) => gitignoreCovers(line.trim(), entry));
 };
 /**
- * Whether a single `.gitignore` line already ignores `entry` (a bare basename like `.neon` or
- * `.env.local`).
- *
- * Deliberately narrow: an exact match, or a glob **without a path separator** — the
- * `.env*` / `*.local` / `.env.?` shapes that repos actually use for env files — matched
- * against the whole basename. Everything else returns false, which at worst appends an entry
- * git already covers (harmless) rather than skipping one it doesn't (a committed credential).
- * That's why path-scoped patterns (`config/.env`), negations (`!.env.local`), character
- * classes, and comments are all treated as "does not cover".
- */
+* Whether a single `.gitignore` line already ignores `entry` (a bare basename like `.neon` or
+* `.env.local`).
+*
+* Deliberately narrow: an exact match, or a glob **without a path separator** — the
+* `.env*` / `*.local` / `.env.?` shapes that repos actually use for env files — matched
+* against the whole basename. Everything else returns false, which at worst appends an entry
+* git already covers (harmless) rather than skipping one it doesn't (a committed credential).
+* That's why path-scoped patterns (`config/.env`), negations (`!.env.local`), character
+* classes, and comments are all treated as "does not cover".
+*/
 const gitignoreCovers = (line, entry) => {
-    if (line === "" || line.startsWith("#") || line.startsWith("!")) {
-        return false;
-    }
-    // A trailing slash marks a directory-only pattern; the leading one anchors to the
-    // .gitignore's own directory, which is exactly where `entry` lives.
-    const pattern = line.replace(/\/$/, "").replace(/^\//, "");
-    if (pattern === entry)
-        return true;
-    if (pattern.includes("/") || pattern.includes("["))
-        return false;
-    if (!pattern.includes("*") && !pattern.includes("?"))
-        return false;
-    return globToRegExp(pattern).test(entry);
+	if (line === "" || line.startsWith("#") || line.startsWith("!")) return false;
+	const pattern = line.replace(/\/$/, "").replace(/^\//, "");
+	if (pattern === entry) return true;
+	if (pattern.includes("/") || pattern.includes("[")) return false;
+	if (!pattern.includes("*") && !pattern.includes("?")) return false;
+	return globToRegExp(pattern).test(entry);
 };
 /** Compile a separator-free `.gitignore` glob (`*` / `?` only) into an anchored RegExp. */
 const globToRegExp = (pattern) => {
-    const source = pattern
-        .replace(/[.+^${}()|\\]/g, "\\$&")
-        .replace(/\*/g, "[^/]*")
-        .replace(/\?/g, "[^/]");
-    return new RegExp(`^${source}$`);
+	const source = pattern.replace(/[.+^${}()|\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+	return new RegExp(`^${source}$`);
 };
+//#endregion
+export { applyContext, contextBranch, currentContextFile, enrichFromContext, ensureGitignored, isApiKeysCommand, isConfigInit, isCurrentBranchProbe, isProfileCommand, readContextFile, setContext, updateContextFile, walkContextFile };

package/dist/current_branch_fast_path.js

@@ -1,56 +1,47 @@
-import { contextBranch, currentContextFile, readContextFile, } from "./context.js";
 import { log } from "./log.js";
+import { contextBranch, currentContextFile, readContextFile } from "./context.js";
 import { getCliName } from "./utils/cli_name.js";
+//#region src/current_branch_fast_path.ts
 /**
- * Offline fast path for `(config) status --current-branch` (used by shell prompts).
- *
- * Reading the pinned branch out of the local `.neon` file does not need the CLI's
- * full command tree, `@neondatabase/api-client`, or yargs — importing those is ~200ms,
- * which dwarfs the actual work. So the entry point ({@link file://./cli.ts}) calls this
- * BEFORE importing `index.js`, and only falls through to the full CLI when this returns
- * `false`. On the fast path the process loads only this module + `context.js`/`log.js`
- * (~25ms total incl. Node startup) instead of ~230ms.
- *
- * It mirrors the `--current-branch` short-circuit in `status()` (commands/config.ts):
- * print the pinned branch to stdout and exit 0, or print nothing + a `neonctl checkout`
- * hint on stderr and exit non-zero when no branch is pinned.
- *
- * Deliberately conservative: only the EXACT bare invocation is handled —
- * `status --current-branch` or `config status --current-branch` with no other args.
- * Anything else (extra flags like `--context-file`/`--output`, more args, etc.) returns
- * `false` and flows through the normal yargs pipeline, so behavior can never diverge —
- * the worst case is "not faster", never "wrong".
- *
- * @returns `true` if it handled the invocation (caller should NOT load the full CLI).
- */
-export const tryCurrentBranchFastPath = (argv, 
-// `cwd` is overridable so tests can exercise the `.neon` walk-up without mutating
-// `process.cwd()` (which isn't allowed in vitest workers), mirroring currentContextFile.
-cwd = process.cwd()) => {
-    // argv is [execPath, scriptPath, ...userArgs].
-    if (!isExactCurrentBranchInvocation(argv.slice(2))) {
-        return false;
-    }
-    const branch = contextBranch(readContextFile(currentContextFile(cwd)));
-    if (branch) {
-        process.stdout.write(`${branch}\n`);
-    }
-    else {
-        log.info(`No branch pinned. Run \`${getCliName()} checkout <branch>\` to pin a branch and pull its env vars.`);
-        process.exitCode = 1;
-    }
-    return true;
+* Offline fast path for `(config) status --current-branch` (used by shell prompts).
+*
+* Reading the pinned branch out of the local `.neon` file does not need the CLI's
+* full command tree, `@neondatabase/api-client`, or yargs — importing those is ~200ms,
+* which dwarfs the actual work. So the entry point ({@link file://./cli.ts}) calls this
+* BEFORE importing `index.js`, and only falls through to the full CLI when this returns
+* `false`. On the fast path the process loads only this module + `context.js`/`log.js`
+* (~25ms total incl. Node startup) instead of ~230ms.
+*
+* It mirrors the `--current-branch` short-circuit in `status()` (commands/config.ts):
+* print the pinned branch to stdout and exit 0, or print nothing + a `neonctl checkout`
+* hint on stderr and exit non-zero when no branch is pinned.
+*
+* Deliberately conservative: only the EXACT bare invocation is handled —
+* `status --current-branch` or `config status --current-branch` with no other args.
+* Anything else (extra flags like `--context-file`/`--output`, more args, etc.) returns
+* `false` and flows through the normal yargs pipeline, so behavior can never diverge —
+* the worst case is "not faster", never "wrong".
+*
+* @returns `true` if it handled the invocation (caller should NOT load the full CLI).
+*/
+const tryCurrentBranchFastPath = (argv, cwd = process.cwd()) => {
+	if (!isExactCurrentBranchInvocation(argv.slice(2))) return false;
+	const branch = contextBranch(readContextFile(currentContextFile(cwd)));
+	if (branch) process.stdout.write(`${branch}\n`);
+	else {
+		log.info(`No branch pinned. Run \`${getCliName()} checkout <branch>\` to pin a branch and pull its env vars.`);
+		process.exitCode = 1;
+	}
+	return true;
 };
 /**
- * True only for `status --current-branch` or `config status --current-branch` with no
- * other arguments. Any extra token (another flag, `--context-file`, `=`-style flags,
- * positional args) makes this false so the full CLI handles it.
- */
+* True only for `status --current-branch` or `config status --current-branch` with no
+* other arguments. Any extra token (another flag, `--context-file`, `=`-style flags,
+* positional args) makes this false so the full CLI handles it.
+*/
 const isExactCurrentBranchInvocation = (args) => {
-    const rest = args[0] === "status"
-        ? args.slice(1)
-        : args[0] === "config" && args[1] === "status"
-            ? args.slice(2)
-            : null;
-    return rest !== null && rest.length === 1 && rest[0] === "--current-branch";
+	const rest = args[0] === "status" ? args.slice(1) : args[0] === "config" && args[1] === "status" ? args.slice(2) : null;
+	return rest !== null && rest.length === 1 && rest[0] === "--current-branch";
 };
+//#endregion
+export { tryCurrentBranchFastPath };