Automatizando pull request reviews com GitHub Actions e bots

1. Por que automatizar revisões de Pull Request?

Em projetos de software com múltiplos colaboradores, o fluxo de revisão manual de Pull Requests (PRs) frequentemente se torna um gargalo. Desenvolvedores esperam horas ou até dias por uma revisão, enquanto bugs de estilo e padrões de código poderiam ser detectados automaticamente em segundos.

A automação de revisões resolve três problemas centrais:
- Redução de gargalos: tarefas repetitivas (linting, formatação, validação de assets) são executadas por máquinas, liberando revisores humanos para análises complexas
- Consistência: padrões de código são aplicados uniformemente, sem viés ou esquecimento humano
- Casos de uso variados: desde verificar se imagens foram otimizadas até bloquear PRs que introduzem senhas em texto claro

2. Configuração básica de GitHub Actions para PRs

O ponto de partida é um workflow que dispara automaticamente quando um PR é aberto ou atualizado. O gatilho pull_request é o mais comum, mas para forks de terceiros, recomenda-se pull_request_target para acesso seguro a segredos do repositório.

Exemplo de workflow mínimo (arquivo .github/workflows/pr-checks.yml):

name: PR Checks
on:
  pull_request:
    types: [opened, synchronize, reopened]
jobs:
  lint-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm run lint
      - run: npm test

Este workflow executa linting e testes a cada nova alteração no PR. Se falhar, o PR fica bloqueado para merge até correção.

Para maior segurança em forks, utilize pull_request_target:

on: pull_request_target
jobs:
  safe-checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha }}
      - run: npm ci && npm run lint

3. Bots de revisão automatizada: ferramentas e integração

Danger.js — análise programática

Danger.js permite escrever regras em JavaScript/TypeScript que analisam o diff do PR e postam comentários automáticos. Exemplo de arquivo dangerfile.js:

import { danger, warn, message } from "danger"

const hasPackageChanges = danger.git.modified_files.includes("package.json")
const hasLockfileChanges = danger.git.modified_files.includes("package-lock.json")

if (hasPackageChanges && !hasLockfileChanges) {
  warn("Você modificou package.json mas não atualizou package-lock.json")
}

if (danger.github.pr.body.length < 10) {
  fail("A descrição do PR é muito curta. Adicione contexto sobre as mudanças.")
}

const bigPRThreshold = 300
if (danger.github.pr.additions + danger.github.pr.deletions > bigPRThreshold) {
  warn(`PR muito grande (${danger.github.pr.additions + danger.github.pr.deletions} linhas). Considere dividir em PRs menores.`)
}

CodeRabbit e bots de IA

Ferramentas como CodeRabbit (disponível como GitHub App) oferecem revisões contextuais usando inteligência artificial. Elas analisam a lógica do código, sugerem melhorias e detectam potenciais bugs — algo que vai além de simples linting.

Para integrar: vá em Settings > GitHub Apps, procure por "CodeRabbit" e instale no repositório. O bot automaticamente comenta em novos PRs com sugestões.

4. Validação de padrões de commit e metadados

PRs bem estruturados facilitam o entendimento do histórico. É possível validar automaticamente:

Verificação de título e referência a issues (arquivo .github/workflows/pr-metadata.yml):

name: Validate PR Metadata
on:
  pull_request:
    types: [opened, edited]
jobs:
  check-format:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/github-script@v7
        with:
          script: |
            const title = context.payload.pull_request.title
            const body = context.payload.pull_request.body

            // Título deve começar com tipo convencional (fix:, feat:, chore:)
            const titleRegex = /^(fix|feat|chore|docs|refactor|test):\s.+/i
            if (!titleRegex.test(title)) {
              core.setFailed("Título do PR deve seguir o padrão: tipo: descrição (ex: feat: adiciona login)")
            }

            // Descrição deve conter referência a issue
            if (!body || !body.includes("Closes #")) {
              core.setFailed("Descrição do PR deve incluir 'Closes #<numero>' para referenciar a issue")
            }

5. Revisão de segurança e dependências

Segurança é crítica. Duas ferramentas nativas do GitHub se destacam:

Dependabot — cria PRs automáticos para atualizar dependências vulneráveis. Para bloquear PRs que introduzem pacotes inseguros, use CodeQL:

name: "CodeQL Security Scan"
on:
  pull_request:
    branches: [main]
jobs:
  analyze:
    name: Analyze
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: github/codeql-action/init@v3
        with:
          languages: javascript
      - uses: github/codeql-action/analyze@v3

Escanear secrets expostos — action que varre o diff em busca de tokens, senhas ou chaves:

name: Secret Scanning
on: pull_request
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: gitleaks/gitleaks-action@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Se um secret for encontrado, o action falha e o PR é bloqueado.

6. Labels, aprovações automáticas e merge condicional

Labels automáticas com base no tipo de mudança:

name: Auto Label
on: pull_request
jobs:
  labeling:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/labeler@v5
        with:
          repo-token: "${{ secrets.GITHUB_TOKEN }}"

Arquivo .github/labeler.yml:

frontend:
  - src/frontend/**/*
backend:
  - src/backend/**/*
documentation:
  - docs/**/*.md

Aprovação automática para PRs que passam em todos os checks (use com cautela):

name: Auto Approve
on: pull_request
jobs:
  auto-approve:
    if: github.actor == 'dependabot[bot]'
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
    steps:
      - uses: hmarr/auto-approve-action@v4
        with:
          github-token: "${{ secrets.GITHUB_TOKEN }}"

Merge condicional — apenas quando todos os checks passam e há pelo menos uma revisão humana:

name: Auto Merge
on: pull_request
jobs:
  auto-merge:
    if: github.event.pull_request.user.login != 'dependabot[bot]'
    runs-on: ubuntu-latest
    steps:
      - uses: pascalgn/automerge-action@v0.16
        env:
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          MERGE_LABELS: "auto-merge"
          MERGE_METHOD: "squash"
          MERGE_REQUIRED_APPROVALS: "1"

7. Boas práticas e limitações

A automação é poderosa, mas não substitui completamente a revisão humana. Algumas diretrizes importantes:

  • Evitar revisão 100% automatizada: bots não entendem contexto de negócio, arquitetura ou decisões de design. Reserve a automação para verificações objetivas (estilo, segurança, formato)
  • Cuidado com bots aprovando dependências: aprovar automaticamente PRs do Dependabot pode introduzir breaking changes. Configure para apenas dependências de patch (PATCH) e exija revisão para major
  • Monitore logs e falhas: ações que falham silenciosamente podem dar falsa sensação de segurança. Configure notificações no Slack ou e-mail para falhas nas actions de revisão
  • Documente as regras: mantenha um arquivo CONTRIBUTING.md explicando quais verificações automáticas existem e como os contribuidores devem estruturar seus PRs

A automação de revisões de PR com GitHub Actions e bots transforma o fluxo de desenvolvimento, eliminando retrabalho e garantindo qualidade. Combinada com supervisão humana estratégica, ela acelera entregas sem sacrificar segurança ou padrões de código.

Referências