better-commits 1.19.0 → 1.20.0-cli-flags

package/src/index.ts

@@ -1,519 +1,100 @@
 #! /usr/bin/env node
 
-import * as p from "@clack/prompts";
-import color from "picocolors";
-import { StdioOptions, execSync } from "child_process";
 import { chdir } from "process";
-import { Output, parse } from "valibot";
+import * as p from "@clack/prompts";
+import { InferInput, InferOutput, ValiError, parse } from "valibot";
 import { CommitState, Config } from "./valibot-state";
 import {
   load_setup,
-  addNewLine,
-  SPACE_TO_SELECT,
-  REGEX_SLASH_TAG,
-  REGEX_SLASH_NUM,
-  REGEX_START_TAG,
-  REGEX_START_NUM,
-  OPTIONAL_PROMPT,
-  clean_commit_title,
-  COMMIT_FOOTER_OPTIONS,
-  infer_type_from_branch,
   get_git_root,
-  REGEX_SLASH_UND,
-  REGEX_START_UND,
-  get_value_from_cache,
-  set_value_cache,
   NOOP_PROMPT_CACHE,
+  ConfigSource,
 } from "./utils";
-import { git_add, git_status } from "./git";
-import { CUSTOM_SCOPE_KEY, V_FOOTER_OPTIONS } from "./valibot-consts";
-import { flags } from "./args";
+import { create_strict_commit_state } from "./utils/no-interactive-validation";
 import Configstore from "configstore";
-
-main(load_setup());
-
-export async function main(config: Output<typeof Config>) {
-  let commit_state = parse(CommitState, {});
+import { CommitTypePrompt } from "./prompts/commit-type.prompt";
+import { Runnable } from "./prompts/runnable";
+import { CommitScopePrompt } from "./prompts/commit-scope.prompt";
+import { CommitTicketPrompt } from "./prompts/commit-ticket.prompt";
+import { CommitTitlePrompt } from "./prompts/commit-title.prompt";
+import { CommitBodyPrompt } from "./prompts/commit-body.prompt";
+import { CommitFooterPrompt } from "./prompts/commit-footer.prompt";
+import { CommitConfirmPrompt } from "./prompts/commit-confirm.prompt";
+import { CommitStatusPrompt } from "./prompts/commit-status.prompt";
+import { flags } from "./args";
+import { get_package_version } from "./utils";
+import { infer_not_interactive } from "./utils/infer";
+import { print_help_text } from "./help";
+
+type PromptCtor = new (
+  config: InferOutput<typeof Config>,
+  commit_state: InferOutput<typeof CommitState>,
+  prompt_cache: Configstore,
+) => Runnable;
+
+const promptCtors: PromptCtor[] = [
+  CommitStatusPrompt,
+  CommitTypePrompt,
+  CommitScopePrompt,
+  CommitTicketPrompt,
+  CommitTitlePrompt,
+  CommitBodyPrompt,
+  CommitFooterPrompt,
+  CommitConfirmPrompt,
+];
+
+const { config, config_source } = load_setup();
+
+main(config, config_source);
+
+export async function main(
+  config: InferOutput<typeof Config>,
+  config_source: ConfigSource,
+) {
   chdir(get_git_root());
-  const prompt_cache = config.cache_last_value
-    ? new Configstore("better-commits")
-    : NOOP_PROMPT_CACHE;
 
-  if (config.check_status) {
-    let { index, work_tree } = git_status();
-    p.log.step(color.black(color.bgGreen(" Checking Git Status ")));
-    const staged_files = index.reduce(
-      (acc, curr, i: number) => color.green(acc + curr + addNewLine(index, i)),
-      "",
-    );
-    p.log.success("Changes to be committed:\n" + staged_files);
-    if (work_tree.length) {
-      const unstaged_files = work_tree.reduce(
-        (acc, curr, i: number) =>
-          color.red(acc + curr + addNewLine(work_tree, i)),
-        "",
-      );
-      p.log.error("Changes not staged for commit:\n" + unstaged_files);
-      const selected_for_staging = (await p.multiselect({
-        message: `Some files have not been staged, would you like to add them now? ${SPACE_TO_SELECT}`,
-        options: [
-          { value: ".", label: "." },
-          ...work_tree.map((v) => ({ value: v, label: v })),
-        ],
-        required: false,
-      })) as string[];
-      if (p.isCancel(selected_for_staging)) process.exit(0);
-      git_add(selected_for_staging);
-    }
-
-    let updated_status = git_status();
-    if (!updated_status.index.length) {
-      p.log.error(
-        color.red(
-          'no changes added to commit (use "git add" and/or "git commit -a")',
-        ),
-      );
-      process.exit(0);
-    }
+  if (flags.version) {
+    const version = get_package_version();
+    p.log.step("Better Commits v" + version);
+    return;
   }
 
-  const value_to_data: Record<string, { emoji: string; trailer: string }> =
-    config.commit_type.options.reduce(
-      (acc, curr) => ({
-        ...acc,
-        [curr.value]: {
-          emoji: curr.emoji ?? "",
-          trailer: curr.trailer ?? "",
-        },
-      }),
-      {},
-    );
-  if (config.commit_type.enable) {
-    let message = "Select a commit type";
-    let initial_value = config.commit_type.initial_value;
-    if (config.commit_type.infer_type_from_branch) {
-      const options = config.commit_type.options.map((o) => o.value);
-      const type_from_branch = infer_type_from_branch(options);
-      if (type_from_branch) {
-        message = `Commit type inferred from branch ${color.dim("(confirm / edit)")}`;
-        initial_value = type_from_branch;
-      }
-    }
-    const commit_type = await p.select({
-      message,
-      initialValue:
-        get_value_from_cache(prompt_cache, "commit_type") || initial_value,
-      maxItems: config.commit_type.max_items,
-      options: config.commit_type.options,
-    });
-    if (p.isCancel(commit_type)) process.exit(0);
-    set_value_cache(prompt_cache, "commit_type", commit_type);
-    commit_state.trailer = value_to_data[commit_type].trailer;
-    commit_state.type =
-      config.commit_type.append_emoji_to_commit &&
-      config.commit_type.emoji_commit_position === "Start"
-        ? `${value_to_data[commit_type].emoji} ${commit_type}`.trim()
-        : commit_type;
+  if (flags.help) {
+    print_help_text(config, config_source);
+    return;
   }
 
-  if (config.commit_scope.enable) {
-    let commit_scope = await p.select({
-      message: "Select a commit scope",
-      initialValue:
-        get_value_from_cache(prompt_cache, "commit_scope") ||
-        config.commit_scope.initial_value,
-      maxItems: config.commit_scope.max_items,
-      options: config.commit_scope.options,
-    });
-    if (p.isCancel(commit_scope)) process.exit(0);
-    set_value_cache(prompt_cache, "commit_scope", commit_scope);
+  const infer_state = infer_not_interactive(config);
+  const flags_plus_infer: InferInput<typeof CommitState> = {
+    ...flags.commit_state,
+    type: (flags.commit_state.type || infer_state?.type) ?? "",
+    ticket: (flags.commit_state.ticket || infer_state?.ticket) ?? "",
+  };
 
-    if (commit_scope === CUSTOM_SCOPE_KEY && config.commit_scope.custom_scope) {
-      commit_scope = await p.text({
-        message: "Write a custom scope",
-        placeholder: "",
-      });
-      if (p.isCancel(commit_scope)) process.exit(0);
-    }
-    commit_state.scope = commit_scope;
-  }
+  const commit_state = parse(CommitState, flags_plus_infer);
 
-  if (config.check_ticket.infer_ticket) {
+  if (!flags.interactive) {
     try {
-      const branch = execSync(`git ${flags.git_args} branch --show-current`, {
-        stdio: "pipe",
-      }).toString();
-      const found: string[] = [
-        branch.match(REGEX_START_UND),
-        branch.match(REGEX_SLASH_UND),
-        branch.match(REGEX_SLASH_TAG),
-        branch.match(REGEX_SLASH_NUM),
-        branch.match(REGEX_START_TAG),
-        branch.match(REGEX_START_NUM),
-      ]
-        .filter((v) => v != null)
-        .map((v) => (v && v.length >= 2 ? v[1] : ""));
-      if (found.length && found[0]) {
-        commit_state.ticket =
-          config.check_ticket.append_hashtag ||
-          config.check_ticket.prepend_hashtag === "Prompt"
-            ? "#" + found[0]
-            : found[0];
+      parse(create_strict_commit_state(config), commit_state);
+    } catch (err) {
+      if (err instanceof ValiError) {
+        p.log.error(`Invalid --no-interactive commit input: ${err.message}`);
+      } else {
+        p.log.error(`Failed to validate --no-interactive commit input: ${err}`);
       }
-    } catch (err: any) {
-      // Can't find branch, fail silently
-    }
-  }
-
-  if (config.check_ticket.confirm_ticket) {
-    const user_commit_ticket = await p.text({
-      message: commit_state.ticket
-        ? `Ticket / issue inferred from branch ${color.dim("(confirm / edit)")}`
-        : `Add ticket / issue ${OPTIONAL_PROMPT}`,
-      placeholder: "",
-      initialValue:
-        get_value_from_cache(prompt_cache, "commit_ticket") ||
-        commit_state.ticket,
-    });
-    if (p.isCancel(user_commit_ticket)) process.exit(0);
-    set_value_cache(prompt_cache, "commit_ticket", user_commit_ticket);
-    commit_state.ticket = user_commit_ticket ?? "";
-  }
-
-  if (
-    config.check_ticket.prepend_hashtag === "Always" &&
-    commit_state.ticket &&
-    !commit_state.ticket.startsWith("#")
-  ) {
-    commit_state.ticket = "#" + commit_state.ticket;
-  }
-
-  const commit_title = await p.text({
-    message: "Write a brief title describing the commit",
-    initialValue: get_value_from_cache(prompt_cache, "commit_title") || "",
-    placeholder: "",
-    validate: (value) => {
-      if (!value) return "Please enter a title";
-      const commit_scope_size = commit_state.scope
-        ? commit_state.scope.length + 2
-        : 0;
-      const commit_type_size = commit_state.type.length;
-      const commit_ticket_size = config.check_ticket.add_to_title
-        ? commit_state.ticket.length
-        : 0;
-      if (
-        commit_scope_size +
-          commit_type_size +
-          commit_ticket_size +
-          value.length >
-        config.commit_title.max_size
-      )
-        return `Exceeded max length. Title max [${config.commit_title.max_size}]`;
-    },
-  });
-  if (p.isCancel(commit_title)) process.exit(0);
-  set_value_cache(prompt_cache, "commit_title", commit_title);
-
-  let commit_title_with_emoji = commit_title;
-  if (
-    config.commit_type.append_emoji_to_commit &&
-    config.commit_type.emoji_commit_position === "After-Colon"
-  )
-    commit_title_with_emoji = `${value_to_data[commit_state.type].emoji} ${commit_title}`;
-  commit_state.title = clean_commit_title(commit_title_with_emoji);
-
-  if (config.commit_body.enable) {
-    const commit_body = await p.text({
-      message: `Write a detailed description of the changes ${OPTIONAL_PROMPT}`,
-      initialValue: get_value_from_cache(prompt_cache, "commit_body") || "",
-      placeholder: "",
-      validate: (val) => {
-        if (config.commit_body.required && !val)
-          return "Please enter a description";
-      },
-    });
-    if (p.isCancel(commit_body)) process.exit(0);
-
-    commit_state.body = commit_body ?? "";
-    if (config.commit_body.split_by_period) {
-      const sentences = commit_body.split(".").map((s) => s.trim());
-      commit_state.body = sentences.join(".\n");
-    }
-
-    set_value_cache(prompt_cache, "commit_body", commit_state.body);
-  }
-
-  if (config.commit_footer.enable) {
-    const cache_footer = get_value_from_cache(
-      prompt_cache,
-      "commit_footer",
-    ).split(",");
-    const commit_footer = await p.multiselect({
-      message: `Select optional footers ${SPACE_TO_SELECT}`,
-      initialValues: cache_footer || config.commit_footer.initial_value,
-      options: COMMIT_FOOTER_OPTIONS as {
-        value: Output<typeof V_FOOTER_OPTIONS>;
-        label: string;
-        hint: string;
-      }[],
-      required: false,
-    });
-    if (p.isCancel(commit_footer)) process.exit(0);
-    set_value_cache(prompt_cache, "commit_footer", commit_footer.join(","));
-
-    if (commit_footer.includes("breaking-change")) {
-      const breaking_changes_title = await p.text({
-        message: "Breaking changes: Write a short title / summary",
-        placeholder: "",
-        validate: (value) => {
-          if (!value) return "Please enter a title / summary";
-        },
-      });
-      if (p.isCancel(breaking_changes_title)) process.exit(0);
-      const breaking_changes_body = await p.text({
-        message: `Breaking Changes: Write a description & migration instructions ${OPTIONAL_PROMPT}`,
-        placeholder: "",
-      });
-      if (p.isCancel(breaking_changes_body)) process.exit(0);
-      commit_state.breaking_title = breaking_changes_title;
-      commit_state.breaking_body = breaking_changes_body;
-    }
-
-    if (commit_footer.includes("deprecated")) {
-      const deprecated_title = await p.text({
-        message: "Deprecated: Write a short title / summary",
-        placeholder: "",
-        validate: (value) => {
-          if (!value) return "Please enter a title / summary";
-        },
-      });
-      if (p.isCancel(deprecated_title)) process.exit(0);
-      const deprecated_body = await p.text({
-        message: `Deprecated: Write a description ${OPTIONAL_PROMPT}`,
-        placeholder: "",
-      });
-      if (p.isCancel(deprecated_body)) process.exit(0);
-      commit_state.deprecates_body = deprecated_body;
-      commit_state.deprecates_title = deprecated_title;
-    }
-
-    if (commit_footer.includes("closes")) {
-      commit_state.closes = "Closes:";
-    }
-
-    if (commit_footer.includes("custom")) {
-      const custom_footer = await p.text({
-        message: "Write a custom footer",
-        placeholder: "",
-      });
-      if (p.isCancel(custom_footer)) process.exit(0);
-      commit_state.custom_footer = custom_footer;
-    }
-
-    if (!commit_footer.includes("trailer")) {
-      commit_state.trailer = "";
+      process.exit(0);
     }
   }
 
-  if (config.confirm_with_editor) {
-    const options = config.overrides.shell
-      ? { shell: config.overrides.shell, stdio: "inherit" as StdioOptions }
-      : { stdio: "inherit" as StdioOptions };
-    const trailer = commit_state.trailer
-      ? `--trailer="${commit_state.trailer}"`
-      : "";
-    execSync(
-      `git ${flags.git_args} commit -m "${build_commit_string(commit_state, config, false, true, false)}" ${trailer} --edit`,
-      options,
-    );
-    process.exit(0);
-  }
-
-  let continue_commit = true;
-  if (config.print_commit_output) {
-    p.note(
-      build_commit_string(commit_state, config, true, false, true),
-      "Commit Preview",
-    );
-  }
-  if (config.confirm_commit) {
-    continue_commit = (await p.confirm({
-      message: "Confirm Commit?",
-    })) as boolean;
-    if (p.isCancel(continue_commit)) process.exit(0);
-  }
-
-  if (!continue_commit) {
-    p.log.info("Exiting without commit");
-    process.exit(0);
-  }
-
-  try {
-    p.log.info("Committing changes...");
-    const options = config.overrides.shell
-      ? { shell: config.overrides.shell, stdio: "inherit" as StdioOptions }
-      : { stdio: "inherit" as StdioOptions };
-    const trailer = commit_state.trailer
-      ? `--trailer="${commit_state.trailer}"`
-      : "";
-    execSync(
-      `git ${flags.git_args} commit -m "${build_commit_string(commit_state, config, false, true, false)}" ${trailer}`,
-      options,
-    );
-  } catch (err) {
-    p.log.error("Something went wrong when committing: " + err);
-  }
-  p.log.success("Commit Complete");
-
-  // Instead of deleting individual keys, just get what we need and clear.
-  const user_name = prompt_cache.get("username");
-  prompt_cache.clear();
-  if (user_name) prompt_cache.set("username", user_name);
-}
-
-function build_commit_string(
-  commit_state: Output<typeof CommitState>,
-  config: Output<typeof Config>,
-  colorize: boolean = false,
-  escape_quotes: boolean = false,
-  include_trailer: boolean = false,
-): string {
-  let commit_string = "";
-  if (commit_state.type) {
-    commit_string += colorize
-      ? color.blue(commit_state.type)
-      : commit_state.type;
-  }
-
-  if (commit_state.scope) {
-    const scope = colorize
-      ? color.cyan(commit_state.scope)
-      : commit_state.scope;
-    commit_string += `(${scope})`;
-  }
-
-  let title_ticket = commit_state.ticket;
-  const surround = config.check_ticket.surround;
-  if (commit_state.ticket && surround) {
-    const open_token = surround.charAt(0);
-    const close_token = surround.charAt(1);
-    title_ticket = `${open_token}${commit_state.ticket}${close_token}`;
-  }
-
-  const position_beginning = config.check_ticket.title_position === "beginning";
-  if (title_ticket && config.check_ticket.add_to_title && position_beginning) {
-    commit_string = `${colorize ? color.magenta(title_ticket) : title_ticket} ${commit_string}`;
-  }
-
-  const position_before_colon =
-    config.check_ticket.title_position === "before-colon";
-  if (
-    title_ticket &&
-    config.check_ticket.add_to_title &&
-    position_before_colon
-  ) {
-    const spacing =
-      commit_state.scope || (commit_state.type && !config.check_ticket.surround)
-        ? " "
-        : "";
-    commit_string += colorize
-      ? color.magenta(spacing + title_ticket)
-      : spacing + title_ticket;
-  }
-
-  if (
-    commit_state.breaking_title &&
-    config.breaking_change.add_exclamation_to_title
-  ) {
-    commit_string += colorize ? color.red("!") : "!";
-  }
-
-  if (
-    commit_state.scope ||
-    commit_state.type ||
-    (title_ticket && position_before_colon)
-  ) {
-    commit_string += ": ";
-  }
-
-  const position_start = config.check_ticket.title_position === "start";
-  const position_end = config.check_ticket.title_position === "end";
-  if (title_ticket && config.check_ticket.add_to_title && position_start) {
-    commit_string += colorize
-      ? color.magenta(title_ticket) + " "
-      : title_ticket + " ";
-  }
-
-  if (commit_state.title) {
-    commit_string += colorize
-      ? color.reset(commit_state.title)
-      : commit_state.title;
-  }
-
-  if (title_ticket && config.check_ticket.add_to_title && position_end) {
-    commit_string +=
-      " " + (colorize ? color.magenta(title_ticket) : title_ticket);
-  }
-
-  if (commit_state.body) {
-    const temp = commit_state.body.split("\\n"); // literal \n, not new-line.
-    const res = temp
-      .map((v) => (colorize ? color.reset(v.trim()) : v.trim()))
-      .join("\n");
-    commit_string += colorize ? `\n\n${res}` : `\n\n${res}`;
-  }
-
-  if (commit_state.breaking_title) {
-    const title = colorize
-      ? color.red(`BREAKING CHANGE: ${commit_state.breaking_title}`)
-      : `BREAKING CHANGE: ${commit_state.breaking_title}`;
-    commit_string += `\n\n${title}`;
-  }
-
-  if (commit_state.breaking_body) {
-    const body = colorize
-      ? color.red(commit_state.breaking_body)
-      : commit_state.breaking_body;
-    commit_string += `\n\n${body}`;
-  }
-
-  if (commit_state.deprecates_title) {
-    const title = colorize
-      ? color.yellow(`DEPRECATED: ${commit_state.deprecates_title}`)
-      : `DEPRECATED: ${commit_state.deprecates_title}`;
-    commit_string += `\n\n${title}`;
-  }
-
-  if (commit_state.deprecates_body) {
-    const body = colorize
-      ? color.yellow(commit_state.deprecates_body)
-      : commit_state.deprecates_body;
-    commit_string += `\n\n${body}`;
-  }
-
-  if (commit_state.custom_footer) {
-    const temp = commit_state.custom_footer.split("\\n");
-    const res = temp
-      .map((v) => (colorize ? color.reset(v.trim()) : v.trim()))
-      .join("\n");
-    commit_string += colorize ? `\n\n${res}` : `\n\n${res}`;
-  }
-
-  if (commit_state.closes && commit_state.ticket) {
-    commit_string += colorize
-      ? `\n\n${color.reset(commit_state.closes)} ${color.magenta(commit_state.ticket)}`
-      : `\n\n${commit_state.closes} ${commit_state.ticket}`;
-  }
+  const prompt_cache = config.cache_last_value
+    ? new Configstore("better-commits")
+    : NOOP_PROMPT_CACHE;
 
-  if (include_trailer && commit_state.trailer) {
-    commit_string += colorize
-      ? `\n\n${color.dim(commit_state.trailer)}`
-      : `\n\n${commit_state.trailer}`;
-  }
+  const prompts_to_run = flags.interactive
+    ? promptCtors
+    : [CommitConfirmPrompt];
 
-  if (escape_quotes) {
-    commit_string = commit_string.replaceAll('"', '\\"').replaceAll("`", "\\`");
+  for (const Prompt of prompts_to_run) {
+    await new Prompt(config, commit_state, prompt_cache).run();
   }
-
-  return commit_string;
 }

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

@@ -0,0 +1,36 @@
+import { InferOutput } from "valibot";
+import { BranchRunnable } from "./branch-runnable";
+import { V_BRANCH_ACTIONS } from "../valibot-consts";
+import * as p from "@clack/prompts";
+import { BRANCH_ACTION_OPTIONS } from "../utils";
+
+export class BranchCheckoutPrompt extends BranchRunnable {
+  async run(): Promise<void> {
+    if (this.#is_enabled) {
+      const branch_or_worktree = await p.select({
+        message: this.#message,
+        initialValue: this.#initival_values,
+        options: BRANCH_ACTION_OPTIONS,
+      });
+
+      if (p.isCancel(branch_or_worktree)) process.exit();
+      this.#post_run_effects(branch_or_worktree);
+    }
+  }
+
+  get #message() {
+    return `Checkout a branch or create a worktree?`;
+  }
+
+  get #is_enabled() {
+    return this.config.worktrees.enable;
+  }
+
+  get #initival_values() {
+    return this.branch_state.checkout || this.config.branch_action_default;
+  }
+
+  #post_run_effects(value: InferOutput<typeof V_BRANCH_ACTIONS>) {
+    this.branch_state.checkout = value;
+  }
+}