create-better-t-stack 2.32.2 → 2.33.1

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createBtsCli } from "./src-DVlkWMko.js";
+import { createBtsCli } from "./src-T8rBM5gC.js";
 
 //#region src/cli.ts
 createBtsCli().run();

package/dist/index.d.ts

@@ -56,7 +56,7 @@ declare const AddonsSchema: z.ZodEnum<{
   starlight: "starlight";
   biome: "biome";
   husky: "husky";
-  "vibe-rules": "vibe-rules";
+  ruler: "ruler";
   turborepo: "turborepo";
   fumadocs: "fumadocs";
   ultracite: "ultracite";
@@ -196,7 +196,7 @@ declare const router: trpcServer.TRPCBuiltRouter<{
       orm?: "none" | "drizzle" | "prisma" | "mongoose" | undefined;
       auth?: boolean | undefined;
       frontend?: ("none" | "tanstack-router" | "react-router" | "tanstack-start" | "next" | "nuxt" | "native-nativewind" | "native-unistyles" | "svelte" | "solid")[] | undefined;
-      addons?: ("none" | "pwa" | "tauri" | "starlight" | "biome" | "husky" | "vibe-rules" | "turborepo" | "fumadocs" | "ultracite" | "oxlint")[] | undefined;
+      addons?: ("none" | "pwa" | "tauri" | "starlight" | "biome" | "husky" | "ruler" | "turborepo" | "fumadocs" | "ultracite" | "oxlint")[] | undefined;
       examples?: ("none" | "todo" | "ai")[] | undefined;
       git?: boolean | undefined;
       packageManager?: "npm" | "pnpm" | "bun" | undefined;
@@ -215,7 +215,7 @@ declare const router: trpcServer.TRPCBuiltRouter<{
   }>;
   add: trpcServer.TRPCMutationProcedure<{
     input: [{
-      addons?: ("none" | "pwa" | "tauri" | "starlight" | "biome" | "husky" | "vibe-rules" | "turborepo" | "fumadocs" | "ultracite" | "oxlint")[] | undefined;
+      addons?: ("none" | "pwa" | "tauri" | "starlight" | "biome" | "husky" | "ruler" | "turborepo" | "fumadocs" | "ultracite" | "oxlint")[] | undefined;
       webDeploy?: "none" | "workers" | undefined;
       projectDir?: string | undefined;
       install?: boolean | undefined;

package/dist/index.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { builder, createBtsCli, docs, init, router, sponsors } from "./src-DVlkWMko.js";
+import { builder, createBtsCli, docs, init, router, sponsors } from "./src-T8rBM5gC.js";
 
 export { builder, createBtsCli, docs, init, router, sponsors };

package/dist/{src-DVlkWMko.js → src-T8rBM5gC.js}

@@ -10,9 +10,9 @@ import { fileURLToPath } from "node:url";
 import gradient from "gradient-string";
 import * as JSONC from "jsonc-parser";
 import { $, execa } from "execa";
+import { globby } from "globby";
 import handlebars from "handlebars";
 import { IndentationText, Node, Project, QuoteKind, SyntaxKind } from "ts-morph";
-import { globby } from "globby";
 import os from "node:os";
 
 //#region src/utils/get-package-manager.ts
@@ -136,7 +136,7 @@ const ADDON_COMPATIBILITY = {
 	turborepo: [],
 	starlight: [],
 	ultracite: [],
-	"vibe-rules": [],
+	"ruler": [],
 	oxlint: [],
 	fumadocs: [],
 	none: []
@@ -190,7 +190,7 @@ const AddonsSchema = z.enum([
 	"starlight",
 	"biome",
 	"husky",
-	"vibe-rules",
+	"ruler",
 	"turborepo",
 	"fumadocs",
 	"ultracite",
@@ -318,8 +318,8 @@ function getAddonDisplay(addon) {
 			label = "Ultracite";
 			hint = "Zero-config Biome preset with AI integration";
 			break;
-		case "vibe-rules":
-			label = "vibe-rules";
+		case "ruler":
+			label = "Ruler";
 			hint = "Install and apply BTS rules to editors";
 			break;
 		case "husky":
@@ -351,7 +351,7 @@ const ADDON_GROUPS = {
 		"ultracite"
 	],
 	Other: [
-		"vibe-rules",
+		"ruler",
 		"turborepo",
 		"pwa",
 		"tauri",
@@ -1942,373 +1942,143 @@ handlebars.registerHelper("or", (a, b) => a || b);
 handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
 
 //#endregion
-//#region src/helpers/setup/vibe-rules-setup.ts
-async function setupVibeRules(config) {
-	const { packageManager, projectDir } = config;
-	try {
-		log.info("Setting up vibe-rules...");
-		const rulesDir = path.join(projectDir, ".bts");
-		const ruleFile = path.join(rulesDir, "rules.md");
-		if (!await fs.pathExists(ruleFile)) {
-			const templatePath = path.join(PKG_ROOT, "templates", "addons", "vibe-rules", ".bts", "rules.md.hbs");
-			if (await fs.pathExists(templatePath)) {
-				await fs.ensureDir(rulesDir);
-				await processTemplate(templatePath, ruleFile, config);
-			} else {
-				log.error(pc.red("Rules template not found for vibe-rules addon"));
-				return;
+//#region src/helpers/project-generation/template-manager.ts
+async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true, ignorePatterns) {
+	const sourceFiles = await globby(sourcePattern, {
+		cwd: baseSourceDir,
+		dot: true,
+		onlyFiles: true,
+		absolute: false,
+		ignore: ignorePatterns
+	});
+	for (const relativeSrcPath of sourceFiles) {
+		const srcPath = path.join(baseSourceDir, relativeSrcPath);
+		let relativeDestPath = relativeSrcPath;
+		if (relativeSrcPath.endsWith(".hbs")) relativeDestPath = relativeSrcPath.slice(0, -4);
+		const basename = path.basename(relativeDestPath);
+		if (basename === "_gitignore") relativeDestPath = path.join(path.dirname(relativeDestPath), ".gitignore");
+		else if (basename === "_npmrc") relativeDestPath = path.join(path.dirname(relativeDestPath), ".npmrc");
+		const destPath = path.join(destDir, relativeDestPath);
+		await fs.ensureDir(path.dirname(destPath));
+		if (!overwrite && await fs.pathExists(destPath)) continue;
+		if (srcPath.endsWith(".hbs")) await processTemplate(srcPath, destPath, context);
+		else await fs.copy(srcPath, destPath, { overwrite: true });
+	}
+}
+async function copyBaseTemplate(projectDir, context) {
+	const templateDir = path.join(PKG_ROOT, "templates/base");
+	await processAndCopyFiles(["**/*"], templateDir, projectDir, context);
+}
+async function setupFrontendTemplates(projectDir, context) {
+	const hasReactWeb = context.frontend.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next"
+	].includes(f));
+	const hasNuxtWeb = context.frontend.includes("nuxt");
+	const hasSvelteWeb = context.frontend.includes("svelte");
+	const hasSolidWeb = context.frontend.includes("solid");
+	const hasNativeWind = context.frontend.includes("native-nativewind");
+	const hasUnistyles = context.frontend.includes("native-unistyles");
+	const isConvex = context.backend === "convex";
+	if (hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) {
+		const webAppDir = path.join(projectDir, "apps/web");
+		await fs.ensureDir(webAppDir);
+		if (hasReactWeb) {
+			const webBaseDir = path.join(PKG_ROOT, "templates/frontend/react/web-base");
+			if (await fs.pathExists(webBaseDir)) await processAndCopyFiles("**/*", webBaseDir, webAppDir, context);
+			const reactFramework = context.frontend.find((f) => [
+				"tanstack-router",
+				"react-router",
+				"tanstack-start",
+				"next"
+			].includes(f));
+			if (reactFramework) {
+				const frameworkSrcDir = path.join(PKG_ROOT, `templates/frontend/react/${reactFramework}`);
+				if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, webAppDir, context);
+				if (!isConvex && context.api !== "none") {
+					const apiWebBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/react/base`);
+					if (await fs.pathExists(apiWebBaseDir)) await processAndCopyFiles("**/*", apiWebBaseDir, webAppDir, context);
+				}
 			}
-		}
-		const EDITORS$1 = {
-			cursor: {
-				label: "Cursor",
-				hint: ".cursor/rules/*.mdc"
-			},
-			windsurf: {
-				label: "Windsurf",
-				hint: ".windsurfrules"
-			},
-			"claude-code": {
-				label: "Claude Code",
-				hint: "CLAUDE.md"
-			},
-			vscode: {
-				label: "VSCode",
-				hint: ".github/instructions/*.instructions.md"
-			},
-			gemini: {
-				label: "Gemini",
-				hint: "GEMINI.md"
-			},
-			codex: {
-				label: "Codex",
-				hint: "AGENTS.md"
-			},
-			clinerules: {
-				label: "Cline/Roo",
-				hint: ".clinerules/*.md"
-			},
-			roo: {
-				label: "Roo",
-				hint: ".clinerules/*.md"
-			},
-			zed: {
-				label: "Zed",
-				hint: ".rules/*.md"
-			},
-			unified: {
-				label: "Unified",
-				hint: ".rules/*.md"
+		} else if (hasNuxtWeb) {
+			const nuxtBaseDir = path.join(PKG_ROOT, "templates/frontend/nuxt");
+			if (await fs.pathExists(nuxtBaseDir)) await processAndCopyFiles("**/*", nuxtBaseDir, webAppDir, context);
+			if (!isConvex && context.api === "orpc") {
+				const apiWebNuxtDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/nuxt`);
+				if (await fs.pathExists(apiWebNuxtDir)) await processAndCopyFiles("**/*", apiWebNuxtDir, webAppDir, context);
 			}
-		};
-		const selectedEditors = await multiselect({
-			message: "Choose editors to install BTS rule",
-			options: Object.entries(EDITORS$1).map(([key, v]) => ({
-				value: key,
-				label: v.label,
-				hint: v.hint
-			})),
-			required: false
-		});
-		if (isCancel(selectedEditors)) return exitCancelled("Operation cancelled");
-		const editorsArg = selectedEditors.join(", ");
-		const s = spinner();
-		s.start("Saving and applying BTS rules...");
-		try {
-			const saveCmd = getPackageExecutionCommand(packageManager, `vibe-rules@latest save bts -f ${JSON.stringify(path.relative(projectDir, ruleFile))}`);
-			await execa(saveCmd, {
-				cwd: projectDir,
-				env: { CI: "true" },
-				shell: true
-			});
-			for (const editor of selectedEditors) {
-				const loadCmd = getPackageExecutionCommand(packageManager, `vibe-rules@latest load bts ${editor}`);
-				await execa(loadCmd, {
-					cwd: projectDir,
-					env: { CI: "true" },
-					shell: true
-				});
+		} else if (hasSvelteWeb) {
+			const svelteBaseDir = path.join(PKG_ROOT, "templates/frontend/svelte");
+			if (await fs.pathExists(svelteBaseDir)) await processAndCopyFiles("**/*", svelteBaseDir, webAppDir, context);
+			if (!isConvex && context.api === "orpc") {
+				const apiWebSvelteDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/svelte`);
+				if (await fs.pathExists(apiWebSvelteDir)) await processAndCopyFiles("**/*", apiWebSvelteDir, webAppDir, context);
+			}
+		} else if (hasSolidWeb) {
+			const solidBaseDir = path.join(PKG_ROOT, "templates/frontend/solid");
+			if (await fs.pathExists(solidBaseDir)) await processAndCopyFiles("**/*", solidBaseDir, webAppDir, context);
+			if (!isConvex && context.api === "orpc") {
+				const apiWebSolidDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/solid`);
+				if (await fs.pathExists(apiWebSolidDir)) await processAndCopyFiles("**/*", apiWebSolidDir, webAppDir, context);
 			}
-			s.stop(`Applied BTS rules to: ${editorsArg}`);
-		} catch (error) {
-			s.stop(pc.red("Failed to apply BTS rules"));
-			throw error;
 		}
-		try {
-			await fs.remove(rulesDir);
-		} catch (_) {}
-		log.success("vibe-rules setup successfully!");
-	} catch (error) {
-		log.error(pc.red("Failed to set up vibe-rules"));
-		if (error instanceof Error) console.error(pc.red(error.message));
 	}
-}
-
-//#endregion
-//#region src/utils/ts-morph.ts
-const tsProject = new Project({
-	useInMemoryFileSystem: false,
-	skipAddingFilesFromTsConfig: true,
-	manipulationSettings: {
-		quoteKind: QuoteKind.Single,
-		indentationText: IndentationText.TwoSpaces
+	if (hasNativeWind || hasUnistyles) {
+		const nativeAppDir = path.join(projectDir, "apps/native");
+		await fs.ensureDir(nativeAppDir);
+		const nativeBaseCommonDir = path.join(PKG_ROOT, "templates/frontend/native/native-base");
+		if (await fs.pathExists(nativeBaseCommonDir)) await processAndCopyFiles("**/*", nativeBaseCommonDir, nativeAppDir, context);
+		let nativeFrameworkPath = "";
+		if (hasNativeWind) nativeFrameworkPath = "nativewind";
+		else if (hasUnistyles) nativeFrameworkPath = "unistyles";
+		const nativeSpecificDir = path.join(PKG_ROOT, `templates/frontend/native/${nativeFrameworkPath}`);
+		if (await fs.pathExists(nativeSpecificDir)) await processAndCopyFiles("**/*", nativeSpecificDir, nativeAppDir, context, true);
+		if (!isConvex && (context.api === "trpc" || context.api === "orpc")) {
+			const apiNativeSrcDir = path.join(PKG_ROOT, `templates/api/${context.api}/native`);
+			if (await fs.pathExists(apiNativeSrcDir)) await processAndCopyFiles("**/*", apiNativeSrcDir, nativeAppDir, context);
+		}
 	}
-});
-function ensureArrayProperty(obj, name) {
-	return obj.getProperty(name)?.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression) ?? obj.addPropertyAssignment({
-		name,
-		initializer: "[]"
-	}).getFirstDescendantByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-}
-
-//#endregion
-//#region src/helpers/setup/vite-pwa-setup.ts
-async function addPwaToViteConfig(viteConfigPath, projectName) {
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
-	if (!sourceFile) throw new Error("vite config not found");
-	const hasImport = sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "vite-plugin-pwa");
-	if (!hasImport) sourceFile.insertImportDeclaration(0, {
-		namedImports: ["VitePWA"],
-		moduleSpecifier: "vite-plugin-pwa"
-	});
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
-	});
-	if (!defineCall) throw new Error("Could not find defineConfig call in vite config");
-	const callExpr = defineCall;
-	const configObject = callExpr.getArguments()[0];
-	if (!configObject) throw new Error("defineConfig argument is not an object literal");
-	const pluginsArray = ensureArrayProperty(configObject, "plugins");
-	const alreadyPresent = pluginsArray.getElements().some((el) => el.getText().startsWith("VitePWA("));
-	if (!alreadyPresent) pluginsArray.addElement(`VitePWA({
-  registerType: "autoUpdate",
-  manifest: {
-    name: "${projectName}",
-    short_name: "${projectName}",
-    description: "${projectName} - PWA Application",
-    theme_color: "#0c0c0c",
-  },
-  pwaAssets: { disabled: false, config: true },
-  devOptions: { enabled: true },
-})`);
-	await tsProject.save();
 }
-
-//#endregion
-//#region src/helpers/setup/addons-setup.ts
-async function setupAddons(config, isAddCommand = false) {
-	const { addons, frontend, projectDir, packageManager } = config;
-	const hasReactWebFrontend = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next");
-	const hasNuxtFrontend = frontend.includes("nuxt");
-	const hasSvelteFrontend = frontend.includes("svelte");
-	const hasSolidFrontend = frontend.includes("solid");
-	const hasNextFrontend = frontend.includes("next");
-	if (addons.includes("turborepo")) {
-		await addPackageDependency({
-			devDependencies: ["turbo"],
-			projectDir
-		});
-		if (isAddCommand) log.info(`${pc.yellow("Update your package.json scripts:")}
-
-${pc.dim("Replace:")} ${pc.yellow("\"pnpm -r dev\"")} ${pc.dim("→")} ${pc.green("\"turbo dev\"")}
-${pc.dim("Replace:")} ${pc.yellow("\"pnpm --filter web dev\"")} ${pc.dim("→")} ${pc.green("\"turbo -F web dev\"")}
-
-${pc.cyan("Docs:")} ${pc.underline("https://turborepo.com/docs")}
-		`);
+async function setupBackendFramework(projectDir, context) {
+	if (context.backend === "none") return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	if (context.backend === "convex") {
+		if (await fs.pathExists(serverAppDir)) await fs.remove(serverAppDir);
+		const convexBackendDestDir = path.join(projectDir, "packages/backend");
+		const convexSrcDir = path.join(PKG_ROOT, "templates/backend/convex/packages/backend");
+		await fs.ensureDir(convexBackendDestDir);
+		if (await fs.pathExists(convexSrcDir)) await processAndCopyFiles("**/*", convexSrcDir, convexBackendDestDir, context);
+		return;
 	}
-	if (addons.includes("pwa") && (hasReactWebFrontend || hasSolidFrontend)) await setupPwa(projectDir, frontend);
-	if (addons.includes("tauri") && (hasReactWebFrontend || hasNuxtFrontend || hasSvelteFrontend || hasSolidFrontend || hasNextFrontend)) await setupTauri(config);
-	const hasUltracite = addons.includes("ultracite");
-	const hasBiome = addons.includes("biome");
-	const hasHusky = addons.includes("husky");
-	const hasOxlint = addons.includes("oxlint");
-	if (hasUltracite) await setupUltracite(config, hasHusky);
-	else {
-		if (hasBiome) await setupBiome(projectDir);
-		if (hasHusky) {
-			let linter;
-			if (hasOxlint) linter = "oxlint";
-			else if (hasBiome) linter = "biome";
-			await setupHusky(projectDir, linter);
-		}
+	await fs.ensureDir(serverAppDir);
+	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/server/server-base");
+	if (await fs.pathExists(serverBaseDir)) await processAndCopyFiles("**/*", serverBaseDir, serverAppDir, context);
+	const frameworkSrcDir = path.join(PKG_ROOT, `templates/backend/server/${context.backend}`);
+	if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, serverAppDir, context, true);
+	if (context.api !== "none") {
+		const apiServerBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/base`);
+		if (await fs.pathExists(apiServerBaseDir)) await processAndCopyFiles("**/*", apiServerBaseDir, serverAppDir, context, true);
+		const apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/${context.backend}`);
+		if (await fs.pathExists(apiServerFrameworkDir)) await processAndCopyFiles("**/*", apiServerFrameworkDir, serverAppDir, context, true);
 	}
-	if (addons.includes("oxlint")) await setupOxlint(projectDir, packageManager);
-	if (addons.includes("starlight")) await setupStarlight(config);
-	if (addons.includes("vibe-rules")) await setupVibeRules(config);
-	if (addons.includes("fumadocs")) await setupFumadocs(config);
 }
-function getWebAppDir(projectDir, frontends) {
-	if (frontends.some((f) => [
-		"react-router",
-		"tanstack-router",
-		"nuxt",
-		"svelte",
-		"solid"
-	].includes(f))) return path.join(projectDir, "apps/web");
-	return path.join(projectDir, "apps/web");
+async function setupDbOrmTemplates(projectDir, context) {
+	if (context.backend === "convex" || context.orm === "none" || context.database === "none") return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	await fs.ensureDir(serverAppDir);
+	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
+	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, serverAppDir, context);
 }
-async function setupBiome(projectDir) {
-	await addPackageDependency({
-		devDependencies: ["@biomejs/biome"],
-		projectDir
-	});
-	const packageJsonPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			check: "biome check --write ."
-		};
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-}
-async function setupHusky(projectDir, linter) {
-	await addPackageDependency({
-		devDependencies: ["husky", "lint-staged"],
-		projectDir
-	});
-	const packageJsonPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			prepare: "husky"
-		};
-		if (linter === "oxlint") packageJson["lint-staged"] = { "**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,vue,astro,svelte}": "oxlint" };
-		else if (linter === "biome") packageJson["lint-staged"] = { "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."] };
-		else packageJson["lint-staged"] = { "**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,vue,astro,svelte}": "" };
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-}
-async function setupPwa(projectDir, frontends) {
-	const isCompatibleFrontend = frontends.some((f) => [
-		"react-router",
-		"tanstack-router",
-		"solid"
-	].includes(f));
-	if (!isCompatibleFrontend) return;
-	const clientPackageDir = getWebAppDir(projectDir, frontends);
-	if (!await fs.pathExists(clientPackageDir)) return;
-	await addPackageDependency({
-		dependencies: ["vite-plugin-pwa"],
-		devDependencies: ["@vite-pwa/assets-generator"],
-		projectDir: clientPackageDir
-	});
-	const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
-	if (await fs.pathExists(clientPackageJsonPath)) {
-		const packageJson = await fs.readJson(clientPackageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			"generate-pwa-assets": "pwa-assets-generator"
-		};
-		await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
-	}
-	const viteConfigTs = path.join(clientPackageDir, "vite.config.ts");
-	if (await fs.pathExists(viteConfigTs)) await addPwaToViteConfig(viteConfigTs, path.basename(projectDir));
-}
-async function setupOxlint(projectDir, packageManager) {
-	await addPackageDependency({
-		devDependencies: ["oxlint"],
-		projectDir
-	});
-	const packageJsonPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			check: "oxlint"
-		};
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-	const oxlintInitCommand = getPackageExecutionCommand(packageManager, "oxlint@latest --init");
-	await execa(oxlintInitCommand, {
-		cwd: projectDir,
-		env: { CI: "true" },
-		shell: true
-	});
-}
-
-//#endregion
-//#region src/helpers/project-generation/detect-project-config.ts
-async function detectProjectConfig(projectDir) {
-	try {
-		const btsConfig = await readBtsConfig(projectDir);
-		if (btsConfig) return {
-			projectDir,
-			projectName: path.basename(projectDir),
-			database: btsConfig.database,
-			orm: btsConfig.orm,
-			backend: btsConfig.backend,
-			runtime: btsConfig.runtime,
-			frontend: btsConfig.frontend,
-			addons: btsConfig.addons,
-			examples: btsConfig.examples,
-			auth: btsConfig.auth,
-			packageManager: btsConfig.packageManager,
-			dbSetup: btsConfig.dbSetup,
-			api: btsConfig.api,
-			webDeploy: btsConfig.webDeploy
-		};
-		return null;
-	} catch (_error) {
-		return null;
-	}
-}
-async function isBetterTStackProject(projectDir) {
-	try {
-		return await fs.pathExists(path.join(projectDir, "bts.jsonc"));
-	} catch (_error) {
-		return false;
-	}
-}
-
-//#endregion
-//#region src/helpers/project-generation/install-dependencies.ts
-async function installDependencies({ projectDir, packageManager }) {
-	const s = spinner();
-	try {
-		s.start(`Running ${packageManager} install...`);
-		await $({
-			cwd: projectDir,
-			stderr: "inherit"
-		})`${packageManager} install`;
-		s.stop("Dependencies installed successfully");
-	} catch (error) {
-		s.stop(pc.red("Failed to install dependencies"));
-		if (error instanceof Error) consola.error(pc.red(`Installation error: ${error.message}`));
-	}
-}
-
-//#endregion
-//#region src/helpers/project-generation/template-manager.ts
-async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true, ignorePatterns) {
-	const sourceFiles = await globby(sourcePattern, {
-		cwd: baseSourceDir,
-		dot: true,
-		onlyFiles: true,
-		absolute: false,
-		ignore: ignorePatterns
-	});
-	for (const relativeSrcPath of sourceFiles) {
-		const srcPath = path.join(baseSourceDir, relativeSrcPath);
-		let relativeDestPath = relativeSrcPath;
-		if (relativeSrcPath.endsWith(".hbs")) relativeDestPath = relativeSrcPath.slice(0, -4);
-		const basename = path.basename(relativeDestPath);
-		if (basename === "_gitignore") relativeDestPath = path.join(path.dirname(relativeDestPath), ".gitignore");
-		else if (basename === "_npmrc") relativeDestPath = path.join(path.dirname(relativeDestPath), ".npmrc");
-		const destPath = path.join(destDir, relativeDestPath);
-		await fs.ensureDir(path.dirname(destPath));
-		if (!overwrite && await fs.pathExists(destPath)) continue;
-		if (srcPath.endsWith(".hbs")) await processTemplate(srcPath, destPath, context);
-		else await fs.copy(srcPath, destPath, { overwrite: true });
-	}
-}
-async function copyBaseTemplate(projectDir, context) {
-	const templateDir = path.join(PKG_ROOT, "templates/base");
-	await processAndCopyFiles(["**/*"], templateDir, projectDir, context);
-}
-async function setupFrontendTemplates(projectDir, context) {
+async function setupAuthTemplate(projectDir, context) {
+	if (context.backend === "convex" || !context.auth) return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	const webAppDir = path.join(projectDir, "apps/web");
+	const nativeAppDir = path.join(projectDir, "apps/native");
+	const serverAppDirExists = await fs.pathExists(serverAppDir);
+	const webAppDirExists = await fs.pathExists(webAppDir);
+	const nativeAppDirExists = await fs.pathExists(nativeAppDir);
 	const hasReactWeb = context.frontend.some((f) => [
 		"tanstack-router",
 		"react-router",
@@ -2320,13 +2090,29 @@ async function setupFrontendTemplates(projectDir, context) {
 	const hasSolidWeb = context.frontend.includes("solid");
 	const hasNativeWind = context.frontend.includes("native-nativewind");
 	const hasUnistyles = context.frontend.includes("native-unistyles");
-	const isConvex = context.backend === "convex";
-	if (hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) {
-		const webAppDir = path.join(projectDir, "apps/web");
-		await fs.ensureDir(webAppDir);
+	const hasNative = hasNativeWind || hasUnistyles;
+	if (serverAppDirExists) {
+		const authServerBaseSrc = path.join(PKG_ROOT, "templates/auth/server/base");
+		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, serverAppDir, context);
+		if (context.backend === "next") {
+			const authServerNextSrc = path.join(PKG_ROOT, "templates/auth/server/next");
+			if (await fs.pathExists(authServerNextSrc)) await processAndCopyFiles("**/*", authServerNextSrc, serverAppDir, context);
+		}
+		if (context.orm !== "none" && context.database !== "none") {
+			const orm = context.orm;
+			const db = context.database;
+			let authDbSrc = "";
+			if (orm === "drizzle") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/drizzle/${db}`);
+			else if (orm === "prisma") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/prisma/${db}`);
+			else if (orm === "mongoose") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/mongoose/${db}`);
+			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, serverAppDir, context);
+			else if (authDbSrc) {}
+		}
+	}
+	if ((hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) && webAppDirExists) {
 		if (hasReactWeb) {
-			const webBaseDir = path.join(PKG_ROOT, "templates/frontend/react/web-base");
-			if (await fs.pathExists(webBaseDir)) await processAndCopyFiles("**/*", webBaseDir, webAppDir, context);
+			const authWebBaseSrc = path.join(PKG_ROOT, "templates/auth/web/react/base");
+			if (await fs.pathExists(authWebBaseSrc)) await processAndCopyFiles("**/*", authWebBaseSrc, webAppDir, context);
 			const reactFramework = context.frontend.find((f) => [
 				"tanstack-router",
 				"react-router",
@@ -2334,154 +2120,29 @@ async function setupFrontendTemplates(projectDir, context) {
 				"next"
 			].includes(f));
 			if (reactFramework) {
-				const frameworkSrcDir = path.join(PKG_ROOT, `templates/frontend/react/${reactFramework}`);
-				if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, webAppDir, context);
-				if (!isConvex && context.api !== "none") {
-					const apiWebBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/react/base`);
-					if (await fs.pathExists(apiWebBaseDir)) await processAndCopyFiles("**/*", apiWebBaseDir, webAppDir, context);
-				}
+				const authWebFrameworkSrc = path.join(PKG_ROOT, `templates/auth/web/react/${reactFramework}`);
+				if (await fs.pathExists(authWebFrameworkSrc)) await processAndCopyFiles("**/*", authWebFrameworkSrc, webAppDir, context);
 			}
 		} else if (hasNuxtWeb) {
-			const nuxtBaseDir = path.join(PKG_ROOT, "templates/frontend/nuxt");
-			if (await fs.pathExists(nuxtBaseDir)) await processAndCopyFiles("**/*", nuxtBaseDir, webAppDir, context);
-			if (!isConvex && context.api === "orpc") {
-				const apiWebNuxtDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/nuxt`);
-				if (await fs.pathExists(apiWebNuxtDir)) await processAndCopyFiles("**/*", apiWebNuxtDir, webAppDir, context);
-			}
+			const authWebNuxtSrc = path.join(PKG_ROOT, "templates/auth/web/nuxt");
+			if (await fs.pathExists(authWebNuxtSrc)) await processAndCopyFiles("**/*", authWebNuxtSrc, webAppDir, context);
 		} else if (hasSvelteWeb) {
-			const svelteBaseDir = path.join(PKG_ROOT, "templates/frontend/svelte");
-			if (await fs.pathExists(svelteBaseDir)) await processAndCopyFiles("**/*", svelteBaseDir, webAppDir, context);
-			if (!isConvex && context.api === "orpc") {
-				const apiWebSvelteDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/svelte`);
-				if (await fs.pathExists(apiWebSvelteDir)) await processAndCopyFiles("**/*", apiWebSvelteDir, webAppDir, context);
-			}
+			const authWebSvelteSrc = path.join(PKG_ROOT, "templates/auth/web/svelte");
+			if (await fs.pathExists(authWebSvelteSrc)) await processAndCopyFiles("**/*", authWebSvelteSrc, webAppDir, context);
 		} else if (hasSolidWeb) {
-			const solidBaseDir = path.join(PKG_ROOT, "templates/frontend/solid");
-			if (await fs.pathExists(solidBaseDir)) await processAndCopyFiles("**/*", solidBaseDir, webAppDir, context);
-			if (!isConvex && context.api === "orpc") {
-				const apiWebSolidDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/solid`);
-				if (await fs.pathExists(apiWebSolidDir)) await processAndCopyFiles("**/*", apiWebSolidDir, webAppDir, context);
-			}
+			const authWebSolidSrc = path.join(PKG_ROOT, "templates/auth/web/solid");
+			if (await fs.pathExists(authWebSolidSrc)) await processAndCopyFiles("**/*", authWebSolidSrc, webAppDir, context);
 		}
 	}
-	if (hasNativeWind || hasUnistyles) {
-		const nativeAppDir = path.join(projectDir, "apps/native");
-		await fs.ensureDir(nativeAppDir);
-		const nativeBaseCommonDir = path.join(PKG_ROOT, "templates/frontend/native/native-base");
-		if (await fs.pathExists(nativeBaseCommonDir)) await processAndCopyFiles("**/*", nativeBaseCommonDir, nativeAppDir, context);
-		let nativeFrameworkPath = "";
-		if (hasNativeWind) nativeFrameworkPath = "nativewind";
-		else if (hasUnistyles) nativeFrameworkPath = "unistyles";
-		const nativeSpecificDir = path.join(PKG_ROOT, `templates/frontend/native/${nativeFrameworkPath}`);
-		if (await fs.pathExists(nativeSpecificDir)) await processAndCopyFiles("**/*", nativeSpecificDir, nativeAppDir, context, true);
-		if (!isConvex && (context.api === "trpc" || context.api === "orpc")) {
-			const apiNativeSrcDir = path.join(PKG_ROOT, `templates/api/${context.api}/native`);
-			if (await fs.pathExists(apiNativeSrcDir)) await processAndCopyFiles("**/*", apiNativeSrcDir, nativeAppDir, context);
-		}
-	}
-}
-async function setupBackendFramework(projectDir, context) {
-	if (context.backend === "none") return;
-	const serverAppDir = path.join(projectDir, "apps/server");
-	if (context.backend === "convex") {
-		if (await fs.pathExists(serverAppDir)) await fs.remove(serverAppDir);
-		const convexBackendDestDir = path.join(projectDir, "packages/backend");
-		const convexSrcDir = path.join(PKG_ROOT, "templates/backend/convex/packages/backend");
-		await fs.ensureDir(convexBackendDestDir);
-		if (await fs.pathExists(convexSrcDir)) await processAndCopyFiles("**/*", convexSrcDir, convexBackendDestDir, context);
-		return;
-	}
-	await fs.ensureDir(serverAppDir);
-	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/server/server-base");
-	if (await fs.pathExists(serverBaseDir)) await processAndCopyFiles("**/*", serverBaseDir, serverAppDir, context);
-	const frameworkSrcDir = path.join(PKG_ROOT, `templates/backend/server/${context.backend}`);
-	if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, serverAppDir, context, true);
-	if (context.api !== "none") {
-		const apiServerBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/base`);
-		if (await fs.pathExists(apiServerBaseDir)) await processAndCopyFiles("**/*", apiServerBaseDir, serverAppDir, context, true);
-		const apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/${context.backend}`);
-		if (await fs.pathExists(apiServerFrameworkDir)) await processAndCopyFiles("**/*", apiServerFrameworkDir, serverAppDir, context, true);
-	}
-}
-async function setupDbOrmTemplates(projectDir, context) {
-	if (context.backend === "convex" || context.orm === "none" || context.database === "none") return;
-	const serverAppDir = path.join(projectDir, "apps/server");
-	await fs.ensureDir(serverAppDir);
-	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
-	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, serverAppDir, context);
-}
-async function setupAuthTemplate(projectDir, context) {
-	if (context.backend === "convex" || !context.auth) return;
-	const serverAppDir = path.join(projectDir, "apps/server");
-	const webAppDir = path.join(projectDir, "apps/web");
-	const nativeAppDir = path.join(projectDir, "apps/native");
-	const serverAppDirExists = await fs.pathExists(serverAppDir);
-	const webAppDirExists = await fs.pathExists(webAppDir);
-	const nativeAppDirExists = await fs.pathExists(nativeAppDir);
-	const hasReactWeb = context.frontend.some((f) => [
-		"tanstack-router",
-		"react-router",
-		"tanstack-start",
-		"next"
-	].includes(f));
-	const hasNuxtWeb = context.frontend.includes("nuxt");
-	const hasSvelteWeb = context.frontend.includes("svelte");
-	const hasSolidWeb = context.frontend.includes("solid");
-	const hasNativeWind = context.frontend.includes("native-nativewind");
-	const hasUnistyles = context.frontend.includes("native-unistyles");
-	const hasNative = hasNativeWind || hasUnistyles;
-	if (serverAppDirExists) {
-		const authServerBaseSrc = path.join(PKG_ROOT, "templates/auth/server/base");
-		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, serverAppDir, context);
-		if (context.backend === "next") {
-			const authServerNextSrc = path.join(PKG_ROOT, "templates/auth/server/next");
-			if (await fs.pathExists(authServerNextSrc)) await processAndCopyFiles("**/*", authServerNextSrc, serverAppDir, context);
-		}
-		if (context.orm !== "none" && context.database !== "none") {
-			const orm = context.orm;
-			const db = context.database;
-			let authDbSrc = "";
-			if (orm === "drizzle") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/drizzle/${db}`);
-			else if (orm === "prisma") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/prisma/${db}`);
-			else if (orm === "mongoose") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/mongoose/${db}`);
-			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, serverAppDir, context);
-			else if (authDbSrc) {}
-		}
-	}
-	if ((hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) && webAppDirExists) {
-		if (hasReactWeb) {
-			const authWebBaseSrc = path.join(PKG_ROOT, "templates/auth/web/react/base");
-			if (await fs.pathExists(authWebBaseSrc)) await processAndCopyFiles("**/*", authWebBaseSrc, webAppDir, context);
-			const reactFramework = context.frontend.find((f) => [
-				"tanstack-router",
-				"react-router",
-				"tanstack-start",
-				"next"
-			].includes(f));
-			if (reactFramework) {
-				const authWebFrameworkSrc = path.join(PKG_ROOT, `templates/auth/web/react/${reactFramework}`);
-				if (await fs.pathExists(authWebFrameworkSrc)) await processAndCopyFiles("**/*", authWebFrameworkSrc, webAppDir, context);
-			}
-		} else if (hasNuxtWeb) {
-			const authWebNuxtSrc = path.join(PKG_ROOT, "templates/auth/web/nuxt");
-			if (await fs.pathExists(authWebNuxtSrc)) await processAndCopyFiles("**/*", authWebNuxtSrc, webAppDir, context);
-		} else if (hasSvelteWeb) {
-			const authWebSvelteSrc = path.join(PKG_ROOT, "templates/auth/web/svelte");
-			if (await fs.pathExists(authWebSvelteSrc)) await processAndCopyFiles("**/*", authWebSvelteSrc, webAppDir, context);
-		} else if (hasSolidWeb) {
-			const authWebSolidSrc = path.join(PKG_ROOT, "templates/auth/web/solid");
-			if (await fs.pathExists(authWebSolidSrc)) await processAndCopyFiles("**/*", authWebSolidSrc, webAppDir, context);
-		}
-	}
-	if (hasNative && nativeAppDirExists) {
-		const authNativeBaseSrc = path.join(PKG_ROOT, "templates/auth/native/native-base");
-		if (await fs.pathExists(authNativeBaseSrc)) await processAndCopyFiles("**/*", authNativeBaseSrc, nativeAppDir, context);
-		let nativeFrameworkAuthPath = "";
-		if (hasNativeWind) nativeFrameworkAuthPath = "nativewind";
-		else if (hasUnistyles) nativeFrameworkAuthPath = "unistyles";
-		if (nativeFrameworkAuthPath) {
-			const authNativeFrameworkSrc = path.join(PKG_ROOT, `templates/auth/native/${nativeFrameworkAuthPath}`);
-			if (await fs.pathExists(authNativeFrameworkSrc)) await processAndCopyFiles("**/*", authNativeFrameworkSrc, nativeAppDir, context);
+	if (hasNative && nativeAppDirExists) {
+		const authNativeBaseSrc = path.join(PKG_ROOT, "templates/auth/native/native-base");
+		if (await fs.pathExists(authNativeBaseSrc)) await processAndCopyFiles("**/*", authNativeBaseSrc, nativeAppDir, context);
+		let nativeFrameworkAuthPath = "";
+		if (hasNativeWind) nativeFrameworkAuthPath = "nativewind";
+		else if (hasUnistyles) nativeFrameworkAuthPath = "unistyles";
+		if (nativeFrameworkAuthPath) {
+			const authNativeFrameworkSrc = path.join(PKG_ROOT, `templates/auth/native/${nativeFrameworkAuthPath}`);
+			if (await fs.pathExists(authNativeFrameworkSrc)) await processAndCopyFiles("**/*", authNativeFrameworkSrc, nativeAppDir, context);
 		}
 	}
 }
@@ -2489,7 +2150,7 @@ async function setupAddonsTemplate(projectDir, context) {
 	if (!context.addons || context.addons.length === 0) return;
 	for (const addon of context.addons) {
 		if (addon === "none") continue;
-		if (addon === "vibe-rules") continue;
+		if (addon === "ruler") continue;
 		let addonSrcDir = path.join(PKG_ROOT, `templates/addons/${addon}`);
 		let addonDestDir = projectDir;
 		if (addon === "pwa") {
@@ -2630,6 +2291,324 @@ async function setupDeploymentTemplates(projectDir, context) {
 	}
 }
 
+//#endregion
+//#region src/helpers/setup/ruler-setup.ts
+async function setupVibeRules(config) {
+	const { packageManager, projectDir } = config;
+	try {
+		log.info("Setting up Ruler...");
+		const rulerDir = path.join(projectDir, ".ruler");
+		const rulerTemplateDir = path.join(PKG_ROOT, "templates", "addons", "ruler", ".ruler");
+		if (!await fs.pathExists(rulerDir)) if (await fs.pathExists(rulerTemplateDir)) await processAndCopyFiles("**/*", rulerTemplateDir, rulerDir, config);
+		else {
+			log.error(pc.red("Ruler template directory not found"));
+			return;
+		}
+		const EDITORS$1 = {
+			cursor: { label: "Cursor" },
+			windsurf: { label: "Windsurf" },
+			claude: { label: "Claude Code" },
+			copilot: { label: "GitHub Copilot" },
+			"gemini-cli": { label: "Gemini CLI" },
+			codex: { label: "OpenAI Codex CLI" },
+			jules: { label: "Jules" },
+			cline: { label: "Cline" },
+			aider: { label: "Aider" },
+			firebase: { label: "Firebase Studio" },
+			openhands: { label: "Open Hands" },
+			junie: { label: "Junie" },
+			augmentcode: { label: "AugmentCode" },
+			kilocode: { label: "Kilo Code" },
+			opencode: { label: "OpenCode" }
+		};
+		const selectedEditors = await multiselect({
+			message: "Select AI assistants for Ruler",
+			options: Object.entries(EDITORS$1).map(([key, v]) => ({
+				value: key,
+				label: v.label
+			})),
+			required: false
+		});
+		if (isCancel(selectedEditors)) return exitCancelled("Operation cancelled");
+		if (selectedEditors.length === 0) {
+			log.info("No AI assistants selected. To apply rules later, run:");
+			log.info(pc.cyan(`${getPackageExecutionCommand(packageManager, "@intellectronica/ruler@latest apply --local-only")}`));
+			return;
+		}
+		const configFile = path.join(rulerDir, "ruler.toml");
+		const currentConfig = await fs.readFile(configFile, "utf-8");
+		let updatedConfig = currentConfig;
+		const defaultAgentsLine = `default_agents = [${selectedEditors.map((editor) => `"${editor}"`).join(", ")}]`;
+		updatedConfig = updatedConfig.replace(/default_agents = \[\]/, defaultAgentsLine);
+		await fs.writeFile(configFile, updatedConfig);
+		await addRulerScriptToPackageJson(projectDir, packageManager);
+		const s = spinner();
+		s.start("Applying rules with Ruler...");
+		try {
+			const rulerApplyCmd = getPackageExecutionCommand(packageManager, `@intellectronica/ruler@latest apply --agents ${selectedEditors.join(",")} --local-only`);
+			await execa(rulerApplyCmd, {
+				cwd: projectDir,
+				env: { CI: "true" },
+				shell: true
+			});
+			s.stop("Applied rules with Ruler");
+		} catch (_error) {
+			s.stop(pc.red("Failed to apply rules"));
+		}
+	} catch (error) {
+		log.error(pc.red("Failed to set up Ruler"));
+		if (error instanceof Error) console.error(pc.red(error.message));
+	}
+}
+async function addRulerScriptToPackageJson(projectDir, packageManager) {
+	const rootPackageJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(rootPackageJsonPath)) {
+		log.warn("Root package.json not found, skipping ruler:apply script addition");
+		return;
+	}
+	const packageJson = await fs.readJson(rootPackageJsonPath);
+	if (!packageJson.scripts) packageJson.scripts = {};
+	const rulerApplyCommand = getPackageExecutionCommand(packageManager, "@intellectronica/ruler@latest apply --local-only");
+	packageJson.scripts["ruler:apply"] = rulerApplyCommand;
+	await fs.writeJson(rootPackageJsonPath, packageJson, { spaces: 2 });
+}
+
+//#endregion
+//#region src/utils/ts-morph.ts
+const tsProject = new Project({
+	useInMemoryFileSystem: false,
+	skipAddingFilesFromTsConfig: true,
+	manipulationSettings: {
+		quoteKind: QuoteKind.Single,
+		indentationText: IndentationText.TwoSpaces
+	}
+});
+function ensureArrayProperty(obj, name) {
+	return obj.getProperty(name)?.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression) ?? obj.addPropertyAssignment({
+		name,
+		initializer: "[]"
+	}).getFirstDescendantByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+}
+
+//#endregion
+//#region src/helpers/setup/vite-pwa-setup.ts
+async function addPwaToViteConfig(viteConfigPath, projectName) {
+	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
+	if (!sourceFile) throw new Error("vite config not found");
+	const hasImport = sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "vite-plugin-pwa");
+	if (!hasImport) sourceFile.insertImportDeclaration(0, {
+		namedImports: ["VitePWA"],
+		moduleSpecifier: "vite-plugin-pwa"
+	});
+	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
+		const expression = expr.getExpression();
+		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
+	});
+	if (!defineCall) throw new Error("Could not find defineConfig call in vite config");
+	const callExpr = defineCall;
+	const configObject = callExpr.getArguments()[0];
+	if (!configObject) throw new Error("defineConfig argument is not an object literal");
+	const pluginsArray = ensureArrayProperty(configObject, "plugins");
+	const alreadyPresent = pluginsArray.getElements().some((el) => el.getText().startsWith("VitePWA("));
+	if (!alreadyPresent) pluginsArray.addElement(`VitePWA({
+  registerType: "autoUpdate",
+  manifest: {
+    name: "${projectName}",
+    short_name: "${projectName}",
+    description: "${projectName} - PWA Application",
+    theme_color: "#0c0c0c",
+  },
+  pwaAssets: { disabled: false, config: true },
+  devOptions: { enabled: true },
+})`);
+	await tsProject.save();
+}
+
+//#endregion
+//#region src/helpers/setup/addons-setup.ts
+async function setupAddons(config, isAddCommand = false) {
+	const { addons, frontend, projectDir, packageManager } = config;
+	const hasReactWebFrontend = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next");
+	const hasNuxtFrontend = frontend.includes("nuxt");
+	const hasSvelteFrontend = frontend.includes("svelte");
+	const hasSolidFrontend = frontend.includes("solid");
+	const hasNextFrontend = frontend.includes("next");
+	if (addons.includes("turborepo")) {
+		await addPackageDependency({
+			devDependencies: ["turbo"],
+			projectDir
+		});
+		if (isAddCommand) log.info(`${pc.yellow("Update your package.json scripts:")}
+
+${pc.dim("Replace:")} ${pc.yellow("\"pnpm -r dev\"")} ${pc.dim("→")} ${pc.green("\"turbo dev\"")}
+${pc.dim("Replace:")} ${pc.yellow("\"pnpm --filter web dev\"")} ${pc.dim("→")} ${pc.green("\"turbo -F web dev\"")}
+
+${pc.cyan("Docs:")} ${pc.underline("https://turborepo.com/docs")}
+		`);
+	}
+	if (addons.includes("pwa") && (hasReactWebFrontend || hasSolidFrontend)) await setupPwa(projectDir, frontend);
+	if (addons.includes("tauri") && (hasReactWebFrontend || hasNuxtFrontend || hasSvelteFrontend || hasSolidFrontend || hasNextFrontend)) await setupTauri(config);
+	const hasUltracite = addons.includes("ultracite");
+	const hasBiome = addons.includes("biome");
+	const hasHusky = addons.includes("husky");
+	const hasOxlint = addons.includes("oxlint");
+	if (hasUltracite) await setupUltracite(config, hasHusky);
+	else {
+		if (hasBiome) await setupBiome(projectDir);
+		if (hasHusky) {
+			let linter;
+			if (hasOxlint) linter = "oxlint";
+			else if (hasBiome) linter = "biome";
+			await setupHusky(projectDir, linter);
+		}
+	}
+	if (addons.includes("oxlint")) await setupOxlint(projectDir, packageManager);
+	if (addons.includes("starlight")) await setupStarlight(config);
+	if (addons.includes("ruler")) await setupVibeRules(config);
+	if (addons.includes("fumadocs")) await setupFumadocs(config);
+}
+function getWebAppDir(projectDir, frontends) {
+	if (frontends.some((f) => [
+		"react-router",
+		"tanstack-router",
+		"nuxt",
+		"svelte",
+		"solid"
+	].includes(f))) return path.join(projectDir, "apps/web");
+	return path.join(projectDir, "apps/web");
+}
+async function setupBiome(projectDir) {
+	await addPackageDependency({
+		devDependencies: ["@biomejs/biome"],
+		projectDir
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			check: "biome check --write ."
+		};
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+}
+async function setupHusky(projectDir, linter) {
+	await addPackageDependency({
+		devDependencies: ["husky", "lint-staged"],
+		projectDir
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			prepare: "husky"
+		};
+		if (linter === "oxlint") packageJson["lint-staged"] = { "**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,vue,astro,svelte}": "oxlint" };
+		else if (linter === "biome") packageJson["lint-staged"] = { "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."] };
+		else packageJson["lint-staged"] = { "**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,vue,astro,svelte}": "" };
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+}
+async function setupPwa(projectDir, frontends) {
+	const isCompatibleFrontend = frontends.some((f) => [
+		"react-router",
+		"tanstack-router",
+		"solid"
+	].includes(f));
+	if (!isCompatibleFrontend) return;
+	const clientPackageDir = getWebAppDir(projectDir, frontends);
+	if (!await fs.pathExists(clientPackageDir)) return;
+	await addPackageDependency({
+		dependencies: ["vite-plugin-pwa"],
+		devDependencies: ["@vite-pwa/assets-generator"],
+		projectDir: clientPackageDir
+	});
+	const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
+	if (await fs.pathExists(clientPackageJsonPath)) {
+		const packageJson = await fs.readJson(clientPackageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			"generate-pwa-assets": "pwa-assets-generator"
+		};
+		await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
+	}
+	const viteConfigTs = path.join(clientPackageDir, "vite.config.ts");
+	if (await fs.pathExists(viteConfigTs)) await addPwaToViteConfig(viteConfigTs, path.basename(projectDir));
+}
+async function setupOxlint(projectDir, packageManager) {
+	await addPackageDependency({
+		devDependencies: ["oxlint"],
+		projectDir
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			check: "oxlint"
+		};
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+	const oxlintInitCommand = getPackageExecutionCommand(packageManager, "oxlint@latest --init");
+	await execa(oxlintInitCommand, {
+		cwd: projectDir,
+		env: { CI: "true" },
+		shell: true
+	});
+}
+
+//#endregion
+//#region src/helpers/project-generation/detect-project-config.ts
+async function detectProjectConfig(projectDir) {
+	try {
+		const btsConfig = await readBtsConfig(projectDir);
+		if (btsConfig) return {
+			projectDir,
+			projectName: path.basename(projectDir),
+			database: btsConfig.database,
+			orm: btsConfig.orm,
+			backend: btsConfig.backend,
+			runtime: btsConfig.runtime,
+			frontend: btsConfig.frontend,
+			addons: btsConfig.addons,
+			examples: btsConfig.examples,
+			auth: btsConfig.auth,
+			packageManager: btsConfig.packageManager,
+			dbSetup: btsConfig.dbSetup,
+			api: btsConfig.api,
+			webDeploy: btsConfig.webDeploy
+		};
+		return null;
+	} catch (_error) {
+		return null;
+	}
+}
+async function isBetterTStackProject(projectDir) {
+	try {
+		return await fs.pathExists(path.join(projectDir, "bts.jsonc"));
+	} catch (_error) {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/helpers/project-generation/install-dependencies.ts
+async function installDependencies({ projectDir, packageManager }) {
+	const s = spinner();
+	try {
+		s.start(`Running ${packageManager} install...`);
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`${packageManager} install`;
+		s.stop("Dependencies installed successfully");
+	} catch (error) {
+		s.stop(pc.red("Failed to install dependencies"));
+		if (error instanceof Error) consola.error(pc.red(`Installation error: ${error.message}`));
+	}
+}
+
 //#endregion
 //#region src/helpers/project-generation/add-addons.ts
 async function addAddonsToProject(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "2.32.2",
+  "version": "2.33.1",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "type": "module",
   "license": "MIT",

package/templates/addons/vibe-rules/{.bts/rules.md.hbs → .ruler/bts.md.hbs}

@@ -106,7 +106,7 @@ add
 Available addons you can add:
 - **Documentation**: Starlight, Fumadocs
 - **Linting**: Biome, Oxlint, Ultracite
-- **Other**: vibe-rules, Turborepo, PWA, Tauri, Husky
+- **Other**: Ruler, Turborepo, PWA, Tauri, Husky
 
 You can also add web deployment configurations like Cloudflare Workers support.
 

package/templates/addons/vibe-rules/.ruler/mcp.json.hbs

@@ -0,0 +1,18 @@
+{
+  "mcpServers": {
+    "context7": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    }{{#if (or (eq runtime "workers") (eq webDeploy "workers"))}},
+    "cloudflare": {
+			"command": "npx",
+			"args": ["mcp-remote", "https://docs.mcp.cloudflare.com/sse"]
+    }{{/if}}{{#if (eq backend "convex")}},
+    "convex": {
+      "command": "npx",
+      "args": ["-y", "convex@latest", "mcp", "start"]
+    }
+    {{/if}}
+  }
+}

package/templates/addons/vibe-rules/.ruler/ruler.toml.hbs

@@ -0,0 +1,5 @@
+# Ruler Configuration File
+# See https://okigu.com/ruler for documentation.
+
+# Default agents to run when --agents is not specified
+default_agents = []