alepha 0.14.1 → 0.14.2

package/src/cli/commands/{ViteCommands.ts → build.ts}

@@ -1,7 +1,7 @@
 import { access, readFile, unlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { join } from "node:path";
-import { $env, $inject, OPTIONS, t } from "alepha";
+import { $inject, OPTIONS, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import {
@@ -18,78 +18,10 @@ import {
 import type * as Vite from "vite";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
-export class ViteCommands {
+export class BuildCommand {
   protected readonly log = $logger();
   protected readonly utils = $inject(AlephaCliUtils);
 
-  protected readonly env = $env(
-    t.object({
-      VITEST_ARGS: t.string({ default: "" }),
-    }),
-  );
-
-  public readonly run = $command({
-    name: "run",
-    hide: true,
-    description: "Run a TypeScript file directly",
-    flags: t.object({
-      watch: t.optional(
-        t.boolean({ description: "Watch file for changes", alias: "w" }),
-      ),
-    }),
-    summary: false,
-    args: t.text({ title: "path", description: "Filepath to run" }),
-    handler: async ({ args, flags, root }) => {
-      await this.utils.ensureTsConfig(root);
-      await this.utils.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
-    },
-  });
-
-  /**
-   * Will run the project in watch mode.
-   *
-   * - 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.
-   */
-  public readonly dev = $command({
-    name: "dev",
-    description: "Run the project in development mode",
-    args: t.optional(t.text({ title: "path", description: "Filepath to run" })),
-    handler: async ({ args, root }) => {
-      const expo = await this.utils.hasExpo(root);
-
-      await this.utils.ensureConfig(root, {
-        viteConfigTs: !expo,
-        tsconfigJson: true,
-      });
-
-      if (expo) {
-        await this.utils.exec(`expo start`);
-        return;
-      }
-
-      const entry = await boot.getServerEntry(root, args);
-      this.log.trace("Entry file found", { entry });
-
-      try {
-        await access(join(root, "index.html"));
-      } catch {
-        this.log.trace("No index.html found, running entry file with tsx");
-        let cmd = "tsx --watch";
-        if (await this.utils.exists(root, ".env")) {
-          cmd += ` --env-file=./.env`;
-        }
-        cmd += ` ${entry}`;
-        await this.utils.exec(cmd);
-        return;
-      }
-
-      // Ensure vite is installed before running
-      await this.utils.ensureDependency(root, "vite");
-      await this.utils.exec(`vite`);
-    },
-  });
-
   public readonly build = $command({
     name: "build",
     description: "Build the project for production",
@@ -313,39 +245,4 @@ export class ViteCommands {
       }
     },
   });
-
-  public readonly test = $command({
-    name: "test",
-    description: "Run tests using Vitest",
-    flags: t.object({
-      config: t.optional(
-        t.string({
-          description: "Path to Vitest config file",
-          alias: "c",
-        }),
-      ),
-    }),
-    env: t.object({
-      VITEST_ARGS: t.optional(
-        t.string({
-          default: "",
-          description:
-            "Additional arguments to pass to Vitest. E.g., --coverage",
-        }),
-      ),
-    }),
-    handler: async ({ root, flags, env }) => {
-      await this.utils.ensureConfig(root, {
-        tsconfigJson: true,
-        viteConfigTs: true,
-      });
-
-      // Ensure vitest is installed before running
-      await this.utils.ensureDependency(root, "vitest");
-
-      const config = flags.config ? `--config=${flags.config}` : "";
-
-      await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
-    },
-  });
 }

package/src/cli/commands/{ChangelogCommands.ts → changelog.ts}

@@ -45,11 +45,10 @@ export interface Commit {
 interface ChangelogEntry {
   features: Commit[];
   fixes: Commit[];
-  breaking: Commit[];
 }
 
 // =============================================================================
-// CHANGELOG COMMANDS
+// CHANGELOG COMMAND
 // =============================================================================
 
 /**
@@ -61,7 +60,7 @@ interface ChangelogEntry {
  * - `alepha changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
  * - `alepha changelog | tee -a CHANGELOG.md` - Append to file
  */
-export class ChangelogCommands {
+export class ChangelogCommand {
   protected readonly log = $logger();
   protected readonly git = $inject(GitProvider);
   protected readonly parser = $inject(GitMessageParser);
@@ -74,9 +73,11 @@ export class ChangelogCommands {
   /**
    * 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 {
-    return `- **${commit.scope}**: ${commit.description} (\`${commit.hash}\`)`;
+    const breaking = commit.breaking ? " [BREAKING]" : "";
+    return `- **${commit.scope}**: ${commit.description}${breaking} (\`${commit.hash}\`)`;
   }
 
   /**
@@ -85,14 +86,6 @@ export class ChangelogCommands {
   protected formatEntry(entry: ChangelogEntry): string {
     const sections: string[] = [];
 
-    if (entry.breaking.length > 0) {
-      sections.push("### Breaking Changes\n");
-      for (const commit of entry.breaking) {
-        sections.push(this.formatCommit(commit));
-      }
-      sections.push("");
-    }
-
     if (entry.features.length > 0) {
       sections.push("### Features\n");
       for (const commit of entry.features) {
@@ -123,7 +116,6 @@ export class ChangelogCommands {
     const entry: ChangelogEntry = {
       features: [],
       fixes: [],
-      breaking: [],
     };
 
     for (const line of commitsOutput.trim().split("\n")) {
@@ -137,10 +129,7 @@ export class ChangelogCommands {
 
       this.log.trace("Parsed commit", { commit });
 
-      // Categorize commit
-      if (commit.breaking) {
-        entry.breaking.push(commit);
-      }
+      // Categorize commit (breaking flag is preserved on the commit itself)
       if (commit.type === "feat") {
         entry.features.push(commit);
       } else if (commit.type === "fix") {
@@ -155,11 +144,7 @@ export class ChangelogCommands {
    * Check if entry has any public commits.
    */
   protected hasChanges(entry: ChangelogEntry): boolean {
-    return (
-      entry.features.length > 0 ||
-      entry.fixes.length > 0 ||
-      entry.breaking.length > 0
-    );
+    return entry.features.length > 0 || entry.fixes.length > 0;
   }
 
   /**

package/src/cli/commands/clean.ts

@@ -0,0 +1,14 @@
+import { $command } from "alepha/command";
+
+export class CleanCommand {
+  /**
+   * Clean the project, removing the "dist" directory
+   */
+  public readonly clean = $command({
+    name: "clean",
+    description: "Clean the project",
+    handler: async ({ run }) => {
+      await run.rm("./dist");
+    },
+  });
+}

package/src/cli/commands/{DrizzleCommands.ts → db.ts}

@@ -25,14 +25,14 @@ const drizzleCommandFlags = t.object({
   ),
 });
 
-export class DrizzleCommands {
-  log = $logger();
-  utils = $inject(AlephaCliUtils);
+export class DbCommand {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(AlephaCliUtils);
 
   /**
    * Check if database migrations are up to date.
    */
-  check = $command({
+  protected readonly check = $command({
     name: "check-migrations",
     description: "Check if database migration files are up to date",
     args: t.optional(
@@ -74,7 +74,7 @@ export class DrizzleCommands {
         ).catch(() => null);
 
         if (!journalFile) {
-          this.log.info(`No migration journal found.`);
+          this.log.info("No migration journal found.");
           return;
         }
 
@@ -130,14 +130,8 @@ export class DrizzleCommands {
 
   /**
    * Generate database migration files
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions based on the current database schema.
-   * - Writes these definitions to a temporary schema file. (node_modules/.db/entities.ts)
-   * - Invokes Drizzle Kit's CLI to generate migration files based on the current schema.
    */
-  generate = $command({
+  protected readonly generate = $command({
     name: "generate",
     description: "Generate migration files based on current database schema",
     summary: false,
@@ -175,13 +169,8 @@ export class DrizzleCommands {
 
   /**
    * Push database schema changes directly to the database
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions and Drizzle config.
-   * - Invokes Drizzle Kit's push command to apply schema changes directly.
    */
-  push = $command({
+  protected readonly push = $command({
     name: "push",
     description: "Push database schema changes directly to the database",
     summary: false,
@@ -207,13 +196,8 @@ export class DrizzleCommands {
 
   /**
    * Apply pending database migrations
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions and Drizzle config.
-   * - Invokes Drizzle Kit's migrate command to apply pending migrations.
    */
-  migrate = $command({
+  protected readonly migrate = $command({
     name: "migrate",
     description: "Apply pending database migrations",
     summary: false,
@@ -239,13 +223,8 @@ export class DrizzleCommands {
 
   /**
    * Launch Drizzle Studio database browser
-   *
-   * - Loads the Alepha instance from the specified entry file.
-   * - Retrieves all repository primitives to gather database models.
-   * - Creates temporary entity definitions and Drizzle config.
-   * - Invokes Drizzle Kit's studio command to launch the web-based database browser.
    */
-  studio = $command({
+  protected readonly studio = $command({
     name: "studio",
     description: "Launch Drizzle Studio database browser",
     summary: false,
@@ -272,7 +251,7 @@ export class DrizzleCommands {
   /**
    * Parent command for database operations.
    */
-  db = $command({
+  public readonly db = $command({
     name: "db",
     description: "Database management commands",
     children: [this.check, this.generate, this.push, this.migrate, this.studio],
@@ -283,11 +262,6 @@ export class DrizzleCommands {
 
   /**
    * Run a drizzle-kit command for all database providers in an Alepha instance.
-   *
-   * Iterates through all repository providers, prepares Drizzle config for each,
-   * and executes the specified drizzle-kit command.
-   *
-   * @param options - Configuration including command to run, flags, and logging
    */
   public async runDrizzleKitCommand(options: {
     root: string;
@@ -365,12 +339,6 @@ export class DrizzleCommands {
 
   /**
    * Prepare Drizzle configuration files for a database provider.
-   *
-   * Creates temporary entities.js and drizzle.config.js files needed
-   * for Drizzle Kit commands to run properly.
-   *
-   * @param options - Configuration options including kit, provider info, and paths
-   * @returns Path to the generated drizzle.config.js file
    */
   public async prepareDrizzleConfig(options: {
     kit: any;
@@ -473,79 +441,4 @@ export class DrizzleCommands {
       options.rootDir,
     );
   }
-
-  // /**
-  //  * Drop database schema (development only)
-  //  *
-  //  * @experimental
-  //  */
-  // drop = $command({
-  //   name: "db:drop",
-  //   description: "Drop database schema (development only)",
-  //   summary: false,
-  //   args: t.optional(
-  //     t.text({
-  //       title: "path",
-  //       description: "Path to the Alepha server entry file",
-  //     }),
-  //   ),
-  //   flags: drizzleCommandFlags,
-  //   handler: async ({ flags }) => {
-  //     // TODO: Implement db:drop
-  //     this.log.warn("db:drop is not yet implemented");
-  //     if (flags.provider) {
-  //       this.log.info(`Provider filter: ${flags.provider}`);
-  //     }
-  //   },
-  // });
-  //
-  // /**
-  //  * Seed database with initial data
-  //  *
-  //  * @experimental
-  //  */
-  // seed = $command({
-  //   name: "db:seed",
-  //   description: "Seed database with initial data",
-  //   summary: false,
-  //   args: t.optional(
-  //     t.text({
-  //       title: "path",
-  //       description: "Path to the Alepha server entry file",
-  //     }),
-  //   ),
-  //   flags: drizzleCommandFlags,
-  //   handler: async ({ flags }) => {
-  //     // TODO: Implement db:seed
-  //     this.log.warn("db:seed is not yet implemented");
-  //     if (flags.provider) {
-  //       this.log.info(`Provider filter: ${flags.provider}`);
-  //     }
-  //   },
-  // });
-  //
-  // /**
-  //  * Show pending database migrations status
-  //  *
-  //  * @experimental
-  //  */
-  // status = $command({
-  //   name: "db:status",
-  //   description: "Show pending database migrations status",
-  //   summary: false,
-  //   args: t.optional(
-  //     t.text({
-  //       title: "path",
-  //       description: "Path to the Alepha server entry file",
-  //     }),
-  //   ),
-  //   flags: drizzleCommandFlags,
-  //   handler: async ({ flags }) => {
-  //     // TODO: Implement db:status
-  //     this.log.warn("db:status is not yet implemented");
-  //     if (flags.provider) {
-  //       this.log.info(`Provider filter: ${flags.provider}`);
-  //     }
-  //   },
-  // });
 }

package/src/cli/commands/{DeployCommands.ts → deploy.ts}

@@ -4,7 +4,7 @@ import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
-export class DeployCommands {
+export class DeployCommand {
   protected readonly log = $logger();
   protected readonly utils = $inject(AlephaCliUtils);
 

package/src/cli/commands/dev.ts

@@ -0,0 +1,57 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { $inject, t } from "alepha";
+import { $command } from "alepha/command";
+import { $logger } from "alepha/logger";
+import { boot } from "alepha/vite";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class DevCommand {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(AlephaCliUtils);
+
+  /**
+   * 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.
+   */
+  public readonly dev = $command({
+    name: "dev",
+    description: "Run the project in development mode",
+    args: t.optional(t.text({ title: "path", description: "Filepath to run" })),
+    handler: async ({ args, root }) => {
+      const expo = await this.utils.hasExpo(root);
+
+      await this.utils.ensureConfig(root, {
+        viteConfigTs: !expo,
+        tsconfigJson: true,
+      });
+
+      if (expo) {
+        await this.utils.exec("expo start");
+        return;
+      }
+
+      const entry = await boot.getServerEntry(root, args);
+      this.log.trace("Entry file found", { entry });
+
+      try {
+        await access(join(root, "index.html"));
+      } catch {
+        this.log.trace("No index.html found, running entry file with tsx");
+        let cmd = "tsx --watch";
+        if (await this.utils.exists(root, ".env")) {
+          cmd += " --env-file=./.env";
+        }
+        cmd += ` ${entry}`;
+        await this.utils.exec(cmd);
+        return;
+      }
+
+      // Ensure vite is installed before running
+      await this.utils.ensureDependency(root, "vite");
+      await this.utils.exec("vite");
+    },
+  });
+}

package/src/cli/commands/format.ts

@@ -0,0 +1,17 @@
+import { $inject } from "alepha";
+import { $command } from "alepha/command";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class FormatCommand {
+  protected readonly utils = $inject(AlephaCliUtils);
+
+  public readonly format = $command({
+    name: "format",
+    description: "Format the codebase using Biome",
+    handler: async ({ root }) => {
+      await this.utils.ensureConfig(root, { biomeJson: true });
+      await this.utils.ensureDependency(root, "@biomejs/biome");
+      await this.utils.exec("biome format --fix");
+    },
+  });
+}

package/src/cli/commands/{CoreCommands.ts → init.ts}

@@ -1,48 +1,10 @@
 import { $inject, t } from "alepha";
-import { $command, CliProvider } from "alepha/command";
-import { $logger } from "alepha/logger";
+import { $command } from "alepha/command";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
-import { version } from "../version.ts";
 
-export class CoreCommands {
-  protected readonly log = $logger();
-  protected readonly cli = $inject(CliProvider);
+export class InitCommand {
   protected readonly utils = $inject(AlephaCliUtils);
 
-  /**
-   * Called when no command is provided
-   */
-  public readonly root = $command({
-    root: true,
-    flags: t.object({
-      version: t.optional(
-        t.boolean({
-          description: "Show Alepha CLI version",
-          aliases: ["v"],
-        }),
-      ),
-    }),
-    handler: async ({ flags }) => {
-      if (flags.version) {
-        this.log.info(version);
-        return;
-      }
-
-      this.cli.printHelp();
-    },
-  });
-
-  /**
-   * Clean the project, removing the "dist" directory
-   */
-  public readonly clean = $command({
-    name: "clean",
-    description: "Clean the project",
-    handler: async ({ run }) => {
-      await run.rm("./dist");
-    },
-  });
-
   /**
    * Ensure the project has the necessary Alepha configuration files.
    * Add the correct dependencies to package.json and install them.

package/src/cli/commands/lint.ts

@@ -0,0 +1,17 @@
+import { $inject } from "alepha";
+import { $command } from "alepha/command";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class LintCommand {
+  protected readonly utils = $inject(AlephaCliUtils);
+
+  public readonly lint = $command({
+    name: "lint",
+    description: "Run linter across the codebase using Biome",
+    handler: async ({ root }) => {
+      await this.utils.ensureConfig(root, { biomeJson: true });
+      await this.utils.ensureDependency(root, "@biomejs/biome");
+      await this.utils.exec("biome check --formatter-enabled=false --fix");
+    },
+  });
+}

package/src/cli/commands/root.ts

@@ -0,0 +1,32 @@
+import { $inject, t } from "alepha";
+import { $command, CliProvider } from "alepha/command";
+import { $logger } from "alepha/logger";
+import { version } from "../version.ts";
+
+export class RootCommand {
+  protected readonly log = $logger();
+  protected readonly cli = $inject(CliProvider);
+
+  /**
+   * Called when no command is provided
+   */
+  public readonly root = $command({
+    root: true,
+    flags: t.object({
+      version: t.optional(
+        t.boolean({
+          description: "Show Alepha CLI version",
+          aliases: ["v"],
+        }),
+      ),
+    }),
+    handler: async ({ flags }) => {
+      if (flags.version) {
+        this.log.info(version);
+        return;
+      }
+
+      this.cli.printHelp();
+    },
+  });
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,24 @@
+import { $inject, t } from "alepha";
+import { $command } from "alepha/command";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class RunCommand {
+  protected readonly utils = $inject(AlephaCliUtils);
+
+  public readonly 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}`);
+    },
+  });
+}

package/src/cli/commands/test.ts

@@ -0,0 +1,42 @@
+import { $inject, t } from "alepha";
+import { $command } from "alepha/command";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class TestCommand {
+  protected readonly utils = $inject(AlephaCliUtils);
+
+  public readonly test = $command({
+    name: "test",
+    description: "Run tests using Vitest",
+    flags: t.object({
+      config: t.optional(
+        t.string({
+          description: "Path to Vitest config file",
+          alias: "c",
+        }),
+      ),
+    }),
+    env: t.object({
+      VITEST_ARGS: t.optional(
+        t.string({
+          default: "",
+          description:
+            "Additional arguments to pass to Vitest. E.g., --coverage",
+        }),
+      ),
+    }),
+    handler: async ({ root, flags, env }) => {
+      await this.utils.ensureConfig(root, {
+        tsconfigJson: true,
+        viteConfigTs: true,
+      });
+
+      // Ensure vitest is installed before running
+      await this.utils.ensureDependency(root, "vitest");
+
+      const config = flags.config ? `--config=${flags.config}` : "";
+
+      await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
+    },
+  });
+}