How to cd automatically after git clone?

Question

I want to automatically cd to the directory created by the clone command after I git cloned something.

Important: I don't want to alter the syntax for the command (e.g. use an alias/function) because it would break the zsh-completions I get automatically from the Pretzo project.

EDIT: The reason I didn't pick any answer as correct, is because no answer was given that did comply with the condition above.

I use ZSH, but an answer in any other shell is acceptable as well.

Answer 1

Create a function:

gclonecd() {
  git clone "$1" && cd "$(basename "$1" .git)"
}

(Works for links both with and without ".git")

Answer 2

git clone takes an additional argument: the directory to use. You can make it clone into the current working directory with git clone URL . Then, there is no need to change working directory; you are already there.

If you really want the git command to actually change working directory, you can change it to a function which calls the real git when necessary:

git()
{
   local tmp=$(mktemp)
   local repo_name

   if [ "$1" = clone ] ; then
     /usr/bin/git "$@" | tee $tmp
     repo_name=$(awk -F\' '/Cloning into/ {print $2}' $tmp)
     rm $tmp
     printf "changing to directory %s\n" "$repo_name"
     cd "$repo_name"
   else
     /usr/bin/git "$@"
   fi
}

Answer 3

If you provide the local name of the repo, it's really easy using $_:

git clone [email protected]:npm/npm.git npm-local-dir && cd $_

But if you don't want to re-type long names, it's a little ugly but doable with sed:

git clone [email protected]:pckujawa/pattern-rec.git && 
cd `echo $_ | sed -n -e 's/^.*\/\([^.]*\)\(.git\)*/\1/p'`

EDIT: Well, I was going to thank Manav (comment below) for the terse

git clone foo/bar && cd !$:t

but it doesn't work in zsh (something about how zsh does expansions causes it not to treat the first command as input to !$). I had to look up what !$:t did (Advancing in the Bash Shell | ${me:-whatever}). !$ grabs the last part of the previous command and :t will "Remove all leading file name components, leaving the tail." Good information, but I wish I could get it to work with zsh (I tried noglob with no success).

EDIT: Instead of using sed or !$:t (which doesn't work in zsh, for me anyway), I found two other options (one adapting https://unix.stackexchange.com/users/5685/frederik-deweerdt 's answer with https://unix.stackexchange.com/users/129926/henrik-n 's comment):

git clone [email protected]:npm/npm.git && cd $(basename $_ .git)

or

git clone [email protected]:npm/npm.git && cd ${${_%%.git*}##*/}

Answer 4

A simple solution for any POSIX shell is to specify the directory to clone to explicitly (any filesystem path) and reuse it:

git clone <repository> <directory> &&
cd "$_"

and

cd -

when you're done.

Answer 5

You could do something like:

clone_check() {
  (($? != 0)) && return
  local cmd=$history[$((HISTCMD-1))]
  cmd=("${(@Q)${(z)cmd}}")
  if [[ $cmd = "git clone "* ]]; then
    local dir
    if (($#cmd == 3)); then
      dir=${cmd[3]:t}
      dir=${dir%.git}
      dir=${dir#*:}
    elif (($#cmd > 3)); then
      dir=$cmd[-1]
    else
      return
    fi
    print -r CDing into $dir > /dev/tty
    cd -- $dir
  fi
}
precmd_functions+=(clone_check)

It is quite simplistic. It's a precmd hook (executed before each prompt), that checks whether the last command line looked like git clone .../something or git clone .../something dir, guess the directory from that and cd into it.

It doesn't work if you entered git clone foo; whatever or whatever; git clone foo or git clone --option repo...

Answer 6

Here is an adaptation of the above answer for OSX

• mktemp requires additional parameter
• git clone writes to STDERR by default (see this)

Function:

function git {
   local tmp=$(mktemp -t git)
   local repo_name

   if [ "$1" = clone ] ; then
     command git "$@" --progress 2>&1 | tee $tmp
     repo_name=$(awk -F\' '/Cloning into/ {print $2}' $tmp)
     rm $tmp
     printf "changing to directory %s\n" "$repo_name"
     cd "$repo_name"
   else
     command git "$@"
   fi
}

Answer 7

There is a fundamental problem with your request that makes it almost impossible to achieve: git is a child process of the shell in this case, and child processes are unable to modify parent's environment in most operating systems. So, the only way of doing this would be from the shell's side - by implementing an alias or function.

You can find additional details here: https://stackoverflow.com/questions/2375003/how-do-i-set-the-working-directory-of-the-parent-process

Answer 8

I wouldn't recommend it, but you could use this one-liner:

echo 'project' | xargs -I % sh -c 'git clone https://github.com/username/%.git && cd %'

Answer 9

Include this in your shell:

git(){
  case "$1" in clone) git-clone "${@:2}";; *) command git "$@";; esac
}
git-clone(){ 
   local tgt 
   tgt=$(command git clone "$@" 2> >(tee /dev/stderr |head -n1 | cut -d \' -f2)) ||
      return $?
   cd "$tgt"
}

This works by surreptisiously gleaning the cloning target from git's standard error and cd'ing into the target if (and only if) the cloning was a success.

It accepts all arguments and options that the regular git clone does.

Either you can use the git wrapper and not have to worry about your completions, or you can get rid of the git wrapper and rewire your git clone completions to git-clone.

Answer 10

I've made this based on @frederik-deweerdt answer.

So you can user just clone to clone the repo link that are in clipboard, if you inform the repo, it clones than enters.

It is required to install xclip.

clone() {
if [ -z "$1" ]
then
      local repo=$(xclip -o)
else
      local repo=$1
fi
  git clone "$repo" && cd "$(basename "$repo" .git)"
}

Answer 11

Another implementation, also handles additional arguments to the git clone command.

Correctly cd's into the folder provided or the default git repo name.

Usage

gclonecd https://github.com/example/repo
gclonecd https://github.com/example/repo my-custom-folder

Bash Function

# Clones git repo and cd's into it
gclonecd() {
  git_dir="$(basename "$1" .git)"
  git_dir_resolved=${2:-$git_dir}
  git clone "$@" && cd "$git_dir_resolved";
}

Answer 12

If you want to clone with same name, same directory and cd you can use:

 git clone [clone_url] . && cd $_

Answer 13

All of the answers so far seem overly complicated. This works for SSH URIs and any other way of cloning because it simply uses the fact that the thing you just cloned is going to probably be the last modified item in your directory.

 gclone () {
    git clone $1
    local ldir=`ls -t | head -1`
    echo $ldir
    cd $ldir
    pwd
 }

Answer 14

You can use zsh glob qualifiers to expand to the most recently created directory within the current folder.

git clone [email protected]:example/repo.git && cd *(/om[1])

Glob qualifiers are in brackets and can be combined. Here is a breakdown of the qualifiers.

# *(/) directory
# (om) sort by last modified (descendingly)

It is possible that another directory is created right after git creates the working tree, so I wouldn't rely on it in critical scripts. It should be fine for day-to-day terminal usage.

[1] takes the first from the array (yes, it is not 0 in zsh).

Answer 15

I don't like the aliases so I solved it like this:

Add this to your zsh nano ~/.zshrc or bash nano ~/.bashrc:

## git extra features 
# - clone + cd 
function git() {
    if [ "$1" = "clone" ]
    then 
        command git "$@" && cd "$(basename "$_" .git)"
    else
        command git "$@"
    fi
}

Answer 16

If you're using ohmyzsh, you can use the take alias for this.

take https://github.com/npm/cli.git

will clone that repo and then change to its directory.