¿Cómo cambiar el nombre del autor y del committer y el correo electrónico de múltiples commits en Git?

Usando Rebase Interactivo

Usted podría hacer

git rebase -i -p <some HEAD before all of your bad commits>

Luego marque todas sus confirmaciones malas como "editar" en el archivo rebase. Si también desea cambiar su primer commit, debe agregarlo manualmente como primera línea en el archivo rebase (siga el formato de las otras líneas). Luego, cuando git te pida que modifiques cada commit, haz

 git commit --amend --author "New Author Name <[email protected]>" 

Edite o simplemente cierre el editor que se abre, y luego haga

git rebase --continue

Para continuar el rebase.

Podría omitir la apertura de la editor en conjunto aquí anexando --no-edit así que el comando será:

git commit --amend --author "New Author Name <[email protected]>" --no-edit && \
git rebase --continue

Single Commit

Como algunos de los comentaristas han señalado, si solo desea cambiar la confirmación más reciente, el comando rebase no es necesario. Solo hazlo

 git commit --amend --author "New Author Name <[email protected]>"

Esto cambiará el autor al nombre especificado, pero el committer se establecerá en su usuario configurado en git config user.name y git config user.email. Si desea establecer el committer a algo que especifique, esto establecerá tanto el autor como el committer:

 git -c user.name="New Author Name" -c [email protected] commit --amend --reset-author

Nota sobre las confirmaciones de fusión

Hubo un ligero defecto en mi respuesta original. Si hay confirmaciones de fusión entre el HEAD actual y tu <some HEAD before all your bad commits>, entonces git rebase las aplanará (y por cierto, si usas peticiones de extracción de GitHub, habrá un montón de confirmaciones de fusión en tu historial). Esto a menudo puede llevar a un historial muy diferente (ya que los cambios duplicados pueden "rebasarse"), y en el peor de los casos, puede llevar a git rebase pedirle que resuelva conflictos de fusión difíciles (que probablemente ya se resolvieron en las confirmaciones de fusión). La solución es usar la bandera -p para git rebase, que preservará la estructura de fusión de su historial. La página de manual de git rebase advierte que usar -p y -i puede generar problemas, pero en la sección BUGS dice "Editar confirmaciones y reformular sus mensajes de confirmación debería funcionar bien."

He agregado -p al comando anterior. Para el caso en el que solo estás cambiando la confirmación más reciente, esto no es un problema.

También puedes hacer:

git filter-branch --commit-filter '
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "$@";
        else
                git commit-tree "$@";
        fi' HEAD

Tenga en cuenta que si está utilizando este comando en el símbolo del sistema de Windows, debe usar " en lugar de ':

git filter-branch --commit-filter "
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "$@";
        else
                git commit-tree "$@";
        fi" HEAD

Un liner, pero ten cuidado si tienes un repositorio multiusuario-esto cambiará todas las confirmaciones para tener el mismo (nuevo) autor y confirmador.

git filter-branch -f --env-filter "GIT_AUTHOR_NAME='Newname'; GIT_AUTHOR_EMAIL='new@email'; GIT_COMMITTER_NAME='Newname'; GIT_COMMITTER_EMAIL='new@email';" HEAD

Con saltos de línea en la cadena (que es posible en bash):

git filter-branch -f --env-filter "
    GIT_AUTHOR_NAME='Newname'
    GIT_AUTHOR_EMAIL='new@email'
    GIT_COMMITTER_NAME='Newname'
    GIT_COMMITTER_EMAIL='new@email'
  " HEAD

Sucede cuando no tienes un HOME HOME/.gitconfig inicializado. Usted puede arreglar esto como:

git config --global user.name "you name"
git config --global user.email [email protected]
git commit --amend --reset-author

Probado con git versión 1.7.5.4

Para una sola confirmación:

git commit --amend --author="Author Name <[email protected]>"

(extraído de la respuesta de asmeurer)

En el caso de que solo los pocos commits superiores tengan autores malos, puedes hacer esto dentro de git rebase -i usando el comando exec y el commit --amend, de la siguiente manera:

git rebase -i HEAD~6 # as required

Que te presenta la lista editable de confirmaciones:

pick abcd Someone else's commit
pick defg my bad commit 1
pick 1234 my bad commit 2

Luego agregue exec ... --author="..." líneas después de todas las líneas con autores malos:

pick abcd Someone else's commit
pick defg my bad commit 1
exec git commit --amend --author="New Author Name <[email protected]>" -C HEAD
pick 1234 my bad commit 2
exec git commit --amend --author="New Author Name <[email protected]>" -C HEAD

Guardar y salir del editor (para ejecutar).

Esta solución puede ser más larga de escribir que algunas otras, pero es altamente controlable-sé exactamente qué lo confirma golpear.

Gracias a @asmeurer por la inspiración.

Github tiene una buena solución , que es el siguiente script de shell:

#!/bin/sh

git filter-branch --env-filter '

an="$GIT_AUTHOR_NAME"
am="$GIT_AUTHOR_EMAIL"
cn="$GIT_COMMITTER_NAME"
cm="$GIT_COMMITTER_EMAIL"

if [ "$GIT_COMMITTER_EMAIL" = "[email protected]" ]
then
    cn="Your New Committer Name"
    cm="Your New Committer Email"
fi
if [ "$GIT_AUTHOR_EMAIL" = "[email protected]" ]
then
    an="Your New Author Name"
    am="Your New Author Email"
fi

export GIT_AUTHOR_NAME="$an"
export GIT_AUTHOR_EMAIL="$am"
export GIT_COMMITTER_NAME="$cn"
export GIT_COMMITTER_EMAIL="$cm"
'

Como docgnome mencionó, reescribir la historia es peligroso y romperá los repositorios de otras personas.

Pero si realmente quieres hacer eso y estás en un entorno bash (no hay problema en Linux, en Windows, puedes usar git bash, que se proporciona con la instalación de git), usa git filter-branch :

git filter-branch --env-filter '
  if [ $GIT_AUTHOR_EMAIL = bad@email ];
    then GIT_AUTHOR_EMAIL=correct@email;
  fi;
export GIT_AUTHOR_EMAIL'

Para acelerar las cosas, puede especificar un rango de revisiones que desea reescribir:

git filter-branch --env-filter '
  if [ $GIT_AUTHOR_EMAIL = bad@email ];
    then GIT_AUTHOR_EMAIL=correct@email;
  fi;
export GIT_AUTHOR_EMAIL' HEAD~20..HEAD

Al hacerse cargo de un sin combinar commit de otro autor, hay una manera fácil de manejar esto.

git commit --amend --reset-author

Esta es una versión más elaborada de la versión de @Brian:

Para cambiar el autor y el committer, puedes hacer esto (con saltos de línea en la cadena que es posible en bash):

git filter-branch --env-filter '
    if [ "$GIT_COMMITTER_NAME" = "<Old name>" ];
    then
        GIT_COMMITTER_NAME="<New name>";
        GIT_COMMITTER_EMAIL="<New email>";
        GIT_AUTHOR_NAME="<New name>";
        GIT_AUTHOR_EMAIL="<New email>";
    fi' -- --all

Usted podría obtener uno de estos errores:

1. El directorio temporal ya existe
2. Refs starting with refs / original exists already
   (esto significa que otra rama de filtro se ha ejecutado previamente en el repositorio y la referencia de la rama original está respaldado en refs / original )

Si desea forzar la ejecución a pesar de estos errores, agregue --force bandera:

git filter-branch --force --env-filter '
    if [ "$GIT_COMMITTER_NAME" = "<Old name>" ];
    then
        GIT_COMMITTER_NAME="<New name>";
        GIT_COMMITTER_EMAIL="<New email>";
        GIT_AUTHOR_NAME="<New name>";
        GIT_AUTHOR_EMAIL="<New email>";
    fi' -- --all

Una pequeña explicación de la opción -- --all podría ser necesaria: Hace que la rama-filtro funcione en todas las revisiones de todas las referencias (que incluye todas las ramas). Esto significa, por ejemplo, que las etiquetas también se reescriben y son visibles en las ramas reescritas.

Un "error" común es usar HEAD en su lugar, lo que significa filtrar todas las revisiones solo en la rama actual . Y entonces no existirían etiquetas (u otras referencias) en la rama reescrita.

Puede usar este alias para que pueda hacer:

git change-commits GIT_AUTHOR_NAME "old name" "new name"

O para las últimas 10 confirmaciones:

git change-commits GIT_AUTHOR_EMAIL "[email protected]" "[email protected]" HEAD~10..HEAD

Alias:

change-commits = "!f() { VAR=$1; OLD=$2; NEW=$3; shift 3; git filter-branch --env-filter \"if [[ \\\"$`echo $VAR`\\\" = '$OLD' ]]; then export $VAR='$NEW'; fi\" $@; }; f "

Fuente: https://github.com/brauliobo/gitconfig/blob/master/configs/.gitconfig

Espero que sea útil.

1. ejecutar git rebase -i <sha1 or ref of starting point>
2. marque todas las confirmaciones que desea cambiar con edit (o e)

3. Repite los siguientes dos comandos hasta que hayas procesado todas las confirmaciones:

   git commit --amend --reuse-message=HEAD --author="New Author <[email protected]>" ; git rebase --continue

Esto mantendrá toda la otra información de confirmación (incluyendo las fechas). La opción --reuse-message=HEAD impide que el editor de mensajes se inicie.

Utilizo lo siguiente para reescribir el autor de un repositorio completo, incluyendo las etiquetas y todas las ramas:

git filter-branch --tag-name-filter cat --env-filter "
  export GIT_AUTHOR_NAME='New name';
  export GIT_AUTHOR_EMAIL='New email'
" -- --all

Luego, como se describe en la página de MANUAL de filter-branch, elimine todas las referencias originales respaldadas por filter-branch (esto es destructivo, primero la copia de seguridad):

git for-each-ref --format="%(refname)" refs/original/ | \
xargs -n 1 git update-ref -d

Adapté esta solución que funciona ingiriendo un author-conv-filesimple (el formato es el mismo que uno para git-cvsimport). Funciona cambiando todos los usuarios como se define en author-conv-file en todas las ramas.

Usamos esto junto con cvs2git para migrar nuestro repositorio de cvs a git.

Es decir, Muestra author-conv-file

john=John Doe <[email protected]>
jill=Jill Doe <[email protected]>

El script:

 #!/bin/bash

 export $authors_file=author-conv-file

 git filter-branch -f --env-filter '

 get_name () {
     grep "^$1=" "$authors_file" |
     sed "s/^.*=\(.*\) <.*>$/\1/"
 }

 get_email () {
     grep "^$1=" "$authors_file" |
     sed "s/^.*=.* <\(.*\)>$/\1/"
 }

 GIT_AUTHOR_NAME=$(get_name $GIT_COMMITTER_NAME) &&
     GIT_AUTHOR_EMAIL=$(get_email $GIT_COMMITTER_NAME) &&
     GIT_COMMITTER_NAME=$GIT_AUTHOR_NAME &&
     GIT_COMMITTER_EMAIL=$GIT_AUTHOR_EMAIL &&
     export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL &&
     export GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL
 ' -- --all

Encontré que las versiones presentadas son agresivas, especialmente si confirmas parches de otros desarrolladores, esto esencialmente robará su código.

La siguiente versión funciona en todas las ramas y cambia el autor y el comitente por separado para evitar eso.

Felicitaciones a leif81 por la opción all.

#!/bin/bash

git filter-branch --env-filter '
if [ "$GIT_AUTHOR_NAME" = "<old author>" ];
then
    GIT_AUTHOR_NAME="<new author>";
    GIT_AUTHOR_EMAIL="<[email protected]>";
fi
if [ "$GIT_COMMITTER_NAME" = "<old committer>" ];
then
    GIT_COMMITTER_NAME="<new commiter>";
    GIT_COMMITTER_EMAIL="<[email protected]>";
fi
' -- --all

1. Change commit author name & email by Amend, then replacing old-commit with new-one:

   $ git checkout <commit-hash>                            # checkout to the commit need to modify  
   $ git commit --amend --author "name <[email protected]>" # change the author name and email
   
   $ git replace <old-commit-hash> <new-commit-hash>      # replace the old commit by new one
   $ git filter-branch -- --all                           # rewrite all futures commits based on the replacement                   
   
   $ git replace -d <old-commit-hash>     # remove the replacement for cleanliness 
   $ git push -f origin HEAD              # force push 
   

2. Otra manera Rebasing:

   $ git rebase -i <good-commit-hash>      # back to last good commit
   
   # Editor would open, replace 'pick' with 'edit' before the commit want to change author
   
   $ git commit --amend --author="author name <[email protected]>"  # change the author name & email
   
   # Save changes and exit the editor
   
   $ git rebase --continue                # finish the rebase
   

Debo señalar que si el único problema es que el autor/correo electrónico es diferente de su habitual, esto no es un problema. La solución correcta es crear un archivo llamado .mailmap en la base del directorio con líneas como

Name you want <email you want> Name you don't want <email you don't want>

Y a partir de entonces, comandos como git shortlog considerarán que esos dos nombres son los mismos (a menos que específicamente les digas que no lo hagan). Véase http://schacon.github.com/git/git-shortlog.html para más información.

Esto tiene la ventaja de todos los otras soluciones aquí en que usted no tiene que reescribir la historia, que puede causar problemas si usted tiene un upstream, y siempre es una buena manera de perder datos accidentalmente.

Por supuesto, si cometiste algo como tú mismo y realmente debería ser alguien más, y no te importa reescribir la historia en este punto, cambiar el autor del commit es probablemente una buena idea para propósitos de atribución (en cuyo caso te dirijo a mi otra respuesta aquí).

Si usted es el único usuario de este repositorio, puede reescribir el historial usando cualquiera de los dos git filter-branch (como svick escribió ), o git fast-export/git fast-import más script de filtro (como se describe en el artículo referenciado en docgnome answer ), o interactivo rebase . Pero cualquiera de ellos cambiaría las revisiones desde la primera confirmación cambiada en adelante; esto significa problemas para cualquiera que base sus cambios en su rama pre-reescribir.

RECUPERACIÓN

Si otros desarrolladores no basaran su trabajo en la versión previa a la reescritura, la solución más simple sería volver a clonar (clonar de nuevo).

Alternativamente pueden probar git rebase --pull, lo que avanzaría rápidamente si no hubiera ningún cambio en su repositorio, o rebase su rama sobre confirmaciones re-escritas (queremos evitar la fusión, ya que mantendría los comits pre-reescritos para siempre). Todo esto asumiendo que no se han comprometido work; use git stash para guardar los cambios de otro modo.

Si otros desarrolladores usan ramas de características, y / o git pull --rebase no funciona, por ejemplo, porque el desarrollador principal no está configurado, tienen que rebase su trabajo sobre confirmaciones post-reescritura. Por ejemplo, justo después de obtener nuevos cambios (git fetch), para una rama master basada en / bifurcada desde origin/master, uno necesita ejecutar

$ git rebase --onto origin/master origin/master@{1} master

Aquí origin/master@{1} es el estado pre-reescrito (antes de fetch), ver [54]} gitrevisions .

La solución alternativa sería usar el mecanismo refs/replace/, disponible en Git desde la versión 1.6.5. En esta solución proporciona reemplazos para confirmaciones que tienen un correo electrónico incorrecto; luego cualquiera que obtenga' replace ' refs (algo como fetch = +refs/replace/*:refs/replace/* refspec en el lugar apropiado en su .git/config) obtendría reemplazos de forma transparente, y aquellos que no obtengan esos refs verán confirmaciones antiguas.

El procedimiento va algo así:

1. Encuentra todas las confirmaciones con correo electrónico incorrecto, por ejemplo usando

   $ git log [email protected] --all
   

2. Para cada confirmación incorrecta, cree una confirmación de reemplazo y agréguela a la base de datos de objetos

   $ git cat-file -p <ID of wrong commit> | 
     sed -e 's/user@wrong\.email/[email protected]/g' > tmp.txt
   $ git hash-object -t commit -w tmp.txt
   <ID of corrected commit>
   

3. Ahora que has corregido la confirmación en la base de datos de objetos, tienes que decirle a git que reemplace automática y transparentemente la confirmación incorrecta por una corregida usando git replace orden:

   $ git replace <ID of wrong commit> <ID of corrected commit>
   

4. Finalmente, enumere todos los reemplazos para verificar si este procedimiento tuvo éxito

   $ git replace -l
   

   Y comprobar si las sustituciones tienen lugar

   $ git log [email protected] --all
   

Por supuesto, puede automatizar este procedimiento... bueno, todos excepto usar git replace que no tiene (todavía) modo por lotes, por lo que tendría que usar shell loop para eso, o reemplazar "a mano".

NO PROBADO! YMMV.

^{Tenga en cuenta que puede encontrar algunas esquinas ásperas al usar el mecanismo refs/replace/: es nuevo, y aún no está muy bien probado}.

Si la comete quieres arreglar son los más recientes, y sólo un par de ellos, puede utilizar una combinación de git reset y git stash para volver un cometerlos de nuevo después de configurar el nombre y el correo electrónico.

La secuencia será algo como esto (para 2 confirmaciones incorrectas, sin cambios pendientes):

git config user.name <good name>
git config user.email <good email>
git reset HEAD^
git stash
git reset HEAD^
git commit -a
git stash pop
git commit -a

Si está utilizando Eclipse con EGit, entonces hay una solución bastante fácil.
Suposición: tiene confirmaciones en una rama local 'local_master_user_x' que no se puede enviar a una rama remota 'master' debido al usuario no válido.

1. Checkout la rama remota'master'
2. Seleccione los proyectos / carpetas / archivos para los que 'local_master_user_x' contiene cambios
3. Haga clic con el botón derecho en Reemplazar por-Branch - 'local_master_user_x'
4. Confirme estos cambios de nuevo, esta vez como el usuario correcto y en la rama local 'master'
5. Push to remote'master'

Usando rebase interactivo, puede colocar un comando amend después de cada confirmación que desee modificar. Por ejemplo:

pick a07cb86 Project tile template with full details and styling
x git commit --amend --reset-author -Chead

Tenga en cuenta que git almacena dosdirecciones de correo electrónico diferentes, una para el committer (la persona que cometió el cambio) y otra para el autor (la persona que escribió el cambio).

La información del committer no se muestra en la mayoría de los lugares, pero se puede ver con git log -1 --format=%cn,%ce (o usar show en lugar de log para especificar un commit en particular).

Mientras que cambiar el autor de su última confirmación es tan simple como git commit --amend --author "Author Name <[email protected]>", no hay un solo liner o argumento para haga lo mismo con la información del committer.

La solución es (temporalmente, o no) cambiar su información de usuario, luego modificar el commit, lo que actualizará el committer a su información actual:

git config user.email [email protected] 
git commit --amend

Hoy hemos experimentado un problema en el que un carácter UTF8 en un nombre de autor estaba causando problemas en el servidor de compilación, por lo que tuvimos que reescribir el historial para corregir esto. Las medidas adoptadas fueron:

Paso 1: Cambie su nombre de usuario en git para todas las confirmaciones futuras, según las instrucciones aquí: https://help.github.com/articles/setting-your-username-in-git /

Paso 2: Ejecute el siguiente script bash:

#!/bin/sh

REPO_URL=ssh://path/to/your.git
REPO_DIR=rewrite.tmp

# Clone the repository
git clone ${REPO_URL} ${REPO_DIR}

# Change to the cloned repository
cd ${REPO_DIR}

# Checkout all the remote branches as local tracking branches
git branch --list -r origin/* | cut -c10- | xargs -n1 git checkout

# Rewrite the history, use a system that will preseve the eol (or lack of in commit messages) - preferably Linux not OSX
git filter-branch --env-filter '
OLD_EMAIL="[email protected]"
CORRECT_NAME="New Me"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
fi
' --tag-name-filter cat -- --branches --tags

# Force push the rewritten branches + tags to the remote
git push -f

# Remove all knowledge that we did something
rm -rf ${REPO_DIR}

# Tell your colleagues to `git pull --rebase` on all their local remote tracking branches

Descripción rápida: Comprueba tu repositorio en un archivo temporal, compruebe todas las ramas remotas, ejecute el script que reescribirá el historial, haga un empuje de fuerza del nuevo estado y dígale a todos sus colegas que hagan un rebase pull para obtener los cambios.

Tuvimos problemas para ejecutar esto en OS X porque de alguna manera arruinó los finales de línea en los mensajes de confirmación, por lo que tuvimos que volver a ejecutarlo en una máquina Linux después.

Su problema es muy común. Ver " Usando Mailmap para Arreglar la Lista de Autores en Git "

En aras de la simplicidad, he creado un script para facilitar el proceso: git-changemail

Después de poner ese script en su ruta, puede emitir comandos como:

• Cambiar las coincidencias de autor en la rama actual

  $ git changemail -a [email protected] -n newname -m [email protected]
  

• Cambia las coincidencias de autor y committer en y . Pase -f a filter-branch para permitir la reescritura copias de seguridad

  $ git changemail -b [email protected] -n newname -m [email protected] -- -f <branch> <branch2>
  

• Mostrar usuarios existentes en repo

  $ git changemail --show-both
  

Por cierto, después de hacer sus cambios, limpie la copia de seguridad de la rama de filtro con: git-backup-clean

Si usted es el único usuario de este repositorio o no le importa posiblemente romper el repositorio para otros usuarios, entonces sí. Si has empujado estas confirmaciones y existen donde algún otro lugar puede acceder a ellas, entonces no, a menos que no te importe romper los repositorios de otras personas. El problema es que al cambiar estas confirmaciones, generarás nuevos SHAs que harán que se traten como confirmaciones diferentes. Cuando alguien más intenta tirar de estos cambios en las confirmaciones, la historia es diferente y kaboom.

Esta página http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html describe cómo hacerlo. (No he probado esto así YMMV)

También quiero añadir mi Ejemplo. Quiero crear un bash_function con un parámetro dado.

Esto funciona en mint-linux-17.3

# $1 => email to change, $2 => new_name, $3 => new E-Mail

function git_change_user_config_for_commit {

 # defaults
 WRONG_EMAIL=${1:-"[email protected]"}
 NEW_NAME=${2:-"your name"}
 NEW_EMAIL=${3:-"[email protected]"}

 git filter-branch -f --env-filter "
  if [ \$GIT_COMMITTER_EMAIL = '$WRONG_EMAIL' ]; then
    export GIT_COMMITTER_NAME='$NEW_NAME'
    export GIT_COMMITTER_EMAIL='$NEW_EMAIL'
  fi
  if [ \$GIT_AUTHOR_EMAIL = '$WRONG_EMAIL' ]; then
    export GIT_AUTHOR_NAME='$NEW_NAME'
    export GIT_AUTHOR_EMAIL='$NEW_EMAIL'
  fi
 " --tag-name-filter cat -- --branches --tags;
}

git rebase -i YOUR_FIRTS_COMMIT_SHA^

while true; do git commit --amend --author="Name Surname <[email protected]>" --no-edit && git rebase --continue; done

Presione ^C # después de que se haga el rebase (el bucle seguirá actualizando la última confirmación)

Prueba esto. Hará lo mismo que se mencionó anteriormente, pero de forma interactiva.

bash <(curl -s  https://raw.githubusercontent.com/majdarbash/git-author-change-script/master/run.sh)

Referencia: https://github.com/majdarbash/git-author-change-script

Esto no es una respuesta a tu pregunta, sino más bien un script que puedes usar para evitar esto en el futuro. Utiliza hooks globales disponibles desde Git versión 2.9 para verificar su configuración de correo electrónico basado en el directorio en el que se encuentra:

#!/bin/sh
PWD=`pwd`
if [[ $PWD == *"Ippon"* ]] # 1)
then
  EMAIL=$(git config user.email)
  if [[ $EMAIL == *"Work"* ]] # 2)
  then
    echo "";
  else
    echo "Email not configured to your Work email in the Work directory.";
    git config user.email "[email protected]"
    echo "Git email configuration has now been changed to \"$(git config user$
    echo "\nPlease run your command again..."
    echo ''
    exit 1
  fi;
elif [[ $PWD == *"Personal"* ]]
then
  EMAIL=$(git config user.email)
  if [[ $EMAIL == "[email protected]" ]]
  then
    echo "";
  else
    echo "Email is not configured to your personal account in the Personal di$
    git config user.email "[email protected]"
    echo "Git email configuration has now been changed to \"$(git config user$
    echo "\nPlease run your command again..."
    echo ''
    exit 1;
  fi;
fi; 

Comprueba tu directorio de trabajo actual, luego verifica que tu git esté configurado para el correo electrónico correcto. Si no, lo cambia automáticamente. Ver todos los detalles aquí.