create-better-fullstack 1.5.1 → 1.5.3

package/dist/addons-setup-Bll5VFJd.mjs

@@ -0,0 +1,1373 @@
+#!/usr/bin/env node
+import { s as dependencyVersionMap, t as readBtsConfig } from "./bts-config-BYD8mHt-.mjs";
+import { autocompleteMultiselect, cancel, group, isCancel, log, multiselect, select, spinner } from "@clack/prompts";
+import pc from "picocolors";
+import fs from "fs-extra";
+import path from "node:path";
+import { getLocalWebDevPort } from "@better-fullstack/types";
+import consola, { consola as consola$1 } from "consola";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { $ } from "execa";
+
+//#region src/utils/context.ts
+const cliStorage = new AsyncLocalStorage();
+function defaultContext() {
+	return {
+		navigation: {
+			isFirstPrompt: false,
+			lastPromptShownUI: false
+		},
+		silent: false,
+		verbose: false
+	};
+}
+function getContext() {
+	const ctx = cliStorage.getStore();
+	if (!ctx) return defaultContext();
+	return ctx;
+}
+function tryGetContext() {
+	return cliStorage.getStore();
+}
+function isSilent() {
+	return getContext().silent;
+}
+function isFirstPrompt() {
+	return getContext().navigation.isFirstPrompt;
+}
+function didLastPromptShowUI() {
+	return getContext().navigation.lastPromptShownUI;
+}
+function setIsFirstPrompt(value) {
+	const ctx = tryGetContext();
+	if (ctx) ctx.navigation.isFirstPrompt = value;
+}
+function setLastPromptShownUI(value) {
+	const ctx = tryGetContext();
+	if (ctx) ctx.navigation.lastPromptShownUI = value;
+}
+async function runWithContextAsync(options, fn) {
+	const ctx = {
+		navigation: {
+			isFirstPrompt: false,
+			lastPromptShownUI: false
+		},
+		silent: options.silent ?? false,
+		verbose: options.verbose ?? false,
+		projectDir: options.projectDir,
+		projectName: options.projectName,
+		packageManager: options.packageManager
+	};
+	return cliStorage.run(ctx, fn);
+}
+
+//#endregion
+//#region src/utils/errors.ts
+var UserCancelledError = class extends Error {
+	constructor(message = "Operation cancelled") {
+		super(message);
+		this.name = "UserCancelledError";
+	}
+};
+var CLIError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CLIError";
+	}
+};
+function exitWithError(message) {
+	if (isSilent()) throw new CLIError(message);
+	consola.error(pc.red(message));
+	process.exit(1);
+}
+function exitCancelled(message = "Operation cancelled") {
+	if (isSilent()) throw new UserCancelledError(message);
+	cancel(pc.red(message));
+	process.exit(1);
+}
+function handleError(error, fallbackMessage) {
+	const message = error instanceof Error ? error.message : fallbackMessage || String(error);
+	if (isSilent()) throw error instanceof Error ? error : new Error(message);
+	consola.error(pc.red(message));
+	process.exit(1);
+}
+
+//#endregion
+//#region src/utils/add-package-deps.ts
+const addPackageDependency = async (opts) => {
+	const { dependencies = [], devDependencies = [], customDependencies = {}, customDevDependencies = {}, projectDir } = opts;
+	const pkgJsonPath = path.join(projectDir, "package.json");
+	const pkgJson = await fs.readJson(pkgJsonPath);
+	if (!pkgJson.dependencies) pkgJson.dependencies = {};
+	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
+	for (const pkgName of dependencies) {
+		const version = dependencyVersionMap[pkgName];
+		if (version) pkgJson.dependencies[pkgName] = version;
+		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
+	}
+	for (const pkgName of devDependencies) {
+		const version = dependencyVersionMap[pkgName];
+		if (version) pkgJson.devDependencies[pkgName] = version;
+		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
+	}
+	for (const [pkgName, version] of Object.entries(customDependencies)) pkgJson.dependencies[pkgName] = version;
+	for (const [pkgName, version] of Object.entries(customDevDependencies)) pkgJson.devDependencies[pkgName] = version;
+	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+};
+
+//#endregion
+//#region src/utils/package-runner.ts
+/**
+* Returns the appropriate command for running a package without installing it globally,
+* based on the selected package manager.
+*
+* @param packageManager - The selected package manager (e.g., 'npm', 'yarn', 'pnpm', 'bun').
+* @param commandWithArgs - The command to run, including arguments (e.g., "prisma generate --schema=./prisma/schema.prisma").
+* @returns The full command string (e.g., "npx prisma generate --schema=./prisma/schema.prisma").
+*/
+function getPackageExecutionCommand(packageManager, commandWithArgs) {
+	switch (packageManager) {
+		case "pnpm": return `pnpm dlx ${commandWithArgs}`;
+		case "bun": return `bunx ${commandWithArgs}`;
+		case "yarn": return `yarn dlx ${commandWithArgs}`;
+		default: return `npx ${commandWithArgs}`;
+	}
+}
+/**
+* Returns the command and arguments as an array for use with execa's $ template syntax.
+* This avoids the need for shell: true and provides better escaping.
+*
+* @param packageManager - The selected package manager (e.g., 'npm', 'yarn', 'pnpm', 'bun').
+* @param commandWithArgs - The command to run, including arguments (e.g., "prisma generate").
+* @returns An array of [command, ...args] (e.g., ["npx", "prisma", "generate"]).
+*/
+function getPackageExecutionArgs(packageManager, commandWithArgs) {
+	const args = commandWithArgs.split(" ");
+	switch (packageManager) {
+		case "pnpm": return [
+			"pnpm",
+			"dlx",
+			...args
+		];
+		case "bun": return ["bunx", ...args];
+		case "yarn": return [
+			"yarn",
+			"dlx",
+			...args
+		];
+		default: return ["npx", ...args];
+	}
+}
+/**
+* Returns just the runner prefix as an array, for when you already have args built.
+* Use this when you have complex arguments that shouldn't be split by spaces.
+*
+* @param packageManager - The selected package manager.
+* @returns The runner prefix as an array (e.g., ["npx"] or ["pnpm", "dlx"]).
+*
+* @example
+* const prefix = getPackageRunnerPrefix("bun");
+* const args = ["@tauri-apps/cli@latest", "init", "--app-name=foo"];
+* await $`${[...prefix, ...args]}`;
+*/
+function getPackageRunnerPrefix(packageManager) {
+	switch (packageManager) {
+		case "pnpm": return ["pnpm", "dlx"];
+		case "bun": return ["bunx"];
+		case "yarn": return ["yarn", "dlx"];
+		default: return ["npx"];
+	}
+}
+
+//#endregion
+//#region src/helpers/addons/fumadocs-setup.ts
+const TEMPLATES$2 = {
+	"next-mdx": {
+		label: "Next.js: Fumadocs MDX",
+		hint: "Recommended template with MDX support",
+		value: "+next+fuma-docs-mdx"
+	},
+	waku: {
+		label: "Waku: Content Collections",
+		hint: "Template using Waku with content collections",
+		value: "waku"
+	},
+	"react-router": {
+		label: "React Router: MDX Remote",
+		hint: "Template for React Router with MDX remote",
+		value: "react-router"
+	},
+	"react-router-spa": {
+		label: "React Router: SPA",
+		hint: "Template for React Router SPA",
+		value: "react-router-spa"
+	},
+	"tanstack-start": {
+		label: "Tanstack Start: MDX Remote",
+		hint: "Template for Tanstack Start with MDX remote",
+		value: "tanstack-start"
+	}
+};
+async function setupFumadocs(config) {
+	const { packageManager, projectDir } = config;
+	try {
+		log.info("Setting up Fumadocs...");
+		const template = await select({
+			message: "Choose a template",
+			options: Object.entries(TEMPLATES$2).map(([key, template$1]) => ({
+				value: key,
+				label: template$1.label,
+				hint: template$1.hint
+			})),
+			initialValue: "next-mdx"
+		});
+		if (isCancel(template)) return exitCancelled("Operation cancelled");
+		const args = getPackageExecutionArgs(packageManager, `create-fumadocs-app@latest fumadocs --template ${TEMPLATES$2[template].value} --src --pm ${packageManager} --no-git`);
+		const appsDir = path.join(projectDir, "apps");
+		await fs.ensureDir(appsDir);
+		const s = spinner();
+		s.start("Running Fumadocs create command...");
+		await $({
+			cwd: appsDir,
+			env: { CI: "true" }
+		})`${args}`;
+		const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
+		const packageJsonPath = path.join(fumadocsDir, "package.json");
+		if (await fs.pathExists(packageJsonPath)) {
+			const packageJson = await fs.readJson(packageJsonPath);
+			packageJson.name = "fumadocs";
+			if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port=4000`;
+			await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+		}
+		s.stop("Fumadocs setup complete!");
+	} catch (error) {
+		log.error(pc.red("Failed to set up Fumadocs"));
+		if (error instanceof Error) consola.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/utils/external-commands.ts
+function shouldSkipExternalCommands() {
+	const value = process.env.BFS_SKIP_EXTERNAL_COMMANDS;
+	if (!value) return false;
+	const normalized = value.toLowerCase().trim();
+	return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+
+//#endregion
+//#region src/helpers/addons/retry-install.ts
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_INITIAL_DELAY_MS = 750;
+const RETRY_BACKOFF_MULTIPLIER = 2;
+function defaultSleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatDelay(ms) {
+	return ms >= 1e3 ? `${(ms / 1e3).toFixed(ms % 1e3 === 0 ? 0 : 1)}s` : `${ms}ms`;
+}
+async function runInstallWithRetries({ description, run, maxAttempts = DEFAULT_MAX_ATTEMPTS, initialDelayMs = DEFAULT_INITIAL_DELAY_MS, sleep = defaultSleep }) {
+	let delayMs = initialDelayMs;
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+		await run();
+		return true;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (attempt === maxAttempts) {
+			log.warn(pc.yellow(`Warning: Could not ${description} after ${maxAttempts} attempts: ${message}`));
+			return false;
+		}
+		log.warn(pc.yellow(`Warning: Failed to ${description} (attempt ${attempt}/${maxAttempts}): ${message}. Retrying in ${formatDelay(delayMs)}...`));
+		await sleep(delayMs);
+		delayMs *= RETRY_BACKOFF_MULTIPLIER;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/helpers/addons/mcp-setup.ts
+const MCP_AGENTS = [
+	{
+		value: "cursor",
+		label: "Cursor",
+		scope: "both"
+	},
+	{
+		value: "claude-code",
+		label: "Claude Code",
+		scope: "both"
+	},
+	{
+		value: "codex",
+		label: "Codex",
+		scope: "both"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode",
+		scope: "both"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI",
+		scope: "both"
+	},
+	{
+		value: "vscode",
+		label: "VS Code (GitHub Copilot)",
+		scope: "both"
+	},
+	{
+		value: "zed",
+		label: "Zed",
+		scope: "both"
+	},
+	{
+		value: "claude-desktop",
+		label: "Claude Desktop",
+		scope: "global"
+	},
+	{
+		value: "goose",
+		label: "Goose",
+		scope: "global"
+	}
+];
+function uniqueValues$1(values) {
+	return Array.from(new Set(values));
+}
+function hasReactBasedFrontend$1(frontend) {
+	return frontend.includes("react-router") || frontend.includes("react-vite") || frontend.includes("tanstack-router") || frontend.includes("tanstack-start") || frontend.includes("next");
+}
+function hasNativeFrontend$1(frontend) {
+	return frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
+}
+function getRecommendedMcpServers(config) {
+	const servers = [];
+	servers.push({
+		key: "context7",
+		label: "Context7",
+		name: "context7",
+		target: "@upstash/context7-mcp"
+	});
+	if (config.runtime === "workers" || config.webDeploy === "cloudflare" || config.serverDeploy === "cloudflare") servers.push({
+		key: "cloudflare-docs",
+		label: "Cloudflare Docs",
+		name: "cloudflare-docs",
+		target: "https://docs.mcp.cloudflare.com/sse",
+		transport: "sse"
+	});
+	if (config.backend === "convex") servers.push({
+		key: "convex",
+		label: "Convex",
+		name: "convex",
+		target: "npx -y convex@latest mcp start"
+	});
+	if (hasReactBasedFrontend$1(config.frontend)) servers.push({
+		key: "shadcn",
+		label: "shadcn/ui",
+		name: "shadcn",
+		target: "npx -y shadcn@latest mcp"
+	});
+	if (config.frontend.includes("next")) servers.push({
+		key: "next-devtools",
+		label: "Next Devtools",
+		name: "next-devtools",
+		target: "npx -y next-devtools-mcp@latest"
+	});
+	if (config.frontend.includes("nuxt")) servers.push({
+		key: "nuxt-docs",
+		label: "Nuxt Docs",
+		name: "nuxt",
+		target: "https://nuxt.com/mcp"
+	}, {
+		key: "nuxt-ui-docs",
+		label: "Nuxt UI Docs",
+		name: "nuxt-ui",
+		target: "https://ui.nuxt.com/mcp"
+	});
+	if (config.frontend.includes("svelte")) servers.push({
+		key: "svelte-docs",
+		label: "Svelte Docs",
+		name: "svelte",
+		target: "https://mcp.svelte.dev/mcp"
+	});
+	if (config.frontend.includes("astro")) servers.push({
+		key: "astro-docs",
+		label: "Astro Docs",
+		name: "astro-docs",
+		target: "https://mcp.docs.astro.build/mcp"
+	});
+	if (config.dbSetup === "planetscale") servers.push({
+		key: "planetscale",
+		label: "PlanetScale",
+		name: "planetscale",
+		target: "https://mcp.pscale.dev/mcp/planetscale"
+	});
+	if (config.dbSetup === "neon") servers.push({
+		key: "neon",
+		label: "Neon",
+		name: "neon",
+		target: "https://mcp.neon.tech/mcp"
+	});
+	if (config.dbSetup === "supabase") servers.push({
+		key: "supabase",
+		label: "Supabase",
+		name: "supabase",
+		target: "https://mcp.supabase.com/mcp"
+	});
+	if (config.auth === "better-auth") servers.push({
+		key: "better-auth",
+		label: "Better Auth",
+		name: "better-auth",
+		target: "https://mcp.inkeep.com/better-auth/mcp"
+	});
+	if (config.auth === "clerk") servers.push({
+		key: "clerk",
+		label: "Clerk",
+		name: "clerk",
+		target: "https://mcp.clerk.com/mcp"
+	});
+	if (hasNativeFrontend$1(config.frontend)) servers.push({
+		key: "expo",
+		label: "Expo",
+		name: "expo-mcp",
+		target: "https://mcp.expo.dev/mcp"
+	});
+	if (config.payments === "polar") servers.push({
+		key: "polar",
+		label: "Polar",
+		name: "polar",
+		target: "https://mcp.polar.sh/mcp/polar-mcp"
+	});
+	return servers;
+}
+function filterAgentsForScope(scope) {
+	return MCP_AGENTS.filter((a) => a.scope === "both" || a.scope === scope);
+}
+async function setupMcp(config) {
+	if (shouldSkipExternalCommands()) return;
+	const { packageManager, projectDir } = config;
+	log.info("Setting up MCP servers...");
+	const scope = await select({
+		message: "Where should MCP servers be installed?",
+		options: [{
+			value: "project",
+			label: "Project",
+			hint: "Writes to project config files (recommended for teams)"
+		}, {
+			value: "global",
+			label: "Global",
+			hint: "Writes to user-level config files (personal machine)"
+		}],
+		initialValue: "project"
+	});
+	if (isCancel(scope)) return;
+	const recommendedServers = getRecommendedMcpServers(config);
+	if (recommendedServers.length === 0) return;
+	const selectedServerKeys = await multiselect({
+		message: "Select MCP servers to install",
+		options: recommendedServers.map((server) => ({
+			value: server.key,
+			label: server.label,
+			hint: server.target
+		})),
+		required: false,
+		initialValues: recommendedServers.map((server) => server.key)
+	});
+	if (isCancel(selectedServerKeys) || selectedServerKeys.length === 0) return;
+	const agentOptions = filterAgentsForScope(scope).map((a) => ({
+		value: a.value,
+		label: a.label
+	}));
+	const selectedAgents = await multiselect({
+		message: "Select agents to install MCP servers to",
+		options: agentOptions,
+		required: false,
+		initialValues: uniqueValues$1([
+			"cursor",
+			"claude-code",
+			"vscode"
+		].filter((agent) => agentOptions.some((option) => option.value === agent)))
+	});
+	if (isCancel(selectedAgents) || selectedAgents.length === 0) return;
+	const serversByKey = new Map(recommendedServers.map((server) => [server.key, server]));
+	const selectedServers = [];
+	for (const key of selectedServerKeys) {
+		const server = serversByKey.get(key);
+		if (server) selectedServers.push(server);
+	}
+	if (selectedServers.length === 0) return;
+	const installSpinner = spinner();
+	installSpinner.start("Installing MCP servers...");
+	const runner = getPackageRunnerPrefix(packageManager);
+	const globalFlags = scope === "global" ? ["-g"] : [];
+	for (const server of selectedServers) {
+		const transportFlags = server.transport ? ["-t", server.transport] : [];
+		const headerFlags = (server.headers ?? []).flatMap((header) => ["--header", header]);
+		const agentFlags = selectedAgents.flatMap((agent) => ["-a", agent]);
+		const args = [
+			...runner,
+			"add-mcp@latest",
+			server.target,
+			"--name",
+			server.name,
+			...transportFlags,
+			...headerFlags,
+			...agentFlags,
+			...globalFlags,
+			"-y"
+		];
+		await runInstallWithRetries({
+			description: `install MCP server '${server.name}'`,
+			run: async () => {
+				await $({
+					cwd: projectDir,
+					env: { CI: "true" }
+				})`${args}`;
+			}
+		});
+	}
+	installSpinner.stop("MCP servers installed");
+}
+
+//#endregion
+//#region src/helpers/addons/oxlint-setup.ts
+async function setupOxlint(projectDir, packageManager) {
+	await addPackageDependency({
+		devDependencies: ["oxlint", "oxfmt"],
+		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 && oxfmt --write"
+		};
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+	const s = spinner();
+	const oxlintArgs = getPackageExecutionArgs(packageManager, "oxlint@latest --init");
+	s.start("Initializing oxlint and oxfmt...");
+	await $({
+		cwd: projectDir,
+		env: { CI: "true" }
+	})`${oxlintArgs}`;
+	const oxfmtArgs = getPackageExecutionArgs(packageManager, "oxfmt@latest --init");
+	await $({
+		cwd: projectDir,
+		env: { CI: "true" }
+	})`${oxfmtArgs}`;
+	s.stop("oxlint and oxfmt initialized successfully!");
+}
+
+//#endregion
+//#region src/helpers/addons/ruler-setup.ts
+async function setupRuler(config) {
+	const { packageManager, projectDir } = config;
+	try {
+		log.info("Setting up Ruler...");
+		const rulerDir = path.join(projectDir, ".ruler");
+		if (!await fs.pathExists(rulerDir)) {
+			log.error(pc.red("Ruler template directory not found. Please ensure ruler addon is properly installed."));
+			return;
+		}
+		const selectedEditors = await autocompleteMultiselect({
+			message: "Select AI assistants for Ruler",
+			options: Object.entries({
+				agentsmd: { label: "Agents.md" },
+				aider: { label: "Aider" },
+				amazonqcli: { label: "Amazon Q CLI" },
+				amp: { label: "AMP" },
+				antigravity: { label: "Antigravity" },
+				augmentcode: { label: "AugmentCode" },
+				claude: { label: "Claude Code" },
+				cline: { label: "Cline" },
+				codex: { label: "OpenAI Codex CLI" },
+				copilot: { label: "GitHub Copilot" },
+				crush: { label: "Crush" },
+				cursor: { label: "Cursor" },
+				firebase: { label: "Firebase Studio" },
+				firebender: { label: "Firebender" },
+				"gemini-cli": { label: "Gemini CLI" },
+				goose: { label: "Goose" },
+				jules: { label: "Jules" },
+				junie: { label: "Junie" },
+				kilocode: { label: "Kilo Code" },
+				kiro: { label: "Kiro" },
+				mistral: { label: "Mistral" },
+				opencode: { label: "OpenCode" },
+				openhands: { label: "Open Hands" },
+				qwen: { label: "Qwen" },
+				roo: { label: "RooCode" },
+				trae: { label: "Trae AI" },
+				warp: { label: "Warp" },
+				windsurf: { label: "Windsurf" },
+				zed: { label: "Zed" }
+			}).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");
+		let updatedConfig = await fs.readFile(configFile, "utf-8");
+		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 rulerApplyArgs = getPackageExecutionArgs(packageManager, `@intellectronica/ruler@latest apply --agents ${selectedEditors.join(",")} --local-only`);
+			await $({
+				cwd: projectDir,
+				env: { CI: "true" }
+			})`${rulerApplyArgs}`;
+			s.stop("Applied rules with Ruler");
+		} catch {
+			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/helpers/addons/skills-setup.ts
+const SKILL_SOURCES = {
+	"vercel-labs/agent-skills": { label: "Vercel Agent Skills" },
+	"vercel/ai": { label: "Vercel AI SDK" },
+	"vercel/turborepo": { label: "Turborepo" },
+	"yusukebe/hono-skill": { label: "Hono Backend" },
+	"vercel-labs/next-skills": { label: "Next.js Best Practices" },
+	"nuxt/ui": { label: "Nuxt UI" },
+	"heroui-inc/heroui": { label: "HeroUI Native" },
+	"better-auth/skills": { label: "Better Auth" },
+	"neondatabase/agent-skills": { label: "Neon Database" },
+	"supabase/agent-skills": { label: "Supabase" },
+	"planetscale/database-skills": { label: "PlanetScale" },
+	"expo/skills": { label: "Expo" },
+	"prisma/skills": { label: "Prisma" },
+	"elysiajs/skills": { label: "ElysiaJS" },
+	"waynesutton/convexskills": { label: "Convex" },
+	"msmps/opentui-skill": { label: "OpenTUI Platform" },
+	"haydenbleasel/ultracite": { label: "Ultracite" }
+};
+const AVAILABLE_AGENTS = [
+	{
+		value: "cursor",
+		label: "Cursor"
+	},
+	{
+		value: "claude-code",
+		label: "Claude Code"
+	},
+	{
+		value: "cline",
+		label: "Cline"
+	},
+	{
+		value: "github-copilot",
+		label: "GitHub Copilot"
+	},
+	{
+		value: "codex",
+		label: "Codex"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf"
+	},
+	{
+		value: "goose",
+		label: "Goose"
+	},
+	{
+		value: "roo",
+		label: "Roo Code"
+	},
+	{
+		value: "kilo",
+		label: "Kilo Code"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI"
+	},
+	{
+		value: "antigravity",
+		label: "Antigravity"
+	},
+	{
+		value: "openhands",
+		label: "OpenHands"
+	},
+	{
+		value: "trae",
+		label: "Trae"
+	},
+	{
+		value: "amp",
+		label: "Amp"
+	},
+	{
+		value: "pi",
+		label: "Pi"
+	},
+	{
+		value: "qoder",
+		label: "Qoder"
+	},
+	{
+		value: "qwen-code",
+		label: "Qwen Code"
+	},
+	{
+		value: "kiro-cli",
+		label: "Kiro CLI"
+	},
+	{
+		value: "droid",
+		label: "Droid"
+	},
+	{
+		value: "command-code",
+		label: "Command Code"
+	},
+	{
+		value: "clawdbot",
+		label: "Clawdbot"
+	},
+	{
+		value: "zencoder",
+		label: "Zencoder"
+	},
+	{
+		value: "neovate",
+		label: "Neovate"
+	},
+	{
+		value: "mcpjam",
+		label: "MCPJam"
+	}
+];
+function hasReactBasedFrontend(frontend) {
+	return frontend.includes("react-router") || frontend.includes("react-vite") || frontend.includes("tanstack-router") || frontend.includes("tanstack-start") || frontend.includes("next");
+}
+function hasNativeFrontend(frontend) {
+	return frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
+}
+function uniqueValues(values) {
+	return Array.from(new Set(values));
+}
+function getRecommendedSourceKeys(config) {
+	const sources = [];
+	const { frontend, backend, dbSetup, auth, examples, addons, orm } = config;
+	if (hasReactBasedFrontend(frontend)) sources.push("vercel-labs/agent-skills");
+	if (frontend.includes("next")) sources.push("vercel-labs/next-skills");
+	if (frontend.includes("nuxt")) sources.push("nuxt/ui");
+	if (frontend.includes("native-uniwind")) sources.push("heroui-inc/heroui");
+	if (hasNativeFrontend(frontend)) sources.push("expo/skills");
+	if (auth === "better-auth") sources.push("better-auth/skills");
+	if (dbSetup === "neon") sources.push("neondatabase/agent-skills");
+	if (dbSetup === "supabase") sources.push("supabase/agent-skills");
+	if (dbSetup === "planetscale") sources.push("planetscale/database-skills");
+	if (orm === "prisma" || dbSetup === "prisma-postgres") sources.push("prisma/skills");
+	if (examples.includes("ai")) sources.push("vercel/ai");
+	if (addons.includes("turborepo")) sources.push("vercel/turborepo");
+	if (backend === "hono") sources.push("yusukebe/hono-skill");
+	if (backend === "elysia") sources.push("elysiajs/skills");
+	if (backend === "convex") sources.push("waynesutton/convexskills");
+	if (addons.includes("opentui")) sources.push("msmps/opentui-skill");
+	if (addons.includes("ultracite")) sources.push("haydenbleasel/ultracite");
+	return sources;
+}
+const CURATED_SKILLS_BY_SOURCE = {
+	"vercel-labs/agent-skills": (config) => {
+		const skills = [
+			"web-design-guidelines",
+			"vercel-composition-patterns",
+			"vercel-react-best-practices"
+		];
+		if (hasNativeFrontend(config.frontend)) skills.push("vercel-react-native-skills");
+		return skills;
+	},
+	"vercel/ai": () => ["ai-sdk"],
+	"vercel/turborepo": () => ["turborepo"],
+	"yusukebe/hono-skill": () => ["hono"],
+	"vercel-labs/next-skills": () => ["next-best-practices", "next-cache-components"],
+	"nuxt/ui": () => ["nuxt-ui"],
+	"heroui-inc/heroui": () => ["heroui-native"],
+	"better-auth/skills": () => ["better-auth-best-practices"],
+	"neondatabase/agent-skills": () => ["neon-postgres"],
+	"supabase/agent-skills": () => ["supabase-postgres-best-practices"],
+	"planetscale/database-skills": (config) => {
+		if (config.dbSetup !== "planetscale") return [];
+		if (config.database === "postgres") return ["postgres", "neki"];
+		if (config.database === "mysql") return ["mysql", "vitess"];
+		return [];
+	},
+	"expo/skills": (config) => {
+		const skills = [
+			"expo-dev-client",
+			"building-native-ui",
+			"native-data-fetching",
+			"expo-deployment",
+			"upgrading-expo",
+			"expo-cicd-workflows"
+		];
+		if (config.frontend.includes("native-uniwind")) skills.push("expo-tailwind-setup");
+		return skills;
+	},
+	"prisma/skills": (config) => {
+		const skills = [];
+		if (config.orm === "prisma") skills.push("prisma-cli", "prisma-client-api", "prisma-database-setup");
+		if (config.dbSetup === "prisma-postgres") skills.push("prisma-postgres");
+		return skills;
+	},
+	"elysiajs/skills": () => ["elysiajs"],
+	"waynesutton/convexskills": () => [
+		"convex-best-practices",
+		"convex-functions",
+		"convex-schema-validator",
+		"convex-realtime",
+		"convex-http-actions",
+		"convex-cron-jobs",
+		"convex-file-storage",
+		"convex-migrations",
+		"convex-security-check"
+	],
+	"msmps/opentui-skill": () => ["opentui"],
+	"haydenbleasel/ultracite": () => ["ultracite"]
+};
+function getCuratedSkillNamesForSourceKey(sourceKey, config) {
+	return CURATED_SKILLS_BY_SOURCE[sourceKey](config);
+}
+async function setupSkills(config) {
+	if (shouldSkipExternalCommands()) return;
+	const { packageManager, projectDir } = config;
+	const btsConfig = await readBtsConfig(projectDir);
+	const fullConfig = btsConfig ? {
+		...config,
+		addons: btsConfig.addons ?? config.addons
+	} : config;
+	const recommendedSourceKeys = getRecommendedSourceKeys(fullConfig);
+	if (recommendedSourceKeys.length === 0) return;
+	const skillOptions = uniqueValues(recommendedSourceKeys).flatMap((sourceKey) => {
+		const source = SKILL_SOURCES[sourceKey];
+		return getCuratedSkillNamesForSourceKey(sourceKey, fullConfig).map((skillName) => ({
+			value: `${sourceKey}::${skillName}`,
+			label: skillName,
+			hint: source.label
+		}));
+	});
+	if (skillOptions.length === 0) return;
+	const scope = await select({
+		message: "Where should skills be installed?",
+		options: [{
+			value: "project",
+			label: "Project",
+			hint: "Writes to project config files (recommended for teams)"
+		}, {
+			value: "global",
+			label: "Global",
+			hint: "Writes to user-level config files (personal machine)"
+		}],
+		initialValue: "project"
+	});
+	if (isCancel(scope)) return;
+	const selectedSkills = await multiselect({
+		message: "Select skills to install",
+		options: skillOptions,
+		required: false,
+		initialValues: skillOptions.map((option) => option.value)
+	});
+	if (isCancel(selectedSkills) || selectedSkills.length === 0) return;
+	const selectedAgents = await multiselect({
+		message: "Select agents to install skills to",
+		options: AVAILABLE_AGENTS,
+		required: false,
+		initialValues: [
+			"cursor",
+			"claude-code",
+			"github-copilot"
+		]
+	});
+	if (isCancel(selectedAgents) || selectedAgents.length === 0) return;
+	const skillsBySource = {};
+	for (const skillKey of selectedSkills) {
+		const [source, skillName] = skillKey.split("::");
+		if (!skillsBySource[source]) skillsBySource[source] = [];
+		skillsBySource[source].push(skillName);
+	}
+	const installSpinner = spinner();
+	installSpinner.start("Installing skills...");
+	const runner = getPackageRunnerPrefix(packageManager);
+	const agentFlags = selectedAgents.flatMap((agent) => ["-a", agent]);
+	const globalFlag = scope === "global" ? ["-g"] : [];
+	for (const [source, skills] of Object.entries(skillsBySource)) {
+		const skillFlags = skills.flatMap((skill) => ["-s", skill]);
+		const args = [
+			...runner,
+			"skills@latest",
+			"add",
+			source,
+			...globalFlag,
+			...skillFlags,
+			...agentFlags,
+			"-y"
+		];
+		await runInstallWithRetries({
+			description: `install skills from ${source}`,
+			run: async () => {
+				await $({
+					cwd: projectDir,
+					env: { CI: "true" }
+				})`${args}`;
+			}
+		});
+	}
+	installSpinner.stop("Skills installed");
+}
+
+//#endregion
+//#region src/helpers/addons/starlight-setup.ts
+async function setupStarlight(config) {
+	const { packageManager, projectDir } = config;
+	const s = spinner();
+	try {
+		s.start("Setting up Starlight docs...");
+		const args = getPackageExecutionArgs(packageManager, `create-astro@latest ${[
+			"docs",
+			"--template",
+			"starlight",
+			"--no-install",
+			"--add",
+			"tailwind",
+			"--no-git",
+			"--skip-houston"
+		].join(" ")}`);
+		const appsDir = path.join(projectDir, "apps");
+		await fs.ensureDir(appsDir);
+		await $({
+			cwd: appsDir,
+			env: { CI: "true" }
+		})`${args}`;
+		s.stop("Starlight docs setup successfully!");
+	} catch (error) {
+		s.stop(pc.red("Failed to set up Starlight docs"));
+		if (error instanceof Error) consola.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/addons/tauri-setup.ts
+async function setupTauri(config) {
+	const { packageManager, frontend, projectDir } = config;
+	const s = spinner();
+	const clientPackageDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(clientPackageDir)) return;
+	try {
+		s.start("Setting up Tauri desktop app support...");
+		const hasNuxt = frontend.includes("nuxt");
+		const hasSvelte = frontend.includes("svelte");
+		const hasNext = frontend.includes("next");
+		const devUrl = `http://localhost:${getLocalWebDevPort(frontend)}`;
+		const frontendDist = hasNuxt ? "../.output/public" : hasSvelte ? "../build" : hasNext ? "../.next" : frontend.includes("react-router") ? "../build/client" : frontend.includes("react-vite") ? "../dist" : "../dist";
+		const tauriArgs = [
+			"@tauri-apps/cli@latest",
+			"init",
+			`--app-name=${path.basename(projectDir)}`,
+			`--window-title=${path.basename(projectDir)}`,
+			`--frontend-dist=${frontendDist}`,
+			`--dev-url=${devUrl}`,
+			`--before-dev-command=${packageManager} run dev`,
+			`--before-build-command=${packageManager} run build`
+		];
+		const prefix = getPackageRunnerPrefix(packageManager);
+		await $({
+			cwd: clientPackageDir,
+			env: { CI: "true" }
+		})`${[...prefix, ...tauriArgs]}`;
+		s.stop("Tauri desktop app support configured successfully!");
+	} catch (error) {
+		s.stop(pc.red("Failed to set up Tauri"));
+		if (error instanceof Error) consola$1.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/addons/tui-setup.ts
+const TEMPLATES$1 = {
+	core: {
+		label: "Core",
+		hint: "Basic OpenTUI template"
+	},
+	react: {
+		label: "React",
+		hint: "React-based OpenTUI template"
+	},
+	solid: {
+		label: "Solid",
+		hint: "SolidJS-based OpenTUI template"
+	}
+};
+async function setupTui(config) {
+	const { packageManager, projectDir } = config;
+	try {
+		log.info("Setting up OpenTUI...");
+		const template = await select({
+			message: "Choose a template",
+			options: Object.entries(TEMPLATES$1).map(([key, template$1]) => ({
+				value: key,
+				label: template$1.label,
+				hint: template$1.hint
+			})),
+			initialValue: "core"
+		});
+		if (isCancel(template)) return exitCancelled("Operation cancelled");
+		const args = getPackageExecutionArgs(packageManager, `create-tui@latest --template ${template} --no-git --no-install tui`);
+		const appsDir = path.join(projectDir, "apps");
+		await fs.ensureDir(appsDir);
+		const s = spinner();
+		s.start("Running OpenTUI create command...");
+		await $({
+			cwd: appsDir,
+			env: { CI: "true" }
+		})`${args}`;
+		s.stop("OpenTUI setup complete!");
+	} catch (error) {
+		log.error(pc.red("Failed to set up OpenTUI"));
+		if (error instanceof Error) console.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/addons/ultracite-setup.ts
+const LINTERS = {
+	biome: {
+		label: "Biome",
+		hint: "Fast formatter and linter"
+	},
+	eslint: {
+		label: "ESLint",
+		hint: "Traditional JavaScript linter"
+	},
+	oxlint: {
+		label: "Oxlint",
+		hint: "Oxidation compiler linter"
+	}
+};
+const EDITORS = {
+	vscode: { label: "VS Code" },
+	cursor: { label: "Cursor" },
+	windsurf: { label: "Windsurf" },
+	antigravity: { label: "Antigravity" },
+	kiro: { label: "Kiro" },
+	trae: { label: "Trae" },
+	void: { label: "Void" },
+	zed: { label: "Zed" }
+};
+const AGENTS = {
+	claude: { label: "Claude" },
+	codex: { label: "Codex" },
+	jules: { label: "Jules" },
+	copilot: { label: "GitHub Copilot" },
+	cline: { label: "Cline" },
+	amp: { label: "Amp" },
+	aider: { label: "Aider" },
+	"firebase-studio": { label: "Firebase Studio" },
+	"open-hands": { label: "Open Hands" },
+	gemini: { label: "Gemini" },
+	junie: { label: "Junie" },
+	augmentcode: { label: "AugmentCode" },
+	"kilo-code": { label: "Kilo Code" },
+	goose: { label: "Goose" },
+	"roo-code": { label: "Roo Code" },
+	warp: { label: "Warp" },
+	droid: { label: "Droid" },
+	opencode: { label: "OpenCode" },
+	crush: { label: "Crush" },
+	qwen: { label: "Qwen" },
+	"amazon-q-cli": { label: "Amazon Q CLI" },
+	firebender: { label: "Firebender" },
+	"cursor-cli": { label: "Cursor CLI" },
+	"mistral-vibe": { label: "Mistral Vibe" },
+	vercel: { label: "Vercel" }
+};
+const HOOKS = {
+	cursor: { label: "Cursor" },
+	windsurf: { label: "Windsurf" },
+	claude: { label: "Claude" }
+};
+function getFrameworksFromFrontend(frontend) {
+	const frameworkMap = {
+		"tanstack-router": "react",
+		"react-router": "react",
+		"react-vite": "react",
+		"tanstack-start": "react",
+		next: "next",
+		nuxt: "vue",
+		"native-bare": "react",
+		"native-uniwind": "react",
+		"native-unistyles": "react",
+		svelte: "svelte",
+		solid: "solid"
+	};
+	const frameworks = /* @__PURE__ */ new Set();
+	for (const f of frontend) if (f !== "none" && frameworkMap[f]) frameworks.add(frameworkMap[f]);
+	return Array.from(frameworks);
+}
+async function setupUltracite(config, gitHooks) {
+	const { packageManager, projectDir, frontend } = config;
+	try {
+		log.info("Setting up Ultracite...");
+		const result = await group({
+			linter: () => select({
+				message: "Choose linter/formatter",
+				options: Object.entries(LINTERS).map(([key, linter$1]) => ({
+					value: key,
+					label: linter$1.label,
+					hint: linter$1.hint
+				})),
+				initialValue: "biome"
+			}),
+			editors: () => multiselect({
+				message: "Choose editors",
+				options: Object.entries(EDITORS).map(([key, editor]) => ({
+					value: key,
+					label: editor.label
+				})),
+				required: true
+			}),
+			agents: () => multiselect({
+				message: "Choose agents",
+				options: Object.entries(AGENTS).map(([key, agent]) => ({
+					value: key,
+					label: agent.label
+				})),
+				required: true
+			}),
+			hooks: () => multiselect({
+				message: "Choose hooks",
+				options: Object.entries(HOOKS).map(([key, hook]) => ({
+					value: key,
+					label: hook.label
+				}))
+			})
+		}, { onCancel: () => {
+			exitCancelled("Operation cancelled");
+		} });
+		const linter = result.linter;
+		const editors = result.editors;
+		const agents = result.agents;
+		const hooks = result.hooks;
+		const frameworks = getFrameworksFromFrontend(frontend);
+		const ultraciteArgs = [
+			"init",
+			"--pm",
+			packageManager,
+			"--linter",
+			linter
+		];
+		if (frameworks.length > 0) ultraciteArgs.push("--frameworks", ...frameworks);
+		if (editors.length > 0) ultraciteArgs.push("--editors", ...editors);
+		if (agents.length > 0) ultraciteArgs.push("--agents", ...agents);
+		if (hooks.length > 0) ultraciteArgs.push("--hooks", ...hooks);
+		if (gitHooks.length > 0) {
+			const integrations = [...gitHooks];
+			if (gitHooks.includes("husky")) integrations.push("lint-staged");
+			ultraciteArgs.push("--integrations", ...integrations);
+		}
+		const args = getPackageExecutionArgs(packageManager, `ultracite@latest ${ultraciteArgs.join(" ")} --skip-install`);
+		const s = spinner();
+		s.start("Running Ultracite init command...");
+		await $({
+			cwd: projectDir,
+			env: { CI: "true" }
+		})`${args}`;
+		s.stop("Ultracite setup successfully!");
+	} catch (error) {
+		log.error(pc.red("Failed to set up Ultracite"));
+		if (error instanceof Error) console.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/addons/wxt-setup.ts
+const TEMPLATES = {
+	vanilla: {
+		label: "Vanilla",
+		hint: "Vanilla JavaScript template"
+	},
+	vue: {
+		label: "Vue",
+		hint: "Vue.js template"
+	},
+	react: {
+		label: "React",
+		hint: "React template"
+	},
+	solid: {
+		label: "Solid",
+		hint: "SolidJS template"
+	},
+	svelte: {
+		label: "Svelte",
+		hint: "Svelte template"
+	}
+};
+async function setupWxt(config) {
+	const { packageManager, projectDir } = config;
+	try {
+		log.info("Setting up WXT...");
+		const template = await select({
+			message: "Choose a template",
+			options: Object.entries(TEMPLATES).map(([key, template$1]) => ({
+				value: key,
+				label: template$1.label,
+				hint: template$1.hint
+			})),
+			initialValue: "react"
+		});
+		if (isCancel(template)) return exitCancelled("Operation cancelled");
+		const args = getPackageExecutionArgs(packageManager, `wxt@latest init extension --template ${template} --pm ${packageManager}`);
+		const appsDir = path.join(projectDir, "apps");
+		await fs.ensureDir(appsDir);
+		const s = spinner();
+		s.start("Running WXT init command...");
+		await $({
+			cwd: appsDir,
+			env: { CI: "true" }
+		})`${args}`;
+		const extensionDir = path.join(projectDir, "apps", "extension");
+		const packageJsonPath = path.join(extensionDir, "package.json");
+		if (await fs.pathExists(packageJsonPath)) {
+			const packageJson = await fs.readJson(packageJsonPath);
+			packageJson.name = "extension";
+			if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port 5555`;
+			await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+		}
+		s.stop("WXT setup complete!");
+	} catch (error) {
+		log.error(pc.red("Failed to set up WXT"));
+		if (error instanceof Error) console.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/addons/addons-setup.ts
+async function setupAddons(config) {
+	const warnings = [];
+	const { addons, frontend, projectDir } = config;
+	const hasReactWebFrontend = frontend.includes("react-router") || frontend.includes("react-vite") || 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("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 hasLefthook = addons.includes("lefthook");
+	const hasOxlint = addons.includes("oxlint");
+	if (hasUltracite) {
+		const gitHooks = [];
+		if (hasHusky) gitHooks.push("husky");
+		if (hasLefthook) gitHooks.push("lefthook");
+		await setupUltracite(config, gitHooks);
+	} else {
+		if (hasBiome) await setupBiome(projectDir);
+		if (hasOxlint) await setupOxlint(projectDir, config.packageManager);
+		if (hasHusky || hasLefthook) {
+			let linter;
+			if (hasOxlint) linter = "oxlint";
+			else if (hasBiome) linter = "biome";
+			if (hasHusky) await setupHusky(projectDir, linter);
+			if (hasLefthook) await setupLefthook(projectDir);
+		}
+	}
+	if (addons.includes("starlight")) await setupStarlight(config);
+	if (addons.includes("fumadocs")) await setupFumadocs(config);
+	if (addons.includes("opentui")) await setupTui(config);
+	if (addons.includes("wxt")) await setupWxt(config);
+	if (addons.includes("ruler")) await setupRuler(config);
+	if (addons.includes("mcp")) try {
+		await setupMcp(config);
+	} catch (error) {
+		warnings.push(`MCP setup failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (addons.includes("skills")) try {
+		await setupSkills(config);
+	} catch (error) {
+		warnings.push(`Skills setup failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return warnings;
+}
+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"] = { "*": ["oxlint", "oxfmt --write"] };
+		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 setupLefthook(projectDir) {
+	await addPackageDependency({
+		devDependencies: ["lefthook"],
+		projectDir
+	});
+}
+
+//#endregion
+export { setLastPromptShownUI as _, getPackageExecutionArgs as a, UserCancelledError as c, handleError as d, didLastPromptShowUI as f, setIsFirstPrompt as g, runWithContextAsync as h, setupLefthook as i, exitCancelled as l, isSilent as m, setupBiome as n, addPackageDependency as o, isFirstPrompt as p, setupHusky as r, CLIError as s, setupAddons as t, exitWithError as u };