Jak sklonować wszystkie odległe gałęzie w Git?

Mam gałąź masteri developmentgałąź, obie przesyłane do GitHub . Mam cloned, pulled i fetched, ale pozostają w stanie dostać coś innego niż mastertyłu oddziału.

Jestem pewien, że brakuje mi czegoś oczywistego, ale przeczytałem instrukcję i wcale nie czerpię radości.

Najpierw sklonuj zdalne repozytorium Git i włóż do niego cd :

$ git clone git://example.com/myproject
$ cd myproject

Następnie spójrz na lokalne oddziały w swoim repozytorium:

$ git branch
* master

Ale w twoim repozytorium są inne gałęzie! Możesz je zobaczyć za pomocą -aflagi:

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

Jeśli chcesz po prostu rzucić okiem na odgałęzienie, możesz to sprawdzić bezpośrednio:

$ git checkout origin/experimental

Ale jeśli chcesz pracować nad tym oddziałem, musisz utworzyć lokalny oddział śledzenia, który jest wykonywany automatycznie przez:

$ git checkout experimental

i zobaczysz

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Ta ostatnia linia rzuca niektórym ludziom: „Nowa gałąź” - co? To tak naprawdę oznacza, że ​​gałąź jest pobierana z indeksu i tworzona lokalnie dla Ciebie. Poprzednia linia jest rzeczywiście bardziej pouczające, jak mówi, że oddział jest skonfigurowany do śledzenia zdalnego oddział, który zwykle oznacza pochodzenie / branch_name oddział

Teraz, jeśli spojrzysz na swoje lokalne oddziały, zobaczysz to:

$ git branch
* experimental
  master

Możesz faktycznie śledzić więcej niż jedno zdalne repozytorium za pomocą git remote.

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

W tym momencie sprawy stają się dość szalone, więc biegnij, gitkaby zobaczyć, co się dzieje:

$ gitk --all &

Jeśli masz wiele zdalnych gałęzi, które chcesz pobrać jednocześnie:

$ git pull --all

Teraz możesz kasować dowolną gałąź, tak jak potrzebujesz, bez konieczności odwiedzania zdalnego repozytorium.

Ten skrypt Bash pomógł mi:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

Stworzy gałęzie śledzące dla wszystkich gałęzi zdalnych, z wyjątkiem głównego (które prawdopodobnie otrzymałeś z oryginalnego polecenia klonowania). Myślę, że nadal będziesz musiał zrobić

git fetch --all
git pull --all

być pewnym.

Jedna linijka : git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs
jak zwykle: przetestuj w konfiguracji przed skopiowaniem wszechświata rm -rf, jaki znamy

Kredyty dla jednej linijki przejdź do interfejsu użytkownika

--mirrorWydaje się, że użycie opcji powoduje remoteprawidłowe skopiowanie gałęzi śledzących. Jednak ustawia repozytorium jako samo repozytorium, więc musisz później przekształcić je z powrotem w normalne repozytorium.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

^{Odwołanie: Git FAQ: Jak sklonować repozytorium ze wszystkimi zdalnie śledzonymi oddziałami?}

Możesz łatwo przejść do gałęzi bez użycia fantazyjnej składni „git checkout -b somebranch origin / somebranch”. Możesz po prostu zrobić:

git checkout somebranch

Git automatycznie zrobi właściwą rzecz:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'

Git sprawdzi, czy gałąź o tej samej nazwie istnieje w dokładnie jednym pilocie, a jeśli tak, śledzi ją w taki sam sposób, jakbyś wyraźnie wskazał, że jest to gałąź zdalna. Ze strony podręcznika git-checkout w Git 1.8.2.1:

Jeśli <branch> nie zostanie znaleziony, ale istnieje dokładnie gałąź śledzenia w jednym pilocie (nazwij ją <remote>) o pasującej nazwie, traktuj ją jako równoważną do

$ git checkout -b <branch> --track <remote>/<branch>

Jeżeli chodzi o,

$ git checkout -b eksperymentalne pochodzenie / eksperymentalne

za pomocą

$ git checkout -t origin/experimental

lub bardziej szczegółowe, ale łatwiejsze do zapamiętania

$ git checkout --track origin/experimental

może być lepiej, jeśli chodzi o śledzenie zdalnego repozytorium.

Operacja pobierania powinna uzyskać wszystkie zdalne gałęzie, ale nie utworzy dla nich lokalnych gałęzi. Jeśli używasz gitk, powinieneś zobaczyć zdalne gałęzie opisane jako „piloty / origin / dev” lub coś podobnego.

Aby utworzyć gałąź lokalną na podstawie gałęzi zdalnej, wykonaj następujące czynności:

git checkout -b dev refs / remotes / origin / dev

Który powinien zwrócić coś takiego:

Konfiguracja oddziału skonfigurowana do śledzenia zdalnych referencji / pilotów / pochodzenia / dev oddziału.
Przeniesiono do nowej gałęzi „dev”

Teraz, gdy jesteś w gałęzi programistów, polecenie „git pull” zaktualizuje lokalnego programistę do tego samego punktu, co gałąź zdalnych programistów. Pamiętaj, że pobierze wszystkie gałęzie, ale tylko tę, na której jesteś, pociągnij tylko na szczyt drzewa.

Po wykonaniu polecenia „git clone git: // location” wszystkie gałęzie i tagi są pobierane.

Aby pracować nad konkretną gałęzią zdalną, zakładając, że jest to zdalny początek:

git checkout -b branch origin/branchname

Użyj aliasów. Chociaż nie ma natywnych linijek Git, możesz zdefiniować własne jako

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

a następnie użyj go jako

git clone-branches

Dlaczego widzisz tylko „master”

git clonepobiera wszystkie zdalne gałęzie, ale nadal uważa je za „zdalne”, nawet jeśli pliki znajdują się w nowym repozytorium. Jest jeden wyjątek od tego, że proces klonowania tworzy lokalną gałąź o nazwie „master” ze zdalnej gałęzi o nazwie „master”. Domyślnie git branchpokazuje tylko lokalne oddziały, dlatego widzisz tylko „master”.

git branch -apokazuje wszystkie gałęzie, w tym gałęzie zdalne .

Jak zdobyć lokalne oddziały

Jeśli naprawdę chcesz pracować nad oddziałem, prawdopodobnie będziesz chciał mieć jego „lokalną” wersję. Aby po prostu utworzyć oddziały lokalne ze zdalnych oddziałów (bez ich sprawdzania, a tym samym zmiany zawartości katalogu roboczego) , możesz to zrobić w następujący sposób:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

W tym przykładzie branchonejest nazwą lokalnego oddziału, który tworzysz na podstawie origin/branchone; jeśli zamiast tego chcesz utworzyć lokalne oddziały o różnych nazwach, możesz to zrobić:

git branch localbranchname origin/branchone

Po utworzeniu oddziału lokalnego możesz go zobaczyć za pomocą git branch(pamiętaj, że nie musisz -awidzieć oddziałów lokalnych).

Nie jest to zbyt skomplikowane, bardzo proste i proste kroki są następujące;

git fetch origin Spowoduje to przeniesienie wszystkich zdalnych oddziałów do twojego lokalnego.

git branch -a Spowoduje to wyświetlenie wszystkich zdalnych gałęzi.

git checkout --track origin/<branch you want to checkout>

Sprawdź, czy jesteś w pożądanej gałęzi, wykonując następujące polecenie;

git branch

Dane wyjściowe będą się podobać;

*your current branch 
some branch2
some branch3 

Zwróć uwagę na znak *, który oznacza bieżącą gałąź.

Lepiej późno niż wcale, ale oto najlepszy sposób na to:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

W tym momencie masz pełną kopię zdalnego repo ze wszystkimi jego gałęziami (sprawdź za pomocą git branch). Możesz użyć --mirrorzamiast tego, --barejeśli twoje zdalne repo ma własne piloty.

Po prostu zrób to:

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
  master
$ git branch -a
* branchxyz
  master
  remotes/origin/HEAD -> origin/master
  remotes/origin/branchxyz
  remotes/origin/branch123

Widzisz, „git clone git: //example.com/myprojectt” pobiera wszystko, nawet gałęzie, musisz je tylko sprawdzić, wtedy twoja lokalna gałąź zostanie utworzona.

Aby uzyskać wszystkie gałęzie, wystarczy użyć „git clone”.

git clone <your_http_url>

Nawet jeśli widzisz tylko gałąź master, możesz użyć „git branch -a”, aby zobaczyć wszystkie gałęzie.

git branch -a

I możesz przejść do dowolnej gałęzi, którą już masz.

git checkout <your_branch_name>

Nie martw się, że po „git clone” nie musisz łączyć się ze zdalnym repozytorium, „git branch -a” i „git checkout” mogą zostać pomyślnie uruchomione po zamknięciu Wi-Fi. Udowodniono więc, że po wykonaniu „git clone” skopiował on już wszystkie gałęzie ze zdalnego repozytorium. Po tym nie potrzebujesz zdalnego repo, twój lokalny ma już wszystkie kody oddziałów.

A git clonema skopiować całe repozytorium. Spróbuj go sklonować, a następnie uruchom git branch -a. Powinien zawierać listę wszystkich gałęzi. Jeśli następnie chcesz przejść do gałęzi „foo” zamiast „master”, użyj git checkout foo.

Użyj mojego narzędzia git_remote_branch (potrzebujesz Ruby zainstalowanego na twoim komputerze). Został zbudowany specjalnie, aby ułatwić zdalne manipulowanie gałęziami.

Za każdym razem, gdy wykonuje operację w Twoim imieniu, drukuje ją na czerwono na konsoli. Z czasem w końcu wbijają się w twój mózg :-)

Jeśli nie chcesz, aby grb uruchamiał polecenia w Twoim imieniu, po prostu użyj funkcji „wyjaśnij”. Polecenia zostaną wydrukowane na konsoli zamiast wykonane dla Ciebie.

Na koniec wszystkie polecenia mają aliasy, aby ułatwić zapamiętywanie.

Zauważ, że jest to oprogramowanie alfa ;-)

Oto pomoc po uruchomieniu pomocy grb:

git_remote_branch wersja 0.2.6

  Stosowanie:

  grb utwórz nazwę gałęzi [serwer_początku] 

  grb opublikuj nazwa_gałęzi [serwer_początkowy] 

  grb zmień nazwę nazwa_ gałęzi [serwer_początkowy] 

  grb usuń nazwa_gałęzi [serwer_początkowy] 

  grb track nazwa_gałęzi [serwer_początkowy] 



  Uwagi:
  - Jeśli serwer_początkowy nie jest określony, zakłada się nazwę „pochodzenie” 
    (domyślnie git)
  - Funkcja zmiany nazwy zmienia nazwę bieżącej gałęzi

  Wyjaśnij meta-polecenie: możesz również wstawić dowolne polecenie za pomocą 
słowo kluczowe „wyjaśnij”. Zamiast wykonać polecenie, git_remote_branch
po prostu wyświetli listę poleceń, które musisz uruchomić, aby wykonać 
ten cel.

  Przykład: 
    grb wyjaśnić stworzyć
    grb wyjaśni, stwórz github my_branch

  Wszystkie polecenia mają również aliasy:
  utwórz: utwórz, nowy
  delete: usuń, zniszcz, zabij, usuń, rm
  opublikuj: opublikuj, zdalnie
  rename: zmiana nazwy, rn, mv, move
  śledzenie: śledzenie, śledzenie, chwytanie, pobieranie

wszystkie odpowiedzi, które tu widziałem, są poprawne, ale istnieje znacznie czystszy sposób klonowania repozytorium i wyciągania wszystkich gałęzi na raz.

Po sklonowaniu repozytorium wszystkie informacje o gałęziach są faktycznie pobierane, ale gałęzie są ukryte. Za pomocą polecenia

$ git branch -a

możesz wyświetlić wszystkie gałęzie repozytorium i za pomocą polecenia

$ git checkout -b branchname origin/branchname

możesz następnie „ręcznie” pobrać je pojedynczo.

Jednak jeśli chcesz sklonować repozytorium z wieloma gałęziami, wszystkie przedstawione powyżej sposoby są długie i żmudne w odniesieniu do znacznie czystszego i szybszego sposobu, który zamierzam pokazać, chociaż jest to trochę skomplikowane. Aby to osiągnąć, musisz wykonać trzy kroki:

1. Pierwszy krok

utwórz nowy pusty folder na swoim komputerze i klonuj kopię lustrzaną folderu .git z repozytorium:

$ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
$ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git

lokalne repozytorium w folderze my_repo_folder jest nadal puste, jest teraz tylko ukryty folder .git, który można zobaczyć za pomocą polecenia „ls -alt” z terminala.

2. Drugi krok

przełącz to repozytorium z pustego (pustego) do zwykłego, zmieniając wartość logiczną „gołą” konfiguracji git na false:

$ git config --bool core.bare false

3. Trzeci krok

Chwyć wszystko, co znajduje się w bieżącym folderze i utwórz wszystkie gałęzie na komputerze lokalnym, dzięki czemu jest to normalne repo.

$ git reset --hard

Teraz możesz po prostu wpisać polecenie „git branch” i możesz zobaczyć, że wszystkie gałęzie zostały pobrane.

Jest to szybki sposób klonowania repozytorium git ze wszystkimi gałęziami jednocześnie, ale nie jest to coś, co chcesz zrobić dla każdego projektu w ten sposób.

Klonowanie z lokalnego repozytorium nie będzie działać w przypadku git clone i git fetch: wiele gałęzi / tagów pozostanie nierozwiniętych.

Aby uzyskać klon ze wszystkimi gałęziami i tagami.

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

Aby uzyskać klon ze wszystkimi gałęziami i tagami, ale także z kopią roboczą:

git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master

OK, kiedy klonujesz swoje repozytorium, masz tam wszystkie oddziały ...

Jeśli to zrobisz git branch, są jakby ukryte ...

Więc jeśli chcesz zobaczyć nazwę wszystkich gałęzi, po prostu dodaj --allflagę w ten sposób:

git branch --all lub git branch -a

Jeśli tylko zameldujesz się w oddziale, otrzymasz wszystko, czego potrzebujesz.

Ale co jeśli gałąź utworzona przez kogoś innego po sklonowaniu?

W takim przypadku po prostu wykonaj:

git fetch

i sprawdź ponownie wszystkie gałęzie ...

Jeśli chcesz pobierać i kasować w tym samym czasie, możesz:

git fetch && git checkout your_branch_name

Utworzyłem również poniższy obrazek, aby uprościć to, co powiedziałem:

Patrząc na jedną z odpowiedzi na pytanie, zauważyłem, że można go skrócić:

for branch in  `git branch -r | grep -v 'HEAD\|master'`; do  
 git branch --track ${branch##*/} $branch;
done

Ale uwaga, jeśli jedna ze zdalnych gałęzi zostanie nazwana np. Admin_master, nie zostanie pobrana!

Dzięki bigfish za oryginalny pomysł

#!/bin/bash
for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
   git branch --track ${branch#remotes/origin/} $branch
done

Kod ten ściągnie cały kod zdalnych oddziałów do lokalnego repozytorium.

Aby skopiować i wkleić do wiersza poleceń:

git checkout master ; remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch -D $brname ; git checkout -b $brname $remote/$brname ; done ; git checkout master

Dla większej czytelności:

git checkout master ;
remote=origin ;
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do
    git branch -D $brname ;
    git checkout -b $brname $remote/$brname ;
done ;
git checkout master

1. sprawdź master (abyśmy mogli usunąć gałąź, na której jesteśmy)
2. wybierz pilota do kasy (zmień go na dowolny pilot)
3. zapętlić wszystkie gałęzie pilota oprócz master i HEAD
   1. usuń oddział lokalny (abyśmy mogli sprawdzić wymuszone aktualizacje oddziałów)
   2. sprawdź gałąź ze zdalnego
4. sprawdź master (ze względu na to)

Na podstawie odpowiedzi z VonC .

Napisałem te małe funkcje Powershell, aby móc sprawdzić wszystkie moje gałęzie git, które są zdalnie pochodzenia.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>
}


Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>
}

Więcej funkcji git można znaleźć w moim repozytorium ustawień git

Oto odpowiedź, która używa awk. Ta metoda powinna wystarczyć, jeśli zostanie użyta w nowym repozytorium.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

Istniejące gałęzie zostaną po prostu wyewidencjonowane lub zadeklarowane jako już w nim zawarte, ale filtry można dodać, aby uniknąć konfliktów.

Można go również modyfikować, aby wywoływał jawne git checkout -b <branch> -t <remote>/<branch>polecenie.

Ta odpowiedź następująco Nikos C. „s pomysł .

Alternatywnie możemy zamiast tego określić zdalną gałąź. Jest to oparte na murphytalk „s odpowiedź .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Zgłasza krytyczne komunikaty o błędach dotyczące konfliktów, ale widzę je jako nieszkodliwe.

Oba polecenia można aliasować.

Korzystanie nikt dydaktycznego odpowiedzi jako punkt odniesienia, możemy mieć następujące polecenia, aby utworzyć aliasy:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Osobiście użyłbym track-alllub track-all-branches.

Musiałem zrobić dokładnie to samo. Oto mój skrypt Ruby .

#!/usr/bin/env ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  line.strip!
  if /origin\//.match(line)
     remote[line.gsub(/origin\//, '')] = line
   else
     local << line
   end
end
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]

Żadna z tych odpowiedzi go nie ogranicza, z wyjątkiem użytkownika, że ​​nikt nie jest na dobrej drodze.

Miałem problem z przenoszeniem repozytorium z jednego serwera / systemu na inny. Kiedy sklonowałem repozytorium, utworzyło ono tylko lokalną gałąź dla mastera, więc kiedy przełączyłem na nowy pilot, tylko gałąź master została wypchnięta.

Dlatego te dwie metody były BARDZO przydatne. Mam nadzieję, że pomogą komuś innemu.

Metoda 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Metoda 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

git clone --mirror na oryginalnym repozytorium działa dobrze w tym celu.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin

Git zwykle (gdy nie jest określony) pobiera wszystkie gałęzie i / lub tagi (odnośniki, patrz:) git ls-refsz jednego lub więcej innych repozytoriów wraz z obiektami niezbędnymi do uzupełnienia ich historii. Innymi słowy, pobiera obiekty, które są osiągalne przez obiekty już pobrane. Zobacz: co tak git fetchnaprawdę robi?

Czasami możesz mieć oddziały / tagi, które nie są bezpośrednio połączone z bieżącym, więc git pull --all/ git fetch --allnie pomoże w takim przypadku, ale możesz je wymienić według:

git ls-remote -h -t origin

i pobierz je ręcznie, znając nazwy referencyjne.

Aby pobrać je wszystkie , spróbuj:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

^{Ten --depth=10000parametr może pomóc, jeśli masz płytkie repozytorium.}

Następnie sprawdź ponownie wszystkie swoje oddziały:

git branch -avv

Jeśli powyższe nie pomoże, musisz ręcznie dodać brakujące gałęzie do listy śledzenia (ponieważ w jakiś sposób się zgubiły):

$ git remote -v show origin
...
  Remote branches:
    master      tracked

przez git remote set-branches:

git remote set-branches --add origin missing_branch

więc może pojawić się remotes/originpo pobraniu:

$ git remote -v show origin
...
  Remote branches:
    missing_branch new (next fetch will store in remotes/origin)
$ git fetch
From github.com:Foo/Bar
 * [new branch]      missing_branch -> origin/missing_branch

Rozwiązywanie problemów

Jeśli nadal nie możesz uzyskać niczego innego niż gałąź główna, sprawdź następujące elementy:

• Sprawdź dokładnie swoje piloty ( git remote -v), np
  • Sprawdź git config branch.master.remoteto origin.
  • Sprawdź, czy originwskazuje właściwy adres URL za pośrednictwem: git remote show origin(zobacz ten post ).

Na początku 2017 r. Odpowiedź w tym komentarzu działa:

git fetch <origin-name> <branch-name>obniża gałąź dla ciebie. Chociaż nie powoduje to ściągnięcia wszystkich gałęzi naraz, możesz pojedynczo wykonać tę gałąź.

Oto kolejne krótkie polecenie jednowierszowe, które tworzy oddziały lokalne dla wszystkich oddziałów zdalnych:

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

Działa także poprawnie, jeśli śledzone są już lokalne oddziały. Możesz zadzwonić po raz pierwszy git clonelub później.

Jeśli nie musisz mieć mastergałęzi wyewidencjonowanej po klonowaniu, użyj

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout