better-commits 1.19.0 → 1.20.0-cli-flags

package/src/prompts/branch-confirm.prompt.ts

@@ -0,0 +1,134 @@
+import * as p from "@clack/prompts";
+import { execSync } from "child_process";
+import color from "picocolors";
+import { chdir } from "process";
+import { branch_flags } from "../branch-args";
+import { get_git_root } from "../utils";
+import { build_branch, build_worktree_path } from "../utils/build-branch";
+import { BranchRunnable } from "./branch-runnable";
+
+export class BranchConfirmPrompt extends BranchRunnable {
+  async run(): Promise<void> {
+    this.#run_pre_commands();
+    this.#run_checkout();
+    this.#run_post_commands();
+  }
+
+  get #is_worktree(): boolean {
+    return this.branch_state.checkout === "worktree";
+  }
+
+  get #pre_commands(): string[] {
+    return this.#is_worktree
+      ? this.config.worktree_pre_commands
+      : this.config.branch_pre_commands;
+  }
+
+  get #post_commands(): string[] {
+    return this.#is_worktree
+      ? this.config.worktree_post_commands
+      : this.config.branch_post_commands;
+  }
+
+  get #branch_name(): string {
+    return build_branch(this.branch_state, this.config);
+  }
+
+  #run_pre_commands(): void {
+    this.#run_commands(
+      this.#pre_commands,
+      "Something went wrong when executing pre-commands: ",
+    );
+  }
+
+  #run_checkout(): void {
+    const branch_name = this.#branch_name;
+    const branch_flag = this.#verify_branch_name(branch_name);
+
+    if (!this.#is_worktree) {
+      try {
+        execSync(
+          `git ${branch_flags.git_args} checkout ${branch_flag} ${branch_name}`,
+          {
+            stdio: "inherit",
+          },
+        );
+        p.log.info(
+          `Switched to a new branch '${color.bgGreen(
+            " " + color.black(branch_name) + " ",
+          )}'`,
+        );
+      } catch (err) {
+        process.exit(0);
+      }
+
+      return;
+    }
+
+    try {
+      const worktree_name = build_worktree_path(
+        this.branch_state,
+        this.config,
+        get_git_root(branch_flags.git_args),
+      );
+      execSync(
+        `git ${branch_flags.git_args} worktree add ${worktree_name} ${branch_flag} ${branch_name}`,
+        {
+          stdio: "inherit",
+        },
+      );
+      p.log.info(
+        `Created a new worktree ${color.bgGreen(
+          " " + color.black(worktree_name) + " ",
+        )}, checked out branch ${color.bgGreen(
+          " " + color.black(branch_name) + " ",
+        )}`,
+      );
+      p.log.info(
+        color.bgMagenta(color.black(` cd ${worktree_name} `)) +
+          " to navigate to your new worktree",
+      );
+      chdir(worktree_name);
+    } catch (err) {
+      process.exit(0);
+    }
+  }
+
+  #run_post_commands(): void {
+    this.#run_commands(
+      this.#post_commands,
+      "Something went wrong when executing post-commands: ",
+    );
+  }
+
+  #run_commands(commands: string[], error_message: string): void {
+    commands.forEach((command) => {
+      try {
+        execSync(command, { stdio: "inherit" });
+      } catch (err) {
+        p.log.error(error_message + err);
+        process.exit(0);
+      }
+    });
+  }
+
+  #verify_branch_name(branch_name: string): string {
+    // TODO: There has to be a better way 🤦
+    let branch_flag = "";
+    try {
+      execSync(`git ${branch_flags.git_args} show-ref ${branch_name}`, {
+        encoding: "utf-8",
+      });
+      p.log.warning(
+        color.yellow(
+          `${branch_name} already exists! Checking out existing branch.`,
+        ),
+      );
+    } catch (err) {
+      // Branch does not exist
+      branch_flag = "-b";
+    }
+
+    return branch_flag;
+  }
+}

package/src/prompts/branch-description.prompt.ts

@@ -0,0 +1,37 @@
+import * as p from "@clack/prompts";
+import { BranchRunnable } from "./branch-runnable";
+
+export class BranchDescriptionPrompt extends BranchRunnable {
+  async run(): Promise<void> {
+    const description = await p.text({
+      message: this.#message,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+      initialValue: this.branch_state.description,
+    });
+
+    if (p.isCancel(description)) process.exit(0);
+    this.#run_post_effects(description ?? "");
+  }
+
+  get #message(): string {
+    return "Type a short description";
+  }
+
+  get #max_length(): number {
+    return this.config.branch_description.max_length;
+  }
+
+  #validate(value: string | undefined): string | undefined {
+    if (!value) return "Please enter a description";
+    if (value.length > this.#max_length) {
+      return `Exceeded max length. Description max [${this.#max_length}]`;
+    }
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    this.branch_state.description = prompt_result
+      .replace(/\s+/g, "-")
+      .toLowerCase();
+  }
+}

package/src/prompts/branch-runnable.ts

@@ -0,0 +1,13 @@
+import { InferOutput } from "valibot";
+import { BranchState, Config } from "../valibot-state";
+import Configstore from "configstore";
+
+export abstract class BranchRunnable {
+  constructor(
+    protected config: InferOutput<typeof Config>,
+    protected branch_state: InferOutput<typeof BranchState>,
+    protected prompt_cache: Configstore,
+  ) {}
+
+  abstract run(): Promise<void>;
+}

package/src/prompts/branch-ticket.prompt.ts

@@ -0,0 +1,41 @@
+import * as p from "@clack/prompts";
+import { optional_message } from "../utils/messages";
+import { BranchRunnable } from "./branch-runnable";
+
+export class BranchTicketPrompt extends BranchRunnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+
+    const ticket = await p.text({
+      message: this.#message,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+      initialValue: this.branch_state.ticket,
+    });
+
+    if (p.isCancel(ticket)) process.exit(0);
+    this.#run_post_effects(ticket ?? "");
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.branch_ticket.enable;
+  }
+
+  get #is_required(): boolean {
+    return this.config.branch_ticket.required;
+  }
+
+  get #message(): string {
+    return this.#is_required
+      ? "Type ticket / issue number"
+      : optional_message("Type ticket / issue number");
+  }
+
+  #validate(value: string | undefined): string | undefined {
+    if (this.#is_required && !value) return "Please enter a ticket / issue";
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    this.branch_state.ticket = prompt_result;
+  }
+}

package/src/prompts/branch-type.prompt.ts

@@ -0,0 +1,43 @@
+import * as p from "@clack/prompts";
+import { BranchRunnable } from "./branch-runnable";
+
+export class BranchTypePrompt extends BranchRunnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+
+    const branch_type = await p.select({
+      message: this.#message,
+      initialValue: this.#initial_value,
+      options: this.#options,
+    });
+
+    if (p.isCancel(branch_type)) process.exit(0);
+    this.#run_post_effects(branch_type);
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.branch_type.enable;
+  }
+
+  get #message(): string {
+    return "Select a branch type";
+  }
+
+  get #initial_value(): string {
+    return this.branch_state.type || this.config.commit_type.initial_value;
+  }
+
+  get #options(): {
+    label?: string | undefined;
+    value: string;
+    emoji?: string;
+    hint?: string;
+    trailer?: string;
+  }[] {
+    return this.config.commit_type.options;
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    this.branch_state.type = prompt_result;
+  }
+}

package/src/prompts/branch-user.prompt.ts

@@ -0,0 +1,50 @@
+import * as p from "@clack/prompts";
+import { get_value_from_cache, set_value_cache } from "../utils";
+import { optional_message } from "../utils/messages";
+import { BranchRunnable } from "./branch-runnable";
+
+export class BranchUserPrompt extends BranchRunnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+
+    const user_name = await p.text({
+      message: this.#message,
+      placeholder: "",
+      initialValue: this.#initial_value,
+      validate: (value) => this.#validate(value),
+    });
+
+    if (p.isCancel(user_name)) process.exit(0);
+    this.#run_post_effects(user_name ?? "");
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.branch_user.enable;
+  }
+
+  get #is_required(): boolean {
+    return this.config.branch_user.required;
+  }
+
+  get #message(): string {
+    return this.#is_required
+      ? "Type your git username"
+      : optional_message("Type your git username");
+  }
+
+  get #initial_value(): string {
+    return (
+      this.branch_state.user ||
+      get_value_from_cache(this.prompt_cache, "username")
+    );
+  }
+
+  #validate(value: string | undefined): string | undefined {
+    if (this.#is_required && !value) return "Please enter a username";
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    this.branch_state.user = prompt_result.replace(/\s+/g, "-").toLowerCase();
+    set_value_cache(this.prompt_cache, "username", this.branch_state.user);
+  }
+}

package/src/prompts/branch-version.prompt.ts

@@ -0,0 +1,41 @@
+import * as p from "@clack/prompts";
+import { optional_message } from "../utils/messages";
+import { BranchRunnable } from "./branch-runnable";
+
+export class BranchVersionPrompt extends BranchRunnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+
+    const version = await p.text({
+      message: this.#message,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+      initialValue: this.branch_state.version,
+    });
+
+    if (p.isCancel(version)) process.exit(0);
+    this.#run_post_effects(version ?? "");
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.branch_version.enable;
+  }
+
+  get #is_required(): boolean {
+    return this.config.branch_version.required;
+  }
+
+  get #message(): string {
+    return this.#is_required
+      ? "Type version number"
+      : optional_message("Type version number");
+  }
+
+  #validate(value: string | undefined): string | undefined {
+    if (this.#is_required && !value) return "Please enter a version";
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    this.branch_state.version = prompt_result;
+  }
+}

package/src/prompts/commit-body.prompt.ts

@@ -0,0 +1,57 @@
+import * as p from "@clack/prompts";
+import { get_value_from_cache, set_value_cache } from "../utils";
+import { cache_message, optional_message } from "../utils/messages";
+import { Runnable } from "./runnable";
+
+export class CommitBodyPrompt extends Runnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+
+    const { initial_value, message } = this.#get_initial_value();
+    const commit_body = await p.text({
+      message,
+      initialValue: initial_value,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+    });
+
+    if (p.isCancel(commit_body)) process.exit(0);
+    this.#run_post_effects(commit_body ?? "");
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.commit_body.enable;
+  }
+
+  #get_initial_value(): { initial_value: string; message: string } {
+    const cache_value = get_value_from_cache(this.prompt_cache, "commit_body");
+    if (cache_value) {
+      return {
+        initial_value: cache_value,
+        message: cache_message("Commit body"),
+      };
+    }
+
+    return {
+      initial_value: "",
+      message: optional_message("Write a detailed description of the changes"),
+    };
+  }
+
+  #validate(value: string | undefined): string | undefined {
+    if (this.config.commit_body.required && !value) {
+      return "Please enter a description";
+    }
+  }
+
+  #split_by_period(value: string): string {
+    if (!this.config.commit_body.split_by_period) return value;
+    const sentences = value.split(/\.\s+/).map((sentence) => sentence.trim());
+    return sentences.join(".\n");
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    set_value_cache(this.prompt_cache, "commit_body", prompt_result);
+    this.commit_state.body = this.#split_by_period(prompt_result);
+  }
+}

package/src/prompts/commit-confirm.prompt.ts

@@ -0,0 +1,119 @@
+import * as p from "@clack/prompts";
+import { StdioOptions, execSync } from "child_process";
+import { flags } from "../args";
+import { Runnable } from "./runnable";
+import { dry_run_message } from "../utils/messages";
+import { build_commit_string } from "../utils/build-commit-string";
+
+export class CommitConfirmPrompt extends Runnable {
+  async run(): Promise<void> {
+    if (this.#confirm_with_editor) {
+      execSync(`${this.#commit_command} --edit`, this.#git_command_options);
+      process.exit(0);
+    }
+
+    if (this.#print_commit_output) {
+      p.note(
+        build_commit_string({
+          commit_state: this.commit_state,
+          config: this.config,
+          colorize: true,
+          escape_quotes: false,
+          include_trailer: true,
+        }),
+        "Commit Preview",
+      );
+    }
+
+    const continue_commit = await this.#get_continue_commit();
+    if (!continue_commit) {
+      p.log.info("Exiting without commit");
+      process.exit(0);
+    }
+
+    try {
+      p.log.info(
+        flags.dry_run
+          ? dry_run_message("Committing changes...")
+          : "Committing changes...",
+      );
+      execSync(
+        this.#commit_command,
+        flags.dry_run
+          ? this.#git_command_options_quiet
+          : this.#git_command_options,
+      );
+    } catch (err) {
+      p.log.error("Something went wrong when committing: " + err);
+      return;
+    }
+
+    this.#run_post_effects();
+  }
+
+  get #confirm_with_editor(): boolean {
+    return flags.interactive && this.config.confirm_with_editor;
+  }
+
+  get #print_commit_output(): boolean {
+    return this.config.print_commit_output;
+  }
+
+  get #confirm_commit(): boolean {
+    return this.config.confirm_commit;
+  }
+
+  get #git_command_options(): { stdio: StdioOptions; shell?: string } {
+    return this.config.overrides.shell
+      ? { shell: this.config.overrides.shell, stdio: "inherit" as StdioOptions }
+      : { stdio: "inherit" as StdioOptions };
+  }
+
+  get #git_command_options_quiet(): { stdio: StdioOptions; shell?: string } {
+    return this.config.overrides.shell
+      ? { shell: this.config.overrides.shell, stdio: "pipe" as StdioOptions }
+      : { stdio: "pipe" as StdioOptions };
+  }
+
+  get #trailer_arg(): string {
+    return this.commit_state.trailer
+      ? `--trailer="${this.commit_state.trailer}"`
+      : "";
+  }
+
+  get #commit_command(): string {
+    return `git ${flags.git_args} commit -m "${build_commit_string({
+      commit_state: this.commit_state,
+      config: this.config,
+      colorize: false,
+      escape_quotes: true,
+      include_trailer: false,
+    })}" ${this.#trailer_arg} ${this.#dry_run_args}`.trim();
+  }
+
+  get #dry_run_args(): string {
+    return flags.dry_run ? "--dry-run --porcelain --untracked-files=no" : "";
+  }
+
+  async #get_continue_commit(): Promise<boolean> {
+    if (!flags.interactive) return true;
+    if (!this.#confirm_commit) return true;
+
+    // dry_run_message
+    const continue_commit = (await p.confirm({
+      message: flags.dry_run
+        ? dry_run_message("Confirm Commit?")
+        : "Confirm Commit?",
+    })) as boolean;
+    if (p.isCancel(continue_commit)) process.exit(0);
+    return continue_commit;
+  }
+
+  #run_post_effects(): void {
+    p.log.success("Commit Complete");
+
+    const user_name = this.prompt_cache.get("username");
+    this.prompt_cache.clear();
+    if (user_name) this.prompt_cache.set("username", user_name);
+  }
+}