Ytdyklly

Create a function:

gclonecd() {

  git clone "$1" && cd "$(basename "$1" .git)"

}

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

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 %sn" "$repo_name"

     cd "$repo_name"

   else

     /usr/bin/git "$@"

   fi

}

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

git clone git@github.com: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 git@github.com: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 git@github.com:npm/npm.git && cd $(basename $_ .git)

or

git clone git@github.com:npm/npm.git && cd ${${_%%.git*}##*/}

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 %sn" "$repo_name"

     cd "$repo_name"

   else

     command git "$@"

   fi

}

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.

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 %'

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...

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.