alepha 0.13.8 → 0.14.1

package/src/cli/apps/AlephaCli.ts

@@ -2,7 +2,9 @@ import { join } from "node:path";
 import { $hook, $inject, $module, Alepha } from "alepha";
 import { FileSystemProvider } from "alepha/file";
 import { BiomeCommands } from "../commands/BiomeCommands.ts";
+import { ChangelogCommands } from "../commands/ChangelogCommands.ts";
 import { CoreCommands } from "../commands/CoreCommands.ts";
+import { DeployCommands } from "../commands/DeployCommands.ts";
 import { DrizzleCommands } from "../commands/DrizzleCommands.ts";
 import { VerifyCommands } from "../commands/VerifyCommands.ts";
 import { ViteCommands } from "../commands/ViteCommands.ts";
@@ -14,7 +16,8 @@ class AlephaCliExtension {
   protected readonly onConfigure = $hook({
     on: "configure",
     handler: async () => {
-      const extensionPath = join(process.cwd(), "alepha.config.ts");
+      const root = process.cwd();
+      const extensionPath = join(root, "alepha.config.ts");
       const hasExtension = await this.fs.exists(extensionPath);
       if (!hasExtension) {
         return;
@@ -26,7 +29,9 @@ class AlephaCliExtension {
         return;
       }
 
-      this.alepha.with(Extension);
+      this.alepha.inject(Extension, {
+        args: [this.alepha],
+      });
     },
   });
 }
@@ -35,10 +40,12 @@ export const AlephaCli = $module({
   name: "alepha.cli",
   services: [
     AlephaCliExtension,
+    BiomeCommands,
+    ChangelogCommands,
     CoreCommands,
+    DeployCommands,
     DrizzleCommands,
     VerifyCommands,
     ViteCommands,
-    BiomeCommands,
   ],
 });

package/src/cli/apps/AlephaPackageBuilderCli.ts

@@ -79,14 +79,17 @@ export class AlephaPackageBuilderCli {
         JSON.stringify(modules, null, 2),
       );
 
-      const external = [
-        "alepha",
-        packageName,
-        ...modules.map(
-          (item) =>
-            `${packageName}/${item.name.replace("-", "/").replace("/core", "")}`,
-        ),
-      ];
+      const tsconfig = await readFile(
+        join(root, "../../tsconfig.json"),
+        "utf-8",
+      );
+
+      const external: string[] = Object.keys(
+        JSON.parse(tsconfig).compilerOptions.paths,
+      );
+
+      external.push("bun");
+      external.push("bun:sqlite");
 
       await run.rm(this.dist);
 
@@ -103,6 +106,10 @@ export class AlephaPackageBuilderCli {
           fixedExtension: false,
           platform: "node", // TODO: node must be enabled only if index.node.ts exists
           external,
+          dts: {
+            sourcemap: true,
+            resolve: false,
+          },
         });
 
         if (item.native) {

package/src/cli/assets/mainTs.ts

@@ -1,14 +1,13 @@
 export const mainTs = () => `
-import { Alepha, run } from "alepha";
-import { $logger } from "alepha/logger";
+import { run } from "alepha";
+import { $route } from "alepha/server";
 
-const alepha = Alepha.create();
+class App {
+  root = $route({
+    path: "/",
+    handler: () => "Hello, Alepha!",
+  });
+}
 
-alepha.with(() => {
-  const log = $logger();
-
-  log.info("Hello from Alepha!");
-});
-
-run(alepha);
+run(App);
 `.trim();

package/src/cli/atoms/changelogOptions.ts

@@ -0,0 +1,45 @@
+import { $atom, type Static, t } from "alepha";
+
+/**
+ * Default scopes to ignore in changelog generation.
+ * Commits with these scopes won't appear in release notes.
+ */
+export const DEFAULT_IGNORE = [
+  "project",
+  "release",
+  "starter",
+  "example",
+  "chore",
+  "ci",
+  "build",
+  "test",
+  "style",
+];
+
+/**
+ * Changelog configuration atom.
+ *
+ * Configure in `alepha.config.ts`:
+ * ```ts
+ * import { changelogOptions } from "alepha/cli";
+ *
+ * alepha.set(changelogOptions, {
+ *   ignore: ["project", "release", "chore", "docs"],
+ * });
+ * ```
+ */
+export const changelogOptions = $atom({
+  name: "alepha.changelog",
+  schema: t.object({
+    /**
+     * Scopes to ignore (e.g., "project", "release", "chore").
+     * Commits like `feat(chore): ...` will be excluded from changelog.
+     */
+    ignore: t.optional(t.array(t.string())),
+  }),
+  default: {
+    ignore: DEFAULT_IGNORE,
+  },
+});
+
+export type ChangelogOptions = Static<typeof changelogOptions.schema>;

package/src/cli/commands/ChangelogCommands.ts

@@ -0,0 +1,259 @@
+import { exec } from "node:child_process";
+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";
+
+export {
+  type ChangelogOptions,
+  changelogOptions,
+  DEFAULT_IGNORE,
+} from "../atoms/changelogOptions.ts";
+export { GitMessageParser } from "../services/GitMessageParser.ts";
+
+const execAsync = promisify(exec);
+
+// =============================================================================
+// GIT PROVIDER
+// =============================================================================
+
+/**
+ * Git provider for executing git commands.
+ * Can be substituted in tests with a mock implementation.
+ */
+export class GitProvider {
+  async exec(cmd: string, cwd: string): Promise<string> {
+    const { stdout } = await execAsync(`git ${cmd}`, { cwd });
+    return stdout;
+  }
+}
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+export interface Commit {
+  hash: string;
+  type: string;
+  scope: string | null;
+  description: string;
+  breaking: boolean;
+}
+
+interface ChangelogEntry {
+  features: Commit[];
+  fixes: Commit[];
+  breaking: Commit[];
+}
+
+// =============================================================================
+// CHANGELOG COMMANDS
+// =============================================================================
+
+/**
+ * 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
+ */
+export class ChangelogCommands {
+  protected readonly log = $logger();
+  protected readonly git = $inject(GitProvider);
+  protected readonly parser = $inject(GitMessageParser);
+  protected readonly config = $use(changelogOptions);
+
+  // ---------------------------------------------------------------------------
+  // FORMATTING
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Format a single commit line.
+   * Example: `- **cli**: add new command (\`abc1234\`)`
+   */
+  protected formatCommit(commit: Commit): string {
+    return `- **${commit.scope}**: ${commit.description} (\`${commit.hash}\`)`;
+  }
+
+  /**
+   * Format the changelog entry with sections.
+   */
+  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) {
+        sections.push(this.formatCommit(commit));
+      }
+      sections.push("");
+    }
+
+    if (entry.fixes.length > 0) {
+      sections.push("### Bug Fixes\n");
+      for (const commit of entry.fixes) {
+        sections.push(this.formatCommit(commit));
+      }
+      sections.push("");
+    }
+
+    return sections.join("\n");
+  }
+
+  // ---------------------------------------------------------------------------
+  // PARSING
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Parse git log output into a changelog entry.
+   */
+  protected parseCommits(commitsOutput: string): ChangelogEntry {
+    const entry: ChangelogEntry = {
+      features: [],
+      fixes: [],
+      breaking: [],
+    };
+
+    for (const line of commitsOutput.trim().split("\n")) {
+      if (!line.trim()) continue;
+
+      const commit = this.parser.parseCommit(line, this.config);
+      if (!commit) {
+        this.log.trace("Skipping commit", { line });
+        continue;
+      }
+
+      this.log.trace("Parsed commit", { commit });
+
+      // Categorize commit
+      if (commit.breaking) {
+        entry.breaking.push(commit);
+      }
+      if (commit.type === "feat") {
+        entry.features.push(commit);
+      } else if (commit.type === "fix") {
+        entry.fixes.push(commit);
+      }
+    }
+
+    return entry;
+  }
+
+  /**
+   * 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
+    );
+  }
+
+  /**
+   * Get the latest version tag.
+   */
+  protected async getLatestTag(
+    git: (cmd: string) => Promise<string>,
+  ): Promise<string | null> {
+    const tagsOutput = await git("tag --sort=-version:refname");
+    const tags = tagsOutput
+      .trim()
+      .split("\n")
+      .filter((tag) => tag.match(/^\d+\.\d+\.\d+$/));
+
+    return tags[0] || null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // COMMAND
+  // ---------------------------------------------------------------------------
+
+  public readonly changelog = $command({
+    name: "changelog",
+    description:
+      "Generate changelog from conventional commits (outputs to stdout)",
+    flags: t.object({
+      /**
+       * Show changes from this ref (tag, commit, branch).
+       * Defaults to the latest version tag.
+       * Example: --from=1.0.0
+       */
+      from: t.optional(
+        t.string({
+          aliases: ["f"],
+          description: "Starting ref (default: latest tag)",
+        }),
+      ),
+      /**
+       * Show changes up to this ref (tag, commit, branch).
+       * Defaults to HEAD.
+       * Example: --to=main
+       */
+      to: t.optional(
+        t.string({
+          aliases: ["t"],
+          description: "Ending ref (default: HEAD)",
+        }),
+      ),
+    }),
+    handler: async ({ flags, root }) => {
+      const git = (cmd: string) => this.git.exec(cmd, root);
+
+      // Determine the starting point
+      let fromRef: string;
+
+      if (flags.from) {
+        // User specified a ref
+        fromRef = flags.from;
+        this.log.debug("Using specified from ref", { from: fromRef });
+      } else {
+        // Use latest tag
+        const latestTag = await this.getLatestTag(git);
+        if (!latestTag) {
+          process.stdout.write("No version tags found in repository\n");
+          return;
+        }
+        fromRef = latestTag;
+        this.log.debug("Using latest tag", { from: fromRef });
+      }
+
+      // Determine the ending point
+      const toRef = flags.to || "HEAD";
+      this.log.debug("Using to ref", { to: toRef });
+
+      // Get commits in range
+      const commitsOutput = await git(`log ${fromRef}..${toRef} --oneline`);
+
+      if (!commitsOutput.trim()) {
+        process.stdout.write(`No changes in range ${fromRef}..${toRef}\n`);
+        return;
+      }
+
+      // Parse and format
+      const entry = this.parseCommits(commitsOutput);
+
+      if (!this.hasChanges(entry)) {
+        process.stdout.write(
+          `No public changes in range ${fromRef}..${toRef}\n`,
+        );
+        return;
+      }
+
+      // Output the formatted changelog (no header - caller adds it if needed)
+      process.stdout.write(this.formatEntry(entry));
+    },
+  });
+}

package/src/cli/commands/DeployCommands.ts

@@ -0,0 +1,118 @@
+import { join } from "node:path";
+import { $inject, AlephaError, t } from "alepha";
+import { $command } from "alepha/command";
+import { $logger } from "alepha/logger";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+
+export class DeployCommands {
+  protected readonly log = $logger();
+  protected readonly utils = $inject(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
+   *       },
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  public readonly deploy = $command({
+    name: "deploy",
+    description:
+      "Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)",
+    mode: true,
+    flags: t.object({
+      build: t.boolean({
+        description: "Build the project before deployment",
+        default: false,
+      }),
+      migrate: t.boolean({
+        description:
+          "Run database migrations before deployment (if applicable)",
+        default: false,
+      }),
+    }),
+    env: t.object({
+      VERCEL_TOKEN: t.optional(
+        t.text({
+          description: "Vercel API token (e.g., xxxxxxxxxxxxxxxxxxxx)",
+        }),
+      ),
+      VERCEL_ORG_ID: t.optional(
+        t.text({
+          description: "Vercel organization ID (e.g., team_abc123...)",
+        }),
+      ),
+      VERCEL_PROJECT_ID: t.optional(
+        t.text({ description: "Vercel project ID (e.g., prj_abc123...)" }),
+      ),
+      CLOUDFLARE_API_TOKEN: t.optional(
+        t.text({
+          description: "Cloudflare API token (e.g., xxxx-xxxx-xxxx-xxxx)",
+        }),
+      ),
+      CLOUDFLARE_ACCOUNT_ID: t.optional(
+        t.text({
+          description: "Cloudflare account ID (e.g., abc123def456...)",
+        }),
+      ),
+    }),
+    handler: async ({ root, mode, flags }) => {
+      if (flags.build) {
+        await this.utils.exec("alepha build");
+      }
+
+      // Vercel deployment
+      if (await this.utils.exists(root, "dist/vercel.json")) {
+        if (flags.migrate) {
+          this.log.debug("Running database migrations before deployment...");
+          await this.utils.exec(`alepha db migrate --mode=${mode}`);
+        }
+        await this.utils.ensureDependency(root, "vercel", { dev: true });
+        const command =
+          `vercel . --cwd=dist ${mode === "production" ? "--prod" : ""}`.trim();
+        this.log.debug(`Deploying to Vercel with command: ${command}`);
+        await this.utils.exec(command);
+        return;
+      }
+
+      // Cloudflare deployment
+      if (await this.utils.exists(root, "dist/wrangler.jsonc")) {
+        if (flags.migrate) {
+          this.log.debug("Running database migrations before deployment...");
+          await this.utils.exec(`alepha db migrate --mode=${mode}`);
+        }
+        await this.utils.ensureDependency(root, "wrangler", { dev: true });
+        const command =
+          `wrangler deploy ${mode === "production" ? "" : "--env preview"} --config=dist/wrangler.jsonc`.trim();
+        this.log.info(`Deploying to Cloudflare with command: ${command}`);
+        await this.utils.exec(command);
+        return;
+      }
+
+      // Surge deployment
+      if (await this.utils.exists(root, "dist/public/404.html")) {
+        await this.utils.ensureDependency(root, "surge", { dev: true });
+        const distPath = join(root, "dist/public");
+        this.log.debug(`Deploying to Surge from directory: ${distPath}`);
+        await this.utils.exec(`surge ${distPath}`);
+        return;
+      }
+
+      throw new AlephaError(
+        "No deployment configuration found in the dist folder.",
+      );
+    },
+  });
+}