¿Puedo especificar varios usuarios para mí en .gitconfig?

En mi ~/.gitconfig, enumero mi dirección de correo electrónico personal [user], ya que eso es lo que quiero usar para repositorios de Github.

Pero, recientemente, también comencé a usar git para el trabajo. El repositorio git de mi empresa me permite comprometerme, pero cuando envía anuncios de nuevos conjuntos de cambios, dice que son de Anonymous porque no reconoce la dirección de correo electrónico en mi .gitconfig, al menos, esa es mi teoría.

¿Es posible especificar múltiples [user]definiciones en .gitconfig? ¿O hay alguna otra forma de anular el valor predeterminado .gitconfigpara un determinado directorio? En mi caso, reviso todo el código de trabajo ~/worksrc/, ¿hay alguna manera de especificar un .gitconfigsolo para ese directorio (y sus subdirectorios)?

Puede configurar un repositorio individual para usar una dirección de usuario / correo electrónico específica que anule la configuración global. Desde la raíz del repositorio, ejecute

git config user.name "Your Name Here"
git config user.email [email protected]

mientras que el usuario / correo electrónico predeterminado está configurado en su ~ / .gitconfig

git config --global user.name "Your Name Here"
git config --global user.email [email protected]

Desde git 2.13 , es posible resolver esto usando las inclusiones condicionales recién introducidas .

Un ejemplo:

Configuración global ~ / .gitconfig

[user]
    name = John Doe
    email = [email protected]

[includeIf "gitdir:~/work/"]
    path = ~/work/.gitconfig

Trabajo específico config ~ / work / .gitconfig

[user]
    email = [email protected]

O puede agregar la siguiente información en su .git/configarchivo local

[user]  
    name = Your Name
    email = [email protected]

Un interruptor de cuentas de github de comando

Esta solución toma la forma de un solo alias git. Una vez ejecutado, el usuario actual del proyecto se adjuntará a otra cuenta

Generar claves ssh

ssh-keygen -t rsa -C "[email protected]" -f '/Users/arnaudrinquin/.ssh/id_rsa'

[...]

ssh-keygen -t rsa -C "[email protected]" -f '/Users/arnaudrinquin/.ssh/id_rsa_pro'

Vincúlelos a sus cuentas de GitHub / Bitbucket

1. copiar clave pública predeterminada pbcopy < ~/.ssh/id_rsa.pub
2. inicie sesión en su cuenta de GitHub
3. pegue la clave en la add SSH keypágina de github
4. copiar otra clave pública pbcopy < ~/.ssh/id_rsa_pro.pub
5. repita y adapte los pasos 2 a 4 para cualquier otra cuenta

Paso 1. Cambio automático de clave ssh.

Podemos configurar sshpara enviar un uso de una clave de cifrado específica según el host. Lo bueno es que puedes tener varios alias para el mismo hostname.

Ver este ~/.ssh/configarchivo de ejemplo :

# Default GitHub
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa

# Professional github alias
Host github_pro
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_pro

configuración remota de git

Ahora puede usar estos alias en los controles remotos git cambiando [email protected]por git@github_pro.

Puede cambiar los controles remotos de sus proyectos existentes (usando algo como git remote set-url origin git@github_pro:foo/bar.git) o adaptarlos directamente al clonarlos.

git clone [email protected]:ArnaudRinquin/atom-zentabs.git

usando alias, se convierte en:

git clone git@github_pro:ArnaudRinquin/atom-zentabs.git

Paso 2. Cambiar git user.email

La configuración de Git puede ser global o por proyecto. En nuestro caso, queremos una configuración por proyecto. Es muy fácil cambiarlo:

git config user.email '[email protected]'

Si bien esto es fácil, lleva mucho tiempo para los desarrolladores que somos. Podemos escribir un alias git muy simple para eso.

Lo vamos a agregar al ~/.gitconfigarchivo.

[user]
    name = Arnaud Rinquin
    email = [email protected]

...

[alias]
    setpromail = "config user.email '[email protected]'"

Entonces, todo lo que tenemos que hacer es git setpromailcambiar nuestro correo electrónico solo para este proyecto.

Paso 3. ¿Un interruptor de comando por favor?

¿No sería bueno cambiar de una cuenta predeterminada a una específica con un solo comando sin parámetros? Esto es definitivamente posible. Este comando tendrá dos pasos:

• cambiar los controles remotos del proyecto actual a los alias elegidos
• cambiar la configuración actual de user.email del proyecto

Ya tenemos una solución de un comando para el segundo paso, pero el primero es mucho más difícil. Un comando de cambio de host remoto

Aquí viene la solución en forma de otro comando git alias para agregar a su ~/.gitconfig:

[alias]
  changeremotehost = !sh -c \"git remote -v | grep '$1.*fetch' | sed s/..fetch.// | sed s/$1/$2/ | xargs git remote set-url\"

Esto permite cambiar todos los controles remotos de un host a otro (el alias). Mira el ejemplo:

$ > git remote -v
origin  [email protected]:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin  [email protected]:ArnaudRinquin/arnaudrinquin.github.io.git (push)

$ > git changeremotehost github.com github_pro

$ > git remote -v
origin  git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin  git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (push)

Combinarlos todos

Ahora solo tenemos que combinar los dos comandos en uno, esto es bastante fácil. Vea cómo también integro la conmutación de host bitbucket.

[alias]
  changeremotehost = !sh -c \"git remote -v | grep '$1.*fetch' | sed s/..fetch.// | sed s/$1/$2/ | xargs git remote set-url\"
  setpromail = "config user.email '[email protected]'"
  gopro = !sh -c \"git changeremotehost github.com github_pro && git changeremotehost bitbucket.com bitbucket_pro && git setpromail\"

Enlace de origen - Tutorial

Después de inspirarme en la publicación del blog de Orr Sella, escribí un enlace previo al compromiso (que reside en ~/.git/templates/hooks) que establecería nombres de usuario y direcciones de correo electrónico específicos basados ​​en la información dentro de un repositorio local ./.git/config:

Debe colocar la ruta al directorio de plantillas en su ~/.gitconfig:

[init]
    templatedir = ~/.git/templates

A continuación, cada git inito git clonerecogerá ese gancho y será de aplicación a los datos de usuario durante la siguiente git commit. Si desea aplicar el gancho a repos ya existentes, simplemente ejecute un git initdentro del repositorio para reinicializarlo.

Aquí está el gancho que se me ocurrió (todavía necesita un poco de pulido, las sugerencias son bienvenidas). Guárdalo como

~/.git/templates/hooks/pre_commit

o

~/.git/templates/hooks/post-checkout

y asegúrese de que sea ejecutable: chmod +x ./post-checkout || chmod +x ./pre_commit

#!/usr/bin/env bash

# -------- USER CONFIG
# Patterns to match a repo's "remote.origin.url" - beginning portion of the hostname
git_remotes[0]="Github"
git_remotes[1]="Gitlab"

# Adjust names and e-mail addresses
local_id_0[0]="my_name_0"
local_id_0[1]="my_email_0"

local_id_1[0]="my_name_1"
local_id_1[1]="my_email_1"

local_fallback_id[0]="${local_id_0[0]}"
local_fallback_id[1]="${local_id_0[1]}"


# -------- FUNCTIONS
setIdentity()
{
    local current_id local_id

    current_id[0]="$(git config --get --local user.name)"
    current_id[1]="$(git config --get --local user.email)"

    local_id=("$@")

    if [[ "${current_id[0]}" == "${local_id[0]}" &&
          "${current_id[1]}" == "${local_id[1]}" ]]; then
        printf " Local identity is:\n"
        printf "»  User: %s\n»  Mail: %s\n\n" "${current_id[@]}"
    else
        printf "»  User: %s\n»  Mail: %s\n\n" "${local_id[@]}"
        git config --local user.name "${local_id[0]}"
        git config --local user.email "${local_id[1]}"
    fi

    return 0
}

# -------- IMPLEMENTATION
current_remote_url="$(git config --get --local remote.origin.url)"

if [[ "$current_remote_url" ]]; then

    for service in "${git_remotes[@]}"; do

        # Disable case sensitivity for regex matching
        shopt -s nocasematch

        if [[ "$current_remote_url" =~ $service ]]; then
            case "$service" in

                "${git_remotes[0]}" )
                    printf "\n»» An Intermission\n»  %s repository found." "${git_remotes[0]}"
                    setIdentity "${local_id_0[@]}"
                    exit 0
                    ;;

                "${git_remotes[1]}" )
                    printf "\n»» An Intermission\n»  %s repository found." "${git_remotes[1]}"
                    setIdentity "${local_id_1[@]}"
                    exit 0
                    ;;

                * )
                    printf "\n»  pre-commit hook: unknown error\n» Quitting.\n"
                    exit 1
                    ;;

            esac
        fi
    done
else
    printf "\n»» An Intermission\n»  No remote repository set. Using local fallback identity:\n"
    printf "»  User: %s\n»  Mail: %s\n\n" "${local_fallback_id[@]}"

    # Get the user's attention for a second
    sleep 1

    git config --local user.name "${local_fallback_id[0]}"
    git config --local user.email "${local_fallback_id[1]}"
fi

exit 0

EDITAR:

Así que reescribí el gancho como un gancho y comando en Python. Además, también es posible llamar al script como un comando Git ( git passport). También es posible definir un número arbitrario de ID dentro de un archivo de configuración ( ~/.gitpassport) que se pueden seleccionar en una solicitud. Puede encontrar el proyecto en github.com: git-passport: un comando y gancho de Git escrito en Python para administrar múltiples cuentas de Git / identidades de usuario .

Si no desea tener una dirección de correo electrónico predeterminada ( enlaces de direcciones de correo electrónico a un usuario de github ), puede configurar que desee que se le pregunte. Cómo puedes hacer eso depende de la versión de git que uses, ver más abajo.

El inconveniente (previsto) es que debe configurar su dirección de correo electrónico (y su nombre) una vez para cada repositorio. Entonces, no puedes olvidarte de hacerlo.

Versión <2.7.0

[user]
    name = Your name
    email = "(none)"

en su configuración global ~/.gitconfigcomo se indica en un comentario de Dan Aloni en la publicación del blog de Orr Sella . Al intentar hacer la primera confirmación en un repositorio, git falla con el bonito mensaje:

*** Please tell me who you are.

Run

  git config --global user.email "[email protected]"
  git config --global user.name "Your Name"

to set your account's default identity.
Omit --global to set the identity only in this repository.

fatal: unable to auto-detect email address (got '(none)')

El nombre se toma de la configuración global cuando la dirección de correo electrónico se configura localmente (el mensaje no es perfectamente preciso).

2.7.0 ≤ Versión <2.8.0

El comportamiento en las versiones <2.7.0 no fue intencionado y se solucionó con 2.7.0. Todavía puede usar un enlace previo a la confirmación como se describe en la publicación del blog de Orr Sella . Esta solución también funciona para otras versiones, pero las otras soluciones no son para esta versión.

Versión ≥ 2.8.0

Dan Aloni agregó una opción para lograr ese comportamiento (ver notas de la versión ). Úselo con:

[user]
    useConfigOnly = true

Para que funcione, no puede dar un nombre o dirección de correo electrónico en la configuración global. Luego, en la primera confirmación, aparece un mensaje de error

fatal: user.useConfigOnly set but no name given

Por lo tanto, el mensaje no es muy instructivo, pero como configura la opción explícitamente, debe saber qué hacer. A diferencia de la solución de las versiones <2.7.0, siempre debe configurar el nombre y el correo electrónico manualmente.

Con las condiciones condicionales incluidas en Git 2.13, ahora es posible tener múltiples usuarios / correos electrónicos coexistiendo en una máquina con poco trabajo.

user.gitconfigtiene mi nombre personal y correo electrónico work-user.gitconfigtiene mi nombre de trabajo y correo electrónico. Ambos archivos están en ~camino.

Entonces mi nombre personal / correo electrónico se aplica por defecto. Para c:/work/dir, se aplica mi nombre de trabajo / correo electrónico. Para c:/work/github/dir, se aplica mi nombre personal / correo electrónico. Esto funciona cuando se aplica la última configuración.

# ~/.gitconfig
[include]
    path = user.gitconfig
[includeIf "gitdir/i:c:/work/"]
    path = work-user.gitconfig
[includeIf "gitdir/i:c:/work/github/"]
    path = user.gitconfig

gitdires sensible a gitdir/imayúsculas y minúsculas.

"gitdir/i:github/"aplicaría la inclusión condicional para cualquier directorio con githuben su ruta.

Otra opción para gittrabajar con múltiples nombres / correos electrónicos es alias gity usar el -cindicador para anular la configuración global y específica del repositorio.

Por ejemplo, al definir un alias:

alias git='/usr/bin/git -c user.name="Your name" -c user.email="[email protected]"'

Para ver si funciona, simplemente escriba git config user.email:

$ git config user.email
name@example.com

En lugar de un alias, también puedes poner un gitejecutable personalizado dentro de tu $PATH.

#!/bin/sh
/usr/bin/git -c user.name="Your name" -c user.email="[email protected]" "$@"

Una ventaja de este método sobre un repositorio específico .git/configes que se aplica a cada gitrepositorio cuando el gitprograma personalizado está activo. De esta manera, puede cambiar fácilmente entre usuarios / nombres sin modificar ninguna configuración (compartida).

alias git (y secciones en configuraciones git) al rescate!

agregue un alias (desde la línea de comando):

git config --global alias.identity '! git config user.name "$(git config user.$1.name)"; git config user.email "$(git config user.$1.email)"; :'

luego, establecer, por ejemplo

git config --global user.github.name "your github username"
git config --global user.github.email [email protected]

y en un repositorio nuevo o clonado puede ejecutar este comando:

git identity github

Esta solución no es automática, pero el usuario desarmado y el correo electrónico en su mundial ~/.gitconfigy el establecimiento user.useConfigOnlyde trueforzaría git para recordarle que debe configurar manualmente en cada repo nuevo o clonado.

git config --global --unset user.name
git config --global --unset user.email
git config --global user.useConfigOnly true

Aquí están los pasos completos después de leer muchas respuestas aquí.

Cómo configurar múltiples configuraciones de claves SSH para diferentes cuentas de github

Es posible que desee comenzar a verificar sus claves guardadas actualmente

$ ssh-add -l

Si decide eliminar todas las claves almacenadas en caché antes ( opcional, tenga cuidado al respecto )

$ ssh-add -D

Luego puede crear una clave ssh pub / priv vinculada a cada correo electrónico / cuenta que desee / necesite usar

$ cd ~/.ssh
$ ssh-keygen -t rsa -C "[email protected]" <-- save it as "id_rsa_work"
$ ssh-keygen -t rsa -C "[email protected]" <-- save it as "id_rsa_pers"

Después de ejecutar estos comandos, tendrá los siguientes archivos creados

~/.ssh/id_rsa_work      
~/.ssh/id_rsa_work.pub

~/.ssh/id_rsa_pers
~/.ssh/id_rsa_pers.pub 

Asegúrese de que el agente de autenticación se esté ejecutando

$ eval `ssh-agent -s`

Agregue las claves generadas de la siguiente manera (desde la carpeta ~ / .ssh)

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Ahora puede verificar sus claves guardadas nuevamente

$ ssh-add -l

Ahora debe agregar las claves públicas generadas a las claves de acceso de su servidor github / bickbuket

Clone cada uno de los repositorios en diferentes carpetas

Vaya a la carpeta donde trabajará el usuario y ejecute esto

$ git config user.name "Working Hard"
$ git config user.email "[email protected]" 

Solo para ver qué hace esto, verifique el contenido de ".git / config"

Vaya a la carpeta donde trabajará el usuario pers y ejecute esto

$ git config user.name "Personal Account"
$ git config user.email "[email protected]" 

Solo para ver qué hace esto, verifique el contenido de ".git / config"

Después de todo esto, podrá confirmar su código personal y de trabajo simplemente cambiando entre esas dos carpetas

En caso de que esté utilizando Git Bash y necesite generar claves ssh en Windows, siga estos pasos:

https://support.automaticsync.com/hc/en-us/articles/202357115-Generating-an-SSH-Key-on-Windows

Hay una solución simple que parece funcionar bien para evitar errores.

Simplemente elimine la [user]sección de su ~/.gitconfig, lo que le impedirá realizar confirmaciones sin configurar user.namepara cada repositorio.

En su ~/.bashrc, agregue algunos alias simples para el usuario y el correo electrónico:

alias ggmail='git config user.name "My Name";git config user.email [email protected]'
alias gwork='git config user.name "My Name";git config user.email [email protected]'

Esta respuesta está parcialmente inspirada en la publicación de @Saucier, pero estaba buscando una forma automática de configurar user.nameyuser.email según el repositorio, basada en el control remoto, que fuera un poco más liviana que el paquete de pasaporte git que desarrolló . También h / t a @John para la configuración useConfigOnly. Aquí está mi solución:

.gitconfig cambios:

[github]
    name = <github username>
    email = <github email>
[gitlab]
    name = <gitlab username>
    email = <gitlab email>
[init]
    templatedir = ~/.git-templates
[user]
    useConfigOnly = true

gancho posterior al pago que debe guardarse en la siguiente ruta ~/.git-templates/hooks/post-checkout:

#!/usr/bin/env bash

# make regex matching below case insensitive
shopt -s nocasematch

# values in the services array should have a corresponding section in
# .gitconfig where the 'name' and 'email' for that service are specified
remote_url="$( git config --get --local remote.origin.url )"
services=(
    'github'
    'gitlab'
)

set_local_user_config() {
    local service="${1}"
    local config="${2}"
    local service_config="$( git config --get ${service}.${config} )"
    local local_config="$( git config --get --local user.${config} )"

    if [[ "${local_config}" != "${service_config}" ]]; then
        git config --local "user.${config}" "${service_config}"
        echo "repo 'user.${config}' has been set to '${service_config}'"
    fi
}

# if remote_url doesn't contain the any of the values in the services
# array the user name and email will remain unset and the
# user.useConfigOnly = true setting in .gitconfig will prompt for those
# credentials and prevent commits until they are defined
for s in "${services[@]}"; do
    if [[ "${remote_url}" =~ "${s}" ]]; then
        set_local_user_config "${s}" 'name'
        set_local_user_config "${s}" 'email'
        break
    fi
done

Utilizo diferentes credenciales para github y gitlab, pero esas referencias en el código anterior podrían reemplazarse o aumentarse con cualquier servicio que use. Para que el enlace posterior al pago establezca automáticamente el nombre de usuario y el correo electrónico localmente para un repositorio después de un pago, asegúrese de que el nombre del servicio aparezca en la URL remota, agréguelo a la matriz de servicios en el post-checkoutscript y cree una sección para él en su .gitconfigque contiene su nombre de usuario y correo electrónico para ese servicio.

Si ninguno de los nombres de servicio aparece en la URL remota o el repositorio no tiene un control remoto, el nombre de usuario y el correo electrónico no se establecerán localmente. En estos casos, la user.useConfigOnlyconfiguración estará en juego, lo que no le permitirá realizar confirmaciones hasta que el nombre de usuario y el correo electrónico se establezcan en el nivel de repositorio, y le solicitará al usuario que configure esa información.

GIT_AUTHOR_EMAIL + local .bashrc

.bashrc_local: no rastree este archivo, póngalo solo en su computadora de trabajo:

export GIT_AUTHOR_EMAIL='[email protected]'
export GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"

.bashrc: rastrea este archivo, hazlo igual en las computadoras del trabajo y del hogar:

F="$HOME/.bashrc_local"
if [ -r "$F" ]; then
    . "$F"
fi

Estoy usando https://github.com/technicalpickles/homesick para sincronizar mis archivos de puntos.

Si solo gitconfig aceptara variables de entorno: Expansión de variables de shell en git config

Entorno de Windows

Adicional esto se puede modificar desde Git Extensions --> Settings --> Global Settings, si lo tiene instalado en sus sistemas.

gitextensions-latest-release

Haga clic derecho en una carpeta / directorio en el entorno de Windows para acceder a esta configuración.

Actualización : Cómo cambiar / mantener múltiples configuraciones en la Versión 2.49

Tal vez es un simple truco, pero es útil. Simplemente genere 2 claves ssh como a continuación.

Generating public/private rsa key pair.
Enter file in which to save the key (/Users/GowthamSai/.ssh/id_rsa): work
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in damsn.
Your public key has been saved in damsn.pub.
The key fingerprint is:
SHA256:CrsKDJWVVek5GTCqmq8/8RnwvAo1G6UOmQFbzddcoAY [email protected]
The key's randomart image is:
+---[RSA 4096]----+
|. .oEo+=o+.      |
|.o o+o.o=        |
|o o o.o. +       |
| =.+ .  =        |
|= *+.   S.       |
|o*.++o .         |
|=.oo.+.          |
| +. +.           |
|.o=+.            |
+----[SHA256]-----+

Del mismo modo crea uno más para lo personal. Entonces, tienes 2 claves ssh, trabajo y compañía. Copie work.pub, work, personal.pub, personal en ~ / .ssh / Directory.

Luego cree un script de shell con las siguientes líneas y asígnele el nombre crev.sh (Company Reverse) con el siguiente contenido.

cp ~/.ssh/work ~/.ssh/id_rsa
cp ~/.ssh/work.pub ~/.ssh/id_rsa.pub

Del mismo modo, cree uno más llamado prev.sh (Personal Reverse) con el siguiente contenido.

cp ~/.ssh/personal ~/.ssh/id_rsa
cp ~/.ssh/personal.pub ~/.ssh/id_rsa.pub

en ~ / .bashrc agrega alias para esos scripts como a continuación

alias crev="sh ~/.ssh/crev.sh"
alias prev="sh ~/.ssh/prev.sh"
source ~/.bashrc

Siempre que quiera usar compañía, solo haga crev, y si quiere usar personal, haga prev :-p.

Agregue esas claves ssh a sus cuentas de GitHub. Asegúrese de que no haya generado id_rsa anteriormente, porque esos scripts sobrescribirán id_rsa. Si ya ha generado id_rsa, úselo para una de las cuentas. Cópielos como personales y omita la generación de claves personales.

Hice una función bash que maneja eso. Aquí está el repositorio de Github .

Para el registro:

# Look for closest .gitconfig file in parent directories
# This file will be used as main .gitconfig file.
function __recursive_gitconfig_git {
    gitconfig_file=$(__recursive_gitconfig_closest)
    if [ "$gitconfig_file" != '' ]; then
        home="$(dirname $gitconfig_file)/"
        HOME=$home /usr/bin/git "$@"
    else
        /usr/bin/git "$@"
    fi
}

# Look for closest .gitconfig file in parents directories
function __recursive_gitconfig_closest {
    slashes=${PWD//[^\/]/}
    directory="$PWD"
    for (( n=${#slashes}; n>0; --n ))
    do
        test -e "$directory/.gitconfig" && echo "$directory/.gitconfig" && return 
        directory="$directory/.."
    done
}


alias git='__recursive_gitconfig_git'

Simplemente agregue esto a su ~ / .bash_profile para cambiar entre las teclas predeterminadas para github.com

# Git SSH keys swap
alias work_git="ssh-add -D  && ssh-add -K ~/.ssh/id_rsa_work"
alias personal_git="ssh-add -D && ssh-add -K ~/.ssh/id_rsa"

También puede usarlo git commit --author "Your Name <[email protected]>"en el momento de realizar una confirmación en un repositorio donde desea comprometerse como un usuario diferente.

Algo así como la respuesta de Rob W , pero que permite una clave ssh diferente y funciona con versiones anteriores de git (que no tienen, por ejemplo, una configuración core.sshCommand).

Creé el archivo ~/bin/git_poweruser, con permiso ejecutable, y en la RUTA:

#!/bin/bash

TMPDIR=$(mktemp -d)
trap 'rm -rf "$TMPDIR"' EXIT

cat > $TMPDIR/ssh << 'EOF'
#!/bin/bash
ssh -i $HOME/.ssh/poweruserprivatekey $@
EOF

chmod +x $TMPDIR/ssh
export GIT_SSH=$TMPDIR/ssh

git -c user.name="Power User name" -c user.email="[email protected]" $@

Cada vez que quiero comprometer o empujar algo como "Usuario avanzado", lo uso en git_poweruserlugar de git. Debería funcionar en cualquier directorio, y no requiere cambios en , .gitconfigo .ssh/configal menos no en el mío.

Aunque la mayoría de las preguntas respondieron al OP, solo tuve que pasar por esto yo mismo y sin siquiera buscar en Google pude encontrar la solución más rápida y sencilla. Aquí hay pasos simples:

• copia existente .gitconfgde su otro repositorio
• pegar en su repositorio recién agregado
• cambiar valores en el .gitconfigarchivo, como nombre, correo electrónico y nombre de usuario [user] name = John email = [email protected] username = john133
• agregue el nombre de archivo a la .gitignorelista, para asegurarse de no comprometer el .gitconfigarchivo en su repositorio de trabajo