better-commits 1.19.0 → 1.20.0-cli-flags

package/src/branch.ts

@@ -1,263 +1,92 @@
 #! /usr/bin/env node
 
-import * as p from "@clack/prompts";
-import { execSync } from "child_process";
 import Configstore from "configstore";
-import color from "picocolors";
 import { chdir } from "process";
-import { Output, parse } from "valibot";
-import {
-  V_BRANCH_ACTIONS,
-  V_BRANCH_CONFIG_FIELDS,
-  V_BRANCH_FIELDS,
-} from "./valibot-consts";
+import { InferOutput, ValiError, parse } from "valibot";
 import { BranchState, CommitState, Config } from "./valibot-state";
 import {
-  BRANCH_ACTION_OPTIONS,
-  CACHE_PROMPT,
-  OPTIONAL_PROMPT,
   load_setup,
   get_git_root,
+  NOOP_PROMPT_CACHE,
+  ConfigSource,
 } from "./utils";
-import { flags } from "./args";
-
-main(load_setup(" better-branch "));
-
-async function main(config: Output<typeof Config>) {
-  const branch_state = parse(BranchState, {});
-  chdir(get_git_root());
-
-  let checkout_type: Output<typeof V_BRANCH_ACTIONS> = "branch";
-  if (config.worktrees.enable) {
-    const branch_or_worktree = await p.select({
-      message: `Checkout a branch or create a worktree?`,
-      initialValue: config.branch_action_default,
-      options: BRANCH_ACTION_OPTIONS,
-    });
-
-    if (p.isCancel(branch_or_worktree)) process.exit();
-    checkout_type = branch_or_worktree;
-  }
-
-  if (config.branch_user.enable) {
-    const cache_user_name = get_user_from_cache();
-    const user_name_required = config.branch_user.required;
-    const user_name = await p.text({
-      message: `Type your git username ${
-        user_name_required ? "" : OPTIONAL_PROMPT
-      } ${CACHE_PROMPT}`.trim(),
-      placeholder: "",
-      initialValue: cache_user_name,
-      validate: (val) => {
-        if (user_name_required && !val) return "Please enter a username";
-      },
-    });
-    if (p.isCancel(user_name)) process.exit(0);
-    branch_state.user = user_name?.replace(/\s+/g, "-")?.toLowerCase() ?? "";
-    set_user_cache(branch_state.user);
-  }
+import { BranchRunnable } from "./prompts/branch-runnable";
+import { BranchCheckoutPrompt } from "./prompts/branch-checkout.prompt";
+import { BranchUserPrompt } from "./prompts/branch-user.prompt";
+import { BranchTypePrompt } from "./prompts/branch-type.prompt";
+import { BranchTicketPrompt } from "./prompts/branch-ticket.prompt";
+import { BranchVersionPrompt } from "./prompts/branch-version.prompt";
+import { BranchDescriptionPrompt } from "./prompts/branch-description.prompt";
+import { BranchConfirmPrompt } from "./prompts/branch-confirm.prompt";
+import { branch_flags } from "./branch-args";
+import { print_help_text } from "./branch-help";
+import { create_strict_branch_state } from "./utils/no-interactive-validation";
+import { get_package_version } from "./utils";
+import * as p from "@clack/prompts";
 
-  if (config.branch_type.enable) {
-    let initial_value = config.commit_type.initial_value;
-    const commit_type = await p.select({
-      message: `Select a branch type`,
-      initialValue: initial_value,
-      options: config.commit_type.options,
-    });
-    if (p.isCancel(commit_type)) process.exit(0);
-    branch_state.type = commit_type;
-  }
+type PromptCtor = new (
+  config: InferOutput<typeof Config>,
+  commit_state: InferOutput<typeof BranchState>,
+  prompt_cache: Configstore,
+) => BranchRunnable;
+
+const promptCtors: PromptCtor[] = [
+  BranchCheckoutPrompt,
+  BranchUserPrompt,
+  BranchTypePrompt,
+  BranchTicketPrompt,
+  BranchVersionPrompt,
+  BranchDescriptionPrompt,
+  BranchConfirmPrompt,
+];
+
+const { config, config_source } = load_setup(
+  " better-branch ",
+  branch_flags.git_args,
+);
+
+main(config, config_source);
+
+async function main(
+  config: InferOutput<typeof Config>,
+  config_source: ConfigSource,
+) {
+  chdir(get_git_root(branch_flags.git_args));
 
-  if (config.branch_ticket.enable) {
-    const ticked_required = config.branch_ticket.required;
-    const ticket = await p.text({
-      message: `Type ticket / issue number ${
-        ticked_required ? "" : OPTIONAL_PROMPT
-      }`.trim(),
-      placeholder: "",
-      validate: (val) => {
-        if (ticked_required && !val) return "Please enter a ticket / issue";
-      },
-    });
-    if (p.isCancel(ticket)) process.exit(0);
-    branch_state.ticket = ticket;
+  if (branch_flags.version) {
+    const version = get_package_version();
+    p.log.step("Better Commits v" + version);
+    return;
   }
 
-  if (config.branch_version.enable) {
-    const version_required = config.branch_version.required;
-    const version = await p.text({
-      message: `Type version number ${
-        version_required ? "" : OPTIONAL_PROMPT
-      }`.trim(),
-      placeholder: "",
-      validate: (val) => {
-        if (version_required && !val) return "Please enter a version";
-      },
-    });
-    if (p.isCancel(version)) process.exit(0);
-    branch_state.version = version;
+  if (branch_flags.help) {
+    print_help_text(config, config_source);
+    return;
   }
 
-  const description_max_length = config.branch_description.max_length;
-  const description = await p.text({
-    message: "Type a short description",
-    placeholder: "",
-    validate: (value) => {
-      if (!value) return "Please enter a description";
-      if (value.length > description_max_length)
-        return `Exceeded max length. Description max [${description_max_length}]`;
-    },
-  });
-  if (p.isCancel(description)) process.exit(0);
-  branch_state.description =
-    description?.replace(/\s+/g, "-")?.toLowerCase() ?? "";
+  const branch_state = parse(BranchState, branch_flags.branch_state);
 
-  const pre_commands =
-    checkout_type === "worktree"
-      ? config.worktree_pre_commands
-      : config.branch_pre_commands;
-  pre_commands.forEach((command) => {
+  if (!branch_flags.interactive) {
     try {
-      execSync(command, { stdio: "inherit" });
-    } catch (err) {
-      p.log.error("Something went wrong when executing pre-commands: " + err);
-      process.exit(0);
-    }
-  });
-
-  const branch_name = build_branch(branch_state, config);
-  const branch_flag = verify_branch_name(branch_name);
-  if (checkout_type === "branch") {
-    try {
-      execSync(`git ${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);
-    }
-  } else {
-    try {
-      const worktree_name = build_worktree_path(branch_state, config);
-      execSync(
-        `git 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);
+      parse(create_strict_branch_state(config), branch_state);
     } catch (err) {
+      if (err instanceof ValiError) {
+        p.log.error(`Invalid branch input: ${err.message}`);
+      } else {
+        p.log.error(`Failed to validate branch input: ${err}`);
+      }
       process.exit(0);
     }
   }
 
-  const post_commands =
-    checkout_type === "worktree"
-      ? config.worktree_post_commands
-      : config.branch_post_commands;
-  post_commands.forEach((command) => {
-    try {
-      execSync(command, { stdio: "inherit" });
-    } catch (err) {
-      p.log.error("Something went wrong when executing post-commands: " + err);
-      process.exit(0);
-    }
-  });
-}
-
-function build_branch(
-  branch: Output<typeof BranchState>,
-  config: Output<typeof Config>,
-) {
-  let res = "";
-  config.branch_order.forEach((b: Output<typeof V_BRANCH_FIELDS>) => {
-    const config_key: Output<typeof V_BRANCH_CONFIG_FIELDS> = `branch_${b}`;
-    if (branch[b]) res += branch[b] + config[config_key].separator;
-  });
-  if (res.endsWith("-") || res.endsWith("/") || res.endsWith("_")) {
-    return res.slice(0, -1).trim();
-  }
-  return res.trim();
-}
-
-function build_worktree_path(
-  branch_state: Output<typeof BranchState>,
-  config: Output<typeof Config>,
-): string {
-  const gitRoot = get_git_root();
-  const repo_name = gitRoot.split("/").pop() || "repo";
-
-  let worktree_name = config.worktrees.folder_template;
-
-  worktree_name = worktree_name
-    .replace("{{repo_name}}", repo_name)
-    .replace("{{branch_description}}", branch_state.description)
-    .replace("{{user}}", branch_state.user || "")
-    .replace("{{type}}", branch_state.type || "")
-    .replace("{{ticket}}", branch_state.ticket || "")
-    .replace("{{version}}", branch_state.version || "");
-
-  worktree_name = worktree_name
-    .replace(/\s/g, "")
-    .replace(/--+/g, "-")
-    .replace(/^-+|-+$/g, "");
-
-  const base_path = config.worktrees.base_path;
-  return `${base_path}${base_path.endsWith("/") ? "" : "/"}${worktree_name}`;
-}
-
-function get_user_from_cache(): string {
-  try {
-    const config_store = new Configstore("better-commits");
-    return config_store.get("username") ?? "";
-  } catch (err) {
-    p.log.warn(
-      'There was an issue accessing username from cache. Check that the folder "~/.config" exists',
-    );
-  }
-
-  return "";
-}
-
-function verify_branch_name(branch_name: string): string {
-  // TODO: There has to be a better way 🤦
-  let branch_flag = "";
-  try {
-    execSync(`git 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;
-}
-
-function set_user_cache(val: string): void {
-  try {
-    const config_store = new Configstore("better-commits");
-    config_store.set("username", val);
-  } catch (err) {
-    // fail silently, user has likely already seen guidance via get exceptions at this point
+  const prompt_cache = config.cache_last_value
+    ? new Configstore("better-commits")
+    : NOOP_PROMPT_CACHE;
+  const prompts_to_run = branch_flags.interactive
+    ? promptCtors
+    : [BranchConfirmPrompt];
+  for (const Prompt of prompts_to_run) {
+    await new Prompt(config, branch_state, prompt_cache).run();
   }
 }
 

package/src/help.ts

@@ -0,0 +1,131 @@
+import { execSync } from "child_process";
+import { InferOutput } from "valibot";
+import { flags } from "./args";
+import { get_package_version } from "./utils";
+import { infer_ticket_from_git, infer_type_from_git } from "./utils/infer";
+import { Config } from "./valibot-state";
+import color from "picocolors";
+
+const ADDITIONAL_COMMAND_DEFINITIONS: Record<string, string> = {
+  "better-branch": "Create a branch or worktree from a guided prompt flow.",
+  "better-commits-init":
+    "Create a .better-commits.json config in this repository.",
+};
+
+const CLI_FLAG_DEFINITIONS: Record<string, string> = {
+  "--interactive": "Run in interactive prompt mode (default behavior).",
+  "--dry-run": "Print the commit command without creating a commit.",
+  "--help": "Show help information and exit.",
+};
+
+const COMMIT_FLAG_DEFINITIONS: Record<string, string> = {
+  "--type": "Set commit type (for example feat, fix, docs).",
+  "--scope": "Set commit scope.",
+  "--title": "Set commit title/description.",
+  "--body": "Set commit body text.",
+  "--closes": "Set issue/ticket id for a closes footer.",
+  "--ticket": "Set ticket value used in the title.",
+  "--trailer": "Set trailer footer value.",
+  "--deprecates": "Set issue/ticket id for a deprecates footer.",
+  "--breaking-title": "Set breaking-change title footer.",
+  "--breaking-body": "Set breaking-change body footer.",
+  "--deprecates-title": "Set deprecates footer title text.",
+  "--deprecates-body": "Set deprecates footer body text.",
+  "--custom-footer": "Set a custom footer line.",
+};
+
+const GIT_FLAG_DEFINITIONS: Record<string, string> = {
+  "--git-dir": "Set the path to the .git directory.",
+  "--work-tree": "Set the path to the working tree root.",
+};
+
+function to_definition_lines(definitions: Record<string, string>): string {
+  const description_column = 26;
+  const minimum_spacing = 2;
+  const indent = " ";
+
+  return Object.entries(definitions)
+    .map(([name, description]) => {
+      const spaces = Math.max(
+        minimum_spacing,
+        description_column - name.length,
+      );
+      return `${indent}${name}${" ".repeat(spaces)}${description}`;
+    })
+    .join("\n");
+}
+
+export function print_help_text(
+  config: InferOutput<typeof Config>,
+  config_source: "repository" | "global" | "none",
+) {
+  const version = get_package_version();
+
+  let branch = "(none)";
+  try {
+    branch =
+      execSync(`git ${flags.git_args} branch --show-current`, { stdio: "pipe" })
+        .toString()
+        .trim() || "(none)";
+  } catch {
+    // noop
+  }
+
+  const inferred_type =
+    infer_type_from_git(config.commit_type.options, flags.git_args) ||
+    "Unknown";
+  const inferred_ticket = config.check_ticket.infer_ticket
+    ? infer_ticket_from_git(
+        {
+          append_hashtag: config.check_ticket.append_hashtag,
+          prepend_hashtag: config.check_ticket.prepend_hashtag,
+        },
+        flags.git_args,
+      ) || "Unknown"
+    : "Infer Disabled";
+
+  const types = config.commit_type.options
+    .map((option) => option.value)
+    .join(", ")
+    .trim();
+  const scopes = config.commit_scope.options
+    .map((option) => option.value)
+    .join(", ")
+    .trim();
+  const cli_flags = to_definition_lines(CLI_FLAG_DEFINITIONS);
+  const git_flags = to_definition_lines(GIT_FLAG_DEFINITIONS);
+  const commit_flags = to_definition_lines(COMMIT_FLAG_DEFINITIONS);
+  const additional_commands = to_definition_lines(
+    ADDITIONAL_COMMAND_DEFINITIONS,
+  );
+
+  console.log(`
+${color.green(" better-commits")} ${color.gray("v" + version)}
+
+${color.gray("BRANCH")} 
+ ${branch}
+ ${color.gray("Type")} ${color.blue(inferred_type)} ${color.gray("·")} ${color.gray("Ticket")} ${color.magenta(inferred_ticket)}
+
+${color.gray("CONFIGURATION")} 
+ ${config_source}
+
+${color.gray("Types")} 
+ ${types}
+
+${color.gray("Scopes")} 
+ ${scopes}
+
+${color.gray("CLI FLAGS")} 
+${cli_flags}
+
+${color.gray("Commit Flags")} 
+${commit_flags}
+
+${color.gray("Git Flags (Advanced)")} 
+${git_flags}
+
+${color.gray("ADDITIONAL COMMANDS")} 
+${additional_commands}
+
+`);
+}

package/src/index.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest";
+
+describe("project test setup", () => {
+  it("runs Vitest in this TypeScript project", () => {
+    expect(true).toBe(true);
+  });
+});