alepha 0.14.1 → 0.14.2

package/dist/cli/index.js

@@ -1,12 +1,12 @@
 import { createRequire } from "node:module";
 import { join } from "node:path";
-import { $atom, $env, $hook, $inject, $module, $use, Alepha, AlephaError, OPTIONS, t } from "alepha";
+import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, OPTIONS, t } from "alepha";
 import { FileSystemProvider } from "alepha/file";
+import { access, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { $command, CliProvider, EnvUtils } from "alepha/command";
 import { $logger } from "alepha/logger";
-import { exec, spawn } from "node:child_process";
-import { access, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { boot, buildClient, buildServer, copyAssets, 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";
@@ -14,7 +14,7 @@ import * as os from "node:os";
 
 //#region ../../src/cli/assets/appRouterTs.ts
 const appRouterTs = () => `
-import { $page } from "@alepha/react";
+import { $page } from "@alepha/react/router";
 
 export class AppRouter {
   home = $page({
@@ -587,26 +587,134 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 };
 
 //#endregion
-//#region ../../src/cli/commands/BiomeCommands.ts
-var BiomeCommands = class {
+//#region ../../src/cli/commands/build.ts
+var BuildCommand = class {
 	log = $logger();
 	utils = $inject(AlephaCliUtils);
-	format = $command({
-		name: "format",
-		description: "Format the codebase using Biome",
-		handler: async ({ root }) => {
-			await this.utils.ensureConfig(root, { biomeJson: true });
-			await this.utils.ensureDependency(root, "@biomejs/biome");
-			await this.utils.exec(`biome format --fix`);
-		}
-	});
-	lint = $command({
-		name: "lint",
-		description: "Run linter across the codebase using Biome",
-		handler: async ({ root }) => {
-			await this.utils.ensureConfig(root, { biomeJson: true });
-			await this.utils.ensureDependency(root, "@biomejs/biome");
-			await this.utils.exec(`biome check --formatter-enabled=false --fix`);
+	build = $command({
+		name: "build",
+		description: "Build the project for production",
+		args: t.optional(t.text({
+			title: "path",
+			description: "Filepath to build"
+		})),
+		flags: t.object({
+			stats: t.optional(t.boolean({ description: "Generate build stats report" })),
+			vercel: t.optional(t.boolean({ description: "Generate Vercel deployment configuration" })),
+			cloudflare: t.optional(t.boolean({ description: "Generate Cloudflare Workers configuration" })),
+			docker: t.optional(t.boolean({ description: "Generate Docker configuration" })),
+			sitemap: t.optional(t.text({ description: "Generate sitemap.xml with base URL" }))
+		}),
+		handler: async ({ flags, args, run, root }) => {
+			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
+			});
+			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] || {};
+			await this.utils.loadEnv(root, [".env", ".env.production"]);
+			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
+			const hasServer = viteAlephaBuildOptions.serverEntry !== 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
+				})
+			});
+			await run({
+				name: "vite build server",
+				handler: async () => {
+					let clientBuilt = false;
+					try {
+						await readFile(`${distDir}/${clientDir}/index.html`, "utf-8");
+						clientBuilt = true;
+					} catch {}
+					await buildServer({
+						silent: true,
+						entry,
+						distDir,
+						clientDir: clientBuilt ? clientDir : void 0,
+						stats
+					});
+					if (clientBuilt && hasServer) await unlink(`${distDir}/${clientDir}/index.html`);
+				}
+			});
+			await copyAssets({
+				root,
+				entry: `${distDir}/index.js`,
+				distDir,
+				run
+			});
+			if (hasClient) {
+				const sitemapBaseUrl = flags.sitemap ?? clientOptions.sitemap?.hostname;
+				if (sitemapBaseUrl) await run({
+					name: "add sitemap",
+					handler: async () => {
+						await writeFile(`${distDir}/${clientDir}/sitemap.xml`, await generateSitemap({
+							entry: `${distDir}/index.js`,
+							baseUrl: sitemapBaseUrl
+						}));
+					}
+				});
+				if (clientOptions.prerender) await run({
+					name: "pre-render pages",
+					handler: async () => {
+						await prerenderPages({
+							dist: `${distDir}/${clientDir}`,
+							entry: `${distDir}/index.js`,
+							compress: clientOptions.precompress
+						});
+					}
+				});
+			}
+			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
+					})
+				});
+			}
 		}
 	});
 };
@@ -697,7 +805,7 @@ var GitMessageParser = class {
 };
 
 //#endregion
-//#region ../../src/cli/commands/ChangelogCommands.ts
+//#region ../../src/cli/commands/changelog.ts
 const execAsync = promisify(exec);
 /**
 * Git provider for executing git commands.
@@ -718,7 +826,7 @@ var GitProvider = class {
 * - `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 ChangelogCommands = class {
+var ChangelogCommand = class {
 	log = $logger();
 	git = $inject(GitProvider);
 	parser = $inject(GitMessageParser);
@@ -726,20 +834,17 @@ var ChangelogCommands = class {
 	/**
 	* Format a single commit line.
 	* Example: `- **cli**: add new command (\`abc1234\`)`
+	* Breaking changes are flagged: `- **cli**: add new command [BREAKING] (\`abc1234\`)`
 	*/
 	formatCommit(commit) {
-		return `- **${commit.scope}**: ${commit.description} (\`${commit.hash}\`)`;
+		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.breaking.length > 0) {
-			sections.push("### Breaking Changes\n");
-			for (const commit of entry.breaking) sections.push(this.formatCommit(commit));
-			sections.push("");
-		}
 		if (entry.features.length > 0) {
 			sections.push("### Features\n");
 			for (const commit of entry.features) sections.push(this.formatCommit(commit));
@@ -758,8 +863,7 @@ var ChangelogCommands = class {
 	parseCommits(commitsOutput) {
 		const entry = {
 			features: [],
-			fixes: [],
-			breaking: []
+			fixes: []
 		};
 		for (const line of commitsOutput.trim().split("\n")) {
 			if (!line.trim()) continue;
@@ -769,7 +873,6 @@ var ChangelogCommands = class {
 				continue;
 			}
 			this.log.trace("Parsed commit", { commit });
-			if (commit.breaking) entry.breaking.push(commit);
 			if (commit.type === "feat") entry.features.push(commit);
 			else if (commit.type === "fix") entry.fixes.push(commit);
 		}
@@ -779,7 +882,7 @@ var ChangelogCommands = class {
 	* Check if entry has any public commits.
 	*/
 	hasChanges(entry) {
-		return entry.features.length > 0 || entry.fixes.length > 0 || entry.breaking.length > 0;
+		return entry.features.length > 0 || entry.fixes.length > 0;
 	}
 	/**
 	* Get the latest version tag.
@@ -833,28 +936,8 @@ var ChangelogCommands = class {
 };
 
 //#endregion
-//#region ../../src/cli/commands/CoreCommands.ts
-var CoreCommands = class {
-	log = $logger();
-	cli = $inject(CliProvider);
-	utils = $inject(AlephaCliUtils);
-	/**
-	* Called when no command is provided
-	*/
-	root = $command({
-		root: true,
-		flags: t.object({ version: t.optional(t.boolean({
-			description: "Show Alepha CLI version",
-			aliases: ["v"]
-		})) }),
-		handler: async ({ flags }) => {
-			if (flags.version) {
-				this.log.info(version);
-				return;
-			}
-			this.cli.printHelp();
-		}
-	});
+//#region ../../src/cli/commands/clean.ts
+var CleanCommand = class {
 	/**
 	* Clean the project, removing the "dist" directory
 	*/
@@ -865,148 +948,19 @@ var CoreCommands = class {
 			await run.rm("./dist");
 		}
 	});
-	/**
-	* Ensure the project has the necessary Alepha configuration files.
-	* Add the correct dependencies to package.json and install them.
-	*/
-	init = $command({
-		name: "init",
-		description: "Add missing Alepha configuration files to the project",
-		flags: t.object({
-			yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
-			pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
-			npm: t.optional(t.boolean({ description: "Use npm package manager" })),
-			bun: t.optional(t.boolean({ description: "Use Bun package manager" })),
-			react: t.optional(t.boolean({ description: "Include Alepha React dependencies" })),
-			ui: t.optional(t.boolean({ description: "Include Alepha UI dependencies" })),
-			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" }))
-		}),
-		handler: async ({ run, flags, root }) => {
-			if (flags.ui) flags.react = true;
-			const isExpo = await this.utils.hasExpo(root);
-			await run({
-				name: "ensuring configuration files",
-				handler: async () => {
-					await this.utils.ensureConfig(root, {
-						tsconfigJson: true,
-						packageJson: flags,
-						biomeJson: true,
-						viteConfigTs: !isExpo,
-						editorconfig: true,
-						indexHtml: !!flags.react && !isExpo
-					});
-					if (!flags.react) await this.utils.ensureSrcMain(root);
-				}
-			});
-			const pm = await this.utils.getPackageManager(root, flags);
-			if (pm === "yarn") {
-				await this.utils.ensureYarn(root);
-				await run("yarn set version stable");
-			} 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 });
-			await this.utils.ensureDependency(root, "@biomejs/biome", { run });
-			if (flags.test) {
-				await this.utils.ensureTestDir(root);
-				await run(`${pm} ${pm === "yarn" ? "add" : "install"} -D vitest`, { alias: "setup testing with Vitest" });
-			}
-		}
-	});
 };
 
 //#endregion
-//#region ../../src/cli/commands/DeployCommands.ts
-var DeployCommands = 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();
 	utils = $inject(AlephaCliUtils);
 	/**
-	* Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)
-	*
-	* Deploy command can be overridden by creating a alepha.config.ts in the project root:
-	*
-	* ```ts
-	* import { defineConfig } from "alepha/cli";
-	*
-	* export default defineConfig({
-	*   commands: {
-	*     deploy: {
-	*       handler: async ({ root, mode, flags }) => {
-	*         // Custom deployment logic here
-	*       },
-	*     },
-	*   },
-	* });
-	* ```
-	*/
-	deploy = $command({
-		name: "deploy",
-		description: "Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)",
-		mode: true,
-		flags: t.object({
-			build: t.boolean({
-				description: "Build the project before deployment",
-				default: false
-			}),
-			migrate: t.boolean({
-				description: "Run database migrations before deployment (if applicable)",
-				default: false
-			})
-		}),
-		env: t.object({
-			VERCEL_TOKEN: t.optional(t.text({ description: "Vercel API token (e.g., xxxxxxxxxxxxxxxxxxxx)" })),
-			VERCEL_ORG_ID: t.optional(t.text({ description: "Vercel organization ID (e.g., team_abc123...)" })),
-			VERCEL_PROJECT_ID: t.optional(t.text({ description: "Vercel project ID (e.g., prj_abc123...)" })),
-			CLOUDFLARE_API_TOKEN: t.optional(t.text({ description: "Cloudflare API token (e.g., xxxx-xxxx-xxxx-xxxx)" })),
-			CLOUDFLARE_ACCOUNT_ID: t.optional(t.text({ description: "Cloudflare account ID (e.g., abc123def456...)" }))
-		}),
-		handler: async ({ root, mode, flags }) => {
-			if (flags.build) await this.utils.exec("alepha build");
-			if (await this.utils.exists(root, "dist/vercel.json")) {
-				if (flags.migrate) {
-					this.log.debug("Running database migrations before deployment...");
-					await this.utils.exec(`alepha db migrate --mode=${mode}`);
-				}
-				await this.utils.ensureDependency(root, "vercel", { dev: true });
-				const command = `vercel . --cwd=dist ${mode === "production" ? "--prod" : ""}`.trim();
-				this.log.debug(`Deploying to Vercel with command: ${command}`);
-				await this.utils.exec(command);
-				return;
-			}
-			if (await this.utils.exists(root, "dist/wrangler.jsonc")) {
-				if (flags.migrate) {
-					this.log.debug("Running database migrations before deployment...");
-					await this.utils.exec(`alepha db migrate --mode=${mode}`);
-				}
-				await this.utils.ensureDependency(root, "wrangler", { dev: true });
-				const command = `wrangler deploy ${mode === "production" ? "" : "--env preview"} --config=dist/wrangler.jsonc`.trim();
-				this.log.info(`Deploying to Cloudflare with command: ${command}`);
-				await this.utils.exec(command);
-				return;
-			}
-			if (await this.utils.exists(root, "dist/public/404.html")) {
-				await this.utils.ensureDependency(root, "surge", { dev: true });
-				const distPath = join(root, "dist/public");
-				this.log.debug(`Deploying to Surge from directory: ${distPath}`);
-				await this.utils.exec(`surge ${distPath}`);
-				return;
-			}
-			throw new AlephaError("No deployment configuration found in the dist folder.");
-		}
-	});
-};
-
-//#endregion
-//#region ../../src/cli/commands/DrizzleCommands.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 DrizzleCommands = 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",
@@ -1031,7 +985,7 @@ var DrizzleCommands = class {
 				const migrationDir = join(rootDir, "migrations", providerName);
 				const journalFile = await readFile(`${migrationDir}/meta/_journal.json`, "utf-8").catch(() => null);
 				if (!journalFile) {
-					this.log.info(`No migration journal found.`);
+					this.log.info("No migration journal found.");
 					return;
 				}
 				const journal = JSON.parse(journalFile);
@@ -1068,12 +1022,6 @@ var DrizzleCommands = class {
 	});
 	/**
 	* Generate database migration files
-	*
-	* - Loads the Alepha instance from the specified entry file.
-	* - Retrieves all repository primitives to gather database models.
-	* - Creates temporary entity definitions based on the current database schema.
-	* - Writes these definitions to a temporary schema file. (node_modules/.db/entities.ts)
-	* - Invokes Drizzle Kit's CLI to generate migration files based on the current schema.
 	*/
 	generate = $command({
 		name: "generate",
@@ -1099,11 +1047,6 @@ var DrizzleCommands = class {
 	});
 	/**
 	* Push database schema changes directly to the database
-	*
-	* - Loads the Alepha instance from the specified entry file.
-	* - Retrieves all repository primitives to gather database models.
-	* - Creates temporary entity definitions and Drizzle config.
-	* - Invokes Drizzle Kit's push command to apply schema changes directly.
 	*/
 	push = $command({
 		name: "push",
@@ -1127,11 +1070,6 @@ var DrizzleCommands = class {
 	});
 	/**
 	* Apply pending database migrations
-	*
-	* - Loads the Alepha instance from the specified entry file.
-	* - Retrieves all repository primitives to gather database models.
-	* - Creates temporary entity definitions and Drizzle config.
-	* - Invokes Drizzle Kit's migrate command to apply pending migrations.
 	*/
 	migrate = $command({
 		name: "migrate",
@@ -1155,11 +1093,6 @@ var DrizzleCommands = class {
 	});
 	/**
 	* Launch Drizzle Studio database browser
-	*
-	* - Loads the Alepha instance from the specified entry file.
-	* - Retrieves all repository primitives to gather database models.
-	* - Creates temporary entity definitions and Drizzle config.
-	* - Invokes Drizzle Kit's studio command to launch the web-based database browser.
 	*/
 	studio = $command({
 		name: "studio",
@@ -1200,11 +1133,6 @@ var DrizzleCommands = class {
 	});
 	/**
 	* Run a drizzle-kit command for all database providers in an Alepha instance.
-	*
-	* Iterates through all repository providers, prepares Drizzle config for each,
-	* and executes the specified drizzle-kit command.
-	*
-	* @param options - Configuration including command to run, flags, and logging
 	*/
 	async runDrizzleKitCommand(options) {
 		const rootDir = options.root;
@@ -1243,12 +1171,6 @@ var DrizzleCommands = class {
 	}
 	/**
 	* Prepare Drizzle configuration files for a database provider.
-	*
-	* Creates temporary entities.js and drizzle.config.js files needed
-	* for Drizzle Kit commands to run properly.
-	*
-	* @param options - Configuration options including kit, provider info, and paths
-	* @returns Path to the generated drizzle.config.js file
 	*/
 	async prepareDrizzleConfig(options) {
 		const models = Object.keys(options.kit.getModels(options.provider));
@@ -1288,73 +1210,91 @@ var DrizzleCommands = class {
 };
 
 //#endregion
-//#region ../../src/cli/commands/VerifyCommands.ts
-var VerifyCommands = class {
+//#region ../../src/cli/commands/deploy.ts
+var DeployCommand = class {
+	log = $logger();
 	utils = $inject(AlephaCliUtils);
 	/**
-	* Run a series of verification commands to ensure code quality and correctness.
+	* Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)
 	*
-	* This command runs the following checks in order:
-	* - Clean the project
-	* - Format the code
-	* - Lint the code
-	* - Run tests (if Vitest is a dev dependency)
-	* - Check database migrations (if a migrations directory exists)
-	* - Type check the code
-	* - Build the project
-	* - Clean the project again
-	*/
-	verify = $command({
-		name: "verify",
-		description: "Verify the Alepha project",
-		handler: async ({ root, run }) => {
-			await run("alepha clean");
-			await run("alepha format");
-			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.hasExpo(root)) await run("alepha build");
-			await run("alepha clean");
-		}
-	});
-	/**
-	* Run TypeScript type checking across the codebase with no emit.
+	* Deploy command can be overridden by creating a alepha.config.ts in the project root:
+	*
+	* ```ts
+	* import { defineConfig } from "alepha/cli";
+	*
+	* export default defineConfig({
+	*   commands: {
+	*     deploy: {
+	*       handler: async ({ root, mode, flags }) => {
+	*         // Custom deployment logic here
+	*       },
+	*     },
+	*   },
+	* });
+	* ```
 	*/
-	typecheck = $command({
-		name: "typecheck",
-		description: "Check TypeScript types across the codebase",
-		handler: async ({ root }) => {
-			await this.utils.ensureDependency(root, "typescript");
-			await this.utils.exec("tsc --noEmit");
+	deploy = $command({
+		name: "deploy",
+		description: "Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)",
+		mode: true,
+		flags: t.object({
+			build: t.boolean({
+				description: "Build the project before deployment",
+				default: false
+			}),
+			migrate: t.boolean({
+				description: "Run database migrations before deployment (if applicable)",
+				default: false
+			})
+		}),
+		env: t.object({
+			VERCEL_TOKEN: t.optional(t.text({ description: "Vercel API token (e.g., xxxxxxxxxxxxxxxxxxxx)" })),
+			VERCEL_ORG_ID: t.optional(t.text({ description: "Vercel organization ID (e.g., team_abc123...)" })),
+			VERCEL_PROJECT_ID: t.optional(t.text({ description: "Vercel project ID (e.g., prj_abc123...)" })),
+			CLOUDFLARE_API_TOKEN: t.optional(t.text({ description: "Cloudflare API token (e.g., xxxx-xxxx-xxxx-xxxx)" })),
+			CLOUDFLARE_ACCOUNT_ID: t.optional(t.text({ description: "Cloudflare account ID (e.g., abc123def456...)" }))
+		}),
+		handler: async ({ root, mode, flags }) => {
+			if (flags.build) await this.utils.exec("alepha build");
+			if (await this.utils.exists(root, "dist/vercel.json")) {
+				if (flags.migrate) {
+					this.log.debug("Running database migrations before deployment...");
+					await this.utils.exec(`alepha db migrate --mode=${mode}`);
+				}
+				await this.utils.ensureDependency(root, "vercel", { dev: true });
+				const command = `vercel . --cwd=dist ${mode === "production" ? "--prod" : ""}`.trim();
+				this.log.debug(`Deploying to Vercel with command: ${command}`);
+				await this.utils.exec(command);
+				return;
+			}
+			if (await this.utils.exists(root, "dist/wrangler.jsonc")) {
+				if (flags.migrate) {
+					this.log.debug("Running database migrations before deployment...");
+					await this.utils.exec(`alepha db migrate --mode=${mode}`);
+				}
+				await this.utils.ensureDependency(root, "wrangler", { dev: true });
+				const command = `wrangler deploy ${mode === "production" ? "" : "--env preview"} --config=dist/wrangler.jsonc`.trim();
+				this.log.info(`Deploying to Cloudflare with command: ${command}`);
+				await this.utils.exec(command);
+				return;
+			}
+			if (await this.utils.exists(root, "dist/public/404.html")) {
+				await this.utils.ensureDependency(root, "surge", { dev: true });
+				const distPath = join(root, "dist/public");
+				this.log.debug(`Deploying to Surge from directory: ${distPath}`);
+				await this.utils.exec(`surge ${distPath}`);
+				return;
+			}
+			throw new AlephaError("No deployment configuration found in the dist folder.");
 		}
 	});
 };
 
 //#endregion
-//#region ../../src/cli/commands/ViteCommands.ts
-var ViteCommands = class {
+//#region ../../src/cli/commands/dev.ts
+var DevCommand = class {
 	log = $logger();
 	utils = $inject(AlephaCliUtils);
-	env = $env(t.object({ VITEST_ARGS: t.string({ default: "" }) }));
-	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}`);
-		}
-	});
 	/**
 	* Will run the project in watch mode.
 	*
@@ -1375,7 +1315,7 @@ var ViteCommands = class {
 				tsconfigJson: true
 			});
 			if (expo) {
-				await this.utils.exec(`expo start`);
+				await this.utils.exec("expo start");
 				return;
 			}
 			const entry = await boot.getServerEntry(root, args);
@@ -1385,141 +1325,153 @@ var ViteCommands = class {
 			} catch {
 				this.log.trace("No index.html found, running entry file with tsx");
 				let cmd = "tsx --watch";
-				if (await this.utils.exists(root, ".env")) cmd += ` --env-file=./.env`;
+				if (await this.utils.exists(root, ".env")) cmd += " --env-file=./.env";
 				cmd += ` ${entry}`;
 				await this.utils.exec(cmd);
 				return;
 			}
 			await this.utils.ensureDependency(root, "vite");
-			await this.utils.exec(`vite`);
+			await this.utils.exec("vite");
 		}
 	});
-	build = $command({
-		name: "build",
-		description: "Build the project for production",
-		args: t.optional(t.text({
-			title: "path",
-			description: "Filepath to build"
-		})),
+};
+
+//#endregion
+//#region ../../src/cli/commands/format.ts
+var FormatCommand = class {
+	utils = $inject(AlephaCliUtils);
+	format = $command({
+		name: "format",
+		description: "Format the codebase using Biome",
+		handler: async ({ root }) => {
+			await this.utils.ensureConfig(root, { biomeJson: true });
+			await this.utils.ensureDependency(root, "@biomejs/biome");
+			await this.utils.exec("biome format --fix");
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/cli/commands/init.ts
+var InitCommand = class {
+	utils = $inject(AlephaCliUtils);
+	/**
+	* Ensure the project has the necessary Alepha configuration files.
+	* Add the correct dependencies to package.json and install them.
+	*/
+	init = $command({
+		name: "init",
+		description: "Add missing Alepha configuration files to the project",
 		flags: t.object({
-			stats: t.optional(t.boolean({ description: "Generate build stats report" })),
-			vercel: t.optional(t.boolean({ description: "Generate Vercel deployment configuration" })),
-			cloudflare: t.optional(t.boolean({ description: "Generate Cloudflare Workers configuration" })),
-			docker: t.optional(t.boolean({ description: "Generate Docker configuration" })),
-			sitemap: t.optional(t.text({ description: "Generate sitemap.xml with base URL" }))
+			yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
+			pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
+			npm: t.optional(t.boolean({ description: "Use npm package manager" })),
+			bun: t.optional(t.boolean({ description: "Use Bun package manager" })),
+			react: t.optional(t.boolean({ description: "Include Alepha React dependencies" })),
+			ui: t.optional(t.boolean({ description: "Include Alepha UI dependencies" })),
+			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" }))
 		}),
-		handler: async ({ flags, args, run, root }) => {
-			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
-			});
-			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] || {};
-			await this.utils.loadEnv(root, [".env", ".env.production"]);
-			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
-			const hasServer = viteAlephaBuildOptions.serverEntry !== 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
-				})
-			});
+		handler: async ({ run, flags, root }) => {
+			if (flags.ui) flags.react = true;
+			const isExpo = await this.utils.hasExpo(root);
 			await run({
-				name: "vite build server",
+				name: "ensuring configuration files",
 				handler: async () => {
-					let clientBuilt = false;
-					try {
-						await readFile(`${distDir}/${clientDir}/index.html`, "utf-8");
-						clientBuilt = true;
-					} catch {}
-					await buildServer({
-						silent: true,
-						entry,
-						distDir,
-						clientDir: clientBuilt ? clientDir : void 0,
-						stats
+					await this.utils.ensureConfig(root, {
+						tsconfigJson: true,
+						packageJson: flags,
+						biomeJson: true,
+						viteConfigTs: !isExpo,
+						editorconfig: true,
+						indexHtml: !!flags.react && !isExpo
 					});
-					if (clientBuilt && hasServer) await unlink(`${distDir}/${clientDir}/index.html`);
+					if (!flags.react) await this.utils.ensureSrcMain(root);
 				}
 			});
-			await copyAssets({
-				root,
-				entry: `${distDir}/index.js`,
-				distDir,
-				run
-			});
-			if (hasClient) {
-				const sitemapBaseUrl = flags.sitemap ?? clientOptions.sitemap?.hostname;
-				if (sitemapBaseUrl) await run({
-					name: "add sitemap",
-					handler: async () => {
-						await writeFile(`${distDir}/${clientDir}/sitemap.xml`, await generateSitemap({
-							entry: `${distDir}/index.js`,
-							baseUrl: sitemapBaseUrl
-						}));
-					}
-				});
-				if (clientOptions.prerender) await run({
-					name: "pre-render pages",
-					handler: async () => {
-						await prerenderPages({
-							dist: `${distDir}/${clientDir}`,
-							entry: `${distDir}/index.js`,
-							compress: clientOptions.precompress
-						});
-					}
-				});
-			}
-			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
-					})
-				});
+			const pm = await this.utils.getPackageManager(root, flags);
+			if (pm === "yarn") {
+				await this.utils.ensureYarn(root);
+				await run("yarn set version stable");
+			} 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 });
+			await this.utils.ensureDependency(root, "@biomejs/biome", { run });
+			if (flags.test) {
+				await this.utils.ensureTestDir(root);
+				await run(`${pm} ${pm === "yarn" ? "add" : "install"} -D vitest`, { alias: "setup testing with Vitest" });
 			}
-			if (flags.docker || viteAlephaBuildOptions.docker) {
-				const dockerConfig = typeof viteAlephaBuildOptions.docker === "object" ? viteAlephaBuildOptions.docker : {};
-				await run({
-					name: "add Docker config",
-					handler: () => generateDocker({
-						distDir,
-						...dockerConfig
-					})
-				});
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/cli/commands/lint.ts
+var LintCommand = class {
+	utils = $inject(AlephaCliUtils);
+	lint = $command({
+		name: "lint",
+		description: "Run linter across the codebase using Biome",
+		handler: async ({ root }) => {
+			await this.utils.ensureConfig(root, { biomeJson: true });
+			await this.utils.ensureDependency(root, "@biomejs/biome");
+			await this.utils.exec("biome check --formatter-enabled=false --fix");
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/cli/commands/root.ts
+var RootCommand = class {
+	log = $logger();
+	cli = $inject(CliProvider);
+	/**
+	* Called when no command is provided
+	*/
+	root = $command({
+		root: true,
+		flags: t.object({ version: t.optional(t.boolean({
+			description: "Show Alepha CLI version",
+			aliases: ["v"]
+		})) }),
+		handler: async ({ flags }) => {
+			if (flags.version) {
+				this.log.info(version);
+				return;
 			}
+			this.cli.printHelp();
+		}
+	});
+};
+
+//#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 {
+	utils = $inject(AlephaCliUtils);
 	test = $command({
 		name: "test",
 		description: "Run tests using Vitest",
@@ -1543,6 +1495,56 @@ var ViteCommands = class {
 	});
 };
 
+//#endregion
+//#region ../../src/cli/commands/typecheck.ts
+var TypecheckCommand = class {
+	utils = $inject(AlephaCliUtils);
+	/**
+	* Run TypeScript type checking across the codebase with no emit.
+	*/
+	typecheck = $command({
+		name: "typecheck",
+		description: "Check TypeScript types across the codebase",
+		handler: async ({ root }) => {
+			await this.utils.ensureDependency(root, "typescript");
+			await this.utils.exec("tsc --noEmit");
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/cli/commands/verify.ts
+var VerifyCommand = class {
+	utils = $inject(AlephaCliUtils);
+	/**
+	* Run a series of verification commands to ensure code quality and correctness.
+	*
+	* This command runs the following checks in order:
+	* - Clean the project
+	* - Format the code
+	* - Lint the code
+	* - Run tests (if Vitest is a dev dependency)
+	* - Check database migrations (if a migrations directory exists)
+	* - Type check the code
+	* - Build the project
+	* - Clean the project again
+	*/
+	verify = $command({
+		name: "verify",
+		description: "Verify the Alepha project",
+		handler: async ({ root, run }) => {
+			await run("alepha clean");
+			await run("alepha format");
+			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.hasExpo(root)) await run("alepha build");
+			await run("alepha clean");
+		}
+	});
+};
+
 //#endregion
 //#region ../../src/cli/apps/AlephaCli.ts
 var AlephaCliExtension = class {
@@ -1563,13 +1565,21 @@ const AlephaCli = $module({
 	name: "alepha.cli",
 	services: [
 		AlephaCliExtension,
-		BiomeCommands,
-		ChangelogCommands,
-		CoreCommands,
-		DeployCommands,
-		DrizzleCommands,
-		VerifyCommands,
-		ViteCommands
+		BuildCommand,
+		ChangelogCommand,
+		CleanCommand,
+		DbCommand,
+		DeployCommand,
+		DevCommand,
+		FormatCommand,
+		InitCommand,
+		LintCommand,
+		RootCommand,
+		RunCommand,
+		TestCommand,
+		TypecheckCommand,
+		VerifyCommand,
+		GitProvider
 	]
 });
 
@@ -1606,7 +1616,10 @@ var AlephaPackageBuilderCli = class {
 				pkgData.exports["./tsconfig.base"] = "./tsconfig.base.json";
 				pkgData.exports["./package.json"] = "./package.json";
 			}
-			if (packageName === "@alepha/ui") pkgData.exports["./styles"] = "./styles.css";
+			if (packageName === "@alepha/ui") {
+				pkgData.exports["./styles"] = "./src/core/styles.css";
+				pkgData.exports["./json/styles"] = "./src/json/styles.css";
+			}
 			await this.fs.writeFile("package.json", JSON.stringify(pkgData, null, 2));
 			const tmpDir = join(root, "node_modules/.alepha");
 			await this.fs.mkdir(tmpDir, { recursive: true }).catch(() => {});
@@ -1767,11 +1780,16 @@ async function analyzeModules(srcDir, packageName) {
 //#region ../../src/cli/defineConfig.ts
 const defineConfig = (config) => {
 	return (alepha) => {
-		const { commands } = config(alepha);
+		const { commands, services = [] } = config(alepha);
+		for (const it of services) alepha.with(it);
 		return { ...commands };
 	};
 };
+/**
+* @alias defineConfig
+*/
+const defineAlephaConfig = defineConfig;
 
 //#endregion
-export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BiomeCommands, ChangelogCommands, CoreCommands, DEFAULT_IGNORE, DeployCommands, DrizzleCommands, GitMessageParser, GitProvider, VerifyCommands, ViteCommands, analyzeModules, changelogOptions, defineConfig, version };
+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 };
 //# sourceMappingURL=index.js.map