@prisma-next/cli 0.3.0-pr.94.3 → 0.3.0-pr.95.2

package/dist/chunk-AGOTG4L3.js

@@ -0,0 +1,965 @@
+// src/utils/command-helpers.ts
+function setCommandDescriptions(command, shortDescription, longDescription) {
+  command.description(shortDescription);
+  if (longDescription) {
+    command._longDescription = longDescription;
+  }
+  return command;
+}
+function getLongDescription(command) {
+  return command._longDescription;
+}
+
+// src/utils/global-flags.ts
+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;
+}
+
+// src/utils/output.ts
+import { relative } from "path";
+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";
+function formatTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createPrefix(flags) {
+  return flags.timestamps ? `[${formatTimestamp()}] ` : "";
+}
+function isVerbose(flags, level) {
+  return (flags.verbose ?? 0) >= level;
+}
+function createColorFormatter(useColor, colorFn) {
+  return useColor ? colorFn : (text) => text;
+}
+function formatDim(useColor, text) {
+  return useColor ? dim(text) : text;
+}
+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}\u2714 Emitted contract.json \u2192 ${jsonPath}`);
+  lines.push(`${prefix}\u2714 Emitted contract.d.ts \u2192 ${dtsPath}`);
+  lines.push(`${prefix}  coreHash: ${result.coreHash}`);
+  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");
+}
+function formatEmitJson(result) {
+  const output = {
+    ok: true,
+    coreHash: result.coreHash,
+    ...result.profileHash ? { profileHash: result.profileHash } : {},
+    outDir: result.outDir,
+    files: result.files,
+    timings: result.timings
+  };
+  return JSON.stringify(output, null, 2);
+}
+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("\u2716")} ${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");
+}
+function formatErrorJson(error) {
+  return JSON.stringify(error, null, 2);
+}
+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("\u2714")} ${result.summary}`);
+    lines.push(`${prefix}${formatDimText(`  coreHash: ${result.contract.coreHash}`)}`);
+    if (result.contract.profileHash) {
+      lines.push(`${prefix}${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
+    }
+  } else {
+    lines.push(`${prefix}${formatRed("\u2716")} ${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");
+}
+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);
+}
+function formatIntrospectJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+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 prefix2 = indexMatch[1] ? `${dim("unique")} ` : "";
+              const name = indexMatch[2];
+              formattedLabel = `${prefix2}${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 treeChar = isLast ? "\u2514" : "\u251C";
+    const treePrefix = `${prefix}${formatDimText(treeChar)}\u2500 `;
+    const isRootChild = prefix === "";
+    const prefixWithoutAnsi = stripAnsi(prefix);
+    const prefixHasVerticalBar = prefixWithoutAnsi.includes("\u2502");
+    if (isRootChild) {
+      lines.push(`${treePrefix}${formattedLabel}`);
+    } else if (prefixHasVerticalBar) {
+      lines.push(`${treePrefix}${formattedLabel}`);
+    } else {
+      lines.push(`${formatDimText("\u2502")} ${treePrefix}${formattedLabel}`);
+    }
+  }
+  if (node.children && node.children.length > 0) {
+    const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("\u2502")}  `;
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (!child) continue;
+      const isLastChild = i === node.children.length - 1;
+      const childLines = renderSchemaTree(child, flags, {
+        isLast: isLastChild,
+        prefix: childPrefix,
+        useColor,
+        formatDimText,
+        isRoot: false
+      });
+      lines.push(...childLines);
+    }
+  }
+  return lines;
+}
+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 treeLines = renderSchemaTree(schemaView.root, flags, {
+      isLast: true,
+      prefix: "",
+      useColor,
+      formatDimText,
+      isRoot: true
+    });
+    const prefixedTreeLines = treeLines.map((line) => `${prefix}${line}`);
+    lines.push(...prefixedTreeLines);
+  } else {
+    lines.push(`${prefix}\u2714 ${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");
+}
+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 = "\u2714";
+        statusColor = green;
+        break;
+      case "warn":
+        statusGlyph = "\u26A0";
+        statusColor = (text) => useColor ? yellow(text) : text;
+        break;
+      case "fail":
+        statusGlyph = "\u2716";
+        statusColor = red;
+        break;
+    }
+  } else {
+    switch (node.status) {
+      case "pass":
+        statusGlyph = "\u2714";
+        break;
+      case "warn":
+        statusGlyph = "\u26A0";
+        break;
+      case "fail":
+        statusGlyph = "\u2716";
+        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} \u2192 ${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 treeChar = isLast ? "\u2514" : "\u251C";
+    const treePrefix = `${prefix}${formatDimText(treeChar)}\u2500 `;
+    const isRootChild = prefix === "";
+    const prefixWithoutAnsi = stripAnsi(prefix);
+    const prefixHasVerticalBar = prefixWithoutAnsi.includes("\u2502");
+    if (isRootChild) {
+      lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+    } else if (prefixHasVerticalBar) {
+      lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+    } else {
+      lines.push(`${formatDimText("\u2502")} ${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+    }
+  }
+  if (node.children && node.children.length > 0) {
+    const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("\u2502")}  `;
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (!child) continue;
+      const isLastChild = i === node.children.length - 1;
+      const childLines = renderSchemaVerificationTree(child, flags, {
+        isLast: isLastChild,
+        prefix: childPrefix,
+        useColor,
+        formatDimText,
+        isRoot: false
+      });
+      lines.push(...childLines);
+    }
+  }
+  return lines;
+}
+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 treeLines = renderSchemaVerificationTree(result.schema.root, flags, {
+    isLast: true,
+    prefix: "",
+    useColor,
+    formatDimText,
+    isRoot: true
+  });
+  const prefixedTreeLines = treeLines.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("\u2714")} ${result.summary}`);
+  } else {
+    const codeText = result.code ? ` (${result.code})` : "";
+    lines.push(`${prefix}${formatRed("\u2716")} ${result.summary}${codeText}`);
+  }
+  return lines.join("\n");
+}
+function formatSchemaVerifyJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+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("\u2714")} Database signed`);
+    const previousHash = result.marker.previous?.coreHash ?? "none";
+    const currentHash = result.contract.coreHash;
+    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");
+}
+function formatSignJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+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("\u2714")} Planned ${operationCount} operation(s)`);
+  if (result.plan?.operations && result.plan.operations.length > 0) {
+    lines.push(`${prefix}${formatDimText("\u2502")}`);
+    for (let i = 0; i < result.plan.operations.length; i++) {
+      const op = result.plan.operations[i];
+      if (!op) continue;
+      const isLast = i === result.plan.operations.length - 1;
+      const treeChar = isLast ? "\u2514" : "\u251C";
+      const opClass = formatDimText(`[${op.operationClass}]`);
+      lines.push(`${prefix}${formatDimText(treeChar)}\u2500 ${op.label} ${opClass}`);
+    }
+  }
+  if (result.plan?.destination) {
+    lines.push(`${prefix}`);
+    lines.push(
+      `${prefix}${formatDimText(`Destination hash: ${result.plan.destination.coreHash}`)}`
+    );
+  }
+  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");
+}
+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("\u2714")} Applied ${executed} operation(s)`);
+    if (result.marker) {
+      lines.push(`${prefix}${formatDimText(`  Marker written: ${result.marker.coreHash}`)}`);
+      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");
+}
+function formatDbInitJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+var LEFT_COLUMN_WIDTH = 20;
+var RIGHT_COLUMN_MIN_WIDTH = 40;
+var RIGHT_COLUMN_MAX_WIDTH = 90;
+function getTerminalWidth() {
+  const terminalWidth = process.stdout.columns;
+  const defaultWidth = Number.parseInt(process.env["CLI_WIDTH"] || "80", 10);
+  return terminalWidth || defaultWidth;
+}
+function calculateRightColumnWidth() {
+  const terminalWidth = getTerminalWidth();
+  const availableWidth = terminalWidth - 2 - LEFT_COLUMN_WIDTH - 2;
+  return Math.max(RIGHT_COLUMN_MIN_WIDTH, Math.min(availableWidth, RIGHT_COLUMN_MAX_WIDTH));
+}
+function createPrismaNextBadge(useColor) {
+  if (!useColor) {
+    return "prisma-next";
+  }
+  const text = " prisma-next ";
+  const body = bgGreen(bold(text));
+  const separator = "\uE0B0";
+  const tip = green(separator);
+  return `${body}${tip}`;
+}
+function createPadFunction() {
+  return (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+}
+function formatHeaderLine(options) {
+  if (options.operation) {
+    return `${options.brand} ${options.operation} \u2192 ${options.intent}`;
+  }
+  return `${options.brand} ${options.intent}`;
+}
+function formatReadMoreLine(options) {
+  const pad = createPadFunction();
+  const labelPadded = pad("Read more", options.maxLabelWidth);
+  const valueColored = options.useColor ? blue(options.url) : options.url;
+  return `${options.formatDimText("\u2502")} ${labelPadded}  ${valueColored}`;
+}
+function padToFixedWidth(text, width) {
+  const actualWidth = stringWidth(text);
+  const padding = Math.max(0, width - actualWidth);
+  return text + " ".repeat(padding);
+}
+function wrapTextAnsi(text, width) {
+  const wrapped = wrapAnsi(text, width, { hard: false, trim: true });
+  return wrapped.split("\n");
+}
+function formatDefaultValue(value, useColor) {
+  const valueStr = String(value);
+  const defaultText = `default: ${valueStr}`;
+  return useColor ? dim(defaultText) : defaultText;
+}
+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 prefix = isLastCommand && !hasItemsAfter ? formatDimText("\u2514") : formatDimText("\u251C");
+      const treePrefix = `${prefix}\u2500 `;
+      const treePrefixWidth = stringWidth(stripAnsi(treePrefix));
+      const remainingWidth = LEFT_COLUMN_WIDTH - treePrefixWidth;
+      const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+      const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+      lines.push(`${formatDimText("\u2502")} ${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 ? "\u2514" : "\u251C";
+        const continuation = continuationPrefix ?? (isLastCommand && isLastSubcommand && !hasItemsAfter ? " " : formatDimText("\u2502"));
+        const continuationStr = continuation === " " ? " " : continuation;
+        const subTreePrefix = `${continuationStr}  ${formatDimText(treeChar)}\u2500 `;
+        const subTreePrefixWidth = stringWidth(stripAnsi(subTreePrefix));
+        const subRemainingWidth = LEFT_COLUMN_WIDTH - subTreePrefixWidth;
+        const subcommandNamePadded = padToFixedWidth(subcmd.name(), subRemainingWidth);
+        const subcommandNameColored = useColor ? cyan(subcommandNamePadded) : subcommandNamePadded;
+        lines.push(
+          `${formatDimText("\u2502")} ${subTreePrefix}${subcommandNameColored}  ${shortDescription}`
+        );
+      }
+    } else {
+      const prefix = isLastCommand && !hasItemsAfter ? formatDimText("\u2514") : formatDimText("\u251C");
+      const treePrefix = `${prefix}\u2500 `;
+      const treePrefixWidth = stringWidth(stripAnsi(treePrefix));
+      const remainingWidth = LEFT_COLUMN_WIDTH - treePrefixWidth;
+      const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+      const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+      const shortDescription = cmd.description() || "";
+      lines.push(`${formatDimText("\u2502")} ${treePrefix}${commandNameColored}  ${shortDescription}`);
+    }
+  }
+  return lines;
+}
+function formatMultilineDescription(options) {
+  const lines = [];
+  const formatGreen = (text) => options.useColor ? green(text) : text;
+  const rightColumnWidth = calculateRightColumnWidth();
+  const totalWidth = 2 + LEFT_COLUMN_WIDTH + 2 + rightColumnWidth;
+  const wrapWidth = totalWidth - 2;
+  for (const descLine of options.descriptionLines) {
+    const formattedLine = descLine.replace(/Prisma Next/g, (match) => formatGreen(match));
+    const wrappedLines = wrapTextAnsi(formattedLine, wrapWidth);
+    for (const wrappedLine of wrappedLines) {
+      lines.push(`${options.formatDimText("\u2502")} ${wrappedLine}`);
+    }
+  }
+  return lines;
+}
+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("\u2502"));
+  for (const detail of options.details) {
+    const labelWithColon = `${detail.label}:`;
+    const labelPadded = padToFixedWidth(labelWithColon, LEFT_COLUMN_WIDTH);
+    const labelColored = useColor ? cyan(labelPadded) : labelPadded;
+    lines.push(`${formatDimText("\u2502")} ${labelColored}  ${detail.value}`);
+  }
+  if (options.url) {
+    lines.push(formatDimText("\u2502"));
+    lines.push(
+      formatReadMoreLine({
+        url: options.url,
+        maxLabelWidth: LEFT_COLUMN_WIDTH,
+        useColor,
+        formatDimText
+      })
+    );
+  }
+  lines.push(formatDimText("\u2514"));
+  return `${lines.join("\n")}
+`;
+}
+function formatSuccessMessage(flags) {
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  return `${formatGreen("\u2714")} Success`;
+}
+function getCommandDocsUrl(commandPath) {
+  const docsMap = {
+    "contract emit": "https://pris.ly/contract-emit",
+    "db verify": "https://pris.ly/db-verify"
+  };
+  return docsMap[commandPath];
+}
+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(" ");
+}
+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("\u2502"));
+  const optionsList = command.options.map((opt) => {
+    const flags2 = opt.flags;
+    const description = opt.description || "";
+    const defaultValue = opt.defaultValue;
+    return { flags: flags2, description, defaultValue };
+  });
+  const subcommands = command.commands.filter((cmd) => !cmd.name().startsWith("_"));
+  if (subcommands.length > 0) {
+    const hasItemsAfter = optionsList.length > 0;
+    const treeLines = renderCommandTree({
+      commands: subcommands,
+      useColor,
+      formatDimText,
+      hasItemsAfter
+    });
+    lines.push(...treeLines);
+  }
+  if (subcommands.length > 0 && optionsList.length > 0) {
+    lines.push(formatDimText("\u2502"));
+  }
+  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("\u2502")} ${flagsColored}  ${wrappedDescription[0] || ""}`);
+      for (let i = 1; i < wrappedDescription.length; i++) {
+        const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+        lines.push(`${formatDimText("\u2502")} ${emptyLabel}  ${wrappedDescription[i] || ""}`);
+      }
+      if (opt.defaultValue !== void 0) {
+        const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+        const defaultText = formatDefaultValue(opt.defaultValue, useColor);
+        lines.push(`${formatDimText("\u2502")} ${emptyLabel}  ${defaultText}`);
+      }
+    }
+  }
+  const docsUrl = getCommandDocsUrl(commandPath);
+  if (docsUrl) {
+    lines.push(formatDimText("\u2502"));
+    lines.push(
+      formatReadMoreLine({
+        url: docsUrl,
+        maxLabelWidth: LEFT_COLUMN_WIDTH,
+        useColor,
+        formatDimText
+      })
+    );
+  }
+  if (longDescription) {
+    lines.push(formatDimText("\u2502"));
+    const descriptionLines = longDescription.split("\n").filter((line) => line.trim().length > 0);
+    lines.push(...formatMultilineDescription({ descriptionLines, useColor, formatDimText }));
+  }
+  lines.push(formatDimText("\u2514"));
+  return `${lines.join("\n")}
+`;
+}
+
+// src/utils/progress-adapter.ts
+import ora from "ora";
+function createProgressAdapter(options) {
+  const { flags } = options;
+  const shouldShowProgress = !flags.quiet && flags.json !== "object" && process.stdout.isTTY;
+  if (!shouldShowProgress) {
+    return () => {
+    };
+  }
+  const activeSpans = /* @__PURE__ */ new Map();
+  return (event) => {
+    if (event.kind === "spanStart") {
+      if (event.parentSpanId) {
+        console.log(`  \u2192 ${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);
+      }
+    }
+  };
+}
+
+// src/utils/result-handler.ts
+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));
+  }
+  const exitCode = result.failure.domain === "CLI" ? 2 : 1;
+  return exitCode;
+}
+
+export {
+  setCommandDescriptions,
+  parseGlobalFlags,
+  formatEmitOutput,
+  formatEmitJson,
+  formatVerifyOutput,
+  formatVerifyJson,
+  formatIntrospectJson,
+  formatIntrospectOutput,
+  formatSchemaVerifyOutput,
+  formatSchemaVerifyJson,
+  formatSignOutput,
+  formatSignJson,
+  formatDbInitPlanOutput,
+  formatDbInitApplyOutput,
+  formatDbInitJson,
+  formatStyledHeader,
+  formatSuccessMessage,
+  formatCommandHelp,
+  createProgressAdapter,
+  handleResult
+};
+//# sourceMappingURL=chunk-AGOTG4L3.js.map