git-commit-push

name	Git-Commit-Push
description	Skill para commits, pushes e sync total (local = remote = VPS Docker). Analisa mudanças, gera mensagens descritivas, valida código, executa push e verifica sincronização end-to-end dos 3 ambientes. Acionado por "faça um git push", "commite tudo" ou "sync total". Visão full-stack senior dev.

🚀 GIT COMMIT & PUSH PROTOCOL

🎯 Objetivo

Automatizar commits e pushes com mensagens descritivas, validações de código e boas práticas de versionamento.

---

⚡ ATIVAÇÃO AUTOMÁTICA

Comandos que Acionam a Skill

Termos Diretos (SEMPRE usar skill):

• git push
• git commit
• push
• commit
• git e push ← IMPORTANTE: variação comum

Frases em Português:

• "faça um git push"
• "faça o push"
• "faz um push"
• "faça git e push"
• "git e push"
• "commite tudo"
• "commit e push"
• "suba as mudanças"
• "subir mudanças"
• "envie para o github"
• "envia pro github"
• "git push das alterações"
• "commit das mudanças"
• "salva no git"
• "salvar no git"
• "versiona isso"
• "versionar"
• "commitar"
• "pushar"

Sync Total (verificação end-to-end):

• "sync total"
• "full sync"
• "sincronizar tudo"
• "sincroniza tudo"
• "sync ambientes"
• "verifica sync"
• "local = remoto = docker"
• "tá tudo sincronizado?"
• "verifica se tá atualizado"
• "sync all environments"

Variações Curtas:

• "push isso"
• "commita"
• "manda pro git"
• "atualiza o repo"
• "atualizar repositório"
• "sobe isso"
• "sobe pro git"
• "joga no git"
• "puxa e empurra" (pull + push)

Após Implementações:

• "pronto, push"
• "feito, commit"
• "terminei, sobe"
• "ok, git push"
• "antes... git e push"
• "antes, push"
• "só falta o push"

Variações Implícitas (contexto de finalização):

• "agora commita"
• "pode commitar"
• "manda ver no git"
• "finaliza no github"
• "fecha com push"

Regex de Detecção:

/^(antes\s*[\.,]?\s*)?(git\s*(e\s*)?)?((push|commit|commita|commitar|pushar|suba|subir|envie?|manda|versiona|sobe))/i
/(push|commit|github|repo|git)\s*(isso|tudo|mudanças|alterações)?$/i
/(só\s*falta|pode|agora|fecha\s*com)\s*(o\s*)?(push|commit)/i
/(sync\s*(total|tudo|ambientes|all)|full\s*sync|sincroniza(r)?\s*tudo|verifica(r)?\s*sync)/i
/(local\s*=\s*remoto|tá\s*tudo\s*sincronizado|tudo\s*atualizado)/i

Detecção de Flags:

/--sync\b/i          → Ativa PHASE 5.6 completa (sync verification após push)
/--verify-only\b/i   → Pula commit/push, executa APENAS PHASE 5.6 (check estado dos 3 ambientes)

Frases que implicam --verify-only automaticamente:

• "tá tudo sincronizado?", "verifica sync", "verifica se tá atualizado"
• Qualquer frase de sync SEM mudanças pendentes no git

Quando Usar

• Após implementar funcionalidade completa
• Após correções de bugs
• Após refatorações
• Quando solicitado explicitamente

---

📋 PROTOCOLO DE EXECUÇÃO

FASE 1: ANÁLISE DE MUDANÇAS

1.1 Verificar Status do Git

# Ver branch atual
bash git branch --show-current

# Ver mudanças
bash git status --short

# Ver diff detalhado
bash git diff --stat

# Ver arquivos staged (se houver)
bash git diff --cached --stat

1.2 Identificar Tipo de Mudança

# Analisar arquivos modificados
bash git diff --name-only

# Categorizar mudanças:
# - controllers/ → feat/fix backend
# - models/ → feat/fix database
# - routes/ → feat/fix routing
# - public/js/ → feat/fix frontend
# - public/css/ → style
# - *.md → docs
# - package.json → deps

1.3 Mapear Escopo da Mudança

• Backend: Controllers, Models, Routes, Services
• Frontend: JS modules, HTML, CSS
• Config: package.json, .env.example, constants
• Docs: README, CHANGELOG, markdown files
• Infra: Deployment configs, Docker, scripts

---

FASE 2: VALIDAÇÕES PRÉ-COMMIT

2.1 Validação de Código

JavaScript/Node.js:

# Syntax check em arquivos modificados
bash for file in $(git diff --name-only --diff-filter=AM | grep "\.js$"); do node --check "$file" 2>&1 || echo "❌ Erro em $file"; done

# Verificar console.log esquecidos
bash git diff | grep -n "console\.log\|debugger" && echo "⚠️ Debug code detectado"

# Verificar TODO/FIXME
bash git diff | grep -n "TODO\|FIXME\|XXX" && echo "📝 Marcadores pendentes"

Multi-Tenant Validation:

# Verificar queries sem liga_id
bash git diff | grep -A 5 "\.find\|\.findOne\|\.updateMany" | grep -v "liga_id" && echo "⚠️ Query sem liga_id detectada"

Security Checks:

# Verificar rotas desprotegidas
bash git diff routes/ | grep "router\.\(post\|put\|delete\)" | grep -v "verificar" && echo "⚠️ Rota sem middleware"

# Verificar secrets expostos
bash git diff | grep -iE "password|secret|key|token" | grep -v "\.env" && echo "🔒 Possível secret exposto"

2.2 Validação de Qualidade

Code Quality:

# Verificar arquivos > 500 linhas
bash for file in $(git diff --name-only --diff-filter=AM | grep "\.js$"); do lines=$(wc -l < "$file" 2>/dev/null); [ "$lines" -gt 500 ] && echo "📏 $file muito grande ($lines linhas)"; done

# Verificar funções muito complexas
bash git diff | grep -c "function\|=>" | awk '{if($1 > 20) print "⚠️ Muitas funções em um diff"}'

2.3 Decisão: Continuar ou Abortar

• ❌ Syntax errors → ABORTAR, corrigir primeiro
• ⚠️ Debug code → AVISAR usuário, continuar se confirmado
• ⚠️ Security issues → AVISAR, aguardar confirmação
• ✅ Tudo OK → Continuar

---

FASE 3: GERAÇÃO DE MENSAGEM DE COMMIT

3.1 Formato Conventional Commits

<tipo>(<escopo>): <descrição curta>

<corpo detalhado (opcional)>

<footer (opcional)>

3.2 Tipos Padronizados

• feat: Nova funcionalidade
• fix: Correção de bug
• refactor: Refatoração sem mudança de comportamento
• perf: Melhoria de performance
• style: Formatação, espaçamento (não CSS)
• docs: Apenas documentação
• test: Adicionar/corrigir testes
• build: Mudanças no build/deploy
• ci: Mudanças em CI/CD
• chore: Manutenção geral

3.3 Escopos do Projeto

• extrato: Módulo de extratos financeiros
• acertos: Sistema de acertos financeiros
• rodadas: Gerenciamento de rodadas
• mata-mata: Torneio mata-mata
• pontos-corridos: Campeonato por pontos
• artilheiro: Sistema de artilheiros/campeões
• fluxo: Fluxo financeiro
• melhor-mes: Melhor jogador do mês
• export: Funcionalidades de exportação
• pwa: Progressive Web App
• auth: Autenticação
• api: Integrações API
• db: Database/models
• ui: Interface geral

3.4 Algoritmo de Geração de Mensagem

Analisar arquivos modificados:

const mudancas = {
  controllers: arquivos.filter(f => f.includes('controllers/')),
  models: arquivos.filter(f => f.includes('models/')),
  frontend: arquivos.filter(f => f.includes('public/js/')),
  styles: arquivos.filter(f => f.includes('public/css/')),
  routes: arquivos.filter(f => f.includes('routes/')),
  docs: arquivos.filter(f => f.endsWith('.md'))
};

// Determinar tipo principal
let tipo = 'chore';
if (mudancas.controllers.length > 0 || mudancas.models.length > 0) {
  tipo = 'feat'; // ou 'fix' se contiver "fix", "bug", "erro"
}
if (mudancas.styles.length > 0 && mudancas.frontend.length === 0) {
  tipo = 'style';
}
if (mudancas.docs.length > 0 && Object.values(mudancas).flat().length === mudancas.docs.length) {
  tipo = 'docs';
}

// Determinar escopo (pasta principal modificada)
const escopo = identificarEscopoPrincipal(arquivos);

// Gerar descrição baseada em diffs
const descricao = gerarDescricaoInteligente(git.diff);

3.5 Exemplos de Mensagens Geradas

Exemplo 1: Nova feature

# Arquivos: controllers/extratoController.js, public/js/extrato/core.js
# Diff: +calcularSaldoAcertos(), +saldoAcertos

Mensagem gerada:
feat(extrato): adiciona cálculo de saldo de acertos

- Implementa função calcularSaldoAcertos() no controller
- Integra saldo de acertos no extrato do participante
- Atualiza frontend para exibir breakdown de saldos

Exemplo 2: Bug fix

# Arquivos: controllers/acertosController.js
# Diff: -bug no cálculo, +correção

Mensagem gerada:
fix(acertos): corrige cálculo de acertos com múltiplas parcelas

- Resolve erro ao calcular acertos com mais de 3 parcelas
- Adiciona validação para valores negativos

Exemplo 3: Refatoração

# Arquivos: public/js/extrato/core.js, public/js/extrato/ui.js
# Diff: reorganização de funções

Mensagem gerada:
refactor(extrato): separa lógica de apresentação da UI

- Move funções de cálculo para core.js
- Mantém apenas renderização em ui.js
- Melhora manutenibilidade do código

Exemplo 4: Múltiplos módulos

# Arquivos: controllers/mataMataController.js, controllers/acertosController.js
# Diff: mudanças em 2 módulos

Mensagem gerada:
feat(torneio): integra acertos financeiros no mata-mata

- Adiciona cálculo de acertos no ranking do mata-mata
- Sincroniza saldos entre módulos
- Atualiza UI para exibir pendências financeiras

---

FASE 4: EXECUÇÃO DE COMANDOS GIT

4.1 Staging Inteligente

Estratégia 1: Stage por categoria

# Backend primeiro
bash git add controllers/ models/ routes/ services/ 2>/dev/null

# Frontend depois
bash git add public/js/ public/css/ public/participante/ 2>/dev/null

# Config e docs
bash git add package.json *.md config/ 2>/dev/null

# Outros arquivos
bash git add . 2>/dev/null

Estratégia 2: Stage tudo de uma vez (padrão)

bash git add .

4.2 Commit com Mensagem Gerada

# Executar commit
bash git commit -m "[mensagem gerada]"

# Verificar se commit foi bem-sucedido
bash git log -1 --oneline

4.3 Verificações Pré-Push

# Ver branch atual
bash git branch --show-current

# Ver remote configurado
bash git remote -v

# Ver commits a serem enviados
bash git log origin/$(git branch --show-current)..HEAD --oneline

# Verificar se há divergências
bash git fetch origin
bash git status | grep "behind\|diverged"

4.4 Tratamento de Divergências

Cenário 1: Local ahead, remote não alterado

# Push direto
bash git push origin $(git branch --show-current)

Cenário 2: Remote alterado (behind)

# Pull com rebase
bash git pull --rebase origin $(git branch --show-current)

# Resolver conflitos se houver
bash git status | grep "both modified" && echo "⚠️ Conflitos detectados"

# Push após resolver
bash git push origin $(git branch --show-current)

Cenário 3: Divergência crítica

# Abortar e avisar usuário
bash git merge --abort 2>/dev/null
bash git rebase --abort 2>/dev/null

echo "🚫 PUSH ABORTADO: Divergência detectada"
echo "Ações necessárias:"
echo "1. git fetch origin"
echo "2. git rebase origin/main (ou merge)"
echo "3. Resolver conflitos"
echo "4. Tentar push novamente"

---

FASE 5: EXECUÇÃO DO PUSH

5.1 Push Padrão

# Push para branch atual
bash git push origin $(git branch --show-current)

# Verificar sucesso
bash echo $? | grep "0" && echo "✅ Push realizado com sucesso" || echo "❌ Push falhou"

5.2 Push com Tags (se aplicável)

# Se houver tags locais não enviadas
bash git push origin --tags

5.3 Confirmação Final

# Ver último commit no remote
bash git log origin/$(git branch --show-current) -1 --oneline

# Ver status limpo
bash git status

5.4 MERGE AUTOMÁTICO PARA MAIN

Contexto: O ambiente Claude Code web cria feature branches automaticamente (claude/<task>-<hash>). A VPS roda main. Sem merge, as mudanças nunca refletem em produção.

REGRA: Após push em feature branch, SEMPRE fazer merge para main. Conflitos são tarefa a resolver, NÃO motivo para abortar.

5.4.1 Detectar se precisa merge:

BRANCH=$(git branch --show-current)
# Se já está em main, pular essa fase
if [[ "$BRANCH" == "main" || "$BRANCH" == "master" ]]; then
    echo "Já em main — skip merge"
else
    echo "Feature branch detectada: $BRANCH → merge automático para main"
fi

5.4.2 Merge para main (se feature branch):

# Salvar branch atual
FEATURE_BRANCH=$(git branch --show-current)

# Checkout main e atualizar
git checkout main
git pull origin main --no-rebase --no-edit

# Tentar merge
git merge $FEATURE_BRANCH --no-edit

5.4.3 Resolver conflitos (se houver):

Se o merge falhar com conflitos:

1. Listar arquivos conflitantes: git diff --name-only --diff-filter=U
2. Para cada arquivo: ler conteúdo com marcadores <<<<<<<, resolver mantendo as mudanças da feature branch (HEAD/ours)
3. git add dos arquivos resolvidos
4. git commit --no-edit para completar o merge
5. Se resolução falhar após 2 tentativas → git merge --abort, avisar usuário, e voltar para feature branch

IMPORTANTE: Conflitos são uma tarefa a resolver, NÃO um motivo para abortar o fluxo.

5.4.4 Push main e voltar:

# Push main atualizada
git push origin main

# Voltar para feature branch
git checkout $FEATURE_BRANCH
echo "✅ main atualizada e pushada com sucesso"

5.4.5 Fallback (merge falhou completamente):

# Abortar merge e voltar para feature branch
git merge --abort
git checkout $FEATURE_BRANCH
echo "⚠️ Merge automático falhou — resolução manual necessária"
echo "Execute: git checkout main && git merge $FEATURE_BRANCH"

---

5.5 Verificar Deploy via GitHub Actions

Este projeto usa Docker + GitHub Actions — não PM2. Push para main dispara deploy automático:

push main → GitHub Actions (main.yml) → SSH VPS → docker compose build scm-prod → docker compose up -d

Após o push, informar o usuário:

✅ Push realizado. Deploy automático iniciado via GitHub Actions.
Verifique o progresso em: GitHub → aba Actions → workflow mais recente

Regra de decisão:

Situação	Ação
Push para main	Deploy automático — só verificar aba Actions
Push para develop	Deploy staging automático (deploy-staging.yml)
Tag v*	Deploy production alternativo (deploy-production.yml)
Feature branch	Sem deploy — aguardar merge para main

O que verificar na aba Actions:

• Status ✅ success = deploy concluído na VPS
• Status ❌ failure = reportar ao usuário com link do log
• Após deploy bem-sucedido: sugerir Ctrl+Shift+R no browser para limpar cache do frontend

Não tente executar pm2 ou docker manualmente — o pipeline cuida de tudo.

---

5.6 VERIFICAÇÃO DE SYNC TOTAL (Local = Remote = VPS Docker)

Quando executar:

• Flag --sync presente → executar automaticamente após push/merge
• Flag --verify-only presente → executar SEM commit/push (apenas verificação)
• Frases de sync detectadas (ex: "sync total", "tá sincronizado?") → inferir flag adequado
• Sem flag e sem frase de sync → PULAR esta fase (comportamento legado)

IMPORTANTE: Esta fase fecha o loop que antes terminava em 5.5. Garante que os 3 ambientes estão de fato alinhados no mesmo commit.

5.6.1 Verificar paridade LOCAL ↔ REMOTE

# Atualizar referências remotas
git fetch origin main

# Comparar commits
LOCAL_HEAD=$(git rev-parse HEAD)
REMOTE_HEAD=$(git rev-parse origin/main)

if [[ "$LOCAL_HEAD" == "$REMOTE_HEAD" ]]; then
    echo "✅ LOCAL = REMOTE ($LOCAL_HEAD)"
else
    echo "❌ DIVERGÊNCIA: Local ($LOCAL_HEAD) ≠ Remote ($REMOTE_HEAD)"
    # Verificar quem está à frente
    git log --oneline origin/main..HEAD  # commits locais não pushados
    git log --oneline HEAD..origin/main  # commits remotos não puxados
fi

5.6.2 Aguardar conclusão do GitHub Actions

Após push para main, o deploy é disparado automaticamente. Aguardar conclusão:

ESTRATÉGIA:
1. Anotar timestamp do push
2. Consultar GitHub MCP (list_commits) para confirmar que o commit chegou
3. Aguardar até 3 minutos (builds típicos: 1-2min)
   - Poll a cada 20s via GitHub MCP (verificar status do workflow run)
   - Se Actions reportar ❌ failure → ABORTAR com link para o run
   - Se Actions reportar ✅ success → Continuar para 5.6.3
4. Timeout (3min) → Reportar PARTIAL SYNC (Actions ainda em andamento)

Consulta de status via GitHub MCP:

Usar mcp__github__list_commits para verificar se o commit está em main
Verificar aba Actions manualmente se MCP não tiver tool de workflow runs

5.6.3 Health Check VPS Docker

Após Actions concluir com sucesso, verificar se o container está rodando o código novo:

# Aguardar startup do container (Express.js leva ~5-10s)
sleep 10

# Health check via endpoint de versão
HEALTH_RESPONSE=$(curl -s --max-time 10 https://supercartolamanager.com.br/api/app/check-version)

# Extrair dados relevantes
# Response contém: version, serverBoot, serverUptimeSec, timestamp

Validações:

1. Resposta HTTP 200? → Container está respondendo
2. serverUptimeSec < 120? → Container reiniciou recentemente (pós-deploy)
3. serverBoot posterior ao timestamp do push? → Código novo está ativo
4. Endpoint responde em < 5s? → Container saudável (não está em startup lento)

Retry em caso de falha:

- Tentativa 1: imediata
- Tentativa 2: após 5s
- Tentativa 3: após 10s
- Se 3 falhas → Reportar OUT OF SYNC (container pode não ter subido)

Verificação completa (opcional, com --sync):

# Status completo do sistema
SYSTEM_STATUS=$(curl -s --max-time 10 https://supercartolamanager.com.br/api/app/system-status)

# Verifica: mercado, cache, versão, uptime
# Detecta anomalias pós-deploy (cache stale, erros de conexão)

5.6.4 Relatório de Sync

Exibir tabela consolidada ao final:

## 🔄 SYNC STATUS REPORT

| Ambiente     | Commit/Versão           | Status     |
|-------------|-------------------------|------------|
| Local        | abc1234 (main)          | ✅ OK      |
| Remote       | abc1234 (origin/main)   | ✅ OK      |
| VPS Docker   | v05.04.26.1430 (uptime: 15s) | ✅ Sync |

**Status Geral: ✅ FULL SYNC**
Todos os ambientes estão sincronizados no mesmo commit.

Estados possíveis:

Status	Significado	Ação Recomendada
✅ FULL SYNC	Local = Remote = Docker, container saudável	Nenhuma — tudo OK
⚠️ PARTIAL SYNC	Local = Remote, mas Docker ainda atualizando	Aguardar Actions concluir, re-verificar em 2min
❌ OUT OF SYNC	Divergência detectada entre ambientes	Investigar: Actions falhou? Container não subiu? Conflito de merge?
🔴 VPS UNREACHABLE	Endpoint não responde	Verificar: container down? Rede? DNS? Usar restart-server skill

Template de output para --verify-only:

**🔄 ENVIRONMENT SYNC CHECK**

| Ambiente     | Commit         | Versão          | Uptime   | Status |
|-------------|----------------|-----------------|----------|--------|
| Local        | abc1234        | —               | —        | ✅     |
| Remote       | abc1234        | —               | —        | ✅     |
| VPS Docker   | —              | v05.04.26.1430  | 2h 15m   | ✅     |

**Resultado: ✅ FULL SYNC** — Nenhuma ação necessária.

---

FASE 6: LEMBRETE DE CUSTO DA SESSÃO

Limitação: /usage é um slash command interno do Claude Code. Não pode ser executado via bash nem capturado programaticamente. Qualquer tentativa de bash claude usage falha silenciosamente.

6.1 O que fazer

Ao final do push, incluir lembrete para o usuário:

Para ver o custo desta sessão, execute /usage no Claude Code.

6.2 Regra

• NÃO tentar executar claude usage via bash (não funciona)
• NÃO simular ou inventar valores de custo
• Apenas lembrar o usuário que /usage existe como comando interativo

---

📊 OUTPUT FINAL

Template de Resposta

**GIT PUSH EXECUTADO**

**Commit:** [hash] - [mensagem]
**Arquivos:** [quantidade] modificados
**Branch:** [nome da branch] → origin/[branch]
**Deploy:** 🚀 GitHub Actions iniciado (push para main) | ⏭️ Sem deploy (feature branch)

**Resumo:**
- [módulo 1]: [descrição]
- [módulo 2]: [descrição]

Para ver custo da sessão: /usage

---

🔧 CONFIGURAÇÕES AVANÇADAS

Commit Hooks (Automatizado)

# Criar pre-commit hook (opcional)
bash cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
# Syntax check antes de commitar
for file in $(git diff --cached --name-only --diff-filter=AM | grep "\.js$"); do
  node --check "$file" || exit 1
done
EOF

bash chmod +x .git/hooks/pre-commit

Aliases Úteis

# Criar aliases git úteis
bash git config alias.last 'log -1 HEAD'
bash git config alias.unstage 'reset HEAD --'
bash git config alias.visual 'log --oneline --graph --decorate'

---

⚙️ ESTRATÉGIAS POR CONTEXTO

Contexto 1: Desenvolvimento Solo (padrão)

# Push direto para main
bash git add .
bash git commit -m "[mensagem]"
bash git push origin main

Contexto 2: Feature Branches

# Verificar se está em feature branch
branch=$(git branch --show-current)
if [[ $branch != "main" && $branch != "master" ]]; then
  # Push para feature branch
  bash git push origin $branch
  echo "💡 Branch de feature: $branch"
  echo "Para merge: git checkout main && git merge $branch"
fi

Contexto 3: Hotfix Crítico

# Se mensagem contém "hotfix" ou "urgent"
echo "🚨 HOTFIX DETECTADO"
bash git add .
bash git commit -m "hotfix: [descrição]"
bash git push origin main
bash git tag -a "hotfix-$(date +%Y%m%d-%H%M)" -m "Hotfix crítico"
bash git push origin --tags

---

🚫 ANTI-PATTERNS (NUNCA FAZER)

❌ Commit sem Análise

# ERRADO:
bash git add . && git commit -m "updates" && git push

# CERTO:
# 1. Analisar mudanças
# 2. Validar código
# 3. Gerar mensagem descritiva
# 4. Executar push

❌ Mensagens Genéricas

# ERRADO:
git commit -m "fix"
git commit -m "updates"
git commit -m "changes"

# CERTO:
git commit -m "fix(extrato): corrige cálculo de saldo negativo"
git commit -m "feat(pwa): adiciona botão de instalação"

❌ Push sem Validação

# ERRADO:
git push (sem verificar syntax, conflitos, etc)

# CERTO:
# 1. Syntax check
# 2. Verificar divergências
# 3. Pull se necessário
# 4. Push

❌ Commit de Debug Code

# ERRADO: Commitar com console.log
console.log("DEBUG: saldo =", saldo);

# CERTO: Remover debug antes de commitar
bash git diff | grep "console\.log" && echo "⚠️ Remova debug code"

---

✅ CHECKLIST COMPLETO

Pré-Commit

• Syntax check em todos arquivos .js
• Sem console.log ou debugger
• Queries com liga_id validadas
• Rotas protegidas com middleware
• Sem secrets expostos
• Arquivos > 500 linhas revisados

Commit

• Mensagem segue Conventional Commits
• Tipo correto (feat/fix/refactor/etc)
• Escopo identificado
• Descrição clara e concisa
• Corpo detalhado (se necessário)

Push

• Branch verificado
• Remote correto
• Sem divergências ou conflitos
• Push bem-sucedido
• Se feature branch → merge automático para main
• main pushada com sucesso
• Status limpo (working tree clean)

Deploy (Pós-Push para main)

• Informar usuário que GitHub Actions foi disparado
• Indicar aba Actions para acompanhar progresso
• Se Actions falhar → reportar com link do log
• Sugerir Ctrl+Shift+R após deploy bem-sucedido

Sync Verification (--sync ou --verify-only)

• Local HEAD == origin/main HEAD
• GitHub Actions concluiu com sucesso
• VPS Docker respondendo (HTTP 200 em /api/app/check-version)
• serverUptimeSec < 120 (container reiniciou pós-deploy)
• serverBoot posterior ao timestamp do push
• Relatório FULL SYNC / PARTIAL / OUT OF SYNC exibido

Custo (Pós-Push)

• Executar /usage para capturar métricas
• Exibir tokens input/output
• Exibir custo total da sessão
• Exibir duração da sessão

---

🎯 FLUXO VISUAL

📝 SOLICITAÇÃO
   "faça um git push"
          ↓
🔍 FASE 1: ANÁLISE
   git status, git diff
          ↓
✅ FASE 2: VALIDAÇÕES
   syntax, multi-tenant, security
          ↓
   ❌ Falhou? → ABORTAR + avisar usuário
   ✅ Passou? → Continuar
          ↓
💬 FASE 3: MENSAGEM
   Gerar commit message descritiva
          ↓
📦 FASE 4: STAGING + COMMIT
   git add → git commit -m "[mensagem]"
          ↓
🔄 FASE 5: PRÉ-PUSH
   Verificar divergências
          ↓
   🔀 Divergência? → Pull/Rebase → Resolver
   ✅ Limpo? → Continuar
          ↓
🚀 FASE 5: PUSH
   git push origin [branch]
          ↓
🔀 FASE 5.4: MERGE MAIN
   branch != main? → checkout main → merge → push → voltar
          ↓
   conflitos? → resolver como tarefa → continuar
          ↓
🐳 FASE 5.5: DEPLOY STATUS
   push main? → GitHub Actions disparado → verificar aba Actions
   feature branch? → skip (sem deploy automático)
          ↓
🔄 FASE 5.6: SYNC VERIFICATION (--sync ou --verify-only)
   5.6.1 Local HEAD == Remote HEAD?
   5.6.2 GitHub Actions concluiu? (poll até 3min)
   5.6.3 VPS Docker respondendo? (curl /api/app/check-version)
   5.6.4 Relatório: FULL SYNC / PARTIAL / OUT OF SYNC
          ↓
💰 FASE 6: USAGE REPORT
   /usage → capturar métricas da sessão
          ↓
✅ CONCLUSÃO
   Confirmar sucesso + resumo + sync status + custo

---

🎓 CASOS DE USO

Caso 1: Push Simples

USUÁRIO: "faça um git push"

SKILL EXECUTA:
1. git status → 3 arquivos modificados
2. Validações → ✅ Tudo OK
3. Mensagem → "feat(extrato): adiciona exportação PDF"
4. git add .
5. git commit -m "[mensagem]"
6. git push origin main
7. /usage → captura custo
8. Responde: ✅ Push realizado (commit a3f2b91) + 💰 Custo: $0.32

Caso 2: Múltiplas Mudanças

USUÁRIO: "commite tudo"

SKILL EXECUTA:
1. git status → 12 arquivos em 3 módulos
2. Identifica: backend (extrato) + frontend (mata-mata)
3. Mensagem → "feat: integra acertos em extrato e mata-mata"
4. Adiciona bullets detalhando cada módulo
5. Executa commit + push
6. /usage → captura custo
7. Responde: ✅ Push com 12 arquivos + 💰 Custo: $1.15

Caso 3: Hotfix Urgente

USUÁRIO: "git push urgente do fix"

SKILL EXECUTA:
1. Detecta palavra "urgente"
2. Prioriza validação de security
3. Mensagem → "hotfix: corrige vazamento de dados multi-tenant"
4. Commit + push
5. Cria tag hotfix-YYYYMMDD-HHMM
6. /usage → captura custo
7. Responde: 🚨 Hotfix enviado + tag criada + 💰 Custo: $0.18

Caso 4: Conflitos Detectados

USUÁRIO: "faça um push"

SKILL EXECUTA:
1. git fetch → detecta divergência
2. git pull --rebase → conflitos em extrato.js
3. PARA e responde:
   "🚫 Push abortado: conflitos detectados em extrato.js
   
   Resolva manualmente:
   1. Abra extrato.js
   2. Resolva marcações <<< === >>>
   3. Execute: git add extrato.js && git rebase --continue
   4. Solicite novo push"
   
   💰 Custo parcial da sessão: $0.09

---

💡 DECISÕES INTELIGENTES

Escolher Tipo de Commit Automaticamente

const palavrasChave = {
  feat: ['adiciona', 'implementa', 'cria', 'novo', 'nova'],
  fix: ['corrige', 'resolve', 'fix', 'bug', 'erro'],
  refactor: ['refatora', 'reorganiza', 'melhora estrutura'],
  perf: ['otimiza', 'performance', 'melhora velocidade'],
  style: ['formata', 'ajusta estilo', 'spacing'],
  docs: ['documenta', 'atualiza README', 'adiciona comentários']
};

// Analisar commit message e diff para determinar tipo
const tipo = identificarTipoInteligente(diff, palavrasChave);

Detectar Escopo Automaticamente

// Arquivos modificados
const arquivos = getArquivosModificados();

// Mapear para escopos do projeto
const mapeamento = {
  'controllers/extratoController.js': 'extrato',
  'controllers/mataMataController.js': 'mata-mata',
  'public/js/fluxo-financeiro/': 'fluxo',
  'models/Rodada.js': 'rodadas'
};

const escopo = determinarEscopoPrincipal(arquivos, mapeamento);

---

---

🔐 SEGURANÇA E COMPLIANCE

Regras de Proteção

• ❌ Nunca commitar .env
• ❌ Nunca commitar node_modules/
• ❌ Nunca commitar arquivos > 100MB
• ❌ Nunca commitar secrets/tokens
• ✅ Sempre validar multi-tenant
• ✅ Sempre validar security middleware

Validação de .gitignore

# Verificar se .gitignore está configurado
bash test -f .gitignore || echo "⚠️ .gitignore não encontrado"

# Verificar se node_modules está ignorado
bash grep -q "node_modules" .gitignore || echo "⚠️ Adicione node_modules ao .gitignore"

---

STATUS: 🚀 GIT COMMIT & PUSH PROTOCOL - AUTOMATED, SMART, COST-AWARE & SYNC-VERIFIED

Versão: 2.0 (Senior Full-Stack Edition + Usage Tracking + Full Environment Sync)

Última atualização: 2026-04-05