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

package/src/commands/db-verify.ts

@@ -47,10 +47,10 @@ import {
   formatVerifyOutput,
 } from '../utils/formatters/verify';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { createProgressAdapter } from '../utils/progress-adapter';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 
 interface DbVerifyOptions extends CommonCommandOptions {
   readonly db?: string;
@@ -331,7 +331,7 @@ function wrapVerifyError(
   contractPathAbsolute: string,
   modeLabel: string,
 ): Result<never, CliStructuredError> {
-  if (error instanceof CliStructuredError) {
+  if (CliStructuredError.is(error)) {
     return notOk(error);
   }
   if (error instanceof ContractValidationError) {
@@ -529,8 +529,8 @@ export function createDbVerifyCommand(): Command {
       false,
     )
     .action(async (options: DbVerifyOptions) => {
-      const flags = parseGlobalFlags(options);
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const flags = parseGlobalFlagsOrExit(options);
+      const ui = createTerminalUI(flags);
 
       const modeResult = resolveDbVerifyMode(options);
       if (!modeResult.ok) {

package/src/commands/init/detect-package-manager.ts

@@ -56,6 +56,21 @@ export function formatRunCommand(pm: PackageManager, bin: string, args: string):
   return `${pm} ${bin} ${args}`;
 }
 
+export function formatRunScriptCommand(pm: PackageManager, scriptName: string): string {
+  switch (pm) {
+    case 'deno':
+      return `deno task ${scriptName}`;
+    case 'bun':
+      return `bun run ${scriptName}`;
+    case 'pnpm':
+      return `pnpm run ${scriptName}`;
+    case 'yarn':
+      return `yarn run ${scriptName}`;
+    default:
+      return `npm run ${scriptName}`;
+  }
+}
+
 export function formatAddArgs(pm: PackageManager, packages: string[]): string[] {
   if (pm === 'deno') {
     return ['add', ...packages.map((p) => `npm:${p}`)];

package/src/commands/init/errors.ts

@@ -69,6 +69,37 @@ export function errorInitInvalidFlagValue(options: {
   });
 }
 
+/**
+ * `--authoring` and `--schema-path` disagree on file extension (e.g. PSL
+ * authoring with a `.ts` path). Surfaces before any scaffold files are
+ * written so the project tree stays untouched.
+ */
+export function errorInitAuthoringSchemaPathMismatch(options: {
+  readonly authoring: 'psl' | 'typescript';
+  readonly schemaPath: string;
+  readonly actualExtension: string;
+  readonly expectedExtension: string;
+}): CliStructuredError {
+  const expectedAuthoring = options.expectedExtension === '.ts' ? 'typescript' : 'psl';
+  return new CliStructuredError('5014', 'Authoring and schema path do not match', {
+    domain: 'CLI',
+    why:
+      `\`--authoring ${options.authoring}\` requires a schema file ending in ${options.expectedExtension}, ` +
+      `but \`--schema-path ${options.schemaPath}\` ends in ${options.actualExtension}.`,
+    fix:
+      `Use a matching pair, for example \`--authoring ${expectedAuthoring} --schema-path <path>${options.expectedExtension}\`, ` +
+      'or change `--authoring` to match the path you supplied. ' +
+      'You can also omit `--schema-path` to use the default for the chosen authoring.',
+    docsUrl: 'https://prisma-next.dev/docs/cli/init',
+    meta: {
+      authoring: options.authoring,
+      schemaPath: options.schemaPath,
+      actualExtension: options.actualExtension,
+      expectedExtension: options.expectedExtension,
+    },
+  });
+}
+
 /**
  * The user cancelled an interactive prompt (Ctrl-C, escape, declined a
  * selection). Distinct from `errorInitReinitNeedsForce` because that path

package/src/commands/init/hygiene-gitattributes.ts

@@ -20,7 +20,7 @@ import type { TargetId } from './templates/code-templates';
  * `db/contract.json linguist-generated` — not the workspace-glob form
  * `<glob>/contract.json` (which would over-match any unrelated
  * `contract.json` the user has elsewhere) and not the absolute
- * `prisma/contract.json` (which would silently break for a non-default
+ * `DEFAULT_CONTRACT_SOURCE_DIR/contract.json` (which would silently break for a non-default
  * schema path).
  */
 const ARTEFACT_FILENAMES: readonly string[] = [
@@ -59,7 +59,7 @@ export function requiredGitattributesLines(
  *
  * Equivalence is exact-line: a user-customised line like
  * `prisma/*.json linguist-generated` is *not* recognised as covering
- * `prisma/contract.json linguist-generated`. We accept that
+ * `DEFAULT_CONTRACT_SOURCE_DIR/contract.json linguist-generated`. We accept that
  * over-specification — preserving the user's broad pattern *and*
  * appending the narrow one — because the narrow lines are what the
  * acceptance criteria pin (FR3.4 AC).

package/src/commands/init/index.ts

@@ -4,7 +4,7 @@ import {
   setCommandDescriptions,
   setCommandExamples,
 } from '../../utils/command-helpers';
-import { type CommonCommandOptions, parseGlobalFlags } from '../../utils/global-flags';
+import { type CommonCommandOptions, parseGlobalFlagsOrExit } from '../../utils/global-flags';
 import { fireTelemetryAfterInitConsent } from '../../utils/telemetry';
 import {
   INIT_EXIT_EMIT_FAILED,
@@ -15,6 +15,7 @@ import {
   INIT_EXIT_SKILL_INSTALL_FAILED,
   INIT_EXIT_USER_ABORTED,
 } from './exit-codes';
+import { defaultSchemaPath } from './templates/code-templates';
 
 /**
  * Commander.js parsed options for `init`. The init-specific options live
@@ -72,7 +73,7 @@ export function createInitCommand(): Command {
     .option('--authoring <style>', 'Schema authoring style: psl or typescript')
     .option(
       '--schema-path <path>',
-      'Where to write the starter schema (default: prisma/contract.prisma)',
+      `Where to write the starter schema (default: ${defaultSchemaPath('psl')})`,
     )
     .option('--force', 'Overwrite an existing scaffold without prompting')
     .option(
@@ -94,7 +95,7 @@ export function createInitCommand(): Command {
     )
     .action(async (options: InitCommandOptions, actionCommand: Command) => {
       const { runInit } = await import('./init');
-      const flags = parseGlobalFlags(options);
+      const flags = parseGlobalFlagsOrExit(options);
       const canPrompt = deriveCanPrompt({
         flagsInteractive: flags.interactive,
         optionInteractive: options.interactive,

package/src/commands/init/init.ts

@@ -6,7 +6,7 @@ import { basename, dirname, isAbsolute, join } from 'pathe';
 import { CliStructuredError } from '../../utils/cli-errors';
 import { formatErrorJson, formatErrorOutput } from '../../utils/formatters/errors';
 import type { GlobalFlags } from '../../utils/global-flags';
-import { TerminalUI } from '../../utils/terminal-ui';
+import { createTerminalUI, type TerminalUI } from '../../utils/terminal-ui';
 import {
   detectPackageManager,
   formatAddArgs,
@@ -51,7 +51,6 @@ import { type ProbeOutcome, type ProbeOverrides, probeServerVersion } from './pr
 import { findStaleArtefacts, removeDependency } from './reinit-cleanup';
 import {
   DEFAULT_SKILL_SOURCES,
-  formatClaudeSkillInstallCommand,
   formatSkillInstallCommand,
   LEGACY_SKILL_FILE,
   runProjectLevelSkillInstall,
@@ -59,6 +58,7 @@ import {
 import { configFile, dbFile, starterSchema, targetPackageName } from './templates/code-templates';
 import { envExampleContent, envFileContent, MIN_SERVER_VERSION } from './templates/env';
 import { quickReferenceMd } from './templates/quick-reference';
+import { minimalProjectReadmeMd } from './templates/readme';
 import { defaultTsConfig, mergeTsConfig, TsConfigParseError } from './templates/tsconfig';
 
 interface FileEntry {
@@ -130,7 +130,7 @@ export async function runInit(
   },
 ): Promise<number> {
   const { options, flags, canPrompt, probeOverrides, afterFirstTelemetryConsent } = runOptions;
-  const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+  const ui = createTerminalUI(flags);
   const warnings: string[] = [];
   const filesWritten: string[] = [];
   const filesDeleted: string[] = [];
@@ -349,6 +349,26 @@ export async function runInit(
     }
   }
 
+  if (existsSync(join(baseDir, 'src/index.ts'))) {
+    if (!existsSync(join(baseDir, 'README.md'))) {
+      const rawName =
+        parsedPackageJson !== null && typeof parsedPackageJson['name'] === 'string'
+          ? parsedPackageJson['name']
+          : basename(baseDir);
+      filesToWrite.push({
+        path: 'README.md',
+        content: minimalProjectReadmeMd(
+          inputs.target,
+          inputs.schemaPath,
+          sanitisePackageName(rawName),
+          pm,
+        ),
+      });
+    } else {
+      warnings.push('README.md already exists; leaving it untouched.');
+    }
+  }
+
   // -----------------------------------------------------------------
   // Write phase — every input has been parsed and every merged file is
   // staged. From here on, failures are only possible at the
@@ -458,26 +478,21 @@ export async function runInit(
   // framework relies on. A project-level failure is fatal
   // (`INIT_EXIT_SKILL_INSTALL_FAILED`).
   //
-  // Runs after install + emit because (1) `node_modules` is in place,
-  // so any consumers downstream are coherent, and (2) the user has
-  // seen the scaffolding succeed before this network-bound step
-  // potentially fails. We skip the install when the user passed
-  // `--no-install` for the same reason — no `node_modules` means the
-  // workspace isn't ready to consume the skill yet anyway.
-  const manualProjectSkillCommands = DEFAULT_SKILL_SOURCES.flatMap((source) => [
-    formatSkillInstallCommand(install.effectivePm, source),
-    formatClaudeSkillInstallCommand(install.effectivePm, source),
-  ]);
+  // Runs after the install + emit phase when those steps are enabled,
+  // but is not coupled to them: the skills are pulled directly from
+  // the Prisma Next GitHub repo and do not require `node_modules`.
+  // `--no-install` therefore skips only dependency installation and
+  // contract emission; `--no-skill` is the explicit escape hatch for
+  // skipping skills.
+  const manualProjectSkillCommands = DEFAULT_SKILL_SOURCES.map((source) =>
+    formatSkillInstallCommand({ pm: install.effectivePm, source }),
+  );
   const manualProjectSkillSummary = manualProjectSkillCommands.map((c) => `\`${c}\``).join(' && ');
   let skillRegistered = false;
   if (!inputs.installProjectSkill) {
     warnings.push(
       `Skipped Prisma Next skills install (--no-skill). To install the skills later, run: ${manualProjectSkillSummary}`,
     );
-  } else if (install.skipped) {
-    warnings.push(
-      `Skipped Prisma Next skills install because --no-install was passed. After you run install manually, install the skills with: ${manualProjectSkillSummary}`,
-    );
   } else {
     const spinner = ui.spinner();
     spinner.start('Registering Prisma Next skills with the agent runtime...');
@@ -601,6 +616,7 @@ export function exitCodeForError(error: { readonly code: string }): number {
     case '5010': // invalid manifest (malformed package.json) — precondition
     case '5011': // invalid tsconfig (unparseable JSONC) — precondition
     case '5012': // probe failed under --strict-probe — precondition
+    case '5014': // --authoring / --schema-path extension mismatch — precondition
       return INIT_EXIT_PRECONDITION;
     case '5006': // user aborted interactive prompt
       return INIT_EXIT_USER_ABORTED;

package/src/commands/init/inputs.ts

@@ -5,6 +5,7 @@ import { extname, join, normalize } from 'pathe';
 import type { GlobalFlags } from '../../utils/global-flags';
 import { isCI } from '../../utils/is-ci';
 import {
+  errorInitAuthoringSchemaPathMismatch,
   errorInitInvalidFlagValue,
   errorInitMissingFlags,
   errorInitReinitNeedsForce,
@@ -451,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/skill-install.ts

@@ -15,8 +15,8 @@ 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
@@ -73,6 +73,21 @@ 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 {
@@ -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_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 {
@@ -65,11 +67,9 @@ 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', {
@@ -89,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', {
@@ -161,11 +159,9 @@ 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', {
@@ -203,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', {

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/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;