@prisma-next/cli 0.3.0-dev.4 → 0.3.0-dev.41

package/dist/result-handler-BZPY7HX4.mjs

@@ -0,0 +1,1029 @@
+import { relative } from "node:path";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { bgGreen, blue, bold, cyan, dim, green, magenta, red, yellow } from "colorette";
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+import ora from "ora";
+
+//#region src/utils/command-helpers.ts
+/**
+* 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) command._longDescription = longDescription;
+	return command;
+}
+/**
+* Gets the long description from a command if it was set via setCommandDescriptions.
+*/
+function getLongDescription(command) {
+	return command._longDescription;
+}
+
+//#endregion
+//#region src/utils/global-flags.ts
+/**
+* Parses global flags from CLI options.
+* Handles verbosity flags (-v, -vv, --trace), JSON output, quiet mode, timestamps, and color.
+*/
+function parseGlobalFlags(options) {
+	const flags = {};
+	if (options.json === true || options.json === "object") flags.json = "object";
+	else if (options.json === "ndjson") flags.json = "ndjson";
+	if (options.quiet || options.q) flags.quiet = true;
+	if (options.vv || options.trace) flags.verbose = 2;
+	else if (options.verbose || options.v) flags.verbose = 1;
+	else flags.verbose = 0;
+	if (options.timestamps) flags.timestamps = true;
+	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"];
+	return flags;
+}
+
+//#endregion
+//#region src/utils/output.ts
+/**
+* Formats a timestamp for output.
+*/
+function formatTimestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/**
+* Creates a prefix string if timestamps are enabled.
+*/
+function createPrefix(flags) {
+	return flags.timestamps ? `[${formatTimestamp()}] ` : "";
+}
+/**
+* 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;
+}
+/**
+* Formats human-readable output for contract emit.
+*/
+function formatEmitOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const jsonPath = relative(process.cwd(), result.files.json);
+	const dtsPath = relative(process.cwd(), result.files.dts);
+	lines.push(`${prefix}✔ Emitted contract.json → ${jsonPath}`);
+	lines.push(`${prefix}✔ Emitted contract.d.ts → ${dtsPath}`);
+	lines.push(`${prefix}  storageHash: ${result.storageHash}`);
+	if (result.executionHash) lines.push(`${prefix}  executionHash: ${result.executionHash}`);
+	if (result.profileHash) lines.push(`${prefix}  profileHash: ${result.profileHash}`);
+	if (isVerbose(flags, 1)) lines.push(`${prefix}  Total time: ${result.timings.total}ms`);
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for contract emit.
+*/
+function formatEmitJson(result) {
+	const output = {
+		ok: true,
+		storageHash: result.storageHash,
+		...ifDefined("executionHash", result.executionHash),
+		...result.profileHash ? { profileHash: result.profileHash } : {},
+		outDir: result.outDir,
+		files: result.files,
+		timings: result.timings
+	};
+	return JSON.stringify(output, null, 2);
+}
+/**
+* Formats error output for human-readable display.
+*/
+function formatErrorOutput(error, flags) {
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	lines.push(`${prefix}${formatRed("✖")} ${error.summary} (${error.code})`);
+	if (error.why) lines.push(`${prefix}${formatDimText(`  Why: ${error.why}`)}`);
+	if (error.fix) lines.push(`${prefix}${formatDimText(`  Fix: ${error.fix}`)}`);
+	if (error.where?.path) {
+		const whereLine = error.where.line ? `${error.where.path}:${error.where.line}` : error.where.path;
+		lines.push(`${prefix}${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(`${prefix}${formatDimText(header)}`);
+			for (const conflict of conflicts.slice(0, maxToShow)) lines.push(`${prefix}${formatDimText(`    - [${conflict.kind}] ${conflict.summary}`)}`);
+			if (!isVerbose(flags, 1) && conflicts.length > maxToShow) lines.push(`${prefix}${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(`${prefix}${formatDimText(header)}`);
+			for (const issue of issues.slice(0, maxToShow)) {
+				const kind = issue.kind ?? "issue";
+				const message = issue.message ?? "";
+				lines.push(`${prefix}${formatDimText(`    - [${kind}] ${message}`)}`);
+			}
+			if (!isVerbose(flags, 1) && issues.length > maxToShow) lines.push(`${prefix}${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(`${prefix}${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);
+}
+/**
+* Formats human-readable output for database verify.
+*/
+function formatVerifyOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (result.ok) {
+		lines.push(`${prefix}${formatGreen("✔")} ${result.summary}`);
+		lines.push(`${prefix}${formatDimText(`  storageHash: ${result.contract.storageHash}`)}`);
+		if (result.contract.profileHash) lines.push(`${prefix}${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
+	} else lines.push(`${prefix}${formatRed("✖")} ${result.summary} (${result.code})`);
+	if (isVerbose(flags, 1)) {
+		if (result.codecCoverageSkipped) lines.push(`${prefix}${formatDimText("  Codec coverage check skipped (helper returned no supported types)")}`);
+		lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for database verify.
+*/
+function formatVerifyJson(result) {
+	const output = {
+		ok: result.ok,
+		...result.code ? { code: result.code } : {},
+		summary: result.summary,
+		contract: result.contract,
+		...result.marker ? { marker: result.marker } : {},
+		target: result.target,
+		...result.missingCodecs ? { missingCodecs: result.missingCodecs } : {},
+		...result.meta ? { meta: result.meta } : {},
+		timings: result.timings
+	};
+	return JSON.stringify(output, null, 2);
+}
+/**
+* Formats JSON output for database introspection.
+*/
+function formatIntrospectJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Renders a schema tree structure from CoreSchemaView.
+* Matches the style of renderSchemaVerificationTree for consistency.
+*/
+function renderSchemaTree(node, flags, options) {
+	const { isLast, prefix, useColor, formatDimText, isRoot = false } = options;
+	const lines = [];
+	let formattedLabel = node.label;
+	if (useColor) switch (node.kind) {
+		case "root":
+			formattedLabel = bold(node.label);
+			break;
+		case "entity": {
+			const tableMatch = node.label.match(/^table\s+(.+)$/);
+			if (tableMatch?.[1]) {
+				const tableName = tableMatch[1];
+				formattedLabel = `${dim("table")} ${cyan(tableName)}`;
+			} else formattedLabel = cyan(node.label);
+			break;
+		}
+		case "collection":
+			formattedLabel = dim(node.label);
+			break;
+		case "field": {
+			const columnMatch = node.label.match(/^([^:]+):\s*(.+)$/);
+			if (columnMatch?.[1] && columnMatch[2]) {
+				const columnName = columnMatch[1];
+				const rest = columnMatch[2];
+				const typeMatch = rest.match(/^([^\s(]+)\s*(\([^)]+\))$/);
+				if (typeMatch?.[1] && typeMatch[2]) {
+					const typeDisplay = typeMatch[1];
+					const nullability = typeMatch[2];
+					formattedLabel = `${cyan(columnName)}: ${typeDisplay} ${dim(nullability)}`;
+				} else formattedLabel = `${cyan(columnName)}: ${rest}`;
+			} else formattedLabel = node.label;
+			break;
+		}
+		case "index": {
+			const pkMatch = node.label.match(/^primary key:\s*(.+)$/);
+			if (pkMatch?.[1]) {
+				const columnNames = pkMatch[1];
+				formattedLabel = `${dim("primary key")}: ${cyan(columnNames)}`;
+			} else {
+				const uniqueMatch = node.label.match(/^unique\s+(.+)$/);
+				if (uniqueMatch?.[1]) {
+					const name = uniqueMatch[1];
+					formattedLabel = `${dim("unique")} ${cyan(name)}`;
+				} else {
+					const indexMatch = node.label.match(/^(unique\s+)?index\s+(.+)$/);
+					if (indexMatch?.[2]) {
+						const prefix$1 = indexMatch[1] ? `${dim("unique")} ` : "";
+						const name = indexMatch[2];
+						formattedLabel = `${prefix$1}${dim("index")} ${cyan(name)}`;
+					} else formattedLabel = dim(node.label);
+				}
+			}
+			break;
+		}
+		case "extension": {
+			const extMatch = node.label.match(/^([^\s]+)\s+(extension is enabled)$/);
+			if (extMatch?.[1] && extMatch[2]) {
+				const extName = extMatch[1];
+				const rest = extMatch[2];
+				formattedLabel = `${cyan(extName)} ${dim(rest)}`;
+			} else formattedLabel = magenta(node.label);
+			break;
+		}
+		default:
+			formattedLabel = node.label;
+			break;
+	}
+	if (isRoot) lines.push(formattedLabel);
+	else {
+		const treePrefix = `${prefix}${formatDimText(isLast ? "└" : "├")}─ `;
+		const isRootChild = prefix === "";
+		const prefixHasVerticalBar = stripAnsi(prefix).includes("│");
+		if (isRootChild) lines.push(`${treePrefix}${formattedLabel}`);
+		else if (prefixHasVerticalBar) lines.push(`${treePrefix}${formattedLabel}`);
+		else lines.push(`${formatDimText("│")} ${treePrefix}${formattedLabel}`);
+	}
+	if (node.children && node.children.length > 0) {
+		const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("│")}  `;
+		for (let i = 0; i < node.children.length; i++) {
+			const child = node.children[i];
+			if (!child) continue;
+			const childLines = renderSchemaTree(child, flags, {
+				isLast: i === node.children.length - 1,
+				prefix: childPrefix,
+				useColor,
+				formatDimText,
+				isRoot: false
+			});
+			lines.push(...childLines);
+		}
+	}
+	return lines;
+}
+/**
+* Formats human-readable output for database introspection.
+*/
+function formatIntrospectOutput(result, schemaView, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (schemaView) {
+		const prefixedTreeLines = renderSchemaTree(schemaView.root, flags, {
+			isLast: true,
+			prefix: "",
+			useColor,
+			formatDimText,
+			isRoot: true
+		}).map((line) => `${prefix}${line}`);
+		lines.push(...prefixedTreeLines);
+	} else {
+		lines.push(`${prefix}✔ ${result.summary}`);
+		if (isVerbose(flags, 1)) {
+			lines.push(`${prefix}  Target: ${result.target.familyId}/${result.target.id}`);
+			if (result.meta?.dbUrl) lines.push(`${prefix}  Database: ${result.meta.dbUrl}`);
+		}
+	}
+	if (isVerbose(flags, 1)) lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+	return lines.join("\n");
+}
+/**
+* Renders a schema verification tree structure from SchemaVerificationNode.
+* Similar to renderSchemaTree but for verification nodes with status-based colors and glyphs.
+*/
+function renderSchemaVerificationTree(node, flags, options) {
+	const { isLast, prefix, useColor, formatDimText, isRoot = false } = options;
+	const lines = [];
+	let statusGlyph = "";
+	let statusColor = (text) => text;
+	if (useColor) switch (node.status) {
+		case "pass":
+			statusGlyph = "✔";
+			statusColor = green;
+			break;
+		case "warn":
+			statusGlyph = "⚠";
+			statusColor = (text) => useColor ? yellow(text) : text;
+			break;
+		case "fail":
+			statusGlyph = "✖";
+			statusColor = red;
+			break;
+	}
+	else switch (node.status) {
+		case "pass":
+			statusGlyph = "✔";
+			break;
+		case "warn":
+			statusGlyph = "⚠";
+			break;
+		case "fail":
+			statusGlyph = "✖";
+			break;
+	}
+	let labelColor = (text) => text;
+	let formattedLabel = node.name;
+	if (useColor) switch (node.kind) {
+		case "contract":
+		case "schema":
+			labelColor = bold;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "table": {
+			const tableMatch = node.name.match(/^table\s+(.+)$/);
+			if (tableMatch?.[1]) {
+				const tableName = tableMatch[1];
+				formattedLabel = `${dim("table")} ${cyan(tableName)}`;
+			} else formattedLabel = dim(node.name);
+			break;
+		}
+		case "columns":
+			labelColor = dim;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "column": {
+			const columnMatch = node.name.match(/^([^:]+):\s*(.+)$/);
+			if (columnMatch?.[1] && columnMatch[2]) {
+				const columnName = columnMatch[1];
+				const rest = columnMatch[2];
+				const typeMatch = rest.match(/^([^\s→]+)\s*→\s*([^\s(]+)\s*(\([^)]+\))$/);
+				if (typeMatch?.[1] && typeMatch[2] && typeMatch[3]) {
+					const contractType = typeMatch[1];
+					const nativeType = typeMatch[2];
+					const nullability = typeMatch[3];
+					formattedLabel = `${cyan(columnName)}: ${contractType} → ${dim(nativeType)} ${dim(nullability)}`;
+				} else formattedLabel = `${cyan(columnName)}: ${rest}`;
+			} else formattedLabel = node.name;
+			break;
+		}
+		case "type":
+		case "nullability":
+			labelColor = (text) => text;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "primaryKey": {
+			const pkMatch = node.name.match(/^primary key:\s*(.+)$/);
+			if (pkMatch?.[1]) {
+				const columnNames = pkMatch[1];
+				formattedLabel = `${dim("primary key")}: ${cyan(columnNames)}`;
+			} else formattedLabel = dim(node.name);
+			break;
+		}
+		case "foreignKey":
+		case "unique":
+		case "index":
+			labelColor = dim;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "extension": {
+			const dbMatch = node.name.match(/^database is\s+(.+)$/);
+			if (dbMatch?.[1]) {
+				const dbName = dbMatch[1];
+				formattedLabel = `${dim("database is")} ${cyan(dbName)}`;
+			} else {
+				const extMatch = node.name.match(/^([^\s]+)\s+(extension is enabled)$/);
+				if (extMatch?.[1] && extMatch[2]) {
+					const extName = extMatch[1];
+					const rest = extMatch[2];
+					formattedLabel = `${cyan(extName)} ${dim(rest)}`;
+				} else {
+					labelColor = magenta;
+					formattedLabel = labelColor(node.name);
+				}
+			}
+			break;
+		}
+		default:
+			formattedLabel = node.name;
+			break;
+	}
+	else formattedLabel = node.name;
+	const statusGlyphColored = statusColor(statusGlyph);
+	let nodeLabel = formattedLabel;
+	if ((node.status === "fail" || node.status === "warn") && node.message && node.message.length > 0) {
+		const messageText = formatDimText(`(${node.message})`);
+		nodeLabel = `${formattedLabel} ${messageText}`;
+	}
+	if (isRoot) lines.push(`${statusGlyphColored} ${nodeLabel}`);
+	else {
+		const treePrefix = `${prefix}${formatDimText(isLast ? "└" : "├")}─ `;
+		const isRootChild = prefix === "";
+		const prefixHasVerticalBar = stripAnsi(prefix).includes("│");
+		if (isRootChild) lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+		else if (prefixHasVerticalBar) lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+		else lines.push(`${formatDimText("│")} ${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+	}
+	if (node.children && node.children.length > 0) {
+		const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("│")}  `;
+		for (let i = 0; i < node.children.length; i++) {
+			const child = node.children[i];
+			if (!child) continue;
+			const childLines = renderSchemaVerificationTree(child, flags, {
+				isLast: i === node.children.length - 1,
+				prefix: childPrefix,
+				useColor,
+				formatDimText,
+				isRoot: false
+			});
+			lines.push(...childLines);
+		}
+	}
+	return lines;
+}
+/**
+* Formats human-readable output for database schema verification.
+*/
+function formatSchemaVerifyOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	const prefixedTreeLines = renderSchemaVerificationTree(result.schema.root, flags, {
+		isLast: true,
+		prefix: "",
+		useColor,
+		formatDimText,
+		isRoot: true
+	}).map((line) => `${prefix}${line}`);
+	lines.push(...prefixedTreeLines);
+	if (isVerbose(flags, 1)) {
+		lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+		lines.push(`${prefix}${formatDimText(`  pass=${result.schema.counts.pass} warn=${result.schema.counts.warn} fail=${result.schema.counts.fail}`)}`);
+	}
+	lines.push("");
+	if (result.ok) lines.push(`${prefix}${formatGreen("✔")} ${result.summary}`);
+	else {
+		const codeText = result.code ? ` (${result.code})` : "";
+		lines.push(`${prefix}${formatRed("✖")} ${result.summary}${codeText}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for database schema verification.
+*/
+function formatSchemaVerifyJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Formats human-readable output for database sign.
+*/
+function formatSignOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (result.ok) {
+		lines.push(`${prefix}${formatGreen("✔")} Database signed`);
+		const previousHash = result.marker.previous?.storageHash ?? "none";
+		const currentHash = result.contract.storageHash;
+		lines.push(`${prefix}${formatDimText(`  from: ${previousHash}`)}`);
+		lines.push(`${prefix}${formatDimText(`  to:   ${currentHash}`)}`);
+		if (isVerbose(flags, 1)) {
+			if (result.contract.profileHash) lines.push(`${prefix}${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
+			if (result.marker.previous?.profileHash) lines.push(`${prefix}${formatDimText(`  previous profileHash: ${result.marker.previous.profileHash}`)}`);
+			lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for database sign.
+*/
+function formatSignJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Formats human-readable output for db init plan mode.
+*/
+function formatDbInitPlanOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatDimText = (text) => formatDim(useColor, text);
+	const operationCount = result.plan?.operations.length ?? 0;
+	lines.push(`${prefix}${formatGreen("✔")} Planned ${operationCount} operation(s)`);
+	if (result.plan?.operations && result.plan.operations.length > 0) {
+		lines.push(`${prefix}${formatDimText("│")}`);
+		for (let i = 0; i < result.plan.operations.length; i++) {
+			const op = result.plan.operations[i];
+			if (!op) continue;
+			const treeChar = i === result.plan.operations.length - 1 ? "└" : "├";
+			const opClass = formatDimText(`[${op.operationClass}]`);
+			lines.push(`${prefix}${formatDimText(treeChar)}─ ${op.label} ${opClass}`);
+		}
+	}
+	if (result.plan?.destination) {
+		lines.push(`${prefix}`);
+		lines.push(`${prefix}${formatDimText(`Destination hash: ${result.plan.destination.storageHash}`)}`);
+	}
+	if (isVerbose(flags, 1)) lines.push(`${prefix}${formatDimText(`Total time: ${result.timings.total}ms`)}`);
+	lines.push(`${prefix}`);
+	lines.push(`${prefix}${formatDimText("This is a dry run. No changes were applied.")}`);
+	lines.push(`${prefix}${formatDimText("Run without --plan to apply changes.")}`);
+	return lines.join("\n");
+}
+/**
+* Formats human-readable output for db init apply mode.
+*/
+function formatDbInitApplyOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (result.ok) {
+		const executed = result.execution?.operationsExecuted ?? 0;
+		lines.push(`${prefix}${formatGreen("✔")} Applied ${executed} operation(s)`);
+		if (result.marker) {
+			lines.push(`${prefix}${formatDimText(`  Marker written: ${result.marker.storageHash}`)}`);
+			if (result.marker.profileHash) lines.push(`${prefix}${formatDimText(`  Profile hash: ${result.marker.profileHash}`)}`);
+		}
+		if (isVerbose(flags, 1)) lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for db init command.
+*/
+function formatDbInitJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Fixed width for left column in help output.
+*/
+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.stdout.columns;
+	const defaultWidth = Number.parseInt(process.env["CLI_WIDTH"] || "80", 10);
+	return terminalWidth || defaultWidth;
+}
+/**
+* Calculates the available width for the right column based on terminal width.
+* Format: "│ " (2) + left column (20) + "  " (2) + right column = total
+* So: right column = terminal width - 2 - 20 - 2 = terminal width - 24
+*/
+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 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(useColor) {
+	if (!useColor) return "prisma-next";
+	return `${bgGreen(bold(" prisma-next "))}${green("")}`;
+}
+/**
+* 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(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(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);
+}
+/**
+* Wraps text to fit within a specified width using wrap-ansi.
+* Preserves ANSI escape codes and breaks at word boundaries.
+*/
+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;
+}
+/**
+* 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 - 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 - 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 - 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 multiline description with "Prisma Next" in green.
+* Wraps at the same right-hand boundary as the right column.
+* The right edge is defined by: left column (20) + gap (2) + right column (90) = 112 characters total.
+* Since the description line starts with "│ " (2 chars), the text wraps at 112 - 2 = 110 characters.
+*/
+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;
+}
+/**
+* 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(useColor);
+	const operation = useColor ? bold(options.command) : options.command;
+	const intent = formatDimText(options.description);
+	lines.push(formatHeaderLine({
+		brand,
+		operation,
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	for (const detail of options.details) {
+		const labelPadded = padToFixedWidth(`${detail.label}:`, LEFT_COLUMN_WIDTH);
+		const labelColored = useColor ? cyan(labelPadded) : labelPadded;
+		lines.push(`${formatDimText("│")} ${labelColored}  ${detail.value}`);
+	}
+	if (options.url) {
+		lines.push(formatDimText("│"));
+		lines.push(formatReadMoreLine({
+			url: options.url,
+			maxLabelWidth: LEFT_COLUMN_WIDTH,
+			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`;
+}
+/**
+* Maps command paths to their documentation URLs.
+*/
+function getCommandDocsUrl(commandPath) {
+	return {
+		"contract emit": "https://pris.ly/contract-emit",
+		"db verify": "https://pris.ly/db-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 brand = createPrismaNextBadge(useColor);
+	const operation = useColor ? bold(commandPath) : commandPath;
+	const intent = formatDimText(shortDescription);
+	lines.push(formatHeaderLine({
+		brand,
+		operation,
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	const optionsList = command.options.map((opt) => {
+		return {
+			flags: opt.flags,
+			description: opt.description || "",
+			defaultValue: opt.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
+		}));
+	}
+	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) => {
+		return {
+			flags: opt.flags,
+			description: opt.description || "",
+			defaultValue: opt.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/progress-adapter.ts
+/**
+* Creates a progress adapter that converts control-api progress events
+* into CLI spinner/progress output.
+*
+* The adapter:
+* - Starts/succeeds spinners for top-level span boundaries
+* - Prints per-operation lines for nested spans (e.g., migration operations under 'apply')
+* - Respects quiet/json/non-TTY flags (no-op in those cases)
+*
+* @param options - Progress adapter configuration
+* @returns An onProgress callback compatible with control-api operations
+*/
+function createProgressAdapter(options) {
+	const { flags } = options;
+	if (!(!flags.quiet && flags.json !== "object" && process.stdout.isTTY)) return () => {};
+	const activeSpans = /* @__PURE__ */ new Map();
+	return (event) => {
+		if (event.kind === "spanStart") {
+			if (event.parentSpanId) {
+				console.log(`  → ${event.label}...`);
+				return;
+			}
+			const spinner = ora({
+				text: event.label,
+				color: flags.color !== false ? "cyan" : false
+			}).start();
+			activeSpans.set(event.spanId, {
+				spinner,
+				startTime: Date.now()
+			});
+		} else if (event.kind === "spanEnd") {
+			const spanState = activeSpans.get(event.spanId);
+			if (spanState) {
+				const elapsed = Date.now() - spanState.startTime;
+				if (event.outcome === "error") spanState.spinner.fail(`${spanState.spinner.text} (failed)`);
+				else if (event.outcome === "skipped") spanState.spinner.info(`${spanState.spinner.text} (skipped)`);
+				else spanState.spinner.succeed(`${spanState.spinner.text} (${elapsed}ms)`);
+				activeSpans.delete(event.spanId);
+			}
+		}
+	};
+}
+
+//#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().
+*
+* @param result - The result from a CLI command
+* @param flags - Global flags for output formatting
+* @param onSuccess - Optional callback for successful results (for custom success output)
+* @returns The exit code that should be used (0 for success, non-zero for errors)
+*/
+function handleResult(result, flags, onSuccess) {
+	if (result.ok) {
+		if (onSuccess) onSuccess(result.value);
+		return 0;
+	}
+	const envelope = result.failure.toEnvelope();
+	if (flags.json) console.error(formatErrorJson(envelope));
+	else console.error(formatErrorOutput(envelope, flags));
+	return result.failure.domain === "CLI" ? 2 : 1;
+}
+
+//#endregion
+export { formatSuccessMessage as _, formatDbInitJson as a, parseGlobalFlags as b, formatEmitOutput as c, formatRootHelp as d, formatSchemaVerifyJson as f, formatStyledHeader as g, formatSignOutput as h, formatDbInitApplyOutput as i, formatIntrospectJson as l, formatSignJson as m, createProgressAdapter as n, formatDbInitPlanOutput as o, formatSchemaVerifyOutput as p, formatCommandHelp as r, formatEmitJson as s, handleResult as t, formatIntrospectOutput as u, formatVerifyJson as v, setCommandDescriptions as x, formatVerifyOutput as y };
+//# sourceMappingURL=result-handler-BZPY7HX4.mjs.map