create-start-kit-dev 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# create-start-kit-dev
+
+CLI for scaffolding and configuring [Start Kit](https://github.com/CarlosZiegler/start-kit.dev) projects.
+
+## Usage
+
+### Create a new project
+
+```bash
+bunx create-start-kit-dev create my-app
+```
+
+This downloads the template, installs dependencies, and runs the interactive setup wizard.
+
+### Initialize an existing project
+
+```bash
+bunx create-start-kit-dev init
+```
+
+### Run a specific setup phase
+
+```bash
+bunx create-start-kit-dev init --step database
+```
+
+## Setup Phases
+
+The wizard guides you through these phases (resumable if interrupted):
+
+| Phase | What it does |
+|-------|-------------|
+| **Branding** | App name, description, logo, colors |
+| **Features** | Toggle AI, payments, storage, i18n |
+| **Database** | PostgreSQL connection and schema setup |
+| **Environment** | Generate `.env` with required variables |
+| **Infrastructure** | Docker and deployment config |
+
+## Development
+
+```bash
+bun install
+bun run build    # Build with tsdown
+bun run dev      # Watch mode
+```
+
+## License
+
+MIT

package/dist/index.mjs

@@ -0,0 +1,811 @@
+#!/usr/bin/env bun
+import { confirm, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { downloadTemplate } from "giget";
+
+//#region src/lib/state.ts
+const STATE_FILE = ".setup-state.json";
+const DEFAULT_STATE = {
+	version: 1,
+	completedPhases: []
+};
+function getStatePath() {
+	return `${process.cwd()}/${STATE_FILE}`;
+}
+function loadState() {
+	const path = getStatePath();
+	if (!existsSync(path)) return { ...DEFAULT_STATE };
+	const content = readFileSync(path, "utf-8");
+	return JSON.parse(content);
+}
+async function saveState(state) {
+	await Bun.write(getStatePath(), JSON.stringify(state, null, 2));
+}
+function isPhaseCompleted(state, phase) {
+	return state.completedPhases.includes(phase);
+}
+function markPhaseCompleted(state, phase) {
+	if (!state.completedPhases.includes(phase)) state.completedPhases.push(phase);
+	return state;
+}
+
+//#endregion
+//#region src/lib/helpers.ts
+const NAME_PATTERN = /name:\s*"[^"]*"/;
+const DESCRIPTION_PATTERN = /description:\s*"[^"]*"/;
+function updateJsonFile(path, updates) {
+	const content = readFileSync(path, "utf-8");
+	const json = JSON.parse(content);
+	for (const [key, value] of Object.entries(updates)) json[key] = value;
+	writeFileSync(path, `${JSON.stringify(json, null, 2)}\n`);
+}
+function updateAppConfig(path, name, description) {
+	let content = readFileSync(path, "utf-8");
+	content = content.replace(NAME_PATTERN, `name: "${name}"`);
+	content = content.replace(DESCRIPTION_PATTERN, `description: "${description}"`);
+	writeFileSync(path, content);
+}
+function writeEnvFile(path, vars, comments) {
+	const lines = [];
+	for (const [key, value] of Object.entries(vars)) {
+		if (comments?.[key]) lines.push(`# ${comments[key]}`);
+		const formatted = value.includes(" ") ? `"${value}"` : value;
+		lines.push(`${key}=${formatted}`);
+	}
+	writeFileSync(path, `${lines.join("\n")}\n`);
+}
+function readEnvFile(path) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		const result = {};
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (trimmed && !trimmed.startsWith("#")) {
+				const eqIndex = trimmed.indexOf("=");
+				if (eqIndex > 0) {
+					const key = trimmed.slice(0, eqIndex);
+					let value = trimmed.slice(eqIndex + 1);
+					if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+					result[key] = value;
+				}
+			}
+		}
+		return result;
+	} catch {
+		return {};
+	}
+}
+function generateSecret(bytes = 32) {
+	const buffer = new Uint8Array(bytes);
+	crypto.getRandomValues(buffer);
+	return btoa(String.fromCharCode(...buffer));
+}
+async function exec(command) {
+	const proc = Bun.spawn([
+		"sh",
+		"-c",
+		command
+	], {
+		stdout: "pipe",
+		stderr: "pipe"
+	});
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	const exitCode = await proc.exited;
+	return {
+		stdout: stdout.trim(),
+		stderr: stderr.trim(),
+		exitCode
+	};
+}
+async function testDbConnection(url) {
+	try {
+		const { SQL } = await import("bun");
+		const sql = new SQL(url);
+		const result = sql.query("SELECT version()").get();
+		sql.close();
+		return {
+			ok: true,
+			version: result.version
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+
+//#endregion
+//#region src/lib/validators.ts
+const DOMAIN_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/i;
+function isValidDomain(value) {
+	return DOMAIN_PATTERN.test(value);
+}
+function isValidPostgresUrl(value) {
+	return value.startsWith("postgresql://") || value.startsWith("postgres://");
+}
+function isValidAppName(value) {
+	return value.length >= 2 && value.length <= 50;
+}
+function toKebabCase(value) {
+	return value.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+//#endregion
+//#region src/phases/branding.ts
+async function runBranding(state) {
+	const appName = await text({
+		message: "What's your app name?",
+		placeholder: "My SaaS App",
+		initialValue: state.branding?.appName,
+		validate: (v) => {
+			if (!isValidAppName(v)) return "Name must be 2-50 characters";
+		}
+	});
+	if (isCancel(appName)) process.exit(0);
+	const description = await text({
+		message: "Short description?",
+		placeholder: "A platform for managing widgets",
+		initialValue: state.branding?.description
+	});
+	if (isCancel(description)) process.exit(0);
+	const domain = await text({
+		message: "What's your domain? (for emails, auth origins)",
+		placeholder: "mysaasapp.com",
+		initialValue: state.branding?.domain,
+		validate: (v) => {
+			if (v && !isValidDomain(v)) return "Enter a valid domain (e.g. myapp.com)";
+		}
+	});
+	if (isCancel(domain)) process.exit(0);
+	const s = spinner();
+	s.start("Updating files...");
+	const kebabName = toKebabCase(appName);
+	updateJsonFile("package.json", { name: kebabName });
+	updateAppConfig("src/lib/config/app.config.ts", appName, description);
+	s.stop("Files updated");
+	log.success(`package.json → name: "${kebabName}"`);
+	log.success(`app.config.ts → name: "${appName}"`);
+	state.branding = {
+		appName,
+		description,
+		domain: domain || ""
+	};
+	markPhaseCompleted(state, "branding");
+	await saveState(state);
+	return state;
+}
+
+//#endregion
+//#region src/phases/database.ts
+async function runDatabase(state) {
+	const dbChoice = await select({
+		message: "Do you already have a PostgreSQL database?",
+		options: [{
+			value: "own",
+			label: "Yes, I have a connection URL"
+		}, {
+			value: "instagres",
+			label: "No, create one instantly with Instagres (pg.new)",
+			hint: "free 72h, claim to keep"
+		}]
+	});
+	if (isCancel(dbChoice)) process.exit(0);
+	let databaseUrl;
+	if (dbChoice === "instagres") {
+		const s = spinner();
+		s.start("Creating instant Neon database via Instagres...");
+		const result = await exec("bunx get-db --yes --env .env --key DATABASE_URL");
+		if (result.exitCode !== 0) {
+			s.stop("Failed to create database");
+			log.error(`get-db failed: ${result.stderr}`);
+			log.info("You can try manually: npx get-db --yes");
+			log.info("Or provide your own DATABASE_URL and re-run: bunx create-start-kit-dev init --step database");
+			process.exit(1);
+		}
+		s.stop("Database created!");
+		databaseUrl = readEnvFile(".env").DATABASE_URL ?? "";
+		if (!databaseUrl) {
+			log.error("DATABASE_URL not found in .env after get-db. Check .env manually.");
+			process.exit(1);
+		}
+		log.success("DATABASE_URL written to .env");
+		log.warn("This database expires in 72 hours.");
+		log.info("Claim it at https://neon.tech or run: npx get-db claim");
+	} else {
+		const url = await text({
+			message: "Enter your DATABASE_URL:",
+			placeholder: "postgresql://user:pass@host:5432/mydb",
+			validate: (v) => {
+				if (!isValidPostgresUrl(v)) return "Must start with postgresql:// or postgres://";
+			}
+		});
+		if (isCancel(url)) process.exit(0);
+		databaseUrl = url;
+	}
+	const s = spinner();
+	s.start("Testing database connection...");
+	const test = await testDbConnection(databaseUrl);
+	if (!test.ok) {
+		s.stop("Connection failed");
+		log.error(`Could not connect: ${test.error}`);
+		log.info("Check your DATABASE_URL and try again.");
+		process.exit(1);
+	}
+	s.stop("Connected to PostgreSQL");
+	const shouldMigrate = await confirm({
+		message: "Run database migrations now?",
+		initialValue: true
+	});
+	if (isCancel(shouldMigrate)) process.exit(0);
+	if (shouldMigrate) {
+		const ms = spinner();
+		ms.start("Running migrations...");
+		const envVars = readEnvFile(".env");
+		if (!envVars.DATABASE_URL) {
+			envVars.DATABASE_URL = databaseUrl;
+			writeEnvFile(".env", envVars);
+		}
+		const migrateResult = await exec("bun run db:push");
+		if (migrateResult.exitCode !== 0) {
+			ms.stop("Migration failed");
+			log.error(migrateResult.stderr);
+			log.info("You can run migrations later with: bun run db:push");
+		} else ms.stop("Migrations applied!");
+	}
+	state.database = {
+		provider: dbChoice,
+		migrated: shouldMigrate === true
+	};
+	markPhaseCompleted(state, "database");
+	await saveState(state);
+	return state;
+}
+
+//#endregion
+//#region src/phases/env.ts
+const DUMMY_VALUES = {
+	RESEND_API_KEY: "re_dummy_replace_me",
+	S3_ACCESS_KEY_ID: "dummy_replace_me",
+	S3_SECRET_ACCESS_KEY: "dummy_replace_me",
+	S3_BUCKET: "dummy-bucket"
+};
+function setupCoreVars(ctx) {
+	if (!ctx.envVars.BETTER_AUTH_SECRET || ctx.envVars.BETTER_AUTH_SECRET.includes("haha")) {
+		ctx.envVars.BETTER_AUTH_SECRET = generateSecret();
+		log.success("BETTER_AUTH_SECRET — auto-generated");
+	} else log.info("BETTER_AUTH_SECRET — keeping existing value");
+	ctx.envVars.BETTER_AUTH_BASE_URL = ctx.envVars.BETTER_AUTH_BASE_URL ?? "http://localhost:3000";
+	ctx.envVars.VITE_BETTER_AUTH_BASE_URL = ctx.envVars.VITE_BETTER_AUTH_BASE_URL ?? "http://localhost:3000";
+}
+async function setupEmail(ctx, enabled) {
+	if (enabled) {
+		const resendKey = await text({
+			message: "RESEND_API_KEY (get one at resend.com, or Enter for placeholder):",
+			placeholder: "re_xxxxxxxxxxxx",
+			initialValue: ctx.envVars.RESEND_API_KEY
+		});
+		if (isCancel(resendKey)) process.exit(0);
+		if (!resendKey || resendKey === DUMMY_VALUES.RESEND_API_KEY) {
+			ctx.envVars.RESEND_API_KEY = DUMMY_VALUES.RESEND_API_KEY;
+			ctx.placeholders.push("RESEND_API_KEY");
+			log.warn("Using placeholder — emails will fail until you add a real key");
+		} else ctx.envVars.RESEND_API_KEY = resendKey;
+		const domain = ctx.state.branding?.domain ?? "yourdomain.com";
+		const appName = ctx.state.branding?.appName ?? "App";
+		ctx.envVars.RESEND_FROM_EMAIL = ctx.envVars.RESEND_FROM_EMAIL ?? `${appName} <noreply@${domain}>`;
+		return;
+	}
+	ctx.envVars.RESEND_API_KEY = ctx.envVars.RESEND_API_KEY ?? DUMMY_VALUES.RESEND_API_KEY;
+	if (ctx.envVars.RESEND_API_KEY === DUMMY_VALUES.RESEND_API_KEY) ctx.placeholders.push("RESEND_API_KEY");
+}
+async function setupStorageCredentials(ctx) {
+	const accessKey = await text({
+		message: "S3_ACCESS_KEY_ID:",
+		initialValue: ctx.envVars.S3_ACCESS_KEY_ID
+	});
+	if (isCancel(accessKey)) process.exit(0);
+	ctx.envVars.S3_ACCESS_KEY_ID = accessKey;
+	const secretKey = await text({
+		message: "S3_SECRET_ACCESS_KEY:",
+		initialValue: ctx.envVars.S3_SECRET_ACCESS_KEY
+	});
+	if (isCancel(secretKey)) process.exit(0);
+	ctx.envVars.S3_SECRET_ACCESS_KEY = secretKey;
+	const bucket = await text({
+		message: "S3_BUCKET:",
+		initialValue: ctx.envVars.S3_BUCKET ?? "app-assets"
+	});
+	if (isCancel(bucket)) process.exit(0);
+	ctx.envVars.S3_BUCKET = bucket;
+	const endpoint = await text({
+		message: "S3_ENDPOINT (optional, Enter to skip):",
+		initialValue: ctx.envVars.S3_ENDPOINT
+	});
+	if (isCancel(endpoint)) process.exit(0);
+	if (endpoint) ctx.envVars.S3_ENDPOINT = endpoint;
+	ctx.envVars.S3_REGION = ctx.envVars.S3_REGION ?? "us-east-1";
+	ctx.envVars.STORAGE_PROVIDER = ctx.envVars.STORAGE_PROVIDER ?? "s3";
+}
+function setSeaweedfsDefaults(ctx) {
+	ctx.envVars.STORAGE_PROVIDER = "seaweedfs";
+	ctx.envVars.S3_ENDPOINT = "http://localhost:8333";
+	ctx.envVars.S3_ACCESS_KEY_ID = "minioadmin";
+	ctx.envVars.S3_SECRET_ACCESS_KEY = "minioadmin";
+	ctx.envVars.S3_BUCKET = "app-assets";
+	ctx.envVars.S3_REGION = "us-east-1";
+	if (ctx.state.infra) ctx.state.infra.seaweedfs = true;
+	else ctx.state.infra = {
+		seaweedfs: true,
+		redis: false
+	};
+}
+function setStorageDummies(ctx) {
+	ctx.envVars.STORAGE_PROVIDER = ctx.envVars.STORAGE_PROVIDER ?? "s3";
+	ctx.envVars.S3_ACCESS_KEY_ID = DUMMY_VALUES.S3_ACCESS_KEY_ID;
+	ctx.envVars.S3_SECRET_ACCESS_KEY = DUMMY_VALUES.S3_SECRET_ACCESS_KEY;
+	ctx.envVars.S3_BUCKET = DUMMY_VALUES.S3_BUCKET;
+	ctx.envVars.S3_REGION = "us-east-1";
+	ctx.placeholders.push("S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY", "S3_BUCKET");
+	log.warn("Using placeholders — file uploads will fail until configured");
+}
+async function setupStorage(ctx, enabled) {
+	if (!enabled) {
+		ctx.envVars.STORAGE_PROVIDER = ctx.envVars.STORAGE_PROVIDER ?? "s3";
+		ctx.envVars.S3_ACCESS_KEY_ID = ctx.envVars.S3_ACCESS_KEY_ID ?? DUMMY_VALUES.S3_ACCESS_KEY_ID;
+		ctx.envVars.S3_SECRET_ACCESS_KEY = ctx.envVars.S3_SECRET_ACCESS_KEY ?? DUMMY_VALUES.S3_SECRET_ACCESS_KEY;
+		ctx.envVars.S3_BUCKET = ctx.envVars.S3_BUCKET ?? DUMMY_VALUES.S3_BUCKET;
+		ctx.envVars.S3_REGION = ctx.envVars.S3_REGION ?? "us-east-1";
+		if (ctx.envVars.S3_ACCESS_KEY_ID === DUMMY_VALUES.S3_ACCESS_KEY_ID) ctx.placeholders.push("S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY", "S3_BUCKET");
+		return;
+	}
+	const storageChoice = await select({
+		message: "Do you have S3-compatible storage credentials?",
+		options: [
+			{
+				value: "dummy",
+				label: "No, use placeholder values",
+				hint: "storage calls will fail gracefully"
+			},
+			{
+				value: "credentials",
+				label: "Yes, I have credentials (S3, R2, Minio, etc.)"
+			},
+			{
+				value: "seaweedfs",
+				label: "Start SeaweedFS via Docker (local S3)"
+			}
+		]
+	});
+	if (isCancel(storageChoice)) process.exit(0);
+	if (storageChoice === "credentials") await setupStorageCredentials(ctx);
+	else if (storageChoice === "seaweedfs") setSeaweedfsDefaults(ctx);
+	else setStorageDummies(ctx);
+}
+async function setupStripe(ctx) {
+	const stripeSecret = await text({
+		message: "STRIPE_SECRET_KEY (Enter to skip):",
+		placeholder: "sk_test_xxxxx",
+		initialValue: ctx.envVars.STRIPE_SECRET_KEY
+	});
+	if (isCancel(stripeSecret)) process.exit(0);
+	if (!stripeSecret) {
+		log.info("Stripe skipped — payments feature will be disabled");
+		return;
+	}
+	ctx.envVars.STRIPE_SECRET_KEY = stripeSecret;
+	const webhookSecret = await text({
+		message: "STRIPE_WEBHOOK_SECRET:",
+		placeholder: "whsec_xxxxx",
+		initialValue: ctx.envVars.STRIPE_WEBHOOK_SECRET
+	});
+	if (isCancel(webhookSecret)) process.exit(0);
+	if (webhookSecret) ctx.envVars.STRIPE_WEBHOOK_SECRET = webhookSecret;
+	const publishableKey = await text({
+		message: "STRIPE_PUBLISHABLE_KEY (for client):",
+		placeholder: "pk_test_xxxxx",
+		initialValue: ctx.envVars.STRIPE_PUBLISHABLE_KEY
+	});
+	if (isCancel(publishableKey)) process.exit(0);
+	if (publishableKey) {
+		ctx.envVars.STRIPE_PUBLISHABLE_KEY = publishableKey;
+		ctx.envVars.VITE_STRIPE_ENABLED = "true";
+	}
+}
+async function setupAI(ctx) {
+	const openai = await text({
+		message: "OpenAI API key (optional, Enter to skip):",
+		placeholder: "sk-proj-xxxxx",
+		initialValue: ctx.envVars.OPENAI_API_KEY
+	});
+	if (isCancel(openai)) process.exit(0);
+	if (openai) ctx.envVars.OPENAI_API_KEY = openai;
+	const anthropic = await text({
+		message: "Anthropic API key (optional, Enter to skip):",
+		initialValue: ctx.envVars.ANTHROPIC_API_KEY
+	});
+	if (isCancel(anthropic)) process.exit(0);
+	if (anthropic) ctx.envVars.ANTHROPIC_API_KEY = anthropic;
+}
+async function setupRedis(ctx) {
+	const redisChoice = await select({
+		message: "Do you have an external Redis?",
+		options: [
+			{
+				value: "skip",
+				label: "No, skip",
+				hint: "chat won't have resumable streams"
+			},
+			{
+				value: "url",
+				label: "Yes, I have a Redis URL"
+			},
+			{
+				value: "docker",
+				label: "Start Redis via Docker"
+			}
+		]
+	});
+	if (isCancel(redisChoice)) process.exit(0);
+	if (redisChoice === "url") {
+		const redisUrl = await text({
+			message: "REDIS_URL:",
+			placeholder: "redis://localhost:6379",
+			initialValue: ctx.envVars.REDIS_URL
+		});
+		if (isCancel(redisUrl)) process.exit(0);
+		if (redisUrl) ctx.envVars.REDIS_URL = redisUrl;
+	} else if (redisChoice === "docker") {
+		ctx.envVars.REDIS_URL = "redis://localhost:6379";
+		if (ctx.state.infra) ctx.state.infra.redis = true;
+		else ctx.state.infra = {
+			seaweedfs: false,
+			redis: true
+		};
+	}
+}
+async function runEnv(state) {
+	const features = state.features ?? {
+		stripe: false,
+		ai: false,
+		storage: false,
+		redis: false,
+		email: false
+	};
+	const ctx = {
+		envVars: { ...readEnvFile(".env") },
+		placeholders: [],
+		state
+	};
+	setupCoreVars(ctx);
+	await setupEmail(ctx, features.email);
+	await setupStorage(ctx, features.storage);
+	if (features.stripe) await setupStripe(ctx);
+	if (features.ai) await setupAI(ctx);
+	if (features.redis) await setupRedis(ctx);
+	const s = spinner();
+	s.start("Writing .env file...");
+	writeEnvFile(".env", ctx.envVars);
+	s.stop(`.env written (${Object.keys(ctx.envVars).length} variables)`);
+	if (ctx.placeholders.length > 0) {
+		log.warn(`${ctx.placeholders.length} placeholders need real values later:`);
+		for (const p of ctx.placeholders) log.warn(`  \u2022 ${p}`);
+	}
+	state.env = {
+		placeholders: ctx.placeholders,
+		written: true
+	};
+	markPhaseCompleted(state, "env");
+	await saveState(state);
+	return state;
+}
+
+//#endregion
+//#region src/phases/features.ts
+const FEATURE_OPTIONS = [
+	{
+		value: "stripe",
+		label: "Stripe",
+		hint: "payments & subscriptions"
+	},
+	{
+		value: "ai",
+		label: "AI Chat",
+		hint: "OpenAI / Anthropic / Gemini"
+	},
+	{
+		value: "storage",
+		label: "Storage",
+		hint: "S3 / SeaweedFS / R2 / Minio"
+	},
+	{
+		value: "redis",
+		label: "Redis",
+		hint: "resumable chat streams"
+	},
+	{
+		value: "email",
+		label: "Email",
+		hint: "Resend — transactional emails"
+	}
+];
+async function runFeatures(state) {
+	const selected = await multiselect({
+		message: "Which features do you want to enable?",
+		options: FEATURE_OPTIONS.map((f) => ({
+			value: f.value,
+			label: `${f.label} (${f.hint})`
+		})),
+		initialValues: state.features ? Object.entries(state.features).filter(([, v]) => v).map(([k]) => k) : [],
+		required: false
+	});
+	if (isCancel(selected)) process.exit(0);
+	const features = {
+		stripe: selected.includes("stripe"),
+		ai: selected.includes("ai"),
+		storage: selected.includes("storage"),
+		redis: selected.includes("redis"),
+		email: selected.includes("email")
+	};
+	const enabled = Object.entries(features).filter(([, v]) => v).map(([k]) => k);
+	if (enabled.length > 0) log.success(`Enabled: ${enabled.join(", ")}`);
+	else log.info("No optional features selected — core app only");
+	state.features = features;
+	markPhaseCompleted(state, "features");
+	await saveState(state);
+	return state;
+}
+
+//#endregion
+//#region src/phases/infra.ts
+async function startDockerService(name, service, successMsg) {
+	const s = spinner();
+	s.start(`Starting ${name}...`);
+	const result = await exec(`docker compose up -d ${service}`);
+	if (result.exitCode !== 0) {
+		s.stop(`Failed to start ${name}`);
+		log.error(result.stderr);
+		log.info(`Make sure Docker is running, then try: docker compose up -d ${service}`);
+	} else s.stop(successMsg);
+}
+async function checkDatabase(envVars) {
+	if (!envVars.DATABASE_URL) return;
+	const db = await testDbConnection(envVars.DATABASE_URL);
+	return db.ok ? "Database — connected" : `Database — failed: ${db.error}`;
+}
+async function checkRedis(envVars) {
+	if (!envVars.REDIS_URL) return;
+	try {
+		const { RedisClient } = await import("bun");
+		const redis = new RedisClient(envVars.REDIS_URL);
+		await redis.connect();
+		await redis.disconnect();
+		return "Redis — connected";
+	} catch {
+		return "Redis — not reachable (will use fallback)";
+	}
+}
+async function runInfra(state) {
+	const needsSeaweedfs = state.infra?.seaweedfs ?? false;
+	const needsRedis = state.infra?.redis ?? false;
+	if (needsSeaweedfs || needsRedis) {
+		if (needsSeaweedfs) await startDockerService("SeaweedFS (local S3)", "seaweedfs", "SeaweedFS running on localhost:8333");
+		if (needsRedis) await startDockerService("Redis", "redis", "Redis running on localhost:6379");
+	} else {
+		log.info("No Docker services needed!");
+		log.info("Your setup uses external services or placeholders.");
+	}
+	const checks = spinner();
+	checks.start("Running final checks...");
+	const envVars = readEnvFile(".env");
+	const results = (await Promise.all([checkDatabase(envVars), checkRedis(envVars)])).filter((r) => r !== void 0);
+	checks.stop("Health checks complete");
+	for (const r of results) if (r.includes("failed") || r.includes("not reachable")) log.warn(r);
+	else log.success(r);
+	markPhaseCompleted(state, "infra");
+	await saveState(state);
+	return state;
+}
+
+//#endregion
+//#region src/phases/scaffold.ts
+const TEMPLATE_URI = "gh:CarlosZiegler/start-kit.dev/apps/start-template#main";
+async function fetchTemplate(targetDir) {
+	const s = spinner();
+	s.start("Downloading template...");
+	try {
+		await downloadTemplate(TEMPLATE_URI, {
+			dir: targetDir,
+			force: false
+		});
+		s.stop("Template downloaded");
+	} catch (error) {
+		s.stop("Download failed");
+		log.error(String(error));
+		process.exit(1);
+	}
+	await exec(`git -C "${targetDir}" init`);
+}
+async function installDeps(targetDir) {
+	const s = spinner();
+	s.start("Installing dependencies...");
+	const result = await exec(`cd "${targetDir}" && bun install`);
+	if (result.exitCode !== 0) {
+		s.stop("Install failed");
+		log.error(result.stderr);
+		log.info(`Try manually: cd ${targetDir} && bun install`);
+		process.exit(1);
+	}
+	s.stop("Dependencies installed");
+}
+async function runScaffold(projectNameArg) {
+	let projectName = projectNameArg;
+	if (!projectName) {
+		const name = await text({
+			message: "What's your project name?",
+			placeholder: "my-saas-app",
+			validate: (v = "") => {
+				if (!isValidAppName(v)) return "Name must be 2-50 characters";
+			}
+		});
+		if (isCancel(name)) process.exit(0);
+		projectName = name;
+	}
+	const dirName = toKebabCase(projectName);
+	const targetDir = `${process.cwd()}/${dirName}`;
+	if (existsSync(targetDir)) {
+		log.error(`Directory "${dirName}" already exists.`);
+		process.exit(1);
+	}
+	log.info(`Creating project in ./${dirName}`);
+	await fetchTemplate(targetDir);
+	await installDeps(targetDir);
+	await exec(`rm -f "${targetDir}/.setup-state.json"`);
+	log.success(`Project created in ./${dirName}`);
+	return targetDir;
+}
+
+//#endregion
+//#region src/index.ts
+const PHASES = [
+	{
+		key: "branding",
+		label: "Branding",
+		run: runBranding
+	},
+	{
+		key: "features",
+		label: "Features",
+		run: runFeatures
+	},
+	{
+		key: "database",
+		label: "Database",
+		run: runDatabase
+	},
+	{
+		key: "env",
+		label: "Environment",
+		run: runEnv
+	},
+	{
+		key: "infra",
+		label: "Infrastructure",
+		run: runInfra
+	}
+];
+function showPhaseStatus(state) {
+	for (const phase of PHASES) {
+		const done = isPhaseCompleted(state, phase.key);
+		const icon = done ? "✓" : "○";
+		log.info(`${icon} ${phase.label}${done ? " (completed)" : ""}`);
+	}
+}
+async function getResumeStartIndex(state) {
+	const firstIncomplete = PHASES.findIndex((p) => !isPhaseCompleted(state, p.key));
+	const options = [];
+	if (firstIncomplete >= 0) options.push({
+		value: "continue",
+		label: `Continue from ${PHASES[firstIncomplete].label}`
+	});
+	options.push({
+		value: "start-over",
+		label: "Start over"
+	}, {
+		value: "jump",
+		label: "Jump to a specific phase"
+	});
+	const choice = await select({
+		message: "What would you like to do?",
+		options
+	});
+	if (isCancel(choice)) process.exit(0);
+	if (choice === "continue") return firstIncomplete;
+	if (choice === "start-over") return -1;
+	return await selectPhase(state);
+}
+async function selectPhase(state) {
+	const jumpTo = await select({
+		message: "Which phase?",
+		options: PHASES.map((p, i) => ({
+			value: i,
+			label: p.label,
+			hint: isPhaseCompleted(state, p.key) ? "completed" : void 0
+		}))
+	});
+	if (isCancel(jumpTo)) process.exit(0);
+	return jumpTo;
+}
+async function runSinglePhase(targetStep, state) {
+	const phase = PHASES.find((p) => p.key === targetStep);
+	if (!phase) {
+		log.error(`Unknown phase: ${targetStep}`);
+		log.info(`Available: ${PHASES.map((p) => p.key).join(", ")}`);
+		process.exit(1);
+	}
+	await phase.run(state);
+	outro(`Phase "${phase.label}" complete!`);
+}
+async function runWizard(state) {
+	showPhaseStatus(state);
+	let startFrom = 0;
+	let currentState = state;
+	if (state.completedPhases.length > 0) {
+		const resumeIndex = await getResumeStartIndex(state);
+		if (resumeIndex === -1) currentState = {
+			version: 1,
+			completedPhases: []
+		};
+		else startFrom = resumeIndex;
+	}
+	for (let i = startFrom; i < PHASES.length; i++) {
+		const phase = PHASES[i];
+		log.step(`Phase ${i + 1}/${PHASES.length}: ${phase.label}`);
+		currentState = await phase.run(currentState);
+	}
+	outro("Setup complete! Run `bun dev` to start your app.");
+}
+function showUsage() {
+	console.log("Usage:");
+	console.log("  bunx create-start-kit-dev create [project-name]   Create a new project");
+	console.log("  bunx create-start-kit-dev init [--step <phase>]    Setup existing project");
+	console.log("");
+	console.log("Phases: branding, features, database, env, infra");
+}
+async function handleCreate(args) {
+	const projectName = args.at(1);
+	intro("Start Kit — Create New Project");
+	const targetDir = await runScaffold(projectName);
+	process.chdir(targetDir);
+	log.step("Now let's configure your project...");
+	await runWizard(loadState());
+}
+async function handleInit(args) {
+	const stepIndex = args.indexOf("--step");
+	const targetStep = stepIndex >= 0 ? args.at(stepIndex + 1) : void 0;
+	intro("Start Kit Setup");
+	const state = loadState();
+	if (targetStep) await runSinglePhase(targetStep, state);
+	else await runWizard(state);
+}
+async function main() {
+	const args = process.argv.slice(2);
+	const command = args.at(0);
+	if (command === "create") {
+		await handleCreate(args);
+		return;
+	}
+	if (command === "init") {
+		await handleInit(args);
+		return;
+	}
+	showUsage();
+}
+main().catch((error) => {
+	console.error("Setup failed:", error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "create-start-kit-dev",
+  "version": "0.1.0",
+  "description": "CLI for scaffolding and configuring Start Kit projects",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "Carlos Ziegler",
+    "url": "https://github.com/CarlosZiegler"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CarlosZiegler/start-kit.dev",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/CarlosZiegler/start-kit.dev#readme",
+  "bugs": {
+    "url": "https://github.com/CarlosZiegler/start-kit.dev/issues"
+  },
+  "keywords": [
+    "cli",
+    "starter",
+    "template",
+    "tanstack",
+    "tanstack-start",
+    "bun",
+    "typescript",
+    "scaffold",
+    "create"
+  ],
+  "bin": {
+    "create-start-kit-dev": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "giget": "^3.1.2",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}