create-better-fullstack 1.8.1 → 2.0.1

package/README.md

@@ -43,13 +43,27 @@ Configure your stack visually — pick every option from a UI, preview your choi
 --yolo             # Scaffold a random stack — good for exploring
 --template <name>  # Use a preset (t3, mern, pern, uniwind)
 --ecosystem <lang> # Start in typescript, react-native, rust, python, go, java, or elixir mode
+--part <binding>   # Add a multi-ecosystem stack part, e.g. frontend:typescript:next
 --version-channel  # Dependency channel: stable, latest, beta
 --no-git           # Skip git initialization
 --no-install       # Skip dependency installation
+--verify           # Run generated project checks without starting dev servers
 --package-manager  # Package manager (bun, pnpm, npm, yarn)
 --verbose          # Show detailed output
 ```
 
+## Multi-Ecosystem Example
+
+Use repeated `--part` flags to bind each generated app or capability to an ecosystem:
+
+```bash
+bun create better-fullstack@latest my-mixed-app \
+  --part frontend:typescript:next \
+  --part backend:go:gin \
+  --part backend.orm:go:gorm \
+  --part database:universal:postgres
+```
+
 ## Links
 
 - [Website](https://better-fullstack.dev)

package/dist/addons-setup-CExVq7Mg.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./bts-config-CSvxsFML.mjs";
+import { i as setupLefthook, n as setupBiome, r as setupHusky, t as setupAddons } from "./addons-setup-DqVFXnDv.mjs";
+
+export { setupAddons };

package/dist/{addons-setup-CUmA_nra.mjs → addons-setup-DqVFXnDv.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { s as dependencyVersionMap, t as readBtsConfig } from "./bts-config-YcroedMK.mjs";
+import { m as dependencyVersionMap, t as readBtsConfig } from "./bts-config-CSvxsFML.mjs";
 import { autocompleteMultiselect, cancel, group, isCancel, log, multiselect, select, spinner } from "@clack/prompts";
 import pc from "picocolors";
 import fs from "fs-extra";

package/dist/bts-config-CSvxsFML.mjs

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+import { t as __reExport } from "./chunk-CCII7kTE.mjs";
+import fs from "fs-extra";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createCliDefaultProjectConfigBase } from "@better-fullstack/types";
+import { dependencyVersionMap } from "@better-fullstack/template-generator";
+import * as JSONC from "jsonc-parser";
+
+//#region src/utils/get-package-manager.ts
+const getUserPkgManager = () => {
+	const userAgent = process.env.npm_config_user_agent;
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("bun")) return "bun";
+	if (userAgent?.startsWith("yarn")) return "yarn";
+	return "npm";
+};
+
+//#endregion
+//#region src/constants.ts
+const __filename = fileURLToPath(import.meta.url);
+const distPath = path.dirname(__filename);
+const PKG_ROOT = path.join(distPath, "../");
+const DEFAULT_CONFIG_BASE = createCliDefaultProjectConfigBase(getUserPkgManager());
+function getDefaultConfig() {
+	return {
+		...DEFAULT_CONFIG_BASE,
+		projectDir: path.resolve(process.cwd(), DEFAULT_CONFIG_BASE.projectName),
+		packageManager: getUserPkgManager(),
+		frontend: [...DEFAULT_CONFIG_BASE.frontend],
+		addons: [...DEFAULT_CONFIG_BASE.addons],
+		examples: [...DEFAULT_CONFIG_BASE.examples],
+		rustLibraries: [...DEFAULT_CONFIG_BASE.rustLibraries],
+		pythonAi: [...DEFAULT_CONFIG_BASE.pythonAi],
+		javaLibraries: [...DEFAULT_CONFIG_BASE.javaLibraries],
+		javaTestingLibraries: [...DEFAULT_CONFIG_BASE.javaTestingLibraries],
+		aiDocs: [...DEFAULT_CONFIG_BASE.aiDocs]
+	};
+}
+const DEFAULT_CONFIG = getDefaultConfig();
+/**
+* Default UI library for each frontend framework
+* Falls back based on what's compatible
+*/
+const DEFAULT_UI_LIBRARY_BY_FRONTEND = {
+	"tanstack-router": "shadcn-ui",
+	"react-router": "shadcn-ui",
+	"react-vite": "shadcn-ui",
+	"tanstack-start": "shadcn-ui",
+	next: "shadcn-ui",
+	vinext: "shadcn-ui",
+	nuxt: "daisyui",
+	svelte: "daisyui",
+	solid: "daisyui",
+	"solid-start": "daisyui",
+	astro: "daisyui",
+	qwik: "daisyui",
+	angular: "daisyui",
+	redwood: "daisyui",
+	fresh: "daisyui",
+	"native-bare": "none",
+	"native-uniwind": "none",
+	"native-unistyles": "none",
+	none: "none"
+};
+
+//#endregion
+//#region src/utils/get-latest-cli-version.ts
+const getLatestCLIVersion = () => {
+	const packageJsonPath = path.join(PKG_ROOT, "package.json");
+	return fs.readJSONSync(packageJsonPath).version ?? "1.0.0";
+};
+
+//#endregion
+//#region src/types.ts
+var types_exports = {};
+import * as import__better_fullstack_types from "@better-fullstack/types";
+__reExport(types_exports, import__better_fullstack_types);
+
+//#endregion
+//#region src/utils/graph-summary.ts
+const FRONTEND_LABELS = {
+	next: "Next.js web app",
+	astro: "Astro web app",
+	"react-vite": "React + Vite app",
+	"react-router": "React Router app",
+	"tanstack-router": "TanStack Router app",
+	"tanstack-start": "TanStack Start app",
+	nuxt: "Nuxt app",
+	svelte: "SvelteKit app",
+	solid: "Solid app",
+	"solid-start": "SolidStart app",
+	qwik: "Qwik app",
+	angular: "Angular app",
+	redwood: "RedwoodJS app",
+	fresh: "Fresh app"
+};
+const BACKEND_LABELS = {
+	"rust:axum": "Rust Axum API",
+	"rust:actix-web": "Rust Actix Web API",
+	"rust:rocket": "Rust Rocket API",
+	"rust:warp": "Rust Warp API",
+	"rust:poem": "Rust Poem API",
+	"rust:salvo": "Rust Salvo API",
+	"python:fastapi": "Python FastAPI API",
+	"python:django": "Python Django API",
+	"python:flask": "Python Flask API",
+	"python:litestar": "Python Litestar API",
+	"go:gin": "Go Gin API",
+	"go:echo": "Go Echo API",
+	"go:fiber": "Go Fiber API",
+	"go:chi": "Go Chi API",
+	"java:spring-boot": "Java Spring Boot API",
+	"java:quarkus": "Java Quarkus API",
+	"elixir:phoenix": "Elixir Phoenix API",
+	"elixir:phoenix-live-view": "Elixir Phoenix LiveView API"
+};
+const TOOL_LABELS = {
+	postgres: "Postgres",
+	sqlite: "SQLite",
+	mysql: "MySQL",
+	mongodb: "MongoDB",
+	redis: "Redis",
+	edgedb: "EdgeDB",
+	gorm: "GORM",
+	sqlc: "sqlc",
+	ent: "Ent",
+	"ecto-sql": "Ecto SQL",
+	ecto: "Ecto",
+	sqlx: "SQLx",
+	"sea-orm": "SeaORM",
+	sqlalchemy: "SQLAlchemy",
+	sqlmodel: "SQLModel",
+	"django-orm": "Django ORM",
+	"spring-data-jpa": "Spring Data JPA"
+};
+function getSelectedGraphParts(config) {
+	return (config.stackParts ?? []).filter((part) => part.source !== "provided");
+}
+function getGraphPart(config, role, ecosystem) {
+	return getSelectedGraphParts(config).find((part) => part.role === role && (!ecosystem || part.ecosystem === ecosystem));
+}
+function hasGraphPart(config, role, ecosystem) {
+	return Boolean(getGraphPart(config, role, ecosystem));
+}
+function getPrimaryGraphPart(config, role, ecosystem) {
+	return getSelectedGraphParts(config).find((part) => part.role === role && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
+}
+function getGraphBackendUrl(config) {
+	switch (getPrimaryGraphPart(config, "backend")?.ecosystem) {
+		case "elixir": return "http://localhost:4000";
+		case "rust": return "http://localhost:3000";
+		case "python": return "http://localhost:8000";
+		case "go":
+		case "java": return "http://localhost:8080";
+		default: return null;
+	}
+}
+function getEffectiveStack(config) {
+	const effectiveStack = {};
+	const parts = getSelectedGraphParts(config);
+	for (const part of parts) {
+		const key = part.ownerPartId ? `backend.${part.role}` : part.role;
+		effectiveStack[key] = `${part.ecosystem}:${part.toolId}`;
+	}
+	return effectiveStack;
+}
+function labelFor(part) {
+	if (!part) return null;
+	if (part.role === "frontend" && part.ecosystem === "typescript") return FRONTEND_LABELS[part.toolId] ?? `${part.toolId} web app`;
+	if (part.role === "backend") return BACKEND_LABELS[`${part.ecosystem}:${part.toolId}`] ?? `${part.ecosystem} ${part.toolId} API`;
+	return TOOL_LABELS[part.toolId] ?? part.toolId;
+}
+function getGraphSummary(config) {
+	const selectedParts = getSelectedGraphParts(config);
+	if (selectedParts.length === 0) return null;
+	const frontend = getPrimaryGraphPart(config, "frontend");
+	const backend = getPrimaryGraphPart(config, "backend");
+	const database = getPrimaryGraphPart(config, "database");
+	const orm = selectedParts.find((part) => part.role === "orm");
+	const segments = [labelFor(frontend), labelFor(backend)].filter(Boolean);
+	const databaseLabel = backend?.ecosystem === "java" && orm?.toolId === "spring-data-jpa" ? "H2 dev database" : labelFor(database);
+	const dataLabel = [labelFor(orm), databaseLabel].filter(Boolean).join("/");
+	if (dataLabel) segments.push(dataLabel);
+	return segments.length > 0 ? segments.join(" + ") : selectedParts.map((part) => (0, types_exports.formatStackPartSpec)(part, selectedParts)).join(" + ");
+}
+function getGraphBackendDeployInstructions(config) {
+	const backend = getPrimaryGraphPart(config, "backend");
+	if (!backend || config.serverDeploy === "none") return "";
+	const targetPath = backend.targetPath ?? "apps/server";
+	const backendLabel = labelFor(backend) ?? `${backend.ecosystem}:${backend.toolId}`;
+	switch (config.serverDeploy) {
+		case "railway": return [
+			"Server deployment with Railway:",
+			`* Backend: ${backendLabel}`,
+			`* Config: ${targetPath}/railway.toml`,
+			`* Deploy: cd ${targetPath} && railway up`
+		].join("\n");
+		case "docker": return [
+			"Server deployment with Docker:",
+			`* Backend: ${backendLabel}`,
+			`* Build: cd ${targetPath} && docker build -t better-fullstack-server .`
+		].join("\n");
+		case "fly": return [
+			"Server deployment with Fly:",
+			`* Backend: ${backendLabel}`,
+			`* Deploy: cd ${targetPath} && fly launch`
+		].join("\n");
+		case "vercel": return [
+			"Server deployment with Vercel:",
+			`* Backend: ${backendLabel}`,
+			`* Deploy from: ${targetPath}`
+		].join("\n");
+		case "cloudflare":
+		case "sst": return [
+			`Server deployment with ${config.serverDeploy}:`,
+			`* Backend: ${backendLabel}`,
+			`* Review generated files in ${targetPath}`
+		].join("\n");
+		default: return "";
+	}
+}
+
+//#endregion
+//#region src/utils/bts-config.ts
+const BTS_CONFIG_FILE = "bts.jsonc";
+function normalizeGraphConfigForPersistence(projectConfig, stackParts) {
+	if (!stackParts) return projectConfig;
+	const legacyConfig = (0, types_exports.stackPartsToLegacyProjectConfigPartial)(stackParts);
+	const selectedEcosystems = new Set(stackParts.filter((part) => part.source !== "provided").map((part) => part.ecosystem));
+	const normalized = {
+		...projectConfig,
+		...legacyConfig
+	};
+	if (!selectedEcosystems.has("rust")) {
+		normalized.rustWebFramework = "none";
+		normalized.rustFrontend = "none";
+		normalized.rustOrm = "none";
+		normalized.rustApi = "none";
+		normalized.rustCli = "none";
+		normalized.rustLibraries = [];
+		normalized.rustLogging = "none";
+		normalized.rustErrorHandling = "none";
+		normalized.rustCaching = "none";
+		normalized.rustAuth = "none";
+	}
+	if (!selectedEcosystems.has("python")) {
+		normalized.pythonWebFramework = "none";
+		normalized.pythonOrm = "none";
+		normalized.pythonValidation = "none";
+		normalized.pythonAi = [];
+		normalized.pythonAuth = "none";
+		normalized.pythonApi = "none";
+		normalized.pythonTaskQueue = "none";
+		normalized.pythonGraphql = "none";
+		normalized.pythonQuality = "none";
+	}
+	if (!selectedEcosystems.has("go")) {
+		normalized.goWebFramework = "none";
+		normalized.goOrm = "none";
+		normalized.goApi = "none";
+		normalized.goCli = "none";
+		normalized.goLogging = "none";
+		normalized.goAuth = "none";
+	}
+	if (!selectedEcosystems.has("java")) {
+		normalized.javaWebFramework = "none";
+		normalized.javaBuildTool = "none";
+		normalized.javaOrm = "none";
+		normalized.javaAuth = "none";
+		normalized.javaLibraries = [];
+		normalized.javaTestingLibraries = [];
+	}
+	if (!selectedEcosystems.has("elixir")) {
+		normalized.elixirWebFramework = "none";
+		normalized.elixirOrm = "none";
+		normalized.elixirAuth = "none";
+		normalized.elixirApi = "none";
+		normalized.elixirRealtime = "none";
+		normalized.elixirJobs = "none";
+		normalized.elixirValidation = "none";
+		normalized.elixirHttp = "none";
+		normalized.elixirJson = "none";
+		normalized.elixirEmail = "none";
+		normalized.elixirCaching = "none";
+		normalized.elixirObservability = "none";
+		normalized.elixirTesting = "none";
+		normalized.elixirQuality = "none";
+		normalized.elixirDeploy = "none";
+	}
+	return normalized;
+}
+async function writeBtsConfig(projectConfig) {
+	const stackParts = projectConfig.stackParts ?? (0, types_exports.legacyProjectConfigToStackParts)(projectConfig);
+	const persistedConfig = normalizeGraphConfigForPersistence(projectConfig, projectConfig.stackParts);
+	const graphSummary = projectConfig.stackParts ? getGraphSummary({ stackParts }) : null;
+	const effectiveStack = projectConfig.stackParts ? getEffectiveStack({ stackParts }) : void 0;
+	const btsConfig = {
+		version: getLatestCLIVersion(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...graphSummary ? {
+			graphSummary,
+			effectiveStack
+		} : {},
+		ecosystem: persistedConfig.ecosystem,
+		database: persistedConfig.database,
+		orm: persistedConfig.orm,
+		backend: persistedConfig.backend,
+		runtime: persistedConfig.runtime,
+		frontend: persistedConfig.frontend,
+		addons: persistedConfig.addons,
+		examples: persistedConfig.examples,
+		auth: persistedConfig.auth,
+		payments: persistedConfig.payments,
+		email: persistedConfig.email,
+		fileUpload: persistedConfig.fileUpload,
+		effect: persistedConfig.effect,
+		ai: persistedConfig.ai,
+		stateManagement: persistedConfig.stateManagement,
+		validation: persistedConfig.validation,
+		forms: persistedConfig.forms,
+		testing: persistedConfig.testing,
+		packageManager: persistedConfig.packageManager,
+		versionChannel: persistedConfig.versionChannel,
+		dbSetup: persistedConfig.dbSetup,
+		api: persistedConfig.api,
+		webDeploy: persistedConfig.webDeploy,
+		serverDeploy: persistedConfig.serverDeploy,
+		cssFramework: persistedConfig.cssFramework,
+		uiLibrary: persistedConfig.uiLibrary,
+		realtime: persistedConfig.realtime,
+		jobQueue: persistedConfig.jobQueue,
+		animation: persistedConfig.animation,
+		logging: persistedConfig.logging,
+		observability: persistedConfig.observability,
+		featureFlags: persistedConfig.featureFlags,
+		analytics: persistedConfig.analytics,
+		mobileNavigation: persistedConfig.mobileNavigation,
+		mobileUI: persistedConfig.mobileUI,
+		mobileStorage: persistedConfig.mobileStorage,
+		mobileTesting: persistedConfig.mobileTesting,
+		mobilePush: persistedConfig.mobilePush,
+		mobileOTA: persistedConfig.mobileOTA,
+		mobileDeepLinking: persistedConfig.mobileDeepLinking,
+		cms: persistedConfig.cms,
+		caching: persistedConfig.caching,
+		i18n: persistedConfig.i18n,
+		search: persistedConfig.search,
+		fileStorage: persistedConfig.fileStorage,
+		rustWebFramework: persistedConfig.rustWebFramework,
+		rustFrontend: persistedConfig.rustFrontend,
+		rustOrm: persistedConfig.rustOrm,
+		rustApi: persistedConfig.rustApi,
+		rustCli: persistedConfig.rustCli,
+		rustLibraries: persistedConfig.rustLibraries,
+		rustLogging: persistedConfig.rustLogging,
+		rustErrorHandling: persistedConfig.rustErrorHandling,
+		rustCaching: persistedConfig.rustCaching,
+		rustAuth: persistedConfig.rustAuth,
+		pythonWebFramework: persistedConfig.pythonWebFramework,
+		pythonOrm: persistedConfig.pythonOrm,
+		pythonValidation: persistedConfig.pythonValidation,
+		pythonAi: persistedConfig.pythonAi,
+		pythonAuth: persistedConfig.pythonAuth,
+		pythonApi: persistedConfig.pythonApi,
+		pythonTaskQueue: persistedConfig.pythonTaskQueue,
+		pythonGraphql: persistedConfig.pythonGraphql,
+		pythonQuality: persistedConfig.pythonQuality,
+		goWebFramework: persistedConfig.goWebFramework,
+		goOrm: persistedConfig.goOrm,
+		goApi: persistedConfig.goApi,
+		goCli: persistedConfig.goCli,
+		goLogging: persistedConfig.goLogging,
+		goAuth: persistedConfig.goAuth,
+		javaWebFramework: persistedConfig.javaWebFramework,
+		javaBuildTool: persistedConfig.javaBuildTool,
+		javaOrm: persistedConfig.javaOrm,
+		javaAuth: persistedConfig.javaAuth,
+		javaLibraries: persistedConfig.javaLibraries,
+		javaTestingLibraries: persistedConfig.javaTestingLibraries,
+		elixirWebFramework: persistedConfig.elixirWebFramework,
+		elixirOrm: persistedConfig.elixirOrm,
+		elixirAuth: persistedConfig.elixirAuth,
+		elixirApi: persistedConfig.elixirApi,
+		elixirRealtime: persistedConfig.elixirRealtime,
+		elixirJobs: persistedConfig.elixirJobs,
+		elixirValidation: persistedConfig.elixirValidation,
+		elixirHttp: persistedConfig.elixirHttp,
+		elixirJson: persistedConfig.elixirJson,
+		elixirEmail: persistedConfig.elixirEmail,
+		elixirCaching: persistedConfig.elixirCaching,
+		elixirObservability: persistedConfig.elixirObservability,
+		elixirTesting: persistedConfig.elixirTesting,
+		elixirQuality: persistedConfig.elixirQuality,
+		elixirDeploy: persistedConfig.elixirDeploy,
+		aiDocs: persistedConfig.aiDocs,
+		stackParts
+	};
+	const baseContent = {
+		$schema: "https://better-fullstack-web.vercel.app/schema.json",
+		version: btsConfig.version,
+		createdAt: btsConfig.createdAt,
+		...btsConfig.graphSummary ? {
+			graphSummary: btsConfig.graphSummary,
+			effectiveStack: btsConfig.effectiveStack
+		} : {},
+		ecosystem: btsConfig.ecosystem,
+		database: btsConfig.database,
+		orm: btsConfig.orm,
+		backend: btsConfig.backend,
+		runtime: btsConfig.runtime,
+		frontend: btsConfig.frontend,
+		addons: btsConfig.addons,
+		examples: btsConfig.examples,
+		auth: btsConfig.auth,
+		payments: btsConfig.payments,
+		email: btsConfig.email,
+		fileUpload: btsConfig.fileUpload,
+		effect: btsConfig.effect,
+		ai: btsConfig.ai,
+		stateManagement: btsConfig.stateManagement,
+		validation: btsConfig.validation,
+		forms: btsConfig.forms,
+		testing: btsConfig.testing,
+		packageManager: btsConfig.packageManager,
+		versionChannel: btsConfig.versionChannel,
+		dbSetup: btsConfig.dbSetup,
+		api: btsConfig.api,
+		webDeploy: btsConfig.webDeploy,
+		serverDeploy: btsConfig.serverDeploy,
+		cssFramework: btsConfig.cssFramework,
+		uiLibrary: btsConfig.uiLibrary,
+		realtime: btsConfig.realtime,
+		jobQueue: btsConfig.jobQueue,
+		animation: btsConfig.animation,
+		logging: btsConfig.logging,
+		observability: btsConfig.observability,
+		featureFlags: btsConfig.featureFlags,
+		analytics: btsConfig.analytics,
+		mobileNavigation: btsConfig.mobileNavigation,
+		mobileUI: btsConfig.mobileUI,
+		mobileStorage: btsConfig.mobileStorage,
+		mobileTesting: btsConfig.mobileTesting,
+		mobilePush: btsConfig.mobilePush,
+		mobileOTA: btsConfig.mobileOTA,
+		mobileDeepLinking: btsConfig.mobileDeepLinking,
+		cms: btsConfig.cms,
+		caching: btsConfig.caching,
+		i18n: btsConfig.i18n,
+		search: btsConfig.search,
+		fileStorage: btsConfig.fileStorage,
+		rustWebFramework: btsConfig.rustWebFramework,
+		rustFrontend: btsConfig.rustFrontend,
+		rustOrm: btsConfig.rustOrm,
+		rustApi: btsConfig.rustApi,
+		rustCli: btsConfig.rustCli,
+		rustLibraries: btsConfig.rustLibraries,
+		rustLogging: btsConfig.rustLogging,
+		rustErrorHandling: btsConfig.rustErrorHandling,
+		rustCaching: btsConfig.rustCaching,
+		rustAuth: btsConfig.rustAuth,
+		pythonWebFramework: btsConfig.pythonWebFramework,
+		pythonOrm: btsConfig.pythonOrm,
+		pythonValidation: btsConfig.pythonValidation,
+		pythonAi: btsConfig.pythonAi,
+		pythonAuth: btsConfig.pythonAuth,
+		pythonApi: btsConfig.pythonApi ?? "none",
+		pythonTaskQueue: btsConfig.pythonTaskQueue,
+		pythonGraphql: btsConfig.pythonGraphql,
+		pythonQuality: btsConfig.pythonQuality,
+		goWebFramework: btsConfig.goWebFramework,
+		goOrm: btsConfig.goOrm,
+		goApi: btsConfig.goApi,
+		goCli: btsConfig.goCli,
+		goLogging: btsConfig.goLogging,
+		goAuth: btsConfig.goAuth,
+		javaWebFramework: btsConfig.javaWebFramework,
+		javaBuildTool: btsConfig.javaBuildTool,
+		javaOrm: btsConfig.javaOrm,
+		javaAuth: btsConfig.javaAuth,
+		javaLibraries: btsConfig.javaLibraries,
+		javaTestingLibraries: btsConfig.javaTestingLibraries,
+		elixirWebFramework: btsConfig.elixirWebFramework,
+		elixirOrm: btsConfig.elixirOrm,
+		elixirAuth: btsConfig.elixirAuth,
+		elixirApi: btsConfig.elixirApi,
+		elixirRealtime: btsConfig.elixirRealtime,
+		elixirJobs: btsConfig.elixirJobs,
+		elixirValidation: btsConfig.elixirValidation,
+		elixirHttp: btsConfig.elixirHttp,
+		elixirJson: btsConfig.elixirJson,
+		elixirEmail: btsConfig.elixirEmail,
+		elixirCaching: btsConfig.elixirCaching,
+		elixirObservability: btsConfig.elixirObservability,
+		elixirTesting: btsConfig.elixirTesting,
+		elixirQuality: btsConfig.elixirQuality,
+		elixirDeploy: btsConfig.elixirDeploy,
+		aiDocs: btsConfig.aiDocs,
+		stackParts: btsConfig.stackParts
+	};
+	let configContent = JSON.stringify(baseContent);
+	const formatResult = JSONC.format(configContent, void 0, {
+		tabSize: 2,
+		insertSpaces: true,
+		eol: "\n"
+	});
+	configContent = JSONC.applyEdits(configContent, formatResult);
+	const finalContent = `// Better Fullstack configuration file
+// safe to delete
+${graphSummary ? "// For multi-ecosystem projects, graphSummary/effectiveStack and stackParts are the source of truth.\n// Legacy fields such as backend/orm may stay as compatibility fallbacks.\n" : ""}
+
+${configContent}`;
+	const configPath = path.join(projectConfig.projectDir, BTS_CONFIG_FILE);
+	await fs.writeFile(configPath, finalContent, "utf-8");
+}
+async function readBtsConfig(projectDir) {
+	try {
+		const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+		if (!await fs.pathExists(configPath)) return null;
+		const configContent = await fs.readFile(configPath, "utf-8");
+		const errors = [];
+		const config = JSONC.parse(configContent, errors, {
+			allowTrailingComma: true,
+			disallowComments: false
+		});
+		if (errors.length > 0) {
+			console.warn("Warning: Found errors parsing bts.jsonc:", errors);
+			return null;
+		}
+		if (config.stackParts && config.stackParts.length > 0) {
+			const diagnostics = (0, types_exports.compareLegacyConfigToStackParts)(config, config.stackParts);
+			if (diagnostics.length > 0) console.warn(`Warning: bts.jsonc legacy fields differ from stackParts; using stackParts for ${diagnostics.map((diagnostic) => diagnostic.path).filter(Boolean).join(", ")}.`);
+			return {
+				...config,
+				...(0, types_exports.stackPartsToLegacyProjectConfigPartial)(config.stackParts),
+				stackParts: config.stackParts
+			};
+		}
+		return {
+			...config,
+			stackParts: (0, types_exports.legacyProjectConfigToStackParts)(config)
+		};
+	} catch {
+		return null;
+	}
+}
+async function updateBtsConfig(projectDir, updates) {
+	try {
+		const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+		if (!await fs.pathExists(configPath)) return;
+		let modifiedContent = await fs.readFile(configPath, "utf-8");
+		for (const [key, value] of Object.entries(updates)) {
+			const editResult = JSONC.modify(modifiedContent, [key], value, { formattingOptions: {
+				tabSize: 2,
+				insertSpaces: true,
+				eol: "\n"
+			} });
+			modifiedContent = JSONC.applyEdits(modifiedContent, editResult);
+		}
+		await fs.writeFile(configPath, modifiedContent, "utf-8");
+	} catch {}
+}
+
+//#endregion
+export { getGraphBackendUrl as a, getPrimaryGraphPart as c, getLatestCLIVersion as d, DEFAULT_CONFIG as f, getUserPkgManager as g, getDefaultConfig as h, getGraphBackendDeployInstructions as i, hasGraphPart as l, dependencyVersionMap as m, updateBtsConfig as n, getGraphPart as o, DEFAULT_UI_LIBRARY_BY_FRONTEND as p, writeBtsConfig as r, getGraphSummary as s, readBtsConfig as t, types_exports as u };

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 //#region src/cli.ts
-if (process.argv[2] === "mcp" && process.argv.length === 3) import("./mcp-DoPutOIG.mjs").then((m) => m.startMcpServer());
+if (process.argv[2] === "mcp" && process.argv.length === 3) import("./mcp-DfnYbMju.mjs").then((m) => m.startMcpServer());
 else import("./index.mjs").then((m) => m.createBtsCli().run());
 
 //#endregion