@prisma-next/cli 0.3.0-pr.99.5 → 0.3.0

package/dist/result-handler-oK_vA-Fn.mjs

@@ -0,0 +1,697 @@
+import { relative, resolve } from "pathe";
+import { hasMigrations } from "@prisma-next/framework-components/control";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { readFile } from "node:fs/promises";
+import { reconstructGraph } from "@prisma-next/migration-tools/dag";
+import { readMigrationsDir } from "@prisma-next/migration-tools/io";
+import { isAttested, isDraft } from "@prisma-next/migration-tools/types";
+import { blue, bold, cyan, dim, green, magenta, red } from "colorette";
+import wrapAnsi from "wrap-ansi";
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+
+//#region src/utils/formatters/helpers.ts
+/**
+* Checks if verbose output is enabled at the specified level.
+*/
+function isVerbose(flags, level) {
+	return (flags.verbose ?? 0) >= level;
+}
+/**
+* Creates a color-aware formatter function.
+* Returns a function that applies the color only if colors are enabled.
+*/
+function createColorFormatter(useColor, colorFn) {
+	return useColor ? colorFn : (text) => text;
+}
+/**
+* Formats text with dim styling if colors are enabled.
+*/
+function formatDim(useColor, text) {
+	return useColor ? dim(text) : text;
+}
+
+//#endregion
+//#region src/utils/formatters/styled.ts
+/**
+* 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 remainingWidth = LEFT_COLUMN_WIDTH$1 - stringWidth(stripAnsi(treePrefix));
+			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 subRemainingWidth = LEFT_COLUMN_WIDTH$1 - stringWidth(stripAnsi(subTreePrefix));
+				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 remainingWidth = LEFT_COLUMN_WIDTH$1 - stringWidth(stripAnsi(treePrefix));
+			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`;
+}
+
+//#endregion
+//#region src/utils/formatters/help.ts
+/**
+* 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 rightColumnWidth = calculateRightColumnWidth();
+	const wrapWidth = 2 + LEFT_COLUMN_WIDTH + 2 + rightColumnWidth - 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",
+		"migration apply": "https://pris.ly/migration-apply",
+		"migration show": "https://pris.ly/migration-show",
+		"migration status": "https://pris.ly/migration-status",
+		"migration verify": "https://pris.ly/migration-verify"
+	}[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}`);
+	}
+	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`;
+}
+
+//#endregion
+//#region src/utils/global-flags.ts
+/**
+* Parses global flags from CLI options.
+* Handles verbosity flags (-v, --trace), JSON output, quiet mode, color,
+* interactivity (--interactive/--no-interactive), and auto-accept (-y/--yes).
+*/
+function parseGlobalFlags(options) {
+	const flags = {};
+	if (options.json || !process.stdout.isTTY) 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 && !process.env["CI"];
+	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;
+}
+
+//#endregion
+//#region src/utils/command-helpers.ts
+const longDescriptions = /* @__PURE__ */ new WeakMap();
+const commandExamples = /* @__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);
+}
+/**
+* Resolves the absolute path to contract.json from the config.
+* Centralises the fallback logic shared by every command that reads the contract.
+*/
+function resolveContractPath(config) {
+	return config.contract?.output ? resolve(config.contract.output) : resolve("src/prisma/contract.json");
+}
+/**
+* Resolves the migrations directory and config path from CLI options.
+* Shared by migration-apply, migration-plan, and migration-status.
+*/
+function resolveMigrationPaths(configOption, config) {
+	const configPath = configOption ? relative(process.cwd(), resolve(configOption)) : "prisma-next.config.ts";
+	const migrationsDir = resolve(configOption ? resolve(configOption, "..") : process.cwd(), config.migrations?.dir ?? "migrations");
+	return {
+		configPath,
+		migrationsDir,
+		migrationsRelative: relative(process.cwd(), migrationsDir),
+		refsPath: resolve(migrationsDir, "refs.json")
+	};
+}
+/**
+* Maps a PathDecision to the slim CLI output representation.
+*/
+function toPathDecisionResult(decision) {
+	return {
+		fromHash: decision.fromHash,
+		toHash: decision.toHash,
+		alternativeCount: decision.alternativeCount,
+		tieBreakReasons: decision.tieBreakReasons,
+		...ifDefined("refName", decision.refName),
+		selectedPath: decision.selectedPath.map((entry) => ({
+			dirName: entry.dirName,
+			migrationId: entry.migrationId,
+			from: entry.from,
+			to: entry.to
+		}))
+	};
+}
+function targetSupportsMigrations(target) {
+	return hasMigrations(target);
+}
+function getTargetMigrations(target) {
+	return hasMigrations(target) ? target.migrations : void 0;
+}
+async function loadAllBundles(migrationsDir) {
+	const all = await readMigrationsDir(migrationsDir);
+	const attested = all.filter(isAttested);
+	return {
+		attested,
+		drafts: all.filter(isDraft),
+		graph: reconstructGraph(attested)
+	};
+}
+/**
+* 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 Error(`Contract at ${relative(process.cwd(), contractPath)} is missing a valid storage.storageHash. Run \`prisma-next contract emit\` to regenerate.`);
+	if (typeof schemaVersion !== "string") throw new Error(`Contract at ${relative(process.cwd(), contractPath)} is missing schemaVersion.`);
+	if (typeof target !== "string") throw new Error(`Contract at ${relative(process.cwd(), contractPath)} is missing target.`);
+	if (typeof targetFamily !== "string") throw new Error(`Contract at ${relative(process.cwd(), contractPath)} is missing targetFamily.`);
+	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:
+* --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("--json", "Output as 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
+//#region src/utils/formatters/errors.ts
+/**
+* Formats error output for human-readable display.
+*/
+function formatErrorOutput(error, flags) {
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	lines.push(`${formatRed("✖")} ${error.summary} (${error.code})`);
+	if (error.why) lines.push(`${formatDimText(`  Why: ${error.why}`)}`);
+	if (error.fix) lines.push(`${formatDimText(`  Fix: ${error.fix}`)}`);
+	if (error.where?.path) {
+		const whereLine = error.where.line ? `${error.where.path}:${error.where.line}` : error.where.path;
+		lines.push(`${formatDimText(`  Where: ${whereLine}`)}`);
+	}
+	if (error.meta?.["conflicts"]) {
+		const conflicts = error.meta["conflicts"];
+		if (conflicts.length > 0) {
+			const maxToShow = isVerbose(flags, 1) ? conflicts.length : Math.min(3, conflicts.length);
+			const header = isVerbose(flags, 1) ? "  Conflicts:" : `  Conflicts (showing ${maxToShow} of ${conflicts.length}):`;
+			lines.push(`${formatDimText(header)}`);
+			for (const conflict of conflicts.slice(0, maxToShow)) lines.push(`${formatDimText(`    - [${conflict.kind}] ${conflict.summary}`)}`);
+			if (!isVerbose(flags, 1) && conflicts.length > maxToShow) lines.push(`${formatDimText("  Re-run with -v/--verbose to see all conflicts")}`);
+		}
+	}
+	if (error.meta?.["issues"]) {
+		const issues = error.meta["issues"];
+		if (issues.length > 0) {
+			const maxToShow = isVerbose(flags, 1) ? issues.length : Math.min(3, issues.length);
+			const header = isVerbose(flags, 1) ? "  Issues:" : `  Issues (showing ${maxToShow} of ${issues.length}):`;
+			lines.push(`${formatDimText(header)}`);
+			for (const issue of issues.slice(0, maxToShow)) {
+				const kind = issue.kind ?? "issue";
+				const message = issue.message ?? "";
+				lines.push(`${formatDimText(`    - [${kind}] ${message}`)}`);
+			}
+			if (!isVerbose(flags, 1) && issues.length > maxToShow) lines.push(`${formatDimText("  Re-run with -v/--verbose to see all issues")}`);
+		}
+	}
+	if (error.docsUrl && isVerbose(flags, 1)) lines.push(formatDimText(error.docsUrl));
+	if (isVerbose(flags, 2) && error.meta) lines.push(`${formatDimText(`  Meta: ${JSON.stringify(error.meta, null, 2)}`)}`);
+	return lines.join("\n");
+}
+/**
+* Formats error output as JSON.
+*/
+function formatErrorJson(error) {
+	return JSON.stringify(error, null, 2);
+}
+
+//#endregion
+//#region src/utils/result-handler.ts
+/**
+* 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.domain === "CLI" ? 2 : 1;
+}
+
+//#endregion
+export { formatStyledHeader as _, maskConnectionUrl as a, formatDim as b, resolveMigrationPaths as c, setCommandExamples as d, targetSupportsMigrations as f, formatRootHelp as g, formatCommandHelp as h, loadAllBundles as i, sanitizeErrorMessage as l, parseGlobalFlags as m, addGlobalOptions as n, readContractEnvelope as o, toPathDecisionResult as p, getTargetMigrations as r, resolveContractPath as s, handleResult as t, setCommandDescriptions as u, formatSuccessMessage as v, isVerbose as x, createColorFormatter as y };
+//# sourceMappingURL=result-handler-oK_vA-Fn.mjs.map