alepha 0.15.0 → 0.15.1

package/dist/cli/index.js

@@ -2,7 +2,7 @@ import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, t } from "al
 import { FileSystemProvider } from "alepha/file";
 import { $command, CliProvider, EnvUtils } from "alepha/command";
 import { $logger, ConsoleColorProvider } from "alepha/logger";
-import { boot, buildClient, buildServer, copyAssets, devServer, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
+import { buildClient, buildServer, copyAssets, generateCloudflare, generateDocker, generateSitemap, generateVercel, importVite, importViteReact, prerenderPages, viteAlephaSsrPreload } from "alepha/vite";
 import { exec, spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
@@ -79,7 +79,7 @@ $atom$1[KIND] = "atom";
 * Options can be overridden via vite.config.ts or CLI flags.
 */
 const buildOptions = $atom$1({
-	name: "alepha.build.options",
+	name: "alepha.cli.build.options",
 	description: "Build configuration options",
 	schema: t.object({
 		stats: t.optional(t.boolean({ default: false })),
@@ -102,6 +102,180 @@ const buildOptions = $atom$1({
 	default: {}
 });
 
+//#endregion
+//#region ../../src/cli/atoms/appEntryOptions.ts
+const appEntryOptions = $atom({
+	name: "alepha.cli.appEntry.options",
+	schema: t.object({
+		server: t.optional(t.text()),
+		browser: t.optional(t.text()),
+		style: t.optional(t.text())
+	}),
+	default: {}
+});
+
+//#endregion
+//#region ../../src/cli/providers/AppEntryProvider.ts
+/**
+* Service for locating entry files in Alepha projects.
+*
+* Originally in alepha/vite, moved to CLI to avoid cli -> vite dependency.
+*/
+var AppEntryProvider = class {
+	fs = $inject(FileSystemProvider);
+	options = $use(appEntryOptions);
+	serverEntries = [
+		"main.server.ts",
+		"main.server.tsx",
+		"main.ts",
+		"main.tsx"
+	];
+	browserEntries = [
+		"main.browser.ts",
+		"main.browser.tsx",
+		"main.ts",
+		"main.tsx"
+	];
+	styleEntries = [
+		"main.css",
+		"styles.css",
+		"style.css"
+	];
+	/**
+	* Get application entry points.
+	*
+	* Server entry is required, an error is thrown if not found.
+	* Browser entry is optional.
+	*
+	* It will first check for custom entries in options, see appEntryOptions.
+	*/
+	async getAppEntry(root) {
+		const appEntry = {
+			root,
+			server: ""
+		};
+		if (this.options.server) {
+			if (!await this.fs.exists(this.fs.join(root, this.options.server))) throw new AlephaError(`Custom server entry "${this.options.server}" not found.`);
+			appEntry.server = this.options.server;
+		}
+		if (this.options.browser) {
+			if (!await this.fs.exists(this.fs.join(root, this.options.browser))) throw new AlephaError(`Custom browser entry "${this.options.browser}" not found.`);
+			appEntry.browser = this.options.browser;
+		}
+		if (this.options.style) {
+			if (!await this.fs.exists(this.fs.join(root, this.options.style))) throw new AlephaError(`Custom style entry "${this.options.style}" not found.`);
+			appEntry.style = this.options.style;
+		}
+		const srcFiles = await this.fs.ls(this.fs.join(root, "src"));
+		if (!appEntry.server) {
+			for (const entry of this.serverEntries) if (srcFiles.includes(entry)) {
+				appEntry.server = this.fs.join("src", entry);
+				break;
+			}
+		}
+		if (!appEntry.server) throw new AlephaError("No server entry found. Please, add a main.server.ts file in the src/ directory or configure a custom entry in alepha.config.ts.");
+		if (!appEntry.browser) {
+			for (const entry of this.browserEntries) if (srcFiles.includes(entry)) {
+				appEntry.browser = this.fs.join("src", entry);
+				break;
+			}
+		}
+		if (!appEntry.style) {
+			for (const entry of this.styleEntries) if (srcFiles.includes(entry)) {
+				appEntry.style = this.fs.join("src", entry);
+				break;
+			}
+		}
+		return appEntry;
+	}
+};
+
+//#endregion
+//#region ../../src/cli/providers/ViteTemplateProvider.ts
+var ViteTemplateProvider = class {
+	fs = $inject(FileSystemProvider);
+	generateIndexHtml(entry) {
+		const style = entry.style;
+		const browser = entry.browser ?? entry.server;
+		return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<title>App</title>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+${style ? `<link rel="stylesheet" href="/${style}" />` : ""}
+</head>
+<body>
+<div id="root"></div>
+<script type="module" src="/${browser}"><\/script>
+</body>
+</html>
+`.trim();
+	}
+};
+
+//#endregion
+//#region ../../src/cli/providers/ViteBuildProvider.ts
+var ViteBuildProvider = class {
+	alepha;
+	appEntry;
+	viteDevServer;
+	templateProvider = $inject(ViteTemplateProvider);
+	/**
+	* We need to close the Vite dev server after build is done.
+	*/
+	onReady = $hook({
+		on: "ready",
+		priority: "last",
+		handler: async () => {
+			await this.viteDevServer?.close();
+		}
+	});
+	onStop = $hook({
+		on: "stop",
+		handler: async () => {
+			await this.viteDevServer?.close();
+		}
+	});
+	async init(opts) {
+		const { createServer } = await importVite();
+		process.env.ALEPHA_CLI_IMPORT = "true";
+		process.env.NODE_ENV = "production";
+		process.env.LOG_LEVEL ??= "warn";
+		/**
+		* 01/26 Vite 7
+		* "runnerImport" doesn't work as expected here. (e.g. build docs fail)
+		* -> We still use devServer and ssrLoadModule for now.
+		* -> This is clearly a bad stuff, we need to find better way.
+		*/
+		this.viteDevServer = await createServer({
+			server: { middlewareMode: true },
+			appType: "custom",
+			logLevel: "silent"
+		});
+		await this.viteDevServer.ssrLoadModule(opts.entry.server);
+		const alepha = globalThis.__alepha;
+		if (!alepha) throw new AlephaError("Alepha instance not found after loading entry module");
+		this.alepha = alepha;
+		this.appEntry = opts.entry;
+		return alepha;
+	}
+	hasClient() {
+		if (!this.alepha) throw new AlephaError("ViteBuildProvider not initialized");
+		try {
+			this.alepha.inject("ReactServerProvider");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	generateIndexHtml() {
+		if (!this.appEntry) throw new AlephaError("ViteBuildProvider not initialized");
+		return this.templateProvider.generateIndexHtml(this.appEntry);
+	}
+};
+
 //#endregion
 //#region ../../src/cli/services/AlephaCliUtils.ts
 /**
@@ -117,14 +291,15 @@ var AlephaCliUtils = class {
 	log = $logger();
 	fs = $inject(FileSystemProvider);
 	envUtils = $inject(EnvUtils);
+	boot = $inject(AppEntryProvider);
 	/**
 	* Execute a command with inherited stdio.
 	*/
 	async exec(command, options = {}) {
 		const root = options.root ?? process.cwd();
 		this.log.debug(`Executing command: ${command}`, { cwd: root });
-		const runExec = async (app$1, args$1) => {
-			const prog = spawn(app$1, args$1, {
+		const runExec = async (app, args) => {
+			const prog = spawn(app, args, {
 				stdio: "inherit",
 				cwd: root,
 				env: {
@@ -137,14 +312,22 @@ var AlephaCliUtils = class {
 			}));
 		};
 		if (options.global) {
-			const [app$1, ...args$1] = command.split(" ");
-			await runExec(app$1, args$1);
+			const [app, ...args] = command.split(" ");
+			await runExec(app, args);
 			return;
 		}
 		const suffix = process.platform === "win32" ? ".cmd" : "";
 		const [app, ...args] = command.split(" ");
 		let execPath = await this.checkFileExists(root, `node_modules/.bin/${app}${suffix}`);
 		if (!execPath) execPath = await this.checkFileExists(root, `node_modules/alepha/node_modules/.bin/${app}${suffix}`);
+		if (!execPath) {
+			let parentDir = this.fs.join(root, "..");
+			for (let i = 0; i < 3; i++) {
+				execPath = await this.checkFileExists(parentDir, `node_modules/.bin/${app}${suffix}`);
+				if (execPath) break;
+				parentDir = this.fs.join(parentDir, "..");
+			}
+		}
 		if (!execPath) throw new AlephaError(`Could not find executable for command '${app}'. Make sure the package is installed.`);
 		await runExec(execPath, args);
 	}
@@ -164,7 +347,15 @@ var AlephaCliUtils = class {
 	*/
 	async loadAlephaFromServerEntryFile(rootDir, explicitEntry) {
 		process.env.ALEPHA_CLI_IMPORT = "true";
-		const entry = await boot.getServerEntry(rootDir, explicitEntry);
+		const root = rootDir ?? process.cwd();
+		let entry;
+		if (explicitEntry) {
+			entry = this.fs.join(root, explicitEntry);
+			if (!await this.fs.exists(entry)) throw new AlephaError(`Explicit server entry file "${explicitEntry}" not found.`);
+		} else {
+			const appEntry = await this.boot.getAppEntry(root);
+			entry = this.fs.join(root, appEntry.server);
+		}
 		delete global.__alepha;
 		const mod = await import(entry);
 		this.log.debug(`Load entry: ${entry}`);
@@ -283,6 +474,12 @@ var PackageManagerUtils = class {
 		return this.hasDependency(root, "expo");
 	}
 	/**
+	* Check if React is present in the project.
+	*/
+	async hasReact(root) {
+		return this.hasDependency(root, "react");
+	}
+	/**
 	* Install a dependency if it's missing from the project.
 	*/
 	async ensureDependency(root, packageName, options = {}) {
@@ -293,7 +490,7 @@ var PackageManagerUtils = class {
 		}
 		const cmd = await this.getInstallCommand(root, packageName, dev);
 		if (options.run) await options.run(cmd, {
-			alias: `installing ${packageName}`,
+			alias: `add ${packageName}`,
 			root
 		});
 		else if (options.exec) {
@@ -368,17 +565,17 @@ var PackageManagerUtils = class {
 			await this.writePackageJson(root, content);
 			return content;
 		}
-		const packageJson$1 = await this.readPackageJson(root);
+		const packageJson = await this.readPackageJson(root);
 		const newContent = this.generatePackageJsonContent(modes);
-		packageJson$1.type = "module";
-		packageJson$1.dependencies ??= {};
-		packageJson$1.devDependencies ??= {};
-		packageJson$1.scripts ??= {};
-		Object.assign(packageJson$1.dependencies, newContent.dependencies);
-		Object.assign(packageJson$1.devDependencies, newContent.devDependencies);
-		Object.assign(packageJson$1.scripts, newContent.scripts);
-		await this.writePackageJson(root, packageJson$1);
-		return packageJson$1;
+		packageJson.type = "module";
+		packageJson.dependencies ??= {};
+		packageJson.devDependencies ??= {};
+		packageJson.scripts ??= {};
+		Object.assign(packageJson.dependencies, newContent.dependencies);
+		Object.assign(packageJson.devDependencies, newContent.devDependencies);
+		Object.assign(packageJson.scripts, newContent.scripts);
+		await this.writePackageJson(root, packageJson);
+		return packageJson;
 	}
 	generatePackageJsonContent(modes) {
 		const dependencies = { alepha: `^${version}` };
@@ -390,11 +587,11 @@ var PackageManagerUtils = class {
 			typecheck: "alepha typecheck",
 			verify: "alepha verify"
 		};
-		if (modes.admin) {
+		if (modes.ui) {
 			dependencies["@alepha/ui"] = `^${version}`;
-			modes.web = true;
+			modes.react = true;
 		}
-		if (modes.web) {
+		if (modes.react) {
 			dependencies["@alepha/react"] = `^${version}`;
 			dependencies.react = "^19.2.0";
 			dependencies["react-dom"] = "^19.2.0";
@@ -453,7 +650,7 @@ export const ApiModule = $module({
 
 //#endregion
 //#region ../../src/cli/assets/biomeJson.ts
-const biomeJson = `
+const biomeJson = () => `
 {
   "$schema": "https://biomejs.dev/schemas/latest/schema.json",
   "vcs": {
@@ -549,8 +746,8 @@ ${projectName}/
 │   │   ├── AppRouter.ts  # Routes with $page
 │   │   └── index.ts      # Web module definition with $module
 │   ├── main.server.ts    # Server entry
-│   └── main.browser.ts   # Browser entry (React only)
-├── index.html            # (React only)
+│   ├── main.browser.ts   # Browser entry (React only)
+│   └── main.css          # CSS entry (React only)
 ├── package.json
 └── tsconfig.json
 \`\`\`
@@ -595,6 +792,7 @@ This is an **Alepha** project - a convention-driven TypeScript framework for typ
 - Use \`protected\` instead of \`private\` for class members
 - Import with file extensions: \`import { User } from "./User.ts"\`
 - Use \`t\` from Alepha for schemas (not Zod)
+- Prefer \`t.text()\` over \`t.string()\` for user input (has default max length, auto-trim, supports lowercase option)
 
 ## Project Structure
 ${projectStructure}
@@ -792,7 +990,7 @@ test("dummy test", () => {
 
 //#endregion
 //#region ../../src/cli/assets/editorconfig.ts
-const editorconfig = `
+const editorconfig = () => `
 # https://editorconfig.org
 
 root = true
@@ -806,22 +1004,6 @@ indent_style = space
 indent_size = 2
 `.trim();
 
-//#endregion
-//#region ../../src/cli/assets/indexHtml.ts
-const indexHtml = (browserEntry) => `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>App</title>
-</head>
-<body>
-<div id="root"></div>
-<script type="module" src="${browserEntry}"><\/script>
-</body>
-</html>
-`.trim();
-
 //#endregion
 //#region ../../src/cli/assets/mainBrowserTs.ts
 const mainBrowserTs = () => `
@@ -835,6 +1017,32 @@ alepha.with(WebModule);
 run(alepha);
 `.trim();
 
+//#endregion
+//#region ../../src/cli/assets/mainCss.ts
+const mainCss = () => `
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+html,
+body {
+  height: 100%;
+}
+
+body {
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
+    "Helvetica Neue", Arial, sans-serif;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
+}
+
+#root {
+  height: 100%;
+}
+`.trim();
+
 //#endregion
 //#region ../../src/cli/assets/mainServerTs.ts
 const mainServerTs = (options = {}) => {
@@ -853,7 +1061,7 @@ run(alepha);
 
 //#endregion
 //#region ../../src/cli/assets/tsconfigJson.ts
-const tsconfigJson = `
+const tsconfigJson = () => `
 {
   "extends": "alepha/tsconfig.base"
 }
@@ -879,15 +1087,18 @@ export class AppRouter {
 
 //#endregion
 //#region ../../src/cli/assets/webHelloComponentTsx.ts
-const webHelloComponentTsx = () => `
+const webHelloComponentTsx = () => `import { useState } from "react";
+
 interface Props {
   message: string;
 }
 
 const Hello = (props: Props) => {
+  const [message, setMessage] = useState(props.message);
   return (
     <div>
-      <h1>{props.message}</h1>
+      <h1>{message}</h1>
+      <input value={message} onChange={e => setMessage(e.target.value)} />
       <p>Edit this component in src/web/components/Hello.tsx</p>
     </div>
   );
@@ -942,27 +1153,30 @@ var ProjectScaffolder = class {
 	*/
 	async ensureConfig(root, opts) {
 		const tasks = [];
+		const force = opts.force ?? false;
 		if (opts.packageJson) tasks.push(this.pm.ensurePackageJson(root, typeof opts.packageJson === "boolean" ? {} : opts.packageJson).then(() => {}));
-		if (opts.tsconfigJson) tasks.push(this.ensureTsConfig(root));
-		if (opts.indexHtml) tasks.push(this.ensureReactProject(root));
-		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root));
-		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root));
-		if (opts.claudeMd) tasks.push(this.ensureClaudeMd(root, typeof opts.claudeMd === "boolean" ? {} : opts.claudeMd));
+		if (opts.tsconfigJson) tasks.push(this.ensureTsConfig(root, { force }));
+		if (opts.indexHtml) tasks.push(this.ensureReactProject(root, { force }));
+		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root, { force }));
+		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root, { force }));
+		if (opts.claudeMd) tasks.push(this.ensureClaudeMd(root, typeof opts.claudeMd === "boolean" ? { force } : {
+			...opts.claudeMd,
+			force
+		}));
 		await Promise.all(tasks);
 	}
-	async ensureTsConfig(root) {
-		if (await this.existsInParents(root, "tsconfig.json")) return;
-		await this.fs.writeFile(this.fs.join(root, "tsconfig.json"), tsconfigJson);
+	async ensureTsConfig(root, opts = {}) {
+		if (!opts.force && await this.existsInParents(root, "tsconfig.json")) return;
+		await this.fs.writeFile(this.fs.join(root, "tsconfig.json"), tsconfigJson());
 	}
-	async ensureBiomeConfig(root) {
-		await this.ensureFileIfNotExists(root, "biome.json", biomeJson);
+	async ensureBiomeConfig(root, opts = {}) {
+		await this.ensureFile(root, "biome.json", biomeJson(), opts.force);
 	}
-	async ensureEditorConfig(root) {
-		await this.ensureFileIfNotExists(root, ".editorconfig", editorconfig);
+	async ensureEditorConfig(root, opts = {}) {
+		await this.ensureFile(root, ".editorconfig", editorconfig(), opts.force);
 	}
 	async ensureClaudeMd(root, options = {}) {
-		const path = this.fs.join(root, "CLAUDE.md");
-		if (!await this.fs.exists(path)) await this.fs.writeFile(path, claudeMd(options));
+		await this.ensureFile(root, "CLAUDE.md", claudeMd(options), options.force);
 	}
 	/**
 	* Ensure src/main.server.ts exists with full API structure.
@@ -972,39 +1186,37 @@ var ProjectScaffolder = class {
 	* - src/api/index.ts (API module)
 	* - src/api/controllers/HelloController.ts (example controller)
 	*/
-	async ensureApiProject(root) {
+	async ensureApiProject(root, opts = {}) {
 		const srcDir = this.fs.join(root, "src");
-		if (await this.fs.exists(srcDir)) {
+		if (!opts.force && await this.fs.exists(srcDir)) {
 			if ((await this.fs.ls(srcDir)).length > 0) return;
 		}
 		const appName = this.getAppName(root);
 		await this.fs.mkdir(this.fs.join(root, "src/api/controllers"), { recursive: true });
-		await this.fs.writeFile(this.fs.join(srcDir, "main.server.ts"), mainServerTs());
-		await this.fs.writeFile(this.fs.join(srcDir, "api/index.ts"), apiIndexTs({ appName }));
-		await this.fs.writeFile(this.fs.join(srcDir, "api/controllers/HelloController.ts"), apiHelloControllerTs());
+		await this.ensureFile(srcDir, "main.server.ts", mainServerTs(), opts.force);
+		await this.ensureFile(srcDir, "api/index.ts", apiIndexTs({ appName }), opts.force);
+		await this.ensureFile(srcDir, "api/controllers/HelloController.ts", apiHelloControllerTs(), opts.force);
 	}
 	/**
 	* Ensure full React project structure exists.
 	*
 	* Creates:
-	* - index.html
 	* - src/main.server.ts, src/main.browser.ts
 	* - src/api/index.ts, src/api/controllers/HelloController.ts
 	* - src/web/index.ts, src/web/AppRouter.ts, src/web/components/Hello.tsx
 	*/
-	async ensureReactProject(root) {
-		if (await this.fs.exists(this.fs.join(root, "index.html"))) return;
+	async ensureReactProject(root, opts = {}) {
 		const appName = this.getAppName(root);
 		await this.fs.mkdir(this.fs.join(root, "src/api/controllers"), { recursive: true });
 		await this.fs.mkdir(this.fs.join(root, "src/web/components"), { recursive: true });
-		await this.fs.writeFile(this.fs.join(root, "index.html"), indexHtml("src/main.browser.ts"));
-		await this.ensureFileIfNotExists(root, "src/api/index.ts", apiIndexTs({ appName }));
-		await this.ensureFileIfNotExists(root, "src/api/controllers/HelloController.ts", apiHelloControllerTs());
-		await this.ensureFileIfNotExists(root, "src/main.server.ts", mainServerTs({ react: true }));
-		await this.ensureFileIfNotExists(root, "src/web/index.ts", webIndexTs({ appName }));
-		await this.ensureFileIfNotExists(root, "src/web/AppRouter.ts", webAppRouterTs());
-		await this.ensureFileIfNotExists(root, "src/web/components/Hello.tsx", webHelloComponentTsx());
-		await this.ensureFileIfNotExists(root, "src/main.browser.ts", mainBrowserTs());
+		await this.ensureFile(root, "src/main.css", mainCss(), opts.force);
+		await this.ensureFile(root, "src/api/index.ts", apiIndexTs({ appName }), opts.force);
+		await this.ensureFile(root, "src/api/controllers/HelloController.ts", apiHelloControllerTs(), opts.force);
+		await this.ensureFile(root, "src/main.server.ts", mainServerTs({ react: true }), opts.force);
+		await this.ensureFile(root, "src/web/index.ts", webIndexTs({ appName }), opts.force);
+		await this.ensureFile(root, "src/web/AppRouter.ts", webAppRouterTs(), opts.force);
+		await this.ensureFile(root, "src/web/components/Hello.tsx", webHelloComponentTsx(), opts.force);
+		await this.ensureFile(root, "src/main.browser.ts", mainBrowserTs(), opts.force);
 	}
 	/**
 	* Ensure test directory exists with a dummy test file.
@@ -1019,9 +1231,12 @@ var ProjectScaffolder = class {
 		}
 		if ((await this.fs.ls(testDir)).length === 0) await this.fs.writeFile(dummyPath, dummySpecTs());
 	}
-	async ensureFileIfNotExists(root, relativePath, content) {
+	/**
+	* Write a file, optionally overriding if it exists.
+	*/
+	async ensureFile(root, relativePath, content, force) {
 		const fullPath = this.fs.join(root, relativePath);
-		if (!await this.fs.exists(fullPath)) await this.fs.writeFile(fullPath, content);
+		if (force || !await this.fs.exists(fullPath)) await this.fs.writeFile(fullPath, content);
 	}
 	/**
 	* Check if a file exists in the given directory or any parent directory.
@@ -1045,15 +1260,13 @@ var BuildCommand = class {
 	utils = $inject(AlephaCliUtils);
 	pm = $inject(PackageManagerUtils);
 	scaffolder = $inject(ProjectScaffolder);
+	boot = $inject(AppEntryProvider);
+	viteBuildProvider = $inject(ViteBuildProvider);
 	options = $use(buildOptions);
 	build = $command({
 		name: "build",
 		mode: "production",
 		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" })),
@@ -1062,15 +1275,14 @@ var BuildCommand = class {
 			sitemap: t.optional(t.text({ description: "Generate sitemap.xml with base URL" })),
 			bun: t.optional(t.boolean({ description: "Prioritize .bun.ts entry files for Bun runtime" }))
 		}),
-		handler: async ({ flags, args, run, root }) => {
-			process.env.ALEPHA_BUILD_MODE = "cli";
+		handler: async ({ flags, run, root }) => {
 			process.env.NODE_ENV = "production";
 			if (await this.pm.hasExpo(root)) return;
 			await this.scaffolder.ensureConfig(root, { tsconfigJson: true });
-			const entry = await boot.getServerEntry(root, args);
+			const entry = await this.boot.getAppEntry(root);
 			this.log.trace("Entry file found", { entry });
 			const distDir = "dist";
-			const clientDir = "public";
+			const publicDir = "public";
 			await this.pm.ensureDependency(root, "vite", {
 				run,
 				exec: (cmd, opts) => this.utils.exec(cmd, opts)
@@ -1079,36 +1291,58 @@ var BuildCommand = class {
 			const options = this.options;
 			await this.utils.loadEnv(root, [".env", ".env.production"]);
 			const stats = flags.stats ?? options.stats ?? false;
-			const hasClient = await this.fs.exists(this.fs.join(root, "index.html"));
-			if (hasClient) await run({
-				name: "vite build client",
-				handler: () => buildClient({
-					silent: true,
-					dist: `${distDir}/${clientDir}`,
-					stats,
-					precompress: true
-				})
+			let template = "";
+			let hasClient = false;
+			let alepha;
+			await run({
+				name: "analyze app",
+				handler: async () => {
+					alepha = await this.viteBuildProvider.init({ entry });
+					hasClient = this.viteBuildProvider.hasClient();
+					if (hasClient) template = this.viteBuildProvider.generateIndexHtml();
+				}
 			});
+			if (!alepha) throw new AlephaError("Alepha instance not found");
+			if (hasClient) {
+				const indexHtmlPath = this.fs.join(root, "index.html");
+				await this.fs.writeFile(indexHtmlPath, template);
+				try {
+					await run({
+						name: "vite build client",
+						handler: () => buildClient({
+							silent: true,
+							dist: `${distDir}/${publicDir}`,
+							stats,
+							precompress: true
+						})
+					});
+				} finally {
+					await this.fs.rm(indexHtmlPath);
+				}
+			}
 			await run({
 				name: "vite build server",
 				handler: async () => {
-					const clientIndexPath = `${distDir}/${clientDir}/index.html`;
+					if (!alepha) throw new AlephaError("Alepha instance not found");
+					const clientIndexPath = `${distDir}/${publicDir}/index.html`;
 					const clientBuilt = await this.fs.exists(clientIndexPath);
 					const conditions = [];
 					if (flags.bun) conditions.push("bun");
 					if (options.cloudflare) conditions.push("workerd");
 					await buildServer({
 						silent: true,
-						entry,
+						entry: entry.server,
 						distDir,
-						clientDir: clientBuilt ? clientDir : void 0,
+						clientDir: clientBuilt ? publicDir : void 0,
 						stats,
-						conditions
+						conditions,
+						alepha
 					});
 					if (clientBuilt) await this.fs.rm(clientIndexPath);
 				}
 			});
 			await copyAssets({
+				alepha,
 				root,
 				entry: `${distDir}/index.js`,
 				distDir,
@@ -1116,31 +1350,24 @@ var BuildCommand = class {
 			});
 			if (hasClient) {
 				const sitemapHostname = flags.sitemap ?? options.sitemap?.hostname;
-				if (sitemapHostname) await run({
-					name: "add sitemap",
-					handler: async () => {
-						await this.fs.writeFile(`${distDir}/${clientDir}/sitemap.xml`, await generateSitemap({
-							entry: `${distDir}/index.js`,
-							baseUrl: sitemapHostname
-						}));
-					}
+				if (sitemapHostname) await generateSitemap({
+					alepha,
+					baseUrl: sitemapHostname,
+					output: `${distDir}/${publicDir}/sitemap.xml`,
+					run
 				});
-				await run({
-					name: "pre-render pages",
-					handler: async () => {
-						await prerenderPages({
-							dist: `${distDir}/${clientDir}`,
-							entry: `${distDir}/index.js`,
-							compress: true
-						});
-					}
+				await prerenderPages({
+					alepha,
+					dist: `${distDir}/${publicDir}`,
+					compress: true,
+					run
 				});
 			}
 			if (flags.vercel || options.vercel) await run({
 				name: "add Vercel config",
 				handler: () => generateVercel({
 					distDir,
-					clientDir,
+					clientDir: publicDir,
 					config: options.vercel
 				})
 			});
@@ -1528,6 +1755,237 @@ var DeployCommand = class {
 	});
 };
 
+//#endregion
+//#region ../../src/cli/providers/ViteDevServerProvider.ts
+/**
+* Vite development server with Alepha integration.
+*
+* Architecture:
+* - Vite runs in middleware mode (no HTTP server)
+* - Alepha is the HTTP server via server:onRequest event
+* - Request flow: Page requests → Alepha SSR, Assets → Vite middleware
+*
+* HMR Strategy:
+* - Browser-only changes (CSS, client components) → Vite HMR (React Fast Refresh)
+* - Server-only changes → Restart Alepha → Full browser reload
+* - Shared changes → Restart Alepha → Let Vite HMR propagate
+*
+* Features:
+* - Automatic .env reload detection
+* - Error recovery on next file change
+* - Optimized module invalidation (only changed files + importers)
+*/
+var ViteDevServerProvider = class {
+	log = $logger();
+	fs = $inject(FileSystemProvider);
+	templateProvider = $inject(ViteTemplateProvider);
+	server;
+	options;
+	alepha = null;
+	hasError = false;
+	changedFiles = /* @__PURE__ */ new Set();
+	async init(options) {
+		this.options = options;
+		await this.createViteServer();
+		return await this.loadAlepha(true);
+	}
+	async start() {
+		await this.alepha?.start();
+	}
+	/**
+	* Create the Vite server in middleware mode.
+	*/
+	async createViteServer() {
+		const { createServer } = await importVite();
+		const viteReact = await importViteReact();
+		const plugins = [];
+		if (viteReact) plugins.push(viteReact());
+		plugins.push(viteAlephaSsrPreload());
+		plugins.push(this.createHmrPlugin());
+		this.server = await createServer({
+			root: this.options.root,
+			plugins,
+			server: { middlewareMode: true },
+			appType: "custom",
+			customLogger: {
+				info: () => {},
+				warn: this.log.warn.bind(this.log),
+				error: this.log.error.bind(this.log),
+				warnOnce: this.log.warn.bind(this.log),
+				clearScreen: () => {},
+				hasWarned: false,
+				hasErrorLogged: () => false
+			}
+		});
+		this.server.restart = async () => {
+			const startTime = Date.now();
+			try {
+				this.hasError = true;
+				await this.loadAlepha(false);
+				await this.alepha?.start();
+				this.log.debug(`Env reloaded in ${Date.now() - startTime}ms`);
+				this.sendBrowserReload();
+			} catch (err) {
+				this.hasError = true;
+				this.log.error("Reload failed", err);
+				this.log.warn("Waiting for file changes to retry...");
+				this.alepha = null;
+			}
+		};
+	}
+	/**
+	* Vite plugin to handle HMR for Alepha.
+	*/
+	createHmrPlugin() {
+		return {
+			name: "alepha-hmr",
+			handleHotUpdate: async (ctx) => {
+				if (ctx.file.includes("/.idea/")) return [];
+				const firstModule = ctx.modules[0];
+				const isBrowserOnly = firstModule && !firstModule._ssrModule;
+				const isServerOnly = firstModule && !firstModule._clientModule;
+				if (isBrowserOnly) return;
+				const startTime = Date.now();
+				try {
+					this.changedFiles.add(ctx.file);
+					await this.loadAlepha(false);
+					await this.alepha?.start();
+					this.log.debug(`Reloaded in ${Date.now() - startTime}ms`);
+					if (isServerOnly) {
+						this.sendBrowserReload();
+						return [];
+					}
+					return;
+				} catch (err) {
+					this.hasError = true;
+					this.log.error("Reload failed", err);
+					this.log.warn("Waiting for file changes to retry...");
+					this.alepha = null;
+					return [];
+				}
+			}
+		};
+	}
+	/**
+	* Send browser reload signal via custom event.
+	* Browser listens for 'alepha:reload' and does window.location.reload()
+	*/
+	sendBrowserReload() {
+		this.server.ws.send({
+			type: "custom",
+			event: "alepha:reload",
+			data: {}
+		});
+	}
+	/**
+	* Setup environment variables for dev mode.
+	*/
+	async setupEnvironment() {
+		const { loadEnv } = await importVite();
+		const env = loadEnv(process.env.NODE_ENV || "development", this.options.root, "");
+		process.env.NODE_ENV ??= "development";
+		process.env.VITE_ALEPHA_DEV = "true";
+		process.env.SERVER_HOST ??= this.options.host?.toString() ?? "localhost";
+		process.env.SERVER_PORT ??= String(this.options.port ?? (process.env.SERVER_PORT ? Number(process.env.SERVER_PORT) : 3e3));
+		for (const [key, value] of Object.entries(env)) process.env[key] ??= value;
+	}
+	/**
+	* Load or reload the Alepha instance.
+	*/
+	async loadAlepha(isInitialLoad = false) {
+		if (this.alepha) {
+			await this.alepha.stop().catch((err) => this.log.warn("Error stopping Alepha", err));
+			this.alepha = null;
+		}
+		if (isInitialLoad || this.hasError) this.server.moduleGraph.invalidateAll();
+		else this.invalidateModulesWithImporters();
+		this.changedFiles.clear();
+		const envSnapshot = { ...process.env };
+		await this.setupEnvironment();
+		await this.server.ssrLoadModule(this.options.entry.server);
+		const alepha = globalThis.__alepha;
+		if (!alepha) throw new AlephaError("Alepha instance not found after loading entry module");
+		this.alepha = alepha;
+		await this.setupAlepha();
+		this.hasError = false;
+		process.env = envSnapshot;
+		return alepha;
+	}
+	hasReact() {
+		try {
+			this.alepha?.inject("ReactServerProvider");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Setup Alepha instance with Vite middleware and template.
+	*/
+	async setupAlepha() {
+		if (!this.alepha || !this.hasReact()) return;
+		const template = await this.server.transformIndexHtml("/", this.templateProvider.generateIndexHtml(this.options.entry));
+		this.alepha.store.set("alepha.react.server.template", template);
+		this.alepha.events.on("server:onRequest", {
+			priority: "first",
+			callback: async ({ request }) => {
+				const node = request.raw.node;
+				if (!node || this.isPageRequest(node.req)) return;
+				if (await this.runViteMiddleware(node.req, node.res, request)) {
+					request.reply.status = node.res.statusCode || 200;
+					request.reply.body = null;
+				}
+			}
+		});
+	}
+	/**
+	* Check if request is for an HTML page (not an asset).
+	*/
+	isPageRequest(req) {
+		const url = req.url || "/";
+		if (url === "/" || url === "/index.html") return true;
+		if (url.startsWith("/@") || url.startsWith("/__vite")) return false;
+		if (/\.\w+$/.test(url.split("?")[0])) return false;
+		return true;
+	}
+	/**
+	* Run Vite middleware and detect if it handled the request.
+	*/
+	async runViteMiddleware(req, res, ctx) {
+		return new Promise((resolve) => {
+			let resolved = false;
+			const done = (handled) => {
+				if (resolved) return;
+				resolved = true;
+				if (handled) ctx.metadata.vite = true;
+				resolve(handled);
+			};
+			res.on("finish", () => done(true));
+			res.on("close", () => res.headersSent && done(true));
+			this.server.middlewares(req, res, () => done(false));
+			setImmediate(() => {
+				if (res.headersSent || res.writableEnded) done(true);
+			});
+		});
+	}
+	/**
+	* Invalidate modules and all their importers.
+	*/
+	invalidateModulesWithImporters() {
+		const invalidated = /* @__PURE__ */ new Set();
+		const queue = [...this.changedFiles];
+		while (queue.length > 0) {
+			const file = queue.pop();
+			if (invalidated.has(file)) continue;
+			const mod = this.server.moduleGraph.getModuleById(file);
+			if (!mod) continue;
+			this.server.moduleGraph.invalidateModule(mod);
+			invalidated.add(file);
+			for (const importer of mod.importers) if (importer.id && !invalidated.has(importer.id)) queue.push(importer.id);
+		}
+	}
+};
+
 //#endregion
 //#region ../../src/cli/commands/dev.ts
 var DevCommand = class {
@@ -1537,6 +1995,8 @@ var DevCommand = class {
 	pm = $inject(PackageManagerUtils);
 	scaffolder = $inject(ProjectScaffolder);
 	alepha = $inject(Alepha);
+	viteDevServer = $inject(ViteDevServerProvider);
+	boot = $inject(AppEntryProvider);
 	/**
 	* Will run the project in watch mode.
 	*
@@ -1546,53 +2006,21 @@ var DevCommand = class {
 	dev = $command({
 		name: "dev",
 		description: "Run the project in development mode",
-		args: t.optional(t.text({
-			title: "path",
-			description: "Filepath to run"
-		})),
-		handler: async ({ args, root }) => {
-			const expo = await this.pm.hasExpo(root);
+		handler: async ({ root }) => {
+			const [expo, react] = await Promise.all([this.pm.hasExpo(root), this.pm.hasReact(root)]);
 			await this.scaffolder.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 });
-			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, { global: exe === "bun" });
-				return;
-			}
+			const entry = await this.boot.getAppEntry(root);
+			this.log.debug("Entry file found", { entry });
 			await this.pm.ensureDependency(root, "vite", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
-			await devServer();
-		}
-	});
-	async isBunProject(root) {
-		if (this.alepha.isBun()) return true;
-		return this.fs.exists(this.fs.join(root, "bun.lock"));
-	}
-	async isFullstackProject(root) {
-		return this.fs.exists(this.fs.join(root, "index.html"));
-	}
-};
-
-//#endregion
-//#region ../../src/cli/commands/format.ts
-var FormatCommand = class {
-	utils = $inject(AlephaCliUtils);
-	pm = $inject(PackageManagerUtils);
-	scaffolder = $inject(ProjectScaffolder);
-	format = $command({
-		name: "format",
-		description: "Format the codebase using Biome",
-		handler: async ({ root }) => {
-			await this.scaffolder.ensureConfig(root, { biomeJson: true });
-			await this.pm.ensureDependency(root, "@biomejs/biome", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
-			await this.utils.exec("biome format --fix");
+			await this.viteDevServer.init({
+				root,
+				entry
+			});
+			await this.viteDevServer.start();
 		}
 	});
 };
@@ -1627,7 +2055,7 @@ const DEFAULT_IGNORE = [
 * ```
 */
 const changelogOptions = $atom({
-	name: "alepha.changelog",
+	name: "alepha.cli.changelog.options",
 	schema: t.object({ ignore: t.optional(t.array(t.string())) }),
 	default: { ignore: DEFAULT_IGNORE }
 });
@@ -1835,7 +2263,7 @@ var GenEnvCommand = class {
 					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`;
+					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);
@@ -1935,35 +2363,41 @@ var InitCommand = class {
 			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" })),
-			web: t.optional(t.boolean({
+			react: t.optional(t.boolean({
 				aliases: ["r"],
 				description: "Include Alepha React dependencies"
 			})),
-			admin: t.optional(t.boolean({ description: "Include Alepha UI dependencies" })),
-			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" }))
+			ui: t.optional(t.boolean({ description: "Include Alepha UI dependencies" })),
+			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" })),
+			force: t.optional(t.boolean({
+				aliases: ["f"],
+				description: "Override existing files"
+			}))
 		}),
 		handler: async ({ run, flags, root, args }) => {
-			if (flags.admin) flags.web = true;
+			if (flags.react) flags.ui = true;
 			if (args) {
 				root = this.fs.join(root, args);
 				await this.fs.mkdir(root);
 			}
 			const isExpo = await this.pm.hasExpo(root);
+			const force = !!flags.force;
 			await run({
 				name: "ensuring configuration files",
 				handler: async () => {
 					await this.scaffolder.ensureConfig(root, {
+						force,
 						tsconfigJson: true,
 						packageJson: flags,
 						biomeJson: true,
 						editorconfig: true,
-						indexHtml: !!flags.web && !isExpo,
+						indexHtml: !!flags.react && !isExpo,
 						claudeMd: flags.agent ? {
-							react: !!flags.web,
-							ui: !!flags.admin
+							react: !!flags.react,
+							ui: !!flags.ui
 						} : false
 					});
-					if (!flags.web) await this.scaffolder.ensureApiProject(root);
+					if (!flags.react) await this.scaffolder.ensureApiProject(root, { force });
 				}
 			});
 			const pmName = await this.pm.getPackageManager(root, flags);
@@ -2009,7 +2443,7 @@ var LintCommand = class {
 		handler: async ({ root }) => {
 			await this.scaffolder.ensureConfig(root, { biomeJson: true });
 			await this.pm.ensureDependency(root, "@biomejs/biome", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
-			await this.utils.exec("biome check --formatter-enabled=false --fix");
+			await this.utils.exec("biome check --fix");
 		}
 	});
 };
@@ -2162,7 +2596,6 @@ const AlephaCli = $module({
 		DbCommand,
 		DeployCommand,
 		DevCommand,
-		FormatCommand,
 		InitCommand,
 		LintCommand,
 		RootCommand,
@@ -2170,6 +2603,7 @@ const AlephaCli = $module({
 		TypecheckCommand,
 		VerifyCommand,
 		GenCommand,
+		AppEntryProvider,
 		GitProvider
 	]
 });
@@ -2232,6 +2666,7 @@ var AlephaPackageBuilderCli = class {
 					sourcemap: true,
 					fixedExtension: false,
 					platform: "node",
+					inlineOnly: false,
 					external,
 					dts: { sourcemap: true }
 				});
@@ -2241,6 +2676,7 @@ var AlephaPackageBuilderCli = class {
 					platform: "neutral",
 					sourcemap: true,
 					dts: false,
+					inlineOnly: false,
 					external
 				});
 				if (item.browser) entries.push({
@@ -2249,6 +2685,7 @@ var AlephaPackageBuilderCli = class {
 					platform: "browser",
 					sourcemap: true,
 					dts: false,
+					inlineOnly: false,
 					external
 				});
 				if (item.bun) entries.push({
@@ -2258,6 +2695,7 @@ var AlephaPackageBuilderCli = class {
 					sourcemap: true,
 					fixedExtension: false,
 					dts: false,
+					inlineOnly: false,
 					external
 				});
 				const config = this.fs.join(tmpDir, `tsdown-${item.name.replace("/", "-")}.config.js`);
@@ -2281,6 +2719,7 @@ var AlephaPackageBuilderCli = class {
 		}
 	});
 };
+var AlephaPackageBuilderCli_default = AlephaPackageBuilderCli;
 async function getAllFiles(dir) {
 	const files = [];
 	async function scan(currentDir) {
@@ -2384,6 +2823,7 @@ const defineConfig = (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);
+		if (config.entry) alepha.set(appEntryOptions, config.entry);
 		return { ...config.commands };
 	};
 };
@@ -2393,5 +2833,5 @@ const defineConfig = (runConfig) => {
 const defineAlephaConfig = defineConfig;
 
 //#endregion
-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 };
+export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli_default as AlephaPackageBuilderCli, AppEntryProvider, BuildCommand, ChangelogCommand, CleanCommand, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
 //# sourceMappingURL=index.js.map