List all local branches without a remote

Problem: I want a way of deleting all the local branches I have that do not have a remote. It's easy enough to pipe the names of the branches into a git branch -D {branch_name}, but how do I get that list in the first place?

For example:

I create a new branch without a remote:

$ git co -b no_upstream

I list all my branches, and there's only one with a remote

$ git branch -a
master
* no_upstream
remotes/origin/HEAD -> origin/master
remotes/origin/master

What command can I run to get no_upstream as an answer?

I can run git rev-parse --abbrev-ref --symbolic-full-name @{u} and that will show that it has no remote:

$ git rev-parse --abbrev-ref --symbolic-full-name @{u}
error: No upstream configured for branch 'no_upstream'
error: No upstream configured for branch 'no_upstream'
fatal: ambiguous argument '@{u}': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

But as this is an error, it won't let me use it or pipe it to other commands. I'm intending to use this as either a shell script alias'd to git-delete-unbranched or maybe make a super simple Gem like git-branch-delete-orphans

I recommend using git branch --format to specify the exact output you want from the git branch command. By doing that, you can pull out just the refname and the upstream, like this:

git branch --format "%(refname:short) %(upstream)"

It outputs the branches along with the remote branches if they exist, in the following format:

25-timeout-error-with-many-targets
31-target-suggestions refs/remotes/origin/31-target-suggestions
54-feedback-link refs/remotes/origin/54-feedback-link
65-digest-double-publish

Once you have this nicely formatted output, it's as easy as piping it through awk to get your list:

git branch --format "%(refname:short) %(upstream)" | awk '{if (!$2) print $1;}'

Results in the following output:

25-timeout-error-with-many-targets
65-digest-double-publish

The awk portion prints the first column if there is no second column.

Bonus: Create an alias

Make it easy to run by creating an alias in your global .gitconfig file (or wherever):

[alias]
  local-branches = "!git branch --format '%(refname:short) %(upstream:short)' | awk '{if (!$2) print $1;}'"

Bonus: Remote Filtering

If for some reason you have multiple tracking remotes for different branches, it's easy enough to specify which remote you want to check against. Just add the remote name to the awk pattern. In my case, it's origin so I can do this:

git branch --format "%(refname:short) %(upstream)" | awk '$2 !~/\/origin\// { print $1 }'

Important: The backslash needs to be escaped in the alias or else you will have an invalid gitconfig file.

---

Previous Answer

The previous answer was functionally similar, but used the following as it's starting point. Over time, commenters have pointed out that a regex is unreliable due to the variance possible in a commit message, so I no longer recommend this method. But, here it is for reference:

I recently discovered git branch -vv which is the "very verbose" version of the git branch command.

It outputs the branches along with the remote branches if they exist, in the following format:

  25-timeout-error-with-many-targets    206a5fa WIP: batch insert
  31-target-suggestions                 f5bdce6 [origin/31-target-suggestions] Create target suggestion for team and list on save
* 54-feedback-link                      b98e97c [origin/54-feedback-link] WIP: Feedback link in mail
  65-digest-double-publish              2de4150 WIP: publishing-state

Once you have this nicely formatted output, it's as easy as piping it through cut and awk to get your list:

git branch -vv | cut -c 3- | awk '$3 !~/\[/ { print $1 }'

git branch (without any options) lists only local branches, but you don't know if they are tracking a remote branch or not.

Usually those local branches should be deleted once merged into master (as seen in this issue of git-sweep):

git branch --no-contains master --merged master | xargs git branch -d

This isn't as complete as you want, but it is a start.

> With --merged, only branches merged into the named commit (i.e. the branches whose tip commits are reachable from the named commit) will be listed.

I have a similar issue. I want to remove all local branches that were tracking remote branches that are now deleted. I am finding that git remote prune origin was insufficient to remove the branches that I want gone. Once the remote is deleted, I want the local to go away too. Here is what worked for me:

From my ~/.gitconfig:

[alias]
  prune-branches = !git remote prune origin && git branch -vv | grep ': gone]' | awk '{print $1}' | xargs -r git branch -d

Here is a git config --global ... command for easily adding this as git prune-branches:

git config --global alias.prune-branches '!git remote prune origin && git branch -vv | grep '"'"': gone]'"'"' | awk '"'"'{print $1}'"'"' | xargs -r git branch -d'

NOTE: I changed the -d to -D in my actual configuration, because I don't want to hear Git complain about unmerged branches. You may want this functionality as well. If so, simply use -D instead of -d at the end of that command.

Also, FWIW, your global configuration file would almost always be ~/.gitconfig.

(OS X Fix)

As written, this does not work on OS X because of the use of xargs -r (thanks, Korny).

The -r is to prevent xargs from running git branch -d without a branch name, which will result in an error message "fatal: branch name required". If you don't mind the error message, you can simply remove the -r argument to xargs and you're all set.

However, if you don't want to see an error message (and really, who could blame you) then you'll need something else that checks for an empty pipe. If you might be able to use ifne from moreutils. You would insert ifne before xargs, which will stop xargs from running with empty data. NOTE: ifne considers anything to be not empty, this includes blank lines, so you may still see that error message. I've not tested this on OS X.

Here is that git config line with ifne:

git config --global alias.prune-branches '!git remote prune origin && git branch -vv | grep '"'"': gone]'"'"' | awk '"'"'{print $1}'"'"' | ifne xargs git branch -d'

Late edit:

Better is

git for-each-ref  --format='%(refname:short) %(upstream)'  refs/heads \
| awk '$2 !~/^refs\/remotes/'

---

On GNU/anything

for b in `git branch|sed s,..,,`; do
    git config --get branch.$b.remote|sed Q1 && echo git branch -D $b
done

If more than a handful of branches were likely, there'd be better ways, using comm -23 on the output of git branch|sed|sort and git config -l|sed|sort.

This works for me:

git branch -vv | grep -v origin

(if your remote is named anything other than origin, substitute that).

This will list all the branches that aren't tracking a remote, which sounds like what you're looking for.

I synthetise my own Git command to get the origin/***: gone branches:

git remote prune origin && git branch -vv | cut -c 3- | grep ': gone]' | awk '{print $1}' | xargs -n1 -r echo git branch -d

git remote prune origin && git branch -vv will print branches in verbose mode.

cut -c 3- will remove very first characters.

grep ': gone]' will print only the gone remote branches.

awk '{print $1}' will print the branch name.

xargs -n1 -r echo git branch -d will print the git branch -d command to remove branches (-n1 will manage one command per time, -r to avoid issuing command if no branch is present).

HINT: remove the "echo" command to run the commands instead of print only, I left this in the command to check commands before issuing to git.

HINT 2: issue git branch -D if and only if you are sure you want to remove unmerged branches

Here is something I have used in PowerShell with comments to explain what it's doing. In an attempt to make it clear what's going on, I've not used any abbreviated PowerShell commands (aliases). Feel free to compress it to your desired level of crypticness :)

$verboseList = @(git branch -vv)
foreach ($line in $verboseList)
{
    # Get the branch name
    $branch = [regex]::Match($line, "\s(\S+)\s").Captures.Groups[1].Value
    # Check if the line contains text to indicate if the remote is deleted
    $remoteGone = $line.Contains(": gone]")
    # Check if the line does not contain text to indicate it is a tracking branch (i.e., it's local)
    $isLocal = !($line.Contains("[origin/"))
    if ($remoteGone -or $isLocal)
    {
        # Print the branch name
        $branch
    }
}

The most voted answer here does not work on my system see gist

This following does work and is reasonably clean.

git branch -v | awk '$3 == "[gone]" { print $1 }' | xargs git branch -D

Use -d if you don't want to delete un-merged branches.

Combining a few of the existing answers:

[alias]
        branch-local = !git branch -vv | cut -c 3- | egrep '([0-9a-f]{7} [^[])|(: gone\\])' | sed -E 's/(^.+[0-9a-f]{7} (\\[.+\\])?).*$/\\1/'

E.g.:

$ git branch-local
autogen_autoreconf      fcfb1c6 [github/autogen_autoreconf: gone]
autotools_documentation 72dc477 [github/autotools_documentation: gone]
cray-mpich-messy        2196f4b
epel-sphinx             cfda770
lammps                  07d96a7 [github/lammps: gone]
lark-error              9ab5d6c [github/lark-error: gone]
no-root2                c3894d1
openmpi-cray            69326cf [github/openmpi-cray: gone]
shellcheck-cleanup      40d90ec
travis-python36         cde072e
update_vagrant_default  4f69f47 [github/update_vagrant_default: gone]
web-docs                e73b4a8

None of the existing answers seems to work for me.

Here's my solution to list local branches that are not also remote

comm -13 <(git branch -r | sed 's/origin\/\(.*\)/\1/g' | cut -c 3-) <(git branch | cut -c 3-)

And here's an explanation of how it works:

1. Consider the list of all remote branches (without 'origin/' or leading spaces) git branch -r | sed 's/origin\/\(.*\)/\1/g' | cut -c 3-

2. Consider the list of all local branches (without asterisks or leading spaces) git branch | cut -c 3-

3. Compare these two lists and show me anything in list 2 (my local branches) that isn't in list 1 (the list of remote branches) comm -13 <(git branch -r | sed 's/origin\/\(.*\)/\1/g' | cut -c 3-) <(git branch | cut -c 3-)

> comm can take a combination of the flags -1, -2 and -3 indicating > which file to suppress lines from (unique to file 1, unique to file 2 > or common to both)