alepha 0.14.1 → 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/{ChangelogCommands.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);
 
@@ -45,23 +45,22 @@ export interface Commit {
 interface ChangelogEntry {
   features: Commit[];
   fixes: Commit[];
-  breaking: Commit[];
 }
 
 // =============================================================================
-// CHANGELOG COMMANDS
+// CHANGELOG COMMAND
 // =============================================================================
 
 /**
  * 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 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;
   }
 
   /**
@@ -181,7 +166,7 @@ export class ChangelogCommands {
   // 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/{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.
@@ -99,6 +61,8 @@ export class CoreCommands {
       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/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,41 @@
+import { $inject, Alepha, t } from "alepha";
+import { $command, CliProvider } from "alepha/command";
+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
+   */
+  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(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;
+      }
+
+      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}`);
+    },
+  });
+}