better-commits 1.23.2 → 1.23.3

package/dist/branch.js

@@ -1,28 +1,637 @@
 #! /usr/bin/env node
-import{c as q,e as j,f as U,g as W,j as g}from"./chunk-43H72S6V.js";import{a as F,e as E,j as G,k as L,l as V,m as f,o as l,r as D,s as H}from"./chunk-B7AGSPP3.js";import gt from"configstore";import{chdir as ut}from"process";import{ValiError as _t,parse as J}from"valibot";var a=class{constructor(t,e,n){this.config=t;this.branch_state=e;this.prompt_cache=n}};import*as b from"@clack/prompts";var d=class extends a{async run(){if(this.#e){let t=await b.select({message:this.#t,initialValue:this.#r,options:G});b.isCancel(t)&&process.exit(),this.#n(t)}}get#t(){return"Checkout a branch or create a worktree?"}get#e(){return this.config.worktrees.enable}get#r(){return this.branch_state.checkout||this.config.branch_action_default}#n(t){this.branch_state.checkout=t}};import*as v from"@clack/prompts";var y=class extends a{async run(){if(!this.#t)return;let t=await v.text({message:this.#r,placeholder:"",initialValue:this.#n,validate:e=>this.#i(e)});v.isCancel(t)&&process.exit(0),this.#o(t??"")}get#t(){return this.config.branch_user.enable}get#e(){return this.config.branch_user.required}get#r(){return this.#e?"Type your git username":g("Type your git username")}get#n(){return this.branch_state.user||D(this.prompt_cache,"username")}#i(t){if(this.#e&&!t)return"Please enter a username"}#o(t){this.branch_state.user=t.replace(/\s+/g,"-").toLowerCase(),H(this.prompt_cache,"username",this.branch_state.user)}};import*as u from"@clack/prompts";var k=class extends a{async run(){if(!this.#t)return;let e=await(this.config.branch_type.autocomplete?u.autocomplete:u.select)({message:this.#e,initialValue:this.#r,options:this.#n});u.isCancel(e)&&process.exit(0),this.#i(e)}get#t(){return this.config.branch_type.enable}get#e(){return"Select a branch type"}get#r(){return this.branch_state.type||this.config.commit_type.initial_value}get#n(){return this.config.commit_type.options}#i(t){this.branch_state.type=t}};import*as p from"@clack/prompts";var w=class extends a{async run(){if(!this.#t)return;let e=await(this.config.branch_scope.autocomplete?p.autocomplete:p.select)({message:this.#e,initialValue:this.#r,options:this.#n});p.isCancel(e)&&process.exit(0),await this.#o(e)}get#t(){return this.config.branch_scope.enable}get#e(){return"Select a branch scope"}get#r(){return this.branch_state.scope||this.config.commit_scope.initial_value}get#n(){return this.config.commit_scope.options}get#i(){return this.config.commit_scope.custom_scope}async#o(t){let e=t;if(e===F&&this.#i){let n=await p.text({message:"Write a custom scope",placeholder:""});p.isCancel(n)&&process.exit(0),e=n??""}this.branch_state.scope=e}};import*as C from"@clack/prompts";var x=class extends a{async run(){if(!this.#t)return;let t=await C.text({message:this.#r,placeholder:"",validate:e=>this.#n(e),initialValue:this.branch_state.ticket});C.isCancel(t)&&process.exit(0),this.#i(t??"")}get#t(){return this.config.branch_ticket.enable}get#e(){return this.config.branch_ticket.required}get#r(){return this.#e?"Type ticket / issue number":g("Type ticket / issue number")}#n(t){if(this.#e&&!t)return"Please enter a ticket / issue"}#i(t){this.branch_state.ticket=t}};import*as S from"@clack/prompts";var $=class extends a{async run(){if(!this.#t)return;let t=await S.text({message:this.#r,placeholder:"",validate:e=>this.#n(e),initialValue:this.branch_state.version});S.isCancel(t)&&process.exit(0),this.#i(t??"")}get#t(){return this.config.branch_version.enable}get#e(){return this.config.branch_version.required}get#r(){return this.#e?"Type version number":g("Type version number")}#n(t){if(this.#e&&!t)return"Please enter a version"}#i(t){this.branch_state.version=t}};import*as O from"@clack/prompts";var I=class extends a{async run(){let t=await O.text({message:this.#t,placeholder:"",validate:e=>this.#r(e),initialValue:this.branch_state.description});O.isCancel(t)&&process.exit(0),this.#n(t??"")}get#t(){return"Type a short description"}get#e(){return this.config.branch_description.max_length}#r(t){if(!t)return"Please enter a description";if(t.length>this.#e)return`Exceeded max length. Description max [${this.#e}]`}#n(t){this.branch_state.description=t.replace(/\s+/g,"-").toLowerCase()}};import*as m from"@clack/prompts";import{execSync as B}from"child_process";import h from"picocolors";import{chdir as at}from"process";import{parse as rt}from"@bomb.sh/args";var M=["user","type","scope","description","ticket","branch-version","checkout"],nt=["git-dir","work-tree"],it=["interactive","dry-run","help","version"],T=class{#t;constructor(t){this.#t=t}get interactive(){return!this.#t.no_interactive}get dry_run(){return this.#t.dry_run}get help(){return this.#t.help}get version(){return this.#t.version}get git_args(){return this.#t.git_args}get branch_state(){return this.#t.branch_state}},o=new T(ot(process.argv.slice(2)));function ot(r){let t=rt(r,{alias:{h:"help",v:"version"},boolean:it,string:[...M,...nt]}),e={};return M.forEach(n=>{let i=t[n];if(i){let s=n==="branch-version"?"version":n.replace("-","_");s==="checkout"?e[s]=i??"branch":e[s]=i}}),{help:t.help===!0,version:t.version===!0,git_args:st(t["git-dir"],t["work-tree"]),no_interactive:t.interactive===!1,dry_run:t["dry-run"]===!0,branch_state:e}}function st(r,t){return`${r?`--git-dir=${r}`:""} ${t?`--work-tree=${t}`:""}`.trim()}function K(r,t){let e="";return t.branch_order.forEach(n=>{let i=`branch_${n}`;r[n]&&(e+=r[n]+t[i].separator)}),e.endsWith("-")||e.endsWith("/")||e.endsWith("_")?e.slice(0,-1).trim():e.trim()}function Y(r,t,e){let n=e.split("/").pop()||"repo",i=t.worktrees.folder_template;i=i.replace("{{repo_name}}",n).replace("{{branch_description}}",r.description).replace("{{user}}",r.user||"").replace("{{type}}",r.type||"").replace("{{scope}}",r.scope||"").replace("{{ticket}}",r.ticket||"").replace("{{version}}",r.version||""),i=i.replace(/\s/g,"").replace(/--+/g,"-").replace(/^-+|-+$/g,"");let s=t.worktrees.base_path;return`${s}${s.endsWith("/")?"":"/"}${i}`}var _=class extends a{async run(){this.#i(),this.#o(),this.#c()}get#t(){return this.branch_state.checkout==="worktree"}get#e(){return this.#t?this.config.worktree_pre_commands:this.config.branch_pre_commands}get#r(){return this.#t?this.config.worktree_post_commands:this.config.branch_post_commands}get#n(){return K(this.branch_state,this.config)}#i(){this.#a(this.#e,"Something went wrong when executing pre-commands: ")}#o(){let t=this.#n,e=this.#p(t);if(!this.#t){let n=`git ${o.git_args} checkout ${e} ${t}`;if(o.dry_run){this.#s(n);return}try{B(n,{stdio:"inherit"}),m.log.info(`Switched to a new branch '${h.bgGreen(" "+h.black(t)+" ")}'`)}catch{process.exit(0)}return}try{let n=Y(this.branch_state,this.config,f(o.git_args)),i=`git ${o.git_args} worktree add ${n} ${e} ${t}`;if(o.dry_run){this.#s(i);return}B(i,{stdio:"inherit"}),m.log.info(`Created a new worktree ${h.bgGreen(" "+h.black(n)+" ")}, checked out branch ${h.bgGreen(" "+h.black(t)+" ")}`),m.log.info(h.bgMagenta(h.black(` cd ${n} `))+" to navigate to your new worktree"),at(n)}catch{process.exit(0)}}#c(){this.#a(this.#r,"Something went wrong when executing post-commands: ")}#a(t,e){t.forEach(n=>{if(o.dry_run){this.#s(n);return}try{B(n,{stdio:"inherit"})}catch(i){m.log.error(e+i),process.exit(0)}})}#s(t){m.log.info(`Dry run: ${t}`)}#p(t){let e="";try{B(`git ${o.git_args} show-ref ${t}`,{encoding:"utf-8"}),m.log.warning(h.yellow(`${t} already exists! Checking out existing branch.`))}catch{e="-b"}return e}};import{execSync as ct}from"child_process";import c from"picocolors";var pt={"--interactive":"Run in interactive prompt mode (default behavior).","--dry-run":"Print branch commands without creating a branch or worktree.","--help":"Show help information and exit."},ht={"--user":"Set branch username segment.","--type":"Set branch type (for example feat, fix, docs).","--scope":"Set branch scope segment.","--description":"Set branch description segment.","--ticket":"Set branch ticket/issue segment.","--branch-version":"Set branch version segment.","--checkout":"Choose branch or worktree checkout mode."},mt={"--git-dir":"Set the path to the .git directory.","--work-tree":"Set the path to the working tree root."};function A(r){let n=" ";return Object.entries(r).map(([i,s])=>{let P=Math.max(2,26-i.length);return`${n}${i}${" ".repeat(P)}${s}`}).join(`
-`)}function z(r,t){let e=l(),n="(none)";try{n=ct(`git ${o.git_args} branch --show-current`,{stdio:"pipe"}).toString().trim()||"(none)"}catch{}let i=j(r.commit_type.options,o.git_args)||"Unknown",s=r.check_ticket.infer_ticket?U({append_hashtag:r.check_ticket.append_hashtag,prepend_hashtag:r.check_ticket.prepend_hashtag},o.git_args)||"Unknown":"Infer Disabled",P=r.commit_scope.infer_scope_from_branch?W(r.commit_scope.options,o.git_args)||"Unknown":"Infer Disabled",Q=r.commit_type.options.map(N=>N.value).join(", ").trim(),X=r.commit_scope.options.map(N=>N.value).join(", ").trim(),Z=A(pt),tt=A(mt),et=A(ht);console.log(`
-${c.green("\uF489 better-branch")} ${c.gray("v"+e)}
+import {
+  create_strict_branch_state,
+  infer_scope_from_git,
+  infer_ticket_from_git,
+  infer_type_from_git,
+  optional_message
+} from "./chunk-H5CLUQIL.js";
+import {
+  BRANCH_ACTION_OPTIONS,
+  BranchState,
+  CUSTOM_SCOPE_KEY,
+  NOOP_PROMPT_CACHE,
+  get_git_root,
+  get_package_version,
+  get_value_from_cache,
+  load_setup,
+  set_value_cache
+} from "./chunk-GAAS3VS3.js";
 
-${c.gray("BRANCH")} 
- ${n}
- ${c.gray("Type")} ${c.blue(i)} ${c.gray("\xB7")} ${c.gray("Scope")} ${c.cyan(P)} ${c.gray("\xB7")} ${c.gray("Ticket")} ${c.magenta(s)}
+// src/branch.ts
+import Configstore from "configstore";
+import { chdir as chdir2 } from "process";
+import { ValiError, parse as parse2 } from "valibot";
 
-${c.gray("CONFIGURATION")} 
- ${t}
+// src/prompts/branch-runnable.ts
+var BranchRunnable = class {
+  constructor(config2, branch_state, prompt_cache) {
+    this.config = config2;
+    this.branch_state = branch_state;
+    this.prompt_cache = prompt_cache;
+  }
+};
 
-${c.gray("Types")} 
- ${Q}
+// src/prompts/branch-checkout.prompt.ts
+import * as p from "@clack/prompts";
+var BranchCheckoutPrompt = class extends BranchRunnable {
+  async run() {
+    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) {
+    this.branch_state.checkout = value;
+  }
+};
 
-${c.gray("Scopes")} 
- ${X}
+// src/prompts/branch-user.prompt.ts
+import * as p2 from "@clack/prompts";
+var BranchUserPrompt = class extends BranchRunnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const user_name = await p2.text({
+      message: this.#message,
+      placeholder: "",
+      initialValue: this.#initial_value,
+      validate: (value) => this.#validate(value)
+    });
+    if (p2.isCancel(user_name))
+      process.exit(0);
+    this.#run_post_effects(user_name ?? "");
+  }
+  get #is_enabled() {
+    return this.config.branch_user.enable;
+  }
+  get #is_required() {
+    return this.config.branch_user.required;
+  }
+  get #message() {
+    return this.#is_required ? "Type your git username" : optional_message("Type your git username");
+  }
+  get #initial_value() {
+    return this.branch_state.user || get_value_from_cache(this.prompt_cache, "username");
+  }
+  #validate(value) {
+    if (this.#is_required && !value)
+      return "Please enter a username";
+  }
+  #run_post_effects(prompt_result) {
+    this.branch_state.user = prompt_result.replace(/\s+/g, "-").toLowerCase();
+    set_value_cache(this.prompt_cache, "username", this.branch_state.user);
+  }
+};
 
-${c.gray("CLI FLAGS")} 
-${Z}
+// src/prompts/branch-type.prompt.ts
+import * as p3 from "@clack/prompts";
+var BranchTypePrompt = class extends BranchRunnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const prompt_type = this.config.branch_type.autocomplete ? p3.autocomplete : p3.select;
+    const branch_type = await prompt_type({
+      message: this.#message,
+      initialValue: this.#initial_value,
+      options: this.#options
+    });
+    if (p3.isCancel(branch_type))
+      process.exit(0);
+    this.#run_post_effects(branch_type);
+  }
+  get #is_enabled() {
+    return this.config.branch_type.enable;
+  }
+  get #message() {
+    return "Select a branch type";
+  }
+  get #initial_value() {
+    return this.branch_state.type || this.config.commit_type.initial_value;
+  }
+  get #options() {
+    return this.config.commit_type.options;
+  }
+  #run_post_effects(prompt_result) {
+    this.branch_state.type = prompt_result;
+  }
+};
 
-${c.gray("Branch Flags")} 
-${et}
+// src/prompts/branch-scope.prompt.ts
+import * as p4 from "@clack/prompts";
+var BranchScopePrompt = class extends BranchRunnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const prompt_type = this.config.branch_scope.autocomplete ? p4.autocomplete : p4.select;
+    const branch_scope = await prompt_type({
+      message: this.#message,
+      initialValue: this.#initial_value,
+      options: this.#options
+    });
+    if (p4.isCancel(branch_scope))
+      process.exit(0);
+    await this.#run_post_effects(branch_scope);
+  }
+  get #is_enabled() {
+    return this.config.branch_scope.enable;
+  }
+  get #message() {
+    return "Select a branch scope";
+  }
+  get #initial_value() {
+    return this.branch_state.scope || this.config.commit_scope.initial_value;
+  }
+  get #options() {
+    return this.config.commit_scope.options;
+  }
+  get #custom_scope_enabled() {
+    return this.config.commit_scope.custom_scope;
+  }
+  async #run_post_effects(prompt_result) {
+    let branch_scope_value = prompt_result;
+    if (branch_scope_value === CUSTOM_SCOPE_KEY && this.#custom_scope_enabled) {
+      const branch_scope = await p4.text({
+        message: "Write a custom scope",
+        placeholder: ""
+      });
+      if (p4.isCancel(branch_scope))
+        process.exit(0);
+      branch_scope_value = branch_scope ?? "";
+    }
+    this.branch_state.scope = branch_scope_value;
+  }
+};
 
-${c.gray("Git Flags (Advanced)")} 
-${tt}
+// src/prompts/branch-ticket.prompt.ts
+import * as p5 from "@clack/prompts";
+var BranchTicketPrompt = class extends BranchRunnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const ticket = await p5.text({
+      message: this.#message,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+      initialValue: this.branch_state.ticket
+    });
+    if (p5.isCancel(ticket))
+      process.exit(0);
+    this.#run_post_effects(ticket ?? "");
+  }
+  get #is_enabled() {
+    return this.config.branch_ticket.enable;
+  }
+  get #is_required() {
+    return this.config.branch_ticket.required;
+  }
+  get #message() {
+    return this.#is_required ? "Type ticket / issue number" : optional_message("Type ticket / issue number");
+  }
+  #validate(value) {
+    if (this.#is_required && !value)
+      return "Please enter a ticket / issue";
+  }
+  #run_post_effects(prompt_result) {
+    this.branch_state.ticket = prompt_result;
+  }
+};
 
-`)}import*as R from"@clack/prompts";var ft=[d,y,k,x,w,$,I,_],{config:lt,config_source:dt}=V(" better-branch ",o.git_args);bt(lt,dt);async function bt(r,t){if(ut(f(o.git_args)),o.version){let s=l();R.log.step("Better Commits v"+s);return}if(o.help){z(r,t);return}let e=J(E,o.branch_state);if(!o.interactive)try{J(q(r),e)}catch(s){s instanceof _t?R.log.error(`Invalid branch input: ${s.message}`):R.log.error(`Failed to validate branch input: ${s}`),process.exit(0)}let n=r.cache_last_value?new gt("better-commits"):L,i=o.interactive?ft:[_];for(let s of i)await new s(r,e,n).run()}
+// src/prompts/branch-version.prompt.ts
+import * as p6 from "@clack/prompts";
+var BranchVersionPrompt = class extends BranchRunnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const version = await p6.text({
+      message: this.#message,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+      initialValue: this.branch_state.version
+    });
+    if (p6.isCancel(version))
+      process.exit(0);
+    this.#run_post_effects(version ?? "");
+  }
+  get #is_enabled() {
+    return this.config.branch_version.enable;
+  }
+  get #is_required() {
+    return this.config.branch_version.required;
+  }
+  get #message() {
+    return this.#is_required ? "Type version number" : optional_message("Type version number");
+  }
+  #validate(value) {
+    if (this.#is_required && !value)
+      return "Please enter a version";
+  }
+  #run_post_effects(prompt_result) {
+    this.branch_state.version = prompt_result;
+  }
+};
+
+// src/prompts/branch-description.prompt.ts
+import * as p7 from "@clack/prompts";
+var BranchDescriptionPrompt = class extends BranchRunnable {
+  async run() {
+    const description = await p7.text({
+      message: this.#message,
+      placeholder: "",
+      validate: (value) => this.#validate(value),
+      initialValue: this.branch_state.description
+    });
+    if (p7.isCancel(description))
+      process.exit(0);
+    this.#run_post_effects(description ?? "");
+  }
+  get #message() {
+    return "Type a short description";
+  }
+  get #max_length() {
+    return this.config.branch_description.max_length;
+  }
+  #validate(value) {
+    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) {
+    this.branch_state.description = prompt_result.replace(/\s+/g, "-").toLowerCase();
+  }
+};
+
+// src/prompts/branch-confirm.prompt.ts
+import * as p8 from "@clack/prompts";
+import { execSync } from "child_process";
+import color from "picocolors";
+import { chdir } from "process";
+
+// src/branch-args.ts
+import { parse } from "@bomb.sh/args";
+var BRANCH_OPTIONS = [
+  "user",
+  "type",
+  "scope",
+  "description",
+  "ticket",
+  "branch-version",
+  "checkout"
+];
+var GIT_OPTIONS = ["git-dir", "work-tree"];
+var BOOLEAN_FLAGS = [
+  "interactive",
+  "dry-run",
+  "help",
+  "version"
+];
+var BranchFlags = class {
+  #runtime;
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  get interactive() {
+    return !this.#runtime.no_interactive;
+  }
+  get dry_run() {
+    return this.#runtime.dry_run;
+  }
+  get help() {
+    return this.#runtime.help;
+  }
+  get version() {
+    return this.#runtime.version;
+  }
+  get git_args() {
+    return this.#runtime.git_args;
+  }
+  get branch_state() {
+    return this.#runtime.branch_state;
+  }
+};
+var branch_flags = new BranchFlags(
+  parse_branch_runtime_flags(process.argv.slice(2))
+);
+function parse_branch_runtime_flags(argv) {
+  const parsed = parse(argv, {
+    alias: { h: "help", v: "version" },
+    boolean: BOOLEAN_FLAGS,
+    string: [...BRANCH_OPTIONS, ...GIT_OPTIONS]
+  });
+  const branch_state = {};
+  BRANCH_OPTIONS.forEach((value) => {
+    const cli_value = parsed[value];
+    if (cli_value) {
+      const str = value === "branch-version" ? "version" : value.replace("-", "_");
+      if (str === "checkout")
+        branch_state[str] = cli_value ?? "branch";
+      else if (str === "description")
+        branch_state[str] = cli_value.replace(/\s+/g, "-").toLowerCase();
+      else
+        branch_state[str] = cli_value;
+    }
+  });
+  return {
+    help: parsed["help"] === true,
+    version: parsed["version"] === true,
+    git_args: get_git_args(parsed["git-dir"], parsed["work-tree"]),
+    no_interactive: parsed["interactive"] === false,
+    dry_run: parsed["dry-run"] === true,
+    branch_state
+  };
+}
+function get_git_args(git_dir, work_tree) {
+  return `${git_dir ? `--git-dir=${git_dir}` : ""} ${work_tree ? `--work-tree=${work_tree}` : ""}`.trim();
+}
+
+// src/utils/build-branch.ts
+function build_branch(branch, config2) {
+  let res = "";
+  config2.branch_order.forEach((b) => {
+    const config_key = `branch_${b}`;
+    if (branch[b])
+      res += branch[b] + config2[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, config2, git_root) {
+  const repo_name = git_root.split("/").pop() || "repo";
+  let worktree_name = config2.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("{{scope}}", branch_state.scope || "").replace("{{ticket}}", branch_state.ticket || "").replace("{{version}}", branch_state.version || "");
+  worktree_name = worktree_name.replace(/\s/g, "").replace(/--+/g, "-").replace(/^-+|-+$/g, "");
+  const base_path = config2.worktrees.base_path;
+  return `${base_path}${base_path.endsWith("/") ? "" : "/"}${worktree_name}`;
+}
+
+// src/prompts/branch-confirm.prompt.ts
+var BranchConfirmPrompt = class extends BranchRunnable {
+  async run() {
+    this.#run_pre_commands();
+    this.#run_checkout();
+    this.#run_post_commands();
+  }
+  get #is_worktree() {
+    return this.branch_state.checkout === "worktree";
+  }
+  get #pre_commands() {
+    return this.#is_worktree ? this.config.worktree_pre_commands : this.config.branch_pre_commands;
+  }
+  get #post_commands() {
+    return this.#is_worktree ? this.config.worktree_post_commands : this.config.branch_post_commands;
+  }
+  get #branch_name() {
+    return build_branch(this.branch_state, this.config);
+  }
+  #run_pre_commands() {
+    this.#run_commands(
+      this.#pre_commands,
+      "Something went wrong when executing pre-commands: "
+    );
+  }
+  #run_checkout() {
+    const branch_name = this.#branch_name;
+    const branch_flag = this.#verify_branch_name(branch_name);
+    if (!this.#is_worktree) {
+      const command = `git ${branch_flags.git_args} checkout ${branch_flag} ${branch_name}`;
+      if (branch_flags.dry_run) {
+        this.#log_dry_run_command(command);
+        return;
+      }
+      try {
+        execSync(command, {
+          stdio: "inherit"
+        });
+        p8.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)
+      );
+      const command = `git ${branch_flags.git_args} worktree add ${worktree_name} ${branch_flag} ${branch_name}`;
+      if (branch_flags.dry_run) {
+        this.#log_dry_run_command(command);
+        return;
+      }
+      execSync(command, {
+        stdio: "inherit"
+      });
+      p8.log.info(
+        `Created a new worktree ${color.bgGreen(
+          " " + color.black(worktree_name) + " "
+        )}, checked out branch ${color.bgGreen(
+          " " + color.black(branch_name) + " "
+        )}`
+      );
+      p8.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() {
+    this.#run_commands(
+      this.#post_commands,
+      "Something went wrong when executing post-commands: "
+    );
+  }
+  #run_commands(commands, error_message) {
+    commands.forEach((command) => {
+      if (branch_flags.dry_run) {
+        this.#log_dry_run_command(command);
+        return;
+      }
+      try {
+        execSync(command, { stdio: "inherit" });
+      } catch (err) {
+        p8.log.error(error_message + err);
+        process.exit(0);
+      }
+    });
+  }
+  #log_dry_run_command(command) {
+    p8.log.info(`Dry run: ${command}`);
+  }
+  #verify_branch_name(branch_name) {
+    let branch_flag = "";
+    try {
+      execSync(`git ${branch_flags.git_args} show-ref ${branch_name}`, {
+        encoding: "utf-8"
+      });
+      p8.log.warning(
+        color.yellow(
+          `${branch_name} already exists! Checking out existing branch.`
+        )
+      );
+    } catch (err) {
+      branch_flag = "-b";
+    }
+    return branch_flag;
+  }
+};
+
+// src/branch-help.ts
+import { execSync as execSync2 } from "child_process";
+import color2 from "picocolors";
+var CLI_FLAG_DEFINITIONS = {
+  "--interactive": "Run in interactive prompt mode (default behavior).",
+  "--dry-run": "Print branch commands without creating a branch or worktree.",
+  "--help": "Show help information and exit."
+};
+var BRANCH_FLAG_DEFINITIONS = {
+  "--user": "Set branch username segment.",
+  "--type": "Set branch type (for example feat, fix, docs).",
+  "--scope": "Set branch scope segment.",
+  "--description": "Set branch description segment.",
+  "--ticket": "Set branch ticket/issue segment.",
+  "--branch-version": "Set branch version segment.",
+  "--checkout": "Choose branch or worktree checkout mode."
+};
+var GIT_FLAG_DEFINITIONS = {
+  "--git-dir": "Set the path to the .git directory.",
+  "--work-tree": "Set the path to the working tree root."
+};
+function to_definition_lines(definitions) {
+  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");
+}
+function print_help_text(config2, config_source2) {
+  const version = get_package_version();
+  let branch = "(none)";
+  try {
+    branch = execSync2(`git ${branch_flags.git_args} branch --show-current`, {
+      stdio: "pipe"
+    }).toString().trim() || "(none)";
+  } catch {
+  }
+  const inferred_type = infer_type_from_git(config2.commit_type.options, branch_flags.git_args) || "Unknown";
+  const inferred_ticket = config2.check_ticket.infer_ticket ? infer_ticket_from_git(
+    {
+      append_hashtag: config2.check_ticket.append_hashtag,
+      prepend_hashtag: config2.check_ticket.prepend_hashtag
+    },
+    branch_flags.git_args
+  ) || "Unknown" : "Infer Disabled";
+  const inferred_scope = config2.commit_scope.infer_scope_from_branch ? infer_scope_from_git(
+    config2.commit_scope.options,
+    branch_flags.git_args
+  ) || "Unknown" : "Infer Disabled";
+  const types = config2.commit_type.options.map((option) => option.value).join(", ").trim();
+  const scopes = config2.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 branch_flags_help = to_definition_lines(BRANCH_FLAG_DEFINITIONS);
+  console.log(`
+${color2.green("\uF489 better-branch")} ${color2.gray("v" + version)}
+
+${color2.gray("BRANCH")} 
+ ${branch}
+ ${color2.gray("Type")} ${color2.blue(inferred_type)} ${color2.gray("\xB7")} ${color2.gray("Scope")} ${color2.cyan(inferred_scope)} ${color2.gray("\xB7")} ${color2.gray("Ticket")} ${color2.magenta(inferred_ticket)}
+
+${color2.gray("CONFIGURATION")} 
+ ${config_source2}
+
+${color2.gray("Types")} 
+ ${types}
+
+${color2.gray("Scopes")} 
+ ${scopes}
+
+${color2.gray("CLI FLAGS")} 
+${cli_flags}
+
+${color2.gray("Branch Flags")} 
+${branch_flags_help}
+
+${color2.gray("Git Flags (Advanced)")} 
+${git_flags}
+
+`);
+}
+
+// src/branch.ts
+import * as p9 from "@clack/prompts";
+var promptCtors = [
+  BranchCheckoutPrompt,
+  BranchUserPrompt,
+  BranchTypePrompt,
+  BranchTicketPrompt,
+  BranchScopePrompt,
+  BranchVersionPrompt,
+  BranchDescriptionPrompt,
+  BranchConfirmPrompt
+];
+var { config, config_source } = load_setup(
+  " better-branch ",
+  branch_flags.git_args
+);
+main(config, config_source);
+async function main(config2, config_source2) {
+  chdir2(get_git_root(branch_flags.git_args));
+  if (branch_flags.version) {
+    const version = get_package_version();
+    p9.log.step("Better Commits v" + version);
+    return;
+  }
+  if (branch_flags.help) {
+    print_help_text(config2, config_source2);
+    return;
+  }
+  const branch_state = parse2(BranchState, branch_flags.branch_state);
+  if (!branch_flags.interactive) {
+    try {
+      parse2(create_strict_branch_state(config2), branch_state);
+    } catch (err) {
+      if (err instanceof ValiError) {
+        p9.log.error(`Invalid branch input: ${err.message}`);
+      } else {
+        p9.log.error(`Failed to validate branch input: ${err}`);
+      }
+      process.exit(0);
+    }
+  }
+  const prompt_cache = config2.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(config2, branch_state, prompt_cache).run();
+  }
+}