neon 6.0.0 → 6.2.0

package/dist/commands/plugins.js

@@ -17,7 +17,10 @@ var plugins_exports = /* @__PURE__ */ __exportAll({
 	builder: () => builder,
 	command: () => command,
 	describe: () => describe,
-	handler: () => handler
+	handler: () => handler,
+	installPlugins: () => installPlugins,
+	pluginsInstallError: () => pluginsInstallError,
+	reportPluginsInstall: () => reportPluginsInstall
 });
 const coerceAgents = (value) => {
 	if (value === void 0) return [];
@@ -54,13 +57,18 @@ const builder = (argv) => argv.usage("$0 plugins [options]").options({
 		coerce: coerceAgents
 	}
 }).example("$0 plugins", "Interactive: pick agents, then install").example("$0 plugins -y", "Detected agents (project folders, else the host CLI agent), skip prompts").example("$0 plugins --agent cursor --agent claude-code", "Install into specific agents").example("$0 plugins --global", "Install user-level").epilogue(helpEpilogue(helpCsv("Supported agents at project scope", pluginProjectAgents), helpCsv("Also with --global", pluginGlobalOnlyAgents), `Currently one plugin: ${NEON_PLUGIN_NAME} from ${PLUGIN_SOURCE}.`, `It includes the Neon MCP server (${NEON_MCP_URL})`, helpCsv("and these skills", PLUGIN_SKILLS))).strict().check(noPassthrough("plugins"));
-const handler = async (props) => {
-	const cwd = process.cwd();
-	const yes = props.yes === true;
+/**
+* Plans and runs the plugin install for every resolved target. No CLI-only concerns here
+* (no `writer` table, no `recordCommandSuccessExtras`): a caller that only wants the
+* outcome — `neon init` / `neon bootstrap` — gets it without rendering a result table.
+*/
+const installPlugins = async (options) => {
+	const cwd = options.cwd ?? process.cwd();
+	const yes = options.yes === true;
 	const interactive = canPickAgentsInteractively() && !yes;
 	const plan = await resolvePluginsPlan({
-		global: props.global === true,
-		agents: props.agent ?? [],
+		global: options.global === true,
+		agents: options.agents ?? [],
 		yes,
 		cwd,
 		interactive
@@ -70,12 +78,14 @@ const handler = async (props) => {
 	const rows = [];
 	const failed = [];
 	const scope = scopeLabel(plan.scope);
-	for (const mapped of plan.targets) {
+	for (const [index, mapped] of plan.targets.entries()) {
 		const args = pluginsAddArgs({
 			target: mapped.target,
 			global: plan.scope === "global"
 		});
 		const agent = mapped.agents.join(", ");
+		const displayNames = mapped.agents.map((id) => getAgentDisplayName(id)).join(", ");
+		log.info("Installing the Neon plugin for %s (%d/%d)...", displayNames, index + 1, plan.targets.length);
 		try {
 			await runPluginsCli({
 				args,
@@ -102,8 +112,31 @@ const handler = async (props) => {
 			});
 		}
 	}
+	return {
+		scope: plan.scope,
+		rows,
+		failed
+	};
+};
+/** The exact error `neon plugins` throws for a failed outcome, or `undefined` on success. */
+const pluginsInstallError = (outcome) => {
+	const { failed, rows, scope } = outcome;
+	if (failed.length === 0) return;
+	const first = failed[0];
+	if (first === void 0) return /* @__PURE__ */ new Error("Failed to install the Neon plugin.");
+	const retry = neonPluginsRetryCommand({
+		agents: failed.flatMap((row) => row.agents),
+		global: scope === "global"
+	});
+	if (first.message.includes("needs npx (Node.js)")) return new Error(first.message);
+	const detail = failed.map((row) => row.message).join("\n");
+	if (failed.length === rows.length) return /* @__PURE__ */ new Error(`${detail}\nRetry with: ${retry}`);
+	return /* @__PURE__ */ new Error(`Failed to install the Neon plugin for: ${failed.flatMap((row) => row.agents).join(", ")}.\n${detail}\nRetry with: ${retry}`);
+};
+/** Writes the results table and, on success, the "Installed the Neon plugin" line. Shared by `neon plugins` and any in-process caller that wants the same human output. */
+const reportPluginsInstall = (props, outcome) => {
 	const out = writer(props);
-	out.write(rows, {
+	out.write(outcome.rows, {
 		fields: [
 			"scope",
 			"plugin",
@@ -114,21 +147,19 @@ const handler = async (props) => {
 		title: "Plugins"
 	});
 	out.end();
-	if (failed.length === 0) {
-		recordCommandSuccessExtras({ scope: plan.scope });
-		log.info(plan.scope === "project" ? "Installed the Neon plugin (project)." : "Installed the Neon plugin (user).");
-		return;
-	}
-	const first = failed[0];
-	if (first === void 0) throw new Error("Failed to install the Neon plugin.");
-	const retry = neonPluginsRetryCommand({
-		agents: failed.flatMap((row) => row.agents),
-		global: plan.scope === "global"
+	if (outcome.failed.length === 0) log.info(outcome.scope === "project" ? "Installed the Neon plugin (project)." : "Installed the Neon plugin (user).");
+};
+const handler = async (props) => {
+	const outcome = await installPlugins({
+		cwd: props.cwd,
+		yes: props.yes,
+		global: props.global,
+		agents: props.agent
 	});
-	if (first.message.includes("needs npx (Node.js)")) throw new Error(first.message);
-	const detail = failed.map((row) => row.message).join("\n");
-	if (failed.length === rows.length) throw new Error(`${detail}\nRetry with: ${retry}`);
-	throw new Error(`Failed to install the Neon plugin for: ${failed.flatMap((row) => row.agents).join(", ")}.\n${detail}\nRetry with: ${retry}`);
+	reportPluginsInstall(props, outcome);
+	const error = pluginsInstallError(outcome);
+	if (error) throw error;
+	recordCommandSuccessExtras({ scope: outcome.scope });
 };
 //#endregion
-export { aliases, builder, command, describe, handler, plugins_exports as t };
+export { aliases, builder, command, describe, handler, installPlugins, pluginsInstallError, reportPluginsInstall, plugins_exports as t };

package/dist/commands/skills.js

@@ -18,7 +18,10 @@ var skills_exports = /* @__PURE__ */ __exportAll({
 	builder: () => builder,
 	command: () => command,
 	describe: () => describe,
-	handler: () => handler
+	handler: () => handler,
+	installSkills: () => installSkills,
+	reportSkillsInstall: () => reportSkillsInstall,
+	skillsInstallError: () => skillsInstallError
 });
 const scopeLabel = (scope) => scope === "project" ? "this directory" : "user-level";
 const coerceAgents = (value) => {
@@ -83,15 +86,20 @@ const builder = (argv) => argv.usage("$0 skills [command] [options]").command("u
 		coerce: coerceSkills
 	}
 }).example("$0 skills", "Interactive: this directory, then agents, then skills").example("$0 skills -y", "This directory, detected agents (project folders, else the host CLI agent), the default skills").example("$0 skills -y -s neon -s neon-ai-gateway", "Named skills into detected agents").example("$0 skills -s neon -s neon-ai-gateway --agent cursor", "Named skills into a named agent").example("$0 skills --global", "Install user-level skills").epilogue(helpEpilogue(helpCsv("Supported agents", skillsInstallableAgents()), "Supported skills, by source repo:", skillsHelpValues(), skillsYesHelp())).strict().check(noPassthrough("skills"));
-const handler = async (props) => {
+/**
+* Plans and runs the skills install for every resolved source/invocation. No CLI-only
+* concerns here (no `writer` table, no `recordCommandSuccessExtras`): a caller that only
+* wants the outcome — `neon init` / `neon bootstrap` — gets it without rendering a table.
+*/
+const installSkills = async (options) => {
 	assertSkillsNode();
-	const cwd = process.cwd();
-	const yes = props.yes === true;
+	const cwd = options.cwd ?? process.cwd();
+	const yes = options.yes === true;
 	const interactive = canPickAgentsInteractively() && !yes;
 	const plan = await resolveSkillsPlan({
-		global: props.global === true,
-		agents: props.agent ?? [],
-		skills: props.skill ?? [],
+		global: options.global === true,
+		agents: options.agents ?? [],
+		skills: options.skills ?? [],
 		yes,
 		cwd,
 		interactive
@@ -138,8 +146,32 @@ const handler = async (props) => {
 			});
 		}
 	}
+	return {
+		scope: plan.scope,
+		agents: plan.agents,
+		rows,
+		failed
+	};
+};
+/** The exact error `neon skills` throws for a failed outcome, or `undefined` on success. */
+const skillsInstallError = (outcome) => {
+	const { failed, rows, scope, agents } = outcome;
+	if (failed.length === 0) return;
+	const first = failed[0];
+	if (first === void 0) return /* @__PURE__ */ new Error("Failed to install Neon agent skills.");
+	const retry = neonSkillsRetryCommand({
+		skills: failed.flatMap((row) => row.skills),
+		agents,
+		global: scope === "global"
+	});
+	if (first.message.includes("needs npx (Node.js)") || first.message.includes("needs Node.js")) return new Error(first.message);
+	if (failed.length === rows.length) return /* @__PURE__ */ new Error(`${first.message}\nRetry with: ${retry}`);
+	return /* @__PURE__ */ new Error(`Failed to install Neon agent skills for: ${failed.map((row) => row.label).join(", ")}.\n${first.message}\nRetry with: ${retry}`);
+};
+/** Writes the results table and, on success, the "Wrote ... skills" line. Shared by `neon skills` and any in-process caller that wants the same human output. */
+const reportSkillsInstall = (props, outcome) => {
 	const out = writer(props);
-	out.write(rows, {
+	out.write(outcome.rows, {
 		fields: [
 			"scope",
 			"skills",
@@ -150,21 +182,20 @@ const handler = async (props) => {
 		title: "Skills"
 	});
 	out.end();
-	if (failed.length === 0) {
-		recordCommandSuccessExtras({ scope: plan.scope });
-		log.info(plan.scope === "project" ? "Wrote skills in this directory." : "Wrote user-level skills.");
-		return;
-	}
-	const first = failed[0];
-	if (first === void 0) throw new Error("Failed to install Neon agent skills.");
-	const retry = neonSkillsRetryCommand({
-		skills: failed.flatMap((row) => row.skills),
-		agents: plan.agents,
-		global: plan.scope === "global"
+	if (outcome.failed.length === 0) log.info(outcome.scope === "project" ? "Wrote skills in this directory." : "Wrote user-level skills.");
+};
+const handler = async (props) => {
+	const outcome = await installSkills({
+		cwd: props.cwd,
+		yes: props.yes,
+		global: props.global,
+		agents: props.agent,
+		skills: props.skill
 	});
-	if (first.message.includes("needs npx (Node.js)") || first.message.includes("needs Node.js")) throw new Error(first.message);
-	if (failed.length === rows.length) throw new Error(`${first.message}\nRetry with: ${retry}`);
-	throw new Error(`Failed to install Neon agent skills for: ${failed.map((row) => row.label).join(", ")}.\n${first.message}\nRetry with: ${retry}`);
+	reportSkillsInstall(props, outcome);
+	const error = skillsInstallError(outcome);
+	if (error) throw error;
+	recordCommandSuccessExtras({ scope: outcome.scope });
 };
 const updateHandler = async (props) => {
 	assertSkillsNode();
@@ -219,4 +250,4 @@ const updateHandler = async (props) => {
 	if (failure !== void 0) throw new Error(failure.includes("needs npx (Node.js)") || failure.includes("needs Node.js") ? failure : `${failure}\nRetry with: ${neonSkillsUpdateRetryCommand(scope === "global")}`);
 };
 //#endregion
-export { aliases, builder, command, describe, handler, skills_exports as t };
+export { aliases, builder, command, describe, handler, installSkills, reportSkillsInstall, skillsInstallError, skills_exports as t };

package/dist/commands/snapshots.js

@@ -17,6 +17,7 @@ var snapshots_exports = /* @__PURE__ */ __exportAll({
 const SNAPSHOT_FIELDS = [
 	"id",
 	"name",
+	"slug",
 	"source_branch_id",
 	"expires_at",
 	"created_at"
@@ -38,6 +39,12 @@ const SNAPSHOT_FREQUENCIES = [
 	"weekly",
 	"monthly"
 ];
+/** Matches createSnapshot.query.slug in the Management API spec. */
+const SNAPSHOT_SLUG = /^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$/;
+const SNAPSHOT_REF = {
+	describe: "Snapshot id, unique name, or slug. Lookup order: id, unique name, slug.",
+	type: "string"
+};
 /** Narrow an arbitrary string to a supported {@link SnapshotFrequency}. */
 const isSnapshotFrequency = (value) => SNAPSHOT_FREQUENCIES.some((frequency) => frequency === value);
 const command = "snapshots";
@@ -46,7 +53,7 @@ const aliases = ["snapshot"];
 const builder = (argv) => argv.usage("$0 snapshots <sub-command> [options]").options({ "project-id": {
 	describe: "Project ID",
 	type: "string"
-} }).middleware(fillSingleProject).command("list", "List snapshots in the project", (yargs) => yargs, (args) => list(args)).command("get <id>", "Get a snapshot by id or name", (yargs) => yargs, (args) => get(args)).command("create", "Create a snapshot from a branch", (yargs) => yargs.options({
+} }).middleware(fillSingleProject).command("list", "List snapshots in the project", (yargs) => yargs, (args) => list(args)).command("get <id>", "Get a snapshot by id, unique name, or slug", (yargs) => yargs.positional("id", SNAPSHOT_REF), (args) => get(args)).command("create", "Create a snapshot from a branch", (yargs) => yargs.options({
 	branch: {
 		alias: "b",
 		describe: "Branch id or name to snapshot. Defaults to the branch in your context, or the project's default branch.",
@@ -56,6 +63,10 @@ const builder = (argv) => argv.usage("$0 snapshots <sub-command> [options]").opt
 		describe: "A name for the snapshot",
 		type: "string"
 	},
+	slug: {
+		describe: "User-defined resource ID, unique in the project (1-63 characters: start with a lowercase letter, then lowercase letters, digits, or hyphens, ending with a letter or digit). Omit to let the API generate one. It cannot be changed later.",
+		type: "string"
+	},
 	timestamp: {
 		describe: "Take the snapshot at this point in time (RFC 3339, e.g. 2025-01-01T00:00:00Z). Must fall within the branch's restore window. Mutually exclusive with --lsn.",
 		type: "string"
@@ -71,9 +82,10 @@ const builder = (argv) => argv.usage("$0 snapshots <sub-command> [options]").opt
 }).conflicts("timestamp", "lsn").example([
 	["$0 snapshots create", "Snapshot the head of the context/default branch"],
 	["$0 snapshots create --branch main --name pre-migration", "Snapshot the head of main with a name"],
+	["$0 snapshots create --branch main --name \"Before migration\" --slug before-migration", "Snapshot main with a display name and a slug"],
 	["$0 snapshots create --branch main --timestamp 2025-01-01T00:00:00Z", "Snapshot main at a point in time"],
 	["$0 snapshots create --branch main --lsn 0/1F3C8A0 --expires-at 2025-12-31T23:59:59Z", "Snapshot main at an LSN, auto-deleting at the given time"]
-]), (args) => create(args)).command("update <id>", "Update a snapshot's name or expiration", (yargs) => yargs.options({
+]), (args) => create(args)).command("update <id>", "Update a snapshot's name or expiration by id, unique name, or slug", (yargs) => yargs.positional("id", SNAPSHOT_REF).options({
 	name: {
 		describe: "Rename the snapshot",
 		type: "string"
@@ -86,7 +98,7 @@ const builder = (argv) => argv.usage("$0 snapshots <sub-command> [options]").opt
 		describe: "Clear the expiration so the snapshot is kept indefinitely.",
 		type: "boolean"
 	}
-}).conflicts("expires-at", "clear-expiration"), (args) => update(args)).command("delete <id>", "Delete a snapshot by id or name", (yargs) => yargs, (args) => deleteSnapshot(args)).command("restore <id>", "Restore a snapshot into a branch", (yargs) => yargs.options({
+}).conflicts("expires-at", "clear-expiration"), (args) => update(args)).command("delete <id>", "Delete a snapshot by id, unique name, or slug", (yargs) => yargs.positional("id", SNAPSHOT_REF), (args) => deleteSnapshot(args)).command("restore <id>", "Restore a snapshot (id, unique name, or slug) into a branch", (yargs) => yargs.positional("id", SNAPSHOT_REF).options({
 	name: {
 		describe: "Name for the newly restored branch. Auto-generated when omitted.",
 		type: "string"
@@ -155,9 +167,8 @@ const toIso = (value, flag) => {
 	return new Date(ms).toISOString();
 };
 /**
-* Resolve a snapshot from an id **or** a name. Snapshot names are not guaranteed
-* unique, so an id match wins; a name that resolves to more than one snapshot is a
-* hard error asking the user to disambiguate by id.
+* Unique names precede slugs so existing name-based commands keep targeting
+* the named snapshot when another snapshot's slug matches that name.
 */
 const resolveSnapshot = async (props) => {
 	const { data: { snapshots } } = await props.apiClient.listSnapshots(props.projectId);
@@ -166,8 +177,11 @@ const resolveSnapshot = async (props) => {
 	const byName = snapshots.filter((s) => s.name === props.id);
 	if (byName.length === 1) return byName[0];
 	if (byName.length > 1) throw new Error(`Multiple snapshots are named "${props.id}". Re-run with the snapshot id:\n${byName.map((s) => `  ${s.id}`).join("\n")}`);
-	throw new Error(`Snapshot "${props.id}" not found.\nAvailable snapshots: ${snapshots.map((s) => `${s.name} (${s.id})`).join(", ") || "none"}`);
+	const bySlug = snapshots.find((s) => s.slug === props.id);
+	if (bySlug) return bySlug;
+	throw new Error(`Snapshot "${props.id}" not found.\nAvailable snapshots: ${snapshots.map((s) => formatSnapshotRef(s)).join(", ") || "none"}`);
 };
+const formatSnapshotRef = (snapshot) => snapshot.slug ? `${snapshot.name} (${snapshot.id}, slug: ${snapshot.slug})` : `${snapshot.name} (${snapshot.id})`;
 const list = async (props) => {
 	const { data: { snapshots } } = await props.apiClient.listSnapshots(props.projectId);
 	writer(props).end(snapshots, {
@@ -187,12 +201,14 @@ const get = async (props) => {
 const create = async (props) => {
 	if (props.lsn !== void 0 && !looksLikeLSN(props.lsn)) throw new Error(`Invalid --lsn value: "${props.lsn}". Expected an LSN like 0/1F3C8A0.`);
 	if (props.timestamp !== void 0 && !looksLikeTimestamp(props.timestamp)) throw new Error(`Invalid --timestamp value: "${props.timestamp}". Use an RFC 3339 timestamp, e.g. 2025-01-01T00:00:00Z.`);
+	if (props.slug !== void 0 && !SNAPSHOT_SLUG.test(props.slug)) throw new Error(`Invalid --slug value: "${props.slug}". Use 1-63 characters: start with a lowercase letter, then lowercase letters, digits, or hyphens, and end with a letter or digit.`);
 	const { branchId } = await resolveBranchRef({
 		...props,
 		branch: props.branch
 	});
 	const { data } = await retryOnLock(() => props.apiClient.createSnapshot(props.projectId, branchId, {
 		name: props.name,
+		slug: props.slug,
 		timestamp: props.timestamp,
 		lsn: props.lsn,
 		expires_at: props.expiresAt ? toIso(props.expiresAt, "--expires-at") : void 0

package/dist/context.js

@@ -52,6 +52,34 @@ const isClaimCommand = (args) => args._[0] === "claim" || args._[0] === "claimab
 */
 const isApiKeysCommand = (args) => args._[0] === "api-keys" || args._[0] === "api-key";
 const isMcpCommand = (args) => args._[0] === "mcp";
+/**
+* `neon git install/uninstall/status` only touch the local git hooks directory and `.neon`
+* — never the Neon API — so they must work (and never pop a browser login) without
+* credentials, the same reasoning as {@link isProfileCommand}. `sync` and `cleanup` are
+* excluded: both can reach the API (`sync` always delegates to `checkout`; `cleanup` does
+* too with `--prune-neon-branches`).
+*/
+const isGitLocalCommand = (args) => args._[0] === "git" && (args._[1] === "install" || args._[1] === "uninstall" || args._[1] === "status");
+/** The env var the installed `post-checkout` hook sets before invoking `neon git sync`. */
+const GIT_HOOK_ENV_FLAG = "NEON_GIT_HOOK";
+/**
+* True only for a `neon git sync` invocation triggered by the installed `post-checkout`
+* hook, in a repo that has **not** itself run `neon git install` — the case that must never
+* touch the network (auth included). Checked before authentication runs at all, since
+* `core.hooksPath` can point at a directory shared by several repositories: the hook script
+* firing here does not by itself mean *this* repo opted in.
+*
+* The `.neon` read is deliberately **not** the usual walk-up resolution
+* ({@link currentContextFile}): a `post-checkout` hook always runs with `cwd` at the
+* repository's top level, and opt-in must be recorded by *this* repo's own `.neon` — an
+* ancestor directory's `.neon` (found by the walk-up, e.g. a parent monorepo folder that
+* happens to hold one for an unrelated project) must never authorize it.
+*/
+const isUnfollowedGitHookSync = (args, cwd = process.cwd()) => {
+	if (!(args._[0] === "git" && args._[1] === "sync")) return false;
+	if (process.env[GIT_HOOK_ENV_FLAG] !== "1") return false;
+	return readContextFile(resolve(cwd, CONTEXT_FILE)).git?.follow !== true;
+};
 const isSkillsCommand = (args) => args._[0] === "skills" || args._[0] === "skill";
 const isPluginsCommand = (args) => args._[0] === "plugins" || args._[0] === "plugin";
 const isAskCommand = (args) => args._[0] === "ask";
@@ -163,12 +191,73 @@ const updateContextFile = (file, context) => {
 * `.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.
+*
+* The {@link Context.git} block is additionally **preserved** when the caller doesn't
+* provide one, so a plain `link` / `set-context` / `checkout` never wipes the git → Neon
+* mapping a user (or `neon git sync`) built up. Pass an explicit `git` to replace it.
+*
+* That preservation is skipped when `context.projectId` differs from the file's existing
+* `projectId`: the mapping's Neon branch **names** are only meaningful within the project
+* they were recorded against, and carrying them into a different project could point
+* `neon git cleanup --prune-neon-branches` at a same-named branch that was never actually
+* mapped there.
 */
 const applyContext = (file, context) => {
 	const isNewFile = !existsSync(file);
-	updateContextFile(file, context);
+	const existing = isNewFile ? {} : readContextFile(file);
+	const projectChanged = existing.projectId !== void 0 && context.projectId !== existing.projectId;
+	const merged = context.git === void 0 && existing.git !== void 0 && !projectChanged ? {
+		...context,
+		git: existing.git
+	} : context;
+	updateContextFile(file, merged);
 	if (isNewFile) ensureGitignored(file);
 };
+/** Look up the Neon branch a git branch maps to in the persisted `.neon` context. */
+const gitBranchMapping = (context, gitBranch) => context.git?.map?.[gitBranch];
+/** The full git → Neon mapping from the context (a copy; empty when unset). */
+const gitBranchMap = (context) => ({ ...context.git?.map });
+/** Replace the git → Neon mapping in `.neon`, preserving `git.follow` and the rest. */
+const setGitBranchMap = (file, map) => {
+	const context = readContextFile(file);
+	applyContext(file, {
+		...context,
+		git: {
+			...context.git,
+			map
+		}
+	});
+};
+/**
+* Record a git branch -> Neon branch mapping in `.neon`, merging into any existing map and
+* preserving the rest of the context. Passes an explicit `git` so {@link applyContext}
+* replaces (rather than just preserves) the block with the new entry folded in.
+*/
+const setGitBranchMapping = (file, gitBranch, neonBranch) => {
+	const context = readContextFile(file);
+	const git = {
+		...context.git,
+		map: {
+			...context.git?.map,
+			[gitBranch]: neonBranch
+		}
+	};
+	applyContext(file, {
+		...context,
+		git
+	});
+};
+/** Set the `git.follow` flag (whether the post-checkout hook drives `neon git sync`). */
+const setGitFollow = (file, follow) => {
+	const context = readContextFile(file);
+	applyContext(file, {
+		...context,
+		git: {
+			...context.git,
+			follow
+		}
+	});
+};
 /**
 * 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
@@ -231,7 +320,7 @@ const ensureGitignoreEntry = (path, entry) => {
 };
 const basenameOf = (file) => {
 	const parts = file.split(/[\\/]/);
-	return parts[parts.length - 1] || CONTEXT_FILE;
+	return parts[parts.length - 1] || ".neon";
 };
 const hasGitignoreEntry = (content, entry) => {
 	return content.split(/\r?\n/).some((line) => gitignoreCovers(line.trim(), entry));
@@ -261,4 +350,4 @@ const globToRegExp = (pattern) => {
 	return new RegExp(`^${source}$`);
 };
 //#endregion
-export { applyContext, contextBranch, currentContextFile, enrichFromContext, ensureDirectoryGitignored, ensureGitignored, isApiKeysCommand, isAskCommand, isClaimCommand, isConfigInit, isCurrentBranchProbe, isInspectDbUrl, isMcpCommand, isMcpOauth, isPluginsCommand, isProfileCommand, isSkillsCommand, readContextFile, setContext, updateContextFile, walkContextFile };
+export { CONTEXT_FILE, applyContext, contextBranch, currentContextFile, enrichFromContext, ensureDirectoryGitignored, ensureGitignored, gitBranchMap, gitBranchMapping, isApiKeysCommand, isAskCommand, isClaimCommand, isConfigInit, isCurrentBranchProbe, isGitLocalCommand, isInspectDbUrl, isMcpCommand, isMcpOauth, isPluginsCommand, isProfileCommand, isSkillsCommand, isUnfollowedGitHookSync, readContextFile, setContext, setGitBranchMap, setGitBranchMapping, setGitFollow, updateContextFile, walkContextFile };

package/dist/dev/env.js

@@ -1,2 +1,2 @@
-import { a as resolveDevEnv, i as dropClaimableUnsupported, n as MissingBranchContextError, o as resolveNeonEnvVars, r as ServiceNotOnBranchError, t as DevEnvMismatchError } from "../_chunks/env-DRpFX-_d.js";
+import { a as resolveDevEnv, i as dropClaimableUnsupported, n as MissingBranchContextError, o as resolveNeonEnvVars, r as ServiceNotOnBranchError, t as DevEnvMismatchError } from "../_chunks/env-CtOH9xsl.js";
 export { DevEnvMismatchError, MissingBranchContextError, ServiceNotOnBranchError, dropClaimableUnsupported, resolveDevEnv, resolveNeonEnvVars };

package/dist/env_services.js

@@ -1,2 +1,121 @@
-import { a as envKeysForSelection, c as ownedEnvServiceKeys, d as servicesForEnvKeys, i as ENV_PULL_SERVICES, l as parseEnvPullKeys, n as ENV_PULL_KEYS, o as envPullFlagValue, r as ENV_PULL_KEY_HELP, s as envServiceKeys, t as BRANCH_ENV_KEY, u as serviceForEnvKey } from "./_chunks/env_services-DlXECBPi.js";
+import { NEON_SERVICES } from "./neon_services.js";
+import { f as parseFunctionBaseUrlKey, t as NEON_ENV_VAR_KEYS, u as isFunctionBaseUrlKey } from "./_chunks/env-N19A7qND.js";
+//#region src/env_services.ts
+const ENV_PULL_SERVICES = NEON_SERVICES;
+const ENV_PULL_KEYS = [
+	...Object.values(NEON_ENV_VAR_KEYS.postgres),
+	NEON_ENV_VAR_KEYS.branch.name,
+	...Object.values(NEON_ENV_VAR_KEYS.auth),
+	...Object.values(NEON_ENV_VAR_KEYS.dataApi),
+	...Object.values(NEON_ENV_VAR_KEYS.storage),
+	...Object.values(NEON_ENV_VAR_KEYS.aiGateway)
+];
+const ENV_PULL_KEY_HELP = `${ENV_PULL_KEYS.join(", ")}, or NEON_FUNCTION_<SLUG>_BASE_URL`;
+/** The OS-level env vars each service contributes to a pulled `.env`. */
+const SERVICE_ENV_KEYS = {
+	postgres: Object.values(NEON_ENV_VAR_KEYS.postgres),
+	auth: Object.values(NEON_ENV_VAR_KEYS.auth),
+	"data-api": Object.values(NEON_ENV_VAR_KEYS.dataApi),
+	"object-storage": Object.values(NEON_ENV_VAR_KEYS.storage),
+	"ai-gateway": Object.values(NEON_ENV_VAR_KEYS.aiGateway),
+	functions: []
+};
+/**
+* The subset of {@link SERVICE_ENV_KEYS} a pull *owns*, and so may prune from the target file
+* when the branch no longer has it. Object storage is deliberately absent: it is emitted under
+* the third-party `AWS_*` names, which collide with credentials a user may set by hand, so
+* `env pull` only ever writes them. Function URL keys cannot live here because slugs are
+* discovered at runtime.
+*/
+const SERVICE_OWNED_ENV_KEYS = {
+	...SERVICE_ENV_KEYS,
+	"object-storage": [],
+	functions: []
+};
+/**
+* Branch identity. Not a service — every branch has a name — so a scoped pull refreshes it
+* alongside whatever services were selected.
+*/
+const BRANCH_ENV_KEY = NEON_ENV_VAR_KEYS.branch.name;
+const ENV_KEY_SERVICE = {
+	DATABASE_URL: "postgres",
+	DATABASE_URL_UNPOOLED: "postgres",
+	NEON_BRANCH: null,
+	NEON_AUTH_BASE_URL: "auth",
+	NEON_AUTH_JWKS_URL: "auth",
+	NEON_DATA_API_URL: "data-api",
+	AWS_ACCESS_KEY_ID: "object-storage",
+	AWS_SECRET_ACCESS_KEY: "object-storage",
+	AWS_ENDPOINT_URL_S3: "object-storage",
+	AWS_REGION: "object-storage",
+	NEON_AI_GATEWAY_TOKEN: "ai-gateway",
+	NEON_AI_GATEWAY_BASE_URL: "ai-gateway"
+};
+const serviceForEnvKey = (key) => isFunctionBaseUrlKey(key) ? "functions" : ENV_KEY_SERVICE[key];
+/** Services that must be resolved to produce the selected env keys. */
+const servicesForEnvKeys = (keys) => ENV_PULL_SERVICES.filter((service) => keys.some((key) => serviceForEnvKey(key) === service));
+/** Every env var the selected services contribute, plus branch identity. */
+const envServiceKeys = (services) => {
+	const keys = /* @__PURE__ */ new Set([BRANCH_ENV_KEY]);
+	for (const service of services) for (const key of SERVICE_ENV_KEYS[service]) keys.add(key);
+	return keys;
+};
+/**
+* The env vars a pull scoped to `services` may prune. Narrower than the unscoped set on
+* purpose: `env pull -s ai-gateway` says nothing about `DATABASE_URL`, so it must leave it
+* alone rather than treat its absence from this pull as "the branch no longer has it".
+* Function URL keys cannot live here because slugs are discovered at runtime.
+*/
+const ownedEnvServiceKeys = (services) => services.flatMap((service) => SERVICE_OWNED_ENV_KEYS[service]);
+const envKeysForSelection = (services, envKeys) => {
+	const selected = services.length > 0 ? envServiceKeys(services) : /* @__PURE__ */ new Set();
+	for (const key of envKeys) selected.add(key);
+	if (selected.has(NEON_ENV_VAR_KEYS.storage.accessKeyId) !== selected.has(NEON_ENV_VAR_KEYS.storage.secretAccessKey)) throw new Error("AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY must be selected together: they are two halves of one newly issued object-storage credential. Add the missing key to --env, or use --service object-storage.");
+	const staticKeys = ENV_PULL_KEYS.filter((key) => selected.has(key));
+	const functionKeys = [...selected].filter(isFunctionBaseUrlKey).sort((left, right) => left.localeCompare(right));
+	return [...staticKeys, ...functionKeys];
+};
+/** Parse repeated or comma-separated `--env` values into canonical env-key order. */
+const parseEnvPullKeys = (raw, flag) => {
+	const names = raw.flatMap((value) => value.split(",")).map((name) => name.trim()).filter((name) => name !== "");
+	const supported = `Supported values: ${ENV_PULL_KEY_HELP}.`;
+	if (names.length === 0) throw new Error(`${flag} needs at least one env variable. ${supported}`);
+	const unknown = names.filter((name) => !ENV_PULL_KEYS.some((key) => key === name) && !isFunctionBaseUrlKey(name));
+	if (unknown.length > 0) {
+		const displayNames = unknown.map(redactUnknownEnvValue);
+		const suggestions = [...new Set(unknown.map(suggestEnvPullKey).filter((key) => key !== null))];
+		const suggestion = suggestions.length > 0 ? ` Did you mean ${suggestions.join(" or ")}?` : "";
+		throw new Error(`Unknown env variable${unknown.length === 1 ? "" : "s"} ${displayNames.join(", ")}.${suggestion} ${supported}`);
+	}
+	const staticKeys = ENV_PULL_KEYS.filter((key) => names.includes(key));
+	const functionKeys = [...new Set(names.filter(isFunctionBaseUrlKey))].sort((left, right) => left.localeCompare(right));
+	return [...staticKeys, ...functionKeys];
+};
+const isKnownEnvPullKey = (key) => ENV_PULL_KEYS.some((supportedKey) => supportedKey === key) || isFunctionBaseUrlKey(key);
+const redactUnknownEnvValue = (value) => {
+	const separator = value.indexOf("=");
+	if (separator !== -1) {
+		const key = value.slice(0, separator);
+		return isKnownEnvPullKey(key) ? `${key}=<redacted>` : "<redacted invalid value>";
+	}
+	return "<redacted invalid value>";
+};
+const suggestEnvPullKey = (value) => {
+	if (value.includes("=")) return null;
+	if (parseFunctionBaseUrlKey(value) !== null) return null;
+	const closest = ENV_PULL_KEYS.map((key) => [key, editDistance(value, key)]).sort((a, b) => a[1] - b[1])[0];
+	return closest && closest[1] <= 2 ? closest[0] : null;
+};
+const editDistance = (left, right) => {
+	let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+	for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+		const current = [leftIndex];
+		for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) current[rightIndex] = Math.min((previous[rightIndex] ?? 0) + 1, (current[rightIndex - 1] ?? 0) + 1, (previous[rightIndex - 1] ?? 0) + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1));
+		previous = current;
+	}
+	return previous[right.length] ?? right.length;
+};
+/** Narrow yargs' array option value without accepting any other runtime shape. */
+const envPullFlagValue = (value) => Array.isArray(value) ? value.map(String) : void 0;
+//#endregion
 export { BRANCH_ENV_KEY, ENV_PULL_KEYS, ENV_PULL_KEY_HELP, ENV_PULL_SERVICES, envKeysForSelection, envPullFlagValue, envServiceKeys, ownedEnvServiceKeys, parseEnvPullKeys, serviceForEnvKey, servicesForEnvKeys };