Guía completa de Git y GitHub

git --version

git config --global user.name "Tu Nombre"
git config --global user.email "tu.email@ejemplo.com"

git config --global core.editor "vim"
git config --global core.editor "nano"
git config --global core.editor "code --wait"  # VS Code

git config --global init.defaultBranch main

git config --list
git config --list --show-origin  # Ver de dónde viene cada configuración
git config user.name             # Ver configuración específica

git init
git init nombre-proyecto
git init --bare  # Repositorio sin working directory (para servidores)

git clone <url>
git clone https://github.com/usuario/repositorio.git
git clone <url> <directorio-destino>

git clone --depth 1 <url>  # Clone superficial (solo último commit)
git clone -b <rama> <url>  # Clonar rama específica, o,
git clone --branch=nombre-rama <url> 

git status
git status -s              # Formato corto
git status --short         # Formato abreviado
git status -b              # Mostrar rama e información de tracking

git diff                   # Cambios no staged (no confirmados)
git diff --staged          # Cambios staged
git diff --cached          # Sinónimo de --staged
git diff HEAD              # Todos los cambios desde último commit
git diff <rama1> <rama2>   # Diferencias entre ramas
git diff <commit1> <commit2>  # Diferencias entre commits
git diff --stat            # Resumen estadístico
git diff --name-only       # Solo nombres de archivos

git add <archivo>        # Añadir archivo específico
git add .                # Añadir todos los archivos del directorio actual
git add -A               # Añadir todos los archivos del repositorio
git add *.js             # Añadir por patrón
git add -p               # Añadir interactivamente por fragmentos
git add -u               # Añadir solo archivos ya rastreados modificados

git commit -m "Mensaje del commit"
git commit -am "Mensaje"   # Add + commit (solo tracked files)
git commit                 # Abre editor para mensaje largo
git commit --amend         # Modificar último commit
git commit --amend -m "Nuevo mensaje"  # Cambiar mensaje del último commit
git commit --amend --no-edit  # Añadir cambios sin cambiar mensaje

git log
git log --oneline          # Una línea por commit
git log --graph            # Vista gráfica
git log --all              # Todas las ramas
git log --decorate         # Mostrar referencias (ramas, tags)
git log -p                 # Mostrar diferencias (patch)
git log -n 5               # Últimos 5 commits
git log --since="2 weeks"  # Commits de las últimas 2 semanas
git log --author="Edison"  # Commits de un autor
git log --grep="palabra"   # Buscar en mensajes de commit
git log -- archivo.txt     # Historial de un archivo
git log --follow archivo.txt  # Incluir renombrados

git log --pretty=format:"%h - %an, %ar : %s"
git log --pretty=format:"%h %s" --graph
git log --graph --oneline --all --decorate
git config --global alias.tree "log --graph --decorate --all --oneline"
git tree

git checkout -- <archivo>  # Método antiguo
git restore <archivo>      # Método moderno (Git 2.23+)
git restore .              # Restaurar todos los archivos

git reset HEAD <archivo>   # Método antiguo
git restore --staged <archivo>  # Método moderno
git reset HEAD             # Quitar todos

git reset --soft HEAD~1   # Mantiene cambios en staging
git reset --mixed HEAD~1  # Mantiene cambios en working directory [default]
git reset --hard HEAD~1   # CUIDADO: Elimina todo
git reset <commit>        # Volver a un commit específico

git revert <commit>        # Crea nuevo commit que deshace cambios
git revert HEAD            # Revertir último commit
git revert --no-commit HEAD~3..HEAD  # Revertir últimos 3 commits

git rm <archivo>           # Eliminar archivo
git rm --cached <archivo>  # Quitar del tracking pero mantener en disco
git rm -r directorio/      # Eliminar directorio recursivamente
git mv <origen> <destino>  # Renombrar/mover archivo

git branch <nombre-rama>   # Crear rama
git checkout -b <nombre-rama>  # Crear y cambiar
git switch -c <nombre-rama>    # Método moderno (Git 2.23+)

git branch                 # Ramas locales
git branch -a              # Todas las ramas (locales + remotas)
git branch -r              # Solo ramas remotas
git branch -v              # Con último commit de cada rama
git branch --merged        # Ramas fusionadas con la actual
git branch --no-merged     # Ramas no fusionadas

git checkout <rama>        # Método antiguo
git switch <rama>          # Método moderno (Git 2.23+)
git checkout -             # Volver a rama anterior

git branch -d <rama>       # Eliminar rama fusionada
git branch -D <rama>       # Forzar eliminación
git push origin --delete <rama>  # Eliminar rama remota

git branch -m <nuevo-nombre>     # Renombrar rama actual
git branch -m <viejo> <nuevo>    # Renombrar otra rama

git merge <rama>           # Fusionar rama en la actual
git merge --no-ff <rama>   # Forzar commit de merge
git merge --squash <rama>  # Fusionar como un solo commit
git merge --abort          # Cancelar merge en conflicto

git rebase <rama-base>     # Rebasar rama actual
git rebase main            # Rebasar sobre main
git rebase -i HEAD~3       # Rebase interactivo (últimos 3 commits)
git rebase --continue      # Continuar después de resolver conflictos
git rebase --abort         # Cancelar rebase
git rebase --skip          # Saltar commit actual

git cherry-pick <commit>   # Aplicar un commit
git cherry-pick <commit1> <commit2>   # Varios commits
git cherry-pick <commit1>..<commit2>  # Rango de commits
git cherry-pick --continue # Continuar después de conflictos
git cherry-pick --abort    # Cancelar

git remote                 # Listar remotos
git remote -v              # Con URLs
git remote show origin     # Información detallada

git remote add <nombre> <url>
git remote add origin https://github.com/usuario/repo.git

git remote rename <viejo> <nuevo>
git remote remove <nombre>
git remote set-url origin <nueva-url>

git fetch                  # Fetch de origin
git fetch origin           # Fetch de origin explícitamente
git fetch --all            # Fetch de todos los remotos
git fetch origin <rama>    # Fetch de rama específica

git pull                   # Pull de rama actual
git pull origin main       # Pull de rama específica
git pull --rebase          # Pull con rebase en lugar de merge
git pull --rebase origin main

git push                     # Push de rama actual
git push origin main         # Push a rama específica
git push -u origin main      # Push y establecer upstream
git push --all               # Push de todas las ramas
git push --tags              # Push de todos los tags
git push origin --delete <rama>  # Eliminar rama remota
git push --force             # ⚠️ Forzar push (PELIGROSO)
git push --force-with-lease  # Forzar pero más seguro

git branch -u origin/main  # Establecer upstream de rama actual
git branch --set-upstream-to=origin/main
git branch -vv             # Ver tracking branches

git stash                  # Guardar cambios
git stash save "mensaje"   # Con mensaje descriptivo
git stash -u               # Incluir archivos untracked
git stash --all            # Incluir todo (untracked + ignored)
git stash list             # Listar stashes
git stash show             # Ver cambios del último stash
git stash show -p          # Ver diff completo
git stash apply            # Aplicar último stash (lo mantiene)
git stash pop              # Aplicar y eliminar último stash
git stash apply stash@{2}  # Aplicar stash específico
git stash drop stash@{0}   # Eliminar stash específico
git stash clear            # Eliminar todos los stashes
git stash branch <rama>    # Crear rama desde stash

git tag v1.0               # Tag ligero
git tag v1.0 <commit>      # Tag en commit específico

git tag -a v1.0 -m "Versión 1.0"
git tag -a v1.0 <commit> -m "mensaje"

git tag                    # Listar tags
git tag -l "v1.8.*"        # Listar con patrón
git show v1.0              # Ver información del tag
git push origin v1.0       # Push de tag específico
git push origin --tags     # Push de todos los tags
git tag -d v1.0            # Eliminar tag local
git push origin --delete v1.0  # Eliminar tag remoto
git checkout v1.0          # Checkout a tag (detached HEAD)

git grep "texto"           # Buscar en working directory
git grep "texto" <commit>  # Buscar en commit específico
git grep -n "texto"        # Con números de línea
git grep --count "texto"   # Contar coincidencias
git grep -i "texto"        # Case insensitive

git bisect start           # Iniciar bisect
git bisect bad             # Marcar commit actual como malo
git bisect good <commit>   # Marcar commit bueno conocido
# Git checkout commits intermedios automáticamente
git bisect good            # Marcar como bueno
git bisect bad             # Marcar como malo
git bisect reset           # Terminar bisect

git blame <archivo>        # Ver autor de cada línea
git blame -L 10,20 <archivo>  # Solo líneas 10-20
git blame -e <archivo>     # Mostrar emails
git blame -w <archivo>     # Ignorar cambios de whitespace

git reflog                 # Ver reflog
git reflog show            # Igual que git reflog
git reflog --all           # Reflog de todas las referencias
git reset --hard HEAD@{2}  # Volver a estado anterior

git worktree add <path> <branch>  # Crear worktree
git worktree list          # Listar worktrees
git worktree remove <path> # Eliminar worktree
git worktree prune         # Limpiar worktrees obsoletos

git submodule add <url> <path>           # Añadir submodule
git submodule init                       # Inicializar submodules
git submodule update                     # Actualizar submodules
git submodule update --init --recursive  # Init + update recursivo
git clone --recurse-submodules <url>     # Clonar con submodules

git archive --format=zip --output=proyecto.zip HEAD
git archive --format=tar.gz --output=proyecto.tar.gz main

git bundle create repo.bundle HEAD --all
git clone repo.bundle repo-clonado
git bundle verify repo.bundle

git status                 # Ver archivos con conflictos
git diff                   # Ver conflictos
git diff --ours            # Ver nuestra versión
git diff --theirs          # Ver su versión

git mergetool                        # Abrir herramienta de merge
git mergetool --tool=vimdiff
git config --global merge.tool meld  # Configurar herramienta

git merge -X ours <rama>         # Preferir nuestra versión
git merge -X theirs <rama>       # Preferir su versión
git checkout --ours <archivo>    # Tomar nuestra versión
git checkout --theirs <archivo>  # Tomar su versión

git flow init
git flow feature start nueva-caracteristica
git flow feature finish nueva-caracteristica
git flow release start 1.0.0
git flow release finish 1.0.0
git flow hotfix start fix-critico
git flow hotfix finish fix-critico

# Al empezar el día
git pull origin main  # Siempre sincronizo primero
git status            # Muestra el estado actual del repositorio.

# Trabajo en una nueva funcionalidad
git switch -c feat/login-social   # Creo rama con convención clara

# ... desarrollo varias horas ...
git add .
git commit -m "feat: implementar login con Google y GitHub"

# Pequeña corrección rápida
git add src/components/LoginForm.tsx
git commit -m "fix: corregir validación de email en formulario"

# Al final del día o antes de push
git branch -M main # Muestra las ramas existentes.
git switch main
git pull                 # Vuelvo a sincronizar por si alguien más empujó
git switch feat/login-social
git rebase main          # Mantengo mi rama actualizada (rebase limpio)
git switch main
git merge --ff-only feat/login-social   # Fast-forward si es posible
git push -u origin main  # Envía los cambios al repositorio remoto.
git branch -d feat/login-social   # Elimino la rama ya que está integrada

# Opcional: commit squash al final (muy común en proyectos pequeños)
git merge --squash feat/login-social
git commit -m "feat: login con proveedores sociales + validaciones"
git push

# Inicio de jornada / después de stand-up
git fetch --prune          # Limpio referencias remotas obsoletas
git switch main
git pull

# Nueva tarea (ej: ticket #456 - mejorar rendimiento de dashboard)
git switch -c feature/456-dashboard-perf

# Desarrollo normal (varios commits)
git commit -m "feat(dashboard): lazy loading de gráficos pesados"
git commit -m "refactor: extraer hook useChartData"

# Antes de terminar el día
git rebase -i origin/main    # O rebase main si ya está actualizado
# Squash/reword si quiero limpiar commits antes de PR

# Subo y creo Pull Request
git push -u origin feature/456-dashboard-perf

# En GitHub/GitLab:
#   → Creo PR → añado reviewers → espero revisión
#   → Después de aprobar y pasar CI/CD:
#     Merge squash / merge commit / 
#     rebase & merge (depende de la política del equipo)

# Una vez mergeado (normalmente por el reviewer o bot)
git switch main
git pull
git fetch --prune
git branch -d feature/456-dashboard-perf   # Limpio localmente

# Opción más rápida y segura (recomendada)
git switch main
git pull
git switch -c hotfix/789-boton-pago-falla

# Arreglo rápido (1-3 commits)
git commit -m "fix: corregir validación de tarjeta en checkout"

git push -u origin hotfix/789-boton-pago-falla

# → Crear PR rápido hacia main
# → Revisión exprés (o auto-merge si es crítico)
# → Merge (preferiblemente squash o rebase)

# Después del deploy
git switch main
git pull
git tag hotfix-2025-12-30-boton-pago   # O v1.2.3-hotfix si usas semver
git push --tags

# Estoy en medio de feature/cuenta-premium
git status

# → Aparece bug urgente
git stash push -m "WIP premium checkout"

# Arreglo rápido
git switch -c hotfix/791-api-timeout
# ... fix ...
git commit -m "fix: aumentar timeout en llamada a /reports"
git push -u origin hotfix/791-api-timeout
# → PR rápido → merge

# Vuelvo a lo mío
git switch feature/cuenta-premium
git stash pop
# Continúo donde estaba...

# Node.js
node_modules/
npm-debug.log
.env

# Python
__pycache__/
*.py[cod]
venv/
.pytest_cache/

# IDE
.vscode/
.idea/
*.swp

# OS
.DS_Store
Thumbs.db

# Build
dist/
build/
*.log

git config --global core.excludesfile ~/.gitignore_global
git check-ignore -v <archivo>  # Ver por qué archivo es ignorado

git cat-file -p <hash>     # Ver contenido de objeto
git cat-file -t <hash>     # Ver tipo de objeto
git cat-file -s <hash>     # Ver tamaño de objeto
git ls-tree <tree-hash>    # Listar contenido de tree
git ls-files               # Listar archivos en index
git ls-files -s            # Con información detallada
git ls-remote <remote>     # Listar referencias remotas

git update-index --add <archivo>     # Añadir al index
git update-index --remove <archivo>  # Quitar del index
git read-tree <tree>       # Leer tree al index
git write-tree             # Crear tree desde index

git show-ref               # Mostrar todas las referencias
git update-ref refs/heads/main <commit>  # Actualizar referencia
git symbolic-ref HEAD      # Ver a qué apunta HEAD
git for-each-ref           # Iterar sobre referencias

git hash-object <archivo>     # Calcular hash de archivo
git hash-object -w <archivo>  # Escribir objeto
git rev-parse HEAD            # Convertir referencia a hash
git rev-list HEAD             # Listar commits alcanzables

#!/bin/sh
# .git/hooks/pre-commit

npm test
if [ $? -ne 0 ]; then
    echo "Tests fallaron. Commit cancelado."
    exit 1
fi

#!/bin/sh
# .git/hooks/commit-msg

commit_msg=$(cat "$1")
pattern="^(feat|fix|docs|style|refactor|test|chore): .+"

if ! echo "$commit_msg" | grep -qE "$pattern"; then
    echo "Error: El mensaje debe seguir el formato:"
    echo "(feat|fix|docs|style|refactor|test|chore): descripción"
    exit 1
fi

# Configurar aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual 'log --oneline --graph --all --decorate'
git config --global alias.amend 'commit --amend --no-edit'

# Usar aliases
git co main
git visual

git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset \
-%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
git config --global alias.undo 'reset HEAD~1 --mixed'
git config --global alias.contributors 'shortlog -sn'

git reset --hard HEAD
git clean -fd  # Eliminar archivos untracked

git reflog  # Encontrar hash del commit
git checkout <hash>
git branch recovery <hash>  # Crear rama desde commit

git commit --amend  # Modificar mensaje o añadir archivos

git checkout rama-correcta
git cherry-pick <commit>
git checkout rama-incorrecta
git reset --hard HEAD~1  # Eliminar de rama incorrecta

git reset HEAD~1  # Deshacer commit pero mantener cambios
git add <archivo1>
git commit -m "Primera parte"
git add <archivo2>
git commit -m "Segunda parte"

git remote add upstream <url-original>
git fetch upstream
git checkout main
git merge upstream/main
git push origin main

git branch temp-branch  # Crear rama desde HEAD actual
git checkout main
git merge temp-branch

git remote prune origin  # Eliminar referencias remotas obsoletas
git fetch --prune        # Fetch y prune simultáneamente

git gc               # Garbage collection
git gc --aggressive  # Más agresivo
git prune            # Eliminar objetos inalcanzables

git rev-list --objects --all \
  | git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' \
  | sed -n 's/^blob //p' \
  | sort --numeric-sort --key=2 \
  | tail -n 10

git filter-branch --tree-filter 'rm -f archivo-sensible' HEAD
# O usar git-filter-repo (más rápido)
git filter-repo --path archivo-sensible --invert-paths

HEAD                  # Commit actual
HEAD^                 # Padre de HEAD (HEAD~1)
HEAD^^                # Abuelo de HEAD (HEAD~2)
HEAD~3                # 3 commits antes de HEAD
main^2                # Segundo padre de main (en merge)
<branch>@{yesterday}  # Posición ayer
HEAD@{5}              # 5 movimientos atrás en reflog

<commit1>..<commit2>   # Commits alcanzables desde commit2 pero no desde commit1
<commit1>...<commit2>  # Commits alcanzables desde cualquiera pero no desde ambos
<branch>^@             # Todos los padres de branch
<commit>^!             # El commit pero no sus padres

GIT_AUTHOR_NAME        # Nombre del autor
GIT_AUTHOR_EMAIL       # Email del autor
GIT_COMMITTER_NAME     # Nombre del committer
GIT_COMMITTER_EMAIL    # Email del committer
GIT_EDITOR             # Editor predeterminado
GIT_PAGER              # Pager para output
GIT_TRACE              # Activar tracing

# Colorear output
git config --global color.ui auto

# Guardar credenciales
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'

# Autocorrección de comandos
git config --global help.autocorrect 10

# Rebase por defecto al hacer pull
git config --global pull.rebase true

# Prune automático
git config --global fetch.prune true

# Diff mejorado
git config --global diff.algorithm histogram

# Rerere (reuse recorded resolution)
git config --global rerere.enabled true

# Deshacer TODO y volver limpio
git reset --hard HEAD
git clean -fd

# Recuperar trabajo después de reset --hard
git reflog
git reset --hard <hash>

# Salir de cualquier operación en progreso
git merge --abort
git rebase --abort
git cherry-pick --abort

# Verificar integridad del repositorio
git fsck --full

# Reparar repositorio corrupto
git fsck --full --no-dangling
git gc --aggressive --prune=now

alias g='git'
alias gs='git status'
alias ga='git add'
alias gc='git commit'
alias gp='git push'
alias gl='git pull'
alias gd='git diff'
alias gco='git checkout'
alias gb='git branch'
alias glg='git log --graph --oneline --all --decorate'