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

Estaba escribiendo un guión simple en la computadora de la escuela y cometiendo los cambios a Git (en un repository que estaba en mi pendrive, clonado desde mi computadora en casa). Después de varios commits, me di cuenta de que estaba cometiendo cosas como usuario root.

¿Hay alguna forma de cambiar el autor de estos commits a mi nombre?

Cambiar el autor (o committer) requeriría volver a escribir todo el historial. Si estás de acuerdo con eso y crees que vale la pena, entonces deberías echarle un vistazo a git filter-branch . La página man incluye varios ejemplos para comenzar. También tenga en cuenta que puede usar variables de entorno para cambiar el nombre del autor, el autor, las fechas, etc. – consulte la sección “Variables del entorno” de la página del manual de git .

Específicamente, puede corregir todos los nombres de autor y correos electrónicos incorrectos para todas las twigs y tags con este comando (fuente: ayuda de GitHub ):

#!/bin/sh git filter-branch --env-filter ' OLD_EMAIL="your-old-email@example.com" CORRECT_NAME="Your Correct Name" CORRECT_EMAIL="your-correct-email@example.com" if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ] then export GIT_COMMITTER_NAME="$CORRECT_NAME" export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL" fi if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ] then export GIT_AUTHOR_NAME="$CORRECT_NAME" export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL" fi ' --tag-name-filter cat -- --branches --tags 

Usando Rebase interactivo

Podrías hacerlo

 git rebase -i -p  

Luego marque todas las confirmaciones incorrectas como “editar” en el archivo rebase. Si también desea cambiar su primer compromiso, debe agregarlo manualmente como primera línea en el archivo rebase (siga el formato de las otras líneas). Entonces, cuando git le pida que modifique cada compromiso, haga

  git commit --amend --author "New Author Name " 

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

 git rebase --continue 

para continuar la rebase.

Puede omitir la apertura del editor aquí al agregar --no-edit para que el comando sea:

 git commit --amend --author "New Author Name " --no-edit && \ git rebase --continue 

Single Commit

Como algunos de los comentaristas han notado, si solo quieres cambiar la confirmación más reciente, el comando rebase no es necesario. Solo haz

  git commit --amend --author "New Author Name " 

Esto cambiará el autor al nombre especificado, pero el committer se configurará para 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 user.email=email@address.com commit --amend --reset-author 

Nota sobre los compromisos de fusión

Hubo un pequeño error en mi respuesta original. Si hay algún commit de fusión entre el HEAD actual y tu , entonces git rebase los git rebase (y por cierto, si usas solicitudes de extracción de GitHub, habrá una gran cantidad de combinaciones se compromete en tu historia). Esto muy a menudo puede llevar a una historia muy diferente (ya que los cambios duplicados pueden ser “redefinidos”) y en el peor de los casos, puede llevar a la base de datos de git rebase pedirle que resuelva conflictos de fusión difíciles (que probablemente ya se resolvieron en los commits de fusión) ) La solución es usar el indicador -p para git rebase , que preservará la estructura de fusión de su historial. La página de git rebase advierte que usar -p y -i puede provocar problemas, pero en la sección BUGS dice “La edición de confirmaciones y la nueva redacción de los mensajes de confirmación deberían funcionar bien”.

He agregado -p al comando anterior. Para el caso en el que solo está 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" = "" ]; then GIT_COMMITTER_NAME=""; GIT_AUTHOR_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_EMAIL=""; git commit-tree "$@"; else git commit-tree "$@"; fi' HEAD 

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

 git filter-branch --commit-filter " if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_AUTHOR_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_EMAIL=""; git commit-tree "$@"; else git commit-tree "$@"; fi" HEAD 

Un trazador de líneas, pero tenga cuidado si tiene un repository de usuarios múltiples: 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 linebreaks 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 tiene inicializado un $ HOME / .gitconfig. Puedes arreglar esto como:

 git config --global user.name "you name" git config --global user.email you@domain.com git commit --amend --reset-author 

probado con la versión de Git 1.7.5.4

Para una única confirmación:

 git commit --amend --author="Author Name " 

(extraído de la respuesta del asmeurer)

En el caso en que solo los primeros commits tengan malos autores, puedes hacer esto dentro de git rebase -i usando el comando exec y la confirmación de --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 

A continuación, agregue las líneas exec ... --author="..." después de todas las líneas con los autores incorrectos:

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

guardar y salir del editor (para ejecutar).

Esta solución puede ser más larga de escribir que otras, pero es muy controlable: sé exactamente qué se compromete.

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" = "your@email.to.match" ] then cn="Your New Committer Name" cm="Your New Committer Email" fi if [ "$GIT_AUTHOR_EMAIL" = "your@email.to.match" ] 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 se menciona en el docgnome, reescribir la historia es peligroso y romperá los repositorys 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), utiliza 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 compromiso no compartido 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 linebreaks en la cadena que es posible en bash):

 git filter-branch --env-filter ' if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_NAME=""; GIT_AUTHOR_EMAIL=""; fi' -- --all 

Puede obtener uno de estos errores:

  1. El directorio temporal ya existe
  2. Refs comenzando con refs / original ya existe
    (Esto significa que otra twig de filtro se ha ejecutado previamente en el repository y que la referencia de la twig original se copia en refs / original )

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

 git filter-branch --force --env-filter ' if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_NAME=""; GIT_AUTHOR_EMAIL=""; fi' -- --all 

Una pequeña explicación de la opción -- --all podría ser necesaria: hace que la twig de filtro funcione en todas las revisiones en todos los refs (que incluye todas las twigs). Esto significa, por ejemplo, que las tags también se reescriben y son visibles en las twigs reescritas.

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

Puedes usar este alias para que puedas hacer:

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

o durante los últimos 10 commits:

 git change-commits GIT_AUTHOR_EMAIL "old@email.com" "new@email.com" 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. Ejecute git rebase -i
  2. marque todos los commits que quiera cambiar con edit (o e )
  3. repita los siguientes dos comandos hasta que haya procesado todas las confirmaciones:

    git commit --amend --reuse-message=HEAD --author="New Author " ; git rebase --continue

Esto mantendrá toda la información de compromiso (incluidas las fechas). La --reuse-message=HEAD evita que se --reuse-message=HEAD el editor de mensajes.

Utilizo lo siguiente para reescribir el autor para un repository completo, incluidas las tags y todas las twigs:

 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 MAN de filter-branch , elimine todos los refs originales respaldados 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 

Adapte esta solución que funciona al ingerir un simple author-conv-file (el formato es el mismo que el de git-cvsimport ). Funciona al cambiar todos los usuarios como se define en el author-conv-file en todas las twigs.

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

es decir, muestra author-conv-file

 john=John Doe  jill=Jill Doe  

La secuencia de comandos:

  #!/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 

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

La versión siguiente funciona en todas las twigs y cambia el autor y la persona que comenta por separado para evitar eso.

Felicitaciones a leif81 por la opción de todos.

 #!/bin/bash git filter-branch --env-filter ' if [ "$GIT_AUTHOR_NAME" = "" ]; then GIT_AUTHOR_NAME=""; GIT_AUTHOR_EMAIL=""; fi if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_COMMITTER_EMAIL=""; fi ' -- --all 
  1. Cambie el author name & email commit por Amend , luego reemplace old-commit with new-one :

     $ git checkout  # checkout to the commit need to modify $ git commit --amend --author "name " # change the author name and email $ git replace   # replace the old commit by new one $ git filter-branch -- --all # rewrite all futures commits based on the replacement $ git replace -d  # remove the replacement for cleanliness $ git push -f origin HEAD # force push 
  2. Otra forma de Rebasing :

     $ git rebase -i  # 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 " # 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 al 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  Name you don't want  

Y a partir de ese momento, los comandos como git shortlog considerarán que esos dos nombres son los mismos (a menos que específicamente les indique que no lo git shortlog ). Consulte http://schacon.github.com/git/git-shortlog.html para obtener más información.

Esto tiene la ventaja de todas las otras soluciones aquí en que no tiene que reescribir el historial, lo que puede causar problemas si tiene un flujo ascendente, y siempre es una buena manera de perder datos accidentalmente.

Por supuesto, si has cometido algo como tú mismo y realmente debería ser otra persona, y no te importa reescribir la historia en este punto, cambiar el autor de la confirmación es probablemente una buena idea para fines de atribución (en cuyo caso te dirijo a mi otra respuesta aquí).

Si usted es el único usuario de este repository, puede reescribir el historial utilizando git filter-branch (como escribió svick ) o git fast-export / git fast-import plus script (como se describe en el artículo al que se hace referencia en docgnome answer ), o rebase interactivo. Pero cualquiera de ellos cambiaría las revisiones del primer compromiso modificado en adelante; esto significa problemas para cualquiera que basó sus cambios en su twig antes de la reescritura.

RECUPERACIÓN

Si otros desarrolladores no basaron 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 , que se adelantaría rápidamente si no hubiera ningún cambio en su repository, o rebase su twig en la parte superior de las confirmaciones escritas (queremos evitar la fusión, ya que mantendría reescribir los comits para siempre). Todo esto suponiendo que no hayan realizado un trabajo; use git stash para guardar los cambios de lo contrario.

Si otros desarrolladores usan twigs de características, y / o git pull --rebase no funciona, por ejemplo, porque upstream no está configurado, tienen que volver a establecer su trabajo en la parte superior de las confirmaciones posteriores a la reescritura. Por ejemplo, justo después de obtener nuevos cambios ( git fetch ), para una twig master basada en / bifurcada desde el origin/master , se necesita ejecutar

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

Aquí origin/master@{1} es un estado previo a la reescritura (antes de fetch), consulte gitrevisions .


La solución alternativa sería usar refs / replace / mechanism, 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; entonces cualquiera que busque ‘reemplazar’ refs (algo así como fetch = +refs/replace/*:refs/replace/* refspec en el lugar apropiado en su .git/config ) obtendría reemplazos transparentemente, y aquellos que no busquen esos refs lo harían ver compromisos antiguos

El procedimiento es algo como esto:

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

     $ git log --author=user@wrong.email --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  | sed -e 's/user@wrong\.email/user@example.com/g' > tmp.txt $ git hash-object -t commit -w tmp.txt  
  3. Ahora que ha corregido la confirmación en la base de datos de objetos, debe indicar a git que reemplace de forma automática y transparente la confirmación incorrecta por una corregida utilizando el comando git replace :

     $ git replace   
  4. Finalmente, liste todos los reemplazos para verificar si este procedimiento tuvo éxito

     $ git replace -l 

    y verificar si se realizan reemplazos

     $ git log --author=user@wrong.email --all 

Por supuesto, puedes automatizar este procedimiento … bueno, todo excepto usar git replace que no tiene (aún) modo batch, por lo que tendrías que usar Shell Loop para eso, o reemplazar “a mano”.

¡NO PROBADO! YMMV.

Tenga en cuenta que puede encontrar algunas esquinas difíciles al usar refs/replace/ mechanism: es nuevo y aún no se ha probado muy bien .

Si las confirmaciones que desea corregir son las más recientes, y solo un par de ellas, puede usar una combinación de git reset y git stash para volver a cometerlas nuevamente después de configurar el nombre correcto y el correo electrónico.

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

 git config user.name  git config user.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 twig local ‘local_master_user_x’ que no se puede enviar a una twig remota ‘master’ debido a que el usuario no es válido.

  1. Verifica la twig remota ‘master’
  2. Seleccione los proyectos / carpetas / archivos para los cuales ‘local_master_user_x’ contiene cambios
  3. Haga clic derecho – Reemplazar con – Sucursal – ‘local_master_user_x’
  4. Confirme estos cambios nuevamente, esta vez como el usuario correcto y en la twig local ‘master’
  5. Empujar al ‘maestro’ remoto

Con la utilización de rebase interactiva, puede colocar un comando de modificación 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 dos direcciones 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 puede verla con git log -1 --format=%cn,%ce (o use show lugar de log para especificar un commit en particular).

Si bien cambiar el autor de su última confirmación es tan simple como git commit --amend --author "Author Name " , no hay una sola línea o argumento para hacer lo mismo con la información del autor.

La solución es (temporalmente o no) cambiar su información de usuario, luego modifique la confirmación, que actualizará al committer a su información actual:

 git config user.email my_other_email@example.com git commit --amend 

Hoy hemos tenido un problema en el que un carácter UTF8 en un nombre de autor estaba causando problemas en el servidor de comstackción, por lo que tuvimos que reescribir el historial para corregirlo. Los pasos tomados fueron:

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

Paso 2: ejecuta 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="me@something.com" 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: Verifique su repository en un archivo temporal, revise todas las sucursales remotas, ejecute el script que reescribirá el historial, haga un esfuerzo forzado del nuevo estado y diga a todos sus colegas que realicen un reajuste de la base para obtener los cambios.

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

Tu problema es realmente común. Consulte ” Uso de Mailmap para corregir la lista de autores en Git ”

En aras de la simplicidad, he creado una secuencia de comandos para facilitar el proceso: git-changemil

Después de poner esa secuencia de comandos en su camino, puede emitir comandos como:

  • Cambiar coincidencias de autor en la twig actual

     $ git changemil -a old@email.com -n newname -m new@email.com 
  • Cambie el autor y las coincidencias del committer en y . Pase -f a filtrar-twig para permitir la reescritura de copias de seguridad

     $ git changemil -b old@email.com -n newname -m new@email.com -- -f <branch> <branch2> 
  • Mostrar usuarios existentes en el repository

     $ git changemil --show-both 

Por cierto, después de realizar los cambios, limpie la copia de seguridad de la twig de filtro con: git-backup-clean

Si usted es el único usuario de este repository o si no le importa posiblemente cancelar el repository para otros usuarios, entonces sí. Si has implementado estos commits y existen donde otro lugar puede acceder a ellos, entonces no, a menos que no te importe romper los repositorys de otras personas. El problema es cambiar estos commits, generarás nuevos SHA que harán que sean tratados como commits diferentes. Cuando alguien más intenta obtener estos commits modificados, 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 lo he probado así que YMMV)

Quiero agregar mi ejemplo también. Quiero crear una función bash_ 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:-"you_wrong_mail@hello.world"} NEW_NAME=${2:-"your name"} NEW_EMAIL=${3:-"new_mail@hello.world"} 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 " --no-edit && git rebase --continue; done 

Press ^C # after the rebase is done (the loop will keep updating last commit)

Probar esto. It will do the same as above mentioned, but interactively.

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

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

This isn’t an answer to your question, but rather a script you can use to avoid this in the future. It utilizes global hooks available since Git version 2.9 to check your email configuration based on the directory your in:

 #!/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 "youremail@youremail.com" 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 == "youremail@youremail.com" ]] then echo ""; else echo "Email is not configured to your personal account in the Personal di$ git config user.email "youremail@youremail.com" echo "Git email configuration has now been changed to \"$(git config user$ echo "\nPlease run your command again..." echo '' exit 1; fi; fi; 

It checks your current working directory, then verifies your git is configured to the correct email. If not, it changes it automatically. See the full details here .