create-prisma 0.7.1-pr.52.181.1 → 0.7.2

package/dist/index.mjs

@@ -1,2291 +1,3 @@
 #!/usr/bin/env node
-import { os } from "@orpc/server";
-import { createCli } from "trpc-cli";
-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 { isMap, isScalar, parseDocument } from "yaml";
-import Handlebars from "handlebars";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { z } from "zod";
-import { execa } from "execa";
-import { randomUUID } from "node:crypto";
-import os$1 from "node:os";
-import { PostHog } from "posthog-node";
-import { styleText } from "node:util";
-//#region src/utils/regexp.ts
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-//#endregion
-//#region src/utils/runtime.ts
-function usesNodeStyleRuntime(packageManager) {
-	return packageManager !== void 0 && packageManager !== "bun";
-}
-function requiresDotenvConfigImport(packageManager) {
-	return usesNodeStyleRuntime(packageManager);
-}
-function requiresPrismaConfigDotenvImport(_packageManager) {
-	return true;
-}
-//#endregion
-//#region src/constants/dependencies.ts
-const dependencyVersionMap = {
-	"@elysiajs/node": "^1.4.5",
-	"@libsql/client": "^0.17.4",
-	"@prisma/client": "^7.8.0",
-	"@prisma/adapter-pg": "^7.8.0",
-	"@prisma/adapter-libsql": "^7.8.0",
-	"@prisma/adapter-mariadb": "^7.8.0",
-	"@prisma/adapter-mssql": "^7.8.0",
-	"@prisma/composer": "0.6.0",
-	"@prisma/composer-prisma-cloud": "0.6.0",
-	"@types/node": "^26.0.0",
-	arktype: "^2.2.3",
-	dotenv: "^17.4.2",
-	effect: "4.0.0-beta.93",
-	esbuild: "^0.28.2",
-	prisma: "^7.8.0",
-	tsx: "^4.22.4"
-};
-const prismaPlatformCliPackage = "@prisma/cli@next";
-function getWorkspaceDependencyVersion(packageManager) {
-	return packageManager === "npm" ? "*" : "workspace:*";
-}
-function getCreateTemplateDependencies(template, packageManager) {
-	const targets = [];
-	if (template === "hono" || template === "elysia" || template === "nest") {
-		const runtimeDevDependencies = usesNodeStyleRuntime(packageManager) ? ["tsx"] : [];
-		if (template === "elysia") targets.push({
-			packageJsonPath: "package.json",
-			dependencies: ["@elysiajs/node"],
-			devDependencies: ["@types/node", ...runtimeDevDependencies]
-		});
-		else if (runtimeDevDependencies.length > 0) targets.push({
-			packageJsonPath: "package.json",
-			dependencies: [],
-			devDependencies: runtimeDevDependencies
-		});
-	}
-	if (template === "turborepo") targets.push({
-		packageJsonPath: "apps/api/package.json",
-		dependencies: ["dotenv"],
-		devDependencies: ["tsx"],
-		customDependencies: { "@repo/db": getWorkspaceDependencyVersion(packageManager) }
-	});
-	targets.push({
-		packageJsonPath: "package.json",
-		dependencies: [
-			"@prisma/composer",
-			"@prisma/composer-prisma-cloud",
-			"arktype",
-			"effect",
-			...template === "turborepo" ? ["dotenv"] : []
-		],
-		devDependencies: template === "hono" || template === "elysia" || template === "nest" ? ["esbuild"] : []
-	});
-	if (template === "turborepo") targets.push({
-		packageJsonPath: "apps/api/package.json",
-		dependencies: [],
-		devDependencies: ["esbuild"]
-	});
-	return targets;
-}
-//#endregion
-//#region src/types.ts
-const databaseProviders = [
-	"postgresql",
-	"mysql",
-	"sqlite",
-	"sqlserver",
-	"cockroachdb"
-];
-const packageManagers = [
-	"npm",
-	"pnpm",
-	"yarn",
-	"bun"
-];
-const createTemplates = [
-	"hono",
-	"elysia",
-	"nest",
-	"next",
-	"svelte",
-	"astro",
-	"nuxt",
-	"tanstack-start",
-	"turborepo"
-];
-const createAddons = [
-	"skills",
-	"mcp",
-	"extension"
-];
-const addonInstallScopes = ["project", "global"];
-const extensionTargets = [
-	"vscode",
-	"cursor",
-	"windsurf"
-];
-const prismaSkillNames = [
-	"prisma-cli",
-	"prisma-client-api",
-	"prisma-compute",
-	"prisma-database-setup",
-	"prisma-upgrade-v7",
-	"prisma-postgres"
-];
-const DatabaseProviderSchema = z.enum(databaseProviders);
-const PackageManagerSchema = z.enum(packageManagers);
-const CreateTemplateSchema = z.enum(createTemplates);
-z.enum(createAddons);
-z.enum(addonInstallScopes);
-z.enum(extensionTargets);
-z.enum(prismaSkillNames);
-const CommonCommandOptionsSchema = z.object({
-	yes: z.boolean().optional().describe("Skip prompts and accept default choices"),
-	verbose: z.boolean().optional().describe("Show verbose command output during setup")
-});
-const PrismaSetupOptionsSchema = z.object({
-	provider: DatabaseProviderSchema.optional().describe("Database provider"),
-	packageManager: PackageManagerSchema.optional().describe("Package manager used for dependency installation"),
-	install: z.boolean().optional().describe("Install dependencies with selected package manager")
-});
-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"),
-	deploy: z.boolean().optional().describe("Deploy the scaffolded project with Prisma Composer"),
-	force: z.boolean().optional().describe("Allow scaffolding into a non-empty target directory")
-});
-const CreateCommandInputSchema = PrismaSetupCommandInputSchema.extend(CreateScaffoldOptionsSchema.shape);
-//#endregion
-//#region src/utils/package-manager.ts
-const packageManagerManifestValues = {
-	npm: "npm@11.17.0",
-	pnpm: "pnpm@11.8.0",
-	yarn: "yarn@4.17.0",
-	bun: "bun@1.3.14"
-};
-function parseUserAgent(userAgent) {
-	if (userAgent?.startsWith("pnpm")) return "pnpm";
-	if (userAgent?.startsWith("yarn")) return "yarn";
-	if (userAgent?.startsWith("bun")) return "bun";
-	if (userAgent?.startsWith("npm")) return "npm";
-	return null;
-}
-function parsePackageManagerField(packageManagerField) {
-	if (typeof packageManagerField !== "string" || packageManagerField.length === 0) return null;
-	const managerName = packageManagerField.split("@")[0];
-	const parsed = PackageManagerSchema.safeParse(managerName);
-	return parsed.success ? parsed.data : null;
-}
-async function detectFromPackageJson(projectDir) {
-	const packageJsonPath = path.join(projectDir, "package.json");
-	if (!await fs.pathExists(packageJsonPath)) return null;
-	return parsePackageManagerField((await fs.readJson(packageJsonPath)).packageManager);
-}
-async function detectFromLockfile(projectDir) {
-	for (const check of [
-		{
-			manager: "pnpm",
-			lockfile: "pnpm-lock.yaml"
-		},
-		{
-			manager: "yarn",
-			lockfile: "yarn.lock"
-		},
-		{
-			manager: "bun",
-			lockfile: "bun.lockb"
-		},
-		{
-			manager: "bun",
-			lockfile: "bun.lock"
-		},
-		{
-			manager: "npm",
-			lockfile: "package-lock.json"
-		},
-		{
-			manager: "npm",
-			lockfile: "npm-shrinkwrap.json"
-		}
-	]) if (await fs.pathExists(path.join(projectDir, check.lockfile))) return check.manager;
-	return null;
-}
-async function detectPackageManager(projectDir = process.cwd()) {
-	const fromPackageJson = await detectFromPackageJson(projectDir);
-	if (fromPackageJson) return fromPackageJson;
-	const fromLockfile = await detectFromLockfile(projectDir);
-	if (fromLockfile) return fromLockfile;
-	const fromUserAgent = parseUserAgent(process.env.npm_config_user_agent);
-	if (fromUserAgent) return fromUserAgent;
-	return "npm";
-}
-function getPackageManagerManifestValue(packageManager) {
-	if (!packageManager) return;
-	return packageManagerManifestValues[packageManager];
-}
-function getInstallCommand(packageManager) {
-	return `${packageManager} install`;
-}
-function getRunScriptCommand(packageManager, scriptName) {
-	const { command, args } = getRunScriptArgs(packageManager, scriptName);
-	return [command, ...args].join(" ");
-}
-function getRunScriptArgs(packageManager, scriptName) {
-	switch (packageManager) {
-		case "bun": return {
-			command: "bun",
-			args: ["run", scriptName]
-		};
-		case "pnpm": return {
-			command: "pnpm",
-			args: ["run", scriptName]
-		};
-		case "yarn": return {
-			command: "yarn",
-			args: ["run", scriptName]
-		};
-		default: return {
-			command: "npm",
-			args: ["run", scriptName]
-		};
-	}
-}
-function getRunScriptInDirectoryCommand(packageManager, directory, scriptName) {
-	switch (packageManager) {
-		case "bun": return `bun run --cwd ${directory} ${scriptName}`;
-		case "pnpm": return `pnpm --dir ${directory} run ${scriptName}`;
-		case "yarn": return `yarn --cwd ${directory} run ${scriptName}`;
-		default: return `npm --prefix ${directory} run ${scriptName}`;
-	}
-}
-function getRuntimeScriptCommand(packageManager, kind, options) {
-	const { sourceEntrypoint, builtEntrypoint, emit = false } = options;
-	if (packageManager === "bun") switch (kind) {
-		case "dev": return `bun --watch ${sourceEntrypoint}`;
-		case "build": return emit ? "tsc" : "tsc --noEmit";
-		case "start": return `bun ${sourceEntrypoint}`;
-	}
-	switch (kind) {
-		case "dev": return `tsx watch ${sourceEntrypoint}`;
-		case "build": return "tsc";
-		case "start": return builtEntrypoint ? `node ${builtEntrypoint}` : `tsx ${sourceEntrypoint}`;
-	}
-}
-function getInstallArgs(packageManager) {
-	return {
-		command: packageManager,
-		args: ["install"]
-	};
-}
-function getPackageExecutionArgs(packageManager, commandArgs, options = {}) {
-	switch (packageManager) {
-		case "pnpm": return {
-			command: "pnpm",
-			args: [
-				...options.silent ? ["--silent"] : [],
-				"dlx",
-				...commandArgs
-			]
-		};
-		case "yarn": return {
-			command: "yarn",
-			args: [
-				"dlx",
-				...options.silent ? ["--quiet"] : [],
-				...commandArgs
-			]
-		};
-		case "bun": return {
-			command: "bunx",
-			args: [...options.silent ? ["--silent"] : [], ...commandArgs]
-		};
-		default: return {
-			command: "npx",
-			args: [...options.silent ? ["--yes"] : [], ...commandArgs]
-		};
-	}
-}
-function getPackageExecutionCommand(packageManager, commandArgs, options = {}) {
-	const execution = getPackageExecutionArgs(packageManager, commandArgs, options);
-	return [execution.command, ...execution.args].join(" ");
-}
-function getPrismaCliArgs(packageManager, prismaArgs) {
-	if (packageManager === "bun") return {
-		command: "bunx",
-		args: [
-			"--bun",
-			"prisma",
-			...prismaArgs
-		]
-	};
-	if (packageManager === "pnpm") return {
-		command: "pnpm",
-		args: [
-			"exec",
-			"prisma",
-			...prismaArgs
-		]
-	};
-	if (packageManager === "yarn") return {
-		command: "yarn",
-		args: [
-			"exec",
-			"prisma",
-			...prismaArgs
-		]
-	};
-	return getPackageExecutionArgs(packageManager, ["prisma", ...prismaArgs]);
-}
-//#endregion
-//#region src/templates/shared.ts
-function getSeedCommand(packageManager) {
-	if (packageManager === "bun") return "bun ./prisma/seed.ts";
-	return "tsx ./prisma/seed.ts";
-}
-function getPrismaCommand(packageManager, subcommand) {
-	return `prisma ${subcommand}`;
-}
-Handlebars.registerHelper("eq", (left, right) => left === right);
-Handlebars.registerHelper("composerPlatformCliInvocation", (packageManager) => packageManager ? JSON.stringify(getPackageExecutionArgs(packageManager, [prismaPlatformCliPackage], { silent: true })) : "{}");
-Handlebars.registerHelper("prismaAuthLoginCommand", (packageManager) => packageManager ? getPackageExecutionCommand(packageManager, [
-	prismaPlatformCliPackage,
-	"auth",
-	"login"
-], { silent: true }) : "");
-Handlebars.registerHelper("prismaCliInvocation", (packageManager) => packageManager ? JSON.stringify(getPrismaCliArgs(packageManager, [])) : "{}");
-Handlebars.registerHelper("runScriptCommand", (packageManager, scriptName) => packageManager ? getRunScriptCommand(packageManager, scriptName) : "");
-Handlebars.registerHelper("runScriptInDirectoryCommand", (packageManager, directory, scriptName) => packageManager ? getRunScriptInDirectoryCommand(packageManager, directory, scriptName) : "");
-Handlebars.registerHelper("packageManagerManifestValue", (packageManager) => getPackageManagerManifestValue(packageManager) ?? "");
-Handlebars.registerHelper("requiresDotenvConfigImport", (packageManager) => requiresDotenvConfigImport(packageManager));
-Handlebars.registerHelper("requiresPrismaConfigDotenvImport", (packageManager) => requiresPrismaConfigDotenvImport(packageManager));
-Handlebars.registerHelper("sqliteAdapterPackage", () => "@prisma/adapter-libsql");
-Handlebars.registerHelper("sqliteAdapterClass", () => "PrismaLibSql");
-Handlebars.registerHelper("seedCommand", (packageManager) => getSeedCommand(packageManager));
-Handlebars.registerHelper("prismaCommand", (packageManager, subcommand) => getPrismaCommand(packageManager, subcommand));
-Handlebars.registerHelper("runtimeScript", (packageManager, kind, sourceEntrypoint, builtEntrypoint, options) => {
-	if (!packageManager) return "";
-	const hash = options.hash;
-	return getRuntimeScriptCommand(packageManager, kind, {
-		sourceEntrypoint,
-		builtEntrypoint,
-		emit: hash.emit === true
-	});
-});
-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;
-	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-create-template.ts
-const starterStyleOutputPaths = {
-	astro: "src/styles.css",
-	next: "src/app/globals.css",
-	nuxt: "app/assets/css/main.css",
-	svelte: "src/app.css",
-	"tanstack-start": "src/styles.css"
-};
-function getCreateTemplateDir(template) {
-	return resolveTemplatesDir(`templates/create/${template}`);
-}
-function createTemplateContext(projectName, template, provider, packageManager, composerPostgres) {
-	return {
-		projectName,
-		template,
-		provider,
-		packageManager,
-		composerPostgres
-	};
-}
-const pnpmAllowedBuilds = [
-	"@prisma/engines",
-	"@parcel/watcher",
-	"esbuild",
-	"msgpackr-extract",
-	"prisma",
-	"sharp",
-	"unrs-resolver",
-	"workerd"
-];
-const composerEffectOverrides = {
-	"@effect/platform-bun": "4.0.0-beta.93",
-	"@effect/platform-node": "4.0.0-beta.93",
-	"@effect/platform-node-shared": "4.0.0-beta.93",
-	"@effect/sql-d1": "4.0.0-beta.93",
-	"@effect/sql-pg": "4.0.0-beta.93",
-	"@effect/vitest": "4.0.0-beta.93"
-};
-function renderPnpmAllowBuildLine(packageName) {
-	return `  ${packageName.startsWith("@") ? JSON.stringify(packageName) : packageName}: true`;
-}
-function renderPnpmAllowBuilds() {
-	return ["allowBuilds:", ...pnpmAllowedBuilds.map(renderPnpmAllowBuildLine)].join("\n");
-}
-function hasPnpmAllowBuild(content, packageName) {
-	const key = escapeRegExp(packageName);
-	return new RegExp(`^\\s*["']?${key}["']?\\s*:\\s*true\\s*$`, "m").test(content);
-}
-function mergePnpmAllowBuilds(content) {
-	const missingBuilds = pnpmAllowedBuilds.filter((packageName) => !hasPnpmAllowBuild(content, packageName));
-	if (missingBuilds.length === 0) return content;
-	const missingLines = missingBuilds.map(renderPnpmAllowBuildLine);
-	const trimmedContent = content.trimEnd();
-	const lines = trimmedContent.length > 0 ? trimmedContent.split("\n") : [];
-	const allowBuildsIndex = lines.findIndex((line) => /^allowBuilds:\s*$/.test(line));
-	if (allowBuildsIndex === -1) {
-		const allowBuilds = ["allowBuilds:", ...missingLines].join("\n");
-		return trimmedContent.length > 0 ? `${trimmedContent}\n\n${allowBuilds}\n` : `${allowBuilds}\n`;
-	}
-	lines.splice(allowBuildsIndex + 1, 0, ...missingLines);
-	return `${lines.join("\n")}\n`;
-}
-function mergePnpmComposerOverrides(content) {
-	const document = parseDocument(content);
-	if (document.errors.length > 0) throw new Error(`Could not update pnpm-workspace.yaml: ${document.errors[0]?.message}`);
-	if (!document.has("overrides")) document.set("overrides", document.createNode({}));
-	let overrides = document.get("overrides", true);
-	if (isScalar(overrides) && overrides.value === null) {
-		document.set("overrides", document.createNode({}));
-		overrides = document.get("overrides", true);
-	}
-	if (!isMap(overrides)) throw new Error("Could not update pnpm-workspace.yaml: \"overrides\" must be a mapping.");
-	const missingOverrides = Object.entries(composerEffectOverrides).filter(([packageName]) => !overrides.has(packageName));
-	if (missingOverrides.length === 0) return content;
-	for (const [packageName, version] of missingOverrides) overrides.set(packageName, version);
-	return document.toString();
-}
-async function ensurePnpmWorkspace(projectDir) {
-	const workspacePath = path.join(projectDir, "pnpm-workspace.yaml");
-	if (!await fs.pathExists(workspacePath)) {
-		const content = mergePnpmComposerOverrides(`${renderPnpmAllowBuilds()}\n`);
-		await fs.writeFile(workspacePath, content, "utf8");
-		return;
-	}
-	const existingContent = await fs.readFile(workspacePath, "utf8");
-	const nextContent = mergePnpmComposerOverrides(mergePnpmAllowBuilds(existingContent));
-	if (nextContent !== existingContent) await fs.writeFile(workspacePath, nextContent, "utf8");
-}
-async function scaffoldCreateTemplate(opts) {
-	const { projectDir, projectName, template, provider, packageManager } = opts;
-	const templateRoot = getCreateTemplateDir(template);
-	const context = createTemplateContext(projectName, template, provider, packageManager, opts.composerPostgres === true);
-	await renderTemplateTree({
-		templateRoot,
-		outputDir: projectDir,
-		context
-	});
-	const starterStyleOutputPath = starterStyleOutputPaths[template];
-	if (starterStyleOutputPath) await renderTemplateFile({
-		templateFilePath: resolveTemplatesDir("templates/shared/starter.css"),
-		outputPath: path.join(projectDir, starterStyleOutputPath),
-		context
-	});
-	if (context.composerPostgres) await renderTemplateFile({
-		templateFilePath: resolveTemplatesDir("templates/shared/setup-composer-postgres.mjs.hbs"),
-		outputPath: path.join(projectDir, "scripts/setup-composer-postgres.mjs"),
-		context
-	});
-	if (packageManager === "pnpm") await ensurePnpmWorkspace(projectDir);
-}
-//#endregion
-//#region src/constants/db-packages.ts
-function getDbPackages(provider, _packageManager) {
-	switch (provider) {
-		case "postgresql":
-		case "cockroachdb": return "@prisma/adapter-pg";
-		case "mysql": return "@prisma/adapter-mariadb";
-		case "sqlite": return "@prisma/adapter-libsql";
-		case "sqlserver": return "@prisma/adapter-mssql";
-		default: throw new Error(`Unsupported database provider: ${String(provider)}`);
-	}
-}
-//#endregion
-//#region src/tasks/install.ts
-function getPrismaScriptMap() {
-	return {
-		"db:generate": "prisma generate",
-		"db:push": "prisma db push",
-		"db:migrate": "prisma migrate dev",
-		"db:migrate:deploy": "prisma migrate deploy",
-		"db:seed": "prisma db seed"
-	};
-}
-function getVersion(packageName) {
-	return dependencyVersionMap[packageName];
-}
-function unique(items) {
-	return [...new Set(items)];
-}
-function sortRecord(record) {
-	return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
-}
-async function projectContainsText(projectDir, text) {
-	const directories = [projectDir];
-	while (directories.length > 0) {
-		const currentDirectory = directories.pop();
-		if (!currentDirectory) continue;
-		const entries = await fs.readdir(currentDirectory, { withFileTypes: true });
-		for (const entry of entries) {
-			if (entry.name === "node_modules" || entry.name === ".git") continue;
-			const entryPath = path.join(currentDirectory, entry.name);
-			if (entry.isDirectory()) {
-				directories.push(entryPath);
-				continue;
-			}
-			if (!entry.isFile() || !/\.(c|m)?[jt]sx?$/.test(entry.name)) continue;
-			if ((await fs.readFile(entryPath, "utf8")).includes(text)) return true;
-		}
-	}
-	return false;
-}
-async function addPackageDependency(opts) {
-	const { dependencies = [], devDependencies = [], customDependencies = {}, scripts = {}, scriptMode, projectDir } = opts;
-	const pkgJsonPath = path.join(projectDir, "package.json");
-	if (!await fs.pathExists(pkgJsonPath)) throw new Error(`No package.json found in ${projectDir}. Run this command inside an existing JavaScript/TypeScript project.`);
-	const pkgJson = await fs.readJson(pkgJsonPath);
-	if (!pkgJson.dependencies) pkgJson.dependencies = {};
-	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
-	if (!pkgJson.scripts) pkgJson.scripts = {};
-	for (const pkgName of unique(dependencies)) {
-		const version = getVersion(pkgName);
-		if (version) pkgJson.dependencies[pkgName] = version;
-		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
-	}
-	for (const pkgName of unique(devDependencies)) {
-		const version = getVersion(pkgName);
-		if (version) pkgJson.devDependencies[pkgName] = version;
-		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
-	}
-	for (const [pkgName, version] of Object.entries(customDependencies)) pkgJson.dependencies[pkgName] = version;
-	for (const [scriptName, command] of Object.entries(scripts)) {
-		if (scriptMode === "if-missing") {
-			if (typeof pkgJson.scripts[scriptName] !== "string" || pkgJson.scripts[scriptName].trim().length === 0) pkgJson.scripts[scriptName] = command;
-			continue;
-		}
-		pkgJson.scripts[scriptName] = command;
-	}
-	pkgJson.dependencies = sortRecord(pkgJson.dependencies);
-	pkgJson.devDependencies = sortRecord(pkgJson.devDependencies);
-	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
-}
-async function writePrismaDependencies(provider, packageManager, projectDir = process.cwd()) {
-	const dependencies = ["@prisma/client"];
-	const devDependencies = ["prisma"];
-	dependencies.push(getDbPackages(provider, packageManager));
-	if (provider === "sqlite") dependencies.push("@libsql/client");
-	if (requiresDotenvConfigImport(packageManager) || await projectContainsText(projectDir, "dotenv/config")) dependencies.push("dotenv");
-	await addPackageDependency({
-		dependencies,
-		devDependencies,
-		scripts: getPrismaScriptMap(),
-		scriptMode: "if-missing",
-		projectDir
-	});
-}
-async function writeCreateTemplateDependencies(opts) {
-	const { template, packageManager, projectDir = process.cwd() } = opts;
-	const targets = getCreateTemplateDependencies(template, packageManager);
-	for (const dependencyTarget of targets) {
-		const targetDirectory = path.join(projectDir, path.dirname(dependencyTarget.packageJsonPath));
-		await addPackageDependency({
-			dependencies: dependencyTarget.dependencies,
-			devDependencies: dependencyTarget.devDependencies,
-			customDependencies: dependencyTarget.customDependencies,
-			projectDir: targetDirectory
-		});
-	}
-	const packageJsonPath = path.join(projectDir, "package.json");
-	const pkgJson = await fs.readJson(packageJsonPath);
-	const effectVersions = {
-		"@effect/platform-bun": "4.0.0-beta.93",
-		"@effect/platform-node": "4.0.0-beta.93",
-		"@effect/platform-node-shared": "4.0.0-beta.93",
-		"@effect/sql-d1": "4.0.0-beta.93",
-		"@effect/sql-pg": "4.0.0-beta.93",
-		"@effect/vitest": "4.0.0-beta.93"
-	};
-	if (packageManager === "yarn") pkgJson.resolutions = {
-		...pkgJson.resolutions ?? {},
-		...effectVersions
-	};
-	else if (packageManager !== "pnpm") pkgJson.overrides = {
-		...pkgJson.overrides ?? {},
-		...effectVersions
-	};
-	pkgJson.engines = {
-		...pkgJson.engines ?? {},
-		node: ">=24"
-	};
-	await fs.writeJson(packageJsonPath, pkgJson, { spaces: 2 });
-}
-async function installProjectDependencies(packageManager, projectDir = process.cwd(), options = {}) {
-	const verbose = options.verbose === true;
-	const installCommand = getInstallArgs(packageManager);
-	const env = packageManager === "yarn" ? {
-		...process.env,
-		YARN_ENABLE_IMMUTABLE_INSTALLS: "false"
-	} : void 0;
-	await execa(installCommand.command, installCommand.args, {
-		cwd: projectDir,
-		env,
-		stdio: verbose ? "inherit" : "pipe"
-	});
-}
-//#endregion
-//#region src/tasks/setup-prisma.ts
-const DEFAULT_DATABASE_PROVIDER = "postgresql";
-const DEFAULT_INSTALL = true;
-const INITIAL_MIGRATION_NAME = "00000000000000_init";
-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/prisma.server.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",
-		initialValue: DEFAULT_DATABASE_PROVIDER,
-		options: [
-			{
-				value: "postgresql",
-				label: "PostgreSQL",
-				hint: "Default"
-			},
-			{
-				value: "mysql",
-				label: "MySQL"
-			},
-			{
-				value: "sqlite",
-				label: "SQLite"
-			},
-			{
-				value: "sqlserver",
-				label: "SQL Server"
-			},
-			{
-				value: "cockroachdb",
-				label: "CockroachDB"
-			}
-		]
-	});
-	if (isCancel(databaseProvider)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return DatabaseProviderSchema.parse(databaseProvider);
-}
-function getPackageManagerHint(option, detected) {
-	if (option === detected) return "Detected";
-	if (option === "bun") return "Fast runtime + package manager";
-}
-async function promptForPackageManager(detectedPackageManager) {
-	const packageManager = await select({
-		message: "Choose package manager",
-		initialValue: detectedPackageManager,
-		options: [
-			{
-				value: "npm",
-				label: "npm",
-				hint: getPackageManagerHint("npm", detectedPackageManager)
-			},
-			{
-				value: "pnpm",
-				label: "pnpm",
-				hint: getPackageManagerHint("pnpm", detectedPackageManager)
-			},
-			{
-				value: "yarn",
-				label: "yarn",
-				hint: getPackageManagerHint("yarn", detectedPackageManager)
-			},
-			{
-				value: "bun",
-				label: "bun",
-				hint: getPackageManagerHint("bun", detectedPackageManager)
-			}
-		]
-	});
-	if (isCancel(packageManager)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return PackageManagerSchema.parse(packageManager);
-}
-async function promptForDependencyInstall(packageManager) {
-	const shouldInstall = await confirm({
-		message: `Install dependencies now with ${getInstallCommand(packageManager)}?`,
-		initialValue: true
-	});
-	if (isCancel(shouldInstall)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return Boolean(shouldInstall);
-}
-function getCommandErrorMessage(error) {
-	if (error instanceof Error && "stderr" in error) {
-		const stderr = String(error.stderr ?? "").trim();
-		if (stderr.length > 0) return stderr;
-	}
-	return error instanceof Error ? error.message : String(error);
-}
-async function collectPrismaSetupInitialContext(input, options = {}) {
-	const projectDir = path.resolve(options.projectDir ?? process.cwd());
-	const useDefaults = input.yes === true;
-	const verbose = input.verbose === true;
-	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
-	if (!databaseProvider) return;
-	const databaseUrl = (process.env.DATABASE_URL ?? "").trim() || void 0;
-	const detectedPackageManager = await detectPackageManager(projectDir);
-	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager));
-	if (!packageManager) return;
-	const shouldInstall = input.install ?? (useDefaults ? DEFAULT_INSTALL : await promptForDependencyInstall(packageManager));
-	if (shouldInstall === void 0) return;
-	return {
-		projectDir,
-		verbose,
-		databaseProvider,
-		databaseUrl,
-		packageManager,
-		shouldInstall
-	};
-}
-async function completePrismaSetupContext(context, options = {}) {
-	const shouldUsePrismaPostgres = context.databaseProvider === "postgresql";
-	return {
-		...context,
-		shouldUsePrismaPostgres,
-		shouldMigrateAndSeed: options.shouldMigrateAndSeed === true
-	};
-}
-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: throw new Error(`Unsupported provider: ${String(provider)}`);
-	}
-}
-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;
-	}
-	const existingContent = await fs.readFile(gitignorePath, "utf8");
-	if (hasGitignoreEntry(existingContent, entry)) return;
-	const separator = existingContent.endsWith("\n") ? "" : "\n";
-	await fs.appendFile(gitignorePath, `${separator}${entry}\n`, "utf8");
-}
-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);
-	await ensureRequiredPrismaFiles(projectDir);
-	const generatedDir = await fs.pathExists(path.join(prismaProjectDir, "server/utils/prisma.ts")) ? "server/generated" : "src/generated";
-	if (options.provider !== "postgresql") {
-		const envExamplePath = path.join(prismaProjectDir, ".env.example");
-		if (!await fs.pathExists(envExamplePath)) await fs.writeFile(envExamplePath, `# Copy this file to .env and replace the value before deploying.\nDATABASE_URL="${getDefaultDatabaseUrl(options.provider)}"\n`, "utf8");
-	}
-	await ensureGitignoreEntry(prismaProjectDir, generatedDir);
-}
-async function writeDependenciesForContext(context, projectDir) {
-	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
-	try {
-		await writePrismaDependencies(context.databaseProvider, context.packageManager, prismaProjectDir);
-		return true;
-	} catch (error) {
-		cancel(getCommandErrorMessage(error));
-		return false;
-	}
-}
-async function installDependenciesForContext(context, projectDir) {
-	if (!context.shouldInstall) return true;
-	const installCommand = getInstallCommand(context.packageManager);
-	if (context.verbose) {
-		log.step(`Running ${installCommand}`);
-		try {
-			await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
-			log.success("Dependencies installed.");
-			return true;
-		} catch (error) {
-			cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
-			return false;
-		}
-	}
-	const installSpinner = spinner();
-	installSpinner.start(`Running ${installCommand}...`);
-	try {
-		await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
-		installSpinner.stop("Dependencies installed.");
-		return true;
-	} catch (error) {
-		installSpinner.stop("Could not install dependencies.");
-		cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
-		return false;
-	}
-}
-async function finalizePrismaFilesForContext(context, projectDir) {
-	const initSpinner = spinner();
-	initSpinner.start("Preparing Prisma files...");
-	try {
-		await finalizePrismaFiles({
-			provider: context.databaseProvider,
-			projectDir
-		});
-		initSpinner.stop("Prisma files ready.");
-		return true;
-	} catch (error) {
-		initSpinner.stop("Could not prepare Prisma files.");
-		cancel(getCommandErrorMessage(error));
-		return false;
-	}
-}
-async function generatePrismaClientForContext(context, projectDir) {
-	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
-	const generateCommand = getRunScriptCommand(context.packageManager, "db:generate");
-	if (context.verbose) log.step(`Running ${generateCommand}`);
-	const generateSpinner = context.verbose ? void 0 : spinner();
-	generateSpinner?.start("Generating Prisma Client...");
-	try {
-		const generateArgs = getRunScriptArgs(context.packageManager, "db:generate");
-		await execa(generateArgs.command, generateArgs.args, {
-			cwd: prismaProjectDir,
-			env: {
-				...process.env,
-				DATABASE_URL: context.databaseUrl ?? getDefaultDatabaseUrl(context.databaseProvider)
-			},
-			stdio: context.verbose ? "inherit" : "pipe"
-		});
-		if (context.verbose) log.success("Prisma Client generated.");
-		else generateSpinner?.stop("Prisma Client generated.");
-		return { didGenerateClient: true };
-	} catch (error) {
-		if (context.verbose) log.warn("Could not generate Prisma Client.");
-		else generateSpinner?.stop("Could not generate Prisma Client.");
-		return {
-			didGenerateClient: false,
-			warning: `Prisma generate failed: ${getCommandErrorMessage(error)}`
-		};
-	}
-}
-async function generateInitialMigrationForContext(context, projectDir) {
-	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
-	const migrationsDir = path.join(prismaProjectDir, "prisma/migrations");
-	if (await fs.pathExists(migrationsDir)) {
-		if ((await fs.readdir(migrationsDir, { withFileTypes: true })).some((entry) => entry.isDirectory())) return { didGenerateMigration: true };
-	}
-	if (!context.shouldInstall) return { didGenerateMigration: false };
-	const migrationDir = path.join(migrationsDir, INITIAL_MIGRATION_NAME);
-	const migrationFile = path.join(migrationDir, "migration.sql");
-	const migrationInvocation = getPrismaCliArgs(context.packageManager, [
-		"migrate",
-		"diff",
-		"--from-empty",
-		"--to-schema",
-		"prisma/schema.prisma",
-		"--script",
-		"--output",
-		migrationFile
-	]);
-	const migrationSpinner = context.verbose ? void 0 : spinner();
-	migrationSpinner?.start("Generating initial migration...");
-	try {
-		await fs.ensureDir(migrationDir);
-		await execa(migrationInvocation.command, migrationInvocation.args, {
-			cwd: prismaProjectDir,
-			env: {
-				...process.env,
-				DATABASE_URL: context.databaseUrl ?? getDefaultDatabaseUrl(context.databaseProvider)
-			},
-			stdio: context.verbose ? "inherit" : "pipe"
-		});
-		await fs.writeFile(path.join(migrationsDir, "migration_lock.toml"), `# Please do not edit this file manually\nprovider = "${context.databaseProvider}"\n`, "utf8");
-		if (context.verbose) log.success("Initial migration generated.");
-		else migrationSpinner?.stop("Initial migration generated.");
-		return { didGenerateMigration: true };
-	} catch (error) {
-		await fs.remove(migrationDir);
-		if (context.verbose) log.warn("Could not generate the initial migration.");
-		else migrationSpinner?.stop("Could not generate the initial migration.");
-		return {
-			didGenerateMigration: false,
-			warning: `Initial migration generation failed: ${getCommandErrorMessage(error)}`
-		};
-	}
-}
-function buildWarningLines(generateWarning, migrationGenerationWarning, migrateAndSeedWarning) {
-	const warningLines = [];
-	if (generateWarning) warningLines.push(`- ${generateWarning}`);
-	if (migrationGenerationWarning) warningLines.push(`- ${migrationGenerationWarning}`);
-	if (migrateAndSeedWarning) warningLines.push(`- ${migrateAndSeedWarning}`);
-	return warningLines;
-}
-function buildNextStepsForContext(opts) {
-	const { context, options, didGenerateClient, didMigrate, didSeed } = opts;
-	const nextSteps = [...options.prependNextSteps ?? []];
-	if (!context.shouldInstall) nextSteps.push(`- ${getInstallCommand(context.packageManager)}`);
-	if (!didGenerateClient) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:generate")}`);
-	if (options.includeMigrationAndSeedNextSteps !== false && !didMigrate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:migrate")}`);
-	if (options.includeMigrationAndSeedNextSteps !== false && !didSeed) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:seed")}`);
-	if (options.includeDevNextStep) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "dev")}`);
-	return nextSteps;
-}
-async function executePrismaSetupContext(context, options = {}) {
-	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
-	if (!await writeDependenciesForContext(context, projectDir)) return { ok: false };
-	if (!await installDependenciesForContext(context, projectDir)) return { ok: false };
-	if (!await finalizePrismaFilesForContext(context, projectDir)) return { ok: false };
-	const generateResult = await generatePrismaClientForContext(context, projectDir);
-	const migrationGenerationResult = await generateInitialMigrationForContext(context, projectDir);
-	const migrateAndSeedResult = await migrateAndSeedIfRequested(context, projectDir, {
-		databaseUrl: context.databaseUrl,
-		didGenerateClient: generateResult.didGenerateClient
-	});
-	const warningLines = buildWarningLines(generateResult.warning, migrationGenerationResult.warning, migrateAndSeedResult.warning);
-	return {
-		ok: true,
-		nextSteps: buildNextStepsForContext({
-			context,
-			options,
-			didGenerateClient: generateResult.didGenerateClient,
-			didMigrate: migrateAndSeedResult.didMigrate,
-			didSeed: migrateAndSeedResult.didSeed
-		}),
-		warningSection: warningLines.length > 0 ? `\n\n${warningLines.join("\n")}` : "",
-		didGenerateClient: generateResult.didGenerateClient,
-		didGenerateMigration: migrationGenerationResult.didGenerateMigration
-	};
-}
-async function migrateAndSeedIfRequested(context, projectDir, options) {
-	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
-	if (!context.shouldMigrateAndSeed) return {
-		didMigrate: false,
-		didSeed: false
-	};
-	if (!options.didGenerateClient) return {
-		didMigrate: false,
-		didSeed: false,
-		warning: "Skipped migrate + seed because the Prisma Client was not generated."
-	};
-	if (!options.databaseUrl) return {
-		didMigrate: false,
-		didSeed: false,
-		warning: "Skipped migrate + seed because no DATABASE_URL is available."
-	};
-	const migrateInvocation = getPrismaCliArgs(context.packageManager, ["migrate", "deploy"]);
-	const seedInvocation = getPrismaCliArgs(context.packageManager, ["db", "seed"]);
-	const migrateSpinner = spinner();
-	migrateSpinner.start("Applying migrations...");
-	let didMigrate = false;
-	try {
-		await execa(migrateInvocation.command, migrateInvocation.args, {
-			cwd: prismaProjectDir,
-			env: {
-				...process.env,
-				DATABASE_URL: options.databaseUrl
-			},
-			stdio: context.verbose ? "inherit" : "pipe"
-		});
-		migrateSpinner.stop("Migrations applied.");
-		didMigrate = true;
-	} catch (error) {
-		migrateSpinner.stop(`Migration failed${error instanceof Error ? `: ${error.message}` : "."}`);
-		return {
-			didMigrate: false,
-			didSeed: false,
-			warning: `Migration failed; run \`${getRunScriptCommand(context.packageManager, "db:migrate:deploy")}\` manually.`
-		};
-	}
-	const seedSpinner = spinner();
-	seedSpinner.start("Seeding database...");
-	let didSeed = false;
-	try {
-		await execa(seedInvocation.command, seedInvocation.args, {
-			cwd: prismaProjectDir,
-			env: {
-				...process.env,
-				DATABASE_URL: options.databaseUrl
-			},
-			stdio: context.verbose ? "inherit" : "pipe"
-		});
-		seedSpinner.stop("Database seeded.");
-		didSeed = true;
-	} catch (error) {
-		seedSpinner.stop(`Seed failed${error instanceof Error ? `: ${error.message}` : "."}`);
-		return {
-			didMigrate,
-			didSeed: false,
-			warning: `Seed failed; run \`${getRunScriptCommand(context.packageManager, "db:seed")}\` manually.`
-		};
-	}
-	return {
-		didMigrate,
-		didSeed
-	};
-}
-//#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) {
-	const skills = [...SHARED_PRISMA_SKILLS, "prisma-compute"];
-	if (provider === "postgresql") return [...skills, "prisma-postgres"];
-	return 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-compute": {
-			value: "prisma-compute",
-			label: "prisma-compute",
-			hint: "Prisma Compute deploy and hosting workflows"
-		},
-		"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 = [...SHARED_PRISMA_SKILLS];
-	if (provider === "postgresql" && shouldUsePrismaPostgres) skills.push("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 {
-		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) {
-		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: throw new Error(`Unsupported extension target: ${String(target)}`);
-	}
-}
-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/tasks/deploy-with-composer.ts
-function redactSecrets(message) {
-	return message.replace(/\b((?:prisma\+)?postgres(?:ql)?:\/\/)[^\s'"]+/gi, "$1<redacted>").replace(/(['"])([A-Z0-9_]*(?:DATABASE_URL|DIRECT_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY|ACCESS_KEY)[A-Z0-9_]*=)(.*?)\1/g, "$1$2<redacted>$1").replace(/\b([A-Z0-9_]*(?:DATABASE_URL|DIRECT_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY|ACCESS_KEY)[A-Z0-9_]*=)[^\s]+/g, "$1<redacted>");
-}
-function getErrorMessage(error) {
-	if (error instanceof Error) return redactSecrets(error.message);
-	if (typeof error === "object" && error !== null) {
-		const message = Reflect.get(error, "message");
-		const summary = Reflect.get(error, "summary");
-		if (typeof summary === "string") return redactSecrets(summary);
-		if (typeof message === "string") return redactSecrets(message);
-	}
-	return redactSecrets(String(error));
-}
-function createExplicitDeployError(reason, error) {
-	const detail = error === void 0 ? "" : `: ${getErrorMessage(error)}`;
-	return /* @__PURE__ */ new Error(`Deploy requested but ${reason}${detail}`);
-}
-function parsePrismaCliEnvelope(output) {
-	const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-	for (const line of lines.reverse()) {
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			continue;
-		}
-		if (typeof parsed !== "object" || parsed === null) continue;
-		const record = parsed;
-		const candidate = record.kind === "result" ? record.envelope : parsed;
-		if (typeof candidate !== "object" || candidate === null) continue;
-		const envelope = candidate;
-		if (typeof envelope.ok !== "boolean") continue;
-		return envelope;
-	}
-	throw new Error("Prisma CLI returned output that is not a valid result envelope.");
-}
-function getPrismaPlatformCliArgs(packageManager, args) {
-	return getPackageExecutionArgs(packageManager, [prismaPlatformCliPackage, ...args], { silent: true });
-}
-function getPrismaAuthLoginCommand(packageManager) {
-	return getPackageExecutionCommand(packageManager, [
-		prismaPlatformCliPackage,
-		"auth",
-		"login"
-	], { silent: true });
-}
-async function isAuthenticatedWithPrisma(packageManager, projectDir) {
-	const invocation = getPrismaPlatformCliArgs(packageManager, [
-		"auth",
-		"whoami",
-		"--json",
-		"--no-interactive"
-	]);
-	const result = await execa(invocation.command, invocation.args, {
-		cwd: projectDir,
-		env: process.env,
-		reject: false
-	});
-	let envelope;
-	try {
-		envelope = parsePrismaCliEnvelope(result.stdout);
-	} catch (error) {
-		const detail = result.stderr.trim() || result.stdout.trim() || getErrorMessage(error);
-		throw new Error(redactSecrets(detail));
-	}
-	if (result.exitCode !== 0 || !envelope.ok) throw new Error(envelope.error?.summary ?? envelope.error?.message ?? (result.stderr.trim() || "Prisma authentication check failed."));
-	if (typeof envelope.result !== "object" || envelope.result === null) throw new Error("Prisma CLI authentication output did not include a result.");
-	const authenticated = Reflect.get(envelope.result, "authenticated");
-	if (typeof authenticated !== "boolean") throw new Error("Prisma CLI authentication output did not include an authentication status.");
-	return authenticated;
-}
-async function ensurePrismaAuthentication(packageManager, projectDir) {
-	if (await isAuthenticatedWithPrisma(packageManager, projectDir)) return;
-	if (process.stdin.isTTY !== true) throw new Error(`Prisma authentication is required. Run ${getPrismaAuthLoginCommand(packageManager)} in an interactive terminal, then ${getRunScriptCommand(packageManager, "deploy")}. For CI, set PRISMA_SERVICE_TOKEN.`);
-	log.info("Sign in to Prisma to deploy.");
-	const login = getPrismaPlatformCliArgs(packageManager, ["auth", "login"]);
-	await execa(login.command, login.args, {
-		cwd: projectDir,
-		env: process.env,
-		stdio: "inherit"
-	});
-	if (!await isAuthenticatedWithPrisma(packageManager, projectDir)) throw new Error("Prisma sign-in completed without an active workspace session.");
-}
-function getComposerDeployScriptMap(context) {
-	const steps = [
-		getRunScriptCommand(context.packageManager, "build"),
-		getRunScriptCommand(context.packageManager, "composer:deploy"),
-		...context.useComposerPostgres ? [getRunScriptCommand(context.packageManager, "composer:database:setup")] : []
-	];
-	return {
-		"composer:deploy": getPackageExecutionCommand(context.packageManager, [
-			prismaPlatformCliPackage,
-			"composer",
-			"deploy",
-			"module.ts"
-		], { silent: true }),
-		...context.useComposerPostgres ? { "composer:database:setup": `${context.packageManager === "bun" ? "bun" : "node"} scripts/setup-composer-postgres.mjs` } : {},
-		deploy: steps.join(" && ")
-	};
-}
-async function collectComposerDeployContext(input, options) {
-	if (input.deploy === false) return null;
-	let wantsDeploy;
-	if (input.deploy === true) wantsDeploy = true;
-	else if (options.useDefaults) return null;
-	else {
-		const confirmed = await confirm({
-			message: "Deploy to Prisma now?",
-			initialValue: false
-		});
-		if (isCancel(confirmed)) {
-			cancel("Operation cancelled.");
-			return;
-		}
-		wantsDeploy = confirmed;
-	}
-	if (!wantsDeploy) return null;
-	if (options.databaseProvider !== "postgresql" && (process.env.DATABASE_URL ?? "").trim().length === 0) {
-		const reason = `immediate deployment for ${options.databaseProvider} needs DATABASE_URL`;
-		if (input.deploy === true) throw createExplicitDeployError(reason);
-		log.warn(`${reason}. Scaffolding without deployment; configure the generated .env file and run the deploy script later.`);
-		return null;
-	}
-	return {
-		template: options.template,
-		packageManager: options.packageManager,
-		projectName: options.projectName,
-		useComposerPostgres: false,
-		verbose: options.verbose
-	};
-}
-async function executeComposerDeployContext(params) {
-	const deploy = getRunScriptArgs(params.context.packageManager, "deploy");
-	const deploySpinner = params.context.verbose ? void 0 : spinner();
-	let deployStarted = false;
-	try {
-		await ensurePrismaAuthentication(params.context.packageManager, params.projectDir);
-		if (params.context.verbose) log.step("Prisma deployment output follows.");
-		else {
-			deploySpinner?.start("Deploying to Prisma...");
-			deployStarted = true;
-		}
-		await execa(deploy.command, deploy.args, {
-			cwd: params.projectDir,
-			env: process.env,
-			stdio: params.context.verbose ? "inherit" : "pipe"
-		});
-		if (params.context.verbose) log.success("Deployed to Prisma.");
-		else deploySpinner?.stop("Deployed to Prisma.");
-		return {
-			ok: true,
-			result: { appName: params.context.projectName }
-		};
-	} catch (error) {
-		if (deployStarted) deploySpinner?.stop("Deployment failed.");
-		const deployError = new Error(getErrorMessage(error));
-		log.error(`Deploy failed: ${deployError.message}`);
-		return {
-			ok: false,
-			cancelled: false,
-			error: deployError
-		};
-	}
-}
-//#endregion
-//#region src/telemetry/client.ts
-const TELEMETRY_API_KEY = "";
-const TELEMETRY_HOST = "https://us.i.posthog.com";
-const TELEMETRY_CONFIG_FILE = "telemetry.json";
-const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function shouldDisableTelemetry() {
-	return true;
-}
-function getTelemetryConfigDir() {
-	if (process.platform === "darwin") return path.join(os$1.homedir(), "Library", "Application Support", "create-prisma");
-	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os$1.homedir(), "AppData", "Roaming"), "create-prisma");
-	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os$1.homedir(), ".config"), "create-prisma");
-}
-async function getAnonymousId() {
-	const telemetryConfigPath = path.join(getTelemetryConfigDir(), TELEMETRY_CONFIG_FILE);
-	try {
-		const config = await fs.readJSON(telemetryConfigPath);
-		if (typeof config.anonymousId === "string" && UUID_V4_REGEX.test(config.anonymousId)) return config.anonymousId;
-	} catch {}
-	const anonymousId = randomUUID();
-	try {
-		await fs.ensureDir(path.dirname(telemetryConfigPath));
-		await fs.writeJSON(telemetryConfigPath, { anonymousId }, { spaces: 2 });
-	} catch {}
-	return anonymousId;
-}
-function getCommonProperties() {
-	return {
-		"cli-version": "0.7.1-pr.52.181.1",
-		"node-version": process.version,
-		platform: process.platform,
-		arch: process.arch
-	};
-}
-function sanitizeProperties(properties) {
-	return Object.fromEntries(Object.entries(properties).filter(([, value]) => value !== void 0));
-}
-async function trackCliTelemetry(event, properties) {
-	if (shouldDisableTelemetry()) return;
-	let client;
-	try {
-		const distinctId = await getAnonymousId();
-		const sanitizedProperties = sanitizeProperties({
-			...getCommonProperties(),
-			...properties,
-			$process_person_profile: false
-		});
-		client = new PostHog(TELEMETRY_API_KEY, {
-			host: TELEMETRY_HOST,
-			disableGeoip: true,
-			flushAt: 1,
-			flushInterval: 0
-		});
-		await client.captureImmediate({
-			distinctId,
-			event,
-			properties: sanitizedProperties,
-			disableGeoip: true
-		});
-	} catch {} finally {
-		if (client) await client.shutdown().catch(() => {});
-	}
-}
-//#endregion
-//#region src/telemetry/create.ts
-function getRequestedAddons(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 addons;
-}
-function getTargetDirectoryState(context) {
-	if (!context.targetPathState.exists) return "new";
-	if (context.targetPathState.isEmptyDirectory) return "empty_directory";
-	return "non_empty_directory";
-}
-function getBaseCreateProperties(input, context) {
-	const resolvedAddons = context?.addonSetupContext?.addons ?? getRequestedAddons(input);
-	return {
-		command: "create",
-		"uses-defaults": input.yes === true,
-		verbose: input.verbose === true,
-		force: input.force === true,
-		template: context?.template ?? input.template ?? null,
-		"database-provider": context?.prismaSetupContext.databaseProvider ?? input.provider ?? null,
-		"package-manager": context?.prismaSetupContext.packageManager ?? input.packageManager ?? null,
-		"should-install": context?.prismaSetupContext.shouldInstall ?? input.install ?? null,
-		"should-generate": true,
-		"uses-prisma-postgres": context?.prismaSetupContext.shouldUsePrismaPostgres ?? (input.provider === void 0 ? null : input.provider === "postgresql"),
-		addons: resolvedAddons,
-		"addon-count": resolvedAddons.length,
-		"addon-scope": context?.addonSetupContext?.scope ?? null,
-		"skills-count": context?.addonSetupContext?.skills.length ?? null,
-		"skills-agents-count": context?.addonSetupContext?.skillsAgents.length ?? null,
-		"mcp-agents-count": context?.addonSetupContext?.mcpAgents.length ?? null,
-		"extension-target-count": context?.addonSetupContext?.extensionTargets.length ?? null,
-		"target-directory-state": context ? getTargetDirectoryState(context) : null
-	};
-}
-function getErrorName(error) {
-	if (error instanceof Error) return error.name;
-	return error === void 0 ? null : "UnknownError";
-}
-function getErrorCode(error) {
-	if (typeof error !== "object" || error === null) return null;
-	const exitCode = Reflect.get(error, "exitCode");
-	if (typeof exitCode === "number") return exitCode;
-	const code = Reflect.get(error, "code");
-	return typeof code === "number" || typeof code === "string" ? code : null;
-}
-async function trackCreateCompleted(params) {
-	await trackCliTelemetry("cli:create_command_completed", {
-		...getBaseCreateProperties(params.input, params.context),
-		"duration-ms": params.durationMs
-	});
-}
-async function trackCreateFailed(params) {
-	await trackCliTelemetry("cli:create_command_failed", {
-		...getBaseCreateProperties(params.input, params.context),
-		"duration-ms": params.durationMs,
-		"failure-stage": params.stage,
-		"error-name": getErrorName(params.error),
-		"error-code": getErrorCode(params.error)
-	});
-}
-//#endregion
-//#region src/ui/branding.ts
-const prismaTitle = `${styleText(["bold", "cyan"], "Create")} ${styleText(["bold", "magenta"], "Prisma")}`;
-function getCreatePrismaIntro() {
-	return prismaTitle;
-}
-//#endregion
-//#region src/commands/create.ts
-const DEFAULT_PROJECT_NAME = "my-app";
-const DEFAULT_TEMPLATE = "hono";
-function toPackageName(projectName) {
-	return projectName.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+/, "").replace(/-+$/, "") || "app";
-}
-function formatPathForDisplay(filePath) {
-	return path.relative(process.cwd(), filePath) || ".";
-}
-function validateProjectName(value) {
-	const trimmed = String(value ?? "").trim();
-	if (trimmed.length === 0) return "Please enter a project name.";
-	if (trimmed === "..") return "Project name cannot be '..'.";
-	if (path.isAbsolute(trimmed)) return "Use a relative project name instead of an absolute path.";
-}
-async function promptForProjectName() {
-	const projectName = await text({
-		message: "Project name",
-		placeholder: DEFAULT_PROJECT_NAME,
-		initialValue: DEFAULT_PROJECT_NAME,
-		validate: validateProjectName
-	});
-	if (isCancel(projectName)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return String(projectName).trim();
-}
-async function promptForCreateTemplate() {
-	const template = await select({
-		message: "Select template",
-		initialValue: DEFAULT_TEMPLATE,
-		options: [
-			{
-				value: "hono",
-				label: "Hono",
-				hint: "TypeScript API starter"
-			},
-			{
-				value: "elysia",
-				label: "Elysia",
-				hint: "TypeScript API starter with Elysia's Node adapter"
-			},
-			{
-				value: "nest",
-				label: "NestJS",
-				hint: "Official Nest-style API starter with a Prisma service"
-			},
-			{
-				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: "tanstack-start",
-				label: "TanStack Start",
-				hint: "TanStack Start React app with file routes and server functions"
-			},
-			{
-				value: "turborepo",
-				label: "Turborepo",
-				hint: "Monorepo starter with apps + packages/db Prisma package"
-			}
-		]
-	});
-	if (isCancel(template)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return CreateTemplateSchema.parse(template);
-}
-async function inspectTargetPath(targetPath) {
-	if (!await fs.pathExists(targetPath)) return {
-		exists: false,
-		isDirectory: true,
-		isEmptyDirectory: true
-	};
-	if (!(await fs.stat(targetPath)).isDirectory()) return {
-		exists: true,
-		isDirectory: false,
-		isEmptyDirectory: false
-	};
-	return {
-		exists: true,
-		isDirectory: true,
-		isEmptyDirectory: (await fs.readdir(targetPath)).length === 0
-	};
-}
-async function runCreateCommand(rawInput = {}) {
-	const startedAt = Date.now();
-	let input = {};
-	let context;
-	let failureStage = "validate_input";
-	try {
-		input = CreateCommandInputSchema.parse(rawInput);
-		intro(getCreatePrismaIntro());
-		failureStage = "collect_context";
-		context = await collectCreateContext(input);
-		if (!context) return;
-		failureStage = "unknown";
-		const executionResult = await executeCreateContext(context);
-		if (!executionResult.ok) {
-			failureStage = executionResult.stage;
-			throw executionResult.error instanceof Error ? executionResult.error : new Error(executionResult.error === void 0 ? `Create command failed during ${executionResult.stage}` : String(executionResult.error));
-		}
-		await trackCreateCompleted({
-			input,
-			context,
-			durationMs: Date.now() - startedAt
-		});
-	} catch (error) {
-		const commandError = error instanceof Error ? error : new Error(String(error));
-		cancel(`Create command failed: ${commandError.message}`);
-		try {
-			await trackCreateFailed({
-				input,
-				context,
-				durationMs: Date.now() - startedAt,
-				error: commandError,
-				stage: failureStage
-			});
-		} catch {}
-		throw commandError;
-	}
-}
-async function collectCreateContext(input) {
-	const useDefaults = input.yes === true;
-	const force = input.force === true;
-	const projectNameInput = input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : await promptForProjectName());
-	if (projectNameInput === void 0) return;
-	const projectName = String(projectNameInput).trim();
-	const projectNameValidationError = validateProjectName(projectName);
-	if (projectNameValidationError) {
-		cancel(projectNameValidationError);
-		return;
-	}
-	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate());
-	if (!template) return;
-	const targetDirectory = path.resolve(process.cwd(), projectName);
-	const targetPathState = await inspectTargetPath(targetDirectory);
-	if (targetPathState.exists && !targetPathState.isDirectory) {
-		cancel(`Target path ${formatPathForDisplay(targetDirectory)} already exists and is not a directory. Choose a different project name.`);
-		return;
-	}
-	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
-		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
-		return;
-	}
-	const prismaSetupInitialContext = await collectPrismaSetupInitialContext(input, { projectDir: targetDirectory });
-	if (!prismaSetupInitialContext) return;
-	const projectPackageName = toPackageName(path.basename(targetDirectory));
-	const composerDeployContext = await collectComposerDeployContext(input, {
-		template,
-		databaseProvider: prismaSetupInitialContext.databaseProvider,
-		packageManager: prismaSetupInitialContext.packageManager,
-		projectName: projectPackageName,
-		useDefaults,
-		verbose: prismaSetupInitialContext.verbose
-	});
-	if (composerDeployContext === void 0) return;
-	const prismaSetupContext = await completePrismaSetupContext(prismaSetupInitialContext, { shouldMigrateAndSeed: Boolean(composerDeployContext) });
-	if (!prismaSetupContext) return;
-	const useComposerPostgres = prismaSetupContext.shouldUsePrismaPostgres;
-	if (composerDeployContext) composerDeployContext.useComposerPostgres = useComposerPostgres;
-	if (composerDeployContext && useComposerPostgres) log.info("Composer will provision Prisma Postgres and wire it into the application.");
-	const composerScaffoldContext = composerDeployContext ?? {
-		template,
-		packageManager: prismaSetupContext.packageManager,
-		projectName: projectPackageName,
-		useComposerPostgres,
-		verbose: prismaSetupContext.verbose
-	};
-	const addonSetupContext = await collectCreateAddonSetupContext(input, {
-		useDefaults,
-		provider: prismaSetupContext.databaseProvider,
-		shouldUsePrismaPostgres: prismaSetupContext.shouldUsePrismaPostgres
-	});
-	if (addonSetupContext === void 0) return;
-	return {
-		targetDirectory,
-		targetPathState,
-		force,
-		template,
-		projectPackageName,
-		prismaSetupContext,
-		addonSetupContext: addonSetupContext ?? void 0,
-		composerScaffoldContext,
-		composerDeployContext: composerDeployContext ?? void 0,
-		useComposerPostgres
-	};
-}
-async function executeCreateContext(context) {
-	const scaffoldSpinner = spinner();
-	scaffoldSpinner.start(`Scaffolding ${context.template} project...`);
-	try {
-		await scaffoldCreateTemplate({
-			projectDir: context.targetDirectory,
-			projectName: context.projectPackageName,
-			template: context.template,
-			provider: context.prismaSetupContext.databaseProvider,
-			packageManager: context.prismaSetupContext.packageManager,
-			composerPostgres: context.useComposerPostgres
-		});
-		scaffoldSpinner.stop("Project files scaffolded.");
-	} catch (error) {
-		scaffoldSpinner.stop("Could not scaffold project files.");
-		return {
-			ok: false,
-			stage: "scaffold_template",
-			error
-		};
-	}
-	try {
-		await writeCreateTemplateDependencies({
-			template: context.template,
-			packageManager: context.prismaSetupContext.packageManager,
-			projectDir: context.targetDirectory
-		});
-		await addPackageDependency({
-			scripts: getComposerDeployScriptMap(context.composerScaffoldContext),
-			scriptMode: "if-missing",
-			projectDir: context.targetDirectory
-		});
-	} catch (error) {
-		return {
-			ok: false,
-			stage: "scaffold_template",
-			error
-		};
-	}
-	if (context.targetPathState.exists && !context.targetPathState.isEmptyDirectory && context.force) log.warn(`Used --force in non-empty directory ${formatPathForDisplay(context.targetDirectory)}.`);
-	const nextSteps = formatPathForDisplay(context.targetDirectory) === "." ? [] : [`- cd ${formatPathForDisplay(context.targetDirectory)}`];
-	if (context.addonSetupContext) try {
-		await executeCreateAddonSetupContext({
-			context: context.addonSetupContext,
-			packageManager: context.prismaSetupContext.packageManager,
-			projectDir: context.targetDirectory,
-			verbose: context.prismaSetupContext.verbose
-		});
-	} catch (error) {
-		return {
-			ok: false,
-			stage: "addons",
-			error
-		};
-	}
-	let prismaResult;
-	try {
-		prismaResult = await executePrismaSetupContext(Boolean(context.composerDeployContext && context.useComposerPostgres) ? {
-			...context.prismaSetupContext,
-			shouldMigrateAndSeed: false
-		} : context.prismaSetupContext, {
-			prependNextSteps: nextSteps,
-			projectDir: context.targetDirectory,
-			includeDevNextStep: true,
-			includeMigrationAndSeedNextSteps: !context.useComposerPostgres
-		});
-		if (!prismaResult.ok) return {
-			ok: false,
-			stage: "prisma_setup"
-		};
-		if (context.composerDeployContext && (!prismaResult.didGenerateClient || !prismaResult.didGenerateMigration)) return {
-			ok: false,
-			stage: "prisma_setup",
-			error: /* @__PURE__ */ new Error("Could not generate Prisma Client and the initial migration required for deployment.")
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			stage: "prisma_setup",
-			error
-		};
-	}
-	let deployResult;
-	if (context.composerDeployContext) try {
-		const result = await executeComposerDeployContext({
-			context: context.composerDeployContext,
-			projectDir: context.targetDirectory
-		});
-		if (!result.ok && !result.cancelled) return {
-			ok: false,
-			stage: "composer_deploy",
-			error: result.error
-		};
-		if (!result.ok) prismaResult.warningSection += "\n\n- Prisma deployment was cancelled.";
-		if (result.ok) deployResult = result.result;
-	} catch (error) {
-		return {
-			ok: false,
-			stage: "composer_deploy",
-			error
-		};
-	}
-	if (!deployResult) {
-		const deployNextStep = `- ${getRunScriptCommand(context.prismaSetupContext.packageManager, "deploy")}`;
-		if (!prismaResult.nextSteps.includes(deployNextStep)) prismaResult.nextSteps.push(deployNextStep);
-	}
-	const summaryLines = [];
-	summaryLines.push(`Setup complete.${prismaResult.warningSection}`);
-	if (deployResult) summaryLines.push("", "Deployed to Prisma:", `- App: ${deployResult.appName}`);
-	summaryLines.push("", "Next steps:", prismaResult.nextSteps.join("\n"));
-	outro(summaryLines.join("\n"));
-	return { ok: true };
-}
-//#endregion
-//#region src/index.ts
-const CLI_VERSION = "0.7.1-pr.52.181.1";
-const router = os.router({ create: os.meta({
-	description: "Create a new project with Prisma setup",
-	default: true,
-	negateBooleans: true
-}).input(CreateCommandInputSchema.optional()).handler(async ({ input }) => {
-	await runCreateCommand(input ?? {});
-}) });
-function createCreatePrismaCli() {
-	return createCli({
-		router,
-		name: "create-prisma",
-		version: CLI_VERSION
-	});
-}
-async function create(input = {}) {
-	await runCreateCommand(input);
-}
-//#endregion
-export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };
+import { a as CreateTemplateSchema, c as PackageManagerSchema, i as CreateCommandInputSchema, l as SchemaPresetSchema, n as createCreatePrismaCli, o as DatabaseProviderSchema, r as router, s as DatabaseUrlSchema, t as create } from "./src-B3hRLZ0U.mjs";
+export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };