better-commits 1.23.2 → 1.23.3

package/dist/index.js

@@ -1,61 +1,1142 @@
 #! /usr/bin/env node
-import{a as ft,b as ht,d as bt,e as N,f as j,g as D,h as f,i as I,j as S,k as et,l as yt,m as it}from"./chunk-43H72S6V.js";import{a as ct,c as mt,f as n,i as lt,k as pt,l as _t,m as ut,o as T,p as gt,q as dt,r as g,s as d}from"./chunk-B7AGSPP3.js";import{chdir as Kt}from"process";import*as z from"@clack/prompts";import{ValiError as Ht,parse as Ot}from"valibot";import Ut from"configstore";import*as V from"@clack/prompts";var p=class{constructor(t,e,o){this.config=t;this.commit_state=e;this.prompt_cache=o}};var L=class extends p{async run(){if(this.#i){let{initial_value:t,message:e}=this.#e,s=await(this.config.commit_type.autocomplete?V.autocomplete:V.select)({message:e,initialValue:t,maxItems:this.#s,options:this.#t});V.isCancel(s)&&process.exit(0),this.#r(s)}}get#i(){return this.config.commit_type.enable}get#e(){let t=g(this.prompt_cache,"commit_type");if(t)return{initial_value:t,message:f("Commit type")};if(this.config.commit_type.infer_type_from_branch){let e=N(this.#t,n.git_args);if(e)return{message:I("Commit type"),initial_value:e}}return{initial_value:this.config.commit_type.initial_value,message:"Select a commit type"}}get#t(){return this.config.commit_type.options}get#o(){return this.#t.reduce((t,e)=>({...t,[e.value]:{emoji:e.emoji??"",trailer:e.trailer??""}}),{})}get#s(){return this.config.commit_type.max_items}#r(t){d(this.prompt_cache,"commit_type",t);let e=this.#o;this.commit_state.trailer=e[t].trailer,this.commit_state.type=this.config.commit_type.append_emoji_to_commit&&this.config.commit_type.emoji_commit_position==="Start"?`${e[t].emoji} ${t}`.trim():t}};import*as k from"@clack/prompts";var G=class extends p{async run(){if(!this.#i)return;let{initial_value:t,message:e}=this.#e(),s=await(this.config.commit_scope.autocomplete?k.autocomplete:k.select)({message:e,initialValue:t,maxItems:this.#t,options:this.#o});k.isCancel(s)&&process.exit(0),await this.#r(s)}get#i(){return this.config.commit_scope.enable}#e(){let t=g(this.prompt_cache,"commit_scope");if(t)return{initial_value:t,message:f("Commit scope")};if(this.config.commit_scope.infer_scope_from_branch){let e=D(this.#o,n.git_args);if(e)return{initial_value:e,message:I("Commit scope")}}return{initial_value:this.config.commit_scope.initial_value,message:"Select a commit scope"}}get#t(){return this.config.commit_scope.max_items}get#o(){return this.config.commit_scope.options}get#s(){return this.config.commit_scope.custom_scope}async#r(t){d(this.prompt_cache,"commit_scope",t);let e=t;if(e===ct&&this.#s){let o=await k.text({message:"Write a custom scope",placeholder:""});k.isCancel(o)&&process.exit(0),e=o??""}this.commit_state.scope=e}};import*as B from"@clack/prompts";var M=class extends p{async run(){let{initial_value:t,message:e}=this.#o();if(this.commit_state.ticket=t,this.#e){let o=await B.text({message:e,placeholder:"",initialValue:t});B.isCancel(o)&&process.exit(0),d(this.prompt_cache,"commit_ticket",o),this.commit_state.ticket=o??""}this.#t&&this.commit_state.ticket&&!this.commit_state.ticket.startsWith("#")&&(this.commit_state.ticket="#"+this.commit_state.ticket)}get#i(){return this.config.check_ticket.infer_ticket}get#e(){return this.config.check_ticket.confirm_ticket}get#t(){return this.config.check_ticket.prepend_hashtag==="Always"}#o(){let t=g(this.prompt_cache,"commit_ticket");if(t)return{initial_value:t,message:f("Ticket / issue")};if(this.#i){let e=j({append_hashtag:this.config.check_ticket.append_hashtag,prepend_hashtag:this.config.check_ticket.prepend_hashtag},n.git_args);if(e)return{initial_value:e,message:I("Ticket / issue")}}return{initial_value:this.commit_state.ticket,message:S("Add ticket / issue")}}};import*as q from"@clack/prompts";var W=class extends p{async run(){let{initial_value:t,message:e}=this.#i(),o=await q.text({message:e,initialValue:t,placeholder:"",validate:s=>this.#e(s)});q.isCancel(o)&&process.exit(0),this.#n(o??"")}#i(){let t=g(this.prompt_cache,"commit_title");return t?{initial_value:t,message:f("Commit title")}:{initial_value:this.commit_state.title,message:"Write a brief title describing the commit"}}#e(t){if(!t)return"Please enter a title";if(this.#o(t)>this.#t)return`Exceeded max length. Title max [${this.#t}]`}get#t(){return this.config.commit_title.max_size}#o(t){return ft({type:this.commit_state.type,scope:this.commit_state.scope,ticket:this.commit_state.ticket,title:t},{include_ticket:this.config.check_ticket.add_to_title})}get#s(){return this.config.commit_type.options.reduce((t,e)=>({...t,[e.value]:{emoji:e.emoji??""}}),{})}#r(t){return this.config.commit_type.append_emoji_to_commit&&this.config.commit_type.emoji_commit_position==="After-Colon"?`${this.#s[this.commit_state.type]?.emoji??""} ${t}`.trim():t}#n(t){d(this.prompt_cache,"commit_title",t),this.commit_state.title=dt(this.#r(t))}};import*as H from"@clack/prompts";var K=class extends p{async run(){if(!this.#i)return;let{initial_value:t,message:e}=this.#e(),o=await H.text({message:e,initialValue:t,placeholder:"",validate:s=>this.#t(s)});H.isCancel(o)&&process.exit(0),this.#o(o??"")}get#i(){return this.config.commit_body.enable}#e(){let t=g(this.prompt_cache,"commit_body");return t?{initial_value:t,message:f("Commit body")}:{initial_value:"",message:S("Write a detailed description of the changes")}}#t(t){if(this.config.commit_body.required&&!t)return"Please enter a description"}#o(t){d(this.prompt_cache,"commit_body",t),this.commit_state.body=t}};import*as $ from"@clack/prompts";var U=class extends p{async run(){if(!this.#i)return;let{initial_values:t,message:e}=this.#o(),o=await $.multiselect({message:e,initialValues:t,options:this.#e,required:!1});$.isCancel(o)&&process.exit(0);let s=this.#r(o),r=await this.#n(s);this.#m(o,s,r)}get#i(){return this.config.commit_footer.enable}get#e(){let t=new Set(this.config.commit_footer.options);return lt.filter(e=>t.has(e.value))}get#t(){return this.#e.map(t=>t.value)}#o(){let t=g(this.prompt_cache,"commit_footer");return t?{initial_values:this.#s(t),message:et(f("Commit footers"))}:{initial_values:this.config.commit_footer.initial_value.filter(o=>this.#t.includes(o)),message:et(S("Select optional footers"))}}#s(t){return t.split(",").map(e=>e.trim()).filter(e=>this.#t.includes(e))}#r(t){return{includes_breaking_change:t.includes("breaking-change"),includes_deprecated:t.includes("deprecated"),includes_closes:t.includes("closes"),includes_custom:t.includes("custom"),includes_trailer:t.includes("trailer")}}async#n(t){let e={breaking_title:"",breaking_body:"",deprecated_title:"",deprecated_body:"",custom_footer:""};return t.includes_breaking_change&&(e.breaking_title=await this.#c("Breaking changes: Write a short title / summary"),e.breaking_body=await this.#a(S("Breaking Changes: Write a description & migration instructions"))),t.includes_deprecated&&(e.deprecated_title=await this.#c("Deprecated: Write a short title / summary"),e.deprecated_body=await this.#a(S("Deprecated: Write a description"))),t.includes_custom&&(e.custom_footer=await this.#a("Write a custom footer")),e}async#c(t){let e=await $.text({message:t,placeholder:"",validate:o=>{if(!o)return"Please enter a title / summary"}});return $.isCancel(e)&&process.exit(0),e??""}async#a(t){let e=await $.text({message:t,placeholder:""});return $.isCancel(e)&&process.exit(0),e??""}#m(t,e,o){d(this.prompt_cache,"commit_footer",t.join(",")),this.commit_state.breaking_title=o.breaking_title,this.commit_state.breaking_body=o.breaking_body,this.commit_state.deprecates_title=o.deprecated_title,this.commit_state.deprecates_body=o.deprecated_body,this.commit_state.custom_footer=o.custom_footer,this.commit_state.closes=e.includes_closes?"Closes:":"",e.includes_trailer||(this.commit_state.trailer="")}};import*as h from"@clack/prompts";import{execSync as Ct}from"child_process";import u from"picocolors";function ot({commit_state:i,config:t,colorize:e=!1,escape_quotes:o=!1,include_trailer:s=!1}){let r="";if(i.type&&(r+=e?u.blue(i.type):i.type),i.scope){let c=e?u.cyan(i.scope):i.scope;r+=`(${c})`}let a=i.ticket,l=t.check_ticket.surround;if(i.ticket&&l){let c=l.charAt(0),b=l.charAt(1);a=`${c}${i.ticket}${b}`}let C=t.check_ticket.title_position==="beginning";a&&t.check_ticket.add_to_title&&C&&(r=`${e?u.magenta(a):a} ${r}`);let x=t.check_ticket.title_position==="before-colon";if(a&&t.check_ticket.add_to_title&&x){let c=i.scope||i.type&&!t.check_ticket.surround?" ":"";r+=e?u.magenta(c+a):c+a}i.breaking_title&&t.breaking_change.add_exclamation_to_title&&(r+=e?u.red("!"):"!"),(i.scope||i.type||a&&x)&&(r+=": ");let y=t.check_ticket.title_position==="start",A=t.check_ticket.title_position==="end";if(a&&t.check_ticket.add_to_title&&y&&(r+=e?u.magenta(a)+" ":a+" "),i.title&&(r+=e?u.reset(i.title):i.title),a&&t.check_ticket.add_to_title&&A&&(r+=" "+(e?u.magenta(a):a)),i.body){let c=i.body;t.commit_body.split_by_period&&(c=c.replace(/\.\s+/g,`.
-`));let O=c.split("\\n").map(F=>e?u.reset(F.trim()):F.trim()).join(`
-`);r+=`
+import {
+  a_for_all_message,
+  cache_message,
+  create_strict_commit_state,
+  dry_run_message,
+  get_commit_title_size,
+  infer_not_interactive,
+  infer_scope_from_git,
+  infer_ticket_from_git,
+  infer_type_from_git,
+  inferred_message,
+  optional_message,
+  space_to_select_message
+} from "./chunk-H5CLUQIL.js";
+import {
+  COMMIT_FOOTER_OPTIONS,
+  CUSTOM_SCOPE_KEY,
+  CommitState,
+  NOOP_PROMPT_CACHE,
+  addNewLine,
+  clean_commit_title,
+  flags,
+  get_git_root,
+  get_package_version,
+  get_value_from_cache,
+  load_setup,
+  set_value_cache
+} from "./chunk-GAAS3VS3.js";
 
-${O}`}if(i.breaking_title){let c=e?u.red(`BREAKING CHANGE: ${i.breaking_title}`):`BREAKING CHANGE: ${i.breaking_title}`;r+=`
+// src/index.ts
+import { chdir } from "process";
+import * as p10 from "@clack/prompts";
+import { ValiError, parse } from "valibot";
+import Configstore from "configstore";
 
-${c}`}if(i.breaking_body){let c=e?u.red(i.breaking_body):i.breaking_body;r+=`
+// src/prompts/commit-type.prompt.ts
+import * as p from "@clack/prompts";
 
-${c}`}if(i.deprecates_title){let c=e?u.yellow(`DEPRECATED: ${i.deprecates_title}`):`DEPRECATED: ${i.deprecates_title}`;r+=`
+// src/prompts/runnable.ts
+var Runnable = class {
+  constructor(config2, commit_state, prompt_cache) {
+    this.config = config2;
+    this.commit_state = commit_state;
+    this.prompt_cache = prompt_cache;
+  }
+};
 
-${c}`}if(i.deprecates_body){let c=e?u.yellow(i.deprecates_body):i.deprecates_body;r+=`
+// src/prompts/commit-type.prompt.ts
+var CommitTypePrompt = class extends Runnable {
+  async run() {
+    if (this.#is_enabled) {
+      const { initial_value, message } = this.#initial_value;
+      const prompt_type = this.config.commit_type.autocomplete ? p.autocomplete : p.select;
+      const commit_type = await prompt_type({
+        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() {
+    return this.config.commit_type.enable;
+  }
+  get #initial_value() {
+    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() {
+    return this.config.commit_type.options;
+  }
+  get #value_to_data() {
+    return this.#options.reduce(
+      (acc, curr) => ({
+        ...acc,
+        [curr.value]: {
+          emoji: curr.emoji ?? "",
+          trailer: curr.trailer ?? ""
+        }
+      }),
+      {}
+    );
+  }
+  get #max_items() {
+    return this.config.commit_type.max_items;
+  }
+  #run_post_effects(prompt_result) {
+    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;
+  }
+};
 
-${c}`}if(i.custom_footer){let b=i.custom_footer.split("\\n").map(O=>e?u.reset(O.trim()):O.trim()).join(`
-`);r+=`
+// src/prompts/commit-scope.prompt.ts
+import * as p2 from "@clack/prompts";
+var CommitScopePrompt = class extends Runnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const { initial_value, message } = this.#get_initial_value();
+    const prompt_type = this.config.commit_scope.autocomplete ? p2.autocomplete : p2.select;
+    let commit_scope = await prompt_type({
+      message,
+      initialValue: initial_value,
+      maxItems: this.#max_items,
+      options: this.#options
+    });
+    if (p2.isCancel(commit_scope))
+      process.exit(0);
+    await this.#post_run_effects(commit_scope);
+  }
+  get #is_enabled() {
+    return this.config.commit_scope.enable;
+  }
+  #get_initial_value() {
+    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")
+      };
+    }
+    if (this.config.commit_scope.infer_scope_from_branch) {
+      const scope_from_branch = infer_scope_from_git(
+        this.#options,
+        flags.git_args
+      );
+      if (scope_from_branch) {
+        return {
+          initial_value: scope_from_branch,
+          message: inferred_message("Commit scope")
+        };
+      }
+    }
+    return {
+      initial_value: this.config.commit_scope.initial_value,
+      message: "Select a commit scope"
+    };
+  }
+  get #max_items() {
+    return this.config.commit_scope.max_items;
+  }
+  get #options() {
+    return this.config.commit_scope.options;
+  }
+  get #custom_scope_enabled() {
+    return this.config.commit_scope.custom_scope;
+  }
+  async #post_run_effects(prompt_result) {
+    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 p2.text({
+        message: "Write a custom scope",
+        placeholder: ""
+      });
+      if (p2.isCancel(commit_scope))
+        process.exit(0);
+      commit_scope_value = commit_scope ?? "";
+    }
+    this.commit_state.scope = commit_scope_value;
+  }
+};
 
-${b}`}return i.closes&&i.ticket&&(r+=e?`
+// src/prompts/commit-ticket.prompt.ts
+import * as p3 from "@clack/prompts";
+var CommitTicketPrompt = class extends Runnable {
+  async run() {
+    const { initial_value, message } = this.#get_initial_value();
+    this.commit_state.ticket = initial_value;
+    if (this.#confirm_ticket_enabled) {
+      const user_commit_ticket = await p3.text({
+        message,
+        placeholder: "",
+        initialValue: initial_value
+      });
+      if (p3.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() {
+    return this.config.check_ticket.infer_ticket;
+  }
+  get #confirm_ticket_enabled() {
+    return this.config.check_ticket.confirm_ticket;
+  }
+  get #prepend_hashtag_always() {
+    return this.config.check_ticket.prepend_hashtag === "Always";
+  }
+  #get_initial_value() {
+    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")
+    };
+  }
+};
 
-${u.reset(i.closes)} ${u.magenta(i.ticket)}`:`
+// src/prompts/commit-title.prompt.ts
+import * as p4 from "@clack/prompts";
+var CommitTitlePrompt = class extends Runnable {
+  async run() {
+    const { initial_value, message } = this.#get_initial_value();
+    const commit_title = await p4.text({
+      message,
+      initialValue: initial_value,
+      placeholder: "",
+      validate: (value) => this.#validate(value)
+    });
+    if (p4.isCancel(commit_title))
+      process.exit(0);
+    this.#run_post_effects(commit_title ?? "");
+  }
+  #get_initial_value() {
+    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")
+      };
+    }
+    return {
+      initial_value: this.commit_state.title,
+      message: "Write a brief title describing the commit"
+    };
+  }
+  #validate(value) {
+    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() {
+    return this.config.commit_title.max_size;
+  }
+  #get_size(value) {
+    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() {
+    return this.config.commit_type.options.reduce(
+      (acc, curr) => ({
+        ...acc,
+        [curr.value]: {
+          emoji: curr.emoji ?? ""
+        }
+      }),
+      {}
+    );
+  }
+  #title_with_emoji(title) {
+    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) {
+    set_value_cache(this.prompt_cache, "commit_title", prompt_result);
+    this.commit_state.title = clean_commit_title(
+      this.#title_with_emoji(prompt_result)
+    );
+  }
+};
 
-${i.closes} ${i.ticket}`),s&&i.trailer&&(r+=e?`
+// src/prompts/commit-body.prompt.ts
+import * as p5 from "@clack/prompts";
+var CommitBodyPrompt = class extends Runnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const { initial_value, message } = this.#get_initial_value();
+    const commit_body = await p5.text({
+      message,
+      initialValue: initial_value,
+      placeholder: "",
+      validate: (value) => this.#validate(value)
+    });
+    if (p5.isCancel(commit_body))
+      process.exit(0);
+    this.#run_post_effects(commit_body ?? "");
+  }
+  get #is_enabled() {
+    return this.config.commit_body.enable;
+  }
+  #get_initial_value() {
+    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) {
+    if (this.config.commit_body.required && !value) {
+      return "Please enter a description";
+    }
+  }
+  #run_post_effects(prompt_result) {
+    set_value_cache(this.prompt_cache, "commit_body", prompt_result);
+    this.commit_state.body = prompt_result;
+  }
+};
 
-${u.dim(i.trailer)}`:`
+// src/prompts/commit-footer.prompt.ts
+import * as p6 from "@clack/prompts";
+var CommitFooterPrompt = class extends Runnable {
+  async run() {
+    if (!this.#is_enabled)
+      return;
+    const { initial_values, message } = this.#get_initial_value();
+    const commit_footer = await p6.multiselect({
+      message,
+      initialValues: initial_values,
+      options: this.#options,
+      required: false
+    });
+    if (p6.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() {
+    return this.config.commit_footer.enable;
+  }
+  get #options() {
+    const allowed_values = new Set(this.config.commit_footer.options);
+    return COMMIT_FOOTER_OPTIONS.filter(
+      (option) => allowed_values.has(option.value)
+    );
+  }
+  get #available_option_values() {
+    return this.#options.map((option) => option.value);
+  }
+  #get_initial_value() {
+    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) {
+    return cache_value.split(",").map((value) => value.trim()).filter(
+      (value) => this.#available_option_values.includes(value)
+    );
+  }
+  #get_selection(commit_footer) {
+    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) {
+    const footer_inputs = {
+      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) {
+    const response = await p6.text({
+      message,
+      placeholder: "",
+      validate: (value) => {
+        if (!value)
+          return "Please enter a title / summary";
+      }
+    });
+    if (p6.isCancel(response))
+      process.exit(0);
+    return response ?? "";
+  }
+  async #optional_text(message) {
+    const response = await p6.text({
+      message,
+      placeholder: ""
+    });
+    if (p6.isCancel(response))
+      process.exit(0);
+    return response ?? "";
+  }
+  #run_post_effects(commit_footer, selection, footer_inputs) {
+    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 = "";
+    }
+  }
+};
 
-${i.trailer}`),o&&(r=r.replaceAll('"','\\"').replaceAll("`","\\`")),r}import{execSync as kt}from"child_process";import*as P from"@clack/prompts";import X from"picocolors";var vt=["M","T","R","D","A","C"];function st(){let i="";try{i=kt(`git ${n.git_args} status --porcelain`,{stdio:"pipe"}).toString()}catch(s){return P.log.error(X.red("Failed to git status"+s)),{index:[],work_tree:[]}}let t=i.split(`
-`),e=[],o=[];return t.forEach(s=>{let r=s.trimEnd();if(!r)return;let a=r.substring(2).trim(),l=r.charAt(0).trim(),C=r.charAt(1).trim();(l==="?"||C==="?")&&e.push(a),vt.includes(l)&&o.push(a),vt.includes(C)&&e.push(a)}),{index:o,work_tree:e}}function $t(i){let t=i.join(" ");if(t)try{kt(`git ${n.git_args} add ${t}`,{stdio:"pipe"}).toString(),P.log.success(X.green("Changes successfully staged"))}catch{P.log.error(X.red("Failed to stage changes"))}}function Y(){st().index.length||(P.log.error(X.red('no changes added to commit (use "git add" and/or "git commit -a")')),process.exit(0))}var E=class extends p{async run(){n.interactive||Y(),this.#i&&(Ct(`${this.#n} --edit`,this.#o),process.exit(0)),this.#e&&h.note(ot({commit_state:this.commit_state,config:this.config,colorize:!0,escape_quotes:!1,include_trailer:!0}),"Commit Preview",{format:e=>e}),await this.#a()||(h.log.info("Exiting without commit"),process.exit(0));try{h.log.info(n.dry_run?it("Committing changes..."):"Committing changes..."),Ct(this.#n,n.dry_run?this.#s:this.#o)}catch(e){h.log.error("Something went wrong when committing: "+e);return}this.#m()}get#i(){return n.interactive&&this.config.confirm_with_editor}get#e(){return this.config.print_commit_output}get#t(){return this.config.confirm_commit}get#o(){return this.config.overrides.shell?{shell:this.config.overrides.shell,stdio:"inherit"}:{stdio:"inherit"}}get#s(){return this.config.overrides.shell?{shell:this.config.overrides.shell,stdio:"pipe"}:{stdio:"pipe"}}get#r(){return this.commit_state.trailer?`--trailer="${this.commit_state.trailer}"`:""}get#n(){return`git ${n.git_args} commit -m "${ot({commit_state:this.commit_state,config:this.config,colorize:!1,escape_quotes:!0,include_trailer:!1})}" ${this.#r} ${this.#c}`.trim()}get#c(){return n.dry_run?"--dry-run --porcelain --untracked-files=no":""}async#a(){if(!n.interactive||!this.#t)return!0;let t=await h.confirm({message:n.dry_run?it("Confirm Commit?"):"Confirm Commit?"});return h.isCancel(t)&&process.exit(0),t}#m(){h.log.success("Commit Complete");let t=this.prompt_cache.get("username");this.prompt_cache.clear(),t&&this.prompt_cache.set("username",t)}};import*as w from"@clack/prompts";import J from"picocolors";import{styleText as m}from"node:util";import{AutocompletePrompt as Pt}from"@clack/core";import{S_BAR as R,S_BAR_END as Et,S_CHECKBOX_INACTIVE as xt,S_CHECKBOX_SELECTED as Rt,limitOptions as Tt,settings as Nt,symbol as jt}from"@clack/prompts";function Dt(i,t){if(!i)return!0;let e=(t.label??String(t.value??"")).toLowerCase(),o=(t.hint??"").toLowerCase(),s=String(t.value).toLowerCase(),r=i.toLowerCase();return e.includes(r)||o.includes(r)||s.includes(r)}function Lt(i,t){return i==="
"||t.ctrl===!0&&t.name==="a"}var rt=class extends Pt{constructor(e){super({options:e.options,multiple:!0,filter:e.filter??((o,s)=>Dt(o,s)),validate:o=>e.required&&(!Array.isArray(o)||o.length===0)?"Please select at least one item":e.validate?.(o),initialValue:e.initialValues,signal:e.signal,input:e.input,output:e.output,render(){let o=e.withGuide??Nt.withGuide,s=`${o?`${m("gray",R)}
-`:""}${jt(this.state)}  ${e.message}
-`,r=this.userInput,a=this.userInputWithCursor,l=this.options,C=this.filteredOptions.length!==l.length?m("dim",` (${this.filteredOptions.length} match${this.filteredOptions.length===1?"":"es"})`):"";switch(this.state){case"submit":return`${s}${o?`${m("gray",R)}  `:""}${m("dim",`${this.selectedValues.length} items selected`)}`;case"cancel":return`${s}${o?`${m("gray",R)}  `:""}${m(["strikethrough","dim"],r)}`;default:{let x=this.state==="error"?"yellow":"cyan",y=o?`${m(x,R)}  `:"",A=o?m(x,Et):"",c=[`${m("dim","\u2191/\u2193")} to navigate`,`${m("dim","Space/Tab:")} select`,`${m("dim","Ctrl+a:")} select visible`,`${m("dim","Enter:")} confirm`,`${m("dim","Type:")} to search`],b=this.filteredOptions.length===0&&r?[`${y}${m("yellow","No matches found")}`]:[],O=this.state==="error"?[`${y}${m("yellow",this.error)}`]:[],F=[...`${s}${o?m(x,R):""}`.split(`
-`),`${y}${m("dim","Search:")} ${a}${C}`,...b,...O],nt=[`${y}${c.join(" \u2022 ")}`,A],It=Tt({cursor:this.cursor,options:this.filteredOptions,style:(v,Vt)=>{let At=this.selectedValues.includes(v.value),tt=v.label??String(v.value??""),Ft=v.hint&&this.focusedValue!==void 0&&v.value===this.focusedValue?m("dim",` (${v.hint})`):"",at=At?m("green",Rt):m("dim",xt);return v.disabled?`${m("gray",xt)} ${m(["strikethrough","gray"],tt)}`:Vt?`${at} ${tt}${Ft}`:`${at} ${m("dim",tt)}`},maxItems:e.maxItems,output:e.output,rowPadding:F.length+nt.length});return[...F,...It.map(v=>`${y}${v}`),...nt].join(`
-`)}}}});this.promptOptions=e;this.on("key",(o,s)=>{if(s.name==="space"&&!this.isNavigating&&this.focusedValue!==void 0){this.toggleSelected(this.focusedValue),this.#e();return}Lt(o,s)&&(this.#i(),this.isNavigating=!0,this.#e())})}_isActionKey(e,o){return super._isActionKey(e,o)||this.multiple&&o.name==="space"&&e!==void 0&&e!==""}#i(){let e=this.filteredOptions.filter(s=>!s.disabled).map(s=>s.value);if(!e.length)return;let o=e.every(s=>this.selectedValues.includes(s));this.selectedValues=o?this.selectedValues.filter(s=>!e.includes(s)):[...this.selectedValues,...e.filter(s=>!this.selectedValues.includes(s))]}#e(){let e=this.rl;e?.write("",{ctrl:!0,name:"e"}),this._cursor=e?.cursor??this.userInput.length}};function St(i){return new rt(i).prompt()}var Q=class extends p{async run(){if(!this.#i)return;let t=st();if(this.#e(t),t.work_tree.length){let e=await this.#o(t.work_tree);e.length&&$t(e)}Y()}get#i(){return this.config.check_status}#e(t){w.log.step(J.black(J.bgGreen(" Checking Git Status ")));let e=this.#t(t.index,J.green);if(w.log.success(`Changes to be committed:
-`+e),!t.work_tree.length)return;let o=this.#t(t.work_tree,J.red);w.log.error(`Changes not staged for commit:
-`+o)}#t(t,e){return t.reduce((o,s,r)=>e(o+s+gt(t,r)),"")}async#o(t){let e=this.config.check_status_autocomplete?await St({message:"Some files have not been staged, add them now?",options:t.map(o=>({value:o,label:o})),required:!1}):await w.multiselect({message:yt("Some files have not been staged, add them now?"),options:t.map(o=>({value:o,label:o})),required:!1});return w.isCancel(e)&&process.exit(0),e}};import{execSync as Gt}from"child_process";import _ from"picocolors";var Mt={"better-branch":"Create a branch or worktree from a guided prompt flow.","better-commits-init":"Create a .better-commits.jsonc config in this repository."},Bt={"--no-interactive":"Run without tui prompts.","--dry-run":"Print the commit command without creating a commit.","--help":"Show help information and exit."},Wt={"--type":"Set commit type (can be inferred from branch).","--scope":"Set commit scope (can be inferred from branch).","--title":"Set commit title/description.","--body":"Set commit body text.","--ticket":"Set ticket / issue (can be inferred from branch).","--closes":"Set closes footer (true/false).","--trailer":"Set trailer footer value.","--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."},qt={"--git-dir":"Set the path to the .git directory.","--work-tree":"Set the path to the working tree root."};function Z(i){let o=" ";return Object.entries(i).map(([s,r])=>{let a=Math.max(2,26-s.length);return`${o}${s}${" ".repeat(a)}${r}`}).join(`
-`)}function wt(i,t){let e=T(),o="(none)";try{o=Gt(`git ${n.git_args} branch --show-current`,{stdio:"pipe"}).toString().trim()||"(none)"}catch{}let s=N(i.commit_type.options,n.git_args)||"Unknown",r=i.check_ticket.infer_ticket?j({append_hashtag:i.check_ticket.append_hashtag,prepend_hashtag:i.check_ticket.prepend_hashtag},n.git_args)||"Unknown":"Infer Disabled",a=i.commit_scope.infer_scope_from_branch?D(i.commit_scope.options,n.git_args)||"Unknown":"Infer Disabled",l=i.commit_type.options.map(b=>b.value).join(", ").trim(),C=i.commit_scope.options.map(b=>b.value).join(", ").trim(),x=Z(Bt),y=Z(qt),A=Z(Wt),c=Z(Mt);console.log(`
-${_.green("\uF489 better-commits")} ${_.gray("v"+e)}
+// src/prompts/commit-confirm.prompt.ts
+import * as p8 from "@clack/prompts";
+import { execSync as execSync2 } from "child_process";
 
-${_.gray("BRANCH")} 
- ${o}
- ${_.gray("Type")} ${_.blue(s)} ${_.gray("\xB7")} ${_.gray("Scope")} ${_.cyan(a)} ${_.gray("\xB7")} ${_.gray("Ticket")} ${_.magenta(r)}
+// src/utils/build-commit-string.ts
+import color from "picocolors";
+function build_commit_string({
+  commit_state,
+  config: config2,
+  colorize = false,
+  escape_quotes = false,
+  include_trailer = false
+}) {
+  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 = config2.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 = config2.check_ticket.title_position === "beginning";
+  if (title_ticket && config2.check_ticket.add_to_title && position_beginning) {
+    commit_string = `${colorize ? color.magenta(title_ticket) : title_ticket} ${commit_string}`;
+  }
+  const position_before_colon = config2.check_ticket.title_position === "before-colon";
+  if (title_ticket && config2.check_ticket.add_to_title && position_before_colon) {
+    const spacing = commit_state.scope || commit_state.type && !config2.check_ticket.surround ? " " : "";
+    commit_string += colorize ? color.magenta(spacing + title_ticket) : spacing + title_ticket;
+  }
+  if (commit_state.breaking_title && config2.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 = config2.check_ticket.title_position === "start";
+  const position_end = config2.check_ticket.title_position === "end";
+  if (title_ticket && config2.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 && config2.check_ticket.add_to_title && position_end) {
+    commit_string += " " + (colorize ? color.magenta(title_ticket) : title_ticket);
+  }
+  if (commit_state.body) {
+    let body = commit_state.body;
+    if (config2.commit_body.split_by_period) {
+      body = body.replace(/\.\s+/g, ".\n");
+    }
+    const temp = body.split("\\n");
+    const res = temp.map((value) => colorize ? color.reset(value.trim()) : value.trim()).join("\n");
+    commit_string += `
 
-${_.gray("CONFIGURATION")} 
- ${t}
+${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 += `
 
-${_.gray("Types")} 
- ${l}
+${title}`;
+  }
+  if (commit_state.breaking_body) {
+    const body = colorize ? color.red(commit_state.breaking_body) : commit_state.breaking_body;
+    commit_string += `
 
-${_.gray("Scopes")} 
- ${C}
+${body}`;
+  }
+  if (commit_state.deprecates_title) {
+    const title = colorize ? color.yellow(`DEPRECATED: ${commit_state.deprecates_title}`) : `DEPRECATED: ${commit_state.deprecates_title}`;
+    commit_string += `
 
-${_.gray("CLI FLAGS")} 
-${x}
+${title}`;
+  }
+  if (commit_state.deprecates_body) {
+    const body = colorize ? color.yellow(commit_state.deprecates_body) : commit_state.deprecates_body;
+    commit_string += `
 
-${_.gray("Commit Flags")} 
-${A}
+${body}`;
+  }
+  if (commit_state.custom_footer) {
+    const temp = commit_state.custom_footer.split("\\n");
+    const res = temp.map((value) => colorize ? color.reset(value.trim()) : value.trim()).join("\n");
+    commit_string += `
 
-${_.gray("Git Flags (Advanced)")} 
-${y}
+${res}`;
+  }
+  if (commit_state.closes && commit_state.ticket) {
+    commit_string += colorize ? `
 
-${_.gray("ADDITIONAL COMMANDS")} 
-${c}
+${color.reset(commit_state.closes)} ${color.magenta(commit_state.ticket)}` : `
 
-`)}var Xt=[Q,L,G,M,W,K,U,E],{config:Yt,config_source:Jt}=_t();Qt(Yt,Jt);async function Qt(i,t){if(Kt(ut()),n.version){let l=T();z.log.step("Better Commits v"+l);return}if(n.help){wt(i,t);return}let e=bt(i),o={...n.commit_state,type:(n.commit_state.type||e?.type)??"",scope:(n.commit_state.scope||e?.scope)??"",ticket:(n.commit_state.ticket||e?.ticket)??""},s=Ot(mt,o);if(!n.interactive)try{Ot(ht(i),s)}catch(l){l instanceof Ht?z.log.error(`Invalid commit input: ${l.message}`):z.log.error(`Failed to validate commit input: ${l}`),process.exit(0)}let r=i.cache_last_value?new Ut("better-commits"):pt,a=n.interactive?Xt:[E];for(let l of a)await new l(i,s,r).run()}export{Qt as main};
+${commit_state.closes} ${commit_state.ticket}`;
+  }
+  if (include_trailer && commit_state.trailer) {
+    commit_string += colorize ? `
+
+${color.dim(commit_state.trailer)}` : `
+
+${commit_state.trailer}`;
+  }
+  if (escape_quotes) {
+    commit_string = commit_string.replaceAll('"', '\\"').replaceAll("`", "\\`");
+  }
+  return commit_string;
+}
+
+// src/git.ts
+import { execSync } from "child_process";
+import * as p7 from "@clack/prompts";
+import color2 from "picocolors";
+var porcelain_states = ["M", "T", "R", "D", "A", "C"];
+function git_status() {
+  let status = "";
+  try {
+    status = execSync(`git ${flags.git_args} status --porcelain`, {
+      stdio: "pipe"
+    }).toString();
+  } catch (err) {
+    p7.log.error(color2.red("Failed to git status" + err));
+    return { index: [], work_tree: [] };
+  }
+  const lines = status.split("\n");
+  const work_tree = [];
+  const index = [];
+  lines.forEach((v) => {
+    const line = v.trimEnd();
+    if (!line)
+      return;
+    const path_plus_file = line.substring(2).trim();
+    const first_char = line.charAt(0).trim();
+    const second_char = line.charAt(1).trim();
+    if (first_char === "?" || second_char === "?") {
+      work_tree.push(path_plus_file);
+    }
+    if (porcelain_states.includes(first_char)) {
+      index.push(path_plus_file);
+    }
+    if (porcelain_states.includes(second_char)) {
+      work_tree.push(path_plus_file);
+    }
+  });
+  return { index, work_tree };
+}
+function git_add(files) {
+  const space_delimited_files = files.join(" ");
+  if (space_delimited_files) {
+    try {
+      execSync(`git ${flags.git_args} add ${space_delimited_files}`, {
+        stdio: "pipe"
+      }).toString();
+      p7.log.success(color2.green("Changes successfully staged"));
+    } catch (err) {
+      p7.log.error(color2.red("Failed to stage changes"));
+    }
+  }
+}
+function ensure_staged_changes() {
+  const updated_status = git_status();
+  if (updated_status.index.length)
+    return;
+  p7.log.error(
+    color2.red(
+      'no changes added to commit (use "git add" and/or "git commit -a")'
+    )
+  );
+  process.exit(0);
+}
+
+// src/prompts/commit-confirm.prompt.ts
+var CommitConfirmPrompt = class extends Runnable {
+  async run() {
+    if (!flags.interactive)
+      ensure_staged_changes();
+    if (this.#confirm_with_editor) {
+      execSync2(`${this.#commit_command} --edit`, this.#git_command_options);
+      process.exit(0);
+    }
+    if (this.#print_commit_output) {
+      p8.note(
+        build_commit_string({
+          commit_state: this.commit_state,
+          config: this.config,
+          colorize: true,
+          escape_quotes: false,
+          include_trailer: true
+        }),
+        "Commit Preview",
+        { format: (line) => line }
+      );
+    }
+    const continue_commit = await this.#get_continue_commit();
+    if (!continue_commit) {
+      p8.log.info("Exiting without commit");
+      process.exit(0);
+    }
+    try {
+      p8.log.info(
+        flags.dry_run ? dry_run_message("Committing changes...") : "Committing changes..."
+      );
+      execSync2(
+        this.#commit_command,
+        flags.dry_run ? this.#git_command_options_quiet : this.#git_command_options
+      );
+    } catch (err) {
+      p8.log.error("Something went wrong when committing: " + err);
+      return;
+    }
+    this.#run_post_effects();
+  }
+  get #confirm_with_editor() {
+    return flags.interactive && this.config.confirm_with_editor;
+  }
+  get #print_commit_output() {
+    return this.config.print_commit_output;
+  }
+  get #confirm_commit() {
+    return this.config.confirm_commit;
+  }
+  get #git_command_options() {
+    return this.config.overrides.shell ? { shell: this.config.overrides.shell, stdio: "inherit" } : { stdio: "inherit" };
+  }
+  get #git_command_options_quiet() {
+    return this.config.overrides.shell ? { shell: this.config.overrides.shell, stdio: "pipe" } : { stdio: "pipe" };
+  }
+  get #trailer_arg() {
+    return this.commit_state.trailer ? `--trailer="${this.commit_state.trailer}"` : "";
+  }
+  get #commit_command() {
+    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() {
+    return flags.dry_run ? "--dry-run --porcelain --untracked-files=no" : "";
+  }
+  async #get_continue_commit() {
+    if (!flags.interactive)
+      return true;
+    if (!this.#confirm_commit)
+      return true;
+    const continue_commit = await p8.confirm({
+      message: flags.dry_run ? dry_run_message("Confirm Commit?") : "Confirm Commit?"
+    });
+    if (p8.isCancel(continue_commit))
+      process.exit(0);
+    return continue_commit;
+  }
+  #run_post_effects() {
+    p8.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);
+  }
+};
+
+// src/prompts/commit-status.prompt.ts
+import * as p9 from "@clack/prompts";
+import color3 from "picocolors";
+
+// src/prompts/autocomplete-multiselect.ts
+import { styleText } from "node:util";
+import { AutocompletePrompt } from "@clack/core";
+import {
+  S_BAR,
+  S_BAR_END,
+  S_CHECKBOX_INACTIVE,
+  S_CHECKBOX_SELECTED,
+  limitOptions,
+  settings,
+  symbol
+} from "@clack/prompts";
+function getFilteredOption(searchText, option) {
+  if (!searchText)
+    return true;
+  const label = (option.label ?? String(option.value ?? "")).toLowerCase();
+  const hint = (option.hint ?? "").toLowerCase();
+  const value = String(option.value).toLowerCase();
+  const term = searchText.toLowerCase();
+  return label.includes(term) || hint.includes(term) || value.includes(term);
+}
+function is_ctrl_a(char, key) {
+  return char === "
" || key.ctrl === true && key.name === "a";
+}
+var AutocompleteMultiselectPrompt = class extends AutocompletePrompt {
+  constructor(promptOptions) {
+    super({
+      options: promptOptions.options,
+      multiple: true,
+      filter: promptOptions.filter ?? ((search, opt) => getFilteredOption(search, opt)),
+      validate: (value) => {
+        if (promptOptions.required && (!Array.isArray(value) || value.length === 0)) {
+          return "Please select at least one item";
+        }
+        return promptOptions.validate?.(value);
+      },
+      initialValue: promptOptions.initialValues,
+      signal: promptOptions.signal,
+      input: promptOptions.input,
+      output: promptOptions.output,
+      render() {
+        const hasGuide = promptOptions.withGuide ?? settings.withGuide;
+        const title = `${hasGuide ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${promptOptions.message}
+`;
+        const userInput = this.userInput;
+        const searchText = this.userInputWithCursor;
+        const options = this.options;
+        const matches = this.filteredOptions.length !== options.length ? styleText(
+          "dim",
+          ` (${this.filteredOptions.length} match${this.filteredOptions.length === 1 ? "" : "es"})`
+        ) : "";
+        switch (this.state) {
+          case "submit": {
+            return `${title}${hasGuide ? `${styleText("gray", S_BAR)}  ` : ""}${styleText("dim", `${this.selectedValues.length} items selected`)}`;
+          }
+          case "cancel": {
+            return `${title}${hasGuide ? `${styleText("gray", S_BAR)}  ` : ""}${styleText(["strikethrough", "dim"], userInput)}`;
+          }
+          default: {
+            const barStyle = this.state === "error" ? "yellow" : "cyan";
+            const guidePrefix = hasGuide ? `${styleText(barStyle, S_BAR)}  ` : "";
+            const guidePrefixEnd = hasGuide ? styleText(barStyle, S_BAR_END) : "";
+            const instructions = [
+              `${styleText("dim", "\u2191/\u2193")} to navigate`,
+              `${styleText("dim", "Space/Tab:")} select`,
+              `${styleText("dim", "Ctrl+a:")} select visible`,
+              `${styleText("dim", "Enter:")} confirm`,
+              `${styleText("dim", "Type:")} to search`
+            ];
+            const noResults = this.filteredOptions.length === 0 && userInput ? [`${guidePrefix}${styleText("yellow", "No matches found")}`] : [];
+            const errorMessage = this.state === "error" ? [`${guidePrefix}${styleText("yellow", this.error)}`] : [];
+            const headerLines = [
+              ...`${title}${hasGuide ? styleText(barStyle, S_BAR) : ""}`.split(
+                "\n"
+              ),
+              `${guidePrefix}${styleText("dim", "Search:")} ${searchText}${matches}`,
+              ...noResults,
+              ...errorMessage
+            ];
+            const footerLines = [
+              `${guidePrefix}${instructions.join(" \u2022 ")}`,
+              guidePrefixEnd
+            ];
+            const displayOptions = limitOptions({
+              cursor: this.cursor,
+              options: this.filteredOptions,
+              style: (option, active) => {
+                const isSelected = this.selectedValues.includes(option.value);
+                const label = option.label ?? String(option.value ?? "");
+                const hint = option.hint && this.focusedValue !== void 0 && option.value === this.focusedValue ? styleText("dim", ` (${option.hint})`) : "";
+                const checkbox = isSelected ? styleText("green", S_CHECKBOX_SELECTED) : styleText("dim", S_CHECKBOX_INACTIVE);
+                if (option.disabled) {
+                  return `${styleText("gray", S_CHECKBOX_INACTIVE)} ${styleText(["strikethrough", "gray"], label)}`;
+                }
+                if (active) {
+                  return `${checkbox} ${label}${hint}`;
+                }
+                return `${checkbox} ${styleText("dim", label)}`;
+              },
+              maxItems: promptOptions.maxItems,
+              output: promptOptions.output,
+              rowPadding: headerLines.length + footerLines.length
+            });
+            return [
+              ...headerLines,
+              ...displayOptions.map((option) => `${guidePrefix}${option}`),
+              ...footerLines
+            ].join("\n");
+          }
+        }
+      }
+    });
+    this.promptOptions = promptOptions;
+    this.on("key", (char, key) => {
+      if (key.name === "space" && !this.isNavigating && this.focusedValue !== void 0) {
+        this.toggleSelected(this.focusedValue);
+        this.#restore_cursor_to_end();
+        return;
+      }
+      if (!is_ctrl_a(char, key))
+        return;
+      this.#toggle_all_visible();
+      this.isNavigating = true;
+      this.#restore_cursor_to_end();
+    });
+  }
+  _isActionKey(char, key) {
+    return super._isActionKey(char, key) || this.multiple && key.name === "space" && char !== void 0 && char !== "";
+  }
+  #toggle_all_visible() {
+    const visible_values = this.filteredOptions.filter((option) => !option.disabled).map((option) => option.value);
+    if (!visible_values.length)
+      return;
+    const every_visible_selected = visible_values.every(
+      (value) => this.selectedValues.includes(value)
+    );
+    this.selectedValues = every_visible_selected ? this.selectedValues.filter((value) => !visible_values.includes(value)) : [
+      ...this.selectedValues,
+      ...visible_values.filter(
+        (value) => !this.selectedValues.includes(value)
+      )
+    ];
+  }
+  #restore_cursor_to_end() {
+    const rl = this.rl;
+    rl?.write("", { ctrl: true, name: "e" });
+    this._cursor = rl?.cursor ?? this.userInput.length;
+  }
+};
+function autocompleteMultiselect(opts) {
+  return new AutocompleteMultiselectPrompt(opts).prompt();
+}
+
+// src/prompts/commit-status.prompt.ts
+var CommitStatusPrompt = class extends Runnable {
+  async run() {
+    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);
+      }
+    }
+    ensure_staged_changes();
+  }
+  get #is_enabled() {
+    return this.config.check_status;
+  }
+  #log_status(status) {
+    p9.log.step(color3.black(color3.bgGreen(" Checking Git Status ")));
+    const staged_files = this.#format_files(status.index, color3.green);
+    p9.log.success("Changes to be committed:\n" + staged_files);
+    if (!status.work_tree.length)
+      return;
+    const unstaged_files = this.#format_files(status.work_tree, color3.red);
+    p9.log.error("Changes not staged for commit:\n" + unstaged_files);
+  }
+  #format_files(files, colorize) {
+    return files.reduce(
+      (acc, curr, index) => colorize(acc + curr + addNewLine(files, index)),
+      ""
+    );
+  }
+  async #select_for_staging(work_tree) {
+    const selected_for_staging = this.config.check_status_autocomplete ? await autocompleteMultiselect({
+      message: "Some files have not been staged, add them now?",
+      options: work_tree.map((v) => ({ value: v, label: v })),
+      required: false
+    }) : await p9.multiselect({
+      message: a_for_all_message("Some files have not been staged, add them now?"),
+      options: work_tree.map((v) => ({ value: v, label: v })),
+      required: false
+    });
+    if (p9.isCancel(selected_for_staging))
+      process.exit(0);
+    return selected_for_staging;
+  }
+};
+
+// src/help.ts
+import { execSync as execSync3 } from "child_process";
+import color4 from "picocolors";
+var ADDITIONAL_COMMAND_DEFINITIONS = {
+  "better-branch": "Create a branch or worktree from a guided prompt flow.",
+  "better-commits-init": "Create a .better-commits.jsonc config in this repository."
+};
+var CLI_FLAG_DEFINITIONS = {
+  "--no-interactive": "Run without tui prompts.",
+  "--dry-run": "Print the commit command without creating a commit.",
+  "--help": "Show help information and exit."
+};
+var COMMIT_FLAG_DEFINITIONS = {
+  "--type": "Set commit type (can be inferred from branch).",
+  "--scope": "Set commit scope (can be inferred from branch).",
+  "--title": "Set commit title/description.",
+  "--body": "Set commit body text.",
+  "--ticket": "Set ticket / issue (can be inferred from branch).",
+  "--closes": "Set closes footer (true/false).",
+  "--trailer": "Set trailer footer value.",
+  "--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."
+};
+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 = execSync3(`git ${flags.git_args} branch --show-current`, { stdio: "pipe" }).toString().trim() || "(none)";
+  } catch {
+  }
+  const inferred_type = infer_type_from_git(config2.commit_type.options, 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
+    },
+    flags.git_args
+  ) || "Unknown" : "Infer Disabled";
+  const inferred_scope = config2.commit_scope.infer_scope_from_branch ? infer_scope_from_git(config2.commit_scope.options, 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 commit_flags = to_definition_lines(COMMIT_FLAG_DEFINITIONS);
+  const additional_commands = to_definition_lines(
+    ADDITIONAL_COMMAND_DEFINITIONS
+  );
+  console.log(`
+${color4.green("\uF489 better-commits")} ${color4.gray("v" + version)}
+
+${color4.gray("BRANCH")} 
+ ${branch}
+ ${color4.gray("Type")} ${color4.blue(inferred_type)} ${color4.gray("\xB7")} ${color4.gray("Scope")} ${color4.cyan(inferred_scope)} ${color4.gray("\xB7")} ${color4.gray("Ticket")} ${color4.magenta(inferred_ticket)}
+
+${color4.gray("CONFIGURATION")} 
+ ${config_source2}
+
+${color4.gray("Types")} 
+ ${types}
+
+${color4.gray("Scopes")} 
+ ${scopes}
+
+${color4.gray("CLI FLAGS")} 
+${cli_flags}
+
+${color4.gray("Commit Flags")} 
+${commit_flags}
+
+${color4.gray("Git Flags (Advanced)")} 
+${git_flags}
+
+${color4.gray("ADDITIONAL COMMANDS")} 
+${additional_commands}
+
+`);
+}
+
+// src/index.ts
+var promptCtors = [
+  CommitStatusPrompt,
+  CommitTypePrompt,
+  CommitScopePrompt,
+  CommitTicketPrompt,
+  CommitTitlePrompt,
+  CommitBodyPrompt,
+  CommitFooterPrompt,
+  CommitConfirmPrompt
+];
+var { config, config_source } = load_setup();
+main(config, config_source);
+async function main(config2, config_source2) {
+  chdir(get_git_root());
+  if (flags.version) {
+    const version = get_package_version();
+    p10.log.step("Better Commits v" + version);
+    return;
+  }
+  if (flags.help) {
+    print_help_text(config2, config_source2);
+    return;
+  }
+  const infer_state = infer_not_interactive(config2);
+  const flags_plus_infer = {
+    ...flags.commit_state,
+    type: (flags.commit_state.type || infer_state?.type) ?? "",
+    scope: (flags.commit_state.scope || infer_state?.scope) ?? "",
+    ticket: (flags.commit_state.ticket || infer_state?.ticket) ?? ""
+  };
+  const commit_state = parse(CommitState, flags_plus_infer);
+  if (!flags.interactive) {
+    try {
+      parse(create_strict_commit_state(config2), commit_state);
+    } catch (err) {
+      if (err instanceof ValiError) {
+        p10.log.error(`Invalid commit input: ${err.message}`);
+      } else {
+        p10.log.error(`Failed to validate commit input: ${err}`);
+      }
+      process.exit(0);
+    }
+  }
+  const prompt_cache = config2.cache_last_value ? new Configstore("better-commits") : NOOP_PROMPT_CACHE;
+  const prompts_to_run = flags.interactive ? promptCtors : [CommitConfirmPrompt];
+  for (const Prompt of prompts_to_run) {
+    await new Prompt(config2, commit_state, prompt_cache).run();
+  }
+}
+export {
+  main
+};