alepha 0.14.2 → 0.14.3

package/src/cli/commands/gen/changelog.spec.ts

@@ -0,0 +1,315 @@
+import { Alepha } from "alepha";
+import { cliOptions } from "alepha/command";
+import {
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "alepha/logger";
+import { describe, expect, test } from "vitest";
+import {
+  ChangelogCommand,
+  changelogOptions,
+  GitMessageParser,
+  GitProvider,
+} from "./changelog.ts";
+
+// =============================================================================
+// MOCK GIT PROVIDER
+// =============================================================================
+
+let currentMockResponses: Map<string, string> | null = null;
+
+class MockGitProvider extends GitProvider {
+  override async exec(cmd: string, _cwd: string): Promise<string> {
+    if (!currentMockResponses) {
+      throw new Error("No git mocks configured");
+    }
+    const response = currentMockResponses.get(cmd);
+    if (response === undefined) {
+      throw new Error(`Unmocked git command: ${cmd}`);
+    }
+    return response;
+  }
+}
+
+function setMockGitResponses(
+  mocks: Array<{ cmd: string; response: string }>,
+): void {
+  currentMockResponses = new Map<string, string>();
+  for (const { cmd, response } of mocks) {
+    currentMockResponses.set(cmd, response);
+  }
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+describe("changelog", () => {
+  describe("GitMessageParser.parseCommit", () => {
+    const defaultConfig = { ignore: ["chore", "ci", "build", "test"] };
+
+    const getParser = () => {
+      const alepha = Alepha.create();
+      return alepha.inject(GitMessageParser);
+    };
+
+    test("should parse conventional commit with scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "abc12345 feat(ui): add button component",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "abc12345",
+        type: "feat",
+        scope: "ui",
+        description: "add button component",
+        breaking: false,
+      });
+    });
+
+    test("should ignore conventional commit without scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "def45678 fix: resolve memory leak",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should detect breaking change with ! marker", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "aaa78901 feat(api)!: remove deprecated endpoint",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "aaa78901",
+        type: "feat",
+        scope: "api",
+        description: "remove deprecated endpoint",
+        breaking: true,
+      });
+    });
+
+    test("should detect breaking change in description", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "bbb01234 feat(auth): breaking change to token format",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "bbb01234",
+        type: "feat",
+        scope: "auth",
+        description: "breaking change to token format",
+        breaking: true,
+      });
+    });
+
+    test("should ignore commits with ignored scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "ccc34567 feat(chore): update deps",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should ignore commits with nested ignored scope", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "ddd67890 feat(test/unit): add tests",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should ignore module-style commits (no type)", () => {
+      const parser = getParser();
+      const result = parser.parseCommit("eee90123 cli: add new command", {});
+      expect(result).toBeNull();
+    });
+
+    test("should return null for non-matching commits", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "fff78901 random commit message",
+        defaultConfig,
+      );
+      expect(result).toBeNull();
+    });
+
+    test("should truncate hash to 8 characters", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "abcdef1234567890 feat(core): something",
+        defaultConfig,
+      );
+      expect(result?.hash).toBe("abcdef12");
+    });
+
+    test("should parse all supported types", () => {
+      const parser = getParser();
+      const types = ["feat", "fix", "docs", "refactor", "perf", "revert"];
+
+      for (const type of types) {
+        const result = parser.parseCommit(
+          `abc12345 ${type}(core): test`,
+          defaultConfig,
+        );
+        expect(result?.type).toBe(type);
+      }
+    });
+
+    test("should handle nested scopes", () => {
+      const parser = getParser();
+      const result = parser.parseCommit(
+        "abc12345 feat(api/users): add endpoint",
+        defaultConfig,
+      );
+
+      expect(result).toEqual({
+        hash: "abc12345",
+        type: "feat",
+        scope: "api/users",
+        description: "add endpoint",
+        breaking: false,
+      });
+    });
+  });
+
+  describe("changelogOptions atom", () => {
+    test("should have default ignore list", async () => {
+      const alepha = Alepha.create();
+      await alepha.start();
+
+      const config = alepha.store.get(changelogOptions);
+      expect(config.ignore).toContain("chore");
+      expect(config.ignore).toContain("ci");
+      expect(config.ignore).toContain("build");
+      expect(config.ignore).toContain("test");
+    });
+
+    test("should allow custom configuration", async () => {
+      const alepha = Alepha.create();
+      alepha.set(changelogOptions, {
+        ignore: ["custom", "internal"],
+      });
+      await alepha.start();
+
+      const config = alepha.store.get(changelogOptions);
+      expect(config.ignore).toEqual(["custom", "internal"]);
+    });
+  });
+
+  describe("changelog command", () => {
+    const setupCommand = async (
+      gitMocks: { cmd: string; response: string }[],
+      argv: string[] = ["changelog"],
+      options?: { ignore?: string[] },
+    ) => {
+      setMockGitResponses(gitMocks);
+
+      const alepha = Alepha.create()
+        .with({
+          provide: LogDestinationProvider,
+          use: MemoryDestinationProvider,
+        })
+        .with({ provide: GitProvider, use: MockGitProvider })
+        .with(ChangelogCommand);
+
+      alepha.store.mut(cliOptions, (old) => ({
+        ...old,
+        argv,
+      }));
+
+      if (options) {
+        alepha.set(changelogOptions, options);
+      }
+
+      await alepha.start();
+
+      return {
+        alepha,
+        logger: alepha.inject(MemoryDestinationProvider),
+      };
+    };
+
+    test("should show changes since latest tag", async () => {
+      await setupCommand([
+        { cmd: "tag --sort=-version:refname", response: "1.0.0\n0.9.0\n" },
+        {
+          cmd: "log 1.0.0..HEAD --oneline",
+          response: [
+            "abc12345 feat(ui): add dashboard",
+            "def56789 fix(core): resolve crash",
+          ].join("\n"),
+        },
+      ]);
+      // Outputs to stdout - test verifies no error
+    });
+
+    test("should show changes from specified version", async () => {
+      await setupCommand(
+        [
+          {
+            cmd: "log 0.5.0..HEAD --oneline",
+            response: "abc12345 feat(api): new feature",
+          },
+        ],
+        ["changelog", "--from=0.5.0"],
+      );
+      // Outputs to stdout - test verifies no error
+    });
+
+    test("should handle no tags found", async () => {
+      await setupCommand([
+        { cmd: "tag --sort=-version:refname", response: "" },
+      ]);
+      // Should output "No version tags found" - no error
+    });
+
+    test("should handle no changes since tag", async () => {
+      await setupCommand([
+        { cmd: "tag --sort=-version:refname", response: "1.0.0\n" },
+        { cmd: "log 1.0.0..HEAD --oneline", response: "" },
+      ]);
+      // Should output "No changes since 1.0.0" - no error
+    });
+
+    test("should filter commits by ignore list", async () => {
+      await setupCommand(
+        [
+          { cmd: "tag --sort=-version:refname", response: "1.0.0\n" },
+          {
+            cmd: "log 1.0.0..HEAD --oneline",
+            response: [
+              "abc12345 feat(ui): add dashboard",
+              "def56789 feat(internal): should be filtered",
+            ].join("\n"),
+          },
+        ],
+        ["changelog"],
+        { ignore: ["internal"] },
+      );
+      // "feat(internal)" is filtered out
+    });
+
+    test("should use -f alias for --from", async () => {
+      await setupCommand(
+        [
+          {
+            cmd: "log 0.8.0..HEAD --oneline",
+            response: "abc12345 feat(cli): new command",
+          },
+        ],
+        ["changelog", "-f=0.8.0"],
+      );
+      // Outputs to stdout - test verifies no error
+    });
+  });
+});

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

@@ -3,15 +3,15 @@ import { promisify } from "node:util";
 import { $inject, $use, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
-import { changelogOptions } from "../atoms/changelogOptions.ts";
-import { GitMessageParser } from "../services/GitMessageParser.ts";
+import { changelogOptions } from "../../atoms/changelogOptions.ts";
+import { GitMessageParser } from "../../services/GitMessageParser.ts";
 
 export {
   type ChangelogOptions,
   changelogOptions,
   DEFAULT_IGNORE,
-} from "../atoms/changelogOptions.ts";
-export { GitMessageParser } from "../services/GitMessageParser.ts";
+} from "../../atoms/changelogOptions.ts";
+export { GitMessageParser } from "../../services/GitMessageParser.ts";
 
 const execAsync = promisify(exec);
 
@@ -55,10 +55,10 @@ interface ChangelogEntry {
  * Changelog command for generating release notes from git commits.
  *
  * Usage:
- * - `alepha changelog` - Show unreleased changes since latest tag to HEAD
- * - `alepha changelog --from=1.0.0` - Show changes from version to HEAD
- * - `alepha changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
- * - `alepha changelog | tee -a CHANGELOG.md` - Append to file
+ * - `alepha gen changelog` - Show unreleased changes since latest tag to HEAD
+ * - `alepha gen changelog --from=1.0.0` - Show changes from version to HEAD
+ * - `alepha gen changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
+ * - `alepha gen changelog | tee -a CHANGELOG.md` - Append to file
  */
 export class ChangelogCommand {
   protected readonly log = $logger();
@@ -166,7 +166,7 @@ export class ChangelogCommand {
   // COMMAND
   // ---------------------------------------------------------------------------
 
-  public readonly changelog = $command({
+  public readonly command = $command({
     name: "changelog",
     description:
       "Generate changelog from conventional commits (outputs to stdout)",

package/src/cli/commands/gen/openapi.ts

@@ -0,0 +1,71 @@
+import { $inject, t } from "alepha";
+import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
+import { $logger } from "alepha/logger";
+import { ServerSwaggerProvider } from "alepha/server/swagger";
+import { AlephaCliUtils } from "../../services/AlephaCliUtils.ts";
+
+export class OpenApiCommand {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly fs = $inject(FileSystemProvider);
+
+  public readonly command = $command({
+    name: "openapi",
+    description: "Generate OpenAPI specification from actions",
+    flags: t.object({
+      out: t.optional(
+        t.text({
+          aliases: ["o"],
+          description: "Output file path",
+        }),
+      ),
+    }),
+    handler: async ({ root, flags }) => {
+      const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+
+      try {
+        const openapiProvider = alepha.inject(
+          ServerSwaggerProvider,
+        ) as ServerSwaggerProvider;
+
+        await alepha.events.emit("configure", alepha);
+
+        let json: any = openapiProvider.json;
+
+        if (!json) {
+          json = openapiProvider.generateSwaggerDoc({
+            info: {
+              title: "API Documentation",
+              version: "1.0.0",
+            },
+          });
+        }
+
+        if (!json) {
+          this.log.error("No actions found to generate OpenAPI specification.");
+          return;
+        }
+
+        if (flags.out) {
+          await this.fs.writeFile(
+            this.fs.join(root, flags.out),
+            JSON.stringify(json, null, 2),
+          );
+        } else {
+          this.log.info(JSON.stringify(json, null, 2));
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("Service not found")) {
+          this.log.error(
+            "Missing $swagger() primitive in your server configuration.",
+          );
+          return;
+        }
+
+        this.log.error(`OpenAPI generation failed - ${message}`, { err });
+      }
+    },
+  });
+}

package/src/cli/commands/gen.ts

@@ -0,0 +1,18 @@
+import { $inject } from "alepha";
+import { $command } from "alepha/command";
+import { ChangelogCommand } from "./gen/changelog.ts";
+import { OpenApiCommand } from "./gen/openapi.ts";
+
+export class GenCommand {
+  protected readonly changelog = $inject(ChangelogCommand);
+  protected readonly openapi = $inject(OpenApiCommand);
+
+  public readonly gen = $command({
+    name: "gen",
+    description: "Generate code, documentation, ...",
+    children: [this.changelog.command, this.openapi.command],
+    handler: async ({ help }) => {
+      help();
+    },
+  });
+}

package/src/cli/commands/init.ts

@@ -61,6 +61,8 @@ export class InitCommand {
       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 {

package/src/cli/commands/root.ts

@@ -1,11 +1,13 @@
-import { $inject, t } from "alepha";
+import { $inject, Alepha, t } from "alepha";
 import { $command, CliProvider } from "alepha/command";
-import { $logger } from "alepha/logger";
+import { $logger, ConsoleColorProvider } from "alepha/logger";
 import { version } from "../version.ts";
 
 export class RootCommand {
   protected readonly log = $logger();
   protected readonly cli = $inject(CliProvider);
+  protected readonly alepha = $inject(Alepha);
+  protected readonly color = $inject(ConsoleColorProvider);
 
   /**
    * Called when no command is provided
@@ -22,7 +24,14 @@ export class RootCommand {
     }),
     handler: async ({ flags }) => {
       if (flags.version) {
-        this.log.info(version);
+        this.log.info(this.color.set("WHITE_BOLD", `Alepha v${version}`));
+        if (this.alepha.isBun()) {
+          this.log.info(this.color.set("GREY_DARK", `└─ Bun v${Bun.version}`));
+        } else {
+          this.log.info(
+            this.color.set("GREY_DARK", `└─ Node ${process.version}`),
+          );
+        }
         return;
       }
 

package/src/cli/commands/typecheck.ts

@@ -1,19 +1,24 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
+import { $logger } from "alepha/logger";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 export class TypecheckCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly log = $logger();
 
   /**
    * Run TypeScript type checking across the codebase with no emit.
    */
   public readonly typecheck = $command({
     name: "typecheck",
+    aliases: ["tc"],
     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.utils.exec("tsc --noEmit");
+      this.log.info("TypeScript type checking completed successfully.");
     },
   });
 }

package/src/cli/index.ts

@@ -2,12 +2,13 @@ export * from "./apps/AlephaCli.ts";
 export * from "./apps/AlephaPackageBuilderCli.ts";
 export * from "./atoms/changelogOptions.ts";
 export * from "./commands/build.ts";
-export * from "./commands/changelog.ts";
 export * from "./commands/clean.ts";
 export * from "./commands/db.ts";
 export * from "./commands/deploy.ts";
 export * from "./commands/dev.ts";
 export * from "./commands/format.ts";
+export * from "./commands/gen/changelog.ts";
+export * from "./commands/gen/openapi.ts";
 export * from "./commands/init.ts";
 export * from "./commands/lint.ts";
 export * from "./commands/root.ts";

package/src/cli/services/AlephaCliUtils.ts

@@ -6,7 +6,6 @@ import { EnvUtils, type RunnerMethod } from "alepha/command";
 import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import { boot } from "alepha/vite";
-import { tsImport } from "tsx/esm/api";
 import { appRouterTs } from "../assets/appRouterTs.ts";
 import { biomeJson } from "../assets/biomeJson.ts";
 import { dummySpecTs } from "../assets/dummySpecTs.ts";
@@ -32,6 +31,7 @@ export class AlephaCliUtils {
   protected readonly log = $logger();
   protected readonly fs = $inject(FileSystemProvider);
   protected readonly envUtils = $inject(EnvUtils);
+  protected readonly alepha = $inject(Alepha);
 
   /**
    * Execute a command using npx with inherited stdio.
@@ -142,6 +142,40 @@ export class AlephaCliUtils {
   // Package Manager & Project Setup
   // ===================================================================================================================
 
+  public async removeFiles(root: string, files: string[]): Promise<void> {
+    await Promise.all(
+      files.map((file) =>
+        this.fs.rm(join(root, file), { force: true, recursive: true }),
+      ),
+    );
+  }
+
+  public async removeYarn(root: string): Promise<void> {
+    await this.removeFiles(root, [".yarn", ".yarnrc.yml", ".yarn"]);
+  }
+
+  public async removePnpm(root: string): Promise<void> {
+    await this.removeFiles(root, ["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
+  }
+
+  public async removeNpm(root: string): Promise<void> {
+    await this.removeFiles(root, ["package-lock.json"]);
+  }
+
+  public async removeBun(root: string): Promise<void> {
+    await this.removeFiles(root, ["bun.lockb"]);
+  }
+
+  public async removeAllPmFilesExcept(
+    root: string,
+    except: string,
+  ): Promise<void> {
+    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.
    *
@@ -157,25 +191,19 @@ export class AlephaCliUtils {
       false,
     );
 
-    // remove lock files from other package managers
-    await this.fs.rm(join(root, "package-lock.json"), { force: true });
-    await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
+    await this.removeAllPmFilesExcept(root, "yarn");
+  }
+
+  public async ensureBun(root: string): Promise<void> {
+    await this.removeAllPmFilesExcept(root, "bun");
   }
 
   public async ensurePnpm(root: string): Promise<void> {
-    // remove lock files from other package managers
-    await this.fs.rm(join(root, "package-lock.json"), { force: true });
-    await this.fs.rm(join(root, "yarn.lock"), { force: true });
-    await this.fs.rm(join(root, ".yarn"), { force: true, recursive: true });
-    await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+    await this.removeAllPmFilesExcept(root, "pnpm");
   }
 
   public async ensureNpm(root: string): Promise<void> {
-    // remove lock files from other package managers
-    await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
-    await this.fs.rm(join(root, "yarn.lock"), { force: true });
-    await this.fs.rm(join(root, ".yarn"), { force: true, recursive: true });
-    await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+    await this.removeAllPmFilesExcept(root, "npm");
   }
 
   /**
@@ -436,9 +464,10 @@ export class AlephaCliUtils {
     process.env.ALEPHA_CLI_IMPORT = "true";
 
     const entry = await boot.getServerEntry(rootDir, explicitEntry);
-    const mod = await tsImport(entry, {
-      parentURL: import.meta.url,
-    });
+
+    delete (global as any).__alepha;
+
+    const mod = await import(entry);
 
     this.log.debug(`Load entry: ${entry}`);
 
@@ -523,6 +552,9 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
     if (flags?.bun) {
       return "bun";
     }
+    if (this.alepha.isBun()) {
+      return "bun";
+    }
     if (await this.checkFileExists(root, "yarn.lock", true)) {
       return "yarn";
     }
@@ -659,6 +691,27 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
     return this.hasDependency(root, "expo");
   }
 
+  async getInstallCommand(root: string, packageName: string, dev = true) {
+    const pm = await this.getPackageManager(root);
+    let cmd: string;
+
+    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();
+  }
+
   /**
    * Install a dependency if it's missing from the project.
    *
@@ -677,21 +730,7 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
       return;
     }
 
-    const pm = await this.getPackageManager(root);
-    let cmd: string;
-
-    switch (pm) {
-      case "yarn":
-        cmd = `yarn add ${dev ? "-D" : ""} ${packageName}`;
-        break;
-      case "pnpm":
-        cmd = `pnpm add ${dev ? "-D" : ""} ${packageName}`;
-        break;
-      default:
-        cmd = `npm install ${dev ? "--save-dev" : ""} ${packageName}`;
-    }
-
-    cmd = cmd.replace(/\s+/g, " ").trim();
+    const cmd = await this.getInstallCommand(root, packageName, dev);
 
     if (options.run) {
       // if it's during a Runner flow, just use the runner's run method