create-prisma 0.1.4 → 0.2.0

package/dist/{create-Dz9GFGFQ.mjs → create-DgN5mAMV.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
+import { cancel, confirm, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
 import fs from "fs-extra";
 import path from "node:path";
 import Handlebars from "handlebars";
@@ -9,82 +9,17 @@ import { z } from "zod";
 import { execa } from "execa";
 import { styleText } from "node:util";
 
-//#region src/templates/shared.ts
-Handlebars.registerHelper("eq", (left, right) => left === right);
-function findPackageRoot(startDir) {
-	let currentDir = startDir;
-	while (true) {
-		if (existsSync(path.join(currentDir, "package.json"))) return currentDir;
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) break;
-		currentDir = parentDir;
-	}
-	throw new Error(`Unable to locate package root from: ${startDir}`);
-}
-function resolveTemplatesDir(relativeTemplatesDir) {
-	const currentFilePath = fileURLToPath(import.meta.url);
-	const packageRoot = findPackageRoot(path.dirname(currentFilePath));
-	const templatePath = path.join(packageRoot, relativeTemplatesDir);
-	if (!existsSync(templatePath)) throw new Error(`Template directory not found at: ${templatePath}`);
-	return templatePath;
-}
-async function getTemplateFilesRecursively(dir) {
-	const entries = await fs.readdir(dir, { withFileTypes: true });
-	return (await Promise.all(entries.map(async (entry) => {
-		const entryPath = path.join(dir, entry.name);
-		if (entry.isDirectory()) return getTemplateFilesRecursively(entryPath);
-		if (!entry.isFile()) return [];
-		return [entryPath];
-	}))).flat();
-}
-function stripHbsExtension(filePath) {
-	return filePath.endsWith(".hbs") ? filePath.slice(0, -4) : filePath;
-}
-function ensureTrailingNewline(content) {
-	return content.endsWith("\n") ? content : `${content}\n`;
-}
-async function renderTemplateFile(opts) {
-	const { templateFilePath, outputPath, context } = opts;
-	const templateContent = await fs.readFile(templateFilePath, "utf8");
-	const outputContent = templateFilePath.endsWith(".hbs") ? Handlebars.compile(templateContent, {
-		noEscape: true,
-		strict: true
-	})(context) : templateContent;
-	await fs.outputFile(outputPath, ensureTrailingNewline(outputContent), "utf8");
-}
-async function renderTemplateTree(opts) {
-	const { templateRoot, outputDir, context } = opts;
-	const templateFiles = await getTemplateFilesRecursively(templateRoot);
-	for (const templateFilePath of templateFiles) {
-		const relativeOutputPath = stripHbsExtension(path.relative(templateRoot, templateFilePath));
-		await renderTemplateFile({
-			templateFilePath,
-			outputPath: path.join(outputDir, relativeOutputPath),
-			context
-		});
-	}
-}
-
-//#endregion
-//#region src/templates/render-create-template.ts
-function getCreateTemplateDir(template) {
-	return resolveTemplatesDir(`templates/create/${template}`);
-}
-function createTemplateContext$1(projectName, schemaPreset, packageManager) {
-	return {
-		projectName,
-		schemaPreset,
-		packageManager
-	};
-}
-async function scaffoldCreateTemplate(opts) {
-	const { projectDir, projectName, template, schemaPreset, packageManager } = opts;
-	await renderTemplateTree({
-		templateRoot: getCreateTemplateDir(template),
-		outputDir: projectDir,
-		context: createTemplateContext$1(projectName, schemaPreset, packageManager)
-	});
-}
+//#region src/constants/dependencies.ts
+const dependencyVersionMap = {
+	"@prisma/client": "^7.4.0",
+	"@prisma/adapter-pg": "^7.4.0",
+	"@prisma/adapter-mariadb": "^7.4.0",
+	"@prisma/adapter-better-sqlite3": "^7.4.0",
+	"@prisma/adapter-mssql": "^7.4.0",
+	dotenv: "^17.2.3",
+	"node-gyp": "^11.5.0",
+	prisma: "^7.4.0"
+};
 
 //#endregion
 //#region src/types.ts
@@ -98,14 +33,45 @@ const databaseProviders = [
 const packageManagers = [
 	"npm",
 	"pnpm",
-	"bun"
+	"yarn",
+	"bun",
+	"deno"
 ];
 const schemaPresets = ["empty", "basic"];
-const createTemplates = ["hono", "next"];
+const createTemplates = [
+	"hono",
+	"next",
+	"svelte",
+	"astro",
+	"nuxt",
+	"turborepo"
+];
+const createAddons = [
+	"skills",
+	"mcp",
+	"extension"
+];
+const addonInstallScopes = ["project", "global"];
+const extensionTargets = [
+	"vscode",
+	"cursor",
+	"windsurf"
+];
+const prismaSkillNames = [
+	"prisma-cli",
+	"prisma-client-api",
+	"prisma-database-setup",
+	"prisma-upgrade-v7",
+	"prisma-postgres"
+];
 const DatabaseProviderSchema = z.enum(databaseProviders);
 const PackageManagerSchema = z.enum(packageManagers);
 const SchemaPresetSchema = z.enum(schemaPresets);
 const CreateTemplateSchema = z.enum(createTemplates);
+const CreateAddonSchema = z.enum(createAddons);
+const AddonInstallScopeSchema = z.enum(addonInstallScopes);
+const ExtensionTargetSchema = z.enum(extensionTargets);
+const PrismaSkillNameSchema = z.enum(prismaSkillNames);
 const DatabaseUrlSchema = z.string().trim().min(1, "Please enter a valid database URL");
 const CommonCommandOptionsSchema = z.object({
 	yes: z.boolean().optional().describe("Skip prompts and accept default choices"),
@@ -120,19 +86,30 @@ const PrismaSetupOptionsSchema = z.object({
 	generate: z.boolean().optional().describe("Generate Prisma Client after scaffolding"),
 	schemaPreset: SchemaPresetSchema.optional().describe("Schema preset to scaffold in prisma/schema.prisma")
 });
-const InitCommandInputSchema = CommonCommandOptionsSchema.extend(PrismaSetupOptionsSchema.shape);
+const PrismaSetupCommandInputSchema = CommonCommandOptionsSchema.extend(PrismaSetupOptionsSchema.shape);
 const CreateScaffoldOptionsSchema = z.object({
 	name: z.string().trim().min(1, "Please enter a valid project name").optional().describe("Project name / directory"),
 	template: CreateTemplateSchema.optional().describe("Project template"),
+	skills: z.boolean().optional().describe("Enable skills addon"),
+	mcp: z.boolean().optional().describe("Enable MCP addon"),
+	extension: z.boolean().optional().describe("Enable extension addon"),
 	force: z.boolean().optional().describe("Allow scaffolding into a non-empty target directory")
 });
-const CreateCommandInputSchema = CommonCommandOptionsSchema.extend(CreateScaffoldOptionsSchema.shape).extend(PrismaSetupOptionsSchema.shape);
+const CreateCommandInputSchema = PrismaSetupCommandInputSchema.extend(CreateScaffoldOptionsSchema.shape);
 
 //#endregion
 //#region src/utils/package-manager.ts
+const packageManagerManifestValues = {
+	npm: "npm@10.9.0",
+	pnpm: "pnpm@10.16.1",
+	yarn: "yarn@4.13.0",
+	bun: "bun@1.3.9"
+};
 function parseUserAgent(userAgent) {
 	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("yarn")) return "yarn";
 	if (userAgent?.startsWith("bun")) return "bun";
+	if (userAgent?.startsWith("deno")) return "deno";
 	if (userAgent?.startsWith("npm")) return "npm";
 	return null;
 }
@@ -147,12 +124,20 @@ async function detectFromPackageJson(projectDir) {
 	if (!await fs.pathExists(packageJsonPath)) return null;
 	return parsePackageManagerField((await fs.readJson(packageJsonPath)).packageManager);
 }
+async function detectFromDenoConfig(projectDir) {
+	for (const configFile of ["deno.json", "deno.jsonc"]) if (await fs.pathExists(path.join(projectDir, configFile))) return "deno";
+	return null;
+}
 async function detectFromLockfile(projectDir) {
 	for (const check of [
 		{
 			manager: "pnpm",
 			lockfile: "pnpm-lock.yaml"
 		},
+		{
+			manager: "yarn",
+			lockfile: "yarn.lock"
+		},
 		{
 			manager: "bun",
 			lockfile: "bun.lockb"
@@ -168,6 +153,10 @@ async function detectFromLockfile(projectDir) {
 		{
 			manager: "npm",
 			lockfile: "npm-shrinkwrap.json"
+		},
+		{
+			manager: "deno",
+			lockfile: "deno.lock"
 		}
 	]) if (await fs.pathExists(path.join(projectDir, check.lockfile))) return check.manager;
 	return null;
@@ -177,49 +166,75 @@ async function detectPackageManager(projectDir = process.cwd()) {
 	if (fromPackageJson) return fromPackageJson;
 	const fromLockfile = await detectFromLockfile(projectDir);
 	if (fromLockfile) return fromLockfile;
+	const fromDenoConfig = await detectFromDenoConfig(projectDir);
+	if (fromDenoConfig) return fromDenoConfig;
 	const fromUserAgent = parseUserAgent(process.env.npm_config_user_agent);
 	if (fromUserAgent) return fromUserAgent;
 	return "npm";
 }
+function getPackageManagerManifestValue(packageManager) {
+	if (!packageManager || packageManager === "deno") return;
+	return packageManagerManifestValues[packageManager];
+}
+function getDenoPrismaSpecifier() {
+	return `npm:prisma@${dependencyVersionMap.prisma.replace(/^[^0-9]*/, "")}`;
+}
 function getInstallCommand(packageManager) {
+	if (packageManager === "deno") return "deno install --allow-scripts";
 	return `${packageManager} install`;
 }
 function getRunScriptCommand(packageManager, scriptName) {
 	switch (packageManager) {
+		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}`;
 	}
 }
 function getInstallArgs(packageManager) {
+	if (packageManager === "deno") return {
+		command: "deno",
+		args: ["install", "--allow-scripts"]
+	};
 	return {
 		command: packageManager,
 		args: ["install"]
 	};
 }
-function getPackageExecutor(packageManager) {
+function getPackageExecutionArgs(packageManager, commandArgs) {
 	switch (packageManager) {
 		case "pnpm": return {
 			command: "pnpm",
-			args: ["dlx"]
+			args: ["dlx", ...commandArgs]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: ["dlx", ...commandArgs]
 		};
 		case "bun": return {
 			command: "bunx",
-			args: []
+			args: [...commandArgs]
 		};
+		case "deno": {
+			const [packageName, ...args] = commandArgs;
+			if (!packageName) throw new Error("Package execution requires a package name.");
+			return {
+				command: "deno",
+				args: [
+					"run",
+					"-A",
+					`npm:${packageName}`,
+					...args
+				]
+			};
+		}
 		default: return {
 			command: "npx",
-			args: []
+			args: [...commandArgs]
 		};
 	}
 }
-function getPackageExecutionArgs(packageManager, commandArgs) {
-	const executor = getPackageExecutor(packageManager);
-	return {
-		command: executor.command,
-		args: [...executor.args, ...commandArgs]
-	};
-}
 function getPackageExecutionCommand(packageManager, commandArgs) {
 	const execution = getPackageExecutionArgs(packageManager, commandArgs);
 	return [execution.command, ...execution.args].join(" ");
@@ -230,6 +245,15 @@ function getPrismaCliArgs(packageManager, prismaArgs) {
 		"prisma",
 		...prismaArgs
 	]);
+	if (packageManager === "deno") return {
+		command: "deno",
+		args: [
+			"run",
+			"-A",
+			getDenoPrismaSpecifier(),
+			...prismaArgs
+		]
+	};
 	return getPackageExecutionArgs(packageManager, ["prisma", ...prismaArgs]);
 }
 function getPrismaCliCommand(packageManager, prismaArgs) {
@@ -238,259 +262,88 @@ function getPrismaCliCommand(packageManager, prismaArgs) {
 }
 
 //#endregion
-//#region src/tasks/prisma-postgres.ts
-const PRISMA_POSTGRES_TEMPORARY_NOTICE = "Prisma Postgres is temporary for 24 hours. Claim this database before it expires using CLAIM_URL.";
-const CREATE_DB_COMMAND_ARGS = ["create-db@latest", "--json"];
-function parseCreateDbJson(rawOutput) {
-	const trimmed = rawOutput.trim();
-	if (!trimmed) throw new Error("create-db returned empty output.");
-	const jsonCandidates = [trimmed];
-	const firstBrace = trimmed.indexOf("{");
-	const lastBrace = trimmed.lastIndexOf("}");
-	if (firstBrace !== -1 && lastBrace > firstBrace) jsonCandidates.push(trimmed.slice(firstBrace, lastBrace + 1));
-	for (const candidate of jsonCandidates) try {
-		return JSON.parse(candidate);
-	} catch {}
-	throw new Error(`Unable to parse create-db JSON output: ${trimmed}`);
+//#region src/templates/shared.ts
+Handlebars.registerHelper("eq", (left, right) => left === right);
+Handlebars.registerHelper("installCommand", (packageManager) => packageManager ? getInstallCommand(packageManager) : "");
+Handlebars.registerHelper("runScriptCommand", (packageManager, scriptName) => packageManager ? getRunScriptCommand(packageManager, scriptName) : "");
+Handlebars.registerHelper("packageManagerManifestValue", (packageManager) => getPackageManagerManifestValue(packageManager) ?? "");
+function findPackageRoot(startDir) {
+	let currentDir = startDir;
+	while (true) {
+		if (existsSync(path.join(currentDir, "package.json"))) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	throw new Error(`Unable to locate package root from: ${startDir}`);
 }
-function pickConnectionString(payload) {
-	if (typeof payload.connectionString === "string" && payload.connectionString.length > 0) return payload.connectionString;
-	if (typeof payload.databaseUrl === "string" && payload.databaseUrl.length > 0) return payload.databaseUrl;
+function resolveTemplatesDir(relativeTemplatesDir) {
+	const currentFilePath = fileURLToPath(import.meta.url);
+	const packageRoot = findPackageRoot(path.dirname(currentFilePath));
+	const templatePath = path.join(packageRoot, relativeTemplatesDir);
+	if (!existsSync(templatePath)) throw new Error(`Template directory not found at: ${templatePath}`);
+	return templatePath;
 }
-function extractErrorMessage(payload, fallback) {
-	if (typeof payload.message === "string" && payload.message.length > 0) return payload.message;
-	if (typeof payload.error === "string" && payload.error.length > 0) return payload.error;
-	return fallback;
+async function getTemplateFilesRecursively(dir) {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) return getTemplateFilesRecursively(entryPath);
+		if (!entry.isFile()) return [];
+		return [entryPath];
+	}))).flat();
 }
-async function provisionPrismaPostgres(packageManager, projectDir = process.cwd()) {
-	const command = getPackageExecutionArgs(packageManager, [...CREATE_DB_COMMAND_ARGS]);
-	const commandString = getCreateDbCommand(packageManager);
-	let stdout;
-	try {
-		stdout = (await execa(command.command, command.args, {
-			cwd: projectDir,
-			stdio: "pipe"
-		})).stdout;
-	} catch (error) {
-		if (error instanceof Error && "stderr" in error) {
-			const stderr = String(error.stderr ?? "").trim();
-			const message = stderr.length > 0 ? stderr : error.message;
-			throw new Error(`Failed to run ${commandString}: ${message}`);
-		}
-		throw error;
-	}
-	const payload = parseCreateDbJson(stdout);
-	if (payload.success === false) throw new Error(extractErrorMessage(payload, "create-db reported failure."));
-	const databaseUrl = pickConnectionString(payload);
-	if (!databaseUrl) throw new Error("create-db did not return a connection string.");
-	return {
-		databaseUrl,
-		claimUrl: typeof payload.claimUrl === "string" && payload.claimUrl.length > 0 ? payload.claimUrl : typeof payload.claimURL === "string" && payload.claimURL.length > 0 ? payload.claimURL : void 0
-	};
+function stripHbsExtension(filePath) {
+	return filePath.endsWith(".hbs") ? filePath.slice(0, -4) : filePath;
 }
-function getCreateDbCommand(packageManager) {
-	return getPackageExecutionCommand(packageManager, [...CREATE_DB_COMMAND_ARGS]);
+function ensureTrailingNewline(content) {
+	return content.endsWith("\n") ? content : `${content}\n`;
+}
+async function renderTemplateFile(opts) {
+	const { templateFilePath, outputPath, context } = opts;
+	const templateContent = await fs.readFile(templateFilePath, "utf8");
+	const outputContent = templateFilePath.endsWith(".hbs") ? Handlebars.compile(templateContent, {
+		noEscape: true,
+		strict: true
+	})(context) : templateContent;
+	if (templateFilePath.endsWith(".hbs") && outputContent.trim().length === 0) return;
+	await fs.outputFile(outputPath, ensureTrailingNewline(outputContent), "utf8");
+}
+async function renderTemplateTree(opts) {
+	const { templateRoot, outputDir, context } = opts;
+	const templateFiles = await getTemplateFilesRecursively(templateRoot);
+	for (const templateFilePath of templateFiles) {
+		const relativeOutputPath = stripHbsExtension(path.relative(templateRoot, templateFilePath));
+		await renderTemplateFile({
+			templateFilePath,
+			outputPath: path.join(outputDir, relativeOutputPath),
+			context
+		});
+	}
 }
 
 //#endregion
-//#region src/templates/render-init-templates.ts
-function getInitTemplatesDir() {
-	return resolveTemplatesDir("templates/init");
+//#region src/templates/render-create-template.ts
+function getCreateTemplateDir(template) {
+	return resolveTemplatesDir(`templates/create/${template}`);
 }
-function createTemplateContext(provider, envVar, schemaPreset) {
+function createTemplateContext(projectName, provider, schemaPreset, packageManager) {
 	return {
-		envVar,
+		projectName,
 		provider,
-		schemaPreset
+		schemaPreset,
+		packageManager
 	};
 }
-async function scaffoldInitTemplates(projectDir, provider, envVar = "DATABASE_URL", schemaPreset = "empty") {
+async function scaffoldCreateTemplate(opts) {
+	const { projectDir, projectName, template, provider, schemaPreset, packageManager } = opts;
 	await renderTemplateTree({
-		templateRoot: getInitTemplatesDir(),
+		templateRoot: getCreateTemplateDir(template),
 		outputDir: projectDir,
-		context: createTemplateContext(provider, envVar, schemaPreset)
+		context: createTemplateContext(projectName, provider, schemaPreset, packageManager)
 	});
-	return {
-		schemaPath: path.join(projectDir, "prisma/schema.prisma"),
-		configPath: path.join(projectDir, "prisma.config.ts"),
-		singletonPath: path.join(projectDir, "prisma/index.ts")
-	};
 }
 
-//#endregion
-//#region src/tasks/init-prisma.ts
-const prismaManagedFiles = [
-	"schema.prisma",
-	"prisma/schema.prisma",
-	"prisma/index.ts",
-	"prisma.config.ts"
-];
-const prismaTemplateFiles = [
-	"prisma/schema.prisma",
-	"prisma/index.ts",
-	"prisma.config.ts"
-];
-var PrismaAlreadyInitializedError = class extends Error {
-	existingFiles;
-	constructor(existingFiles) {
-		super(`This project already appears to be Prisma-initialized: ${existingFiles.join(", ")}`);
-		this.name = "PrismaAlreadyInitializedError";
-		this.existingFiles = existingFiles;
-	}
-};
-function findExistingPrismaFiles(projectDir = process.cwd()) {
-	return prismaManagedFiles.map((relativePath) => path.join(projectDir, relativePath)).filter((absolutePath) => fs.existsSync(absolutePath));
-}
-function canReusePrismaFiles(projectDir = process.cwd()) {
-	return prismaTemplateFiles.every((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
-}
-function getDefaultDatabaseUrl(provider) {
-	switch (provider) {
-		case "postgresql": return "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public";
-		case "cockroachdb": return "postgresql://johndoe:randompassword@localhost:26257/mydb?schema=public";
-		case "mysql": return "mysql://johndoe:randompassword@localhost:3306/mydb";
-		case "sqlite": return "file:./dev.db";
-		case "sqlserver": return "sqlserver://localhost:1433;database=mydb;user=SA;password=randompassword;";
-		default: {
-			const exhaustiveCheck = provider;
-			throw new Error(`Unsupported provider: ${String(exhaustiveCheck)}`);
-		}
-	}
-}
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function hasEnvVar(content, envVarName) {
-	const escapedName = escapeRegExp(envVarName);
-	return new RegExp(`(^|\\n)\\s*${escapedName}\\s*=`).test(content);
-}
-function hasEnvComment(content, comment) {
-	const escapedComment = escapeRegExp(comment);
-	return new RegExp(`(^|\\n)\\s*#\\s*${escapedComment}\\s*(?=\\n|$)`).test(content);
-}
-async function ensureEnvVarInEnv(projectDir, envVarName, envVarValue, opts) {
-	const envPath = path.join(projectDir, ".env");
-	const envLine = `${envVarName}="${envVarValue}"`;
-	if (!await fs.pathExists(envPath)) {
-		await fs.writeFile(envPath, `${envLine}\n`, "utf8");
-		return {
-			envPath,
-			status: "created"
-		};
-	}
-	const existingContent = await fs.readFile(envPath, "utf8");
-	if (hasEnvVar(existingContent, envVarName)) {
-		if (opts.mode === "keep-existing") return {
-			envPath,
-			status: "existing"
-		};
-		const escapedName = escapeRegExp(envVarName);
-		const lineRegex = new RegExp(`(^|\\n)\\s*${escapedName}\\s*=.*(?=\\n|$)`, "m");
-		const updatedContent = existingContent.replace(lineRegex, `$1${envLine}`);
-		if (updatedContent === existingContent) return {
-			envPath,
-			status: "existing"
-		};
-		await fs.writeFile(envPath, updatedContent, "utf8");
-		return {
-			envPath,
-			status: "updated"
-		};
-	}
-	const insertion = `${existingContent.endsWith("\n") ? "" : "\n"}${opts.comment ? `\n# ${opts.comment}\n` : "\n"}${envLine}\n`;
-	await fs.appendFile(envPath, insertion, "utf8");
-	return {
-		envPath,
-		status: "appended"
-	};
-}
-async function ensureEnvComment(projectDir, comment) {
-	const envPath = path.join(projectDir, ".env");
-	const commentLine = `# ${comment}`;
-	if (!await fs.pathExists(envPath)) {
-		await fs.writeFile(envPath, `${commentLine}\n`, "utf8");
-		return;
-	}
-	const existingContent = await fs.readFile(envPath, "utf8");
-	if (hasEnvComment(existingContent, comment)) return;
-	const separator = existingContent.endsWith("\n") ? "" : "\n";
-	await fs.appendFile(envPath, `${separator}${commentLine}\n`, "utf8");
-}
-function hasGitignoreEntry(content, entry) {
-	const escapedEntry = escapeRegExp(entry);
-	const escapedWithLeadingSlash = escapeRegExp(`/${entry}`);
-	return new RegExp(`(^|\\n)\\s*(?:${escapedEntry}|${escapedWithLeadingSlash})\\s*(?=\\n|$)`).test(content);
-}
-async function ensureGitignoreEntry(projectDir, entry) {
-	const gitignorePath = path.join(projectDir, ".gitignore");
-	if (!await fs.pathExists(gitignorePath)) {
-		await fs.writeFile(gitignorePath, `${entry}\n`, "utf8");
-		return {
-			gitignorePath,
-			status: "created"
-		};
-	}
-	const existingContent = await fs.readFile(gitignorePath, "utf8");
-	if (hasGitignoreEntry(existingContent, entry)) return {
-		gitignorePath,
-		status: "existing"
-	};
-	const separator = existingContent.endsWith("\n") ? "" : "\n";
-	await fs.appendFile(gitignorePath, `${separator}${entry}\n`, "utf8");
-	return {
-		gitignorePath,
-		status: "appended"
-	};
-}
-async function initializePrismaFiles(options) {
-	const projectDir = options.projectDir ?? process.cwd();
-	const prismaFilesMode = options.prismaFilesMode ?? "create";
-	const existingPrismaFiles = findExistingPrismaFiles(projectDir);
-	if (prismaFilesMode === "create" && existingPrismaFiles.length > 0) throw new PrismaAlreadyInitializedError(existingPrismaFiles);
-	if (prismaFilesMode === "reuse" && existingPrismaFiles.length === 0) throw new Error("Cannot reuse Prisma files because no existing Prisma files were found.");
-	if (prismaFilesMode === "reuse" && !canReusePrismaFiles(projectDir)) throw new Error("Cannot reuse Prisma files because required files are missing.");
-	const schemaPath = path.join(projectDir, "prisma/schema.prisma");
-	const configPath = path.join(projectDir, "prisma.config.ts");
-	const singletonPath = path.join(projectDir, "prisma/index.ts");
-	if (prismaFilesMode !== "reuse") await scaffoldInitTemplates(projectDir, options.provider, "DATABASE_URL", options.schemaPreset ?? "empty");
-	const envResult = await ensureEnvVarInEnv(projectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider), {
-		mode: options.databaseUrl ? "upsert" : "keep-existing",
-		comment: "Added by create-prisma init"
-	});
-	let claimEnvStatus;
-	if (options.claimUrl) {
-		claimEnvStatus = (await ensureEnvVarInEnv(projectDir, "CLAIM_URL", options.claimUrl, {
-			mode: "upsert",
-			comment: PRISMA_POSTGRES_TEMPORARY_NOTICE
-		})).status;
-		await ensureEnvComment(projectDir, PRISMA_POSTGRES_TEMPORARY_NOTICE);
-	}
-	const gitignoreResult = await ensureGitignoreEntry(projectDir, "prisma/generated");
-	return {
-		schemaPath,
-		configPath,
-		singletonPath,
-		prismaFilesMode,
-		envPath: envResult.envPath,
-		envStatus: envResult.status,
-		gitignorePath: gitignoreResult.gitignorePath,
-		gitignoreStatus: gitignoreResult.status,
-		claimEnvStatus
-	};
-}
-
-//#endregion
-//#region src/constants/dependencies.ts
-const dependencyVersionMap = {
-	"@prisma/client": "^7.4.0",
-	"@prisma/adapter-pg": "^7.4.0",
-	"@prisma/adapter-mariadb": "^7.4.0",
-	"@prisma/adapter-better-sqlite3": "^7.4.0",
-	"@prisma/adapter-mssql": "^7.4.0",
-	dotenv: "^17.2.3",
-	prisma: "^7.4.0"
-};
-
 //#endregion
 //#region src/constants/db-packages.ts
 function getDbPackages(provider) {
@@ -509,11 +362,23 @@ function getDbPackages(provider) {
 
 //#endregion
 //#region src/tasks/install.ts
-const prismaScriptMap = {
-	"db:generate": "prisma generate",
-	"db:push": "prisma db push",
-	"db:migrate": "prisma migrate dev"
-};
+function getPrismaScriptMap(packageManager) {
+	if (packageManager === "deno") {
+		const prismaSpecifier = getDenoPrismaSpecifier();
+		return {
+			"db:generate": `deno run -A ${prismaSpecifier} generate`,
+			"db:push": `deno run -A ${prismaSpecifier} db push`,
+			"db:migrate": `deno run -A ${prismaSpecifier} migrate dev`,
+			"db:seed": `deno run -A ${prismaSpecifier} db seed`
+		};
+	}
+	return {
+		"db:generate": "prisma generate",
+		"db:push": "prisma db push",
+		"db:migrate": "prisma migrate dev",
+		"db:seed": "prisma db seed"
+	};
+}
 function getVersion(packageName) {
 	return dependencyVersionMap[packageName];
 }
@@ -565,11 +430,13 @@ async function addPackageDependency(opts) {
 		existingScripts
 	};
 }
-async function writePrismaDependencies(provider, projectDir = process.cwd()) {
+async function writePrismaDependencies(provider, packageManager, projectDir = process.cwd()) {
 	const dependencies = ["@prisma/client", "dotenv"];
 	const devDependencies = ["prisma"];
 	const { adapterPackage } = getDbPackages(provider);
 	dependencies.push(adapterPackage);
+	if (provider === "sqlite" && packageManager === "deno") devDependencies.push("node-gyp");
+	const prismaScriptMap = getPrismaScriptMap(packageManager);
 	const scriptWriteResult = await addPackageDependency({
 		dependencies,
 		devDependencies,
@@ -595,19 +462,83 @@ async function installProjectDependencies(packageManager, projectDir = process.c
 }
 
 //#endregion
-//#region src/ui/branding.ts
-const prismaTitle = `${styleText(["bold", "cyan"], "Create")} ${styleText(["bold", "magenta"], "Prisma")}`;
-function getCreatePrismaIntro() {
-	return prismaTitle;
+//#region src/tasks/prisma-postgres.ts
+const PRISMA_POSTGRES_TEMPORARY_NOTICE = "Prisma Postgres is temporary for 24 hours. Claim this database before it expires using CLAIM_URL.";
+const CREATE_DB_COMMAND_ARGS = ["create-db@latest", "--json"];
+function parseCreateDbJson(rawOutput) {
+	const trimmed = rawOutput.trim();
+	if (!trimmed) throw new Error("create-db returned empty output.");
+	const jsonCandidates = [trimmed];
+	const firstBrace = trimmed.indexOf("{");
+	const lastBrace = trimmed.lastIndexOf("}");
+	if (firstBrace !== -1 && lastBrace > firstBrace) jsonCandidates.push(trimmed.slice(firstBrace, lastBrace + 1));
+	for (const candidate of jsonCandidates) try {
+		return JSON.parse(candidate);
+	} catch {}
+	throw new Error(`Unable to parse create-db JSON output: ${trimmed}`);
+}
+function pickConnectionString(payload) {
+	if (typeof payload.connectionString === "string" && payload.connectionString.length > 0) return payload.connectionString;
+	if (typeof payload.databaseUrl === "string" && payload.databaseUrl.length > 0) return payload.databaseUrl;
+}
+function extractErrorMessage(payload, fallback) {
+	if (typeof payload.message === "string" && payload.message.length > 0) return payload.message;
+	if (typeof payload.error === "string" && payload.error.length > 0) return payload.error;
+	return fallback;
+}
+async function provisionPrismaPostgres(packageManager, projectDir = process.cwd()) {
+	const command = getPackageExecutionArgs(packageManager, [...CREATE_DB_COMMAND_ARGS]);
+	const commandString = getCreateDbCommand(packageManager);
+	let stdout;
+	try {
+		stdout = (await execa(command.command, command.args, {
+			cwd: projectDir,
+			stdio: "pipe"
+		})).stdout;
+	} catch (error) {
+		if (error instanceof Error && "stderr" in error) {
+			const stderr = String(error.stderr ?? "").trim();
+			const message = stderr.length > 0 ? stderr : error.message;
+			throw new Error(`Failed to run ${commandString}: ${message}`);
+		}
+		throw error;
+	}
+	const payload = parseCreateDbJson(stdout);
+	if (payload.success === false) throw new Error(extractErrorMessage(payload, "create-db reported failure."));
+	const databaseUrl = pickConnectionString(payload);
+	if (!databaseUrl) throw new Error("create-db did not return a connection string.");
+	return {
+		databaseUrl,
+		claimUrl: typeof payload.claimUrl === "string" && payload.claimUrl.length > 0 ? payload.claimUrl : typeof payload.claimURL === "string" && payload.claimURL.length > 0 ? payload.claimURL : void 0
+	};
+}
+function getCreateDbCommand(packageManager) {
+	return getPackageExecutionCommand(packageManager, [...CREATE_DB_COMMAND_ARGS]);
 }
 
 //#endregion
-//#region src/commands/init.ts
+//#region src/tasks/setup-prisma.ts
 const DEFAULT_DATABASE_PROVIDER = "postgresql";
 const DEFAULT_SCHEMA_PRESET$1 = "empty";
 const DEFAULT_PRISMA_POSTGRES = true;
 const DEFAULT_INSTALL = true;
 const DEFAULT_GENERATE = true;
+const requiredPrismaFileGroups = [
+	["prisma/schema.prisma", "packages/db/prisma/schema.prisma"],
+	["prisma/seed.ts", "packages/db/prisma/seed.ts"],
+	["prisma.config.ts", "packages/db/prisma.config.ts"],
+	[
+		"src/lib/prisma.ts",
+		"src/lib/server/prisma.ts",
+		"server/utils/prisma.ts",
+		"packages/db/src/client.ts"
+	]
+];
+async function resolvePrismaProjectDir(projectDir) {
+	const monorepoDbDir = path.join(projectDir, "packages/db");
+	if (await fs.pathExists(path.join(monorepoDbDir, "prisma/schema.prisma"))) return monorepoDbDir;
+	return projectDir;
+}
 async function promptForDatabaseProvider() {
 	const databaseProvider = await select({
 		message: "Select your database",
@@ -645,6 +576,7 @@ async function promptForDatabaseProvider() {
 function getPackageManagerHint(option, detected) {
 	if (option === detected) return "Detected";
 	if (option === "bun") return "Fast runtime + package manager";
+	if (option === "deno") return "Runtime + package manager";
 }
 async function promptForPackageManager(detectedPackageManager) {
 	const packageManager = await select({
@@ -661,10 +593,20 @@ async function promptForPackageManager(detectedPackageManager) {
 				label: "pnpm",
 				hint: getPackageManagerHint("pnpm", detectedPackageManager)
 			},
+			{
+				value: "yarn",
+				label: "yarn",
+				hint: getPackageManagerHint("yarn", detectedPackageManager)
+			},
 			{
 				value: "bun",
 				label: "bun",
 				hint: getPackageManagerHint("bun", detectedPackageManager)
+			},
+			{
+				value: "deno",
+				label: "deno",
+				hint: getPackageManagerHint("deno", detectedPackageManager)
 			}
 		]
 	});
@@ -696,50 +638,6 @@ async function promptForPrismaPostgres() {
 	}
 	return Boolean(shouldUsePrismaPostgres);
 }
-async function promptForPrismaFilesMode(existingFiles, canReuseExistingPrismaFiles, baseDir) {
-	const mode = await select({
-		message: `Prisma already exists (${existingFiles.map((filePath) => formatCreatedPath(filePath, baseDir)).join(", ")}). How should we continue?`,
-		initialValue: canReuseExistingPrismaFiles ? "reuse" : "overwrite",
-		options: canReuseExistingPrismaFiles ? [
-			{
-				value: "reuse",
-				label: "Keep existing Prisma files",
-				hint: "Recommended"
-			},
-			{
-				value: "overwrite",
-				label: "Overwrite Prisma files"
-			},
-			{
-				value: "cancel",
-				label: "Cancel"
-			}
-		] : [{
-			value: "overwrite",
-			label: "Repair and overwrite Prisma files",
-			hint: "Recommended"
-		}, {
-			value: "cancel",
-			label: "Cancel"
-		}]
-	});
-	if (isCancel(mode)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	if (mode === "cancel") {
-		cancel("Operation cancelled.");
-		return;
-	}
-	if (mode !== "reuse" && mode !== "overwrite") {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return mode;
-}
-function formatCreatedPath(filePath, baseDir) {
-	return path.relative(baseDir, filePath);
-}
 function getCommandErrorMessage(error) {
 	if (error instanceof Error && "stderr" in error) {
 		const stderr = String(error.stderr ?? "").trim();
@@ -747,25 +645,14 @@ function getCommandErrorMessage(error) {
 	}
 	return error instanceof Error ? error.message : String(error);
 }
-async function collectInitContext(rawInput = {}, options = {}) {
+async function collectPrismaSetupContext(input, options = {}) {
 	const projectDir = path.resolve(options.projectDir ?? process.cwd());
-	const input = InitCommandInputSchema.parse(rawInput);
 	const useDefaults = input.yes === true;
 	const verbose = input.verbose === true;
 	const shouldGenerate = input.generate ?? DEFAULT_GENERATE;
-	if (!options.skipIntro) intro(getCreatePrismaIntro());
-	let prismaFilesMode = "create";
-	const existingPrismaFiles = findExistingPrismaFiles(projectDir);
-	const canReuseExistingPrismaFiles = canReusePrismaFiles(projectDir);
-	if (existingPrismaFiles.length > 0) if (useDefaults) prismaFilesMode = canReuseExistingPrismaFiles ? "reuse" : "overwrite";
-	else {
-		const selectedMode = await promptForPrismaFilesMode(existingPrismaFiles, canReuseExistingPrismaFiles, projectDir);
-		if (!selectedMode) return;
-		prismaFilesMode = selectedMode;
-	}
 	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
 	if (!databaseProvider) return;
-	const schemaPreset = input.schemaPreset ?? DEFAULT_SCHEMA_PRESET$1;
+	const schemaPreset = input.schemaPreset ?? options.defaultSchemaPreset ?? DEFAULT_SCHEMA_PRESET$1;
 	const databaseUrl = input.databaseUrl;
 	let shouldUsePrismaPostgres = false;
 	if (databaseProvider === "postgresql" && !databaseUrl) {
@@ -782,7 +669,6 @@ async function collectInitContext(rawInput = {}, options = {}) {
 		projectDir,
 		verbose,
 		shouldGenerate,
-		prismaFilesMode,
 		databaseProvider,
 		schemaPreset,
 		databaseUrl,
@@ -791,6 +677,158 @@ async function collectInitContext(rawInput = {}, options = {}) {
 		shouldInstall
 	};
 }
+function getDefaultDatabaseUrl(provider) {
+	switch (provider) {
+		case "postgresql": return "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public";
+		case "cockroachdb": return "postgresql://johndoe:randompassword@localhost:26257/mydb?schema=public";
+		case "mysql": return "mysql://johndoe:randompassword@localhost:3306/mydb";
+		case "sqlite": return "file:./dev.db";
+		case "sqlserver": return "sqlserver://localhost:1433;database=mydb;user=SA;password=randompassword;";
+		default: {
+			const exhaustiveCheck = provider;
+			throw new Error(`Unsupported provider: ${String(exhaustiveCheck)}`);
+		}
+	}
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeEnvValue(value) {
+	if (/[\r\n]/.test(value)) throw new Error("Environment variable values must be single-line.");
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function hasEnvVar(content, envVarName) {
+	const escapedName = escapeRegExp(envVarName);
+	return new RegExp(`(^|\\n)\\s*${escapedName}\\s*=`).test(content);
+}
+function hasEnvComment(content, comment) {
+	const escapedComment = escapeRegExp(comment);
+	return new RegExp(`(^|\\n)\\s*#\\s*${escapedComment}\\s*(?=\\n|$)`).test(content);
+}
+async function ensureEnvVarInEnv(projectDir, envVarName, envVarValue, opts) {
+	const envPath = path.join(projectDir, ".env");
+	const envLine = `${envVarName}="${escapeEnvValue(envVarValue)}"`;
+	if (!await fs.pathExists(envPath)) {
+		const content = opts.comment ? `# ${opts.comment}\n${envLine}\n` : `${envLine}\n`;
+		await fs.writeFile(envPath, content, "utf8");
+		return {
+			envPath,
+			status: "created"
+		};
+	}
+	const existingContent = await fs.readFile(envPath, "utf8");
+	if (hasEnvVar(existingContent, envVarName)) {
+		if (opts.mode === "keep-existing") return {
+			envPath,
+			status: "existing"
+		};
+		const escapedName = escapeRegExp(envVarName);
+		const lineRegex = new RegExp(`(^|\\n)\\s*${escapedName}\\s*=.*(?=\\n|$)`, "gm");
+		const updatedContent = existingContent.replace(lineRegex, `$1${envLine}`);
+		if (updatedContent === existingContent) return {
+			envPath,
+			status: "existing"
+		};
+		await fs.writeFile(envPath, updatedContent, "utf8");
+		return {
+			envPath,
+			status: "updated"
+		};
+	}
+	const insertion = `${existingContent.endsWith("\n") ? "" : "\n"}${opts.comment ? `\n# ${opts.comment}\n` : "\n"}${envLine}\n`;
+	await fs.appendFile(envPath, insertion, "utf8");
+	return {
+		envPath,
+		status: "appended"
+	};
+}
+async function ensureEnvComment(projectDir, comment) {
+	const envPath = path.join(projectDir, ".env");
+	const commentLine = `# ${comment}`;
+	if (!await fs.pathExists(envPath)) {
+		await fs.writeFile(envPath, `${commentLine}\n`, "utf8");
+		return;
+	}
+	const existingContent = await fs.readFile(envPath, "utf8");
+	if (hasEnvComment(existingContent, comment)) return;
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fs.appendFile(envPath, `${separator}${commentLine}\n`, "utf8");
+}
+function hasGitignoreEntry(content, entry) {
+	const escapedEntry = escapeRegExp(entry);
+	const escapedWithLeadingSlash = escapeRegExp(`/${entry}`);
+	const escapedWithTrailingSlash = escapeRegExp(`${entry}/`);
+	const escapedWithLeadingAndTrailingSlash = escapeRegExp(`/${entry}/`);
+	return new RegExp(`(^|\\n)\\s*(?:${escapedEntry}|${escapedWithLeadingSlash}|${escapedWithTrailingSlash}|${escapedWithLeadingAndTrailingSlash})\\s*(?=\\n|$)`).test(content);
+}
+async function ensureGitignoreEntry(projectDir, entry) {
+	const gitignorePath = path.join(projectDir, ".gitignore");
+	if (!await fs.pathExists(gitignorePath)) {
+		await fs.writeFile(gitignorePath, `${entry}\n`, "utf8");
+		return {
+			gitignorePath,
+			status: "created"
+		};
+	}
+	const existingContent = await fs.readFile(gitignorePath, "utf8");
+	if (hasGitignoreEntry(existingContent, entry)) return {
+		gitignorePath,
+		status: "existing"
+	};
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fs.appendFile(gitignorePath, `${separator}${entry}\n`, "utf8");
+	return {
+		gitignorePath,
+		status: "appended"
+	};
+}
+async function ensureRequiredPrismaFiles(projectDir) {
+	const missingFiles = [];
+	for (const candidates of requiredPrismaFileGroups) {
+		let foundCandidate = false;
+		for (const relativePath of candidates) {
+			const absolutePath = path.join(projectDir, relativePath);
+			if (await fs.pathExists(absolutePath)) {
+				foundCandidate = true;
+				break;
+			}
+		}
+		if (!foundCandidate) missingFiles.push(candidates.join(" or "));
+	}
+	if (missingFiles.length > 0) throw new Error(`Template is missing required Prisma files: ${missingFiles.join(", ")}`);
+}
+async function finalizePrismaFiles(options) {
+	const projectDir = options.projectDir ?? process.cwd();
+	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
+	const schemaPath = path.join(prismaProjectDir, "prisma/schema.prisma");
+	const configPath = path.join(prismaProjectDir, "prisma.config.ts");
+	await ensureRequiredPrismaFiles(projectDir);
+	const singletonPath = await fs.pathExists(path.join(prismaProjectDir, "src/lib/prisma.ts")) ? path.join(prismaProjectDir, "src/lib/prisma.ts") : await fs.pathExists(path.join(prismaProjectDir, "src/lib/server/prisma.ts")) ? path.join(prismaProjectDir, "src/lib/server/prisma.ts") : await fs.pathExists(path.join(prismaProjectDir, "server/utils/prisma.ts")) ? path.join(prismaProjectDir, "server/utils/prisma.ts") : path.join(prismaProjectDir, "src/client.ts");
+	const generatedDir = await fs.pathExists(path.join(prismaProjectDir, "server/utils/prisma.ts")) ? "server/generated" : "src/generated";
+	const envResult = await ensureEnvVarInEnv(prismaProjectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider), {
+		mode: options.databaseUrl ? "upsert" : "keep-existing",
+		comment: "Added by create-prisma"
+	});
+	let claimEnvStatus;
+	if (options.claimUrl) {
+		claimEnvStatus = (await ensureEnvVarInEnv(prismaProjectDir, "CLAIM_URL", options.claimUrl, {
+			mode: "upsert",
+			comment: PRISMA_POSTGRES_TEMPORARY_NOTICE
+		})).status;
+		await ensureEnvComment(prismaProjectDir, PRISMA_POSTGRES_TEMPORARY_NOTICE);
+	}
+	const gitignoreResult = await ensureGitignoreEntry(prismaProjectDir, generatedDir);
+	return {
+		schemaPath,
+		configPath,
+		singletonPath,
+		envPath: envResult.envPath,
+		envStatus: envResult.status,
+		gitignorePath: gitignoreResult.gitignorePath,
+		gitignoreStatus: gitignoreResult.status,
+		claimEnvStatus
+	};
+}
 async function provisionPrismaPostgresIfNeeded(context, projectDir) {
 	if (!context.shouldUsePrismaPostgres) return { databaseUrl: context.databaseUrl };
 	const createDbCommand = getCreateDbCommand(context.packageManager);
@@ -813,8 +851,9 @@ async function provisionPrismaPostgresIfNeeded(context, projectDir) {
 	}
 }
 async function writeDependenciesForContext(context, projectDir) {
+	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
 	try {
-		return await writePrismaDependencies(context.databaseProvider, projectDir);
+		return await writePrismaDependencies(context.databaseProvider, context.packageManager, prismaProjectDir);
 	} catch (error) {
 		cancel(getCommandErrorMessage(error));
 		return;
@@ -846,22 +885,18 @@ async function installDependenciesForContext(context, projectDir) {
 		return false;
 	}
 }
-async function initializePrismaFilesForContext(context, projectDir, provisionResult) {
+async function finalizePrismaFilesForContext(context, projectDir, provisionResult) {
 	const initSpinner = spinner();
 	initSpinner.start("Preparing Prisma files...");
 	try {
-		const initResult = await initializePrismaFiles({
+		const finalizeResult = await finalizePrismaFiles({
 			provider: context.databaseProvider,
 			databaseUrl: provisionResult.databaseUrl,
 			claimUrl: provisionResult.claimUrl,
-			schemaPreset: context.schemaPreset,
-			prismaFilesMode: context.prismaFilesMode,
 			projectDir
 		});
-		if (initResult.prismaFilesMode === "overwrite") initSpinner.stop("Prisma files updated.");
-		else if (initResult.prismaFilesMode === "reuse") initSpinner.stop("Using existing Prisma files.");
-		else initSpinner.stop("Prisma files ready.");
-		return initResult;
+		initSpinner.stop("Prisma files ready.");
+		return finalizeResult;
 	} catch (error) {
 		initSpinner.stop("Could not prepare Prisma files.");
 		cancel(getCommandErrorMessage(error));
@@ -869,6 +904,7 @@ async function initializePrismaFilesForContext(context, projectDir, provisionRes
 	}
 }
 async function generatePrismaClientForContext(context, projectDir) {
+	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
 	if (!context.shouldGenerate) return { didGenerateClient: false };
 	const generateCommand = getPrismaCliCommand(context.packageManager, ["generate"]);
 	if (context.verbose) log.step(`Running ${generateCommand}`);
@@ -877,7 +913,7 @@ async function generatePrismaClientForContext(context, projectDir) {
 	try {
 		const generateArgs = getPrismaCliArgs(context.packageManager, ["generate"]);
 		await execa(generateArgs.command, generateArgs.args, {
-			cwd: projectDir,
+			cwd: prismaProjectDir,
 			stdio: context.verbose ? "inherit" : "pipe"
 		});
 		if (context.verbose) log.success("Prisma Client generated.");
@@ -904,16 +940,17 @@ function buildNextStepsForContext(opts) {
 	if (!context.shouldInstall) nextSteps.push(`- ${getInstallCommand(context.packageManager)}`);
 	if (!didGenerateClient || !context.shouldGenerate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:generate")}`);
 	nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:migrate")}`);
+	nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:seed")}`);
 	if (options.includeDevNextStep) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "dev")}`);
 	return nextSteps;
 }
-async function executeInitContext(context, options = {}) {
+async function executePrismaSetupContext(context, options = {}) {
 	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
 	const provisionResult = await provisionPrismaPostgresIfNeeded(context, projectDir);
 	if (!provisionResult) return;
 	if (!await writeDependenciesForContext(context, projectDir)) return;
 	if (!await installDependenciesForContext(context, projectDir)) return;
-	if (!await initializePrismaFilesForContext(context, projectDir, provisionResult)) return;
+	if (!await finalizePrismaFilesForContext(context, projectDir, provisionResult)) return;
 	const generateResult = await generatePrismaClientForContext(context, projectDir);
 	const warningLines = buildWarningLines(provisionResult.warning, generateResult.warning);
 	const nextSteps = buildNextStepsForContext({
@@ -927,15 +964,540 @@ Next steps:
 ${nextSteps.join("\n")}`);
 	return { packageManager: context.packageManager };
 }
-async function runInitCommand(rawInput = {}, options = {}) {
+
+//#endregion
+//#region src/tasks/setup-addons.ts
+const DEFAULT_ADDON_SCOPE = "project";
+const DEFAULT_SKILLS_AGENTS = [
+	"claude-code",
+	"codex",
+	"cursor"
+];
+const DEFAULT_MCP_AGENTS = [
+	"claude-code",
+	"codex",
+	"cursor"
+];
+const DEFAULT_EXTENSION_TARGETS = ["vscode", "cursor"];
+const PRISMA_MCP_SERVER = "https://mcp.prisma.io/mcp";
+const ADDON_OPTIONS = [
+	{
+		value: "skills",
+		label: "Skills",
+		hint: "Install curated Prisma skills to your selected coding agents"
+	},
+	{
+		value: "mcp",
+		label: "MCP",
+		hint: "Configure Prisma MCP server in agent MCP config files"
+	},
+	{
+		value: "extension",
+		label: "IDE Extension",
+		hint: "Install Prisma extension in selected IDEs (VS Code, Cursor, Windsurf)"
+	}
+];
+const SKILLS_AGENT_OPTIONS = [
+	{
+		value: "cursor",
+		label: "Cursor"
+	},
+	{
+		value: "claude-code",
+		label: "Claude Code"
+	},
+	{
+		value: "cline",
+		label: "Cline"
+	},
+	{
+		value: "github-copilot",
+		label: "GitHub Copilot"
+	},
+	{
+		value: "codex",
+		label: "Codex"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf"
+	},
+	{
+		value: "goose",
+		label: "Goose"
+	},
+	{
+		value: "roo",
+		label: "Roo Code"
+	},
+	{
+		value: "kilo",
+		label: "Kilo Code"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI"
+	},
+	{
+		value: "antigravity",
+		label: "Antigravity"
+	},
+	{
+		value: "openhands",
+		label: "OpenHands"
+	},
+	{
+		value: "trae",
+		label: "Trae"
+	},
+	{
+		value: "amp",
+		label: "Amp"
+	},
+	{
+		value: "pi",
+		label: "Pi"
+	},
+	{
+		value: "qoder",
+		label: "Qoder"
+	},
+	{
+		value: "qwen-code",
+		label: "Qwen Code"
+	},
+	{
+		value: "kiro-cli",
+		label: "Kiro CLI"
+	},
+	{
+		value: "droid",
+		label: "Droid"
+	},
+	{
+		value: "command-code",
+		label: "Command Code"
+	},
+	{
+		value: "clawdbot",
+		label: "Clawdbot"
+	},
+	{
+		value: "zencoder",
+		label: "Zencoder"
+	},
+	{
+		value: "neovate",
+		label: "Neovate"
+	},
+	{
+		value: "mcpjam",
+		label: "MCPJam"
+	}
+];
+const MCP_AGENT_OPTIONS = [
+	{
+		value: "claude-code",
+		label: "Claude Code"
+	},
+	{
+		value: "codex",
+		label: "Codex"
+	},
+	{
+		value: "cursor",
+		label: "Cursor"
+	},
+	{
+		value: "vscode",
+		label: "VS Code"
+	},
+	{
+		value: "github-copilot-cli",
+		label: "GitHub Copilot CLI"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI"
+	},
+	{
+		value: "goose",
+		label: "Goose"
+	},
+	{
+		value: "zed",
+		label: "Zed"
+	},
+	{
+		value: "antigravity",
+		label: "Antigravity"
+	},
+	{
+		value: "cline",
+		label: "Cline VS Code Extension"
+	},
+	{
+		value: "cline-cli",
+		label: "Cline CLI"
+	},
+	{
+		value: "claude-desktop",
+		label: "Claude Desktop"
+	},
+	{
+		value: "mcporter",
+		label: "MCPorter"
+	}
+];
+const SHARED_PRISMA_SKILLS = [
+	"prisma-cli",
+	"prisma-client-api",
+	"prisma-database-setup",
+	"prisma-upgrade-v7"
+];
+function getAvailablePrismaSkills(provider) {
+	if (provider === "postgresql") return [...SHARED_PRISMA_SKILLS, "prisma-postgres"];
+	return [...SHARED_PRISMA_SKILLS];
+}
+function getSkillOptions(provider) {
+	const available = getAvailablePrismaSkills(provider);
+	const options = {
+		"prisma-cli": {
+			value: "prisma-cli",
+			label: "prisma-cli",
+			hint: "Prisma CLI reference"
+		},
+		"prisma-client-api": {
+			value: "prisma-client-api",
+			label: "prisma-client-api",
+			hint: "Prisma Client query patterns"
+		},
+		"prisma-database-setup": {
+			value: "prisma-database-setup",
+			label: "prisma-database-setup",
+			hint: "Database provider setup guides"
+		},
+		"prisma-upgrade-v7": {
+			value: "prisma-upgrade-v7",
+			label: "prisma-upgrade-v7",
+			hint: "v6 to v7 migration guide"
+		},
+		"prisma-postgres": {
+			value: "prisma-postgres",
+			label: "prisma-postgres",
+			hint: "Prisma Postgres workflows"
+		}
+	};
+	return available.map((skill) => options[skill]);
+}
+function collectAddonsFromInput(input) {
+	const addons = [];
+	if (input.skills === true) addons.push("skills");
+	if (input.mcp === true) addons.push("mcp");
+	if (input.extension === true) addons.push("extension");
+	return uniqueValues(addons);
+}
+const EXTENSION_TARGET_OPTIONS = [
+	{
+		value: "vscode",
+		label: "VS Code",
+		hint: "Uses the `code` CLI"
+	},
+	{
+		value: "cursor",
+		label: "Cursor",
+		hint: "Uses the `cursor` CLI"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf",
+		hint: "Uses the `windsurf` CLI"
+	}
+];
+function uniqueValues(values) {
+	return Array.from(new Set(values));
+}
+function getRecommendedPrismaSkills(provider, shouldUsePrismaPostgres) {
+	const skills = [...getAvailablePrismaSkills(provider)];
+	if (!shouldUsePrismaPostgres) return skills.filter((skill) => skill !== "prisma-postgres");
+	return uniqueValues(skills);
+}
+async function promptForAddons() {
+	const selectedAddons = await multiselect({
+		message: "Select add-ons (optional)",
+		options: ADDON_OPTIONS,
+		required: false
+	});
+	if (isCancel(selectedAddons)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedAddons);
+}
+async function promptForAddonScope() {
+	const selectedScope = await select({
+		message: "Where should add-ons write config?",
+		initialValue: DEFAULT_ADDON_SCOPE,
+		options: [{
+			value: "project",
+			label: "Project",
+			hint: "Recommended for teams (checked into the project when applicable)"
+		}, {
+			value: "global",
+			label: "Global",
+			hint: "Personal machine-level setup"
+		}]
+	});
+	if (isCancel(selectedScope)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return selectedScope;
+}
+async function promptForPrismaSkills(provider, recommendedSkills) {
+	const options = getSkillOptions(provider);
+	const optionValues = new Set(options.map((option) => option.value));
+	const selectedSkills = await multiselect({
+		message: "Select Prisma skills",
+		options,
+		required: false,
+		initialValues: recommendedSkills.filter((skill) => optionValues.has(skill))
+	});
+	if (isCancel(selectedSkills)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedSkills);
+}
+async function promptForSkillsAgents() {
+	const selectedAgents = await multiselect({
+		message: "Select agents for skills",
+		options: SKILLS_AGENT_OPTIONS,
+		required: false,
+		initialValues: [...DEFAULT_SKILLS_AGENTS]
+	});
+	if (isCancel(selectedAgents)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedAgents);
+}
+async function promptForMcpAgents() {
+	const selectedAgents = await multiselect({
+		message: "Select agents for MCP",
+		options: MCP_AGENT_OPTIONS,
+		required: false,
+		initialValues: [...DEFAULT_MCP_AGENTS]
+	});
+	if (isCancel(selectedAgents)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedAgents);
+}
+async function promptForExtensionTargets() {
+	const selectedTargets = await multiselect({
+		message: "Select IDEs for extension install",
+		options: EXTENSION_TARGET_OPTIONS,
+		required: false,
+		initialValues: DEFAULT_EXTENSION_TARGETS
+	});
+	if (isCancel(selectedTargets)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedTargets);
+}
+async function collectCreateAddonSetupContext(input, options) {
+	const hasExplicitAddonSelection = input.skills !== void 0 || input.mcp !== void 0 || input.extension !== void 0;
+	const selectedFromInput = collectAddonsFromInput(input);
+	const selectedAddons = selectedFromInput.length > 0 ? selectedFromInput : hasExplicitAddonSelection ? [] : options.useDefaults ? [] : await promptForAddons();
+	if (!selectedAddons) return;
+	const addons = uniqueValues(selectedAddons);
+	if (addons.length === 0) return null;
+	const scope = addons.includes("skills") || addons.includes("mcp") ? options.useDefaults ? DEFAULT_ADDON_SCOPE : await promptForAddonScope() : DEFAULT_ADDON_SCOPE;
+	if (!scope) return;
+	const recommendedSkills = getRecommendedPrismaSkills(options.provider, options.shouldUsePrismaPostgres);
+	const skills = !addons.includes("skills") ? [] : options.useDefaults ? recommendedSkills : await promptForPrismaSkills(options.provider, recommendedSkills);
+	if (!skills) return;
+	const skillsAgents = !addons.includes("skills") ? [] : options.useDefaults ? [...DEFAULT_SKILLS_AGENTS] : await promptForSkillsAgents();
+	if (!skillsAgents) return;
+	const mcpAgents = !addons.includes("mcp") ? [] : options.useDefaults ? [...DEFAULT_MCP_AGENTS] : await promptForMcpAgents();
+	if (!mcpAgents) return;
+	const extensionTargets = !addons.includes("extension") ? [] : options.useDefaults ? [...DEFAULT_EXTENSION_TARGETS] : await promptForExtensionTargets();
+	if (!extensionTargets) return;
+	return {
+		addons,
+		scope,
+		skills,
+		skillsAgents: uniqueValues(skillsAgents),
+		mcpAgents: uniqueValues(mcpAgents),
+		extensionTargets: uniqueValues(extensionTargets)
+	};
+}
+async function executeExternalCommand(params) {
+	await execa(params.command, params.args, {
+		cwd: params.cwd,
+		stdio: params.verbose ? "inherit" : "pipe",
+		env: {
+			...process.env,
+			CI: "true"
+		}
+	});
+}
+async function installSkillsAddon(params) {
+	if (params.agents.length === 0 || params.skills.length === 0) return "Skipped skills addon because no skills or agents were selected.";
+	const scopeArgs = params.scope === "global" ? ["-g"] : [];
+	const skillArgs = params.skills.flatMap((skill) => ["-s", skill]);
+	const agentArgs = params.agents.flatMap((agent) => ["-a", agent]);
+	const commandArgs = [
+		"skills@latest",
+		"add",
+		"prisma/skills",
+		...scopeArgs,
+		...skillArgs,
+		...agentArgs,
+		"-y"
+	];
+	const execution = getPackageExecutionArgs(params.packageManager, commandArgs);
 	try {
-		const context = await collectInitContext(rawInput, options);
-		if (!context) return;
-		return executeInitContext(context, options);
+		await executeExternalCommand({
+			command: execution.command,
+			args: execution.args,
+			cwd: params.projectDir,
+			verbose: params.verbose
+		});
+		return;
+	} catch (error) {
+		return `Skills addon failed: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+async function installMcpAddon(params) {
+	if (params.agents.length === 0) return "Skipped MCP addon because no agents were selected.";
+	const scopeArgs = params.scope === "global" ? ["-g"] : [];
+	const agentArgs = params.agents.flatMap((agent) => ["-a", agent]);
+	const commandArgs = [
+		"add-mcp@latest",
+		PRISMA_MCP_SERVER,
+		...scopeArgs,
+		...agentArgs,
+		"--name",
+		"prisma",
+		"--gitignore",
+		"-y"
+	];
+	const execution = getPackageExecutionArgs(params.packageManager, commandArgs);
+	try {
+		await executeExternalCommand({
+			command: execution.command,
+			args: execution.args,
+			cwd: params.projectDir,
+			verbose: params.verbose
+		});
+		return;
 	} catch (error) {
-		cancel(`Init command failed: ${error instanceof Error ? error.message : String(error)}`);
+		return `MCP addon failed: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+function getExtensionInstallBinary(target) {
+	switch (target) {
+		case "vscode": return "code";
+		case "cursor": return "cursor";
+		case "windsurf": return "windsurf";
+		default: {
+			const exhaustiveCheck = target;
+			throw new Error(`Unsupported extension target: ${String(exhaustiveCheck)}`);
+		}
+	}
+}
+async function installExtensionAddon(params) {
+	if (params.targets.length === 0) return ["Skipped extension addon because no IDE targets were selected."];
+	const warnings = [];
+	for (const target of params.targets) {
+		const binary = getExtensionInstallBinary(target);
+		try {
+			await executeExternalCommand({
+				command: binary,
+				args: ["--version"],
+				cwd: params.projectDir,
+				verbose: false
+			});
+		} catch {
+			warnings.push(`Skipped ${target} extension install because the \`${binary}\` CLI is not available.`);
+			continue;
+		}
+		try {
+			await executeExternalCommand({
+				command: binary,
+				args: [
+					"--install-extension",
+					"Prisma.prisma",
+					"--force"
+				],
+				cwd: params.projectDir,
+				verbose: params.verbose
+			});
+		} catch (error) {
+			warnings.push(`${target} extension install failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	return warnings;
+}
+async function executeCreateAddonSetupContext(params) {
+	const { context, packageManager, projectDir, verbose } = params;
+	const addonSpinner = spinner();
+	addonSpinner.start("Applying selected add-ons...");
+	const warnings = [];
+	if (context.addons.includes("skills")) {
+		const warning = await installSkillsAddon({
+			packageManager,
+			projectDir,
+			scope: context.scope,
+			skills: context.skills,
+			agents: context.skillsAgents,
+			verbose
+		});
+		if (warning) warnings.push(warning);
+	}
+	if (context.addons.includes("mcp")) {
+		const warning = await installMcpAddon({
+			packageManager,
+			projectDir,
+			scope: context.scope,
+			agents: context.mcpAgents,
+			verbose
+		});
+		if (warning) warnings.push(warning);
+	}
+	if (context.addons.includes("extension")) {
+		const extensionWarnings = await installExtensionAddon({
+			projectDir,
+			verbose,
+			targets: context.extensionTargets
+		});
+		warnings.push(...extensionWarnings);
+	}
+	if (warnings.length > 0) {
+		addonSpinner.stop("Add-ons applied with warnings.");
+		for (const warning of warnings) log.warn(warning);
 		return;
 	}
+	addonSpinner.stop("Add-ons applied.");
+}
+
+//#endregion
+//#region src/ui/branding.ts
+const prismaTitle = `${styleText(["bold", "cyan"], "Create")} ${styleText(["bold", "magenta"], "Prisma")}`;
+function getCreatePrismaIntro() {
+	return prismaTitle;
 }
 
 //#endregion
@@ -972,15 +1534,38 @@ async function promptForCreateTemplate() {
 	const template = await select({
 		message: "Select template",
 		initialValue: DEFAULT_TEMPLATE,
-		options: [{
-			value: "hono",
-			label: "Hono",
-			hint: "Bun + TypeScript API starter"
-		}, {
-			value: "next",
-			label: "Next.js",
-			hint: "App Router + TypeScript starter"
-		}]
+		options: [
+			{
+				value: "hono",
+				label: "Hono",
+				hint: "TypeScript API starter"
+			},
+			{
+				value: "next",
+				label: "Next.js",
+				hint: "App Router + TypeScript starter"
+			},
+			{
+				value: "svelte",
+				label: "SvelteKit",
+				hint: "Official minimal SvelteKit + TypeScript starter"
+			},
+			{
+				value: "astro",
+				label: "Astro",
+				hint: "Official minimal Astro starter with API route example"
+			},
+			{
+				value: "nuxt",
+				label: "Nuxt",
+				hint: "Official minimal Nuxt starter with Nitro API route example"
+			},
+			{
+				value: "turborepo",
+				label: "Turborepo",
+				hint: "Monorepo starter with apps + packages/db Prisma package"
+			}
+		]
 	});
 	if (isCancel(template)) {
 		cancel("Operation cancelled.");
@@ -1023,7 +1608,6 @@ async function collectCreateContext(input) {
 	if (!projectName) return;
 	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate());
 	if (!template) return;
-	const schemaPreset = input.schemaPreset ?? DEFAULT_SCHEMA_PRESET;
 	const targetDirectory = path.resolve(process.cwd(), projectName);
 	const targetPathState = await inspectTargetPath(targetDirectory);
 	if (targetPathState.exists && !targetPathState.isDirectory) {
@@ -1034,29 +1618,26 @@ async function collectCreateContext(input) {
 		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
 		return;
 	}
-	const initContext = await collectInitContext({
-		yes: input.yes,
-		verbose: input.verbose,
-		provider: input.provider,
-		packageManager: input.packageManager,
-		prismaPostgres: input.prismaPostgres,
-		databaseUrl: input.databaseUrl,
-		install: input.install,
-		generate: input.generate,
-		schemaPreset
-	}, {
-		skipIntro: true,
-		projectDir: targetDirectory
+	const prismaSetupContext = await collectPrismaSetupContext(input, {
+		projectDir: targetDirectory,
+		defaultSchemaPreset: DEFAULT_SCHEMA_PRESET
 	});
-	if (!initContext) return;
+	if (!prismaSetupContext) return;
+	const addonSetupContext = await collectCreateAddonSetupContext(input, {
+		useDefaults,
+		provider: prismaSetupContext.databaseProvider,
+		shouldUsePrismaPostgres: prismaSetupContext.shouldUsePrismaPostgres
+	});
+	if (addonSetupContext === void 0) return;
 	return {
 		targetDirectory,
 		targetPathState,
 		force,
 		template,
-		schemaPreset,
+		schemaPreset: prismaSetupContext.schemaPreset,
 		projectPackageName: toPackageName(path.basename(targetDirectory)),
-		initContext
+		prismaSetupContext,
+		addonSetupContext: addonSetupContext ?? void 0
 	};
 }
 async function executeCreateContext(context) {
@@ -1068,7 +1649,8 @@ async function executeCreateContext(context) {
 			projectName: context.projectPackageName,
 			template: context.template,
 			schemaPreset: context.schemaPreset,
-			packageManager: context.initContext.packageManager
+			provider: context.prismaSetupContext.databaseProvider,
+			packageManager: context.prismaSetupContext.packageManager
 		});
 		scaffoldSpinner.stop("Project files scaffolded.");
 	} catch (error) {
@@ -1078,8 +1660,13 @@ async function executeCreateContext(context) {
 	}
 	if (context.targetPathState.exists && !context.targetPathState.isEmptyDirectory && context.force) log.warn(`Used --force in non-empty directory ${formatPathForDisplay(context.targetDirectory)}.`);
 	const cdStep = `- cd ${formatPathForDisplay(context.targetDirectory)}`;
-	await executeInitContext(context.initContext, {
-		skipIntro: true,
+	if (context.addonSetupContext) await executeCreateAddonSetupContext({
+		context: context.addonSetupContext,
+		packageManager: context.prismaSetupContext.packageManager,
+		projectDir: context.targetDirectory,
+		verbose: context.prismaSetupContext.verbose
+	});
+	await executePrismaSetupContext(context.prismaSetupContext, {
 		prependNextSteps: [cdStep],
 		projectDir: context.targetDirectory,
 		includeDevNextStep: true
@@ -1087,4 +1674,4 @@ async function executeCreateContext(context) {
 }
 
 //#endregion
-export { DatabaseProviderSchema as a, PackageManagerSchema as c, CreateTemplateSchema as i, SchemaPresetSchema as l, runInitCommand as n, DatabaseUrlSchema as o, CreateCommandInputSchema as r, InitCommandInputSchema as s, runCreateCommand as t };
+export { DatabaseUrlSchema as a, DatabaseProviderSchema as i, CreateCommandInputSchema as n, PackageManagerSchema as o, CreateTemplateSchema as r, SchemaPresetSchema as s, runCreateCommand as t };