gitbasher 5.2.0 → 5.3.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to gitbasher are generated automatically by [semantic-release](https://github.com/semantic-release/semantic-release) from [Conventional Commits](https://www.conventionalcommits.org/) on `main`. The project follows [Semantic Versioning](https://semver.org/).
 
+## [5.3.0](https://github.com/maxbolgarin/gitbasher/compare/v5.2.1...v5.3.0) (2026-09-30)
+
+### 🚀 Features
+
+* **config:** add `gitb cfg fast-split` to toggle split in fast modes ([c56e173](https://github.com/maxbolgarin/gitbasher/commit/c56e1735efeaea8c71f83e5d983cd24ff26fcd2b))
+* **commit:** ask before splitting, add undo split and fast-split setting ([1de1fcd](https://github.com/maxbolgarin/gitbasher/commit/1de1fcd523b5080da0c8248347558a421c8d72bb))
+* **commit:** show undo-split hint in the split type menu ([520e66a](https://github.com/maxbolgarin/gitbasher/commit/520e66aec25b43b7fb83b27f863cc6af4a0ab0e2))
+
+### 🐛 Bug Fixes
+
+* **branch:** pass HEAD to --merged when deleting merged branches ([2cdaf58](https://github.com/maxbolgarin/gitbasher/commit/2cdaf58c3a92e9f26eba47bd180b582cb9676d04))
+
+## [5.2.1](https://github.com/maxbolgarin/gitbasher/compare/v5.2.0...v5.2.1) (2026-07-11)
+
+### 🐛 Bug Fixes
+
+* **commit:** gate AI split by scope count and stop discarding near-complete groupings ([90becec](https://github.com/maxbolgarin/gitbasher/commit/90becec0f49a7a3e57e57e11a71b6909884ab337))
+
 ## [5.2.0](https://github.com/maxbolgarin/gitbasher/compare/v5.1.0...v5.2.0) (2026-07-07)
 
 ### 🚀 Features

package/README.md

@@ -360,7 +360,7 @@ gitb commit <combined>       # compact form: ff, aifp, fastsp, ...
 | `staged` | `st` | Use already-staged files (skip the add step) |
 | `push` | `p` `pu` | Push after the commit succeeds |
 | `scope` | `s` | Force a scope: `type(scope): message` (useful with fast mode) |
-| `no-split` | `nsp` `nsl` | Disable automatic split detection for this commit |
+| `no-split` | `nos` `nsp` `nsl` | Don't offer to split this commit (fast modes split by default) |
 | `ai` | `i` `llm` | Generate the commit message with AI |
 | `msg` | `m` | Open `$EDITOR` for a multiline message body |
 | `ticket` | `t` `j` `jira` | Append ticket info to the header |
@@ -383,6 +383,8 @@ gitb commit <combined>       # compact form: ff, aifp, fastsp, ...
 - Word order doesn't matter: `ai fast push` == `push fast ai` == `aifp`.
 - Modifiers stack on actions: `ai+fixup`, `fast+amend`, `split+push`, `ai+staged`, …
 - `fast` and `staged` are mutually exclusive (one stages all, the other uses what's staged).
+- Splitting: a regular commit **asks first** whether to try a split (before any grouping or AI work), then asks again to confirm the resulting groups. Fast modes (`fast`, `ff`, …) split without asking unless you turn it off with `gitb cfg fast-split`.
+- Press `u` at any split prompt to **undo the split**: commits already made by the split are dropped, staging is restored, and you continue with a single commit. `ff` never stops, so use the setting or `no-split` there.
 - `revert` and `ff` only accept `push` (as `revp` / `ffp`); to rewrite the last commit message use [`gitb edit`](#gitb-edit).
 
 ### `gitb edit`
@@ -804,6 +806,7 @@ gitb origin remove                               # delete the remote
 | `history` | `hist` | How many recent commits to include in AI prompts |
 | `diff` | `payload` | AI diff payload size (line and character caps) |
 | `push-size` | `ps` `pushsize` | Warn before pushing more than N MB (0 disables) |
+| `fast-split` | `fs` `fastsplit` | Split automatically in fast commit modes (on/off) |
 | `completion` | `comp` | Install / uninstall bash & zsh tab completion |
 | `delete` | `unset` `del` | Remove global config |
 
@@ -890,7 +893,8 @@ Overview-first diffs built for the gitbasher workflow — no flag memorization.
 | `gitbasher.ai-commit-history-limit` | `gitb cfg history` | Recent commits included in AI prompts (default `10`) |
 | `gitbasher.push-warn-size` | `gitb cfg push-size` | Warn before pushing more than N MB (default `50`, `0` disables) |
 | `gitbasher.worktreebase` | `git config gitbasher.worktreebase <dir>` | Base directory for new worktrees (default `.worktree` under the repo root) |
-| `gitbasher.commit-auto-split` | `git config gitbasher.commit-auto-split <ask\|always\|never>` | Offer to split a commit per scope (default `ask`) |
+| `gitbasher.commit-auto-split` | `git config gitbasher.commit-auto-split <ask\|always\|never>` | Offer to split a commit per scope (default `ask`: ask before splitting, then confirm the groups) |
+| `gitbasher.commit-fast-split` | `gitb cfg fast-split` | Fast modes split automatically (default `true`); `false` makes `fast` ask and `ff` commit as one |
 | `gitbasher.commit-max-split-groups` | `git config gitbasher.commit-max-split-groups <2..20>` | Cap on split commits per run (default `7`) |
 | `gitbasher.commit-split-order` | `git config gitbasher.commit-split-order <auto\|alpha>` | Order split commits by dependency (`auto`, default) or alphabetically (`alpha`) |
 | `gitbasher.commit-ai-grouping` | `git config gitbasher.commit-ai-grouping <never\|auto\|always>` | AI feature grouping for commit splits (default `auto`) |

package/dist/gitb

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 set -o pipefail
-GITBASHER_VERSION="5.2.0"
+GITBASHER_VERSION="5.3.0"
 if [ "$1" == "init" ] || [ "$1" == "i" ]; then
     git init
 fi
@@ -948,6 +948,11 @@ function print_configuration {
     else
         echo -e "\tPush warn:\t${GREEN}${push_warn} MB${ENDCOLOR} $(config_source_tag gitbasher.push-warn-size)"
     fi
+    if [ "$(get_fast_split)" = "true" ]; then
+        echo -e "\tFast split:\t${GREEN}auto${ENDCOLOR} $(config_source_tag gitbasher.commit-fast-split)"
+    else
+        echo -e "\tFast split:\t${YELLOW}off${ENDCOLOR} $(config_source_tag gitbasher.commit-fast-split)"
+    fi
     echo
     echo -e "${GRAY}Source:${ENDCOLOR} ${BLUE}(project)${ENDCOLOR}${GRAY} this repo,${ENDCOLOR} ${PURPLE}(global)${ENDCOLOR}${GRAY} ~/.gitconfig,${ENDCOLOR} ${GRAY}(default) built-in fallback${ENDCOLOR}"
 }
@@ -1204,6 +1209,14 @@ function get_push_warn_size {
 function set_push_warn_size {
     set_config_value gitbasher.push-warn-size "$1"
 }
+function get_fast_split {
+    local v
+    v=$(get_config_value gitbasher.commit-fast-split "true")
+    if [ "$v" = "false" ]; then echo "false"; else echo "true"; fi
+}
+function set_fast_split {
+    set_config_value gitbasher.commit-fast-split "$1"
+}
 function human_size {
     local bytes="${1:-0}"
     case "$bytes" in ''|*[!0-9]*) bytes=0;; esac
@@ -3691,6 +3704,40 @@ function configure_push_warn_size {
     yes_no_choice "\nSet push size warning globally" "true"
     git config --global gitbasher.push-warn-size "$limit_input"
 }
+function configure_fast_split {
+    echo -e "${YELLOW}Configure Fast Mode Split${ENDCOLOR}"
+    echo
+    if [ "$(get_fast_split)" = "true" ]; then
+        echo -e "Current: ${GREEN}auto${ENDCOLOR} (fast modes split without asking)"
+    else
+        echo -e "Current: ${YELLOW}off${ENDCOLOR} (fast asks first, ff commits everything as one)"
+    fi
+    echo
+    echo -e "When staged changes span several scopes, fast commit modes (${BLUE}fast${ENDCOLOR}, ${BLUE}ff${ENDCOLOR}, ...)"
+    echo -e "split them into atomic commits without asking. Turn it off to have ${BLUE}fast${ENDCOLOR}"
+    echo -e "ask first (like a regular commit) and ${BLUE}ff${ENDCOLOR} make a single commit."
+    echo
+    echo -e "1. ${GREEN}auto${ENDCOLOR}:\tsplit automatically in fast modes"
+    echo -e "2. ${YELLOW}off${ENDCOLOR}:\tdon't split by default in fast modes"
+    echo -e "0. Exit without changes"
+    local choice value label
+    while true; do
+        read_key choice || exit
+        case "$choice" in
+            1) value="true";  label="auto"; break ;;
+            2) value="false"; label="off";  break ;;
+            0) exit ;;
+        esac
+    done
+    echo
+    set_fast_split "$value" >/dev/null
+    echo -e "${GREEN}✓ Set fast mode split to ${label} for '${project_name}'${ENDCOLOR}"
+    echo
+    [ "$GITBASHER_NO_REPO" = "true" ] && exit
+    echo -e "Do you want to set it ${YELLOW}globally${ENDCOLOR} for all projects (Y/n)?"
+    yes_no_choice "\nSet fast mode split globally" "true"
+    set_config_value gitbasher.commit-fast-split "$value" "true" >/dev/null
+}
 function configure_ai_diff {
     echo -e "${YELLOW}Configure AI Diff Payload Size${ENDCOLOR}"
     echo
@@ -3852,6 +3899,8 @@ function delete_global {
     _delete_global_add "gitbasher.ai-commit-history-limit" "AI commit history limit" "$global_ai_history" "$GREEN"
     local global_push_warn=$(git config --global --get gitbasher.push-warn-size)
     _delete_global_add "gitbasher.push-warn-size" "Push size warning" "${global_push_warn:+${global_push_warn} MB}" "$GREEN"
+    local global_fast_split=$(git config --global --get gitbasher.commit-fast-split)
+    _delete_global_add "gitbasher.commit-fast-split" "Fast mode split" "$global_fast_split" "$GREEN"
     local global_ai_diff_lines=$(git config --global --get gitbasher.ai-diff-limit)
     local global_ai_diff_chars=$(git config --global --get gitbasher.ai-diff-max-chars)
     if [ -n "$global_ai_diff_lines" ] || [ -n "$global_ai_diff_chars" ]; then
@@ -3949,6 +3998,7 @@ function config_script {
         history|hist)         set_ai_history_cfg="true";;
         diff|payload)         set_ai_diff_cfg="true";;
         push-size|pushsize|ps) set_push_warn_cfg="true";;
+        fast-split|fastsplit|fs) set_fast_split_cfg="true";;
         delete|unset|del)     delete_cfg="true";;
         user|name|email|u)    set_user_cfg="true";;
         auto|completion|comp) auto_cfg="true";;
@@ -3982,6 +4032,8 @@ function config_script {
         header="$header AI DIFF PAYLOAD"
     elif [ -n "${set_push_warn_cfg}" ]; then
         header="$header PUSH SIZE WARNING"
+    elif [ -n "${set_fast_split_cfg}" ]; then
+        header="$header FAST MODE SPLIT"
     elif [ -n "${delete_cfg}" ]; then
         header="$header UNSET GLOBAL CONFIG"
     elif [ -n "${set_user_cfg}" ]; then
@@ -4055,6 +4107,10 @@ function config_script {
         configure_push_warn_size
         exit
     fi
+    if [ "$set_fast_split_cfg" == "true" ]; then
+        configure_fast_split
+        exit
+    fi
     if [ "$delete_cfg" == "true" ]; then
         delete_global
         exit
@@ -4083,6 +4139,7 @@ function config_script {
         print_help_row $PAD "history"   "hist"              "Set how many recent commits to include in AI prompts"
         print_help_row $PAD "diff"      "payload"           "Set the diff payload size (lines and char cap) sent to AI"
         print_help_row $PAD "push-size" "ps, pushsize"      "Warn before pushing more than N MB (0 disables)"
+        print_help_row $PAD "fast-split" "fs, fastsplit"    "Split automatically in fast commit modes (on/off)"
         print_help_row $PAD "auto"      "completion, comp"  "Install/remove tab completion for bash, zsh, or fish"
         print_help_row $PAD "delete"    "unset, del"        "Unset a global gitbasher configuration value"
         print_help_row $PAD "help"      "h"                 "Show this help"
@@ -6972,6 +7029,18 @@ function get_max_split_groups {
     [ "$v" -gt 20 ] && v=20
     printf '%s' "$v"
 }
+function should_attempt_ai_grouping {
+    local scope_count="$1" mode="$2"
+    case "$mode" in
+        always) return 0 ;;
+        never)  return 1 ;;
+    esac
+    case "$scope_count" in
+        ''|*[!0-9]*) return 1 ;;
+    esac
+    [ "$scope_count" -ge 3 ] && return 0
+    return 1
+}
 #
 #
 #
@@ -7146,6 +7215,7 @@ Read <diff> to decide which files implement the same feature. Output TSV (scope<
     local ai_response
     ai_response=$(call_ai_api "$system_prompt" "$user_prompt" "$AI_MAX_TOKENS_FULL" "" "" "low" 2>/dev/null)
     if [ $? -ne 0 ] || [ -z "$ai_response" ]; then
+        ai_grouping_fail_reason="API error"
         return 1
     fi
     ai_response=$(printf '%s' "$ai_response" | LC_ALL=C sed -e 's/^```[a-zA-Z]*$//' -e 's/^```$//')
@@ -7153,6 +7223,14 @@ Read <diff> to decide which files implement the same feature. Output TSV (scope<
     while IFS= read -r f; do
         [ -n "$f" ] && gset_add staged_set "$f"
     done <<< "$staged_files"
+    gmap_clear folder_scope_of
+    local _fk _ff
+    for _fk in "${split_group_keys[@]}"; do
+        while IFS= read -r _ff; do
+            [ -n "$_ff" ] && gmap_set folder_scope_of "$_ff" "$_fk"
+        done <<< "$(gmap_get split_groups "$_fk")"
+    done
+    gmap_clear assigned_set
     gmap_clear new_groups
     local -a new_keys=()
     local line scope file tab_count
@@ -7174,6 +7252,8 @@ Read <diff> to decide which files implement the same feature. Output TSV (scope<
         fi
         scope=$(printf '%s' "$scope" | LC_ALL=C tr '[:upper:]' '[:lower:]')
         gset_has staged_set "$file" || continue
+        gset_has assigned_set "$file" && continue
+        gset_add assigned_set "$file"
         if ! gmap_has new_groups "$scope"; then
             new_keys+=("$scope")
             gmap_set new_groups "$scope" "$file"
@@ -7181,15 +7261,44 @@ Read <diff> to decide which files implement the same feature. Output TSV (scope<
             gmap_set new_groups "$scope" "$(gmap_get new_groups "$scope")"$'\n'"$file"
         fi
     done <<< "$ai_response"
-    local total_assigned=0 total_staged
+    local total_assigned=0 total_staged unmatched
     local key
     for key in "${new_keys[@]}"; do
         total_assigned=$((total_assigned + $(printf '%s\n' "$(gmap_get new_groups "$key")" | grep -c .)))
     done
     total_staged=$(printf '%s\n' "$staged_files" | grep -c .)
-    if [ "$total_assigned" -ne "$total_staged" ] || [ ${#new_keys[@]} -lt 1 ]; then
+    if [ ${#new_keys[@]} -lt 1 ] || [ "$total_assigned" -eq 0 ]; then
+        ai_grouping_fail_reason="no usable grouping returned"
         return 1
     fi
+    unmatched=$((total_staged - total_assigned))
+    [ "$unmatched" -lt 0 ] && unmatched=0   # dedup should prevent this; be safe
+    if [ "$unmatched" -gt 0 ] && [ $((unmatched * 5)) -gt "$total_staged" ]; then
+        ai_grouping_fail_reason="${unmatched} of ${total_staged} files unassigned"
+        return 1
+    fi
+    if [ "$unmatched" -gt 0 ]; then
+        local single_group=""
+        [ ${#new_keys[@]} -eq 1 ] && single_group="${new_keys[0]}"
+        local sf leftover_scope
+        while IFS= read -r sf; do
+            [ -z "$sf" ] && continue
+            gset_has assigned_set "$sf" && continue
+            if [ -n "$single_group" ]; then
+                leftover_scope="$single_group"
+            else
+                leftover_scope=$(gmap_get folder_scope_of "$sf")
+                [ -z "$leftover_scope" ] && leftover_scope="misc"
+            fi
+            if ! gmap_has new_groups "$leftover_scope"; then
+                new_keys+=("$leftover_scope")
+                gmap_set new_groups "$leftover_scope" "$sf"
+            else
+                gmap_set new_groups "$leftover_scope" "$(gmap_get new_groups "$leftover_scope")"$'\n'"$sf"
+            fi
+            gset_add assigned_set "$sf"
+        done <<< "$staged_files"
+    fi
     gmap_clear split_groups
     split_group_keys=()
     for key in "${new_keys[@]}"; do
@@ -7243,11 +7352,35 @@ function _restore_split_snapshot {
     done < "$snapshot"
     rm -f "$snapshot"
 }
+function _undo_commit_split {
+    local start_head="$1"
+    local orig_tree="$2"
+    local snapshot="$3"
+    local made="$4"
+    if [ "${made:-0}" -gt 0 ]; then
+        if [ -n "$start_head" ]; then
+            git reset -q --soft "$start_head" >/dev/null 2>&1
+        else
+            git update-ref -d HEAD >/dev/null 2>&1
+        fi
+    fi
+    if [ -n "$orig_tree" ] && git read-tree "$orig_tree" >/dev/null 2>&1; then
+        rm -f "$snapshot"
+    else
+        _restore_split_snapshot "$snapshot"
+    fi
+}
 function print_split_type_menu {
     local scope="$1"
     local ai_available="$2"
+    local made="${3:-0}"
     echo -e "${YELLOW}What type of changes for ${BLUE}${BOLD}${scope}${ENDCOLOR}${YELLOW}?${ENDCOLOR}"
     echo -e "Final message will be ${YELLOW}<type>${ENDCOLOR}(${BLUE}<scope>${ENDCOLOR}): ${BLUE}<summary>${ENDCOLOR}"
+    if [ "$made" -gt 0 ]; then
+        echo -e "${GRAY}Changes were split into groups — press ${ENDCOLOR}${BOLD}u${NORMAL}${GRAY} to undo the split (drops the ${made} split commit(s) made so far) and commit everything at once.${ENDCOLOR}"
+    else
+        echo -e "${GRAY}Changes were split into groups — press ${ENDCOLOR}${BOLD}u${NORMAL}${GRAY} to undo the split and commit everything at once.${ENDCOLOR}"
+    fi
     echo -e "1. ${BOLD}feat${ENDCOLOR}:\tnew feature, logic change or performance improvement"
     echo -e "2. ${BOLD}fix${ENDCOLOR}:\t\tsmall changes, eg. bug fix"
     echo -e "3. ${BOLD}refactor${ENDCOLOR}:\tcode change that neither fixes a bug nor adds a feature, style changes"
@@ -7261,6 +7394,7 @@ function print_split_type_menu {
         echo -e "g. ${GREEN}${BOLD}ai${ENDCOLOR}:\t\tgenerate commit message using AI"
     fi
     echo -e "s. ${YELLOW}${BOLD}skip${ENDCOLOR}:\tSkip this group and leave its files unstaged"
+    echo -e "u. ${CYAN}${BOLD}undo${ENDCOLOR}:\tUndo split and commit all changes as a single commit"
     echo -e "0. ${RED}${BOLD}abort${ENDCOLOR}:\tAbort split and restore original staging"
     echo
 }
@@ -7334,7 +7468,7 @@ function run_split_ai_for_scope {
     echo
     echo -e "${GREEN}AI suggestion:${ENDCOLOR} ${BOLD}$ai_msg${ENDCOLOR}"
     echo
-    read_key choice "Use it? (y/e to edit/r to regenerate/s to skip group/0 to abort) " || choice="0"
+    read_key choice "Use it? (y/e to edit/r to regenerate/s to skip group/u to undo split/0 to abort) " || choice="0"
     echo
     normalize_key "$choice"
     while [ "$normalized_key" = "r" ]; do
@@ -7354,7 +7488,7 @@ ${ai_msg}"
         echo
         echo -e "${GREEN}AI suggestion:${ENDCOLOR} ${BOLD}$ai_msg${ENDCOLOR}"
         echo
-        read_key choice "Use it? (y/e to edit/r to regenerate/s to skip group/0 to abort) " || choice="0"
+        read_key choice "Use it? (y/e to edit/r to regenerate/s to skip group/u to undo split/0 to abort) " || choice="0"
         echo
         normalize_key "$choice"
     done
@@ -7371,6 +7505,8 @@ ${ai_msg}"
             [ -n "$f" ] && git restore --staged -- ":(top,literal)$f" >/dev/null 2>&1
         done <<< "$_files_str"
         return 2
+    elif [ "$normalized_key" = "u" ]; then
+        return 4
     elif [ "$choice" = "0" ]; then
         return 3
     fi
@@ -7384,6 +7520,9 @@ function perform_commit_split {
         return 1
     fi
     _capture_split_statuses
+    local start_head orig_tree
+    start_head=$(git rev-parse -q --verify HEAD 2>/dev/null)
+    orig_tree=$(git write-tree 2>/dev/null)
     local snapshot_file
     snapshot_file=$(mktemp "${TMPDIR:-/tmp}/gitb-split-snapshot.XXXXXX")
     chmod 600 "$snapshot_file" 2>/dev/null || true
@@ -7406,6 +7545,10 @@ function perform_commit_split {
     fi
     local scope files_str msg ai_msg choice scope_for_msg prefix manual_input
     local -a files_array
+    if [ -z "$auto_accept" ] && [ -n "$llm" ] && [ "$ai_ok" = "true" ]; then
+        echo
+        echo -e "${GRAY}Tip: press ${ENDCOLOR}${BOLD}u${NORMAL}${GRAY} at a split prompt to undo the split and make a single commit instead.${ENDCOLOR}"
+    fi
     for scope in "${split_group_keys[@]}"; do
         idx=$((idx + 1))
         echo
@@ -7454,6 +7597,13 @@ function perform_commit_split {
             run_split_ai_for_scope "$scope" "$scope_for_msg" "$files_str"
             case $? in
                 2) continue ;;
+                4)
+                    _undo_commit_split "$start_head" "$orig_tree" "$snapshot_file" "$commit_count"
+                    trap - INT TERM
+                    echo
+                    echo -e "${YELLOW}Split undone, continuing with a single commit.${ENDCOLOR}"
+                    return 3
+                    ;;
                 3)
                     _restore_split_snapshot "$snapshot_file"
                     trap - INT TERM
@@ -7474,11 +7624,11 @@ function perform_commit_split {
             local commit_type=""
             local is_empty_msg=""
             echo
-            print_split_type_menu "$scope" "$ai_ok"
+            print_split_type_menu "$scope" "$ai_ok" "$commit_count"
             local tchoice
             while true; do
                 read_key tchoice || tchoice="0"
-                if ! sanitize_choice_input "$tchoice" "^[0-9sg]$"; then
+                if ! sanitize_choice_input "$tchoice" "^[0-9sgu]$"; then
                     continue
                 fi
                 tchoice="$sanitized_choice"
@@ -7500,6 +7650,13 @@ function perform_commit_split {
                         case $? in
                             0) break ;;
                             2) continue 2 ;;
+                            4)
+                                _undo_commit_split "$start_head" "$orig_tree" "$snapshot_file" "$commit_count"
+                                trap - INT TERM
+                                echo
+                                echo -e "${YELLOW}Split undone, continuing with a single commit.${ENDCOLOR}"
+                                return 3
+                                ;;
                             3)
                                 _restore_split_snapshot "$snapshot_file"
                                 trap - INT TERM
@@ -7509,10 +7666,17 @@ function perform_commit_split {
                                 ;;
                             *)
                                 echo
-                                print_split_type_menu "$scope" "$ai_ok"
+                                print_split_type_menu "$scope" "$ai_ok" "$commit_count"
                                 ;;
                         esac
                         ;;
+                    u)
+                        _undo_commit_split "$start_head" "$orig_tree" "$snapshot_file" "$commit_count"
+                        trap - INT TERM
+                        echo
+                        echo -e "${YELLOW}Split undone, continuing with a single commit.${ENDCOLOR}"
+                        return 3
+                        ;;
                     s)
                         echo -e "${YELLOW}Skipping scope '${scope}' (files left unstaged)${ENDCOLOR}"
                         while IFS= read -r f; do
@@ -7606,18 +7770,35 @@ function try_offer_commit_split {
     local ai_grouping
     ai_grouping=$(get_config_value gitbasher.commit-ai-grouping "auto")
     local should_use_ai="false"
-    case "$ai_grouping" in
-        never)  should_use_ai="false" ;;
-        *)      should_use_ai="true" ;;   # auto + always: attempt AI
-    esac
-    if [ -z "$llm" ]; then
-        should_use_ai="false"
+    if [ -n "$llm" ] && should_attempt_ai_grouping "${#split_group_keys[@]}" "$ai_grouping"; then
+        should_use_ai="true"
+    fi
+    if [ ${#split_group_keys[@]} -lt 2 ] && [ "$should_use_ai" != "true" ]; then
+        if [ -n "$force_split" ]; then
+            echo -e "${YELLOW}Cannot split: all changes look like a single feature.${ENDCOLOR}"
+        fi
+        return 1
+    fi
+    local choice
+    if [ -z "$force_split" ] && [ -z "$auto_yes" ] && [ "$auto_split" != "always" ]; then
+        echo
+        if [ ${#split_group_keys[@]} -ge 2 ]; then
+            echo -e "${YELLOW}Staged changes span ${#split_group_keys[@]} scopes:${ENDCOLOR} ${BLUE}${split_group_keys[*]}${ENDCOLOR}"
+        fi
+        read_key choice "Try to split them into atomic commits? (y/N) " || choice=""
+        echo
+        if [ -z "$choice" ] || ! is_yes "$choice"; then
+            return 1
+        fi
     fi
     if [ "$should_use_ai" = "true" ] && check_ai_available 2>/dev/null; then
         echo
         echo -e "${YELLOW}Grouping changes by feature with AI...${ENDCOLOR}"
+        local ai_grouping_fail_reason=""
         if ! group_files_by_feature_with_ai; then
-            echo -e "${YELLOW}AI feature grouping failed, falling back to folder-based grouping.${ENDCOLOR}"
+            local reason_suffix=""
+            [ -n "$ai_grouping_fail_reason" ] && reason_suffix=" (${ai_grouping_fail_reason})"
+            echo -e "${YELLOW}AI feature grouping failed${reason_suffix}, using folder-based grouping.${ENDCOLOR}"
         fi
         consolidate_split_groups "$(get_max_split_groups)"
     fi
@@ -7631,7 +7812,6 @@ function try_offer_commit_split {
     echo
     print_split_groups_preview
     echo
-    local choice
     if [ -n "$force_split" ] || [ -n "$auto_yes" ] || [ "$auto_split" = "always" ]; then
         choice="y"
     else
@@ -7641,8 +7821,13 @@ function try_offer_commit_split {
     if [ -z "$choice" ] || ! is_yes "$choice"; then
         return 1
     fi
-    perform_commit_split || return 2
-    return 0
+    local split_rc=0
+    perform_commit_split || split_rc=$?
+    case "$split_rc" in
+        0) return 0 ;;
+        3) return 3 ;;
+        *) return 2 ;;
+    esac
 }
 function handle_ai_commit_generation {
     local step="$1"
@@ -8071,7 +8256,7 @@ function commit_script {
         print_help_row $FPAD "staged"   "st"          "Use already-staged files (skip the add step)"
         print_help_row $FPAD "push"     "p, pu"       "Push after the commit succeeds"
         print_help_row $FPAD "scope"    "s"           "Force a scope: 'type(scope): message' (useful with fast mode)"
-        print_help_row $FPAD "no-split" "nos, nsp, nsl" "Disable automatic split detection for this commit"
+        print_help_row $FPAD "no-split" "nos, nsp, nsl" "Don't offer to split this commit (fast modes split by default)"
         print_help_row $FPAD "ai"       "i, llm"      "Generate the commit message with AI"
         print_help_row $FPAD "msg"      "m"           "Open \$EDITOR for a multiline message body"
         print_help_row $FPAD "ticket"   "t, j, jira"  "Append ticket info to the header"
@@ -8090,6 +8275,8 @@ function commit_script {
         echo -e "  ${BLUE}•${ENDCOLOR} Word order doesn't matter: ${GREEN}ai fast push${ENDCOLOR} == ${GREEN}push fast ai${ENDCOLOR} == ${GREEN}aifp${ENDCOLOR}"
         echo -e "  ${BLUE}•${ENDCOLOR} Modifiers stack on actions: ${GREEN}ai+fixup${ENDCOLOR}, ${GREEN}fast+amend${ENDCOLOR}, ${GREEN}split+push${ENDCOLOR}, ${GREEN}ai+staged${ENDCOLOR}, ..."
         echo -e "  ${BLUE}•${ENDCOLOR} ${BOLD}fast${NORMAL} and ${BOLD}staged${NORMAL} are mutually exclusive (one stages all, the other uses what's staged)"
+        echo -e "  ${BLUE}•${ENDCOLOR} Regular commits ask before splitting; fast modes split by default (toggle: ${GREEN}gitb cfg fast-split${ENDCOLOR})"
+        echo -e "  ${BLUE}•${ENDCOLOR} Press ${BOLD}u${NORMAL} at a split prompt to undo the split and commit everything as one"
         echo -e "  ${BLUE}•${ENDCOLOR} ${BOLD}revert${NORMAL} and ${BOLD}ff${NORMAL} only accept ${BOLD}push${NORMAL} (as ${BOLD}revp${NORMAL}/${BOLD}ffp${NORMAL}); to rewrite the last message use ${GREEN}gitb edit${ENDCOLOR}"
         git config --unset gitbasher.cached-git-add 2>/dev/null || true
         exit 0
@@ -8244,14 +8431,19 @@ function commit_script {
     else
         staged_files_list="$(sed 's/^/\t/' <<< "$(git -c core.quotePath=false diff --no-renames --name-only --cached)")"
     fi
-    if [ -z "${amend}" ] && [ -z "${fixup}" ] && [ -z "${msg}" ] && [ -z "${ticket}" ] && [ -z "${no_split}" ]; then
-        _split_auto_yes=""
-        if [ -n "$fast" ] || [ -n "$auto_accept" ]; then
+    _split_skip="${no_split}"
+    _split_auto_yes=""
+    if [ -z "$split" ] && { [ -n "$fast" ] || [ -n "$auto_accept" ]; }; then
+        if [ "$(get_fast_split)" = "false" ]; then
+            [ -n "$auto_accept" ] && _split_skip="true"
+        else
             _split_auto_yes="true"
         fi
+    fi
+    if [ -z "${amend}" ] && [ -z "${fixup}" ] && [ -z "${msg}" ] && [ -z "${ticket}" ] && [ -z "${_split_skip}" ]; then
         try_offer_commit_split "$split" "$_split_auto_yes"
         _split_rc=$?
-        if [ -n "$split" ]; then
+        if [ -n "$split" ] && [ "$_split_rc" -ne 3 ]; then
             if [ "$_split_rc" -ge 2 ]; then
                 exit 1
             fi
@@ -9123,7 +9315,7 @@ function branch_script {
                             "$main_branch"|"$current_branch"|master|main|develop) continue ;;
                         esac
                         merged_to_delete+=("$_mb")
-                    done < <(git branch --merged --format='%(refname:short)')
+                    done < <(git branch --merged HEAD --format='%(refname:short)')
                     for branch_to_delete in "${merged_to_delete[@]}"; do
                         delete_output=$(git branch -d "$branch_to_delete" 2>&1)
                         delete_code=$?
@@ -15428,7 +15620,7 @@ _gitb_sub_sync="push p merge m mergep mp pm dry d dr help h"
 _gitb_sub_wip="up u down d help h"
 _gitb_sub_branch="list l remote r re main def m new n c newd nd cd delete del d prev p - recent rc gone g tag t help h"
 _gitb_sub_tag="annotated a an commit c co cm all al push ps ph p push-all pa delete del d delete-all da list log l remote re r fetch help h"
-_gitb_sub_config="default def d b main separator sep editor ed e ticket jira ti t scopes scope sc s ai llm key provider prov model m proxy prx p history hist diff payload push-size pushsize ps delete unset del user name email u auto completion comp help h"
+_gitb_sub_config="default def d b main separator sep editor ed e ticket jira ti t scopes scope sc s ai llm key provider prov model m proxy prx p history hist diff payload push-size pushsize ps fast-split fastsplit fs delete unset del user name email u auto completion comp help h"
 _gitb_sub_undo="commit c amend a merge m rebase r stash s help h"
 _gitb_sub_reset="soft s undo u interactive i ref r help h"
 _gitb_sub_stash="select sel all list l pop p show s drop d apply a help h"
@@ -15777,7 +15969,7 @@ _gitb() {
                     _values 'tag mode' 'annotated[create annotated tag]' 'commit[tag a commit]' 'all[tag everything]' 'push[push tag]' 'push-all[push all tags]' 'delete[delete tag]' 'delete-all[delete all]' 'list[list tags]' 'remote[remote tags]' 'help[show help]'
                     ;;
                 config|cf|cfg|conf)
-                    _values 'config key' 'default[default branch]' 'separator[separator char]' 'editor[editor]' 'ticket[ticket prefix]' 'scopes[scope list]' 'ai[AI setup wizard]' 'key[AI API key]' 'provider[AI provider]' 'model[AI model]' 'proxy[AI proxy]' 'history[AI history]' 'diff[AI diff payload]' 'push-size[warn on large pushes]' 'delete[unset a key]' 'user[user name/email]' 'auto[manage tab completion]' 'help[show help]'
+                    _values 'config key' 'default[default branch]' 'separator[separator char]' 'editor[editor]' 'ticket[ticket prefix]' 'scopes[scope list]' 'ai[AI setup wizard]' 'key[AI API key]' 'provider[AI provider]' 'model[AI model]' 'proxy[AI proxy]' 'history[AI history]' 'diff[AI diff payload]' 'push-size[warn on large pushes]' 'fast-split[split in fast commit modes]' 'delete[unset a key]' 'user[user name/email]' 'auto[manage tab completion]' 'help[show help]'
                     ;;
                 undo|un)
                     _values 'undo target' 'commit[undo last commit]' 'amend[undo amend]' 'merge[undo merge]' 'rebase[undo rebase]' 'stash[undo stash]' 'help[show help]'
@@ -15979,7 +16171,7 @@ complete -c gitb -n "$__gitb_branch" -a "list remote main new newd delete prev r
 set -l __gitb_tag "__gitb_using_cmd tag t tg; and __gitb_at_position 2"
 complete -c gitb -n "$__gitb_tag" -a "annotated commit all push push-all delete delete-all list remote help"
 set -l __gitb_config "__gitb_using_cmd config cf cfg conf; and __gitb_at_position 2"
-complete -c gitb -n "$__gitb_config" -a "default separator editor ticket scopes ai key provider model proxy history diff push-size delete user auto help"
+complete -c gitb -n "$__gitb_config" -a "default separator editor ticket scopes ai key provider model proxy history diff push-size fast-split delete user auto help"
 set -l __gitb_undo "__gitb_using_cmd undo un; and __gitb_at_position 2"
 complete -c gitb -n "$__gitb_undo" -a "commit amend merge rebase stash help"
 set -l __gitb_reset "__gitb_using_cmd reset res; and __gitb_at_position 2"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gitbasher",
-    "version": "5.2.0",
+    "version": "5.3.0",
     "description": "Simple bash utility that makes git easy to use",
     "keywords": [
         "git",