Git en Equipo: Colaboración y Resolución de Conflictos

¡Domina el trabajo colaborativo con Git! En este tutorial avanzado te guiaré paso a paso para que aprendas estrategias de equipo, resolución de conflictos y mejores prácticas para trabajar eficientemente en proyectos colaborativos.

Objetivo: Aprender técnicas avanzadas de colaboración con Git, incluyendo resolución de conflictos, code review, flujos de trabajo en equipo y automatización para entornos colaborativos.

Paso 1: Configuración para Trabajo en Equipo

Plantilla de Commit para Equipos

# Crear plantilla de commit message
git config --global commit.template ~/.gitmessage

# Contenido del archivo ~/.gitmessage:
[#ISSUE] - Tipo: Descripción breve

Descripción detallada de los cambios realizados:

- Cambio 1
- Cambio 2
- Cambio 3

Breaking changes: 
- [ ] Sí
- [X] No

Signed-off-by: Nombre <[email protected]>

Configuración de Hook de Pre-commit para Equipos

# Crear hook de pre-commit compartido
#!/bin/sh
#
# Pre-commit hook para verificación de código en equipo

# Verificar que no hay conflictos de merge
if git diff --name-only --diff-filter=U | grep -q '^'; then
    echo "❌ Hay conflictos sin resolver. Abortando commit."
    exit 1
fi

# Verificar que el mensaje de commit sigue el formato
if ! grep -q "\[#.*\] - .*:" "$1"; then
    echo "❌ El mensaje de commit no sigue el formato requerido."
    echo "Formato: [#ISSUE] - Tipo: Descripción"
    exit 1
fi

# Ejecutar tests básicos
npm test -- --passWithNoTests
if [ $? -ne 0 ]; then
    echo "❌ Tests fallaron. Abortando commit."
    exit 1
fi

echo "✅ Pre-commit checks pasados correctamente"
exit 0

Paso 2: Estrategias de Branching para Equipos

Git Flow para Múltiples Desarrolladores

# Estructura recomendada para equipos
main
└── develop
    ├── feature/autenticacion-oauth
    ├── feature/carrito-compras
    ├── release/1.2.0
    └── hotfix/payment-bug

# Comandos para coordinación
git fetch --all --prune
git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote" 2>/dev/null || true; done

Conventional Commits para Equipos

# Estructura estandarizada de commits
git commit -m "feat: añadir autenticación OAuth"
git commit -m "fix: resolver bug en checkout"
git commit -m "docs: actualizar documentación API"
git commit -m "refactor: mejorar estructura de componentes"
git commit -m "test: añadir tests para módulo de pago"

# Tipos convencionales:
# feat: Nueva característica
# fix: Corrección de bug
# docs: Cambios en documentación
# style: Cambios de formato
# refactor: Refactorización de código
# test: Añadir tests
# chore: Tareas de mantenimiento

Paso 3: Resolución Avanzada de Conflictos

Herramientas Visuales para Conflictos

# Configurar herramienta de merge preferida
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

# Configurar herramienta de diff
git config --global diff.tool vscode
git config --global difftool.vscode.cmd 'code --wait --diff $LOCAL $REMOTE'

# Usar durante conflictos:
git mergetool              # Abrir herramienta de merge
git difftool --tool=vscode # Comparar cambios visualmente

Estrategias para Conflictos Complejos

# Ver conflictos actuales
git diff --name-only --diff-filter=U

# Ver cambios por archivo
git status --porcelain | grep '^UU'

# Abortar merge y reiniciar
git merge --abort
git reset --hard HEAD

# O resolver manualmente archivo por archivo
git checkout --ours archivo.conflicto.js
git checkout --theirs archivo.conflicto.css
git add archivo.resuelto.js

Paso 4: Revision de Código con Git

Comandos para Code Review

# Ver cambios entre ramas
git diff main..feature/nueva-funcionalidad

# Ver cambios específicos de un autor
git log --author="nombre" --oneline

# Ver cambios en archivos específicos
git log --follow --stat -- archivo.js

# Crear parche para revisión
git format-patch main --stdout > cambios.patch

# Aplicar parche de revisión
git apply --check cambios.patch
git am cambios.patch

GitHub Flow para Equipos

# Flujo completo de revisión
git checkout -b feature/review-request
# Hacer cambios y commits
git push -u origin feature/review-request

# Solicitar revisión (desde GitHub/GitLab)
# Después de comentarios...
git add . 
git commit -m "address review comments"
git push

# Después de aprobación
git checkout main
git pull origin main
git merge --no-ff feature/review-request
git push origin main

Paso 5: Trabajo con Múltiples Remotos y Forks

Configuración para Open Source

# Añadir remotos para contribución
git remote add upstream https://github.com/proyecto/original.git
git remote add origin https://github.com/mi-usuario/proyecto.git

# Sincronizar con upstream
git fetch upstream
git checkout main
git merge upstream/main
git push origin main

# Crear rama para contribución
git checkout -b fix/issue-123
# Hacer cambios
git push -u origin fix/issue-123

Mantener Fork Actualizado

#!/bin/bash
# Script para mantener fork actualizado
git checkout main
git fetch upstream
git merge upstream/main
git push origin main

# Actualizar todas las ramas locales
git fetch --all --prune
for branch in $(git branch -r | grep -v '\->' | grep -v 'main'); do
    git branch --track "${branch#origin/}" "$branch" 2>/dev/null || true
done

Paso 6: Git Hooks para Colaboración

Hooks Compartidos para Equipos

# .githooks/pre-push
#!/bin/sh
# Verificar que los tests pasan antes de push
npm test
if [ $? -ne 0 ]; then
    echo "❌ Tests fallaron. No se puede hacer push."
    exit 1
fi

# Verificar que el branch está actualizado
git fetch origin
if ! git diff --name-only origin/$(git rev-parse --abbrev-ref HEAD) | grep -q '^'; then
    echo "✅ Branch actualizado con remote"
else
    echo "⚠️  Tu branch no está actualizado con remote. Considera hacer git pull."
fi

Instalar Hooks en Equipo

# Configurar directorio de hooks compartido
git config --global core.hooksPath .githooks

# O symlink a hooks locales
ln -sf ../../.githooks/pre-commit .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

Paso 7: Comandos Avanzados para Debugging en Equipo

Encontrar Commits Problemáticos

# Buscar commit que introdujo un bug
git bisect start
git bisect bad                 # Marcar commit actual como malo
git bisect good v1.0.0         # Marcar commit conocido como bueno

# Git automatically checks out intermediate commits
# Test and mark as good or bad:
git bisect good
git bisect bad

# Finalizar bisect
git bisect reset

Blame Anotado

# Ver historial de cambios por línea
git blame archivo.js

# Ver blame con más contexto
git blame -L 10,20 archivo.js

# Ver blame con información de commit
git blame -s -e archivo.js

# Ver blame con fechas
git blame --date=short archivo.js

Paso 8: Estrategias para Grandes Equipos

Worktrees para Contextos Separados

# Crear worktrees para diferentes features
git worktree add ../feature-a feature/a
git worktree add ../feature-b feature/b

# Trabajar en diferentes features simultáneamente
cd ../feature-a
# Hacer cambios y commits
cd ../proyecto-principal

# Eliminar worktree cuando termines
git worktree remove ../feature-a

Partial Clones para Repos Grandes

# Clone parcial para repositorios muy grandes
git clone --filter=blob:none --no-checkout https://github.com/gran-repo.git
cd gran-repo
git sparse-checkout init --cone
git sparse-checkout set src/app

# Actualizar cuando necesites más archivos
git sparse-checkout add src/utils

Paso 9: Automatización con Git Aliases para Equipos

Aliases Compartidos

# Añadir a .gitconfig o .gitconfig.team
[alias]
    # Alias para trabajo en equipo
    team-status = !git fetch --all --prune && git branch -vv
    review = !git log --oneline origin/main..
    undone = !git reset --soft HEAD~1
    wip = !git add -A && git commit -m \"WIP\"
    unwip = !git log -n 1 | grep -q -c \"WIP\" && git reset HEAD~1

    # Alias para resolución de conflictos
    conflicts = !git diff --name-only --diff-filter=U
    resolve = !git add $(git conflicts)

    # Alias para limpieza
    cleanup = "!git branch --merged | grep -v '\\*\\|main\\|master' | xargs -n 1 git branch -d"

Scripts de Automatización para Equipos

#!/bin/bash
# Script de sincronización para equipos
echo "🔄 Sincronizando con repositorio remoto..."
git fetch --all --prune --tags

echo "📋 Estado de ramas:"
git branch -vv

echo "🧹 Limpiando ramas fusionadas..."
git branch --merged | grep -v '\*\|main\|master' | xargs -n 1 git branch -d

echo "✅ Sincronización completada"

Paso 10: Buenas Prácticas para Equipos

Convenciones de Commits

[#123] - feat: añadir sistema de autenticación

- Implementar login con OAuth2
- Añadir manejo de tokens JWT
- Crear middleware de autenticación

Breaking changes: 
- [X] Sí - Se requiere migración de base de datos
- [ ] No

Signed-off-by: Juan Pérez <[email protected]>

Estrategia de Pull Requests

• Títulos claros: "[#123] - feat: descripción breve"
• Descripción detallada: Contexto, cambios, screenshots
• Revisores asignados: 2+ revisores por PR
• Tests requeridos: Todos los tests deben pasar
• Approvals: 2 approvals mínimo para merge

Paso 11: Resolución de Problemas Comunes en Equipo

Recuperar Commit Perdido

# Buscar en reflog
git reflog

# Recuperar commit específico
git checkout -b recovered-branch [hash-perdido]

# O forzar recreación
git fsck --lost-found

Dividir Commit Grande

# Rebase interactivo
git rebase -i HEAD~3

# Marcar commit como edit
# Luego dividir:
git reset HEAD~1
git add -p
git commit -m "Parte 1"
git commit -m "Parte 2"
git rebase --continue

Paso 12: Integración con Herramientas de Equipo

Integración con JIRA/Issues

# Script para cerrar issues automáticamente
#!/bin/bash
# .githooks/post-commit
MESSAGE=$(git log -1 --pretty=%B)
if [[ $MESSAGE =~ \[([A-Z]+-[0-9]+)\] ]]; then
    ISSUE=${BASH_REMATCH[1]}
    echo "Cerrando issue $ISSUE"
    # Lógica para cerrar issue en tu sistema de tracking
fi

Notificaciones de Equipo

# Hook para notificar canal de equipo
#!/bin/bash
# .githooks/post-receive
CHANNEL="#team-git"
MESSAGE="Nuevo push a $(git rev-parse --abbrev-ref HEAD) por $(git log -1 --pretty=format:'%an')"
curl -X POST -H 'Content-type: application/json' \
     --data "{\"text\":\"$MESSAGE\"}" \
     https://hooks.slack.com/services/TOKEN

Paso 13: Próximos Pasos para Equipos

1. Establecer convenciones de commit y branching
2. Configurar CI/CD integrado con Git
3. Implementar code ownership y review policies
4. Automatizar flujos con hooks y scripts
5. Monitorizar métricas de contribución del equipo

Paso 14: Recursos para Equipos

Recursos para aprender más:

• GitFlow cheatsheet: https://danielkummer.github.io/git-flow-cheatsheet/
• Conventional commits: https://www.conventionalcommits.org/
• Git team workflows: https://github.com/git-guides/git-team-workflow

Conclusión

¡Felicidades! Ahora dominas las técnicas avanzadas de colaboración con Git. Practica estos conceptos en proyectos de equipo y establece convenciones claras para tu grupo de trabajo.

Para más tutoriales sobre desarrollo colaborativo y herramientas, visita nuestra sección de tutoriales.

¡Con estos conocimientos ya puedes trabajar eficientemente en equipos de desarrollo con Git!

💡 Tip Importante

📝 Mejores Prácticas para Trabajo en Equipo con Git

Para colaborar efectivamente en proyectos con Git, considera estos consejos esenciales:

• Establece convenciones claras: Define formatos de commit, estrategias de branching y procesos de revisión desde el inicio.

• Usa herramientas de comunicación: Integra Git con plataformas como Slack, Discord o Microsoft Teams para notificaciones automáticas.

• Implementa code reviews: Establece procesos de revisión de código para mantener la calidad y compartir conocimiento.

• Automatiza verificaciones: Usa hooks para ejecutar tests, linting y otras validaciones automáticamente.

• Documenta procesos: Crea guías claras para flujos de trabajo, convenciones y resolución de problemas comunes.

• Fomenta la comunicación: Usa commits descriptivos y mantén conversaciones abiertas sobre cambios complejos.

• Monitorea métricas: Rastrea contribuciones, frecuencia de commits y resolución de conflictos para mejorar procesos.

• Entrena al equipo: Asegúrate de que todos los miembros dominen las herramientas y procesos establecidos.

📚 Documentación: Revisa la documentación completa de Git Flow aquí y Conventional Commits aquí

¡Estos consejos te ayudarán a crear equipos de desarrollo más eficientes y colaborativos!