@prisma-next/cli 0.10.0 → 0.11.0-dev.1

package/src/commands/init/inputs.ts

@@ -1,8 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
 import * as clack from '@clack/prompts';
+import { readUserConfig, resolveGating, writeUserConfig } from '@prisma-next/cli-telemetry';
 import { extname, join, normalize } from 'pathe';
 import type { GlobalFlags } from '../../utils/global-flags';
+import { isCI } from '../../utils/is-ci';
 import {
+  errorInitAuthoringSchemaPathMismatch,
   errorInitInvalidFlagValue,
   errorInitMissingFlags,
   errorInitReinitNeedsForce,
@@ -68,12 +71,24 @@ export interface ResolvedInitInputs {
    * is added separately via the install step.
    */
   readonly removePreviousFacade: string | null;
+  /**
+   * Telemetry consent answer recorded during this `init` run, or `null`
+   * when no prompt was shown. The prompt fires only on the
+   * canPrompt + !autoAcceptPrompts + no env/CI opt-out +
+   * `enableTelemetry === undefined` intersection; outside that window
+   * the field is `null` and the stored preference (if any) stays
+   * unchanged. The answer has already been persisted to
+   * `$XDG_CONFIG_HOME/prisma-next/config.json` by
+   * the time `runInit` sees this value — it's surfaced here purely so
+   * the post-init summary can mention what the user chose.
+   */
+  readonly enableTelemetry: boolean | null;
   /**
    * Whether to run `npx skills add prisma/prisma-next#v<version>` at the
    * project level after install + emit. True by default; `--no-skill`
    * sets it to `false`. The skill is always project-level (never
    * user-level / global) so its version stays locked to the project's
-   * Prisma Next version — see `agent-skill-install.ts`.
+   * Prisma Next version — see `skill-install.ts`.
    */
   readonly installProjectSkill: boolean;
 }
@@ -91,6 +106,12 @@ const AUTHORING_VALUES: ReadonlyMap<string, AuthoringId> = new Map([
   ['ts', 'typescript'],
 ]);
 
+export const TELEMETRY_CONSENT_MESSAGE = [
+  'Help us prioritize features by sharing anonymous CLI usage data?',
+  'The telemetry implementation is open source and fully transparent.',
+  '(packages/1-framework/3-tooling/cli-telemetry and apps/telemetry-backend).',
+].join(' ');
+
 /**
  * Resolves every required input for `runInit`. In interactive mode, missing
  * inputs are prompted via clack; in non-interactive mode, missing required
@@ -176,6 +197,11 @@ export async function resolveInitInputs(ctx: {
     autoAcceptPrompts,
   });
 
+  const enableTelemetry = await resolveTelemetryConsent({
+    canPrompt,
+    autoAcceptPrompts,
+  });
+
   // Skill-install gating. `--no-skill` (commander parses
   // `options.skill === false`) is the only escape hatch; otherwise
   // project-level install is unconditional. The skill is always
@@ -193,10 +219,60 @@ export async function resolveInitInputs(ctx: {
     strictProbe: Boolean(options.strictProbe),
     reinit,
     removePreviousFacade,
+    enableTelemetry,
     installProjectSkill,
   };
 }
 
+/**
+ * The interactive telemetry consent prompt. Shown as the last
+ * question of the `init` sequence iff:
+ *   1. `canPrompt === true` (interactive stdin / stdout combo),
+ *   2. `autoAcceptPrompts === false` (the user did not pass `--yes`),
+ *   3. neither telemetry env opt-out is active,
+ *   4. the process is not running in CI,
+ *   5. the stored `enableTelemetry` value is `undefined` (the user
+ *      has never been asked, or skipped the prompt previously).
+ *
+ * Outside that intersection the function returns `null` and leaves the
+ * stored preference untouched. Inside it, the user's answer is
+ * persisted via `writeUserConfig({ enableTelemetry })` before this
+ * function returns; on an affirmative answer `writeUserConfig`
+ * generates and stores the v4 `installationId` in the same write.
+ *
+ * The wording names CLI usage data and points to the open-source
+ * client/backend paths. Default value is `true` to match precedent
+ * and to make the consent answer a single keystroke once it's been
+ * disclosed.
+ */
+async function resolveTelemetryConsent(opts: {
+  readonly canPrompt: boolean;
+  readonly autoAcceptPrompts: boolean;
+}): Promise<boolean | null> {
+  if (!opts.canPrompt || opts.autoAcceptPrompts || isCI()) {
+    return null;
+  }
+  const config = readUserConfig();
+  const gating = resolveGating({ env: process.env, config });
+  if (!gating.enabled && gating.reason === 'env-override') {
+    return null;
+  }
+  const stored = config.enableTelemetry;
+  if (stored !== undefined) {
+    return null;
+  }
+  const result = await clack.confirm({
+    message: TELEMETRY_CONSENT_MESSAGE,
+    initialValue: true,
+    output: process.stderr,
+  });
+  if (clack.isCancel(result)) {
+    throw errorInitUserAborted();
+  }
+  writeUserConfig({ enableTelemetry: Boolean(result) });
+  return Boolean(result);
+}
+
 async function resolveWriteEnv(opts: {
   readonly flag: boolean | undefined;
   readonly canPrompt: boolean;
@@ -376,10 +452,11 @@ function validateSchemaPath(value: string, authoring: AuthoringId): string {
   const ext = extname(trimmed).toLowerCase();
   const expected = authoring === 'typescript' ? '.ts' : '.prisma';
   if (ext !== expected) {
-    throw errorInitInvalidFlagValue({
-      flag: 'schema-path',
-      value,
-      allowed: [`<file path ending in ${expected} for --authoring ${authoring}>`],
+    throw errorInitAuthoringSchemaPathMismatch({
+      authoring,
+      schemaPath: trimmed,
+      actualExtension: ext.length > 0 ? ext : '(none)',
+      expectedExtension: expected,
     });
   }
   return normalize(trimmed);

package/src/commands/init/output.ts

@@ -123,7 +123,7 @@ export function buildNextSteps(options: {
   /**
    * Whether the project-level Prisma Next skills install actually ran
    * and succeeded during this `init`. When false (the user passed
-   * `--no-skill` or `--no-install`, so the install was skipped), the
+   * `--no-skill`, so the install was skipped), the
    * "registered with your agent runtime" step is omitted — the skip is
    * already surfaced in the warnings array with a manual-install hint.
    */

package/src/commands/init/{agent-skill-install.ts → skill-install.ts}

@@ -11,12 +11,12 @@ const exec = promisify(execFile);
  * upstream `skills add`. Each `SkillSource` joins this base with its
  * own subpath (and optional `#ref` for version-pinned clusters).
  */
-export const DEFAULT_AGENT_SKILL_BASE = 'prisma/prisma-next';
+export const DEFAULT_SKILL_BASE = 'prisma/prisma-next';
 
 /**
  * One discovery scope inside the Prisma Next monorepo. The CLI emits
- * one `skills add <base>/<subpath>[#ref] --all` invocation per source
- * during `init`.
+ * one `skills add <base>/<subpath>[#ref] --agent ... --skill '*' -y`
+ * invocation per source during `init`.
  *
  * `ref` semantics:
  * - `cli`: pin to the CLI's own package version (lockstep with the
@@ -35,7 +35,7 @@ export interface SkillSource {
   readonly description: string;
 }
 
-export const DEFAULT_AGENT_SKILL_SOURCES: readonly SkillSource[] = [
+export const DEFAULT_SKILL_SOURCES: readonly SkillSource[] = [
   {
     subpath: 'skills',
     ref: 'cli',
@@ -56,7 +56,7 @@ export const DEFAULT_AGENT_SKILL_SOURCES: readonly SkillSource[] = [
 /**
  * Test-only escape hatch for pinning the install base to a local
  * checkout. Production runs leave this unset, so installs always use
- * `DEFAULT_AGENT_SKILL_BASE`.
+ * `DEFAULT_SKILL_BASE`.
  *
  * When set to an absolute filesystem path (typical for tests), the
  * `#ref` fragment is dropped — local-path mode in upstream's CLI does
@@ -66,13 +66,28 @@ export const DEFAULT_AGENT_SKILL_SOURCES: readonly SkillSource[] = [
  */
 function resolveAgentSkillBase(): string {
   const override = process.env['PRISMA_NEXT_SKILLS_BASE']?.trim();
-  return override && override.length > 0 ? override : DEFAULT_AGENT_SKILL_BASE;
+  return override && override.length > 0 ? override : DEFAULT_SKILL_BASE;
 }
 
 function isLocalPath(base: string): boolean {
   return base.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(base);
 }
 
+/** Agent slugs accepted by the upstream `skills add --agent` flag. */
+export type SkillAgent = 'cursor' | 'claude-code' | 'codex' | 'windsurf';
+
+/**
+ * Agents passed to every project-level init install. Upstream `skills add`
+ * is the source of truth for per-agent install behaviour; the CLI lists
+ * every supported runtime on one invocation and delegates the rest.
+ */
+export const DEFAULT_SKILL_AGENTS: readonly SkillAgent[] = [
+  'cursor',
+  'claude-code',
+  'codex',
+  'windsurf',
+];
+
 /**
  * Build the `<base>/<subpath>[#ref]` URL the `skills` CLI will
  * resolve. Exported for unit tests so the per-source format can be
@@ -94,37 +109,36 @@ export function formatSkillSourceUrl(source: SkillSource): string {
  * rest of the install step so a single project consistently uses one
  * runner.
  *
- * `--all` auto-selects every skill in the cluster and every detected
- * agent runtime, skipping the multi-select prompts the `skills` CLI
- * shows by default. A non-interactive scaffold step cannot present
- * prompts.
+ * `--agent` takes space-separated slugs on one flag; `--skill '*'` and `-y`
+ * skip the multi-select prompts a non-interactive scaffold step cannot show.
  *
  * Exported for unit tests so the per-PM dispatch can be asserted
  * without a live subprocess.
  */
-export function formatSkillInstallCommand(pm: PackageManager, source: SkillSource): string {
-  const args = ['skills@latest', 'add', formatSkillSourceUrl(source), '--all'];
-  return formatPackageManagerCommand(pm, args);
-}
-
-/**
- * `skills add --all` should cover Claude Code, but upstream currently skips
- * project-local Claude symlinks when `.claude/` does not already exist. Run
- * the explicit Claude Code install as well so fresh projects get
- * `.claude/skills` without asking users to create that folder first.
- */
-export function formatClaudeSkillInstallCommand(pm: PackageManager, source: SkillSource): string {
-  const args = [
+export function formatSkillInstallCommand(args: {
+  readonly pm: PackageManager;
+  readonly source: SkillSource;
+  readonly agents?: readonly SkillAgent[];
+}): string {
+  const agents = args.agents ?? DEFAULT_SKILL_AGENTS;
+  const cliArgs = [
     'skills@latest',
     'add',
-    formatSkillSourceUrl(source),
+    formatSkillSourceUrl(args.source),
     '--agent',
-    'claude-code',
+    ...agents,
     '--skill',
     "'*'",
     '-y',
   ];
-  return formatPackageManagerCommand(pm, args);
+  return formatPackageManagerCommand(args.pm, cliArgs);
+}
+
+/**
+ * Ordered skill-install commands for one init run. Exported for unit tests.
+ */
+export function resolveProjectSkillInstallCommands(pm: PackageManager): readonly string[] {
+  return DEFAULT_SKILL_SOURCES.map((source) => formatSkillInstallCommand({ pm, source }));
 }
 
 function formatPackageManagerCommand(pm: PackageManager, args: readonly string[]): string {
@@ -162,7 +176,7 @@ function commandToExec(command: string): {
 
 /**
  * Runs the project-level skill install for every source in
- * `DEFAULT_AGENT_SKILL_SOURCES`, in order. Returns
+ * `DEFAULT_SKILL_SOURCES`, in order. Returns
  * `{ ok: true, commands }` on success; throws a structured
  * `errorInitSkillInstallFailed` on the first failure (subsequent
  * sources are not attempted — the user opted into Prisma Next by
@@ -176,10 +190,7 @@ export async function runProjectLevelSkillInstall(ctx: {
   readonly filesWritten: readonly string[];
 }): Promise<{ readonly ok: true; readonly commands: readonly string[] }> {
   const commands: string[] = [];
-  const installCommands = DEFAULT_AGENT_SKILL_SOURCES.flatMap((source) => [
-    formatSkillInstallCommand(ctx.pm, source),
-    formatClaudeSkillInstallCommand(ctx.pm, source),
-  ]);
+  const installCommands = resolveProjectSkillInstallCommands(ctx.pm);
 
   for (const command of installCommands) {
     const { file, args } = commandToExec(command);

package/src/commands/init/templates/code-templates.ts

@@ -1,3 +1,5 @@
+import { DEFAULT_CONTRACT_SOURCE_DIR } from '@prisma-next/config/config-types';
+
 export type TargetId = 'postgres' | 'mongo';
 export type AuthoringId = 'psl' | 'typescript';
 
@@ -11,9 +13,9 @@ export function targetLabel(target: TargetId): string {
 
 export function defaultSchemaPath(authoring: AuthoringId): string {
   if (authoring === 'typescript') {
-    return 'prisma/contract.ts';
+    return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.ts`;
   }
-  return 'prisma/contract.prisma';
+  return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.prisma`;
 }
 
 export function starterSchema(target: TargetId, authoring: AuthoringId): string {
@@ -42,9 +44,10 @@ export function schemaSample(target: TargetId, authoring: AuthoringId): string {
 function schemaSamplePslPostgres(): string {
   return `\`\`\`prisma
 model User {
-  id    Int     @id @default(autoincrement())
-  email String  @unique
-  name  String?
+  id       Int     @id @default(autoincrement())
+  email    String  @unique
+  username String?
+  name     String?
 }
 \`\`\``;
 }
@@ -52,9 +55,10 @@ model User {
 function schemaSamplePslMongo(): string {
   return `\`\`\`prisma
 model User {
-  id    ObjectId @id @map("_id")
-  email String   @unique
-  name  String?
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
   @@map("users")
 }
 \`\`\``;
@@ -63,17 +67,16 @@ model User {
 function schemaSampleTsPostgres(): string {
   return `\`\`\`typescript
 import { defineContract } from '@prisma-next/postgres/contract-builder';
-import sqlFamily from '@prisma-next/postgres/family';
-import postgresTarget from '@prisma-next/postgres/target';
 
 export const contract = defineContract(
-  { family: sqlFamily, target: postgresTarget },
+  {},
   ({ field, model }) => ({
     models: {
       User: model('User', {
         fields: {
           id: field.id.uuidv7(),
           email: field.text().unique(),
+          username: field.text().optional(),
           name: field.text().optional(),
         },
       }),
@@ -86,11 +89,9 @@ export const contract = defineContract(
 function schemaSampleTsMongo(): string {
   return `\`\`\`typescript
 import { defineContract } from '@prisma-next/mongo/contract-builder';
-import mongoFamily from '@prisma-next/mongo/family';
-import mongoTarget from '@prisma-next/mongo/target';
 
 export const contract = defineContract(
-  { family: mongoFamily, target: mongoTarget },
+  {},
   ({ field, model }) => ({
     models: {
       User: model('User', {
@@ -98,6 +99,7 @@ export const contract = defineContract(
         fields: {
           _id: field.objectId(),
           email: field.string(),
+          username: field.string().optional(),
           name: field.string().optional(),
         },
       }),
@@ -113,6 +115,7 @@ function starterSchemaPslPostgres(): string {
 model User {
   id        Int      @id @default(autoincrement())
   email     String   @unique
+  username  String?
   name      String?
   posts     Post[]
   createdAt DateTime @default(now())
@@ -135,10 +138,11 @@ function starterSchemaPslMongo(): string {
   return `// use prisma-next
 
 model User {
-  id    ObjectId @id @map("_id")
-  email String   @unique
-  name  String?
-  posts Post[]
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
+  posts    Post[]
   @@map("users")
 }
 
@@ -155,17 +159,16 @@ model Post {
 
 function starterSchemaTsPostgres(): string {
   return `import { defineContract } from '@prisma-next/postgres/contract-builder';
-import sqlFamily from '@prisma-next/postgres/family';
-import postgresTarget from '@prisma-next/postgres/target';
 
 export const contract = defineContract(
-  { family: sqlFamily, target: postgresTarget },
+  {},
   ({ field, model, rel }) => ({
     models: {
       User: model('User', {
         fields: {
           id: field.id.uuidv7(),
           email: field.text().unique(),
+          username: field.text().optional(),
           name: field.text().optional(),
           createdAt: field.temporal.createdAt(),
           updatedAt: field.temporal.updatedAt(),
@@ -196,11 +199,9 @@ export const contract = defineContract(
 
 function starterSchemaTsMongo(): string {
   return `import { defineContract } from '@prisma-next/mongo/contract-builder';
-import mongoFamily from '@prisma-next/mongo/family';
-import mongoTarget from '@prisma-next/mongo/target';
 
 export const contract = defineContract(
-  { family: mongoFamily, target: mongoTarget },
+  {},
   ({ field, model, rel }) => ({
     models: {
       User: model('User', {
@@ -208,6 +209,7 @@ export const contract = defineContract(
         fields: {
           _id: field.objectId(),
           email: field.string(),
+          username: field.string().optional(),
           name: field.string().optional(),
         },
         relations: {

package/src/commands/init/templates/env.ts

@@ -40,7 +40,14 @@ function envPlaceholderBody(target: TargetId): string {
   if (target === 'postgres') {
     lines.push('DATABASE_URL="postgresql://user:password@localhost:5432/mydb"');
   } else {
-    lines.push('DATABASE_URL="mongodb://localhost:27017/mydb"');
+    lines.push(
+      '# Standalone local mongod / `docker run mongo:7` — no replica set required for first-run queries.',
+    );
+    lines.push(
+      '# Transactions and change streams need a replica set; add ?replicaSet=... only after initiating one.',
+    );
+    lines.push('');
+    lines.push('DATABASE_URL="mongodb://user:password@localhost:27017/mydb"');
   }
   lines.push('');
   return lines.join('\n');

package/src/commands/init/templates/quick-reference-mongo.md

@@ -22,7 +22,7 @@ const user = await db.orm.users
   .first();
 
 // Your editor will show the type of user as
-// { _id: ObjectId; email: string; name: string | null; posts: Post[] } | null
+// { _id: ObjectId; email: string; username: string | null; name: string | null; posts: Post[] } | null
 ```
 
 `db` connects to MongoDB lazily on the first query, so there is no manual `connect(...)` step in your application code. Call `await db.close()` if you need to release the underlying connection (typically only in tests or short-lived scripts). After `close()` the client is single-shot — any further query, `connect()`, or `runtime()` call rejects with `"Mongo client is closed"`. Construct a new `mongo({...})` if you need to use it again.

package/src/commands/init/templates/quick-reference-postgres.md

@@ -22,7 +22,7 @@ const user = await db.orm.User
   .first();
 
 // Your editor will show the type of user as
-// { id: number; email: string; createdAt: Date, name: string, posts: Post[] } | null
+// { id: number; email: string; username: string | null; name: string | null; createdAt: Date; posts: Post[] } | null
 ```
 
 Your contract has two companion files in the same directory:

package/src/commands/init/templates/readme-mongo.md

@@ -0,0 +1,35 @@
+# {{projectName}}
+
+Generated by `prisma-next init` with the Minimal template.
+
+## First run
+
+1. `{{runDbUp}}` — start the local MongoDB replica set with `mongodb-memory-server`. Data persists in `.mongo-data/` across restarts.
+2. `{{runDev}}` — runs `src/index.ts`, which writes one row and reads it back.
+
+## Available scripts
+
+- `{{runDev}}` — run the Prisma Next sample script
+
+### Database and migrations
+
+- `{{runContractEmit}}` — emit contract artifacts after contract changes
+- `{{runDbUp}}` — start the local MongoDB replica set with `mongodb-memory-server`. Data persists in `.mongo-data/` across restarts.
+- `{{runDbDown}}` — stop the local MongoDB process (data preserved)
+- `{{runDbReset}}` — stop and wipe `.mongo-data/` for a clean slate
+- `{{runMigrationPlan}}` — create a MongoDB migration plan
+- `{{runMigrate}}` — apply the planned MongoDB migration
+- `{{runDbSeed}}` — insert sample users manually
+
+## Prisma Next
+
+Prisma Next setup is scaffolded in:
+
+- `{{contractPath}}`
+- `prisma-next.config.ts`
+- `prisma/db.ts`
+- `src/lib/prisma.ts`
+
+For provider-specific Prisma Next reference docs, see `prisma-next.md`. Prisma Next skills live in the upstream `skills/` directory: https://github.com/prisma/prisma-next/tree/main/skills.
+
+Node-based Prisma Next projects expect Node.js 24 LTS or newer.

package/src/commands/init/templates/readme-postgres.md

@@ -0,0 +1,34 @@
+# {{projectName}}
+
+Generated by `prisma-next init` with the Minimal template.
+
+## First run
+
+1. `{{runDbInit}}` — applies your contract to the database (creates tables, signs the marker).
+2. `{{runDev}}` — runs `src/index.ts`, which writes one row and reads it back.
+
+## Available scripts
+
+- `{{runDev}}` — run the Prisma Next sample script
+
+### Database and migrations
+
+- `{{runContractEmit}}` — emit contract artifacts after contract changes
+- `{{runDbInit}}` — initialize database state manually
+- `{{runDbUpdate}}` — update database state manually
+- `{{runMigrationPlan}}` — create a migration plan
+- `{{runMigrate}}` — apply a planned migration
+- `{{runDbSeed}}` — insert sample users manually (run after `db:init`)
+
+## Prisma Next
+
+Prisma Next setup is scaffolded in:
+
+- `{{contractPath}}`
+- `prisma-next.config.ts`
+- `prisma/db.ts`
+- `src/lib/prisma.ts`
+
+For provider-specific Prisma Next reference docs, see `prisma-next.md`. Prisma Next skills live in the upstream `skills/` directory: https://github.com/prisma/prisma-next/tree/main/skills.
+
+Node-based Prisma Next projects expect Node.js 24 LTS or newer.

package/src/commands/init/templates/readme.ts

@@ -0,0 +1,62 @@
+import { formatRunScriptCommand, type PackageManager } from '../detect-package-manager';
+import type { TargetId } from './code-templates';
+import { renderTemplate } from './render';
+
+const sharedVariables = ['projectName', 'contractPath', 'runDev', 'runContractEmit'] as const;
+
+export const postgresVariables = [
+  ...sharedVariables,
+  'runDbInit',
+  'runDbUpdate',
+  'runMigrationPlan',
+  'runMigrate',
+  'runDbSeed',
+] as const;
+
+export const mongoVariables = [
+  ...sharedVariables,
+  'runDbUp',
+  'runDbDown',
+  'runDbReset',
+  'runMigrationPlan',
+  'runMigrate',
+  'runDbSeed',
+] as const;
+
+type PostgresVars = Record<(typeof postgresVariables)[number], string>;
+type MongoVars = Record<(typeof mongoVariables)[number], string>;
+
+export function minimalProjectReadmeMd(
+  target: TargetId,
+  schemaPath: string,
+  projectName: string,
+  pm: PackageManager,
+): string {
+  const run = (script: string): string => formatRunScriptCommand(pm, script);
+  const shared = {
+    projectName,
+    contractPath: schemaPath,
+    runDev: run('dev'),
+    runContractEmit: run('contract:emit'),
+    runMigrationPlan: run('migration:plan'),
+    runMigrate: run('migrate'),
+    runDbSeed: run('db:seed'),
+  };
+
+  if (target === 'mongo') {
+    const vars: MongoVars = {
+      ...shared,
+      runDbUp: run('db:up'),
+      runDbDown: run('db:down'),
+      runDbReset: run('db:reset'),
+    };
+    return renderTemplate('readme-mongo.md', mongoVariables, vars);
+  }
+
+  const vars: PostgresVars = {
+    ...shared,
+    runDbInit: run('db:init'),
+    runDbUpdate: run('db:update'),
+  };
+  return renderTemplate('readme-postgres.md', postgresVariables, vars);
+}

package/src/commands/migrate.ts

@@ -43,9 +43,9 @@ import {
 import { formatMigrationApplyCommandOutput } from '../utils/formatters/migrations';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 
 interface MigrateCommandOptions extends CommonCommandOptions {
   readonly db?: string;
@@ -319,13 +319,10 @@ export function createMigrateCommand(): Command {
       'Target contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path)',
     )
     .action(async (options: MigrateCommandOptions) => {
-      const flags = parseGlobalFlags(options);
+      const flags = parseGlobalFlagsOrExit(options);
       const startTime = Date.now();
 
-      const ui = new TerminalUI({
-        color: flags.color,
-        interactive: flags.interactive,
-      });
+      const ui = createTerminalUI(flags);
 
       const result = await executeMigrateCommand(options, flags, ui, startTime);
 

package/src/commands/migration-check.ts

@@ -17,8 +17,8 @@ import {
 } from '../utils/command-helpers';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
-import { TerminalUI } from '../utils/terminal-ui';
+import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
+import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 import { INTEGRITY_FAILED, OK, PRECONDITION } from './migration-check/exit-codes';
 
 interface MigrationCheckOptions extends CommonCommandOptions {
@@ -335,8 +335,8 @@ export function createMigrationCheckCommand(): Command {
     .argument('[migration]', 'Migration reference (directory name or hash) to check')
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (target: string | undefined, options: MigrationCheckOptions) => {
-      const flags = parseGlobalFlags(options);
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const flags = parseGlobalFlagsOrExit(options);
+      const ui = createTerminalUI(flags);
 
       let result: MigrationCheckResult;
       let exitCode: number;