alepha 0.14.0 → 0.14.1

package/src/cli/commands/ChangelogCommands.ts

@@ -1,13 +1,40 @@
 import { exec } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import { promisify } from "node:util";
-import { t } from "alepha";
+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);
 
-interface Commit {
+// =============================================================================
+// 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;
@@ -16,374 +43,217 @@ interface Commit {
 }
 
 interface ChangelogEntry {
-  version: string;
-  date: string;
   features: Commit[];
   fixes: Commit[];
-  docs: Commit[];
-  improvements: Commit[];
   breaking: Commit[];
 }
 
-interface ChangelogConfig {
+// =============================================================================
+// 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
+  // ---------------------------------------------------------------------------
+
   /**
-   * Commit prefixes to ignore (e.g., "project", "release", "chore")
+   * Format a single commit line.
+   * Example: `- **cli**: add new command (\`abc1234\`)`
    */
-  ignore?: string[];
+  protected formatCommit(commit: Commit): string {
+    return `- **${commit.scope}**: ${commit.description} (\`${commit.hash}\`)`;
+  }
+
   /**
-   * Module scopes to recognize (e.g., "ui", "cli", "core")
-   * If not provided, all non-ignored scopes are included
+   * Format the changelog entry with sections.
    */
-  scopes?: string[];
-}
+  protected formatEntry(entry: ChangelogEntry): string {
+    const sections: string[] = [];
 
-const DEFAULT_IGNORE = [
-  "project",
-  "release",
-  "starter",
-  "example",
-  "chore",
-  "ci",
-  "build",
-  "test",
-  "style",
-];
-
-function parseCommit(line: string, config: ChangelogConfig): Commit | null {
-  const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
-  if (!match) return null;
-
-  const [, hash, message] = match;
-  const breaking =
-    message.includes("!:") || message.toLowerCase().includes("breaking");
-  const ignore = config.ignore ?? DEFAULT_IGNORE;
-
-  // Conventional commit: feat(scope): description or feat!: description
-  const conventionalMatch = message.match(
-    /^(feat|fix|docs|refactor|perf|revert)(?:\(([^)]+)\))?!?:\s*(.+)$/i,
-  );
-  if (conventionalMatch) {
-    const [, type, scope, description] = conventionalMatch;
-
-    // Skip if scope matches ignore list
-    if (scope) {
-      const baseScope = scope.split("/")[0];
-      if (ignore.includes(baseScope) || ignore.includes(scope)) {
-        return null;
+    if (entry.breaking.length > 0) {
+      sections.push("### Breaking Changes\n");
+      for (const commit of entry.breaking) {
+        sections.push(this.formatCommit(commit));
       }
+      sections.push("");
     }
 
-    // Skip if type (without scope) matches ignore list (e.g., "docs" in ignore)
-    if (!scope && ignore.includes(type.toLowerCase())) {
-      return null;
-    }
-
-    return {
-      hash: hash.substring(0, 8),
-      type: type.toLowerCase(),
-      scope: scope || null,
-      description: description.trim(),
-      breaking,
-    };
-  }
-
-  // Module-specific commit: module: description or module/submodule: description
-  const moduleMatch = message.match(
-    /^([a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)?):\s*(.+)$/i,
-  );
-  if (moduleMatch) {
-    const [, module, description] = moduleMatch;
-    const baseModule = module.split("/")[0];
-
-    // Skip ignored prefixes
-    if (ignore.includes(baseModule)) {
-      return null;
-    }
-
-    // If scopes are defined, check if this is a known scope
-    if (config.scopes && !config.scopes.includes(baseModule)) {
-      return null;
+    if (entry.features.length > 0) {
+      sections.push("### Features\n");
+      for (const commit of entry.features) {
+        sections.push(this.formatCommit(commit));
+      }
+      sections.push("");
     }
 
-    // Determine type based on description keywords
-    const desc = description.toLowerCase();
-    let type = "improve";
-    if (
-      desc.includes("fix") ||
-      desc.includes("bug") ||
-      desc.includes("issue")
-    ) {
-      type = "fix";
-    } else if (
-      desc.includes("add") ||
-      desc.includes("new") ||
-      desc.includes("implement")
-    ) {
-      type = "feat";
+    if (entry.fixes.length > 0) {
+      sections.push("### Bug Fixes\n");
+      for (const commit of entry.fixes) {
+        sections.push(this.formatCommit(commit));
+      }
+      sections.push("");
     }
 
-    return {
-      hash: hash.substring(0, 8),
-      type,
-      scope: module,
-      description: description.trim(),
-      breaking,
-    };
+    return sections.join("\n");
   }
 
-  return null;
-}
+  // ---------------------------------------------------------------------------
+  // PARSING
+  // ---------------------------------------------------------------------------
 
-function formatCommit(commit: Commit): string {
-  const scope = commit.scope ? `**${commit.scope}**: ` : "";
-  return `- ${scope}${commit.description} (\`${commit.hash}\`)`;
-}
-
-function generateChangelog(entries: ChangelogEntry[]): string {
-  let output = "# Changelog\n\n";
-  output +=
-    "All notable changes to this project will be documented in this file.\n\n";
+  /**
+   * Parse git log output into a changelog entry.
+   */
+  protected parseCommits(commitsOutput: string): ChangelogEntry {
+    const entry: ChangelogEntry = {
+      features: [],
+      fixes: [],
+      breaking: [],
+    };
 
-  for (const entry of entries) {
-    output += `## [${entry.version}] - ${entry.date}\n\n`;
-    output += formatEntry(entry);
-  }
+    for (const line of commitsOutput.trim().split("\n")) {
+      if (!line.trim()) continue;
 
-  return output;
-}
+      const commit = this.parser.parseCommit(line, this.config);
+      if (!commit) {
+        this.log.trace("Skipping commit", { line });
+        continue;
+      }
 
-function formatEntry(entry: ChangelogEntry): string {
-  let output = "";
+      this.log.trace("Parsed commit", { commit });
 
-  if (entry.breaking.length > 0) {
-    output += "### Breaking Changes\n\n";
-    for (const commit of entry.breaking) {
-      output += `${formatCommit(commit)}\n`;
+      // 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);
+      }
     }
-    output += "\n";
-  }
 
-  if (entry.features.length > 0) {
-    output += "### Features\n\n";
-    for (const commit of entry.features) {
-      output += `${formatCommit(commit)}\n`;
-    }
-    output += "\n";
+    return entry;
   }
 
-  if (entry.fixes.length > 0) {
-    output += "### Bug Fixes\n\n";
-    for (const commit of entry.fixes) {
-      output += `${formatCommit(commit)}\n`;
-    }
-    output += "\n";
+  /**
+   * 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 output;
-}
-
-async function loadConfig(root: string): Promise<ChangelogConfig> {
-  try {
-    const pkgPath = join(root, "package.json");
-    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
-    return pkg.changelog ?? {};
-  } catch {
-    return {};
+  /**
+   * 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;
   }
-}
 
-export class ChangelogCommands {
+  // ---------------------------------------------------------------------------
+  // COMMAND
+  // ---------------------------------------------------------------------------
+
   public readonly changelog = $command({
     name: "changelog",
-    description: "Generate CHANGELOG.md from git commits",
+    description:
+      "Generate changelog from conventional commits (outputs to stdout)",
     flags: t.object({
-      release: t.optional(
-        t.boolean({
-          when: ["--release", "-r"],
-          description:
-            "Output release notes for the latest version only (for GitHub Release)",
-        }),
-      ),
-      preview: t.optional(
-        t.boolean({
-          when: ["--preview", "-p"],
-          description: "Preview unreleased changes (commits since last tag)",
-        }),
-      ),
-      output: t.optional(
+      /**
+       * Show changes from this ref (tag, commit, branch).
+       * Defaults to the latest version tag.
+       * Example: --from=1.0.0
+       */
+      from: t.optional(
         t.string({
-          when: ["--output", "-o"],
-          description:
-            "Output file path (defaults to CHANGELOG.md, use - for stdout)",
+          aliases: ["f"],
+          description: "Starting ref (default: latest tag)",
         }),
       ),
-      limit: t.optional(
-        t.number({
-          when: ["--limit", "-l"],
-          description: "Limit number of versions to include",
+      /**
+       * 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, run, root }) => {
-      const config = await loadConfig(root);
-
-      const git = async (cmd: string) => {
-        const { stdout } = await execAsync(`git ${cmd}`, { cwd: root });
-        return stdout;
-      };
-
-      // Get all tags sorted by version
-      const tagsOutput = await git("tag --sort=-version:refname");
-      const tags = tagsOutput
-        .trim()
-        .split("\n")
-        .filter((tag) => tag.match(/^\d+\.\d+\.\d+$/));
-
-      if (tags.length === 0) {
-        throw new Error("No version tags found");
-      }
-
-      // Preview mode: show unreleased changes
-      if (flags.preview) {
-        const latestTag = tags[0];
-        const commitsOutput = await git(`log ${latestTag}..HEAD --oneline`);
+    handler: async ({ flags, root }) => {
+      const git = (cmd: string) => this.git.exec(cmd, root);
 
-        if (!commitsOutput.trim()) {
-          console.log("No unreleased changes since", latestTag);
-          return;
-        }
-
-        const entry: ChangelogEntry = {
-          version: "Unreleased",
-          date: new Date().toISOString().split("T")[0],
-          features: [],
-          fixes: [],
-          docs: [],
-          improvements: [],
-          breaking: [],
-        };
-
-        for (const line of commitsOutput.trim().split("\n")) {
-          if (!line.trim()) continue;
-          const commit = parseCommit(line, config);
-          if (!commit) continue;
-
-          if (commit.breaking) entry.breaking.push(commit);
-
-          switch (commit.type) {
-            case "feat":
-              entry.features.push(commit);
-              break;
-            case "fix":
-              entry.fixes.push(commit);
-              break;
-            case "docs":
-              entry.docs.push(commit);
-              break;
-            case "refactor":
-            case "perf":
-            case "improve":
-              entry.improvements.push(commit);
-              break;
-          }
-        }
-
-        const hasCommits =
-          entry.features.length > 0 ||
-          entry.fixes.length > 0 ||
-          entry.breaking.length > 0;
+      // Determine the starting point
+      let fromRef: string;
 
-        if (!hasCommits) {
-          console.log("No public changes since", latestTag);
+      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;
         }
-
-        console.log(`## [Unreleased] - since ${latestTag}\n`);
-        console.log(formatEntry(entry));
-        return;
+        fromRef = latestTag;
+        this.log.debug("Using latest tag", { from: fromRef });
       }
 
-      const entries: ChangelogEntry[] = [];
-      const limit = flags.limit || (flags.release ? 1 : tags.length);
-
-      for (let i = 0; i < Math.min(limit, tags.length); i++) {
-        const tag = tags[i];
-        const prevTag = tags[i + 1];
-
-        // Get tag date
-        const dateOutput = await git(`log -1 --format=%ci ${tag}`);
-        const date = dateOutput.trim().split(" ")[0];
-
-        // Get commits between tags
-        const range = prevTag ? `${prevTag}..${tag}` : tag;
-        const commitsOutput = await git(`log ${range} --oneline`);
-
-        const entry: ChangelogEntry = {
-          version: tag,
-          date,
-          features: [],
-          fixes: [],
-          docs: [],
-          improvements: [],
-          breaking: [],
-        };
-
-        for (const line of commitsOutput.trim().split("\n")) {
-          if (!line.trim()) continue;
-          const commit = parseCommit(line, config);
-          if (!commit) continue;
-
-          if (commit.breaking) entry.breaking.push(commit);
-
-          switch (commit.type) {
-            case "feat":
-              entry.features.push(commit);
-              break;
-            case "fix":
-              entry.fixes.push(commit);
-              break;
-            case "docs":
-              entry.docs.push(commit);
-              break;
-            case "refactor":
-            case "perf":
-            case "improve":
-              entry.improvements.push(commit);
-              break;
-          }
-        }
+      // Determine the ending point
+      const toRef = flags.to || "HEAD";
+      this.log.debug("Using to ref", { to: toRef });
 
-        // Only add entry if it has any commits
-        const hasCommits =
-          entry.features.length > 0 ||
-          entry.fixes.length > 0 ||
-          entry.breaking.length > 0;
+      // Get commits in range
+      const commitsOutput = await git(`log ${fromRef}..${toRef} --oneline`);
 
-        if (hasCommits) {
-          entries.push(entry);
-        }
-      }
-
-      if (entries.length === 0) {
-        console.log("No public commits found");
+      if (!commitsOutput.trim()) {
+        process.stdout.write(`No changes in range ${fromRef}..${toRef}\n`);
         return;
       }
 
-      let output: string;
-      if (flags.release) {
-        output = formatEntry(entries[0]);
-      } else {
-        output = generateChangelog(entries);
-      }
+      // Parse and format
+      const entry = this.parseCommits(commitsOutput);
 
-      const outputPath = flags.output ?? "CHANGELOG.md";
-      if (outputPath === "-") {
-        console.log(output);
-      } else {
-        await run(`Writing ${outputPath}`, () =>
-          writeFile(join(root, outputPath), output, "utf8"),
+      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.",
+      );
+    },
+  });
+}