alepha 0.14.3 → 0.15.0

package/dist/cli/index.js

@@ -1,28 +1,456 @@
-import { createRequire } from "node:module";
-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, ConsoleColorProvider } from "alepha/logger";
-import { boot, buildClient, buildServer, copyAssets, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
+import { boot, buildClient, buildServer, copyAssets, devServer, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
 import { exec, spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { ServerSwaggerProvider } from "alepha/server/swagger";
+import { access, readFile, readdir } from "node:fs/promises";
 import * as os from "node:os";
 
-//#region ../../src/cli/assets/appRouterTs.ts
-const appRouterTs = () => `
-import { $page } from "@alepha/react/router";
+//#region ../../src/core/constants/KIND.ts
+/**
+* Used for identifying primitives.
+*
+* @internal
+*/
+const KIND = Symbol.for("Alepha.Kind");
 
-export class AppRouter {
-  home = $page({
-    component: () => "Hello World",
+//#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/services/AlephaCliUtils.ts
+/**
+* Core utility service for CLI commands.
+*
+* Provides:
+* - Command execution
+* - File editing helpers
+* - Drizzle/ORM utilities
+* - Environment loading
+*/
+var AlephaCliUtils = class {
+	log = $logger();
+	fs = $inject(FileSystemProvider);
+	envUtils = $inject(EnvUtils);
+	/**
+	* 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, {
+				stdio: "inherit",
+				cwd: root,
+				env: {
+					...process.env,
+					...options.env
+				}
+			});
+			await new Promise((resolve) => prog.on("exit", () => {
+				resolve();
+			}));
+		};
+		if (options.global) {
+			const [app$1, ...args$1] = command.split(" ");
+			await runExec(app$1, args$1);
+			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) throw new AlephaError(`Could not find executable for command '${app}'. Make sure the package is installed.`);
+		await runExec(execPath, args);
+	}
+	/**
+	* Write a configuration file to node_modules/.alepha directory.
+	*/
+	async writeConfigFile(name, content, root = process.cwd()) {
+		const dir = this.fs.join(root, "node_modules", ".alepha");
+		await this.fs.mkdir(dir, { recursive: true }).catch(() => null);
+		const path = this.fs.join(dir, name);
+		await this.fs.writeFile(path, content);
+		this.log.debug(`Config file written: ${path}`);
+		return path;
+	}
+	/**
+	* Load Alepha instance from a server entry file.
+	*/
+	async loadAlephaFromServerEntryFile(rootDir, explicitEntry) {
+		process.env.ALEPHA_CLI_IMPORT = "true";
+		const entry = await boot.getServerEntry(rootDir, explicitEntry);
+		delete global.__alepha;
+		const mod = await import(entry);
+		this.log.debug(`Load entry: ${entry}`);
+		if (mod.default instanceof Alepha) return {
+			alepha: mod.default,
+			entry
+		};
+		const g = global;
+		if (g.__alepha) return {
+			alepha: g.__alepha,
+			entry
+		};
+		throw new AlephaError(`Could not find Alepha instance in entry file: ${entry}`);
+	}
+	/**
+	* Generate JavaScript code for Drizzle entities export.
+	*/
+	generateEntitiesJs(entry, provider, models = []) {
+		return `
+import "${entry}";
+import { DrizzleKitProvider, Repository } from "alepha/orm";
+
+const alepha = globalThis.__alepha;
+const kit = alepha.inject(DrizzleKitProvider);
+const provider = alepha.services(Repository).find((it) => it.provider.name === "${provider}").provider;
+const models = kit.getModels(provider);
+
+${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
+
+`.trim();
+	}
+	/**
+	* Load environment variables from a .env file.
+	*/
+	async loadEnv(root, files = [".env"]) {
+		await this.envUtils.loadEnv(root, files);
+	}
+	async exists(root, path) {
+		return this.fs.exists(this.fs.join(root, path));
+	}
+	async checkFileExists(root, name) {
+		const configPath = this.fs.join(root, name);
+		if (await this.fs.exists(configPath)) return configPath;
+	}
+};
+
+//#endregion
+//#region ../../src/cli/version.ts
+const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+const version = packageJson.version;
+
+//#endregion
+//#region ../../src/cli/services/PackageManagerUtils.ts
+/**
+* Utility service for package manager operations.
+*
+* Handles detection, installation, and cleanup for:
+* - Yarn
+* - npm
+* - pnpm
+* - Bun
+*/
+var PackageManagerUtils = class {
+	log = $logger();
+	fs = $inject(FileSystemProvider);
+	alepha = $inject(Alepha);
+	/**
+	* Detect the package manager used in the project.
+	*/
+	async getPackageManager(root, flags) {
+		if (flags?.yarn) return "yarn";
+		if (flags?.pnpm) return "pnpm";
+		if (flags?.npm) return "npm";
+		if (flags?.bun) return "bun";
+		if (this.alepha.isBun()) return "bun";
+		if (await this.fs.exists(this.fs.join(root, "bun.lock"))) return "bun";
+		if (await this.fs.exists(this.fs.join(root, "yarn.lock"))) return "yarn";
+		if (await this.fs.exists(this.fs.join(root, "pnpm-lock.yaml"))) return "pnpm";
+		return "npm";
+	}
+	/**
+	* Get the install command for a package.
+	*/
+	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();
+	}
+	/**
+	* Check if a dependency is installed in the project.
+	*/
+	async hasDependency(root, packageName) {
+		try {
+			const pkg = await this.readPackageJson(root);
+			return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName]);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Check if Expo is present in the project.
+	*/
+	async hasExpo(root) {
+		return this.hasDependency(root, "expo");
+	}
+	/**
+	* Install a dependency if it's missing from the project.
+	*/
+	async ensureDependency(root, packageName, options = {}) {
+		const { dev = true } = options;
+		if (await this.hasDependency(root, packageName)) {
+			this.log.debug(`Dependency '${packageName}' is already installed`);
+			return;
+		}
+		const cmd = await this.getInstallCommand(root, packageName, dev);
+		if (options.run) await options.run(cmd, {
+			alias: `installing ${packageName}`,
+			root
+		});
+		else if (options.exec) {
+			this.log.debug(`Installing ${packageName}`);
+			await options.exec(cmd, {
+				global: true,
+				root
+			});
+		}
+	}
+	async ensureYarn(root) {
+		const yarnrcPath = this.fs.join(root, ".yarnrc.yml");
+		if (!await this.fs.exists(yarnrcPath)) await this.fs.writeFile(yarnrcPath, "nodeLinker: node-modules");
+		await this.removeAllPmFilesExcept(root, "yarn");
+	}
+	async ensureBun(root) {
+		await this.removeAllPmFilesExcept(root, "bun");
+	}
+	async ensurePnpm(root) {
+		await this.removeAllPmFilesExcept(root, "pnpm");
+	}
+	async ensureNpm(root) {
+		await this.removeAllPmFilesExcept(root, "npm");
+	}
+	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);
+	}
+	async removeYarn(root) {
+		await this.removeFiles(root, [
+			".yarn",
+			".yarnrc.yml",
+			"yarn.lock"
+		]);
+		await this.editPackageJson(root, (pkg) => {
+			delete pkg.packageManager;
+			return pkg;
+		});
+	}
+	async removePnpm(root) {
+		await this.removeFiles(root, ["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
+		await this.editPackageJson(root, (pkg) => {
+			delete pkg.packageManager;
+			return pkg;
+		});
+	}
+	async removeNpm(root) {
+		await this.removeFiles(root, ["package-lock.json"]);
+	}
+	async removeBun(root) {
+		await this.removeFiles(root, ["bun.lockb", "bun.lock"]);
+	}
+	async readPackageJson(root) {
+		const content = await this.fs.createFile({ path: this.fs.join(root, "package.json") }).text();
+		return JSON.parse(content);
+	}
+	async writePackageJson(root, content) {
+		await this.fs.writeFile(this.fs.join(root, "package.json"), JSON.stringify(content, null, 2));
+	}
+	async editPackageJson(root, editFn) {
+		try {
+			const updated = editFn(await this.readPackageJson(root));
+			await this.writePackageJson(root, updated);
+		} catch {}
+	}
+	async ensurePackageJson(root, modes) {
+		const packageJsonPath = this.fs.join(root, "package.json");
+		if (!await this.fs.exists(packageJsonPath)) {
+			const content = this.generatePackageJsonContent(modes);
+			await this.writePackageJson(root, content);
+			return content;
+		}
+		const packageJson$1 = 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;
+	}
+	generatePackageJsonContent(modes) {
+		const dependencies = { alepha: `^${version}` };
+		const devDependencies = {};
+		const scripts = {
+			dev: "alepha dev",
+			build: "alepha build",
+			lint: "alepha lint",
+			typecheck: "alepha typecheck",
+			verify: "alepha verify"
+		};
+		if (modes.admin) {
+			dependencies["@alepha/ui"] = `^${version}`;
+			modes.web = true;
+		}
+		if (modes.web) {
+			dependencies["@alepha/react"] = `^${version}`;
+			dependencies.react = "^19.2.0";
+			dependencies["react-dom"] = "^19.2.0";
+			devDependencies["@types/react"] = "^19.2.0";
+		}
+		return {
+			type: "module",
+			dependencies,
+			devDependencies,
+			scripts
+		};
+	}
+	async removeFiles(root, files) {
+		await Promise.all(files.map((file) => this.fs.rm(this.fs.join(root, file), {
+			force: true,
+			recursive: true
+		})));
+	}
+};
+
+//#endregion
+//#region ../../src/cli/assets/apiHelloControllerTs.ts
+const apiHelloControllerTs = () => `
+import { t } from "alepha";
+import { $action } from "alepha/server";
+
+export class HelloController {
+  hello = $action({
+    path: "/hello",
+    schema: {
+      response: t.object({
+        message: t.string(),
+      }),
+    },
+    handler: () => ({
+      message: "Hello, Alepha!",
+    }),
   });
 }
 `.trim();
 
+//#endregion
+//#region ../../src/cli/assets/apiIndexTs.ts
+const apiIndexTs = (options = {}) => {
+	const { appName = "app" } = options;
+	return `
+import { $module } from "alepha";
+import { HelloController } from "./controllers/HelloController.ts";
+
+export const ApiModule = $module({
+  name: "${appName}.api",
+  services: [HelloController],
+});
+`.trim();
+};
+
 //#endregion
 //#region ../../src/cli/assets/biomeJson.ts
 const biomeJson = `
@@ -59,6 +487,299 @@ const biomeJson = `
 }
 `.trim();
 
+//#endregion
+//#region ../../src/cli/assets/claudeMd.ts
+const claudeMd = (options = {}) => {
+	const { react = false, projectName = "my-app" } = options;
+	const reactSection = react ? `
+## React & Frontend
+
+### Pages with \`$page\`
+\`\`\`tsx
+import { $page } from "@alepha/react/router";
+import { $client } from "alepha/server/links";
+import type { UserController } from "./UserController.ts";
+
+class AppRouter {
+  api = $client<UserController>();
+
+  users = $page({
+    path: "/users",
+    loader: async () => ({ users: await this.api.listUsers() }),
+    component: ({ users }) => (
+      <ul>{users.map(u => <li key={u.id}>{u.email}</li>)}</ul>
+    ),
+  });
+
+  userDetail = $page({
+    path: "/users/:id",
+    schema: { params: t.object({ id: t.uuid() }) },
+    loader: async ({ params }) => ({ user: await this.api.getUser({ params }) }),
+    lazy: () => import("./UserDetail.tsx"), // Code splitting
+  });
+}
+\`\`\`
+
+### React Hooks
+\`\`\`typescript
+import { useAlepha, useClient, useStore, useAction, useInject } from "@alepha/react";
+import { useRouter, useActive } from "@alepha/react/router";
+import { useForm } from "@alepha/react/form";
+\`\`\`
+
+- \`useClient<Controller>()\` - Type-safe API calls
+- \`useStore(atom)\` - Global state (returns \`[value, setValue]\`)
+- \`useAction({ handler })\` - Async operations with loading/error state
+- \`useRouter<AppRouter>()\` - Type-safe navigation
+- \`useForm({ schema, handler })\` - Type-safe forms with validation
+` : "";
+	const projectStructure = react ? `
+\`\`\`
+${projectName}/
+├── src/
+│   ├── api/              # Backend
+│   │   ├── controllers/  # API controllers with $action
+│   │   ├── services/     # Business logic
+│   │   ├── entities/     # Database entities with $entity
+│   │   ├── providers/    # External service wrappers
+│   │   └── index.ts      # API module definition with $module
+│   ├── web/              # Frontend (React only)
+│   │   ├── components/   # React components
+│   │   ├── atoms/        # State atoms with $atom
+│   │   ├── 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)
+├── package.json
+└── tsconfig.json
+\`\`\`
+` : `
+\`\`\`
+${projectName}/
+├── src/
+│   ├── api/              # Backend
+│   │   ├── controllers/  # API controllers with $action
+│   │   ├── services/     # Business logic
+│   │   ├── entities/     # Database entities with $entity
+│   │   ├── providers/    # External service wrappers
+│   │   └── index.ts      # API module definition with $module
+│   └── main.server.ts    # Server entry (always use main.server.ts)
+├── package.json
+└── tsconfig.json
+\`\`\`
+`;
+	return `# CLAUDE.md
+
+This file provides guidance to Claude Code when working with this Alepha project.
+
+## Overview
+
+This is an **Alepha** project - a convention-driven TypeScript framework for type-safe full-stack applications.
+
+**Key Concepts:**
+- **Primitives**: Features defined with \`$\`-prefixed functions (\`$action\`, \`$entity\`, \`$page\`)
+- **Class-Based**: Services are classes, primitives are class properties
+- **Zero-Config**: Code structure IS the configuration
+- **End-to-End Types**: Types flow from database → API → ${react ? "React" : "client"}
+
+## Rules
+
+- Use TypeScript strict mode
+- Use Biome for formatting (\`alepha lint\`)
+- Use Vitest for testing
+- One file = one class
+- Primitives are class properties (except \`$entity\`, \`$atom\`)
+- No decorators, no Express/Fastify patterns
+- No manual instantiation - use dependency injection
+- 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)
+
+## Project Structure
+${projectStructure}
+## Core Primitives
+
+### API with \`$action\`
+\`\`\`typescript
+import { t } from "alepha";
+import { $action } from "alepha/server";
+
+class UserController {
+  getUser = $action({
+    path: "/users/:id",  // → GET /api/users/:id
+    schema: {
+      params: t.object({ id: t.uuid() }),
+      response: t.object({ id: t.uuid(), email: t.email() }),
+    },
+    handler: async ({ params }) => this.userRepo.findById(params.id),
+  });
+
+  createUser = $action({
+    // POST inferred from body schema
+    schema: {
+      body: t.object({ email: t.email() }),
+      response: userEntity.schema,
+    },
+    handler: async ({ body }) => this.userRepo.create(body),
+  });
+}
+\`\`\`
+
+### Database with \`$entity\` and \`$repository\`
+\`\`\`typescript
+import { $entity, $repository, db } from "alepha/orm";
+
+// Entity defined at module level (for drizzle-kit compatibility)
+export const userEntity = $entity({
+  name: "users",
+  schema: t.object({
+    id: db.primaryKey(),
+    email: t.email(),
+    createdAt: db.createdAt(),
+    updatedAt: db.updatedAt(),
+  }),
+  indexes: [{ column: "email", unique: true }],
+});
+
+class UserService {
+  repo = $repository(userEntity);
+
+  async findById(id: string) {
+    return this.repo.findById(id);
+  }
+}
+\`\`\`
+
+### Dependency Injection
+\`\`\`typescript
+import { $inject } from "alepha";
+
+class OrderService {
+  userService = $inject(UserService);  // Within same module
+
+  async createOrder(userId: string) {
+    const user = await this.userService.findById(userId);
+    // ...
+  }
+}
+
+// Cross-module: use $client instead of $inject
+class AppRouter {
+  api = $client<OrderController>();  // Type-safe HTTP client
+}
+\`\`\`
+
+### Modules with \`$module\`
+\`\`\`typescript
+// src/api/index.ts - Groups all API services
+import { $module } from "alepha";
+
+export const ApiModule = $module({
+  name: "app.api",
+  services: [
+    UserController,
+    OrderController,
+    UserService,
+  ],
+});
+
+// src/web/index.ts - Groups all web services (React only)
+export const WebModule = $module({
+  name: "app.web",
+  services: [AppRouter, Toaster],
+  register(alepha) {
+    // Optional: configure additional services
+    alepha.with(SomeLibrary);
+  },
+});
+\`\`\`
+
+### Environment Variables
+\`\`\`typescript
+import { $env, t } from "alepha";
+
+class AppConfig {
+  env = $env(t.object({
+    DATABASE_URL: t.string(),
+    API_KEY: t.optional(t.string()),
+  }));
+}
+\`\`\`
+${reactSection}
+## Quick Reference
+
+| Primitive | Import | Purpose |
+|-----------|--------|---------|
+| \`$inject\` | \`alepha\` | Dependency injection |
+| \`$env\` | \`alepha\` | Environment variables |
+| \`$hook\` | \`alepha\` | Lifecycle hooks |
+| \`$logger\` | \`alepha/logger\` | Structured logging |
+| \`$action\` | \`alepha/server\` | REST API endpoints |
+| \`$route\` | \`alepha/server\` | Low-level HTTP routes |
+| \`$entity\` | \`alepha/orm\` | Database tables |
+| \`$repository\` | \`alepha/orm\` | Type-safe data access |
+| \`$queue\` | \`alepha/queue\` | Background jobs |
+| \`$scheduler\` | \`alepha/scheduler\` | Cron tasks |
+| \`$cache\` | \`alepha/cache\` | Cached computations |
+| \`$bucket\` | \`alepha/bucket\` | File storage |
+| \`$issuer\` | \`alepha/security\` | JWT tokens |
+| \`$command\` | \`alepha/command\` | CLI commands |${react ? `
+| \`$page\` | \`@alepha/react/router\` | React pages with SSR |
+| \`$atom\` | \`alepha\` | Global state |` : ""}
+
+## Testing
+
+\`\`\`typescript
+import { describe, it, expect } from "vitest";
+import { Alepha } from "alepha";
+
+describe("UserService", () => {
+  it("should create user", async () => {
+    const alepha = Alepha.create().with(UserService);
+    const service = alepha.inject(UserService);
+
+    const user = await service.create({ email: "test@example.com" });
+    expect(user.email).toBe("test@example.com");
+  });
+
+  it("should mock dependencies", async () => {
+    const alepha = Alepha.create()
+      .with(OrderService)
+      .with({ provide: PaymentGateway, use: MockPaymentGateway });
+
+    const service = alepha.inject(OrderService);
+    // PaymentGateway is now mocked
+  });
+});
+\`\`\`
+
+## Common Mistakes
+
+1. **DON'T use decorators** - Use primitives (\`$action\`, not \`@Get()\`)
+2. **DON'T use Zod** - Use TypeBox via \`t\` from Alepha
+3. **DON'T use Express patterns** - No \`app.get()\`, \`router.use()\`
+4. **DON'T inject across modules** - Use \`$client\` for cross-module calls
+5. **DON'T use async constructors** - Use \`$hook({ on: "start" })\`
+6. **DON'T instantiate manually** - Let DI container manage instances
+
+## After Code Changes
+
+Always run:
+\`\`\`bash
+alepha lint      # Format and lint
+alepha typecheck # Type checking
+alepha test      # Run tests (if applicable)
+alepha build     # Build the project
+\`\`\`
+
+## Documentation
+
+- Full docs: https://alepha.dev/llms.txt
+- Detailed docs: https://alepha.dev/llms-full.txt
+`.trim();
+};
+
 //#endregion
 //#region ../../src/cli/assets/dummySpecTs.ts
 const dummySpecTs = () => `
@@ -105,30 +826,30 @@ const indexHtml = (browserEntry) => `
 //#region ../../src/cli/assets/mainBrowserTs.ts
 const mainBrowserTs = () => `
 import { Alepha, run } from "alepha";
-import { AppRouter } from "./AppRouter.ts";
+import { WebModule } from "./web/index.ts";
 
 const alepha = Alepha.create();
 
-alepha.with(AppRouter);
+alepha.with(WebModule);
 
 run(alepha);
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/mainTs.ts
-const mainTs = () => `
-import { run } from "alepha";
-import { $route } from "alepha/server";
-
-class App {
-  root = $route({
-    path: "/",
-    handler: () => "Hello, Alepha!",
-  });
-}
+//#region ../../src/cli/assets/mainServerTs.ts
+const mainServerTs = (options = {}) => {
+	const { react = false } = options;
+	return `
+import { Alepha, run } from "alepha";
+import { ApiModule } from "./api/index.ts";
+${react ? `import { WebModule } from "./web/index.ts";\n` : ""}
+const alepha = Alepha.create();
 
-run(App);
+alepha.with(ApiModule);
+${react ? `alepha.with(WebModule);\n` : ""}
+run(alepha);
 `.trim();
+};
 
 //#endregion
 //#region ../../src/cli/assets/tsconfigJson.ts
@@ -139,407 +860,158 @@ const tsconfigJson = `
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/viteConfigTs.ts
-const viteConfigTs = (serverEntry) => `
-import { viteAlepha } from "alepha/vite";
+//#region ../../src/cli/assets/webAppRouterTs.ts
+const webAppRouterTs = () => `
+import { $page } from "@alepha/react/router";
+import { $client } from "alepha/server/links";
+import type { HelloController } from "../api/controllers/HelloController.ts";
 
-export default {
-  plugins: [
-    viteAlepha(${serverEntry ? `{ serverEntry: "${serverEntry}" }` : ""}),
-  ],
-  test: {
-    globals: true,
-  },
+export class AppRouter {
+  api = $client<HelloController>();
+
+  home = $page({
+    path: "/",
+    lazy: () => import("./components/Hello.tsx"),
+    loader: () => this.api.hello(),
+  });
+}
+`.trim();
+
+//#endregion
+//#region ../../src/cli/assets/webHelloComponentTsx.ts
+const webHelloComponentTsx = () => `
+interface Props {
+  message: string;
+}
+
+const Hello = (props: Props) => {
+  return (
+    <div>
+      <h1>{props.message}</h1>
+      <p>Edit this component in src/web/components/Hello.tsx</p>
+    </div>
+  );
 };
+
+export default Hello;
 `.trim();
 
 //#endregion
-//#region ../../src/cli/version.ts
-const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
-const version = packageJson.version;
+//#region ../../src/cli/assets/webIndexTs.ts
+const webIndexTs = (options = {}) => {
+	const { appName = "app" } = options;
+	return `
+import { $module } from "alepha";
+import { AppRouter } from "./AppRouter.ts";
+
+export const WebModule = $module({
+  name: "${appName}.web",
+  services: [AppRouter],
+});
+`.trim();
+};
 
 //#endregion
-//#region ../../src/cli/services/AlephaCliUtils.ts
-/**
-* Utility service for common project operations used by CLI commands.
-*
-* This service provides helper methods for:
-* - Project configuration file management (tsconfig.json, package.json, etc.)
-* - Package manager setup (Yarn, npm, pnpm)
-* - Sample project downloading
-* - Drizzle ORM/Kit utilities
-* - Alepha instance loading
-*/
-var AlephaCliUtils = class {
-	log = $logger();
-	fs = $inject(FileSystemProvider);
-	envUtils = $inject(EnvUtils);
-	alepha = $inject(Alepha);
-	/**
-	* Execute a command using npx with inherited stdio.
-	*
-	* @example
-	* ```ts
-	* const runner = alepha.inject(ProcessRunner);
-	* await runner.exec("tsx watch src/index.ts");
-	* ```
-	*/
-	async exec(command, options = {}) {
-		const 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, {
-				stdio: "inherit",
-				cwd: root,
-				env: {
-					...process.env,
-					...options.env
-				}
-			});
-			await new Promise((resolve) => prog.on("exit", () => {
-				resolve();
-			}));
-		};
-		if (options.global) {
-			const [app$1, ...args$1] = command.split(" ");
-			await runExec(app$1, args$1);
-			return;
-		}
-		const suffix = process.platform === "win32" ? ".cmd" : "";
-		const [app, ...args] = command.split(" ");
-		let execPath = await this.checkFileExists(root, `node_modules/.bin/${app}${suffix}`, true);
-		if (!execPath) execPath = await this.checkFileExists(root, `node_modules/alepha/node_modules/.bin/${app}${suffix}`, true);
-		if (!execPath) throw new AlephaError(`Could not find executable for command '${app}'. Make sure the package is installed.`);
-		await runExec(execPath, args);
-	}
-	/**
-	* Write a configuration file to node_modules/.alepha directory.
-	*
-	* Creates the .alepha directory if it doesn't exist and writes the file with the given content.
-	*
-	* @param name - The name of the config file to create
-	* @param content - The content to write to the file
-	* @param root - The root directory (defaults to process.cwd())
-	* @returns The absolute path to the created file
-	*
-	* @example
-	* ```ts
-	* const runner = alepha.inject(ProcessRunner);
-	* const configPath = await runner.writeConfigFile("biome.json", biomeConfig);
-	* ```
-	*/
-	async writeConfigFile(name, content, root = process.cwd()) {
-		const dir = join(root, "node_modules", ".alepha");
-		await mkdir(dir, { recursive: true }).catch(() => null);
-		const path = join(dir, name);
-		await writeFile(path, content);
-		this.log.debug(`Config file written: ${path}`);
-		return path;
-	}
-	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"
-		]);
-	}
-	async removePnpm(root) {
-		await this.removeFiles(root, ["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
-	}
-	async removeNpm(root) {
-		await this.removeFiles(root, ["package-lock.json"]);
-	}
-	async removeBun(root) {
-		await this.removeFiles(root, ["bun.lockb"]);
-	}
-	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.
-	*
-	* Creates a .yarnrc.yml file with node-modules linker if it doesn't exist.
-	*
-	* @param root - The root directory of the project
-	*/
-	async ensureYarn(root) {
-		await this.ensureFileExists(root, ".yarnrc.yml", "nodeLinker: node-modules", false);
-		await this.removeAllPmFilesExcept(root, "yarn");
-	}
-	async ensureBun(root) {
-		await this.removeAllPmFilesExcept(root, "bun");
-	}
-	async ensurePnpm(root) {
-		await this.removeAllPmFilesExcept(root, "pnpm");
-	}
-	async ensureNpm(root) {
-		await this.removeAllPmFilesExcept(root, "npm");
-	}
+//#region ../../src/cli/services/ProjectScaffolder.ts
+/**
+* Service for scaffolding new Alepha projects.
+*
+* Handles creation of:
+* - Project structure (src/api, src/web)
+* - Configuration files (tsconfig, biome, editorconfig)
+* - Entry points (main.server.ts, main.browser.ts)
+* - Example code (HelloController, Hello component)
+*/
+var ProjectScaffolder = class {
+	log = $logger();
+	fs = $inject(FileSystemProvider);
+	pm = $inject(PackageManagerUtils);
 	/**
-	* Generate package.json content with Alepha dependencies.
+	* Get the app name from the directory name.
 	*
-	* @param modes - Configuration for which dependencies to include
-	* @returns Package.json partial with dependencies, devDependencies, and scripts
+	* Converts the directory name to a valid module name:
+	* - Converts to lowercase
+	* - Replaces spaces, dashes, underscores with nothing
+	* - Falls back to "app" if empty
 	*/
-	generatePackageJsonContent(modes) {
-		const dependencies = { alepha: `^${version}` };
-		const devDependencies = {};
-		const scripts = {
-			dev: "alepha dev",
-			build: "alepha build",
-			lint: "alepha lint",
-			typecheck: "alepha typecheck",
-			verify: "alepha verify"
-		};
-		if (modes.ui) {
-			dependencies["@alepha/ui"] = `^${version}`;
-			modes.react = true;
-		}
-		if (modes.react) {
-			dependencies["@alepha/react"] = `^${version}`;
-			dependencies.react = "^19.2.0";
-			dependencies["react-dom"] = "^19.2.0";
-			devDependencies["@types/react"] = "^19.2.0";
-		}
-		return {
-			type: "module",
-			dependencies,
-			devDependencies,
-			scripts
-		};
+	getAppName(root) {
+		return basename(root).toLowerCase().replace(/[\s\-_]/g, "") || "app";
 	}
 	/**
-	* Ensure package.json exists and has correct configuration.
-	*
-	* Creates a new package.json if none exists, or updates an existing one to:
-	* - Set "type": "module"
-	* - Add Alepha dependencies
-	* - Add standard scripts
-	*
-	* @param root - The root directory of the project
-	* @param modes - Configuration for which dependencies to include
+	* Ensure all configuration files exist.
 	*/
-	async ensurePackageJson(root, modes) {
-		const packageJsonPath = join(root, "package.json");
-		try {
-			await access(packageJsonPath);
-		} catch (error) {
-			const obj = this.generatePackageJsonContent(modes);
-			await writeFile(packageJsonPath, JSON.stringify(obj, null, 2));
-			return obj;
-		}
-		const content = await readFile(packageJsonPath, "utf8");
-		const packageJson$1 = JSON.parse(content);
-		const newPackageJson = this.generatePackageJsonContent(modes);
-		packageJson$1.type = "module";
-		packageJson$1.dependencies ??= {};
-		packageJson$1.devDependencies ??= {};
-		packageJson$1.scripts ??= {};
-		Object.assign(packageJson$1.dependencies, newPackageJson.dependencies);
-		Object.assign(packageJson$1.devDependencies, newPackageJson.devDependencies);
-		Object.assign(packageJson$1.scripts, newPackageJson.scripts);
-		await writeFile(packageJsonPath, JSON.stringify(packageJson$1, null, 2));
-		return packageJson$1;
-	}
 	async ensureConfig(root, opts) {
 		const tasks = [];
-		if (opts.packageJson) tasks.push(this.ensurePackageJson(root, typeof opts.packageJson === "boolean" ? {} : opts.packageJson));
+		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.viteConfigTs) tasks.push(this.ensureViteConfig(root));
-		if (opts.indexHtml) tasks.push(this.ensureIndexHtml(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));
-		return await Promise.all(tasks);
+		if (opts.claudeMd) tasks.push(this.ensureClaudeMd(root, typeof opts.claudeMd === "boolean" ? {} : opts.claudeMd));
+		await Promise.all(tasks);
 	}
-	/**
-	* Ensure tsconfig.json exists in the project.
-	*
-	* Creates a standard Alepha tsconfig.json if none exists.
-	*
-	* @param root - The root directory of the project
-	*/
 	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 {
-			await access(configPath);
-			return configPath;
-		} catch {
-			return;
-		}
-		let currentDir = root;
-		const maxIterations = 10;
-		let level = 0;
-		while (level < maxIterations) {
-			try {
-				const maybe = join(currentDir, name);
-				await access(maybe);
-				return maybe;
-			} catch {
-				const parentDir = join(currentDir, "..");
-				if (parentDir === currentDir) break;
-				currentDir = parentDir;
-			}
-			level += 1;
-		}
+		if (await this.existsInParents(root, "tsconfig.json")) return;
+		await this.fs.writeFile(this.fs.join(root, "tsconfig.json"), tsconfigJson);
 	}
-	async ensureFileExists(root, name, content, checkParentDirectories = false) {
-		if (!await this.checkFileExists(root, name, checkParentDirectories)) await writeFile(join(root, name), content);
-	}
-	/**
-	* Get the path to Biome configuration file.
-	*
-	* Looks for an existing biome.json in the project root, or creates one if it doesn't exist.
-	*/
 	async ensureBiomeConfig(root) {
-		await this.ensureFileExists(root, "biome.json", biomeJson, true);
+		await this.ensureFileIfNotExists(root, "biome.json", biomeJson);
 	}
-	/**
-	* Ensure .editorconfig exists in the project.
-	*
-	* Creates a standard .editorconfig if none exists.
-	*
-	* @param root - The root directory of the project
-	*/
 	async ensureEditorConfig(root) {
-		await this.ensureFileExists(root, ".editorconfig", editorconfig, true);
-	}
-	/**
-	* Load Alepha instance from a server entry file.
-	*
-	* Dynamically imports the server entry file and extracts the Alepha instance.
-	* Skips the automatic start process.
-	*
-	* @param rootDir - The root directory of the project
-	* @param explicitEntry - Optional explicit path to the entry file
-	* @returns Object containing the Alepha instance and the entry file path
-	* @throws {AlephaError} If the Alepha instance cannot be found
-	*/
-	async loadAlephaFromServerEntryFile(rootDir, explicitEntry) {
-		process.env.ALEPHA_CLI_IMPORT = "true";
-		const entry = await boot.getServerEntry(rootDir, explicitEntry);
-		delete global.__alepha;
-		const mod = await import(entry);
-		this.log.debug(`Load entry: ${entry}`);
-		if (mod.default instanceof Alepha) return {
-			alepha: mod.default,
-			entry
-		};
-		const g = global;
-		if (g.__alepha) return {
-			alepha: g.__alepha,
-			entry
-		};
-		throw new AlephaError(`Could not find Alepha instance in entry file: ${entry}`);
+		await this.ensureFileIfNotExists(root, ".editorconfig", editorconfig);
 	}
-	/**
-	* Generate JavaScript code for Drizzle entities export.
-	*
-	* Creates a temporary entities.js file that imports from the entry file
-	* and exports database models for Drizzle Kit to process.
-	*
-	* @param entry - Path to the server entry file
-	* @param provider - Name of the database provider
-	* @param models - Array of model names to export
-	* @returns JavaScript code as a string
-	*/
-	generateEntitiesJs(entry, provider, models = []) {
-		return `
-import "${entry}";
-import { DrizzleKitProvider, Repository } from "alepha/orm";
-
-const alepha = globalThis.__alepha;
-const kit = alepha.inject(DrizzleKitProvider);
-const provider = alepha.services(Repository).find((it) => it.provider.name === "${provider}").provider;
-const models = kit.getModels(provider);
-
-${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
-
-`.trim();
+	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));
 	}
 	/**
-	* Load environment variables from a .env file.
+	* Ensure src/main.server.ts exists with full API structure.
 	*
-	* Reads the .env file in the specified root directory and sets
-	* the environment variables in process.env.
+	* Creates:
+	* - src/main.server.ts (entry point)
+	* - src/api/index.ts (API module)
+	* - src/api/controllers/HelloController.ts (example controller)
 	*/
-	async loadEnv(root, files = [".env"]) {
-		await this.envUtils.loadEnv(root, files);
-	}
-	async getPackageManager(root, flags) {
-		if (flags?.yarn) return "yarn";
-		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";
-	}
-	async ensureIndexHtml(root) {
-		if (await this.fs.exists(join(root, "index.html"))) return;
-		const serverEntry = "src/main.server.ts";
-		const browserEntry = "src/main.browser.ts";
-		const appRouter = "src/AppRouter.ts";
-		await this.fs.writeFile(join(root, "index.html"), indexHtml(browserEntry));
-		try {
-			await this.fs.mkdir(join(root, "src"), { recursive: true });
-		} catch {}
-		if (!await this.fs.exists(join(root, browserEntry))) await this.fs.writeFile(join(root, browserEntry), mainBrowserTs());
-		if (!await this.fs.exists(join(root, serverEntry))) await this.fs.writeFile(join(root, serverEntry), mainBrowserTs());
-		if (!await this.fs.exists(join(root, appRouter))) await this.fs.writeFile(join(root, appRouter), appRouterTs());
-	}
-	async exists(root, dirName) {
-		return this.fs.exists(join(root, dirName));
+	async ensureApiProject(root) {
+		const srcDir = this.fs.join(root, "src");
+		if (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());
 	}
 	/**
-	* Ensure src/main.ts exists with a minimal Alepha bootstrap.
+	* Ensure full React project structure exists.
 	*
-	* Creates the src directory and main.ts file if the src directory
-	* doesn't exist or is empty.
-	*
-	* @param root - The root directory of the project
+	* 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 ensureSrcMain(root) {
-		const srcDir = join(root, "src");
-		const mainPath = join(srcDir, "main.ts");
-		if (!await this.fs.exists(srcDir)) {
-			await this.fs.mkdir(srcDir, { recursive: true });
-			await this.fs.writeFile(mainPath, mainTs());
-			return;
-		}
-		if ((await this.fs.ls(srcDir)).length === 0) await this.fs.writeFile(mainPath, mainTs());
+	async ensureReactProject(root) {
+		if (await this.fs.exists(this.fs.join(root, "index.html"))) return;
+		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());
 	}
 	/**
 	* Ensure test directory exists with a dummy test file.
-	*
-	* Creates the test directory and a dummy.spec.ts file if the test directory
-	* doesn't exist or is empty.
-	*
-	* @param root - The root directory of the project
 	*/
 	async ensureTestDir(root) {
-		const testDir = join(root, "test");
-		const dummyPath = join(testDir, "dummy.spec.ts");
+		const testDir = this.fs.join(root, "test");
+		const dummyPath = this.fs.join(testDir, "dummy.spec.ts");
 		if (!await this.fs.exists(testDir)) {
 			await this.fs.mkdir(testDir, { recursive: true });
 			await this.fs.writeFile(dummyPath, dummySpecTs());
@@ -547,68 +1019,20 @@ ${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();
-		return JSON.parse(packageJson$1);
-	}
-	/**
-	* Check if a dependency is installed in the project.
-	*
-	* @param root - The root directory of the project
-	* @param packageName - The name of the package to check
-	* @returns True if the package is in dependencies or devDependencies
-	*/
-	async hasDependency(root, packageName) {
-		try {
-			const pkg = await this.readPackageJson(root);
-			return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName]);
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Check if Expo is present in the project.
-	*
-	* @param root - The root directory of the project
-	* @returns True if expo is in dependencies or devDependencies
-	*/
-	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();
+	async ensureFileIfNotExists(root, relativePath, content) {
+		const fullPath = this.fs.join(root, relativePath);
+		if (!await this.fs.exists(fullPath)) await this.fs.writeFile(fullPath, content);
 	}
 	/**
-	* Install a dependency if it's missing from the project.
-	*
-	* Automatically detects the package manager (yarn, pnpm, npm) and installs
-	* the package as a dev dependency if not already present.
+	* Check if a file exists in the given directory or any parent directory.
 	*/
-	async ensureDependency(root, packageName, options = {}) {
-		const { dev = true } = options;
-		if (await this.hasDependency(root, packageName)) {
-			this.log.debug(`Dependency '${packageName}' is already installed`);
-			return;
-		}
-		const cmd = await this.getInstallCommand(root, packageName, dev);
-		if (options.run) await options.run(cmd, { alias: `installing ${packageName}` });
-		else {
-			this.log.debug(`Installing ${packageName}`);
-			await this.exec(cmd, { global: true });
+	async existsInParents(root, filename) {
+		let current = root;
+		while (true) {
+			if (await this.fs.exists(this.fs.join(current, filename))) return true;
+			const parent = dirname(current);
+			if (parent === current) return false;
+			current = parent;
 		}
 	}
 };
@@ -617,9 +1041,14 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 //#region ../../src/cli/commands/build.ts
 var BuildCommand = class {
 	log = $logger();
+	fs = $inject(FileSystemProvider);
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
+	scaffolder = $inject(ProjectScaffolder);
+	options = $use(buildOptions);
 	build = $command({
 		name: "build",
+		mode: "production",
 		description: "Build the project for production",
 		args: t.optional(t.text({
 			title: "path",
@@ -630,57 +1059,53 @@ var BuildCommand = class {
 			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" }))
+			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";
 			process.env.NODE_ENV = "production";
-			if (await this.utils.hasExpo(root)) return;
-			await this.utils.ensureConfig(root, {
-				viteConfigTs: true,
-				tsconfigJson: true
-			});
+			if (await this.pm.hasExpo(root)) return;
+			await this.scaffolder.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 this.pm.ensureDependency(root, "vite", {
+				run,
+				exec: (cmd, opts) => this.utils.exec(cmd, opts)
+			});
 			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;
-			let hasClient = false;
-			try {
-				await access(join(root, "index.html"));
-				hasClient = true;
-			} catch {}
-			const clientOptions = typeof viteAlephaBuildOptions.client === "object" ? viteAlephaBuildOptions.client : {};
+			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: clientOptions.precompress
+					precompress: true
 				})
 			});
 			await run({
 				name: "vite build server",
 				handler: async () => {
-					let clientBuilt = false;
-					try {
-						await readFile(`${distDir}/${clientDir}/index.html`, "utf-8");
-						clientBuilt = true;
-					} catch {}
+					const clientIndexPath = `${distDir}/${clientDir}/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,
 						distDir,
 						clientDir: clientBuilt ? clientDir : void 0,
-						stats
+						stats,
+						conditions
 					});
-					if (clientBuilt && hasServer) await unlink(`${distDir}/${clientDir}/index.html`);
+					if (clientBuilt) await this.fs.rm(clientIndexPath);
 				}
 			});
 			await copyAssets({
@@ -690,58 +1115,49 @@ 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({
+						await this.fs.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
+				})
+			});
 		}
 	});
 };
@@ -769,6 +1185,7 @@ const drizzleCommandFlags = t.object({
 });
 var DbCommand = class {
 	log = $logger();
+	fs = $inject(FileSystemProvider);
 	utils = $inject(AlephaCliUtils);
 	/**
 	* Check if database migrations are up to date.
@@ -793,15 +1210,16 @@ var DbCommand = class {
 				const providerName = provider.name;
 				if (accepted.has(providerName)) continue;
 				accepted.add(providerName);
-				const migrationDir = join(rootDir, "migrations", providerName);
-				const journalFile = await readFile(`${migrationDir}/meta/_journal.json`, "utf-8").catch(() => null);
-				if (!journalFile) {
+				const migrationDir = this.fs.join(rootDir, "migrations", providerName);
+				const journalBuffer = await this.fs.readFile(`${migrationDir}/meta/_journal.json`).catch(() => null);
+				if (!journalBuffer) {
 					this.log.info("No migration journal found.");
 					return;
 				}
-				const journal = JSON.parse(journalFile);
+				const journal = JSON.parse(journalBuffer.toString("utf-8"));
 				const lastMigration = journal.entries[journal.entries.length - 1];
-				const lastSnapshot = JSON.parse(await readFile(`${migrationDir}/meta/${String(lastMigration.idx).padStart(4, "0")}_snapshot.json`, "utf-8"));
+				const snapshotBuffer = await this.fs.readFile(`${migrationDir}/meta/${String(lastMigration.idx).padStart(4, "0")}_snapshot.json`);
+				const lastSnapshot = JSON.parse(snapshotBuffer.toString("utf-8"));
 				const models = drizzleKitProvider.getModels(provider);
 				const kit = drizzleKitProvider.importDrizzleKit();
 				const now = kit.generateDrizzleJson(models, lastSnapshot.id);
@@ -837,7 +1255,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"
@@ -862,7 +1279,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"
@@ -885,7 +1301,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"
@@ -908,7 +1323,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"
@@ -959,6 +1373,7 @@ var DbCommand = class {
 			const provider = primitive.provider;
 			const providerName = provider.name;
 			const dialect = provider.dialect;
+			if (providerName === "") continue;
 			if (accepted.has(providerName)) continue;
 			accepted.add(providerName);
 			if (options.provider && options.provider !== providerName) {
@@ -972,6 +1387,7 @@ var DbCommand = class {
 				provider,
 				providerName,
 				providerUrl: provider.url,
+				providerDriver: provider.driver,
 				dialect,
 				entry,
 				rootDir
@@ -993,9 +1409,9 @@ var DbCommand = class {
 			dbCredentials: { url: options.providerUrl }
 		};
 		if (options.provider.schema) config.schemaFilter = options.provider.schema;
-		if (options.providerName === "d1") config.driver = "d1-http";
-		if (options.providerName === "pglite") config.driver = "pglite";
-		if (options.dialect === "sqlite") if (options.providerName === "d1") {
+		if (options.providerDriver === "d1") config.driver = "d1-http";
+		if (options.providerDriver === "pglite") config.driver = "pglite";
+		if (options.dialect === "sqlite") if (options.providerDriver === "d1") {
 			const token = process.env.CLOUDFLARE_API_TOKEN;
 			if (!token) throw new AlephaError("CLOUDFLARE_API_TOKEN environment variable is not set. https://orm.drizzle.team/docs/guides/d1-http-with-drizzle-kit");
 			const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
@@ -1012,7 +1428,7 @@ var DbCommand = class {
 		} else {
 			let url = options.providerUrl;
 			url = url.replace("sqlite://", "").replace("file://", "");
-			url = join(options.rootDir, url);
+			url = this.fs.join(options.rootDir, url);
 			config.dbCredentials = { url };
 		}
 		const drizzleConfigJs = `export default ${JSON.stringify(config, null, 2)}`;
@@ -1024,7 +1440,9 @@ var DbCommand = class {
 //#region ../../src/cli/commands/deploy.ts
 var DeployCommand = class {
 	log = $logger();
+	fs = $inject(FileSystemProvider);
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
 	/**
 	* Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)
 	*
@@ -1072,7 +1490,10 @@ var DeployCommand = class {
 					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 });
+				await this.pm.ensureDependency(root, "vercel", {
+					dev: true,
+					exec: (cmd, opts) => this.utils.exec(cmd, opts)
+				});
 				const command = `vercel . --cwd=dist ${mode === "production" ? "--prod" : ""}`.trim();
 				this.log.debug(`Deploying to Vercel with command: ${command}`);
 				await this.utils.exec(command);
@@ -1083,15 +1504,21 @@ var DeployCommand = class {
 					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 });
+				await this.pm.ensureDependency(root, "wrangler", {
+					dev: true,
+					exec: (cmd, opts) => this.utils.exec(cmd, opts)
+				});
 				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");
+				await this.pm.ensureDependency(root, "surge", {
+					dev: true,
+					exec: (cmd, opts) => this.utils.exec(cmd, opts)
+				});
+				const distPath = this.fs.join(root, "dist/public");
 				this.log.debug(`Deploying to Surge from directory: ${distPath}`);
 				await this.utils.exec(`surge ${distPath}`);
 				return;
@@ -1105,7 +1532,10 @@ var DeployCommand = class {
 //#region ../../src/cli/commands/dev.ts
 var DevCommand = class {
 	log = $logger();
+	fs = $inject(FileSystemProvider);
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
+	scaffolder = $inject(ProjectScaffolder);
 	alepha = $inject(Alepha);
 	/**
 	* Will run the project in watch mode.
@@ -1121,11 +1551,8 @@ var DevCommand = class {
 			description: "Filepath to run"
 		})),
 		handler: async ({ args, root }) => {
-			const expo = await this.utils.hasExpo(root);
-			await this.utils.ensureConfig(root, {
-				viteConfigTs: !expo,
-				tsconfigJson: true
-			});
+			const expo = await this.pm.hasExpo(root);
+			await this.scaffolder.ensureConfig(root, { tsconfigJson: true });
 			if (expo) {
 				await this.utils.exec("expo start");
 				return;
@@ -1133,24 +1560,23 @@ var DevCommand = class {
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
 			if (!await this.isFullstackProject(root)) {
-				const exe = this.alepha.isBun() ? "bun" : "tsx";
+				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;
 			}
-			await this.utils.ensureDependency(root, "vite");
-			await this.utils.exec("vite");
+			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) {
-		try {
-			await access(join(root, "index.html"));
-			return true;
-		} catch {
-			return false;
-		}
+		return this.fs.exists(this.fs.join(root, "index.html"));
 	}
 };
 
@@ -1158,12 +1584,14 @@ var DevCommand = class {
 //#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.utils.ensureConfig(root, { biomeJson: true });
-			await this.utils.ensureDependency(root, "@biomejs/biome");
+			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");
 		}
 	});
@@ -1385,6 +1813,39 @@ var ChangelogCommand = class {
 	});
 };
 
+//#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 {
@@ -1420,7 +1881,7 @@ var OpenApiCommand = class {
 					this.log.error("Missing $swagger() primitive in your server configuration.");
 					return;
 				}
-				this.log.error(`OpenAPI generation failed - ${message}`, { err });
+				this.log.error(`OpenAPI generation failed - ${message}`, err);
 			}
 		}
 	});
@@ -1431,10 +1892,15 @@ var OpenApiCommand = class {
 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],
+		children: [
+			this.changelog.command,
+			this.openapi.command,
+			this.genEnv.command
+		],
 		handler: async ({ help }) => {
 			help();
 		}
@@ -1445,6 +1911,9 @@ var GenCommand = class {
 //#region ../../src/cli/commands/init.ts
 var InitCommand = class {
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
+	scaffolder = $inject(ProjectScaffolder);
+	fs = $inject(FileSystemProvider);
 	/**
 	* Ensure the project has the necessary Alepha configuration files.
 	* Add the correct dependencies to package.json and install them.
@@ -1452,46 +1921,78 @@ var InitCommand = class {
 	init = $command({
 		name: "init",
 		description: "Add missing Alepha configuration files to the project",
+		args: t.optional(t.text({
+			title: "path",
+			trim: true,
+			lowercase: true
+		})),
 		flags: t.object({
+			agent: t.optional(t.boolean({
+				aliases: ["a"],
+				description: "Add CLAUDE.md for Claude Code AI assistant"
+			})),
 			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" })),
+			web: 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" }))
 		}),
-		handler: async ({ run, flags, root }) => {
-			if (flags.ui) flags.react = true;
-			const isExpo = await this.utils.hasExpo(root);
+		handler: async ({ run, flags, root, args }) => {
+			if (flags.admin) flags.web = true;
+			if (args) {
+				root = this.fs.join(root, args);
+				await this.fs.mkdir(root);
+			}
+			const isExpo = await this.pm.hasExpo(root);
 			await run({
 				name: "ensuring configuration files",
 				handler: async () => {
-					await this.utils.ensureConfig(root, {
+					await this.scaffolder.ensureConfig(root, {
 						tsconfigJson: true,
 						packageJson: flags,
 						biomeJson: true,
-						viteConfigTs: !isExpo,
 						editorconfig: true,
-						indexHtml: !!flags.react && !isExpo
+						indexHtml: !!flags.web && !isExpo,
+						claudeMd: flags.agent ? {
+							react: !!flags.web,
+							ui: !!flags.admin
+						} : false
 					});
-					if (!flags.react) await this.utils.ensureSrcMain(root);
+					if (!flags.web) await this.scaffolder.ensureApiProject(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 === "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 });
-			await this.utils.ensureDependency(root, "@biomejs/biome", { run });
+			const pmName = await this.pm.getPackageManager(root, flags);
+			if (pmName === "yarn") {
+				await this.pm.ensureYarn(root);
+				await run("yarn set version stable", { root });
+			} else if (pmName === "bun") await this.pm.ensureBun(root);
+			else if (pmName === "pnpm") await this.pm.ensurePnpm(root);
+			else await this.pm.ensureNpm(root);
+			await run(`${pmName} install`, {
+				alias: `installing dependencies with ${pmName}`,
+				root
+			});
+			if (!isExpo) await this.pm.ensureDependency(root, "vite", {
+				run,
+				exec: (cmd, opts) => this.utils.exec(cmd, opts)
+			});
+			await this.pm.ensureDependency(root, "@biomejs/biome", {
+				run,
+				exec: (cmd, opts) => this.utils.exec(cmd, opts)
+			});
 			if (flags.test) {
-				await this.utils.ensureTestDir(root);
-				await run(`${pm} ${pm === "yarn" ? "add" : "install"} -D vitest`, { alias: "setup testing with Vitest" });
+				await this.scaffolder.ensureTestDir(root);
+				await run(`${pmName} ${pmName === "yarn" ? "add" : "install"} -D vitest`, { alias: "setup testing with Vitest" });
 			}
+			await run(`${pmName} run lint`, {
+				alias: "running linter",
+				root
+			});
 		}
 	});
 };
@@ -1500,12 +2001,14 @@ var InitCommand = class {
 //#region ../../src/cli/commands/lint.ts
 var LintCommand = class {
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
+	scaffolder = $inject(ProjectScaffolder);
 	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.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");
 		}
 	});
@@ -1539,34 +2042,12 @@ 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 {
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
+	scaffolder = $inject(ProjectScaffolder);
 	test = $command({
 		name: "test",
 		description: "Run tests using Vitest",
@@ -1579,11 +2060,8 @@ 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.ensureDependency(root, "vitest");
+			await this.scaffolder.ensureConfig(root, { tsconfigJson: true });
+			await this.pm.ensureDependency(root, "vitest", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
 			const config = flags.config ? `--config=${flags.config}` : "";
 			await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
 		}
@@ -1594,6 +2072,7 @@ var TestCommand = class {
 //#region ../../src/cli/commands/typecheck.ts
 var TypecheckCommand = class {
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
 	log = $logger();
 	/**
 	* Run TypeScript type checking across the codebase with no emit.
@@ -1604,7 +2083,7 @@ var TypecheckCommand = class {
 		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.pm.ensureDependency(root, "typescript", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
 			await this.utils.exec("tsc --noEmit");
 			this.log.info("TypeScript type checking completed successfully.");
 		}
@@ -1615,6 +2094,7 @@ var TypecheckCommand = class {
 //#region ../../src/cli/commands/verify.ts
 var VerifyCommand = class {
 	utils = $inject(AlephaCliUtils);
+	pm = $inject(PackageManagerUtils);
 	/**
 	* Run a series of verification commands to ensure code quality and correctness.
 	*
@@ -1636,9 +2116,9 @@ var VerifyCommand = class {
 			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");
+			if ((await this.pm.readPackageJson(root)).devDependencies?.vitest) await run("alepha test");
+			if (await this.utils.exists(root, "migrations")) await run("alepha db check-migrations");
+			if (!await this.pm.hasExpo(root)) await run("alepha build");
 			await run("alepha clean");
 		}
 	});
@@ -1686,7 +2166,6 @@ const AlephaCli = $module({
 		InitCommand,
 		LintCommand,
 		RootCommand,
-		RunCommand,
 		TestCommand,
 		TypecheckCommand,
 		VerifyCommand,
@@ -1705,11 +2184,11 @@ var AlephaPackageBuilderCli = class {
 		root: true,
 		handler: async ({ run, root }) => {
 			const modules = [];
-			const pkg = await readFile("package.json", "utf-8");
-			const pkgData = JSON.parse(pkg);
+			const pkgBuffer = await this.fs.readFile("package.json");
+			const pkgData = JSON.parse(pkgBuffer.toString("utf-8"));
 			const packageName = pkgData.name;
 			await run("analyze modules", async () => {
-				modules.push(...await analyzeModules(join(root, this.src), packageName));
+				modules.push(...await analyzeModules(this.fs.join(root, this.src), packageName));
 			});
 			pkgData.exports = {};
 			for (const item of modules) {
@@ -1721,6 +2200,7 @@ var AlephaPackageBuilderCli = class {
 				if (item.native) pkgData.exports[path]["react-native"] = `./src/${item.name}/index.native.ts`;
 				else if (item.browser) pkgData.exports[path]["react-native"] = `./src/${item.name}/index.browser.ts`;
 				if (item.browser) pkgData.exports[path].browser = `./src/${item.name}/index.browser.ts`;
+				if (item.bun) pkgData.exports[path].bun = `./src/${item.name}/index.bun.ts`;
 				pkgData.exports[path].import = `./src/${item.name}/index.ts`;
 				pkgData.exports[path].default = `./src/${item.name}/index.ts`;
 			}
@@ -1733,33 +2213,30 @@ var AlephaPackageBuilderCli = class {
 				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");
+			const tmpDir = this.fs.join(root, "node_modules/.alepha");
 			await this.fs.mkdir(tmpDir, { recursive: true }).catch(() => {});
-			await this.fs.writeFile(join(tmpDir, "module-dependencies.json"), JSON.stringify(modules, null, 2));
-			const tsconfig = await readFile(join(root, "../../tsconfig.json"), "utf-8");
-			const external = Object.keys(JSON.parse(tsconfig).compilerOptions.paths);
+			await this.fs.writeFile(this.fs.join(tmpDir, "module-dependencies.json"), JSON.stringify(modules, null, 2));
+			const tsconfigBuffer = await this.fs.readFile(this.fs.join(root, "../../tsconfig.json"));
+			const external = Object.keys(JSON.parse(tsconfigBuffer.toString("utf-8")).compilerOptions.paths);
 			external.push("bun");
 			external.push("bun:sqlite");
 			await run.rm(this.dist);
 			const build = async (item) => {
 				const entries = [];
-				const src = join(root, this.src, item.name);
-				const dest = join(root, this.dist, item.name);
+				const src = this.fs.join(root, this.src, item.name);
+				const dest = this.fs.join(root, this.dist, item.name);
 				entries.push({
-					entry: join(src, "index.ts"),
+					entry: this.fs.join(src, "index.ts"),
 					outDir: dest,
 					format: ["esm"],
 					sourcemap: true,
 					fixedExtension: false,
 					platform: "node",
 					external,
-					dts: {
-						sourcemap: true,
-						resolve: false
-					}
+					dts: { sourcemap: true }
 				});
 				if (item.native) entries.push({
-					entry: join(src, "index.native.ts"),
+					entry: this.fs.join(src, "index.native.ts"),
 					outDir: dest,
 					platform: "neutral",
 					sourcemap: true,
@@ -1767,14 +2244,23 @@ var AlephaPackageBuilderCli = class {
 					external
 				});
 				if (item.browser) entries.push({
-					entry: join(src, "index.browser.ts"),
+					entry: this.fs.join(src, "index.browser.ts"),
 					outDir: dest,
 					platform: "browser",
 					sourcemap: true,
 					dts: false,
 					external
 				});
-				const config = join(tmpDir, `tsdown-${item.name.replace("/", "-")}.config.js`);
+				if (item.bun) entries.push({
+					entry: this.fs.join(src, "index.bun.ts"),
+					outDir: dest,
+					platform: "node",
+					sourcemap: true,
+					fixedExtension: false,
+					dts: false,
+					external
+				});
+				const config = this.fs.join(tmpDir, `tsdown-${item.name.replace("/", "-")}.config.js`);
 				await this.fs.writeFile(config, `export default ${JSON.stringify(entries, null, 2)};`);
 				await run(`npx tsdown -c=${config}`);
 			};
@@ -1848,7 +2334,7 @@ function detectCircularDependencies(modules) {
 	}
 	for (const module of modules) {
 		const cycle = hasCycle(module.name);
-		if (cycle) throw new Error(`Circular dependency detected: ${cycle.join(" -> ")}`);
+		if (cycle) throw new AlephaError(`Circular dependency detected: ${cycle.join(" -> ")}`);
 	}
 }
 async function analyzeModules(srcDir, packageName) {
@@ -1862,6 +2348,7 @@ async function analyzeModules(srcDir, packageName) {
 				const dependencies = /* @__PURE__ */ new Set();
 				const hasBrowser = await fileExists(join(modulePath, "index.browser.ts"));
 				const hasNative = await fileExists(join(modulePath, "index.native.ts"));
+				const hasBun = await fileExists(join(modulePath, "index.bun.ts"));
 				const hasNode = await fileExists(join(modulePath, "index.node.ts"));
 				const files = await getAllFiles(modulePath);
 				for (const file of files) {
@@ -1878,6 +2365,7 @@ async function analyzeModules(srcDir, packageName) {
 				};
 				if (hasNative) module.native = true;
 				if (hasBrowser) module.browser = true;
+				if (hasBun) module.bun = true;
 				if (hasNode) module.node = true;
 				modules.push(module);
 			} else await scanDirectory(modulePath, moduleName);
@@ -1890,11 +2378,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 };
 	};
 };
 /**
@@ -1903,5 +2393,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, OpenApiCommand, 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