alepha 0.14.3 → 0.15.0

package/dist/cli/index.d.ts

@@ -17,6 +17,7 @@ interface Module {
   dependencies: string[];
   native?: boolean;
   browser?: boolean;
+  bun?: boolean;
   node?: boolean;
 }
 declare class AlephaPackageBuilderCli {
@@ -47,300 +48,305 @@ declare const DEFAULT_IGNORE: string[];
  */
 declare const changelogOptions: alepha0.Atom<alepha0.TObject<{
   /**
-   * Scopes to ignore (e.g., "project", "release", "chore").
-   * Commits like `feat(chore): ...` will be excluded from changelog.
-   */
+       * Scopes to ignore (e.g., "project", "release", "chore").
+       * Commits like `feat(chore): ...` will be excluded from changelog.
+       */
   ignore: alepha0.TOptional<alepha0.TArray<alepha0.TString>>;
 }>, "alepha.changelog">;
 type ChangelogOptions = Static<typeof changelogOptions.schema>;
 //#endregion
 //#region ../../src/cli/services/AlephaCliUtils.d.ts
 /**
- * Utility service for common project operations used by CLI commands.
+ * Core utility service for 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
+ * Provides:
+ * - Command execution
+ * - File editing helpers
+ * - Drizzle/ORM utilities
+ * - Environment loading
  */
 declare class AlephaCliUtils {
   protected readonly log: alepha_logger7.Logger;
   protected readonly fs: FileSystemProvider;
   protected readonly envUtils: EnvUtils;
-  protected readonly alepha: Alepha;
   /**
-   * Execute a command using npx with inherited stdio.
-   *
-   * @example
-   * ```ts
-   * const runner = alepha.inject(ProcessRunner);
-   * await runner.exec("tsx watch src/index.ts");
-   * ```
-   */
+       * Execute a command with inherited stdio.
+       */
   exec(command: string, options?: {
+    root?: string;
     env?: Record<string, string>;
     global?: boolean;
   }): Promise<void>;
   /**
-   * 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);
-   * ```
-   */
+       * Write a configuration file to node_modules/.alepha directory.
+       */
   writeConfigFile(name: string, content: string, root?: string): Promise<string>;
-  removeFiles(root: string, files: string[]): Promise<void>;
-  removeYarn(root: string): Promise<void>;
-  removePnpm(root: string): Promise<void>;
-  removeNpm(root: string): Promise<void>;
-  removeBun(root: string): Promise<void>;
-  removeAllPmFilesExcept(root: string, except: string): Promise<void>;
-  /**
-   * 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
-   */
-  ensureYarn(root: string): Promise<void>;
-  ensureBun(root: string): Promise<void>;
-  ensurePnpm(root: string): Promise<void>;
-  ensureNpm(root: string): Promise<void>;
-  /**
-   * Generate package.json content with Alepha dependencies.
-   *
-   * @param modes - Configuration for which dependencies to include
-   * @returns Package.json partial with dependencies, devDependencies, and scripts
-   */
-  generatePackageJsonContent(modes: DependencyModes): {
-    dependencies: Record<string, string>;
-    devDependencies: Record<string, string>;
-    scripts: Record<string, string>;
-    type: "module";
-  };
-  /**
-   * 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
-   */
-  ensurePackageJson(root: string, modes: DependencyModes): Promise<object>;
-  ensureConfig(root: string, opts: {
-    packageJson?: boolean | DependencyModes;
-    tsconfigJson?: boolean;
-    viteConfigTs?: boolean;
-    indexHtml?: boolean;
-    biomeJson?: boolean;
-    editorconfig?: boolean;
-  }): Promise<Array<void | object>>;
-  /**
-   * Ensure tsconfig.json exists in the project.
-   *
-   * Creates a standard Alepha tsconfig.json if none exists.
-   *
-   * @param root - The root directory of the project
-   */
-  ensureTsConfig(root: string): Promise<void>;
-  /**
-   * Ensure vite.config.ts exists in the project.
-   *
-   * Creates a standard Alepha vite.config.ts if none exists.
-   */
-  ensureViteConfig(root: string, serverEntry?: string): Promise<void>;
-  protected checkFileExists(root: string, name: string, checkParentDirectories?: boolean): Promise<string | undefined>;
-  protected ensureFileExists(root: string, name: string, content: string, checkParentDirectories?: boolean): Promise<void>;
-  /**
-   * 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.
-   */
-  ensureBiomeConfig(root: string): Promise<void>;
-  /**
-   * Ensure .editorconfig exists in the project.
-   *
-   * Creates a standard .editorconfig if none exists.
-   *
-   * @param root - The root directory of the project
-   */
-  ensureEditorConfig(root: string): Promise<void>;
   /**
-   * 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
-   */
+       * Load Alepha instance from a server entry file.
+       */
   loadAlephaFromServerEntryFile(rootDir?: string, explicitEntry?: string): Promise<{
     alepha: Alepha;
     entry: string;
   }>;
   /**
-   * 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
-   */
+       * Generate JavaScript code for Drizzle entities export.
+       */
   generateEntitiesJs(entry: string, provider: string, models?: string[]): string;
   /**
-   * Load environment variables from a .env file.
-   *
-   * Reads the .env file in the specified root directory and sets
-   * the environment variables in process.env.
-   */
+       * Load environment variables from a .env file.
+       */
   loadEnv(root: string, files?: string[]): Promise<void>;
+  exists(root: string, path: string): Promise<boolean>;
+  protected checkFileExists(root: string, name: string): Promise<string | undefined>;
+}
+//#endregion
+//#region ../../src/cli/services/PackageManagerUtils.d.ts
+/**
+ * Utility service for package manager operations.
+ *
+ * Handles detection, installation, and cleanup for:
+ * - Yarn
+ * - npm
+ * - pnpm
+ * - Bun
+ */
+declare class PackageManagerUtils {
+  protected readonly log: alepha_logger7.Logger;
+  protected readonly fs: FileSystemProvider;
+  protected readonly alepha: Alepha;
+  /**
+       * Detect the package manager used in the project.
+       */
   getPackageManager(root: string, flags?: {
     yarn?: boolean;
     pnpm?: boolean;
     npm?: boolean;
     bun?: boolean;
   }): Promise<"yarn" | "pnpm" | "npm" | "bun">;
-  ensureIndexHtml(root: string): Promise<void>;
-  exists(root: string, dirName: string): Promise<boolean>;
-  /**
-   * Ensure src/main.ts exists with a minimal Alepha bootstrap.
-   *
-   * 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
-   */
-  ensureSrcMain(root: string): Promise<void>;
-  /**
-   * 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
-   */
-  ensureTestDir(root: string): Promise<void>;
-  readPackageJson(root: string): Promise<Record<string, any>>;
   /**
-   * 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
-   */
+       * Get the install command for a package.
+       */
+  getInstallCommand(root: string, packageName: string, dev?: boolean): Promise<string>;
+  /**
+       * Check if a dependency is installed in the project.
+       */
   hasDependency(root: string, packageName: string): Promise<boolean>;
   /**
-   * 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
-   */
+       * Check if Expo is present in the project.
+       */
   hasExpo(root: string): Promise<boolean>;
-  getInstallCommand(root: string, packageName: string, dev?: boolean): Promise<string>;
   /**
-   * 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.
-   */
+       * Install a dependency if it's missing from the project.
+       */
   ensureDependency(root: string, packageName: string, options?: {
     dev?: boolean;
     run?: RunnerMethod;
+    exec?: (cmd: string, opts?: {
+      global?: boolean;
+      root?: string;
+    }) => Promise<void>;
   }): Promise<void>;
+  ensureYarn(root: string): Promise<void>;
+  ensureBun(root: string): Promise<void>;
+  ensurePnpm(root: string): Promise<void>;
+  ensureNpm(root: string): Promise<void>;
+  removeAllPmFilesExcept(root: string, except: string): Promise<void>;
+  removeYarn(root: string): Promise<void>;
+  removePnpm(root: string): Promise<void>;
+  removeNpm(root: string): Promise<void>;
+  removeBun(root: string): Promise<void>;
+  readPackageJson(root: string): Promise<Record<string, any>>;
+  writePackageJson(root: string, content: Record<string, any>): Promise<void>;
+  editPackageJson(root: string, editFn: (pkg: Record<string, any>) => Record<string, any>): Promise<void>;
+  ensurePackageJson(root: string, modes: DependencyModes): Promise<Record<string, any>>;
+  generatePackageJsonContent(modes: DependencyModes): {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts: Record<string, string>;
+    type: "module";
+  };
+  protected removeFiles(root: string, files: string[]): Promise<void>;
 }
 interface DependencyModes {
+  web?: boolean;
+  admin?: boolean;
+  expo?: boolean;
+}
+//#endregion
+//#region ../../src/cli/assets/claudeMd.d.ts
+interface ClaudeMdOptions {
   react?: boolean;
   ui?: boolean;
-  expo?: boolean;
+  projectName?: string;
+}
+//#endregion
+//#region ../../src/cli/services/ProjectScaffolder.d.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)
+ */
+declare class ProjectScaffolder {
+  protected readonly log: alepha_logger7.Logger;
+  protected readonly fs: FileSystemProvider;
+  protected readonly pm: PackageManagerUtils;
+  /**
+       * Get the app name from the directory name.
+       *
+       * Converts the directory name to a valid module name:
+       * - Converts to lowercase
+       * - Replaces spaces, dashes, underscores with nothing
+       * - Falls back to "app" if empty
+       */
+  getAppName(root: string): string;
+  /**
+       * Ensure all configuration files exist.
+       */
+  ensureConfig(root: string, opts: {
+    packageJson?: boolean | DependencyModes;
+    tsconfigJson?: boolean;
+    indexHtml?: boolean;
+    biomeJson?: boolean;
+    editorconfig?: boolean;
+    claudeMd?: boolean | ClaudeMdOptions;
+  }): Promise<void>;
+  ensureTsConfig(root: string): Promise<void>;
+  ensureBiomeConfig(root: string): Promise<void>;
+  ensureEditorConfig(root: string): Promise<void>;
+  ensureClaudeMd(root: string, options?: ClaudeMdOptions): Promise<void>;
+  /**
+       * Ensure src/main.server.ts exists with full API structure.
+       *
+       * Creates:
+       * - src/main.server.ts (entry point)
+       * - src/api/index.ts (API module)
+       * - src/api/controllers/HelloController.ts (example controller)
+       */
+  ensureApiProject(root: string): Promise<void>;
+  /**
+       * 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
+       */
+  ensureReactProject(root: string): Promise<void>;
+  /**
+       * Ensure test directory exists with a dummy test file.
+       */
+  ensureTestDir(root: string): Promise<void>;
+  protected ensureFileIfNotExists(root: string, relativePath: string, content: string): Promise<void>;
+  /**
+       * Check if a file exists in the given directory or any parent directory.
+       */
+  protected existsInParents(root: string, filename: string): Promise<boolean>;
 }
 //#endregion
 //#region ../../src/cli/commands/build.d.ts
 declare class BuildCommand {
   protected readonly log: alepha_logger7.Logger;
+  protected readonly fs: FileSystemProvider;
   protected readonly utils: AlephaCliUtils;
+  protected readonly pm: PackageManagerUtils;
+  protected readonly scaffolder: ProjectScaffolder;
+  protected readonly options: Readonly<{
+    stats?: boolean | undefined;
+    vercel?: {
+      config?: {
+        crons?: {
+          path: string;
+          schedule: string;
+        }[] | undefined;
+      } | undefined;
+      projectName?: string | undefined;
+      orgId?: string | undefined;
+      projectId?: string | undefined;
+    } | undefined;
+    cloudflare?: {
+      config?: typebox0.StaticRecord<[], "Decode", {}, {
+        config: alepha0.TOptional<alepha0.TRecord<string, alepha0.TAny>>;
+      }, string, alepha0.TAny> | undefined;
+    } | undefined;
+    docker?: {
+      image?: string | undefined;
+      command?: string | undefined;
+    } | undefined;
+    sitemap?: {
+      hostname: string;
+    } | undefined;
+  }>;
   readonly build: alepha_command0.CommandPrimitive<alepha0.TObject<{
     stats: alepha0.TOptional<alepha0.TBoolean>;
     vercel: alepha0.TOptional<alepha0.TBoolean>;
     cloudflare: alepha0.TOptional<alepha0.TBoolean>;
     docker: alepha0.TOptional<alepha0.TBoolean>;
     sitemap: alepha0.TOptional<alepha0.TString>;
+    bun: alepha0.TOptional<alepha0.TBoolean>;
   }>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
 }
 //#endregion
 //#region ../../src/cli/commands/clean.d.ts
 declare class CleanCommand {
   /**
-   * Clean the project, removing the "dist" directory
-   */
+       * Clean the project, removing the "dist" directory
+       */
   readonly clean: alepha_command0.CommandPrimitive<typebox0.TObject<typebox0.TProperties>, typebox0.TSchema, typebox0.TObject<typebox0.TProperties>>;
 }
 //#endregion
 //#region ../../src/cli/commands/db.d.ts
 declare class DbCommand {
   protected readonly log: alepha_logger7.Logger;
+  protected readonly fs: FileSystemProvider;
   protected readonly utils: AlephaCliUtils;
   /**
-   * Check if database migrations are up to date.
-   */
+       * Check if database migrations are up to date.
+       */
   protected readonly check: alepha_command0.CommandPrimitive<alepha0.TObject<{
     provider: alepha0.TOptional<alepha0.TString>;
     mode: alepha0.TOptional<alepha0.TString>;
   }>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
   /**
-   * Generate database migration files
-   */
+       * Generate database migration files
+       */
   protected readonly generate: alepha_command0.CommandPrimitive<alepha0.TObject<{
     provider: alepha0.TOptional<alepha0.TString>;
     mode: alepha0.TOptional<alepha0.TString>;
     custom: alepha0.TOptional<alepha0.TString>;
   }>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
   /**
-   * Push database schema changes directly to the database
-   */
+       * Push database schema changes directly to the database
+       */
   protected readonly push: alepha_command0.CommandPrimitive<alepha0.TObject<{
     provider: alepha0.TOptional<alepha0.TString>;
     mode: alepha0.TOptional<alepha0.TString>;
   }>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
   /**
-   * Apply pending database migrations
-   */
+       * Apply pending database migrations
+       */
   protected readonly migrate: alepha_command0.CommandPrimitive<alepha0.TObject<{
     provider: alepha0.TOptional<alepha0.TString>;
     mode: alepha0.TOptional<alepha0.TString>;
   }>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
   /**
-   * Launch Drizzle Studio database browser
-   */
+       * Launch Drizzle Studio database browser
+       */
   protected readonly studio: alepha_command0.CommandPrimitive<alepha0.TObject<{
     provider: alepha0.TOptional<alepha0.TString>;
     mode: alepha0.TOptional<alepha0.TString>;
   }>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
   /**
-   * Parent command for database operations.
-   */
+       * Parent command for database operations.
+       */
   readonly db: alepha_command0.CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
   /**
-   * Run a drizzle-kit command for all database providers in an Alepha instance.
-   */
+       * Run a drizzle-kit command for all database providers in an Alepha instance.
+       */
   runDrizzleKitCommand(options: {
     root: string;
     args?: string;
@@ -351,13 +357,14 @@ declare class DbCommand {
     env?: string;
   }): Promise<void>;
   /**
-   * Prepare Drizzle configuration files for a database provider.
-   */
+       * Prepare Drizzle configuration files for a database provider.
+       */
   prepareDrizzleConfig(options: {
     kit: any;
     provider: DatabaseProvider;
     providerName: string;
     providerUrl: string;
+    providerDriver: string;
     dialect: string;
     entry: string;
     rootDir: string;
@@ -367,26 +374,28 @@ declare class DbCommand {
 //#region ../../src/cli/commands/deploy.d.ts
 declare class DeployCommand {
   protected readonly log: alepha_logger7.Logger;
+  protected readonly fs: FileSystemProvider;
   protected readonly utils: AlephaCliUtils;
-  /**
-   * Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)
-   *
-   * Deploy command can be overridden by creating a alepha.config.ts in the project root:
-   *
-   * ```ts
-   * import { defineConfig } from "alepha/cli";
-   *
-   * export default defineConfig({
-   *   commands: {
-   *     deploy: {
-   *       handler: async ({ root, mode, flags }) => {
-   *         // Custom deployment logic here
-   *       },
-   *     },
-   *   },
-   * });
-   * ```
-   */
+  protected readonly pm: PackageManagerUtils;
+  /**
+       * Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)
+       *
+       * Deploy command can be overridden by creating a alepha.config.ts in the project root:
+       *
+       * ```ts
+       * import { defineConfig } from "alepha/cli";
+       *
+       * export default defineConfig({
+       *   commands: {
+       *     deploy: {
+       *       handler: async ({ root, mode, flags }) => {
+       *         // Custom deployment logic here
+       *       },
+       *     },
+       *   },
+       * });
+       * ```
+       */
   readonly deploy: alepha_command0.CommandPrimitive<alepha0.TObject<{
     build: alepha0.TBoolean;
     migrate: alepha0.TBoolean;
@@ -402,21 +411,27 @@ declare class DeployCommand {
 //#region ../../src/cli/commands/dev.d.ts
 declare class DevCommand {
   protected readonly log: alepha_logger7.Logger;
+  protected readonly fs: FileSystemProvider;
   protected readonly utils: AlephaCliUtils;
+  protected readonly pm: PackageManagerUtils;
+  protected readonly scaffolder: ProjectScaffolder;
   protected readonly alepha: Alepha;
   /**
-   * Will run the project in watch mode.
-   *
-   * - If an index.html file is found in the project root, it will run Vite in dev mode.
-   * - Otherwise, it will look for a server entry file and run it with tsx in watch mode.
-   */
+       * Will run the project in watch mode.
+       *
+       * - If an index.html file is found in the project root, it will run Vite in dev mode.
+       * - Otherwise, it will look for a server entry file and run it with tsx in watch mode.
+       */
   readonly dev: alepha_command0.CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
+  protected isBunProject(root: string): Promise<boolean>;
   protected isFullstackProject(root: string): Promise<boolean>;
 }
 //#endregion
 //#region ../../src/cli/commands/format.d.ts
 declare class FormatCommand {
   protected readonly utils: AlephaCliUtils;
+  protected readonly pm: PackageManagerUtils;
+  protected readonly scaffolder: ProjectScaffolder;
   readonly format: alepha_command0.CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 }
 //#endregion
@@ -438,16 +453,16 @@ declare class FormatCommand {
 declare class GitMessageParser {
   protected readonly log: alepha_logger7.Logger;
   /**
-   * Parse a git commit line into a structured Commit object.
-   *
-   * **Format:** `type(scope): description` or `type(scope)!: description`
-   *
-   * **Supported types:** feat, fix, docs, refactor, perf, revert
-   *
-   * **Breaking changes:** Use `!` before `:` (e.g., `feat(api)!: remove endpoint`)
-   *
-   * @returns Commit object or null if not matching/ignored
-   */
+       * Parse a git commit line into a structured Commit object.
+       *
+       * **Format:** `type(scope): description` or `type(scope)!: description`
+       *
+       * **Supported types:** feat, fix, docs, refactor, perf, revert
+       *
+       * **Breaking changes:** Use `!` before `:` (e.g., `feat(api)!: remove endpoint`)
+       *
+       * @returns Commit object or null if not matching/ignored
+       */
   parseCommit(line: string, config: ChangelogOptions): Commit | null;
 }
 //#endregion
@@ -487,39 +502,39 @@ declare class ChangelogCommand {
     ignore?: string[] | undefined;
   }>;
   /**
-   * Format a single commit line.
-   * Example: `- **cli**: add new command (\`abc1234\`)`
-   * Breaking changes are flagged: `- **cli**: add new command [BREAKING] (\`abc1234\`)`
-   */
+       * Format a single commit line.
+       * Example: `- **cli**: add new command (\`abc1234\`)`
+       * Breaking changes are flagged: `- **cli**: add new command [BREAKING] (\`abc1234\`)`
+       */
   protected formatCommit(commit: Commit): string;
   /**
-   * Format the changelog entry with sections.
-   */
+       * Format the changelog entry with sections.
+       */
   protected formatEntry(entry: ChangelogEntry): string;
   /**
-   * Parse git log output into a changelog entry.
-   */
+       * Parse git log output into a changelog entry.
+       */
   protected parseCommits(commitsOutput: string): ChangelogEntry;
   /**
-   * Check if entry has any public commits.
-   */
+       * Check if entry has any public commits.
+       */
   protected hasChanges(entry: ChangelogEntry): boolean;
   /**
-   * Get the latest version tag.
-   */
+       * Get the latest version tag.
+       */
   protected getLatestTag(git: (cmd: string) => Promise<string>): Promise<string | null>;
   readonly command: alepha_command0.CommandPrimitive<alepha0.TObject<{
     /**
-     * Show changes from this ref (tag, commit, branch).
-     * Defaults to the latest version tag.
-     * Example: --from=1.0.0
-     */
+             * Show changes from this ref (tag, commit, branch).
+             * Defaults to the latest version tag.
+             * Example: --from=1.0.0
+             */
     from: alepha0.TOptional<alepha0.TString>;
     /**
-     * Show changes up to this ref (tag, commit, branch).
-     * Defaults to HEAD.
-     * Example: --to=main
-     */
+             * Show changes up to this ref (tag, commit, branch).
+             * Defaults to HEAD.
+             * Example: --to=main
+             */
     to: alepha0.TOptional<alepha0.TString>;
   }>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 }
@@ -537,24 +552,30 @@ declare class OpenApiCommand {
 //#region ../../src/cli/commands/init.d.ts
 declare class InitCommand {
   protected readonly utils: AlephaCliUtils;
+  protected readonly pm: PackageManagerUtils;
+  protected readonly scaffolder: ProjectScaffolder;
+  protected readonly fs: FileSystemProvider;
   /**
-   * Ensure the project has the necessary Alepha configuration files.
-   * Add the correct dependencies to package.json and install them.
-   */
+       * Ensure the project has the necessary Alepha configuration files.
+       * Add the correct dependencies to package.json and install them.
+       */
   readonly init: alepha_command0.CommandPrimitive<alepha0.TObject<{
+    agent: alepha0.TOptional<alepha0.TBoolean>;
     yarn: alepha0.TOptional<alepha0.TBoolean>;
     pnpm: alepha0.TOptional<alepha0.TBoolean>;
     npm: alepha0.TOptional<alepha0.TBoolean>;
     bun: alepha0.TOptional<alepha0.TBoolean>;
-    react: alepha0.TOptional<alepha0.TBoolean>;
-    ui: alepha0.TOptional<alepha0.TBoolean>;
+    web: alepha0.TOptional<alepha0.TBoolean>;
+    admin: alepha0.TOptional<alepha0.TBoolean>;
     test: alepha0.TOptional<alepha0.TBoolean>;
-  }>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
+  }>, alepha0.TOptional<alepha0.TString>, alepha0.TObject<alepha0.TProperties>>;
 }
 //#endregion
 //#region ../../src/cli/commands/lint.d.ts
 declare class LintCommand {
   protected readonly utils: AlephaCliUtils;
+  protected readonly pm: PackageManagerUtils;
+  protected readonly scaffolder: ProjectScaffolder;
   readonly lint: alepha_command0.CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 }
 //#endregion
@@ -565,24 +586,18 @@ declare class RootCommand {
   protected readonly alepha: Alepha;
   protected readonly color: ConsoleColorProvider;
   /**
-   * Called when no command is provided
-   */
+       * Called when no command is provided
+       */
   readonly root: alepha_command0.CommandPrimitive<alepha0.TObject<{
     version: alepha0.TOptional<alepha0.TBoolean>;
   }>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 }
 //#endregion
-//#region ../../src/cli/commands/run.d.ts
-declare class RunCommand {
-  protected readonly utils: AlephaCliUtils;
-  readonly run: alepha_command0.CommandPrimitive<alepha0.TObject<{
-    watch: alepha0.TOptional<alepha0.TBoolean>;
-  }>, alepha0.TString, alepha0.TObject<alepha0.TProperties>>;
-}
-//#endregion
 //#region ../../src/cli/commands/test.d.ts
 declare class TestCommand {
   protected readonly utils: AlephaCliUtils;
+  protected readonly pm: PackageManagerUtils;
+  protected readonly scaffolder: ProjectScaffolder;
   readonly test: alepha_command0.CommandPrimitive<alepha0.TObject<{
     config: alepha0.TOptional<alepha0.TString>;
   }>, alepha0.TSchema, alepha0.TObject<{
@@ -593,49 +608,133 @@ declare class TestCommand {
 //#region ../../src/cli/commands/typecheck.d.ts
 declare class TypecheckCommand {
   protected readonly utils: AlephaCliUtils;
+  protected readonly pm: PackageManagerUtils;
   protected readonly log: alepha_logger7.Logger;
   /**
-   * Run TypeScript type checking across the codebase with no emit.
-   */
+       * Run TypeScript type checking across the codebase with no emit.
+       */
   readonly typecheck: alepha_command0.CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 }
 //#endregion
 //#region ../../src/cli/commands/verify.d.ts
 declare class VerifyCommand {
   protected readonly utils: AlephaCliUtils;
-  /**
-   * Run a series of verification commands to ensure code quality and correctness.
-   *
-   * This command runs the following checks in order:
-   * - Clean the project
-   * - Format the code
-   * - Lint the code
-   * - Run tests (if Vitest is a dev dependency)
-   * - Check database migrations (if a migrations directory exists)
-   * - Type check the code
-   * - Build the project
-   * - Clean the project again
-   */
+  protected readonly pm: PackageManagerUtils;
+  /**
+       * Run a series of verification commands to ensure code quality and correctness.
+       *
+       * This command runs the following checks in order:
+       * - Clean the project
+       * - Format the code
+       * - Lint the code
+       * - Run tests (if Vitest is a dev dependency)
+       * - Check database migrations (if a migrations directory exists)
+       * - Type check the code
+       * - Build the project
+       * - Clean the project again
+       */
   readonly verify: alepha_command0.CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 }
 //#endregion
+//#region ../../src/cli/atoms/buildOptions.d.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.
+ */
+declare const buildOptions: alepha0.Atom<alepha0.TObject<{
+  /**
+       * Generate build stats report.
+       */
+  stats: alepha0.TOptional<alepha0.TBoolean>;
+  /**
+       * Vercel deployment configuration.
+       */
+  vercel: alepha0.TOptional<alepha0.TObject<{
+    projectName: alepha0.TOptional<alepha0.TString>;
+    orgId: alepha0.TOptional<alepha0.TString>;
+    projectId: alepha0.TOptional<alepha0.TString>;
+    config: alepha0.TOptional<alepha0.TObject<{
+      crons: alepha0.TOptional<alepha0.TArray<alepha0.TObject<{
+        path: alepha0.TString;
+        schedule: alepha0.TString;
+      }>>>;
+    }>>;
+  }>>;
+  /**
+       * Cloudflare Workers deployment configuration.
+       */
+  cloudflare: alepha0.TOptional<alepha0.TObject<{
+    config: alepha0.TOptional<alepha0.TRecord<string, alepha0.TAny>>;
+  }>>;
+  /**
+       * Docker deployment configuration.
+       */
+  docker: alepha0.TOptional<alepha0.TObject<{
+    /**
+             * Docker image name to use in the Dockerfile.
+             * @default "node:24-alpine"
+             */
+    image: alepha0.TOptional<alepha0.TString>;
+    /**
+             * Command to run in the Docker container.
+             * @default "node"
+             */
+    command: alepha0.TOptional<alepha0.TString>;
+  }>>;
+  /**
+       * Sitemap generation configuration.
+       */
+  sitemap: alepha0.TOptional<alepha0.TObject<{
+    /**
+             * Base URL for sitemap entries.
+             */
+    hostname: alepha0.TString;
+  }>>;
+}>, "alepha.build.options">;
+/**
+ * Type for build options.
+ */
+type BuildOptions = Static<typeof buildOptions.schema>;
+//#endregion
 //#region ../../src/cli/defineConfig.d.ts
-type AlephaCliConfig = (alepha: Alepha) => {
+interface AlephaCliConfig {
+  /**
+       * Add custom commands to the Alepha CLI.
+       *
+       * You can override 'deploy', 'build', 'dev', 'start' commands this way.
+       * But you can also add your own commands and run them via `alepha <command>`.
+       */
   commands?: Record<string, CommandPrimitive>;
+  /**
+       * Register more services to the Alepha CLI (enhancements, commands, etc.).
+       */
   services?: Array<any>;
-};
-declare const defineConfig: (config: AlephaCliConfig) => (alepha: Alepha) => {
+  /**
+       * Configure Alepha build command.
+       */
+  build?: BuildOptions;
+  /**
+       * Environment variables to set before running commands.
+       *
+       * Always use .env files by default, this is only for dynamic values.
+       */
+  env?: Record<string, unknown>;
+}
+type AlephaCliConfigFn = (alepha: Alepha) => AlephaCliConfig;
+declare const defineConfig: (runConfig: AlephaCliConfig | AlephaCliConfigFn) => (alepha: Alepha) => {
   [x: string]: CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 };
 /**
  * @alias defineConfig
  */
-declare const defineAlephaConfig: (config: AlephaCliConfig) => (alepha: Alepha) => {
+declare const defineAlephaConfig: (runConfig: AlephaCliConfig | AlephaCliConfigFn) => (alepha: Alepha) => {
   [x: string]: CommandPrimitive<alepha0.TObject<alepha0.TProperties>, alepha0.TSchema, alepha0.TObject<alepha0.TProperties>>;
 };
 //#endregion
 //#region ../../src/cli/version.d.ts
 declare const version: any;
 //#endregion
-export { AlephaCli, AlephaCliConfig, AlephaCliUtils, AlephaPackageBuilderCli, BuildCommand, ChangelogCommand, type ChangelogOptions, CleanCommand, Commit, DEFAULT_IGNORE, DbCommand, DependencyModes, DeployCommand, DevCommand, FormatCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, RunCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
+export { AlephaCli, AlephaCliConfig, AlephaCliConfigFn, AlephaCliUtils, AlephaPackageBuilderCli, BuildCommand, ChangelogCommand, type ChangelogOptions, CleanCommand, Commit, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, FormatCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
 //# sourceMappingURL=index.d.ts.map