
Show HN: Gita – a CLI tool to manage multiple Git repos - nosarthur
https://github.com/nosarthur/gita
======
fyhn
One thing this project does really well is to start the readme with a
screenshot. I open the link, scroll down to the readme, and I immediately see
what sort of user interface/experience I will get. Some commenters have noted
that Gita is similar to other multi-repo tools, but both Repo and wstool are
more effort to evaluate, because their readmes don't have pictures.

------
stinos
Nice, but is there a way to just run any command? I.e. just `gita <optional
repo names/paths> <pass entire command line git -C repodir>`. This has
advantages in that you don't have to go round via a command file, don't have
to keep it synced across machines, don't have to remember what you put in the
file etc, and can just use the git syntax which already took long enough to
learn by heart :P

I've used multiple multiple repository tools and in the end all I happen to
use is one (usually versioned) file to store a list of repositories and then a
command which just loops over all repos and applies anything to it. If I need
custom commands I use git aliases so that works both for normal git and
whatever tool used.

~~~
joshka

        → cat ~/bin/git-all
        #!/bin/bash
    
        # Exit on error. Append "|| true" if you expect an error.
        set -o errexit
        # Exit on error inside any functions or subshells.
        set -o errtrace
        # Do not allow use of undefined vars. Use ${VAR:-} to use an undefined VAR
        set -o nounset
        # Catch the error in case command1 fails (but command2 succeeds) in `command1 |command2`
        set -o pipefail
        # Turn on traces, useful while debugging but commented out by default
        # set -o xtrace
    
        help() {
          cat <<EOF
    
        usage: git all <any-git-command>
    
        Runs the git command for all repositories in the current directory.
    
        Examples:
    
          What just happened?
            git all log -1 --oneline
    
          What am I doing now?
            git all status --short --branch
    
          What is everything I'm working on?
            git all branch -vv
        EOF
        }
    
        banner() {
          echo -e "\\033[1m=== $1 ===\\033[0m"
        }
    
        main() {
          if (( $# < 1 )); then
            help
            exit 1
          fi
    
          folders=$(find . -maxdepth 2 -name .git -print0 | xargs -0 -n1 dirname)
          for folder in $folders;
          do
            banner "$folder"
            git -C "$folder" "$@" || true
          done
        }
    
        main "$@"

~~~
stinos
Missed this reply, but yes, that's what I'm talking about!

------
pabs3
Another similar tool is myrepos (it supports other VCSen too). There are
several other similar tools, see the related software section of the myrepos
website:

[https://myrepos.branchable.com/](https://myrepos.branchable.com/)

~~~
noir_lord
I use myrepos and I like it a great deal.

mr register in the root of a git dir.

then `mr status` from home will show the state of all repo's registered, it's
handy at the eod to see what repos you've touched but not committed.

------
puzz
I wrote a similar tool (along with some other git helpers) a while ago:
[https://github.com/tkrajina/git-plus](https://github.com/tkrajina/git-plus).
Note that there is another (more popular) git-plus repository used in Atom. My
own has nothing to do with it (but it's older).

------
guessmyname
Isn’t this what “repo” [1] does?

[1]
[https://source.android.com/setup/develop/repo](https://source.android.com/setup/develop/repo)

~~~
nosarthur
didn't know this tool before. I will give it a try. Thanks!

------
j1elo
Cool, new tooling!

I currently use a mix of mu-repo [1] and uncommitted [2]

[1]: [http://fabioz.github.io/mu-repo/](http://fabioz.github.io/mu-repo/)

[2]: [https://github.com/brandon-
rhodes/uncommitted](https://github.com/brandon-rhodes/uncommitted)

------
amelius
The biggest problem with multiple repositories is to manage consistent
versions (commits).

For example, let's say that I have a release 1.0, which consists of a bunch of
commit IDs of various repositories. How do I go back to that release without
manually checking out the specific commit ID in each repo?

~~~
stinos
We use tags for that. Upon each release all repos get the same tag.
Alternatively with tools like mr [1] you can for each release keep a .mrconfig
somewhere which keeps the commit SHA for each repo (not 100% sure if mr can
create such file by itself, but it's not really hard) so that if you do a
fresh clone it checks out each repo at the correct commit.

[1] [https://linux.die.net/man/1/mr](https://linux.die.net/man/1/mr)

~~~
pabs3
There is a mr/myrepos plugin that adds some automation for remembering the
currently checked out commit:

[https://bitbucket.org/mforbes/mmfhg#rst-header-mr-un-
freeze](https://bitbucket.org/mforbes/mmfhg#rst-header-mr-un-freeze)

------
asutekku
Great tool! It’s nice we have one more tool to choose from. Each program has
their own UX so I don’t see a new contender as a bad thing.

------
Davidbrcz
wstool
([https://github.com/vcstools/wstool](https://github.com/vcstools/wstool)) is
a tool for managing a workspace of multiple heterogenous SCM repositories.

Very convenient. I have used it for ROS projects with multiples SCM

------
1337shadow
Can you put up an asciinema demo pls

------
mav3rick
Isn't this what repo does ?

------
googlemike
Or just have a monorepo :)

~~~
kingosticks
Operations on monorepos can be so slow that having multiple copies checked out
(e.g. different branches) is a thing (ideally using worktrees).

~~~
giancarlostoro
I hate to say it but because I don't feel comfortable with git enough whenever
I am about to do anything outside of my comfort zone I make a hard copy of my
whole directory just to be sure if I get myself into a FUBAR state I can
delete the FUBAR'd directory and copy it again. This has saved me many a
headache. Also gives me a fresh state from which to ask for help from. Anytime
the word rebase is mentioned my coworkers shriek.

~~~
kingosticks
Have you ever had a look at the combination of 'git reflog' and 'git reset
--hard <ident>'? You can find the point before you did the uncomfortable
operation and restore your state to exactly then. Saves having to make that
backup copy (which, again, can be slow for a big repo).

~~~
pjc50
Neither of those saves the working directory, though. So uncommitted work
"feels" at risk while typing unfamiliar git commands.

(I now consider myself pretty good with git as a result of being forced to
learn gerrit, but I also still remember the early painful days)

~~~
kingosticks
True, that's a good point.

