create-better-fullstack 2.1.2 → 2.1.4

package/dist/templates-CnTOtKjm.mjs

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+import { A as types_exports } from "./errors-Cyol8zbN.mjs";
+
+//#region src/utils/generate-reproducible-command.ts
+function getBaseCommand(packageManager) {
+	switch (packageManager) {
+		case "bun": return "bun create better-fullstack@latest";
+		case "pnpm": return "pnpm create better-fullstack@latest";
+		case "yarn": return "yarn create better-fullstack@latest";
+		case "npm":
+		default: return "npx create-better-fullstack@latest";
+	}
+}
+function formatArrayFlag(flag, values) {
+	const normalizedValues = values.filter((value) => value !== "none");
+	if (normalizedValues.length === 0) return `--${flag} none`;
+	return `--${flag} ${normalizedValues.join(" ")}`;
+}
+function appendCommonFlags(flags, config) {
+	if (config.aiDocs && config.aiDocs.length > 0) flags.push(formatArrayFlag("ai-docs", config.aiDocs));
+	else flags.push("--ai-docs none");
+	flags.push(config.git ? "--git" : "--no-git");
+	flags.push(`--package-manager ${config.packageManager}`);
+	if (config.versionChannel !== "stable") flags.push(`--version-channel ${config.versionChannel}`);
+	flags.push(config.install ? "--install" : "--no-install");
+}
+function hasGraphPrimaryPart(config, role, ecosystem) {
+	return config.stackParts?.some((part) => part.source !== "provided" && part.role === role && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
+}
+function getGraphPartIncludingDisabled(config, role, ecosystem) {
+	return config.stackParts?.find((part) => part.source !== "provided" && part.role === role && (!ecosystem || part.ecosystem === ecosystem));
+}
+function getOwnedGraphPartIncludingDisabled(config, ownerRole, role, ecosystem) {
+	const owner = config.stackParts?.find((part) => part.source !== "provided" && part.role === ownerRole && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
+	if (!owner) return void 0;
+	return config.stackParts?.find((part) => part.source !== "provided" && part.role === role && part.ownerPartId === owner.id && (!ecosystem || part.ecosystem === ecosystem));
+}
+function hasAnyGraphAddonPart(config) {
+	return Boolean(config.stackParts?.some((part) => {
+		if (part.source === "provided" || part.toolId === "none") return false;
+		const binding = (0, types_exports.getAddonStackPartBinding)(part.toolId);
+		if (!binding || binding.role !== part.role || binding.ecosystem !== part.ecosystem) return false;
+		if (!binding.ownerRole) return !part.ownerPartId;
+		const owner = config.stackParts?.find((candidate) => candidate.source !== "provided" && candidate.role === binding.ownerRole && candidate.ecosystem === binding.ecosystem && candidate.id === part.ownerPartId);
+		return Boolean(owner);
+	}));
+}
+function hasAnyGraphExamplePart(config) {
+	return Boolean(config.stackParts?.some((part) => part.source !== "provided" && part.toolId !== "none" && part.role === "examples" && part.ecosystem === "universal" && !part.ownerPartId));
+}
+function appendChangedStringFlag(flags, flag, value, defaultValue) {
+	if (value !== defaultValue) flags.push(`--${flag} ${value}`);
+}
+function appendChangedGraphStringFlag(flags, config, role, ecosystem, flag, value, defaultValue) {
+	const graphPart = getGraphPartIncludingDisabled(config, role, ecosystem);
+	if (graphPart) {
+		appendChangedStringFlag(flags, flag, graphPart.toolId === "none" ? "none" : defaultValue, defaultValue);
+		return;
+	}
+	appendChangedStringFlag(flags, flag, value, defaultValue);
+}
+function appendChangedOwnedGraphStringFlag(flags, config, ownerRole, role, ecosystem, flag, value, defaultValue) {
+	const graphPart = getOwnedGraphPartIncludingDisabled(config, ownerRole, role, ecosystem);
+	if (graphPart) {
+		appendChangedStringFlag(flags, flag, graphPart.toolId === "none" ? "none" : defaultValue, defaultValue);
+		return;
+	}
+	appendChangedStringFlag(flags, flag, value, defaultValue);
+}
+function hasAnyOwnedGraphArrayPart(config, ownerRole, role, ecosystem) {
+	return Boolean(getOwnedGraphPartIncludingDisabled(config, ownerRole, role, ecosystem));
+}
+function appendChangedOwnedGraphArrayFlag(flags, config, ownerRole, role, ecosystem, flag, values, defaultValues) {
+	if (hasAnyOwnedGraphArrayPart(config, ownerRole, role, ecosystem)) return;
+	appendChangedArrayFlag(flags, flag, values, defaultValues);
+}
+function appendChangedArrayFlag(flags, flag, values, defaultValues) {
+	if (values.length !== defaultValues.length || values.some((value, index) => value !== defaultValues[index])) flags.push(formatArrayFlag(flag, values));
+}
+function appendAstroIntegrationFlag(flags, config) {
+	if (config.frontend.includes("astro") && config.astroIntegration !== "none") flags.push(`--astro-integration ${config.astroIntegration}`);
+}
+function appendGraphExtraFlags(flags, config) {
+	if (!hasAnyGraphAddonPart(config)) appendChangedArrayFlag(flags, "addons", config.addons, ["turborepo"]);
+	if (!hasAnyGraphExamplePart(config)) appendChangedArrayFlag(flags, "examples", config.examples, []);
+	if (hasGraphPrimaryPart(config, "database")) appendChangedOwnedGraphStringFlag(flags, config, "database", "dbSetup", "universal", "db-setup", config.dbSetup, "none");
+	else appendChangedStringFlag(flags, "db-setup", config.dbSetup, "none");
+	if (hasGraphPrimaryPart(config, "frontend", "typescript")) {
+		const effectiveUiLibrary = getGraphPartIncludingDisabled(config, "ui", "typescript")?.toolId ?? config.uiLibrary;
+		appendAstroIntegrationFlag(flags, config);
+		appendChangedOwnedGraphStringFlag(flags, config, "frontend", "deploy", "typescript", "web-deploy", config.webDeploy, "none");
+		appendChangedGraphStringFlag(flags, config, "css", "typescript", "css-framework", config.cssFramework, "tailwind");
+		appendChangedGraphStringFlag(flags, config, "ui", "typescript", "ui-library", config.uiLibrary, "shadcn-ui");
+		if (effectiveUiLibrary === "shadcn-ui") {
+			appendChangedStringFlag(flags, "shadcn-base", config.shadcnBase ?? "radix", "radix");
+			appendChangedStringFlag(flags, "shadcn-style", config.shadcnStyle ?? "nova", "nova");
+			appendChangedStringFlag(flags, "shadcn-icon-library", config.shadcnIconLibrary ?? "lucide", "lucide");
+			appendChangedStringFlag(flags, "shadcn-color-theme", config.shadcnColorTheme ?? "neutral", "neutral");
+			appendChangedStringFlag(flags, "shadcn-base-color", config.shadcnBaseColor ?? "neutral", "neutral");
+			appendChangedStringFlag(flags, "shadcn-font", config.shadcnFont ?? "inter", "inter");
+			appendChangedStringFlag(flags, "shadcn-radius", config.shadcnRadius ?? "default", "default");
+		}
+		appendChangedGraphStringFlag(flags, config, "stateManagement", "typescript", "state-management", config.stateManagement, "none");
+		appendChangedGraphStringFlag(flags, config, "forms", "typescript", "forms", config.forms, "react-hook-form");
+		appendChangedStringFlag(flags, "validation", config.validation, "zod");
+		appendChangedStringFlag(flags, "testing", config.testing, "vitest");
+		appendChangedGraphStringFlag(flags, config, "animation", "typescript", "animation", config.animation, "none");
+		appendChangedGraphStringFlag(flags, config, "fileUpload", "typescript", "file-upload", config.fileUpload, "none");
+		appendChangedGraphStringFlag(flags, config, "i18n", "typescript", "i18n", config.i18n, "none");
+		appendChangedGraphStringFlag(flags, config, "analytics", "typescript", "analytics", config.analytics, "none");
+	}
+	if (hasGraphPrimaryPart(config, "frontend", "typescript") || hasGraphPrimaryPart(config, "backend", "typescript")) {
+		if (hasGraphPrimaryPart(config, "backend", "typescript")) {
+			appendChangedOwnedGraphStringFlag(flags, config, "backend", "runtime", "typescript", "runtime", config.runtime, "bun");
+			appendChangedOwnedGraphStringFlag(flags, config, "backend", "deploy", "typescript", "server-deploy", config.serverDeploy, "none");
+		} else appendChangedStringFlag(flags, "server-deploy", config.serverDeploy, "none");
+		appendChangedGraphStringFlag(flags, config, "payments", "typescript", "payments", config.payments, "none");
+		appendChangedGraphStringFlag(flags, config, "email", "typescript", "email", config.email, "none");
+		appendChangedStringFlag(flags, "effect", config.effect, "none");
+		appendChangedGraphStringFlag(flags, config, "ai", "typescript", "ai", config.ai, "none");
+		appendChangedGraphStringFlag(flags, config, "realtime", "typescript", "realtime", config.realtime, "none");
+		appendChangedGraphStringFlag(flags, config, "jobQueue", "typescript", "job-queue", config.jobQueue, "none");
+		appendChangedGraphStringFlag(flags, config, "logging", "typescript", "logging", config.logging, "none");
+		appendChangedGraphStringFlag(flags, config, "observability", "typescript", "observability", config.observability, "none");
+		appendChangedGraphStringFlag(flags, config, "featureFlags", "typescript", "feature-flags", config.featureFlags, "none");
+		appendChangedGraphStringFlag(flags, config, "caching", "typescript", "caching", config.caching, "none");
+		appendChangedGraphStringFlag(flags, config, "rateLimit", "typescript", "rate-limit", config.rateLimit, "none");
+		appendChangedGraphStringFlag(flags, config, "cms", "typescript", "cms", config.cms, "none");
+		appendChangedGraphStringFlag(flags, config, "search", "typescript", "search", config.search, "none");
+		appendChangedGraphStringFlag(flags, config, "vectorDb", "typescript", "vectorDb", config.vectorDb, "none");
+		appendChangedGraphStringFlag(flags, config, "fileStorage", "typescript", "file-storage", config.fileStorage, "none");
+	}
+	if (hasGraphPrimaryPart(config, "mobile")) {
+		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "navigation", "react-native", "mobile-navigation", config.mobileNavigation, "expo-router");
+		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "ui", "react-native", "mobile-ui", config.mobileUI, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "storage", "react-native", "mobile-storage", config.mobileStorage, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "testing", "react-native", "mobile-testing", config.mobileTesting, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "push", "react-native", "mobile-push", config.mobilePush, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "ota", "react-native", "mobile-ota", config.mobileOTA, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "deepLinking", "react-native", "mobile-deep-linking", config.mobileDeepLinking, "none");
+	}
+	if (hasGraphPrimaryPart(config, "frontend", "rust")) appendChangedStringFlag(flags, "rust-frontend", config.rustFrontend, "none");
+	if (hasGraphPrimaryPart(config, "backend", "rust")) {
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "cli", "rust", "rust-cli", config.rustCli, "none");
+		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "libraries", "rust", "rust-libraries", config.rustLibraries, []);
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "logging", "rust", "rust-logging", config.rustLogging, "tracing");
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "errorHandling", "rust", "rust-error-handling", config.rustErrorHandling, "anyhow-thiserror");
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "caching", "rust", "rust-caching", config.rustCaching, "none");
+	}
+	if (hasGraphPrimaryPart(config, "backend", "python")) {
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "validation", "python", "python-validation", config.pythonValidation, "none");
+		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "ai", "python", "python-ai", config.pythonAi, []);
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "jobQueue", "python", "python-task-queue", config.pythonTaskQueue, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "api", "python", "python-graphql", config.pythonGraphql, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "codeQuality", "python", "python-quality", config.pythonQuality, "none");
+	}
+	if (hasGraphPrimaryPart(config, "backend", "go")) {
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "cli", "go", "go-cli", config.goCli, "none");
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "logging", "go", "go-logging", config.goLogging, "none");
+	}
+	if (hasGraphPrimaryPart(config, "backend", "java")) {
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "buildTool", "java", "java-build-tool", config.javaBuildTool, "maven");
+		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "libraries", "java", "java-libraries", config.javaLibraries, []);
+		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "testing", "java", "java-testing-libraries", config.javaTestingLibraries, ["junit5"]);
+	}
+	if (hasGraphPrimaryPart(config, "backend", "elixir")) {
+		appendChangedGraphStringFlag(flags, config, "realtime", "elixir", "elixir-realtime", config.elixirRealtime, "channels");
+		appendChangedGraphStringFlag(flags, config, "jobQueue", "elixir", "elixir-jobs", config.elixirJobs, "none");
+		appendChangedGraphStringFlag(flags, config, "validation", "elixir", "elixir-validation", config.elixirValidation, "ecto-changesets");
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "httpClient", "elixir", "elixir-http", config.elixirHttp, "req");
+		appendChangedStringFlag(flags, "elixir-json", config.elixirJson, "jason");
+		appendChangedGraphStringFlag(flags, config, "email", "elixir", "elixir-email", config.elixirEmail, "none");
+		appendChangedGraphStringFlag(flags, config, "caching", "elixir", "elixir-caching", config.elixirCaching, "none");
+		appendChangedGraphStringFlag(flags, config, "observability", "elixir", "elixir-observability", config.elixirObservability, "telemetry");
+		appendChangedGraphStringFlag(flags, config, "testing", "elixir", "elixir-testing", config.elixirTesting, "ex_unit");
+		appendChangedOwnedGraphStringFlag(flags, config, "backend", "codeQuality", "elixir", "elixir-quality", config.elixirQuality, "credo");
+		appendChangedGraphStringFlag(flags, config, "deploy", "elixir", "elixir-deploy", config.elixirDeploy, "none");
+	}
+}
+function appendSharedNonTypeScriptFlags(flags, config) {
+	flags.push(`--email ${config.email}`);
+	flags.push(`--observability ${config.observability}`);
+	flags.push(`--caching ${config.caching}`);
+	flags.push(`--search ${config.search}`);
+	flags.push(formatArrayFlag("addons", config.addons));
+	flags.push(formatArrayFlag("examples", config.examples));
+	flags.push(`--db-setup ${config.dbSetup}`);
+	flags.push(`--web-deploy ${config.webDeploy}`);
+	flags.push(`--server-deploy ${config.serverDeploy}`);
+}
+function getTypeScriptFlags(config) {
+	const flags = [];
+	if (config.frontend && config.frontend.length > 0) flags.push(`--frontend ${config.frontend.join(" ")}`);
+	else flags.push("--frontend none");
+	appendAstroIntegrationFlag(flags, config);
+	flags.push(`--backend ${config.backend}`);
+	flags.push(`--runtime ${config.runtime}`);
+	flags.push(`--database ${config.database}`);
+	flags.push(`--orm ${config.orm}`);
+	flags.push(`--api ${config.api}`);
+	flags.push(`--auth ${config.auth}`);
+	flags.push(`--payments ${config.payments}`);
+	flags.push(`--email ${config.email}`);
+	flags.push(`--file-upload ${config.fileUpload}`);
+	flags.push(`--effect ${config.effect}`);
+	flags.push(`--css-framework ${config.cssFramework}`);
+	flags.push(`--ui-library ${config.uiLibrary}`);
+	if (config.uiLibrary === "shadcn-ui") {
+		flags.push(`--shadcn-base ${config.shadcnBase}`);
+		flags.push(`--shadcn-style ${config.shadcnStyle}`);
+		flags.push(`--shadcn-icon-library ${config.shadcnIconLibrary}`);
+		flags.push(`--shadcn-color-theme ${config.shadcnColorTheme}`);
+		flags.push(`--shadcn-base-color ${config.shadcnBaseColor}`);
+		flags.push(`--shadcn-font ${config.shadcnFont}`);
+		flags.push(`--shadcn-radius ${config.shadcnRadius}`);
+	}
+	flags.push(`--ai ${config.ai}`);
+	flags.push(`--state-management ${config.stateManagement}`);
+	flags.push(`--forms ${config.forms}`);
+	flags.push(`--validation ${config.validation}`);
+	flags.push(`--testing ${config.testing}`);
+	flags.push(`--animation ${config.animation}`);
+	flags.push(`--realtime ${config.realtime}`);
+	flags.push(`--job-queue ${config.jobQueue}`);
+	flags.push(`--logging ${config.logging}`);
+	flags.push(`--observability ${config.observability}`);
+	flags.push(`--feature-flags ${config.featureFlags}`);
+	flags.push(`--caching ${config.caching}`);
+	flags.push(`--rate-limit ${config.rateLimit}`);
+	flags.push(`--i18n ${config.i18n}`);
+	flags.push(`--cms ${config.cms}`);
+	flags.push(`--search ${config.search}`);
+	flags.push(`--vector-db ${config.vectorDb}`);
+	flags.push(`--file-storage ${config.fileStorage}`);
+	flags.push(`--mobile-navigation ${config.mobileNavigation}`);
+	flags.push(`--mobile-ui ${config.mobileUI}`);
+	flags.push(`--mobile-storage ${config.mobileStorage}`);
+	flags.push(`--mobile-testing ${config.mobileTesting}`);
+	flags.push(`--mobile-push ${config.mobilePush}`);
+	flags.push(`--mobile-ota ${config.mobileOTA}`);
+	flags.push(`--mobile-deep-linking ${config.mobileDeepLinking}`);
+	if (config.addons && config.addons.length > 0) flags.push(`--addons ${config.addons.join(" ")}`);
+	else flags.push("--addons none");
+	if (config.examples && config.examples.length > 0) flags.push(`--examples ${config.examples.join(" ")}`);
+	else flags.push("--examples none");
+	flags.push(`--db-setup ${config.dbSetup}`);
+	flags.push(`--web-deploy ${config.webDeploy}`);
+	flags.push(`--server-deploy ${config.serverDeploy}`);
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function getReactNativeFlags(config) {
+	const flags = ["--ecosystem react-native"];
+	if (config.frontend && config.frontend.length > 0) flags.push(`--frontend ${config.frontend.join(" ")}`);
+	else flags.push("--frontend native-bare");
+	flags.push(`--auth ${config.auth}`);
+	flags.push(`--mobile-navigation ${config.mobileNavigation}`);
+	flags.push(`--mobile-ui ${config.mobileUI}`);
+	flags.push(`--mobile-storage ${config.mobileStorage}`);
+	flags.push(`--mobile-testing ${config.mobileTesting}`);
+	flags.push(`--mobile-push ${config.mobilePush}`);
+	flags.push(`--mobile-ota ${config.mobileOTA}`);
+	flags.push(`--mobile-deep-linking ${config.mobileDeepLinking}`);
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function getRustFlags(config) {
+	const flags = ["--ecosystem rust"];
+	flags.push(`--rust-web-framework ${config.rustWebFramework}`);
+	flags.push(`--rust-frontend ${config.rustFrontend}`);
+	flags.push(`--rust-orm ${config.rustOrm}`);
+	flags.push(`--rust-api ${config.rustApi}`);
+	flags.push(`--rust-cli ${config.rustCli}`);
+	flags.push(formatArrayFlag("rust-libraries", config.rustLibraries));
+	flags.push(`--rust-logging ${config.rustLogging}`);
+	flags.push(`--rust-error-handling ${config.rustErrorHandling}`);
+	flags.push(`--rust-caching ${config.rustCaching}`);
+	flags.push(`--rust-auth ${config.rustAuth}`);
+	flags.push(`--rust-realtime ${config.rustRealtime}`);
+	flags.push(`--rust-message-queue ${config.rustMessageQueue}`);
+	flags.push(`--rust-observability ${config.rustObservability}`);
+	flags.push(`--rust-templating ${config.rustTemplating}`);
+	appendSharedNonTypeScriptFlags(flags, config);
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function getPythonFlags(config) {
+	const flags = ["--ecosystem python"];
+	flags.push(`--python-web-framework ${config.pythonWebFramework}`);
+	flags.push(`--python-orm ${config.pythonOrm}`);
+	flags.push(`--python-validation ${config.pythonValidation}`);
+	flags.push(formatArrayFlag("python-ai", config.pythonAi));
+	flags.push(`--python-auth ${config.pythonAuth}`);
+	flags.push(`--python-api ${config.pythonApi}`);
+	flags.push(`--python-task-queue ${config.pythonTaskQueue}`);
+	flags.push(`--python-graphql ${config.pythonGraphql}`);
+	flags.push(`--python-quality ${config.pythonQuality}`);
+	flags.push(formatArrayFlag("python-testing", config.pythonTesting));
+	flags.push(`--python-caching ${config.pythonCaching}`);
+	flags.push(`--python-realtime ${config.pythonRealtime}`);
+	flags.push(`--python-observability ${config.pythonObservability}`);
+	flags.push(formatArrayFlag("python-cli", config.pythonCli));
+	appendSharedNonTypeScriptFlags(flags, config);
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function getGoFlags(config) {
+	const flags = ["--ecosystem go"];
+	flags.push(`--go-web-framework ${config.goWebFramework}`);
+	flags.push(`--go-orm ${config.goOrm}`);
+	flags.push(`--go-api ${config.goApi}`);
+	flags.push(`--go-cli ${config.goCli}`);
+	flags.push(`--go-logging ${config.goLogging}`);
+	flags.push(`--go-auth ${config.goAuth}`);
+	flags.push(formatArrayFlag("go-testing", config.goTesting));
+	flags.push(`--go-realtime ${config.goRealtime}`);
+	flags.push(`--go-message-queue ${config.goMessageQueue}`);
+	flags.push(`--go-caching ${config.goCaching}`);
+	flags.push(`--go-config ${config.goConfig}`);
+	flags.push(`--go-observability ${config.goObservability}`);
+	flags.push(`--auth ${config.auth}`);
+	appendSharedNonTypeScriptFlags(flags, config);
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function getJavaFlags(config) {
+	const flags = ["--ecosystem java"];
+	flags.push(`--java-web-framework ${config.javaWebFramework}`);
+	flags.push(`--java-build-tool ${config.javaBuildTool}`);
+	flags.push(`--java-orm ${config.javaOrm}`);
+	flags.push(`--java-auth ${config.javaAuth}`);
+	flags.push(`--java-api ${config.javaApi}`);
+	flags.push(`--java-logging ${config.javaLogging}`);
+	flags.push(formatArrayFlag("java-libraries", config.javaLibraries));
+	flags.push(formatArrayFlag("java-testing-libraries", config.javaTestingLibraries));
+	appendSharedNonTypeScriptFlags(flags, config);
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function getDotnetFlags(config) {
+	const flags = ["--ecosystem dotnet"];
+	flags.push(`--dotnet-web-framework ${config.dotnetWebFramework}`);
+	flags.push(`--dotnet-orm ${config.dotnetOrm}`);
+	flags.push(`--dotnet-auth ${config.dotnetAuth}`);
+	flags.push(`--dotnet-api ${config.dotnetApi}`);
+	flags.push(formatArrayFlag("dotnet-testing", config.dotnetTesting));
+	flags.push(`--dotnet-job-queue ${config.dotnetJobQueue}`);
+	flags.push(`--dotnet-realtime ${config.dotnetRealtime}`);
+	flags.push(formatArrayFlag("dotnet-observability", config.dotnetObservability));
+	flags.push(`--dotnet-validation ${config.dotnetValidation}`);
+	flags.push(`--dotnet-caching ${config.dotnetCaching}`);
+	flags.push(`--dotnet-deploy ${config.dotnetDeploy}`);
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function getElixirFlags(config) {
+	const flags = ["--ecosystem elixir"];
+	flags.push(`--elixir-web-framework ${config.elixirWebFramework}`);
+	flags.push(`--elixir-orm ${config.elixirOrm}`);
+	flags.push(`--elixir-auth ${config.elixirAuth}`);
+	flags.push(`--elixir-api ${config.elixirApi}`);
+	flags.push(`--elixir-realtime ${config.elixirRealtime}`);
+	flags.push(`--elixir-jobs ${config.elixirJobs}`);
+	flags.push(`--elixir-validation ${config.elixirValidation}`);
+	flags.push(`--elixir-http ${config.elixirHttp}`);
+	flags.push(`--elixir-json ${config.elixirJson}`);
+	flags.push(`--elixir-email ${config.elixirEmail}`);
+	flags.push(`--elixir-caching ${config.elixirCaching}`);
+	flags.push(`--elixir-observability ${config.elixirObservability}`);
+	flags.push(`--elixir-testing ${config.elixirTesting}`);
+	flags.push(`--elixir-quality ${config.elixirQuality}`);
+	flags.push(`--elixir-deploy ${config.elixirDeploy}`);
+	flags.push(formatArrayFlag("elixir-libraries", config.elixirLibraries));
+	appendCommonFlags(flags, config);
+	return flags;
+}
+function generateReproducibleCommand(config) {
+	let flags;
+	if (config.stackParts && config.stackParts.length > 0) {
+		flags = config.stackParts.filter((part) => part.source !== "provided" && part.toolId !== "none").map((part) => `--part ${(0, types_exports.formatStackPartSpec)(part, config.stackParts ?? [])}`);
+		appendGraphExtraFlags(flags, config);
+		appendCommonFlags(flags, config);
+		return `${getBaseCommand(config.packageManager)}${config.relativePath ? ` ${config.relativePath}` : ""} ${flags.join(" ")}`;
+	}
+	switch (config.ecosystem) {
+		case "react-native":
+			flags = getReactNativeFlags(config);
+			break;
+		case "rust":
+			flags = getRustFlags(config);
+			break;
+		case "python":
+			flags = getPythonFlags(config);
+			break;
+		case "go":
+			flags = getGoFlags(config);
+			break;
+		case "java":
+			flags = getJavaFlags(config);
+			break;
+		case "dotnet":
+			flags = getDotnetFlags(config);
+			break;
+		case "elixir":
+			flags = getElixirFlags(config);
+			break;
+		case "typescript":
+		default:
+			flags = getTypeScriptFlags(config);
+			break;
+	}
+	return `${getBaseCommand(config.packageManager)}${config.relativePath ? ` ${config.relativePath}` : ""} ${flags.join(" ")}`;
+}
+
+//#endregion
+//#region src/utils/templates.ts
+const TEMPLATE_PRESETS = {
+	mern: {
+		database: "mongodb",
+		orm: "mongoose",
+		backend: "express",
+		runtime: "node",
+		frontend: ["react-router"],
+		api: "orpc",
+		auth: "better-auth",
+		payments: "none",
+		addons: ["turborepo"],
+		examples: ["none"],
+		dbSetup: "mongodb-atlas",
+		webDeploy: "none",
+		serverDeploy: "none"
+	},
+	pern: {
+		database: "postgres",
+		orm: "drizzle",
+		backend: "express",
+		runtime: "node",
+		frontend: ["tanstack-router"],
+		api: "trpc",
+		auth: "better-auth",
+		payments: "none",
+		addons: ["turborepo"],
+		examples: ["none"],
+		dbSetup: "none",
+		webDeploy: "none",
+		serverDeploy: "none"
+	},
+	t3: {
+		database: "postgres",
+		orm: "prisma",
+		backend: "self",
+		runtime: "none",
+		frontend: ["next"],
+		api: "trpc",
+		auth: "better-auth",
+		payments: "none",
+		addons: ["biome", "turborepo"],
+		examples: ["none"],
+		dbSetup: "none",
+		webDeploy: "none",
+		serverDeploy: "none"
+	},
+	uniwind: {
+		database: "none",
+		orm: "none",
+		backend: "none",
+		runtime: "none",
+		frontend: ["native-uniwind"],
+		api: "none",
+		auth: "none",
+		payments: "none",
+		addons: ["none"],
+		examples: ["none"],
+		dbSetup: "none",
+		webDeploy: "none",
+		serverDeploy: "none"
+	},
+	none: null
+};
+function getTemplateConfig(template) {
+	if (template === "none" || !template) return null;
+	const config = TEMPLATE_PRESETS[template];
+	if (!config) throw new Error(`Unknown template: ${template}`);
+	return config;
+}
+function getTemplateDescription(template) {
+	return {
+		mern: "MongoDB + Express + React + Node.js - Classic MERN stack",
+		pern: "PostgreSQL + Express + React + Node.js - Popular PERN stack",
+		t3: "T3 Stack - Next.js + tRPC + Prisma + PostgreSQL + Better Auth",
+		uniwind: "Expo + Uniwind native app with no backend services",
+		none: "No template - Full customization"
+	}[template] || "";
+}
+
+//#endregion
+export { getTemplateDescription as n, generateReproducibleCommand as r, getTemplateConfig as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-fullstack",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "Scaffold production-ready fullstack apps in seconds. Pick your stack from 425 options — the CLI wires everything together.",
   "keywords": [
     "algolia",
@@ -128,8 +128,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@better-fullstack/template-generator": "^2.1.2",
-    "@better-fullstack/types": "^2.1.2",
+    "@better-fullstack/template-generator": "^2.1.4",
+    "@better-fullstack/types": "^2.1.4",
     "@clack/core": "^0.5.0",
     "@clack/prompts": "^1.6.0",
     "@orpc/server": "^1.14.6",

package/dist/add-handler-9F-AsGM-.mjs

@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-import { c as isSilent, g as updateBtsConfig, l as runWithContextAsync, m as readBtsConfig, n as UserCancelledError, t as CLIError, x as getDefaultConfig } from "./errors-D9yiiGVq.mjs";
-import { t as renderTitle } from "./render-title-zvyKC1ej.mjs";
-import { t as setupAddons } from "./addons-setup-C_xrNtkL.mjs";
-import "./compatibility-rules-D7zYNVjC.mjs";
-import { c as applyDependencyVersionChannel, t as installDependencies, u as getAddonsToAdd } from "./install-dependencies-DDGF-zDG.mjs";
-import { intro, log, outro } from "@clack/prompts";
-import pc from "picocolors";
-import fs from "fs-extra";
-import path from "node:path";
-import { EMBEDDED_TEMPLATES, VirtualFileSystem, processAddonTemplates, processAddonsDeps } from "@better-fullstack/template-generator";
-import { writeTreeToFilesystem } from "@better-fullstack/template-generator/fs-writer";
-
-//#region src/helpers/core/add-handler.ts
-async function addHandler(input, options = {}) {
-	const { silent = false } = options;
-	return runWithContextAsync({ silent }, async () => {
-		try {
-			return await addHandlerInternal(input);
-		} catch (error) {
-			if (error instanceof UserCancelledError) {
-				if (isSilent()) return {
-					success: false,
-					addedAddons: [],
-					projectDir: "",
-					error: error.message
-				};
-				return;
-			}
-			if (error instanceof CLIError) {
-				if (isSilent()) return {
-					success: false,
-					addedAddons: [],
-					projectDir: "",
-					error: error.message
-				};
-				throw error;
-			}
-			if (isSilent()) return {
-				success: false,
-				addedAddons: [],
-				projectDir: "",
-				error: error instanceof Error ? error.message : String(error)
-			};
-			throw error;
-		}
-	});
-}
-async function addHandlerInternal(input) {
-	const projectDir = path.resolve(input.projectDir || process.cwd());
-	if (!isSilent()) {
-		renderTitle();
-		intro(pc.magenta("Add addons to your Better Fullstack project"));
-	}
-	const btsConfig = await readBtsConfig(projectDir);
-	if (!btsConfig) throw new CLIError(`No Better Fullstack project found in ${projectDir}. Make sure bts.jsonc exists.`);
-	const projectName = path.basename(projectDir);
-	if (!isSilent()) log.info(pc.dim(`Detected project: ${projectName}`));
-	const existingAddons = btsConfig.addons || [];
-	let addonsToAdd = [];
-	if (input.addons && input.addons.length > 0) addonsToAdd = input.addons.filter((addon) => addon !== "none" && !existingAddons.includes(addon));
-	else addonsToAdd = (await getAddonsToAdd(btsConfig.frontend || [], existingAddons, btsConfig.auth)).filter((addon) => addon !== "none");
-	if (addonsToAdd.length === 0) {
-		if (!isSilent()) {
-			log.info(pc.dim("No new addons selected."));
-			outro(pc.magenta("Nothing to add."));
-		}
-		return {
-			success: true,
-			addedAddons: [],
-			projectDir
-		};
-	}
-	if (!isSilent()) log.info(pc.cyan(`Adding addons: ${addonsToAdd.join(", ")}`));
-	const baseConfig = getDefaultConfig();
-	const config = {
-		...baseConfig,
-		...btsConfig,
-		projectName,
-		projectDir,
-		relativePath: ".",
-		packageManager: input.packageManager || btsConfig.packageManager || baseConfig.packageManager,
-		addons: addonsToAdd,
-		frontend: btsConfig.frontend || baseConfig.frontend,
-		examples: btsConfig.examples || [],
-		rustLibraries: btsConfig.rustLibraries || [],
-		pythonAi: btsConfig.pythonAi || [],
-		aiDocs: btsConfig.aiDocs || []
-	};
-	const vfs = new VirtualFileSystem();
-	const packageJsonPaths = await collectPackageJsonPaths(projectDir);
-	for (const pkgPath of packageJsonPaths) {
-		const fullPath = path.join(projectDir, pkgPath);
-		const content = await fs.readFile(fullPath, "utf-8");
-		vfs.writeFile(pkgPath, content);
-	}
-	await processAddonTemplates(vfs, EMBEDDED_TEMPLATES, config);
-	processAddonsDeps(vfs, config);
-	await writeTreeToFilesystem({
-		root: vfs.toTree(projectName),
-		fileCount: vfs.getFileCount(),
-		directoryCount: vfs.getDirectoryCount(),
-		config
-	}, projectDir);
-	const setupWarnings = await setupAddons(config);
-	await applyDependencyVersionChannel(projectDir, config.versionChannel);
-	const configUpdates = { addons: [...new Set([...existingAddons, ...addonsToAdd])] };
-	if (input.webDeploy !== void 0) configUpdates.webDeploy = input.webDeploy;
-	if (input.serverDeploy !== void 0) configUpdates.serverDeploy = input.serverDeploy;
-	await updateBtsConfig(projectDir, configUpdates);
-	let addonInstallFailed = false;
-	if (input.install) addonInstallFailed = !(await installDependencies({
-		projectDir,
-		packageManager: config.packageManager
-	})).success;
-	if (!isSilent()) {
-		log.success(pc.green(`Successfully added: ${addonsToAdd.join(", ")}`));
-		for (const warning of setupWarnings) log.warn(pc.yellow(warning));
-		const installCmd = config.packageManager === "npm" ? "npm install" : `${config.packageManager} install`;
-		if (!input.install) log.info(pc.yellow(`Run '${installCmd}' to install new dependencies.`));
-		else if (addonInstallFailed) log.warn(pc.yellow(`Dependency installation failed. Run '${installCmd}' after resolving the error above.`));
-		outro(pc.magenta("Addons added successfully!"));
-	}
-	return {
-		success: true,
-		addedAddons: addonsToAdd,
-		projectDir,
-		setupWarnings: setupWarnings.length > 0 ? setupWarnings : void 0
-	};
-}
-async function collectPackageJsonPaths(projectDir) {
-	const results = [];
-	async function walk(currentDir) {
-		const entries = await fs.readdir(currentDir, { withFileTypes: true });
-		for (const entry of entries) {
-			if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".turbo") continue;
-			const fullPath = path.join(currentDir, entry.name);
-			if (entry.isDirectory()) {
-				await walk(fullPath);
-				continue;
-			}
-			if (entry.isFile() && entry.name === "package.json") results.push(path.relative(projectDir, fullPath).replaceAll(path.sep, "/"));
-		}
-	}
-	await walk(projectDir);
-	if (!results.includes("package.json") && await fs.pathExists(path.join(projectDir, "package.json"))) results.push("package.json");
-	return results;
-}
-
-//#endregion
-export { addHandler };