git-rm-merged-branches

#!/bin/bash
set -euo pipefail

usage() {
    cat >&2 <<EOM
usage: git rm-merged-branches [OPTIONS]

Look for git branches that have been merged to main, and interactively prompt
for whether to delete them.

This is useful to clean up local branches that are associated with pull
requests that have been merged.

Git can natively tell us which branches were merged (git branch --merged).

This command also tries to handle squash + merge cases. (To do this, it checks
each branch by squashing the branch and cherry picking the result to see if
there is any remaining diff.)

The default branch is assumed to be called 'main' or 'master'.

Exclusions:
- The currently checked out branch is ignored
- Branches env/* or stages/* are ignored

Options:
    -h, --help          Display help text
    --no-prune-squash   Don't check for squashed branches

EOM
}

run() {
    echo >&2 "+ $*"
    "$@"
}

# usage: prompt_yn [PROMPT]
# Prompt the user for a yes/no response.
#
# Exit codes:
#   0: user entered yes
#   2: STDIN is not a TTY
#   10: user entered no
#
prompt_yn() {
    local prompt ans
    if [ $# -ge 1 ]; then
        prompt="$1"
    else
        prompt="Continue?"
    fi

    if [ ! -t 0 ]; then
        echo >&2 "$prompt [y/n]"
        echo >&2 "prompt_yn: error: stdin is not a TTY!"
        return 2
    fi

    while true; do
        read -r -p "$prompt [y/n] " ans
        case "$ans" in
            Y|y|yes|YES|Yes)
                return
                ;;
            N|n|no|NO|No)
                return 10
                ;;
        esac
    done
}


# Determine the main/master branch and echo its name.
git-main-branch() {
    local ret
    git rev-parse --verify --quiet main >/dev/null && ret=$? || ret=$?

    case "$ret" in
        0)
            echo main
            return
            ;;
        1)
            # pass
            ;;
        *)
            # probably not a git repo / some other error
            return "$ret"
            ;;
    esac

    if git rev-parse --verify --quiet master >/dev/null; then
        echo master
    else
        echo >&2 "Neither master nor main exists"
        return 1
    fi
}


git-is-branch-cherry-equivalent() {
    local main branch
    main="$1"
    branch="$2"

    local merge_base
    merge_base="$(git merge-base "$main" "$branch")"

    # get the tree content as of the branch
    local tree
    tree="$(git rev-parse "$branch^{tree}")"

    # make a commit that's a single squashed commit of the tree, with
    # the main/master merge base as the parent
    local tmp_commit
    tmp_commit="$(git commit-tree "$tree" -p "$merge_base" -m "tmp from $0")"

    # TODO: is there any way to gc this tmp commit when we're done?

    # determine whether cherry-pick would do anything
    if [[ $(git cherry "$main" "$tmp_commit") == "-"* ]]; then
        # - prefix from git cherry means cherry-pick would be a no-op
        return 0
    fi

    return 1
}

# usage: is-branch-excluded BRANCH CURRENT_BRANCH
is-branch-excluded() {
    local branch current_branch

    branch="$1"
    current_branch="$2"

    # branches excluded from pruning
    case "$branch" in
        master|main)       return 0 ;;
        stages/*)          return 0 ;;
        env/*)             return 0 ;;
        "$current_branch") return 0 ;;
    esac

    return 1
}


main() {
    local branch current_branch
    local nothing_to_do

    current_branch="$(git branch --show-current)"
    nothing_to_do=1

    # prune merged branches
    for branch in $(git branch --format='%(refname:short)' --merged); do

        if is-branch-excluded "$branch" "$current_branch"; then
            continue
        fi

        nothing_to_do=
        if prompt_yn "Delete '$branch'?"; then
            run git branch -d "$branch"
        fi
    done

    if [ -n "$prune_squash" ]; then

        local main
        main="$(git-main-branch)"

        # prune squashed branches
        for branch in $(git for-each-ref refs/heads/ "--format=%(refname:short)")
        do

            if is-branch-excluded "$branch" "$current_branch"; then
                continue
            fi

            if git-is-branch-cherry-equivalent "$main" "$branch"; then
                nothing_to_do=
                if prompt_yn "Delete squashed '$branch'?"; then
                    run git branch -D "$branch"
                fi
            fi
        done
    fi


    if [ -n "$nothing_to_do" ]; then
        echo "Nothing to do"
    else
        echo "Done"
    fi
}

prune_squash=1

while [ $# -ge 1 ] && [[ $1 == -* ]]; do
    case "$1" in
        -h|--help)
            usage
            exit
            ;;
        --no-prune-squash)
            prune_squash=
            ;;
        *)
            echo >&2 "Invalid option: $1"
            exit 1
            ;;
    esac
    shift
done

main