@prisma/orm-toolchain 8.0.0-rc.1-dev.22 → 8.0.0-rc.1-dev.24

package/dist/command-helpers-bGYd7Aab-BNSzfbHK.mjs

@@ -0,0 +1,765 @@
+import { T as errorRuntime$1, f as errorInvalidOutputFormat, t as CliStructuredError$1, v as errorOutputFormatMutex } from "./cli-errors-kU09RUaz-CUkQ9XuM.mjs";
+import { a as formatErrorOutput, i as formatErrorJson, n as createTerminalUI, r as formatDim, t as createColorFormatter } from "./terminal-ui-ypPE9cN6-ilMBkmwT.mjs";
+import { c as spaceMigrationDirectory, t as APP_SPACE_ID$1 } from "./verify-contract-spaces-WvjSiWcB-DZPPCwWO.mjs";
+import "@prisma/orm-framework/utils/defined";
+import { relative, resolve } from "pathe";
+import { readFile } from "node:fs/promises";
+import { hasMigrations } from "@prisma/orm-framework/components/control";
+import { blue, bold, cyan, dim, green, magenta } from "colorette";
+import { notOk } from "@prisma/orm-framework/utils/result";
+import wrapAnsi from "wrap-ansi";
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import { isCI } from "ci-info";
+//#region ../../../1-framework/3-tooling/cli/dist/command-helpers-bGYd7Aab.mjs
+/**
+* Fixed width for left column in help output.
+*/
+const LEFT_COLUMN_WIDTH$1 = 20;
+/**
+* Creates an arrow segment badge with green background and white text.
+* Body: green background with white "prisma-next" text
+* Tip: dark grey arrow pointing right (Powerline separator)
+*/
+function createPrismaNextBadge$1(useColor) {
+	if (!useColor) return "prisma-next";
+	return bold("prisma-next");
+}
+/**
+* Creates a padding function.
+*/
+function createPadFunction() {
+	return (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+}
+/**
+* Formats a header line: brand + operation + intent
+*/
+function formatHeaderLine$1(options) {
+	if (options.operation) return `${options.brand} ${options.operation} → ${options.intent}`;
+	return `${options.brand} ${options.intent}`;
+}
+/**
+* Formats a "Read more" URL line.
+* The "Read more" label is in default color (not cyan), and the URL is blue.
+*/
+function formatReadMoreLine$1(options) {
+	const labelPadded = createPadFunction()("Read more", options.maxLabelWidth);
+	const valueColored = options.useColor ? blue(options.url) : options.url;
+	return `${options.formatDimText("│")} ${labelPadded}  ${valueColored}`;
+}
+/**
+* Pads text to a fixed width, accounting for ANSI escape codes.
+* Uses string-width to measure the actual display width.
+*/
+function padToFixedWidth(text, width) {
+	const actualWidth = stringWidth(text);
+	const padding = Math.max(0, width - actualWidth);
+	return text + " ".repeat(padding);
+}
+/**
+* Renders a command tree structure.
+* Handles both single-level (subcommands of a command) and multi-level (top-level commands with subcommands) trees.
+*/
+function renderCommandTree(options) {
+	const { commands, useColor, formatDimText, hasItemsAfter, continuationPrefix } = options;
+	const lines = [];
+	if (commands.length === 0) return lines;
+	for (let i = 0; i < commands.length; i++) {
+		const cmd = commands[i];
+		if (!cmd) continue;
+		const subcommands = cmd.commands.filter((subcmd) => !subcmd.name().startsWith("_"));
+		const isLastCommand = i === commands.length - 1;
+		if (subcommands.length > 0) {
+			const treePrefix = `${isLastCommand && !hasItemsAfter ? formatDimText("└") : formatDimText("├")}─ `;
+			const treePrefixWidth = stringWidth(stripAnsi(treePrefix));
+			const remainingWidth = LEFT_COLUMN_WIDTH$1 - treePrefixWidth;
+			const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+			const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+			lines.push(`${formatDimText("│")} ${treePrefix}${commandNameColored}`);
+			for (let j = 0; j < subcommands.length; j++) {
+				const subcmd = subcommands[j];
+				if (!subcmd) continue;
+				const isLastSubcommand = j === subcommands.length - 1;
+				const shortDescription = subcmd.description() || "";
+				const treeChar = isLastSubcommand ? "└" : "├";
+				const continuation = continuationPrefix ?? (isLastCommand && isLastSubcommand && !hasItemsAfter ? " " : formatDimText("│"));
+				const subTreePrefix = `${continuation === " " ? " " : continuation}  ${formatDimText(treeChar)}─ `;
+				const subTreePrefixWidth = stringWidth(stripAnsi(subTreePrefix));
+				const subRemainingWidth = LEFT_COLUMN_WIDTH$1 - subTreePrefixWidth;
+				const subcommandNamePadded = padToFixedWidth(subcmd.name(), subRemainingWidth);
+				const subcommandNameColored = useColor ? cyan(subcommandNamePadded) : subcommandNamePadded;
+				lines.push(`${formatDimText("│")} ${subTreePrefix}${subcommandNameColored}  ${shortDescription}`);
+			}
+		} else {
+			const treePrefix = `${isLastCommand && !hasItemsAfter ? formatDimText("└") : formatDimText("├")}─ `;
+			const treePrefixWidth = stringWidth(stripAnsi(treePrefix));
+			const remainingWidth = LEFT_COLUMN_WIDTH$1 - treePrefixWidth;
+			const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+			const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+			const shortDescription = cmd.description() || "";
+			lines.push(`${formatDimText("│")} ${treePrefix}${commandNameColored}  ${shortDescription}`);
+		}
+	}
+	return lines;
+}
+/**
+* Formats the header in the new experimental visual style.
+* This header appears at the start of command output, showing the operation,
+* intent, documentation link, and parameters.
+*/
+function formatStyledHeader(options) {
+	const lines = [];
+	const useColor = options.flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	const brand = createPrismaNextBadge$1(useColor);
+	const operation = useColor ? bold(options.command) : options.command;
+	const intent = formatDimText(options.description);
+	lines.push(formatHeaderLine$1({
+		brand,
+		operation,
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	for (const detail of options.details) {
+		const labelPadded = padToFixedWidth(`${detail.label}:`, LEFT_COLUMN_WIDTH$1);
+		const labelColored = useColor ? cyan(labelPadded) : labelPadded;
+		lines.push(`${formatDimText("│")} ${labelColored}  ${detail.value}`);
+	}
+	if (options.url) {
+		lines.push(formatDimText("│"));
+		lines.push(formatReadMoreLine$1({
+			url: options.url,
+			maxLabelWidth: LEFT_COLUMN_WIDTH$1,
+			useColor,
+			formatDimText
+		}));
+	}
+	lines.push(formatDimText("└"));
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Formats a success message in the styled output format.
+*/
+function formatSuccessMessage(flags) {
+	return `${createColorFormatter(flags.color !== false, green)("✔")} Success`;
+}
+/**
+* Fixed width for left column in help output.
+* Must match the value in styled.ts.
+*/
+const LEFT_COLUMN_WIDTH = 20;
+/**
+* Minimum width for right column wrapping in help output.
+*/
+const RIGHT_COLUMN_MIN_WIDTH = 40;
+/**
+* Maximum width for right column wrapping in help output (when terminal is wide enough).
+*/
+const RIGHT_COLUMN_MAX_WIDTH = 90;
+/**
+* Gets the terminal width, or returns a default if not available.
+*/
+function getTerminalWidth() {
+	const terminalWidth = process.stderr.columns || process.stdout.columns;
+	const envWidth = Number.parseInt(process.env["CLI_WIDTH"] || "", 10);
+	return terminalWidth || (Number.isFinite(envWidth) ? envWidth : 80);
+}
+/**
+* Calculates the available width for the right column based on terminal width.
+*/
+function calculateRightColumnWidth() {
+	const availableWidth = getTerminalWidth() - 2 - LEFT_COLUMN_WIDTH - 2;
+	return Math.max(RIGHT_COLUMN_MIN_WIDTH, Math.min(availableWidth, RIGHT_COLUMN_MAX_WIDTH));
+}
+/**
+* Creates the CLI brand badge.
+*/
+function createPrismaNextBadge(useColor) {
+	return useColor ? bold("prisma-next") : "prisma-next";
+}
+/**
+* Formats a header line: brand + operation + intent
+*/
+function formatHeaderLine(options) {
+	if (options.operation) return `${options.brand} ${options.operation} → ${options.intent}`;
+	return `${options.brand} ${options.intent}`;
+}
+/**
+* Wraps text to fit within a specified width using wrap-ansi.
+*/
+function wrapTextAnsi(text, width) {
+	return wrapAnsi(text, width, {
+		hard: false,
+		trim: true
+	}).split("\n");
+}
+/**
+* Formats a default value as "default: <value>" with dimming.
+*/
+function formatDefaultValue(value, useColor) {
+	const defaultText = `default: ${String(value)}`;
+	return useColor ? dim(defaultText) : defaultText;
+}
+/**
+* Formats a "Read more" URL line.
+*/
+function formatReadMoreLine(options) {
+	const labelPadded = `Read more${" ".repeat(Math.max(0, options.maxLabelWidth - 9))}`;
+	const valueColored = options.useColor ? blue(options.url) : options.url;
+	return `${options.formatDimText("│")} ${labelPadded}  ${valueColored}`;
+}
+/**
+* Formats multiline description with "Prisma Next" in green.
+*/
+function formatMultilineDescription(options) {
+	const lines = [];
+	const formatGreen = (text) => options.useColor ? green(text) : text;
+	const wrapWidth = 24 + calculateRightColumnWidth() - 2;
+	for (const descLine of options.descriptionLines) {
+		const wrappedLines = wrapTextAnsi(descLine.replace(/Prisma Next/g, (match) => formatGreen(match)), wrapWidth);
+		for (const wrappedLine of wrappedLines) lines.push(`${options.formatDimText("│")} ${wrappedLine}`);
+	}
+	return lines;
+}
+/**
+* Maps command paths to their documentation URLs.
+*/
+function getCommandDocsUrl(commandPath) {
+	return {
+		"contract emit": "https://pris.ly/contract-emit",
+		"contract infer": "https://pris.ly/contract-infer",
+		"db schema": "https://pris.ly/db-schema",
+		"db verify": "https://pris.ly/db-verify",
+		"db update": "https://pris.ly/db-update",
+		"migration plan": "https://pris.ly/migration-plan",
+		migrate: "https://pris.ly/migrate",
+		"migration show": "https://pris.ly/migration-show",
+		"migration status": "https://pris.ly/migration-status"
+	}[commandPath];
+}
+/**
+* Builds the full command path from a command and its parents.
+*/
+function buildCommandPath(command) {
+	const parts = [];
+	let current = command;
+	while (current && current.name() !== "prisma-next") {
+		parts.unshift(current.name());
+		current = current.parent ?? void 0;
+	}
+	return parts.join(" ");
+}
+/**
+* Formats help output for a command using the styled format.
+*/
+function formatCommandHelp(options) {
+	const { command, flags } = options;
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	const commandPath = buildCommandPath(command);
+	const shortDescription = command.description() || "";
+	const longDescription = getLongDescription(command);
+	const argsSuffix = command.registeredArguments.map((arg) => arg.required ? `<${arg.name()}>` : `[${arg.name()}]`).join(" ");
+	const brand = createPrismaNextBadge(useColor);
+	const commandWithArgs = argsSuffix ? `${commandPath} ${argsSuffix}` : commandPath;
+	const operation = useColor ? bold(commandWithArgs) : commandWithArgs;
+	const intent = formatDimText(shortDescription);
+	lines.push(formatHeaderLine({
+		brand,
+		operation,
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	const optionsList = command.options.map((opt) => {
+		const description = opt.description || "";
+		const defaultValue = opt.defaultValue;
+		return {
+			flags: opt.flags,
+			description,
+			defaultValue
+		};
+	});
+	const subcommands = command.commands.filter((cmd) => !cmd.name().startsWith("_"));
+	if (subcommands.length > 0) {
+		const treeLines = renderCommandTree({
+			commands: subcommands,
+			useColor,
+			formatDimText,
+			hasItemsAfter: optionsList.length > 0
+		});
+		lines.push(...treeLines);
+	}
+	if (subcommands.length > 0 && optionsList.length > 0) lines.push(formatDimText("│"));
+	if (optionsList.length > 0) for (const opt of optionsList) {
+		const flagsPadded = padToFixedWidth(opt.flags, LEFT_COLUMN_WIDTH);
+		let flagsColored = flagsPadded;
+		if (useColor) {
+			flagsColored = flagsPadded.replace(/(<[^>]+>)/g, (match) => magenta(match));
+			flagsColored = cyan(flagsColored);
+		}
+		const rightColumnWidth = calculateRightColumnWidth();
+		const wrappedDescription = wrapTextAnsi(opt.description, rightColumnWidth);
+		lines.push(`${formatDimText("│")} ${flagsColored}  ${wrappedDescription[0] || ""}`);
+		for (let i = 1; i < wrappedDescription.length; i++) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${wrappedDescription[i] || ""}`);
+		}
+		if (opt.defaultValue !== void 0) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			const defaultText = formatDefaultValue(opt.defaultValue, useColor);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${defaultText}`);
+		}
+	}
+	const docsUrl = getCommandDocsUrl(commandPath);
+	if (docsUrl) {
+		lines.push(formatDimText("│"));
+		lines.push(formatReadMoreLine({
+			url: docsUrl,
+			maxLabelWidth: LEFT_COLUMN_WIDTH,
+			useColor,
+			formatDimText
+		}));
+	}
+	const examples = getCommandExamples(command);
+	if (examples && examples.length > 0) {
+		lines.push(formatDimText("│"));
+		lines.push(`${formatDimText("│")} ${formatDimText("Examples:")}`);
+		for (const example of examples) lines.push(`${formatDimText("│")}   ${useColor ? dim("$") : "$"} ${example}`);
+	}
+	const seeAlso = getCommandSeeAlso(command);
+	if (seeAlso && seeAlso.length > 0) {
+		lines.push(formatDimText("│"));
+		lines.push(`${formatDimText("│")} ${formatDimText("See also:")}`);
+		for (const ref of seeAlso) lines.push(`${formatDimText("│")}   ${ref.verb}  ${formatDimText(ref.oneLiner)}`);
+	}
+	if (longDescription) {
+		lines.push(formatDimText("│"));
+		const descriptionLines = longDescription.split("\n").filter((line) => line.trim().length > 0);
+		lines.push(...formatMultilineDescription({
+			descriptionLines,
+			useColor,
+			formatDimText
+		}));
+	}
+	lines.push(formatDimText("└"));
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Formats help output for the root program using the styled format.
+*/
+function formatRootHelp(options) {
+	const { program, flags } = options;
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	const brand = createPrismaNextBadge(useColor);
+	const intent = formatDimText("Manage your data layer");
+	lines.push(formatHeaderLine({
+		brand,
+		operation: "",
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	const topLevelCommands = program.commands.filter((cmd) => !cmd.name().startsWith("_") && cmd.name() !== "help");
+	const globalOptions = program.options.map((opt) => {
+		const description = opt.description || "";
+		const defaultValue = opt.defaultValue;
+		return {
+			flags: opt.flags,
+			description,
+			defaultValue
+		};
+	});
+	if (topLevelCommands.length > 0) {
+		const treeLines = renderCommandTree({
+			commands: topLevelCommands,
+			useColor,
+			formatDimText,
+			hasItemsAfter: globalOptions.length > 0
+		});
+		lines.push(...treeLines);
+	}
+	if (topLevelCommands.length > 0 && globalOptions.length > 0) lines.push(formatDimText("│"));
+	if (globalOptions.length > 0) for (const opt of globalOptions) {
+		const flagsPadded = padToFixedWidth(opt.flags, LEFT_COLUMN_WIDTH);
+		let flagsColored = flagsPadded;
+		if (useColor) {
+			flagsColored = flagsPadded.replace(/(<[^>]+>)/g, (match) => magenta(match));
+			flagsColored = cyan(flagsColored);
+		}
+		const rightColumnWidth = calculateRightColumnWidth();
+		const wrappedDescription = wrapTextAnsi(opt.description, rightColumnWidth);
+		lines.push(`${formatDimText("│")} ${flagsColored}  ${wrappedDescription[0] || ""}`);
+		for (let i = 1; i < wrappedDescription.length; i++) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${wrappedDescription[i] || ""}`);
+		}
+		if (opt.defaultValue !== void 0) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			const defaultText = formatDefaultValue(opt.defaultValue, useColor);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${defaultText}`);
+		}
+	}
+	const formatGreen = (text) => useColor ? green(text) : text;
+	const descriptionLines = [`Use ${formatGreen("Prisma Next")} to define your data layer as a contract. Sign your database and application with the same contract to guarantee compatibility. Plan and apply migrations to safely evolve your schema.`];
+	if (descriptionLines.length > 0) {
+		lines.push(formatDimText("│"));
+		lines.push(...formatMultilineDescription({
+			descriptionLines,
+			useColor,
+			formatDimText
+		}));
+	}
+	lines.push(formatDimText("└"));
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Returns true when the process is running in any CI environment recognised
+* by the `ci-info` package. The single source of truth for CI detection
+* across this CLI — colour-output suppression and telemetry-skip both call
+* this helper, so neither path drifts from the other when a new CI provider
+* is added upstream.
+*
+* `ci-info` checks the standard `CI=true` marker plus dozens of
+* provider-specific environment variables (Buildkite, Jenkins, Drone,
+* Bitbucket Pipelines, Azure Pipelines, AWS CodeBuild, …) that the raw
+* `process.env.CI` read misses.
+*
+*/
+function isCI$1() {
+	return isCI;
+}
+/**
+* Processes a CLI command result, handling both success and error cases.
+* Formats output appropriately and returns the exit code.
+* Never throws - returns exit code for commands to use with process.exit().
+*
+* Error output:
+* - JSON mode: JSON error to stdout (piped) via ui.output(), human sees nothing on stderr.
+* - Interactive: human-readable error to stderr.
+*/
+function handleResult(result, flags, ui, onSuccess) {
+	if (result.ok) {
+		if (onSuccess) onSuccess(result.value);
+		return 0;
+	}
+	const envelope = result.failure.toEnvelope();
+	if (flags.json) ui.output(formatErrorJson(envelope));
+	else ui.error(formatErrorOutput(envelope, flags));
+	return result.failure.code === "CLI.INIT_USER_ABORTED" ? 3 : 2;
+}
+function isJsonFlagSet(json) {
+	return json === true;
+}
+function resolveOutputFormat(options) {
+	const formatOption = options.format;
+	const jsonFlag = isJsonFlagSet(options.json);
+	if (formatOption !== void 0) {
+		if (formatOption !== "pretty" && formatOption !== "json") throw errorInvalidOutputFormat(formatOption);
+		if (jsonFlag && formatOption === "pretty") throw errorOutputFormatMutex();
+		return {
+			format: formatOption,
+			explicitFormat: true
+		};
+	}
+	if (jsonFlag) return {
+		format: "json",
+		explicitFormat: false
+	};
+	if (!process.stdout.isTTY) return {
+		format: "json",
+		explicitFormat: false
+	};
+	return {
+		format: "pretty",
+		explicitFormat: false
+	};
+}
+function inferJsonModeForParseError(options) {
+	if (options.format === "json") return true;
+	if (isJsonFlagSet(options.json) && options.format !== "pretty") return true;
+	if (options.format !== void 0) return false;
+	return !process.stdout.isTTY;
+}
+function emitGlobalFlagParseError(error, options) {
+	const jsonMode = inferJsonModeForParseError(options);
+	const flags = {
+		format: jsonMode ? "json" : "pretty",
+		explicitFormat: false,
+		...jsonMode ? { json: true } : {},
+		color: false,
+		verbose: 0,
+		interactive: false
+	};
+	const ui = createTerminalUI(flags);
+	const exitCode = handleResult(notOk(error), flags, ui);
+	process.exit(exitCode);
+}
+/**
+* Parses global flags from CLI options.
+* Handles verbosity flags (-v, --trace), output format (--format, --json),
+* quiet mode, color, interactivity (--interactive/--no-interactive), and
+* auto-accept (-y/--yes).
+*
+* On invalid or conflicting format flags, prints a structured CLI error
+* envelope and exits with code 2.
+*/
+function parseGlobalFlagsOrExit(options) {
+	try {
+		return parseGlobalFlags(options);
+	} catch (error) {
+		if (CliStructuredError$1.is(error)) emitGlobalFlagParseError(error, options);
+		throw error;
+	}
+}
+/**
+* Parses global flags from CLI options.
+* Handles verbosity flags (-v, --trace), output format (--format, --json),
+* quiet mode, color, interactivity (--interactive/--no-interactive), and
+* auto-accept (-y/--yes).
+*
+* Throws {@link CliStructuredError} for invalid or conflicting format flags.
+*/
+function parseGlobalFlags(options) {
+	const { format, explicitFormat } = resolveOutputFormat(options);
+	const flags = {
+		format,
+		explicitFormat
+	};
+	if (format === "json") flags.json = true;
+	if (options.quiet || options.q) flags.quiet = true;
+	if (options.trace || process.env["PRISMA_NEXT_TRACE"] === "1") flags.verbose = 2;
+	else if (options.verbose || options.v || process.env["PRISMA_NEXT_DEBUG"] === "1") flags.verbose = 1;
+	else flags.verbose = 0;
+	if (process.env["NO_COLOR"] || flags.json) flags.color = false;
+	else if (options["no-color"]) flags.color = false;
+	else if (options.color !== void 0) flags.color = options.color;
+	else flags.color = process.stdout.isTTY && !isCI$1();
+	if (options["no-interactive"]) flags.interactive = false;
+	else if (options.interactive !== void 0) flags.interactive = options.interactive;
+	else flags.interactive = !!process.stdout.isTTY;
+	if (options.yes || options.y) flags.yes = true;
+	return flags;
+}
+/**
+* Bridges the two TTY checks (stdout via `flags`, stdin via
+* `process.stdin.isTTY`) into the `canPrompt` boolean the interactive
+* `init` flow consumes.
+*
+* Per the [Style Guide § Interactivity](../../../../../../../docs/CLI%20Style%20Guide.md#interactivity):
+*
+* - `flags.interactive` governs *decoration* (TerminalUI, intro/outro,
+*   spinners) and is derived from stdout-TTY by `parseGlobalFlags`,
+*   honouring `--interactive` / `--no-interactive`.
+* - Prompting additionally requires a stdin TTY — closing stdin is a
+*   common signal in CI / agent environments even when stdout stays
+*   attached.
+* - `--interactive` is the explicit override: when the user passes it,
+*   we honour it (e.g. testing flows where stdin is stubbed).
+*
+* Single source of truth for the interactive-prompt decision: both the
+* `init` action handler and the preAction telemetry bridge derive
+* prompt-eligibility from this helper so they cannot drift. Lives in
+* `global-flags` (alongside `parseGlobalFlags`) to keep
+* `utils/telemetry` and `commands/init/index` free of an import cycle.
+*
+* Exported so callers and tests can derive the same value without
+* touching `process` globals.
+*/
+function deriveCanPrompt(opts) {
+	if (opts.optionInteractive === true) return true;
+	if (opts.flagsInteractive === false) return false;
+	return opts.stdinIsTTY;
+}
+const longDescriptions = /* @__PURE__ */ new WeakMap();
+const commandExamples = /* @__PURE__ */ new WeakMap();
+const commandSeeAlso = /* @__PURE__ */ new WeakMap();
+/**
+* Sets both short and long descriptions for a command.
+* The short description is used in command trees and headers.
+* The long description is shown at the bottom of help output.
+*/
+function setCommandDescriptions(command, shortDescription, longDescription) {
+	command.description(shortDescription);
+	if (longDescription) longDescriptions.set(command, longDescription);
+	return command;
+}
+/**
+* Sets copy-pastable examples for a command, shown in help text.
+*/
+function setCommandExamples(command, examples) {
+	commandExamples.set(command, examples);
+	return command;
+}
+/**
+* Gets the long description from a command if it was set via setCommandDescriptions.
+*/
+function getLongDescription(command) {
+	return longDescriptions.get(command);
+}
+/**
+* Gets examples from a command if set via setCommandExamples.
+*/
+function getCommandExamples(command) {
+	return commandExamples.get(command);
+}
+/**
+* Sets cross-references to related commands, rendered in a "See also"
+* section below the Examples block in help output.
+*/
+function setCommandSeeAlso(command, refs) {
+	commandSeeAlso.set(command, refs);
+	return command;
+}
+/**
+* Gets the see-also cross-references from a command.
+*/
+function getCommandSeeAlso(command) {
+	return commandSeeAlso.get(command);
+}
+/**
+* Resolves the absolute path to contract.json from the config.
+*/
+function resolveContractPath(config) {
+	if (config.contract?.output === void 0) throw errorRuntime$1("CONFIG.VALIDATION_FAILED", "config.contract.output is required to resolve the contract path", {
+		why: "CLI commands read the emitted contract from config.contract.output; the config has no value to read.",
+		fix: "Ensure your prisma-next.config.ts goes through `defineConfig()`, which normalises a default output when the provider supplies an input path, or set `contract.output` explicitly."
+	});
+	return resolve(config.contract.output);
+}
+/**
+* Resolves the migrations directory and config path from CLI options.
+* Shared by migrate, migration-plan, and migration-status.
+*
+* - `migrationsDir` is the project's top-level `migrations/` directory
+*   (the root that the aggregate loader walks for every contract space).
+* - `appMigrationsDir` is the app subspace directory under it
+*   (`<migrationsDir>/<APP_SPACE_ID>/`). Every per-app reader / writer
+*   (`migration new`, `migration plan`, `migrate`,
+*   `migration status`, `migration show`, `migration ref`) operates on
+*   this directory. Extensions own their own `migrations/<spaceId>/`.
+* - `refsDir` is the app's refs directory (`<appMigrationsDir>/refs/`).
+*   The framework does not maintain refs at the migrations root.
+*
+* `cwd` is the directory the command was invoked from; every relative path in
+* the result is computed against it.
+*/
+function resolveMigrationPaths(configOption, config, cwd) {
+	const resolvedConfigPath = configOption ? resolve(cwd, configOption) : void 0;
+	const configPath = resolvedConfigPath ? relative(cwd, resolvedConfigPath) : "prisma-next.config.ts";
+	const migrationsDir = resolve(resolvedConfigPath ? resolve(resolvedConfigPath, "..") : cwd, config.migrations?.dir ?? "migrations");
+	const migrationsRelative = relative(cwd, migrationsDir);
+	const appMigrationsDir = spaceMigrationDirectory(migrationsDir, APP_SPACE_ID$1);
+	return {
+		configPath,
+		migrationsDir,
+		migrationsRelative,
+		appMigrationsDir,
+		appMigrationsRelative: relative(cwd, appMigrationsDir),
+		refsDir: resolve(appMigrationsDir, "refs")
+	};
+}
+function collectDeclaredInvariants(graph) {
+	const declared = /* @__PURE__ */ new Set();
+	for (const edges of graph.forwardChain.values()) for (const edge of edges) for (const inv of edge.invariants) declared.add(inv);
+	return declared;
+}
+/**
+* Maps a `MigrationEdge` to the structural-edge shape used in the
+* `MIGRATION.NO_INVARIANT_PATH` error envelope. Shared between
+* `migrate` and `migration status` so both commands surface
+* the same JSON wire shape when an invariant-aware route is unsatisfiable.
+*/
+function toStructuralEdge(edge) {
+	return {
+		dirName: edge.dirName,
+		migrationHash: edge.migrationHash,
+		from: edge.from,
+		to: edge.to,
+		invariants: edge.invariants
+	};
+}
+function targetSupportsMigrations(target) {
+	return hasMigrations(target);
+}
+function getTargetMigrations(target) {
+	return hasMigrations(target) ? target.migrations : void 0;
+}
+/**
+* Reads and parses contract.json, validating the framework-level envelope
+* fields (storageHash, schemaVersion, target, targetFamily).
+*
+* Family-specific validation (storage structure, codec mappings, etc.)
+* happens downstream in the control client via the family instance.
+*/
+async function readContractEnvelope(config) {
+	const contractPath = resolveContractPath(config);
+	const content = await readFile(contractPath, "utf-8");
+	const json = JSON.parse(content);
+	const { schemaVersion, target, targetFamily, profileHash } = json;
+	const storageHash = json["storage"]?.["storageHash"];
+	if (typeof storageHash !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing a valid storage.storageHash. Run \`prisma-next contract emit\` to regenerate.`, { where: { path: contractPath } });
+	if (typeof schemaVersion !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing schemaVersion.`, { where: { path: contractPath } });
+	if (typeof target !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing target.`, { where: { path: contractPath } });
+	if (typeof targetFamily !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing targetFamily.`, { where: { path: contractPath } });
+	return {
+		...json,
+		storageHash,
+		schemaVersion,
+		target,
+		targetFamily,
+		...typeof profileHash === "string" ? { profileHash } : {}
+	};
+}
+/**
+* Masks credentials in a database connection URL.
+* Handles standard URLs (username + password + query params) and libpq-style key=value strings.
+*/
+function maskConnectionUrl(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.username) parsed.username = "****";
+		if (parsed.password) parsed.password = "****";
+		for (const key of [...parsed.searchParams.keys()]) if (/password/i.test(key)) parsed.searchParams.set(key, "****");
+		return parsed.toString();
+	} catch {
+		return url.replace(/password\s*=\s*\S+/gi, "password=****").replace(/user\s*=\s*\S+/gi, "user=****");
+	}
+}
+/**
+* Strips raw connection URL fragments from an error message to prevent credential leakage.
+* Call this before surfacing driver errors to the user.
+*/
+function sanitizeErrorMessage(message, connectionUrl) {
+	if (!connectionUrl) return message;
+	try {
+		const parsed = new URL(connectionUrl);
+		let sanitized = message;
+		sanitized = sanitized.replaceAll(connectionUrl, maskConnectionUrl(connectionUrl));
+		if (parsed.password) sanitized = sanitized.replaceAll(parsed.password, "****");
+		if (parsed.username) sanitized = sanitized.replaceAll(parsed.username, "****");
+		return sanitized;
+	} catch {
+		return message.replace(/password\s*=\s*\S+/gi, "password=****").replace(/user\s*=\s*\S+/gi, "user=****");
+	}
+}
+/**
+* Registers the global CLI options shared by every command:
+* --format, --json, -q/--quiet, -v/--verbose, --trace, --color, --no-color,
+* --interactive, --no-interactive, -y/--yes.
+*
+* Also sets up the styled help formatter.
+*/
+function addGlobalOptions(command) {
+	return command.configureHelp({ formatHelp: (cmd) => {
+		return formatCommandHelp({
+			command: cmd,
+			flags: parseGlobalFlags({})
+		});
+	} }).option("--format <pretty|json>", "Output format (default: pretty, or json when stdout is not a TTY)").option("--json", "Output as JSON (alias for --format json)").option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("--trace", "Trace output: deep internals, stack traces").option("--color", "Force color output").option("--no-color", "Disable color output").option("--interactive", "Force interactive mode").option("--no-interactive", "Disable interactive prompts").option("-y, --yes", "Auto-accept prompts");
+}
+//#endregion
+export { toStructuralEdge as S, sanitizeErrorMessage as _, formatRootHelp as a, setCommandSeeAlso as b, getTargetMigrations as c, maskConnectionUrl as d, parseGlobalFlags as f, resolveMigrationPaths as g, resolveContractPath as h, formatCommandHelp as i, handleResult as l, readContractEnvelope as m, collectDeclaredInvariants as n, formatStyledHeader as o, parseGlobalFlagsOrExit as p, deriveCanPrompt as r, formatSuccessMessage as s, addGlobalOptions as t, isCI$1 as u, setCommandDescriptions as v, targetSupportsMigrations as x, setCommandExamples as y };
+
+//# sourceMappingURL=command-helpers-bGYd7Aab-BNSzfbHK.mjs.map