alepha 0.14.2 → 0.14.4

package/dist/cli/index.js

@@ -1,17 +1,108 @@
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, OPTIONS, t } from "alepha";
+import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, t } from "alepha";
 import { FileSystemProvider } from "alepha/file";
 import { access, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import { $command, CliProvider, EnvUtils } from "alepha/command";
-import { $logger } from "alepha/logger";
-import { boot, buildClient, buildServer, copyAssets, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
+import { $logger, ConsoleColorProvider } from "alepha/logger";
+import { boot, buildClient, buildServer, copyAssets, devServer, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
 import { exec, spawn } from "node:child_process";
-import { tsImport } from "tsx/esm/api";
 import { readFileSync } from "node:fs";
 import { promisify } from "node:util";
+import { ServerSwaggerProvider } from "alepha/server/swagger";
 import * as os from "node:os";
 
+//#region ../../src/core/constants/KIND.ts
+/**
+* Used for identifying primitives.
+*
+* @internal
+*/
+const KIND = Symbol.for("Alepha.Kind");
+
+//#endregion
+//#region ../../src/core/primitives/$atom.ts
+/**
+* Define an atom for state management.
+*
+* Atom lets you define a piece of state with a name, schema, and default value.
+*
+* By default, Alepha state is just a simple key-value store.
+* Using atoms allows you to have type safety, validation, and default values for your state.
+*
+* You control how state is structured and validated.
+*
+* Features:
+* - Set a schema for validation
+* - Set a default value for initial state
+* - Rules, like read-only, custom validation, etc.
+* - Automatic getter access in services with {@link $use}
+* - SSR support (server state automatically serialized and hydrated on client)
+* - React integration (useAtom hook for automatic component re-renders)
+* - Middleware
+* - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
+* - State migrations (version upgrades when schema changes)
+* - Documentation generation & devtools integration
+*
+* Common use cases:
+* - user preferences
+* - feature flags
+* - configuration options
+* - session data
+*
+* Atom must contain only serializable data.
+* Avoid storing complex objects like class instances, functions, or DOM elements.
+* If you need to store complex data, consider using identifiers or references instead.
+*/
+const $atom$1 = (options) => {
+	return new Atom(options);
+};
+var Atom = class {
+	options;
+	get schema() {
+		return this.options.schema;
+	}
+	get key() {
+		return this.options.name;
+	}
+	constructor(options) {
+		this.options = options;
+	}
+};
+$atom$1[KIND] = "atom";
+
+//#endregion
+//#region ../../src/cli/atoms/buildOptions.ts
+/**
+* Build options atom for CLI build command.
+*
+* Defines the available build configuration options with their defaults.
+* Options can be overridden via vite.config.ts or CLI flags.
+*/
+const buildOptions = $atom$1({
+	name: "alepha.build.options",
+	description: "Build configuration options",
+	schema: t.object({
+		stats: t.optional(t.boolean({ default: false })),
+		vercel: t.optional(t.object({
+			projectName: t.optional(t.string()),
+			orgId: t.optional(t.string()),
+			projectId: t.optional(t.string()),
+			config: t.optional(t.object({ crons: t.optional(t.array(t.object({
+				path: t.string(),
+				schedule: t.string()
+			}))) }))
+		})),
+		cloudflare: t.optional(t.object({ config: t.optional(t.json()) })),
+		docker: t.optional(t.object({
+			image: t.optional(t.string({ default: "node:24-alpine" })),
+			command: t.optional(t.string({ default: "node" }))
+		})),
+		sitemap: t.optional(t.object({ hostname: t.string() }))
+	}),
+	default: {}
+});
+
+//#endregion
 //#region ../../src/cli/assets/appRouterTs.ts
 const appRouterTs = () => `
 import { $page } from "@alepha/react/router";
@@ -138,21 +229,6 @@ const tsconfigJson = `
 }
 `.trim();
 
-//#endregion
-//#region ../../src/cli/assets/viteConfigTs.ts
-const viteConfigTs = (serverEntry) => `
-import { viteAlepha } from "alepha/vite";
-
-export default {
-  plugins: [
-    viteAlepha(${serverEntry ? `{ serverEntry: "${serverEntry}" }` : ""}),
-  ],
-  test: {
-    globals: true,
-  },
-};
-`.trim();
-
 //#endregion
 //#region ../../src/cli/version.ts
 const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
@@ -174,6 +250,7 @@ var AlephaCliUtils = class {
 	log = $logger();
 	fs = $inject(FileSystemProvider);
 	envUtils = $inject(EnvUtils);
+	alepha = $inject(Alepha);
 	/**
 	* Execute a command using npx with inherited stdio.
 	*
@@ -235,6 +312,54 @@ var AlephaCliUtils = class {
 		this.log.debug(`Config file written: ${path}`);
 		return path;
 	}
+	async editFile(root, name, editFn) {
+		const filePath = join(root, name);
+		try {
+			await writeFile(filePath, await editFn(await readFile(filePath, "utf8")));
+		} catch (error) {
+			this.log.debug("Could not edit file", error);
+		}
+	}
+	async editJsonFile(root, name, editFn) {
+		return await this.editFile(root, name, async (content) => {
+			const newObj = await editFn(JSON.parse(content));
+			return JSON.stringify(newObj, null, 2);
+		});
+	}
+	async removeFiles(root, files) {
+		await Promise.all(files.map((file) => this.fs.rm(join(root, file), {
+			force: true,
+			recursive: true
+		})));
+	}
+	async removeYarn(root) {
+		await this.removeFiles(root, [
+			".yarn",
+			".yarnrc.yml",
+			"yarn.lock"
+		]);
+		await this.editJsonFile(root, "package.json", (pkg) => {
+			delete pkg.packageManager;
+		});
+	}
+	async removePnpm(root) {
+		await this.removeFiles(root, ["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
+		await this.editJsonFile(root, "package.json", (pkg) => {
+			delete pkg.packageManager;
+		});
+	}
+	async removeNpm(root) {
+		await this.removeFiles(root, ["package-lock.json"]);
+	}
+	async removeBun(root) {
+		await this.removeFiles(root, ["bun.lockb", "bun.lock"]);
+	}
+	async removeAllPmFilesExcept(root, except) {
+		if (except !== "yarn") await this.removeYarn(root);
+		if (except !== "pnpm") await this.removePnpm(root);
+		if (except !== "npm") await this.removeNpm(root);
+		if (except !== "bun") await this.removeBun(root);
+	}
 	/**
 	* Ensure Yarn is configured in the project directory.
 	*
@@ -244,26 +369,16 @@ var AlephaCliUtils = class {
 	*/
 	async ensureYarn(root) {
 		await this.ensureFileExists(root, ".yarnrc.yml", "nodeLinker: node-modules", false);
-		await this.fs.rm(join(root, "package-lock.json"), { force: true });
-		await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
+		await this.removeAllPmFilesExcept(root, "yarn");
+	}
+	async ensureBun(root) {
+		await this.removeAllPmFilesExcept(root, "bun");
 	}
 	async ensurePnpm(root) {
-		await this.fs.rm(join(root, "package-lock.json"), { force: true });
-		await this.fs.rm(join(root, "yarn.lock"), { force: true });
-		await this.fs.rm(join(root, ".yarn"), {
-			force: true,
-			recursive: true
-		});
-		await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+		await this.removeAllPmFilesExcept(root, "pnpm");
 	}
 	async ensureNpm(root) {
-		await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
-		await this.fs.rm(join(root, "yarn.lock"), { force: true });
-		await this.fs.rm(join(root, ".yarn"), {
-			force: true,
-			recursive: true
-		});
-		await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+		await this.removeAllPmFilesExcept(root, "npm");
 	}
 	/**
 	* Generate package.json content with Alepha dependencies.
@@ -335,7 +450,6 @@ var AlephaCliUtils = class {
 		const tasks = [];
 		if (opts.packageJson) tasks.push(this.ensurePackageJson(root, typeof opts.packageJson === "boolean" ? {} : opts.packageJson));
 		if (opts.tsconfigJson) tasks.push(this.ensureTsConfig(root));
-		if (opts.viteConfigTs) tasks.push(this.ensureViteConfig(root));
 		if (opts.indexHtml) tasks.push(this.ensureIndexHtml(root));
 		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root));
 		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root));
@@ -351,14 +465,6 @@ var AlephaCliUtils = class {
 	async ensureTsConfig(root) {
 		await this.ensureFileExists(root, "tsconfig.json", tsconfigJson, true);
 	}
-	/**
-	* Ensure vite.config.ts exists in the project.
-	*
-	* Creates a standard Alepha vite.config.ts if none exists.
-	*/
-	async ensureViteConfig(root, serverEntry) {
-		await this.ensureFileExists(root, "vite.config.ts", viteConfigTs(serverEntry), false);
-	}
 	async checkFileExists(root, name, checkParentDirectories = false) {
 		const configPath = join(root, name);
 		if (!checkParentDirectories) try {
@@ -418,7 +524,8 @@ var AlephaCliUtils = class {
 	async loadAlephaFromServerEntryFile(rootDir, explicitEntry) {
 		process.env.ALEPHA_CLI_IMPORT = "true";
 		const entry = await boot.getServerEntry(rootDir, explicitEntry);
-		const mod = await tsImport(entry, { parentURL: import.meta.url });
+		delete global.__alepha;
+		const mod = await import(entry);
 		this.log.debug(`Load entry: ${entry}`);
 		if (mod.default instanceof Alepha) return {
 			alepha: mod.default,
@@ -470,6 +577,7 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 		if (flags?.pnpm) return "pnpm";
 		if (flags?.npm) return "npm";
 		if (flags?.bun) return "bun";
+		if (this.alepha.isBun()) return "bun";
 		if (await this.checkFileExists(root, "yarn.lock", true)) return "yarn";
 		if (await this.checkFileExists(root, "pnpm-lock.yaml", true)) return "pnpm";
 		return "npm";
@@ -527,7 +635,7 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 		if ((await this.fs.ls(testDir)).length === 0) await this.fs.writeFile(dummyPath, dummySpecTs());
 	}
 	async readPackageJson(root) {
-		const packageJson$1 = await this.fs.createFile({ path: join(root, "package.json") }).text();
+		const packageJson$1 = await this.fs.createFile({ path: this.fs.join(root, "package.json") }).text();
 		return JSON.parse(packageJson$1);
 	}
 	/**
@@ -554,6 +662,23 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 	async hasExpo(root) {
 		return this.hasDependency(root, "expo");
 	}
+	async getInstallCommand(root, packageName, dev = true) {
+		const pm = await this.getPackageManager(root);
+		let cmd;
+		switch (pm) {
+			case "yarn":
+				cmd = `yarn add ${dev ? "-D" : ""} ${packageName}`;
+				break;
+			case "pnpm":
+				cmd = `pnpm add ${dev ? "-D" : ""} ${packageName}`;
+				break;
+			case "bun":
+				cmd = `bun add ${dev ? "-d" : ""} ${packageName}`;
+				break;
+			default: cmd = `npm install ${dev ? "--save-dev" : ""} ${packageName}`;
+		}
+		return cmd.replace(/\s+/g, " ").trim();
+	}
 	/**
 	* Install a dependency if it's missing from the project.
 	*
@@ -566,18 +691,7 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 			this.log.debug(`Dependency '${packageName}' is already installed`);
 			return;
 		}
-		const pm = await this.getPackageManager(root);
-		let cmd;
-		switch (pm) {
-			case "yarn":
-				cmd = `yarn add ${dev ? "-D" : ""} ${packageName}`;
-				break;
-			case "pnpm":
-				cmd = `pnpm add ${dev ? "-D" : ""} ${packageName}`;
-				break;
-			default: cmd = `npm install ${dev ? "--save-dev" : ""} ${packageName}`;
-		}
-		cmd = cmd.replace(/\s+/g, " ").trim();
+		const cmd = await this.getInstallCommand(root, packageName, dev);
 		if (options.run) await options.run(cmd, { alias: `installing ${packageName}` });
 		else {
 			this.log.debug(`Installing ${packageName}`);
@@ -591,8 +705,10 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 var BuildCommand = class {
 	log = $logger();
 	utils = $inject(AlephaCliUtils);
+	options = $use(buildOptions);
 	build = $command({
 		name: "build",
+		mode: "production",
 		description: "Build the project for production",
 		args: t.optional(t.text({
 			title: "path",
@@ -609,33 +725,28 @@ var BuildCommand = class {
 			process.env.ALEPHA_BUILD_MODE = "cli";
 			process.env.NODE_ENV = "production";
 			if (await this.utils.hasExpo(root)) return;
-			await this.utils.ensureConfig(root, {
-				viteConfigTs: true,
-				tsconfigJson: true
-			});
+			await this.utils.ensureConfig(root, { tsconfigJson: true });
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
 			const distDir = "dist";
 			const clientDir = "public";
 			await this.utils.ensureDependency(root, "vite", { run });
 			await run.rm("dist", { alias: "clean dist" });
-			const viteAlephaBuildOptions = (await createRequire(import.meta.url)("vite").resolveConfig({}, "build", "production")).plugins.find((it) => it.name === "alepha:build")?.[OPTIONS] || {};
+			const options = this.options;
 			await this.utils.loadEnv(root, [".env", ".env.production"]);
-			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
-			const hasServer = viteAlephaBuildOptions.serverEntry !== false;
+			const stats = flags.stats ?? options.stats ?? false;
 			let hasClient = false;
 			try {
 				await access(join(root, "index.html"));
 				hasClient = true;
 			} catch {}
-			const clientOptions = typeof viteAlephaBuildOptions.client === "object" ? viteAlephaBuildOptions.client : {};
 			if (hasClient) await run({
 				name: "vite build client",
 				handler: () => buildClient({
 					silent: true,
 					dist: `${distDir}/${clientDir}`,
 					stats,
-					precompress: clientOptions.precompress
+					precompress: true
 				})
 			});
 			await run({
@@ -653,7 +764,7 @@ var BuildCommand = class {
 						clientDir: clientBuilt ? clientDir : void 0,
 						stats
 					});
-					if (clientBuilt && hasServer) await unlink(`${distDir}/${clientDir}/index.html`);
+					if (clientBuilt) await unlink(`${distDir}/${clientDir}/index.html`);
 				}
 			});
 			await copyAssets({
@@ -663,304 +774,79 @@ var BuildCommand = class {
 				run
 			});
 			if (hasClient) {
-				const sitemapBaseUrl = flags.sitemap ?? clientOptions.sitemap?.hostname;
-				if (sitemapBaseUrl) await run({
+				const sitemapHostname = flags.sitemap ?? options.sitemap?.hostname;
+				if (sitemapHostname) await run({
 					name: "add sitemap",
 					handler: async () => {
 						await writeFile(`${distDir}/${clientDir}/sitemap.xml`, await generateSitemap({
 							entry: `${distDir}/index.js`,
-							baseUrl: sitemapBaseUrl
+							baseUrl: sitemapHostname
 						}));
 					}
 				});
-				if (clientOptions.prerender) await run({
+				await run({
 					name: "pre-render pages",
 					handler: async () => {
 						await prerenderPages({
 							dist: `${distDir}/${clientDir}`,
 							entry: `${distDir}/index.js`,
-							compress: clientOptions.precompress
+							compress: true
 						});
 					}
 				});
 			}
-			if (flags.vercel || viteAlephaBuildOptions.vercel) {
-				const config = typeof viteAlephaBuildOptions.vercel === "object" ? viteAlephaBuildOptions.vercel : {};
-				await run({
-					name: "add Vercel config",
-					handler: () => generateVercel({
-						distDir,
-						clientDir,
-						config
-					})
-				});
-			}
-			if (flags.cloudflare || viteAlephaBuildOptions.cloudflare) {
-				const config = typeof viteAlephaBuildOptions.cloudflare === "boolean" ? {} : viteAlephaBuildOptions.cloudflare;
-				await run({
-					name: "add Cloudflare config",
-					handler: () => generateCloudflare({
-						distDir,
-						config
-					})
-				});
-			}
-			if (flags.docker || viteAlephaBuildOptions.docker) {
-				const dockerConfig = typeof viteAlephaBuildOptions.docker === "object" ? viteAlephaBuildOptions.docker : {};
-				await run({
-					name: "add Docker config",
-					handler: () => generateDocker({
-						distDir,
-						...dockerConfig
-					})
-				});
-			}
+			if (flags.vercel || options.vercel) await run({
+				name: "add Vercel config",
+				handler: () => generateVercel({
+					distDir,
+					clientDir,
+					config: options.vercel
+				})
+			});
+			if (flags.cloudflare || options.cloudflare) await run({
+				name: "add Cloudflare config",
+				handler: () => generateCloudflare({
+					distDir,
+					config: options.cloudflare?.config
+				})
+			});
+			if (flags.docker || options.docker) await run({
+				name: "add Docker config",
+				handler: () => generateDocker({
+					distDir,
+					...options.docker
+				})
+			});
 		}
 	});
 };
 
 //#endregion
-//#region ../../src/cli/atoms/changelogOptions.ts
-/**
-* Default scopes to ignore in changelog generation.
-* Commits with these scopes won't appear in release notes.
-*/
-const DEFAULT_IGNORE = [
-	"project",
-	"release",
-	"starter",
-	"example",
-	"chore",
-	"ci",
-	"build",
-	"test",
-	"style"
-];
-/**
-* Changelog configuration atom.
-*
-* Configure in `alepha.config.ts`:
-* ```ts
-* import { changelogOptions } from "alepha/cli";
-*
-* alepha.set(changelogOptions, {
-*   ignore: ["project", "release", "chore", "docs"],
-* });
-* ```
-*/
-const changelogOptions = $atom({
-	name: "alepha.changelog",
-	schema: t.object({ ignore: t.optional(t.array(t.string())) }),
-	default: { ignore: DEFAULT_IGNORE }
-});
-
-//#endregion
-//#region ../../src/cli/services/GitMessageParser.ts
-/**
-* Service for parsing git commit messages into structured format.
-*
-* Only parses **conventional commits with a scope**:
-* - `feat(scope): description` → feature
-* - `fix(scope): description` → bug fix
-* - `feat(scope)!: description` → breaking change
-*
-* Commits without scope are ignored, allowing developers to commit
-* work-in-progress changes without polluting release notes:
-* - `cli: work in progress` → ignored (no type)
-* - `fix: quick patch` → ignored (no scope)
-* - `feat(cli): add command` → included
-*/
-var GitMessageParser = class {
-	log = $logger();
+//#region ../../src/cli/commands/clean.ts
+var CleanCommand = class {
 	/**
-	* Parse a git commit line into a structured Commit object.
-	*
-	* **Format:** `type(scope): description` or `type(scope)!: description`
-	*
-	* **Supported types:** feat, fix, docs, refactor, perf, revert
-	*
-	* **Breaking changes:** Use `!` before `:` (e.g., `feat(api)!: remove endpoint`)
-	*
-	* @returns Commit object or null if not matching/ignored
+	* Clean the project, removing the "dist" directory
 	*/
-	parseCommit(line, config) {
-		const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
-		if (!match) return null;
-		const [, hash, message] = match;
-		const ignore = config.ignore ?? DEFAULT_IGNORE;
-		const conventionalMatch = message.match(/^(feat|fix|docs|refactor|perf|revert)\(([^)]+)\)(!)?:\s*(.+)$/i);
-		if (!conventionalMatch) return null;
-		const [, type, scope, breakingMark, description] = conventionalMatch;
-		const baseScope = scope.split("/")[0];
-		if (ignore.includes(baseScope) || ignore.includes(scope)) return null;
-		const breaking = breakingMark === "!" || description.toLowerCase().includes("breaking");
-		return {
-			hash: hash.substring(0, 8),
-			type: type.toLowerCase(),
-			scope,
-			description: description.trim(),
-			breaking
-		};
-	}
+	clean = $command({
+		name: "clean",
+		description: "Clean the project",
+		handler: async ({ run }) => {
+			await run.rm("./dist");
+		}
+	});
 };
 
 //#endregion
-//#region ../../src/cli/commands/changelog.ts
-const execAsync = promisify(exec);
-/**
-* Git provider for executing git commands.
-* Can be substituted in tests with a mock implementation.
-*/
-var GitProvider = class {
-	async exec(cmd, cwd) {
-		const { stdout } = await execAsync(`git ${cmd}`, { cwd });
-		return stdout;
-	}
-};
-/**
-* Changelog command for generating release notes from git commits.
-*
-* Usage:
-* - `alepha changelog` - Show unreleased changes since latest tag to HEAD
-* - `alepha changelog --from=1.0.0` - Show changes from version to HEAD
-* - `alepha changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
-* - `alepha changelog | tee -a CHANGELOG.md` - Append to file
-*/
-var ChangelogCommand = class {
+//#region ../../src/cli/commands/db.ts
+const drizzleCommandFlags = t.object({
+	provider: t.optional(t.text({ description: "Database provider name to target (e.g., 'postgres', 'sqlite')" })),
+	mode: t.optional(t.text({ description: "Environment variable file(s) to load (e.g., 'production' to load .env.production) https://vite.dev/guide/env-and-mode" }))
+});
+var DbCommand = class {
 	log = $logger();
-	git = $inject(GitProvider);
-	parser = $inject(GitMessageParser);
-	config = $use(changelogOptions);
-	/**
-	* Format a single commit line.
-	* Example: `- **cli**: add new command (\`abc1234\`)`
-	* Breaking changes are flagged: `- **cli**: add new command [BREAKING] (\`abc1234\`)`
-	*/
-	formatCommit(commit) {
-		const breaking = commit.breaking ? " [BREAKING]" : "";
-		return `- **${commit.scope}**: ${commit.description}${breaking} (\`${commit.hash}\`)`;
-	}
-	/**
-	* Format the changelog entry with sections.
-	*/
-	formatEntry(entry) {
-		const sections = [];
-		if (entry.features.length > 0) {
-			sections.push("### Features\n");
-			for (const commit of entry.features) sections.push(this.formatCommit(commit));
-			sections.push("");
-		}
-		if (entry.fixes.length > 0) {
-			sections.push("### Bug Fixes\n");
-			for (const commit of entry.fixes) sections.push(this.formatCommit(commit));
-			sections.push("");
-		}
-		return sections.join("\n");
-	}
+	utils = $inject(AlephaCliUtils);
 	/**
-	* Parse git log output into a changelog entry.
-	*/
-	parseCommits(commitsOutput) {
-		const entry = {
-			features: [],
-			fixes: []
-		};
-		for (const line of commitsOutput.trim().split("\n")) {
-			if (!line.trim()) continue;
-			const commit = this.parser.parseCommit(line, this.config);
-			if (!commit) {
-				this.log.trace("Skipping commit", { line });
-				continue;
-			}
-			this.log.trace("Parsed commit", { commit });
-			if (commit.type === "feat") entry.features.push(commit);
-			else if (commit.type === "fix") entry.fixes.push(commit);
-		}
-		return entry;
-	}
-	/**
-	* Check if entry has any public commits.
-	*/
-	hasChanges(entry) {
-		return entry.features.length > 0 || entry.fixes.length > 0;
-	}
-	/**
-	* Get the latest version tag.
-	*/
-	async getLatestTag(git) {
-		return (await git("tag --sort=-version:refname")).trim().split("\n").filter((tag) => tag.match(/^\d+\.\d+\.\d+$/))[0] || null;
-	}
-	changelog = $command({
-		name: "changelog",
-		description: "Generate changelog from conventional commits (outputs to stdout)",
-		flags: t.object({
-			from: t.optional(t.string({
-				aliases: ["f"],
-				description: "Starting ref (default: latest tag)"
-			})),
-			to: t.optional(t.string({
-				aliases: ["t"],
-				description: "Ending ref (default: HEAD)"
-			}))
-		}),
-		handler: async ({ flags, root }) => {
-			const git = (cmd) => this.git.exec(cmd, root);
-			let fromRef;
-			if (flags.from) {
-				fromRef = flags.from;
-				this.log.debug("Using specified from ref", { from: fromRef });
-			} else {
-				const latestTag = await this.getLatestTag(git);
-				if (!latestTag) {
-					process.stdout.write("No version tags found in repository\n");
-					return;
-				}
-				fromRef = latestTag;
-				this.log.debug("Using latest tag", { from: fromRef });
-			}
-			const toRef = flags.to || "HEAD";
-			this.log.debug("Using to ref", { to: toRef });
-			const commitsOutput = await git(`log ${fromRef}..${toRef} --oneline`);
-			if (!commitsOutput.trim()) {
-				process.stdout.write(`No changes in range ${fromRef}..${toRef}\n`);
-				return;
-			}
-			const entry = this.parseCommits(commitsOutput);
-			if (!this.hasChanges(entry)) {
-				process.stdout.write(`No public changes in range ${fromRef}..${toRef}\n`);
-				return;
-			}
-			process.stdout.write(this.formatEntry(entry));
-		}
-	});
-};
-
-//#endregion
-//#region ../../src/cli/commands/clean.ts
-var CleanCommand = class {
-	/**
-	* Clean the project, removing the "dist" directory
-	*/
-	clean = $command({
-		name: "clean",
-		description: "Clean the project",
-		handler: async ({ run }) => {
-			await run.rm("./dist");
-		}
-	});
-};
-
-//#endregion
-//#region ../../src/cli/commands/db.ts
-const drizzleCommandFlags = t.object({
-	provider: t.optional(t.text({ description: "Database provider name to target (e.g., 'postgres', 'sqlite')" })),
-	mode: t.optional(t.text({ description: "Environment variable file(s) to load (e.g., 'production' to load .env.production) https://vite.dev/guide/env-and-mode" }))
-});
-var DbCommand = class {
-	log = $logger();
-	utils = $inject(AlephaCliUtils);
-	/**
-	* Check if database migrations are up to date.
+	* Check if database migrations are up to date.
 	*/
 	check = $command({
 		name: "check-migrations",
@@ -1026,7 +912,6 @@ var DbCommand = class {
 	generate = $command({
 		name: "generate",
 		description: "Generate migration files based on current database schema",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -1051,7 +936,6 @@ var DbCommand = class {
 	push = $command({
 		name: "push",
 		description: "Push database schema changes directly to the database",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -1074,7 +958,6 @@ var DbCommand = class {
 	migrate = $command({
 		name: "migrate",
 		description: "Apply pending database migrations",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -1097,7 +980,6 @@ var DbCommand = class {
 	studio = $command({
 		name: "studio",
 		description: "Launch Drizzle Studio database browser",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -1295,6 +1177,7 @@ var DeployCommand = class {
 var DevCommand = class {
 	log = $logger();
 	utils = $inject(AlephaCliUtils);
+	alepha = $inject(Alepha);
 	/**
 	* Will run the project in watch mode.
 	*
@@ -1310,30 +1193,42 @@ var DevCommand = class {
 		})),
 		handler: async ({ args, root }) => {
 			const expo = await this.utils.hasExpo(root);
-			await this.utils.ensureConfig(root, {
-				viteConfigTs: !expo,
-				tsconfigJson: true
-			});
+			await this.utils.ensureConfig(root, { tsconfigJson: true });
 			if (expo) {
 				await this.utils.exec("expo start");
 				return;
 			}
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
-			try {
-				await access(join(root, "index.html"));
-			} catch {
-				this.log.trace("No index.html found, running entry file with tsx");
-				let cmd = "tsx --watch";
+			if (!await this.isFullstackProject(root)) {
+				const exe = await this.isBunProject(root) ? "bun" : "tsx";
+				let cmd = `${exe} --watch`;
 				if (await this.utils.exists(root, ".env")) cmd += " --env-file=./.env";
 				cmd += ` ${entry}`;
-				await this.utils.exec(cmd);
+				await this.utils.exec(cmd, { global: exe === "bun" });
 				return;
 			}
 			await this.utils.ensureDependency(root, "vite");
-			await this.utils.exec("vite");
+			await devServer();
 		}
 	});
+	async isBunProject(root) {
+		if (this.alepha.isBun()) return true;
+		try {
+			await access(join(root, "bun.lock"));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async isFullstackProject(root) {
+		try {
+			await access(join(root, "index.html"));
+			return true;
+		} catch {
+			return false;
+		}
+	}
 };
 
 //#endregion
@@ -1351,6 +1246,316 @@ var FormatCommand = class {
 	});
 };
 
+//#endregion
+//#region ../../src/cli/atoms/changelogOptions.ts
+/**
+* Default scopes to ignore in changelog generation.
+* Commits with these scopes won't appear in release notes.
+*/
+const DEFAULT_IGNORE = [
+	"project",
+	"release",
+	"starter",
+	"example",
+	"chore",
+	"ci",
+	"build",
+	"test",
+	"style"
+];
+/**
+* Changelog configuration atom.
+*
+* Configure in `alepha.config.ts`:
+* ```ts
+* import { changelogOptions } from "alepha/cli";
+*
+* alepha.set(changelogOptions, {
+*   ignore: ["project", "release", "chore", "docs"],
+* });
+* ```
+*/
+const changelogOptions = $atom({
+	name: "alepha.changelog",
+	schema: t.object({ ignore: t.optional(t.array(t.string())) }),
+	default: { ignore: DEFAULT_IGNORE }
+});
+
+//#endregion
+//#region ../../src/cli/services/GitMessageParser.ts
+/**
+* Service for parsing git commit messages into structured format.
+*
+* Only parses **conventional commits with a scope**:
+* - `feat(scope): description` → feature
+* - `fix(scope): description` → bug fix
+* - `feat(scope)!: description` → breaking change
+*
+* Commits without scope are ignored, allowing developers to commit
+* work-in-progress changes without polluting release notes:
+* - `cli: work in progress` → ignored (no type)
+* - `fix: quick patch` → ignored (no scope)
+* - `feat(cli): add command` → included
+*/
+var GitMessageParser = class {
+	log = $logger();
+	/**
+	* Parse a git commit line into a structured Commit object.
+	*
+	* **Format:** `type(scope): description` or `type(scope)!: description`
+	*
+	* **Supported types:** feat, fix, docs, refactor, perf, revert
+	*
+	* **Breaking changes:** Use `!` before `:` (e.g., `feat(api)!: remove endpoint`)
+	*
+	* @returns Commit object or null if not matching/ignored
+	*/
+	parseCommit(line, config) {
+		const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
+		if (!match) return null;
+		const [, hash, message] = match;
+		const ignore = config.ignore ?? DEFAULT_IGNORE;
+		const conventionalMatch = message.match(/^(feat|fix|docs|refactor|perf|revert)\(([^)]+)\)(!)?:\s*(.+)$/i);
+		if (!conventionalMatch) return null;
+		const [, type, scope, breakingMark, description] = conventionalMatch;
+		const baseScope = scope.split("/")[0];
+		if (ignore.includes(baseScope) || ignore.includes(scope)) return null;
+		const breaking = breakingMark === "!" || description.toLowerCase().includes("breaking");
+		return {
+			hash: hash.substring(0, 8),
+			type: type.toLowerCase(),
+			scope,
+			description: description.trim(),
+			breaking
+		};
+	}
+};
+
+//#endregion
+//#region ../../src/cli/commands/gen/changelog.ts
+const execAsync = promisify(exec);
+/**
+* Git provider for executing git commands.
+* Can be substituted in tests with a mock implementation.
+*/
+var GitProvider = class {
+	async exec(cmd, cwd) {
+		const { stdout } = await execAsync(`git ${cmd}`, { cwd });
+		return stdout;
+	}
+};
+/**
+* Changelog command for generating release notes from git commits.
+*
+* Usage:
+* - `alepha gen changelog` - Show unreleased changes since latest tag to HEAD
+* - `alepha gen changelog --from=1.0.0` - Show changes from version to HEAD
+* - `alepha gen changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
+* - `alepha gen changelog | tee -a CHANGELOG.md` - Append to file
+*/
+var ChangelogCommand = class {
+	log = $logger();
+	git = $inject(GitProvider);
+	parser = $inject(GitMessageParser);
+	config = $use(changelogOptions);
+	/**
+	* Format a single commit line.
+	* Example: `- **cli**: add new command (\`abc1234\`)`
+	* Breaking changes are flagged: `- **cli**: add new command [BREAKING] (\`abc1234\`)`
+	*/
+	formatCommit(commit) {
+		const breaking = commit.breaking ? " [BREAKING]" : "";
+		return `- **${commit.scope}**: ${commit.description}${breaking} (\`${commit.hash}\`)`;
+	}
+	/**
+	* Format the changelog entry with sections.
+	*/
+	formatEntry(entry) {
+		const sections = [];
+		if (entry.features.length > 0) {
+			sections.push("### Features\n");
+			for (const commit of entry.features) sections.push(this.formatCommit(commit));
+			sections.push("");
+		}
+		if (entry.fixes.length > 0) {
+			sections.push("### Bug Fixes\n");
+			for (const commit of entry.fixes) sections.push(this.formatCommit(commit));
+			sections.push("");
+		}
+		return sections.join("\n");
+	}
+	/**
+	* Parse git log output into a changelog entry.
+	*/
+	parseCommits(commitsOutput) {
+		const entry = {
+			features: [],
+			fixes: []
+		};
+		for (const line of commitsOutput.trim().split("\n")) {
+			if (!line.trim()) continue;
+			const commit = this.parser.parseCommit(line, this.config);
+			if (!commit) {
+				this.log.trace("Skipping commit", { line });
+				continue;
+			}
+			this.log.trace("Parsed commit", { commit });
+			if (commit.type === "feat") entry.features.push(commit);
+			else if (commit.type === "fix") entry.fixes.push(commit);
+		}
+		return entry;
+	}
+	/**
+	* Check if entry has any public commits.
+	*/
+	hasChanges(entry) {
+		return entry.features.length > 0 || entry.fixes.length > 0;
+	}
+	/**
+	* Get the latest version tag.
+	*/
+	async getLatestTag(git) {
+		return (await git("tag --sort=-version:refname")).trim().split("\n").filter((tag) => tag.match(/^\d+\.\d+\.\d+$/))[0] || null;
+	}
+	command = $command({
+		name: "changelog",
+		description: "Generate changelog from conventional commits (outputs to stdout)",
+		flags: t.object({
+			from: t.optional(t.string({
+				aliases: ["f"],
+				description: "Starting ref (default: latest tag)"
+			})),
+			to: t.optional(t.string({
+				aliases: ["t"],
+				description: "Ending ref (default: HEAD)"
+			}))
+		}),
+		handler: async ({ flags, root }) => {
+			const git = (cmd) => this.git.exec(cmd, root);
+			let fromRef;
+			if (flags.from) {
+				fromRef = flags.from;
+				this.log.debug("Using specified from ref", { from: fromRef });
+			} else {
+				const latestTag = await this.getLatestTag(git);
+				if (!latestTag) {
+					process.stdout.write("No version tags found in repository\n");
+					return;
+				}
+				fromRef = latestTag;
+				this.log.debug("Using latest tag", { from: fromRef });
+			}
+			const toRef = flags.to || "HEAD";
+			this.log.debug("Using to ref", { to: toRef });
+			const commitsOutput = await git(`log ${fromRef}..${toRef} --oneline`);
+			if (!commitsOutput.trim()) {
+				process.stdout.write(`No changes in range ${fromRef}..${toRef}\n`);
+				return;
+			}
+			const entry = this.parseCommits(commitsOutput);
+			if (!this.hasChanges(entry)) {
+				process.stdout.write(`No public changes in range ${fromRef}..${toRef}\n`);
+				return;
+			}
+			process.stdout.write(this.formatEntry(entry));
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/cli/commands/gen/env.ts
+var GenEnvCommand = class {
+	log = $logger();
+	utils = $inject(AlephaCliUtils);
+	fs = $inject(FileSystemProvider);
+	command = $command({
+		name: "env",
+		description: "Extract environment variables from server entry file",
+		flags: t.object({ out: t.optional(t.text({
+			aliases: ["o"],
+			description: "Output file path (e.g., .env)"
+		})) }),
+		handler: async ({ root, flags }) => {
+			const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+			try {
+				const { env } = alepha.dump();
+				let dotEnvFile = "";
+				for (const [key, value] of Object.entries(env)) {
+					if (value.description) dotEnvFile += `# ${value.description.split("\n").join("\n# ")}\n`;
+					if (value.required && !value.default) dotEnvFile += `# (required)\n`;
+					if (value.enum) dotEnvFile += `# Possible values: ${value.enum.join(", ")}\n`;
+					dotEnvFile += `${key}=${value.default || ""}\n\n`;
+				}
+				if (flags.out) await this.fs.writeFile(this.fs.join(root, flags.out), dotEnvFile);
+				else this.log.info(dotEnvFile);
+			} catch (err) {
+				this.log.error("Failed to extract environment variables", err);
+			}
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/cli/commands/gen/openapi.ts
+var OpenApiCommand = class {
+	log = $logger();
+	utils = $inject(AlephaCliUtils);
+	fs = $inject(FileSystemProvider);
+	command = $command({
+		name: "openapi",
+		description: "Generate OpenAPI specification from actions",
+		flags: t.object({ out: t.optional(t.text({
+			aliases: ["o"],
+			description: "Output file path"
+		})) }),
+		handler: async ({ root, flags }) => {
+			const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+			try {
+				const openapiProvider = alepha.inject(ServerSwaggerProvider);
+				await alepha.events.emit("configure", alepha);
+				let json = openapiProvider.json;
+				if (!json) json = openapiProvider.generateSwaggerDoc({ info: {
+					title: "API Documentation",
+					version: "1.0.0"
+				} });
+				if (!json) {
+					this.log.error("No actions found to generate OpenAPI specification.");
+					return;
+				}
+				if (flags.out) await this.fs.writeFile(this.fs.join(root, flags.out), JSON.stringify(json, null, 2));
+				else this.log.info(JSON.stringify(json, null, 2));
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				if (message.includes("Service not found")) {
+					this.log.error("Missing $swagger() primitive in your server configuration.");
+					return;
+				}
+				this.log.error(`OpenAPI generation failed - ${message}`, err);
+			}
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/cli/commands/gen.ts
+var GenCommand = class {
+	changelog = $inject(ChangelogCommand);
+	openapi = $inject(OpenApiCommand);
+	genEnv = $inject(GenEnvCommand);
+	gen = $command({
+		name: "gen",
+		description: "Generate code, documentation, ...",
+		children: [
+			this.changelog.command,
+			this.openapi.command,
+			this.genEnv.command
+		],
+		handler: async ({ help }) => {
+			help();
+		}
+	});
+};
+
 //#endregion
 //#region ../../src/cli/commands/init.ts
 var InitCommand = class {
@@ -1381,7 +1586,6 @@ var InitCommand = class {
 						tsconfigJson: true,
 						packageJson: flags,
 						biomeJson: true,
-						viteConfigTs: !isExpo,
 						editorconfig: true,
 						indexHtml: !!flags.react && !isExpo
 					});
@@ -1392,7 +1596,8 @@ var InitCommand = class {
 			if (pm === "yarn") {
 				await this.utils.ensureYarn(root);
 				await run("yarn set version stable");
-			} else if (pm === "pnpm") await this.utils.ensurePnpm(root);
+			} else if (pm === "bun") await this.utils.ensureBun(root);
+			else if (pm === "pnpm") await this.utils.ensurePnpm(root);
 			else await this.utils.ensureNpm(root);
 			await run(`${pm} install`, { alias: `installing dependencies with ${pm}` });
 			if (!isExpo) await this.utils.ensureDependency(root, "vite", { run });
@@ -1425,6 +1630,8 @@ var LintCommand = class {
 var RootCommand = class {
 	log = $logger();
 	cli = $inject(CliProvider);
+	alepha = $inject(Alepha);
+	color = $inject(ConsoleColorProvider);
 	/**
 	* Called when no command is provided
 	*/
@@ -1436,7 +1643,9 @@ var RootCommand = class {
 		})) }),
 		handler: async ({ flags }) => {
 			if (flags.version) {
-				this.log.info(version);
+				this.log.info(this.color.set("WHITE_BOLD", `Alepha v${version}`));
+				if (this.alepha.isBun()) this.log.info(this.color.set("GREY_DARK", `└─ Bun v${Bun.version}`));
+				else this.log.info(this.color.set("GREY_DARK", `└─ Node ${process.version}`));
 				return;
 			}
 			this.cli.printHelp();
@@ -1444,30 +1653,6 @@ var RootCommand = class {
 	});
 };
 
-//#endregion
-//#region ../../src/cli/commands/run.ts
-var RunCommand = class {
-	utils = $inject(AlephaCliUtils);
-	run = $command({
-		name: "run",
-		hide: true,
-		description: "Run a TypeScript file directly",
-		flags: t.object({ watch: t.optional(t.boolean({
-			description: "Watch file for changes",
-			alias: "w"
-		})) }),
-		summary: false,
-		args: t.text({
-			title: "path",
-			description: "Filepath to run"
-		}),
-		handler: async ({ args, flags, root }) => {
-			await this.utils.ensureTsConfig(root);
-			await this.utils.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
-		}
-	});
-};
-
 //#endregion
 //#region ../../src/cli/commands/test.ts
 var TestCommand = class {
@@ -1484,10 +1669,7 @@ var TestCommand = class {
 			description: "Additional arguments to pass to Vitest. E.g., --coverage"
 		})) }),
 		handler: async ({ root, flags, env }) => {
-			await this.utils.ensureConfig(root, {
-				tsconfigJson: true,
-				viteConfigTs: true
-			});
+			await this.utils.ensureConfig(root, { tsconfigJson: true });
 			await this.utils.ensureDependency(root, "vitest");
 			const config = flags.config ? `--config=${flags.config}` : "";
 			await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
@@ -1499,15 +1681,19 @@ var TestCommand = class {
 //#region ../../src/cli/commands/typecheck.ts
 var TypecheckCommand = class {
 	utils = $inject(AlephaCliUtils);
+	log = $logger();
 	/**
 	* Run TypeScript type checking across the codebase with no emit.
 	*/
 	typecheck = $command({
 		name: "typecheck",
+		aliases: ["tc"],
 		description: "Check TypeScript types across the codebase",
 		handler: async ({ root }) => {
+			this.log.info("Starting TypeScript type checking...");
 			await this.utils.ensureDependency(root, "typescript");
 			await this.utils.exec("tsc --noEmit");
+			this.log.info("TypeScript type checking completed successfully.");
 		}
 	});
 };
@@ -1538,7 +1724,7 @@ var VerifyCommand = class {
 			await run("alepha lint");
 			await run("alepha typecheck");
 			if ((await this.utils.readPackageJson(root)).devDependencies?.vitest) await run("alepha test");
-			if (await this.utils.exists(root, "migrations")) await run("alepha db:check-migrations");
+			if (await this.utils.exists(root, "migrations")) await run("alepha db check-migrations");
 			if (!await this.utils.hasExpo(root)) await run("alepha build");
 			await run("alepha clean");
 		}
@@ -1547,13 +1733,26 @@ var VerifyCommand = class {
 
 //#endregion
 //#region ../../src/cli/apps/AlephaCli.ts
+/**
+* Register `tsx` when running in Node.js, ignore for Bun.
+*
+* It's required to have a full TypeScript support. (mostly .tsx files)
+*/
+if (typeof Bun === "undefined") {
+	const { register } = await import("tsx/esm/api");
+	register();
+}
+/**
+* Allow to extend Alepha CLI via `alepha.config.ts` file located in the project root.
+*/
 var AlephaCliExtension = class {
 	alepha = $inject(Alepha);
 	fs = $inject(FileSystemProvider);
 	onConfigure = $hook({
 		on: "configure",
 		handler: async () => {
-			const extensionPath = join(process.cwd(), "alepha.config.ts");
+			const root = process.cwd();
+			const extensionPath = this.fs.join(root, "alepha.config.ts");
 			if (!await this.fs.exists(extensionPath)) return;
 			const { default: Extension } = await import(extensionPath);
 			if (typeof Extension !== "function") return;
@@ -1566,7 +1765,6 @@ const AlephaCli = $module({
 	services: [
 		AlephaCliExtension,
 		BuildCommand,
-		ChangelogCommand,
 		CleanCommand,
 		DbCommand,
 		DeployCommand,
@@ -1575,10 +1773,10 @@ const AlephaCli = $module({
 		InitCommand,
 		LintCommand,
 		RootCommand,
-		RunCommand,
 		TestCommand,
 		TypecheckCommand,
 		VerifyCommand,
+		GenCommand,
 		GitProvider
 	]
 });
@@ -1778,11 +1976,13 @@ async function analyzeModules(srcDir, packageName) {
 
 //#endregion
 //#region ../../src/cli/defineConfig.ts
-const defineConfig = (config) => {
+const defineConfig = (runConfig) => {
 	return (alepha) => {
-		const { commands, services = [] } = config(alepha);
-		for (const it of services) alepha.with(it);
-		return { ...commands };
+		const config = typeof runConfig === "function" ? runConfig(alepha) : runConfig;
+		if (config.services) for (const it of config.services) alepha.with(it);
+		if (config.env) for (const [key, value] of Object.entries(config.env)) process.env[key] = String(value);
+		if (config.build) alepha.set(buildOptions, config.build);
+		return { ...config.commands };
 	};
 };
 /**
@@ -1791,5 +1991,5 @@ const defineConfig = (config) => {
 const defineAlephaConfig = defineConfig;
 
 //#endregion
-export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BuildCommand, ChangelogCommand, CleanCommand, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, FormatCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, RootCommand, RunCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
+export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BuildCommand, ChangelogCommand, CleanCommand, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, FormatCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
 //# sourceMappingURL=index.js.map