better-commits 1.19.1 → 1.20.0-cli-flags

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

@@ -0,0 +1,195 @@
+import * as p from "@clack/prompts";
+import { InferOutput } from "valibot";
+import { V_FOOTER_OPTIONS } from "../valibot-consts";
+import {
+  COMMIT_FOOTER_OPTIONS,
+  get_value_from_cache,
+  set_value_cache,
+} from "../utils";
+import {
+  cache_message,
+  optional_message,
+  space_to_select_message,
+} from "../utils/messages";
+import { Runnable } from "./runnable";
+
+type FooterOption = InferOutput<typeof V_FOOTER_OPTIONS>;
+type FooterPromptOption = {
+  value: FooterOption;
+  label: string;
+  hint: string;
+};
+
+type FooterSelection = {
+  includes_breaking_change: boolean;
+  includes_deprecated: boolean;
+  includes_closes: boolean;
+  includes_custom: boolean;
+  includes_trailer: boolean;
+};
+
+type FooterInputs = {
+  breaking_title: string;
+  breaking_body: string;
+  deprecated_title: string;
+  deprecated_body: string;
+  custom_footer: string;
+};
+
+export class CommitFooterPrompt extends Runnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+
+    const { initial_values, message } = this.#get_initial_value();
+    const commit_footer = (await p.multiselect({
+      message,
+      initialValues: initial_values,
+      options: this.#options,
+      required: false,
+    })) as FooterOption[];
+    if (p.isCancel(commit_footer)) process.exit(0);
+
+    const selection = this.#get_selection(commit_footer);
+    const footer_inputs = await this.#get_footer_inputs(selection);
+    this.#run_post_effects(commit_footer, selection, footer_inputs);
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.commit_footer.enable;
+  }
+
+  get #options(): FooterPromptOption[] {
+    const allowed_values = new Set(this.config.commit_footer.options);
+    return COMMIT_FOOTER_OPTIONS.filter((option) =>
+      allowed_values.has(option.value as FooterOption),
+    ) as FooterPromptOption[];
+  }
+
+  get #available_option_values(): FooterOption[] {
+    return this.#options.map((option) => option.value);
+  }
+
+  #get_initial_value(): { initial_values: FooterOption[]; message: string } {
+    const cache_value = get_value_from_cache(
+      this.prompt_cache,
+      "commit_footer",
+    );
+    if (cache_value) {
+      return {
+        initial_values: this.#parse_cache_value(cache_value),
+        message: space_to_select_message(cache_message("Commit footers")),
+      };
+    }
+
+    const initial_values = this.config.commit_footer.initial_value.filter(
+      (value) => this.#available_option_values.includes(value),
+    );
+    return {
+      initial_values,
+      message: space_to_select_message(
+        optional_message("Select optional footers"),
+      ),
+    };
+  }
+
+  #parse_cache_value(cache_value: string): FooterOption[] {
+    return cache_value
+      .split(",")
+      .map((value) => value.trim())
+      .filter((value): value is FooterOption =>
+        this.#available_option_values.includes(value as FooterOption),
+      );
+  }
+
+  #get_selection(commit_footer: FooterOption[]): FooterSelection {
+    return {
+      includes_breaking_change: commit_footer.includes("breaking-change"),
+      includes_deprecated: commit_footer.includes("deprecated"),
+      includes_closes: commit_footer.includes("closes"),
+      includes_custom: commit_footer.includes("custom"),
+      includes_trailer: commit_footer.includes("trailer"),
+    };
+  }
+
+  async #get_footer_inputs(selection: FooterSelection): Promise<FooterInputs> {
+    const footer_inputs: FooterInputs = {
+      breaking_title: "",
+      breaking_body: "",
+      deprecated_title: "",
+      deprecated_body: "",
+      custom_footer: "",
+    };
+
+    if (selection.includes_breaking_change) {
+      footer_inputs.breaking_title = await this.#required_text(
+        "Breaking changes: Write a short title / summary",
+      );
+      footer_inputs.breaking_body = await this.#optional_text(
+        optional_message(
+          "Breaking Changes: Write a description & migration instructions",
+        ),
+      );
+    }
+
+    if (selection.includes_deprecated) {
+      footer_inputs.deprecated_title = await this.#required_text(
+        "Deprecated: Write a short title / summary",
+      );
+      footer_inputs.deprecated_body = await this.#optional_text(
+        optional_message("Deprecated: Write a description"),
+      );
+    }
+
+    if (selection.includes_custom) {
+      footer_inputs.custom_footer = await this.#optional_text(
+        "Write a custom footer",
+      );
+    }
+
+    return footer_inputs;
+  }
+
+  async #required_text(message: string): Promise<string> {
+    const response = await p.text({
+      message,
+      placeholder: "",
+      validate: (value) => {
+        if (!value) return "Please enter a title / summary";
+      },
+    });
+    if (p.isCancel(response)) process.exit(0);
+    return response ?? "";
+  }
+
+  async #optional_text(message: string): Promise<string> {
+    const response = await p.text({
+      message,
+      placeholder: "",
+    });
+    if (p.isCancel(response)) process.exit(0);
+    return response ?? "";
+  }
+
+  #run_post_effects(
+    commit_footer: FooterOption[],
+    selection: FooterSelection,
+    footer_inputs: FooterInputs,
+  ): void {
+    set_value_cache(
+      this.prompt_cache,
+      "commit_footer",
+      commit_footer.join(","),
+    );
+
+    this.commit_state.breaking_title = footer_inputs.breaking_title;
+    this.commit_state.breaking_body = footer_inputs.breaking_body;
+    this.commit_state.deprecates_title = footer_inputs.deprecated_title;
+    this.commit_state.deprecates_body = footer_inputs.deprecated_body;
+    this.commit_state.custom_footer = footer_inputs.custom_footer;
+
+    this.commit_state.closes = selection.includes_closes ? "Closes:" : "";
+    if (!selection.includes_trailer) {
+      this.commit_state.trailer = "";
+    }
+  }
+}

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

@@ -0,0 +1,73 @@
+import * as p from "@clack/prompts";
+import { CUSTOM_SCOPE_KEY } from "../valibot-consts";
+import { get_value_from_cache, set_value_cache } from "../utils";
+import { cache_message } from "../utils/messages";
+import { Runnable } from "./runnable";
+
+export class CommitScopePrompt extends Runnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+    const { initial_value, message } = this.#get_initial_value();
+
+    let commit_scope = await p.select({
+      message,
+      initialValue: initial_value,
+      maxItems: this.#max_items,
+      options: this.#options,
+    });
+    if (p.isCancel(commit_scope)) process.exit(0);
+
+    await this.#post_run_effects(commit_scope);
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.commit_scope.enable;
+  }
+
+  #get_initial_value(): { initial_value: string; message: string } {
+    const cache_value = get_value_from_cache(this.prompt_cache, "commit_scope");
+    if (cache_value) {
+      return {
+        initial_value: cache_value,
+        message: cache_message("Commit scope"),
+      };
+    }
+
+    return {
+      initial_value: this.config.commit_scope.initial_value,
+      message: "Select a commit scope",
+    };
+  }
+
+  get #max_items(): number | undefined {
+    return this.config.commit_scope.max_items;
+  }
+
+  get #options(): {
+    label?: string | undefined;
+    value: string;
+    hint?: string;
+  }[] {
+    return this.config.commit_scope.options;
+  }
+
+  get #custom_scope_enabled(): boolean {
+    return this.config.commit_scope.custom_scope;
+  }
+
+  async #post_run_effects(prompt_result: string): Promise<void> {
+    set_value_cache(this.prompt_cache, "commit_scope", prompt_result);
+
+    let commit_scope_value = prompt_result;
+    if (commit_scope_value === CUSTOM_SCOPE_KEY && this.#custom_scope_enabled) {
+      const commit_scope = await p.text({
+        message: "Write a custom scope",
+        placeholder: "",
+      });
+      if (p.isCancel(commit_scope)) process.exit(0);
+      commit_scope_value = commit_scope ?? "";
+    }
+
+    this.commit_state.scope = commit_scope_value;
+  }
+}

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

@@ -0,0 +1,75 @@
+import * as p from "@clack/prompts";
+import color from "picocolors";
+import { addNewLine } from "../utils";
+import { space_to_select_message } from "../utils/messages";
+import { git_add, git_status } from "../git";
+import { Runnable } from "./runnable";
+
+export class CommitStatusPrompt extends Runnable {
+  async run(): Promise<void> {
+    if (!this.#is_enabled) return;
+
+    const status = git_status();
+    this.#log_status(status);
+
+    if (status.work_tree.length) {
+      const selected_for_staging = await this.#select_for_staging(
+        status.work_tree,
+      );
+      if (selected_for_staging.length) {
+        git_add(selected_for_staging);
+      }
+    }
+
+    this.#ensure_staged_changes();
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.check_status;
+  }
+
+  #log_status(status: { index: string[]; work_tree: string[] }): void {
+    p.log.step(color.black(color.bgGreen(" Checking Git Status ")));
+
+    const staged_files = this.#format_files(status.index, color.green);
+    p.log.success("Changes to be committed:\n" + staged_files);
+
+    if (!status.work_tree.length) return;
+    const unstaged_files = this.#format_files(status.work_tree, color.red);
+    p.log.error("Changes not staged for commit:\n" + unstaged_files);
+  }
+
+  #format_files(files: string[], colorize: (value: string) => string): string {
+    return files.reduce(
+      (acc, curr, index) => colorize(acc + curr + addNewLine(files, index)),
+      "",
+    );
+  }
+
+  async #select_for_staging(work_tree: string[]): Promise<string[]> {
+    const selected_for_staging = (await p.multiselect({
+      message: space_to_select_message(
+        "Some files have not been staged, would you like to add them now?",
+      ),
+      options: [
+        { value: ".", label: "." },
+        ...work_tree.map((v) => ({ value: v, label: v })),
+      ],
+      required: false,
+    })) as string[];
+    if (p.isCancel(selected_for_staging)) process.exit(0);
+    return selected_for_staging;
+  }
+
+  #ensure_staged_changes(): void {
+    const updated_status = git_status();
+    if (updated_status.index.length) return;
+
+    p.log.error(
+      color.red(
+        'no changes added to commit (use "git add" and/or "git commit -a")',
+      ),
+    );
+    process.exit(0);
+  }
+}

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

@@ -0,0 +1,82 @@
+import * as p from "@clack/prompts";
+import { flags } from "../args";
+import { get_value_from_cache, set_value_cache } from "../utils";
+import { infer_ticket_from_git } from "../utils/infer";
+import {
+  cache_message,
+  inferred_message,
+  optional_message,
+} from "../utils/messages";
+import { Runnable } from "./runnable";
+
+export class CommitTicketPrompt extends Runnable {
+  async run(): Promise<void> {
+    const { initial_value, message } = this.#get_initial_value();
+    this.commit_state.ticket = initial_value;
+
+    if (this.#confirm_ticket_enabled) {
+      const user_commit_ticket = await p.text({
+        message,
+        placeholder: "",
+        initialValue: initial_value,
+      });
+      if (p.isCancel(user_commit_ticket)) process.exit(0);
+      set_value_cache(this.prompt_cache, "commit_ticket", user_commit_ticket);
+      this.commit_state.ticket = user_commit_ticket ?? "";
+    }
+
+    if (
+      this.#prepend_hashtag_always &&
+      this.commit_state.ticket &&
+      !this.commit_state.ticket.startsWith("#")
+    ) {
+      this.commit_state.ticket = "#" + this.commit_state.ticket;
+    }
+  }
+
+  get #infer_ticket_enabled(): boolean {
+    return this.config.check_ticket.infer_ticket;
+  }
+
+  get #confirm_ticket_enabled(): boolean {
+    return this.config.check_ticket.confirm_ticket;
+  }
+
+  get #prepend_hashtag_always(): boolean {
+    return this.config.check_ticket.prepend_hashtag === "Always";
+  }
+
+  #get_initial_value(): { initial_value: string; message: string } {
+    const cache_value = get_value_from_cache(
+      this.prompt_cache,
+      "commit_ticket",
+    );
+    if (cache_value) {
+      return {
+        initial_value: cache_value,
+        message: cache_message("Ticket / issue"),
+      };
+    }
+
+    if (this.#infer_ticket_enabled) {
+      const inferred_value = infer_ticket_from_git(
+        {
+          append_hashtag: this.config.check_ticket.append_hashtag,
+          prepend_hashtag: this.config.check_ticket.prepend_hashtag,
+        },
+        flags.git_args,
+      );
+      if (inferred_value) {
+        return {
+          initial_value: inferred_value,
+          message: inferred_message("Ticket / issue"),
+        };
+      }
+    }
+
+    return {
+      initial_value: this.commit_state.ticket,
+      message: optional_message("Add ticket / issue"),
+    };
+  }
+}

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

@@ -0,0 +1,98 @@
+import * as p from "@clack/prompts";
+import {
+  clean_commit_title,
+  get_value_from_cache,
+  set_value_cache,
+} from "../utils";
+import { cache_message } from "../utils/messages";
+import { get_commit_title_size } from "../utils/commit-title-size";
+import { Runnable } from "./runnable";
+
+export class CommitTitlePrompt extends Runnable {
+  async run(): Promise<void> {
+    const { initial_value, message } = this.#get_initial_value();
+    const commit_title = await p.text({
+      message,
+      initialValue: initial_value,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+    });
+
+    if (p.isCancel(commit_title)) process.exit(0);
+    this.#run_post_effects(commit_title ?? "");
+  }
+
+  #get_initial_value(): { initial_value: string; message: string } {
+    const cache_value = get_value_from_cache(this.prompt_cache, "commit_title");
+    if (cache_value) {
+      return {
+        initial_value: cache_value,
+        message: cache_message("Commit title"),
+      };
+    }
+
+    // this.commit_state.title will pull from flag if populated
+    return {
+      initial_value: this.commit_state.title,
+      message: "Write a brief title describing the commit",
+    };
+  }
+
+  #validate(value: string | undefined): string | undefined {
+    if (!value) return "Please enter a title";
+
+    if (this.#get_size(value) > this.#max_size) {
+      return `Exceeded max length. Title max [${this.#max_size}]`;
+    }
+  }
+
+  get #max_size(): number {
+    return this.config.commit_title.max_size;
+  }
+
+  #get_size(value: string): number {
+    return get_commit_title_size(
+      {
+        type: this.commit_state.type,
+        scope: this.commit_state.scope,
+        ticket: this.commit_state.ticket,
+        title: value,
+      },
+      {
+        include_ticket: this.config.check_ticket.add_to_title,
+      },
+    );
+  }
+
+  // TODO: Extract to a Runnable abstract function?
+  get #value_to_data(): Record<string, { emoji: string }> {
+    return this.config.commit_type.options.reduce(
+      (acc, curr) => ({
+        ...acc,
+        [curr.value]: {
+          emoji: curr.emoji ?? "",
+        },
+      }),
+      {},
+    );
+  }
+
+  #title_with_emoji(title: string): string {
+    if (
+      this.config.commit_type.append_emoji_to_commit &&
+      this.config.commit_type.emoji_commit_position === "After-Colon"
+    ) {
+      const emoji = this.#value_to_data[this.commit_state.type]?.emoji ?? "";
+      return `${emoji} ${title}`.trim();
+    }
+
+    return title;
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    set_value_cache(this.prompt_cache, "commit_title", prompt_result);
+    this.commit_state.title = clean_commit_title(
+      this.#title_with_emoji(prompt_result),
+    );
+  }
+}

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

@@ -0,0 +1,93 @@
+import * as p from "@clack/prompts";
+import { flags } from "../args";
+import { get_value_from_cache, set_value_cache } from "../utils";
+import { infer_type_from_git } from "../utils/infer";
+import { cache_message, inferred_message } from "../utils/messages";
+import { Runnable } from "./runnable";
+
+export class CommitTypePrompt extends Runnable {
+  async run() {
+    if (this.#is_enabled) {
+      const { initial_value, message } = this.#initial_value;
+      const commit_type = await p.select({
+        message,
+        initialValue: initial_value,
+        maxItems: this.#max_items,
+        options: this.#options,
+      });
+      if (p.isCancel(commit_type)) process.exit(0);
+
+      this.#run_post_effects(commit_type);
+    }
+  }
+
+  get #is_enabled(): boolean {
+    return this.config.commit_type.enable;
+  }
+
+  get #initial_value(): { initial_value: string | undefined; message: string } {
+    const cache_value = get_value_from_cache(this.prompt_cache, "commit_type");
+    if (cache_value)
+      return {
+        initial_value: cache_value,
+        message: cache_message("Commit type"),
+      };
+
+    if (this.config.commit_type.infer_type_from_branch) {
+      const type_from_branch = infer_type_from_git(
+        this.#options,
+        flags.git_args,
+      );
+      if (type_from_branch) {
+        return {
+          message: inferred_message("Commit type"),
+          initial_value: type_from_branch,
+        };
+      }
+    }
+
+    return {
+      initial_value: this.config.commit_type.initial_value,
+      message: "Select a commit type",
+    };
+  }
+
+  get #options(): {
+    label: string | undefined;
+    value: string;
+    emoji?: string;
+    hint?: string;
+    trailer?: string;
+  }[] {
+    return this.config.commit_type.options;
+  }
+
+  get #value_to_data(): Record<string, { emoji: string; trailer: string }> {
+    return this.#options.reduce(
+      (acc, curr) => ({
+        ...acc,
+        [curr.value]: {
+          emoji: curr.emoji ?? "",
+          trailer: curr.trailer ?? "",
+        },
+      }),
+      {},
+    );
+  }
+
+  get #max_items(): number | undefined {
+    return this.config.commit_type.max_items;
+  }
+
+  #run_post_effects(prompt_result: string): void {
+    set_value_cache(this.prompt_cache, "commit_type", prompt_result);
+
+    const value_to_data = this.#value_to_data;
+    this.commit_state.trailer = value_to_data[prompt_result].trailer;
+    this.commit_state.type =
+      this.config.commit_type.append_emoji_to_commit &&
+      this.config.commit_type.emoji_commit_position === "Start"
+        ? `${value_to_data[prompt_result].emoji} ${prompt_result}`.trim()
+        : prompt_result;
+  }
+}

package/src/prompts/runnable.ts

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