W5: Pipeline 100% Agentic

// Webhook payload do GitHub
{
  "action": "opened",
  "issue": {
    "number": 247,
    "title": "Adicionar rate limiting de 100 req/min na API de usuários",
    "body": "Estamos sofrendo abuse na rota GET /api/users. Precisamos de rate limiting por IP com resposta 429.",
    "labels": [{"name": "enhancement"}, {"name": "security"}]
  }
}

claude -p "
Issue #247: Adicionar rate limiting 100 req/min na API de usuários.
Leia src/api/users/ e identifique:
1. Qual middleware de rate limiting está disponível no projeto
2. Quais agentes você vai spawnar e por quê
3. Escreva agents-plan.json com a lista de agentes e seus briefs
Contexto máximo: mantenha resposta < 2K tokens.
Escreva resultado em .pipeline/247/orchestrator-plan.json"

{
  "issue": 247,
  "agents": [
    {
      "id": "backend",
      "brief_file": ".pipeline/247/backend-brief.txt",
      "rationale": "Implementar middleware rate-limit em src/api/users/ com resposta 429"
    },
    {
      "id": "test",
      "brief_file": ".pipeline/247/test-brief.txt",
      "rationale": "TDD-first: escrever testes para rate limiting antes da implementação"
    },
    {
      "id": "security",
      "brief_file": ".pipeline/247/security-brief.txt",
      "rationale": "Issue tem label security — auditar OWASP A03 (injection via IP header) e A07 (auth bypass)"
    }
  ]
}

# Backend Agent — implementa o middleware
claude -p "$(cat .pipeline/247/backend-brief.txt)" &

# Test Agent — TDD: escreve testes ANTES da implementação
claude -p "$(cat .pipeline/247/test-brief.txt)" &

# Security Agent — OWASP A03: injection via X-Forwarded-For, A07: bypass por header
claude -p "$(cat .pipeline/247/security-brief.txt)" &

wait # aguarda os 3 terminarem antes de consolidar

# Review agent consolida e audita
claude -p "Leia .pipeline/247/backend-output/, .pipeline/247/tests/, .pipeline/247/security-report.json.
Verifique: SOLID, sem regressões, OWASP OK.
Escreva .pipeline/247/review-result.json com status e issues."

// .pipeline/247/review-result.json
{
  "status": "approved",
  "solid_violations": [],
  "owasp_issues": [],
  "regression_risk": "low",
  "notes": "X-Forwarded-For sanitizado corretamente. Testes cobrem cenários de bypass."
}

# Unidade: domínio isolado, sem I/O externo
npx vitest run --reporter=json > .pipeline/247/test-results.json

# E2E: jornadas críticas com browser headless
npx cypress run --headless --reporter json > .pipeline/247/cypress-results.json

# Load + stress: somente se API mudou (rate limiting mudou o contrato)
k6 run --out json=.pipeline/247/k6-results.json k6/load.js

# Auditoria de dependências: OWASP A06
npm audit --json > .pipeline/247/audit-results.json

gh pr create \
  --title "feat: rate limiting 100 req/min na API de usuários (closes #247)" \
  --body "$(cat .pipeline/247/pr-description.md)"

gh pr merge --squash --auto

gh issue close 247 --comment "Implementado via pipeline autônomo. PR #$(gh pr view --json number -q .number)"

# Regras de decisão do orchestrator (lógica de seleção de agentes)

# Label "security" presente → spawna security agent com checklist OWASP
if issue.labels includes "security":
  spawn security-agent --brief security-brief.txt

# Corpo menciona "frontend" ou "UI" → spawna frontend agent com skill frontend-design
if issue.body matches /(frontend|UI|componente|tela)/i:
  spawn frontend-agent --skill frontend-design --brief frontend-brief.txt

# Corpo menciona "banco" ou "migration" → spawna migration agent
if issue.body matches /(database|migration|schema|PostgreSQL)/i:
  spawn migration-agent --brief migration-brief.txt

# Corpo menciona "performance" ou "latência" → spawna perf agent com k6
if issue.body matches /(performance|latência|throughput|slow)/i:
  spawn perf-agent --tools k6 --brief perf-brief.txt

claude -p "Crie um skill temporário em .pipeline/247/skills/migration-agent.md
para um agente especializado em migrations de banco PostgreSQL com zero downtime.
O skill deve ter: instruções de como criar migrations reversíveis,
checklist de segurança, e formato de output."

---
description: Agente especializado em migrations PostgreSQL com zero downtime
---

## Regras de zero-downtime migration

1. NUNCA use `ALTER TABLE ... DROP COLUMN` sem um ciclo de deploy intermediário
2. Adicione colunas como nullable primeiro, popule com default, então adicione constraint
3. Use transactions explícitas: `BEGIN; ... COMMIT;`
4. Toda migration deve ter `up()` e `down()` implementados e testados

## Checklist de segurança
- [ ] Migration reversível via `down()`
- [ ] Testada em snapshot da base de produção (anonimizada)
- [ ] Lock time estimado < 100ms (senão use `pg_repack` ou online DDL)
- [ ] Plano de rollback documentado em migration-plan.md

## Formato de output
Escreva os arquivos em `.pipeline/[issue]/migrations/`:
- `YYYYMMDDHHMMSS_description.sql` — a migration em si
- `migration-plan.md` — estimativa de lock time e plano de rollback

# ANTI-PATTERN: solicitar output completo causa context overflow
claude -p "
Mostre o conteúdo completo de todos os arquivos em .pipeline/247/backend-output/,
.pipeline/247/tests/, e .pipeline/247/security-report.json.
Analise tudo e me diga se está OK."

# Problema: com 3 agentes gerando código, você facilmente injeta 50K+ tokens
# de output de implementação no contexto do orchestrator.

# PATTERN CORRETO: orchestrator pede apenas { status, output_files[], issues[] }
claude -p "
Cada agente escreveu um arquivo de resultado em .pipeline/247/:
- backend-result.json
- test-result.json
- security-result.json

Leia APENAS esses três arquivos de resultado (não os outputs completos).
Produza um summary em .pipeline/247/wave-1-summary.json com:
{ status: 'ok'|'failed', output_files: [], issues: [] }
Mantenha a resposta abaixo de 500 tokens."

// Formato padrão de result.json para cada agente
{
  "agent": "backend",
  "status": "ok",
  "output_files": [
    "src/middleware/rate-limit.ts",
    "src/api/users/index.ts"
  ],
  "issues": [],
  "tokens_used": 18420,
  "duration_seconds": 47
}

project-root/
├── .pipeline/               # Estado dos pipelines em execução e histórico
│   └── [issue-number]/      # Diretório isolado por issue
│       ├── orchestrator-plan.json
│       ├── backend-brief.txt
│       ├── test-brief.txt
│       ├── security-brief.txt
│       ├── backend-output/  # Arquivos gerados pelo backend agent
│       ├── tests/           # Testes gerados pelo test agent
│       ├── security-report.json
│       ├── wave-1-summary.json
│       ├── review-result.json
│       ├── test-results.json
│       ├── cypress-results.json
│       ├── k6-results.json
│       ├── audit-results.json
│       └── pr-description.md
├── k6/
│   ├── load.js              # Cenário de carga: baseline de throughput
│   └── stress.js            # Cenário de stress: ponto de ruptura
├── scripts/
│   ├── orchestrator.sh      # Script principal do pipeline
│   ├── spawn-agents.sh      # Lançamento paralelo de agentes
│   └── testing-pipeline.sh  # Sequência determinística de testes
└── .github/
    └── workflows/
        └── agentic-pipeline.yml

# .github/workflows/agentic-pipeline.yml
name: Agentic Pipeline

on:
  issues:
    types: [labeled]

jobs:
  run-pipeline:
    # Só dispara para labels que indicam feature elegível para automação
    if: |
      github.event.label.name == 'agentic-ready' ||
      github.event.label.name == 'auto-implement'
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
      issues: write

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Install Claude Code CLI
        run: npm install -g @anthropic-ai/claude-code

      - name: Install GitHub CLI
        run: |
          type -p curl >/dev/null || apt install curl -y
          curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
          echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list > /dev/null
          apt update && apt install gh -y

      - name: Run agentic pipeline
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          ISSUE_NUMBER: ${{ github.event.issue.number }}
          ISSUE_TITLE: ${{ github.event.issue.title }}
          ISSUE_BODY: ${{ github.event.issue.body }}
        run: bash scripts/orchestrator.sh

#!/usr/bin/env bash
# scripts/orchestrator.sh
set -euo pipefail

ISSUE=$ISSUE_NUMBER
PIPELINE_DIR=".pipeline/$ISSUE"
mkdir -p "$PIPELINE_DIR/skills"

echo "=== Pipeline iniciado para issue #$ISSUE ==="

# Fase 1: Boot do orchestrator — análise e planejamento
claude -p "
Issue #$ISSUE: $ISSUE_TITLE
Corpo: $ISSUE_BODY

Analise src/ e identifique os módulos impactados.
Decida quais agentes spawnar. Escreva os briefs.
Output em $PIPELINE_DIR/orchestrator-plan.json e $PIPELINE_DIR/*-brief.txt
Mantenha resposta abaixo de 2K tokens." \
  --output-format json

# Fase 2: Spawn paralelo de agentes especializados
bash scripts/spawn-agents.sh "$PIPELINE_DIR"

# Fase 3: Consolidação e review
claude -p "
Leia $PIPELINE_DIR/*-result.json (apenas os result files, não os outputs completos).
Produza $PIPELINE_DIR/wave-1-summary.json com { status, output_files[], issues[] }"

REVIEW_STATUS=$(jq -r '.status' "$PIPELINE_DIR/wave-1-summary.json")
if [ "$REVIEW_STATUS" != "ok" ]; then
  echo "Wave 1 falhou. Iniciando ciclo de debug..." >&2
  exit 1
fi

# Fase 4: Testing pipeline
bash scripts/testing-pipeline.sh "$PIPELINE_DIR"

# Fase 5: PR + merge + fechamento
bash scripts/merge-and-close.sh "$PIPELINE_DIR" "$ISSUE"

echo "=== Pipeline concluído para issue #$ISSUE ==="

# .github/auto-approve.yml (usando hmarr/auto-approve-action ou equivalente)
# Política restritiva para início: apenas PRs pequenos com todos os gates passando

rules:
  - conditions:
      # Só aprova automaticamente PRs criados pelo pipeline agentic
      - author: "github-actions[bot]"
      # Requer que todos os checks de CI passem
      - check-success: "vitest"
      - check-success: "cypress"
      - check-success: "npm-audit"
      # Limita o tamanho do PR para mudanças incrementais
      - "files-changed < 15"
      - "additions + deletions < 300"
    actions:
      approve: true
      merge:
        method: squash

# Smoke test pós-deploy: verifica endpoints críticos
PROD_URL="https://api.seuapp.com"

# Verifica que o rate limiting responde corretamente
RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" "$PROD_URL/api/users")
if [ "$RESPONSE" != "200" ]; then
  echo "SMOKE TEST FAILED: /api/users retornou $RESPONSE" >&2
  # Aciona rollback automático via vercel rollback ou gh workflow run rollback
  gh workflow run rollback.yml -f deployment_id="$DEPLOYMENT_ID"
  exit 1
fi

# Verifica que rate limiting está ativo (deve retornar 429 após 100 requests)
for i in $(seq 1 101); do
  STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$PROD_URL/api/users")
  if [ "$i" -eq 101 ] && [ "$STATUS" != "429" ]; then
    echo "SMOKE TEST FAILED: rate limiting não ativou na requisição 101" >&2
    exit 1
  fi
done

echo "Smoke tests passaram. Issue fechado."

# Checklist de maturidade para pipeline 100% agentic

## Cobertura de testes
- [ ] Cobertura de testes unitários >= 80% nas rotas críticas
- [ ] Testes de integração com banco de dados real (sem mocks de infra)
- [ ] Testes E2E cobrindo jornadas de usuário afetadas pelo pipeline
- [ ] Load tests com baseline documentado de throughput e latência

## Gates do pipeline
- [ ] Review Agent configurado com checklist SOLID e OWASP Top 10
- [ ] Testing pipeline bloqueia merge se qualquer teste falhar
- [ ] Smoke tests pós-deploy com rollback automático em caso de falha
- [ ] npm audit como gate obrigatório (bloqueia em vulnerabilidades críticas)

## Auto-approve policy
- [ ] Policy restritiva por padrão: PRs pequenos, todos os checks passando
- [ ] Limitação de tamanho de PR configurada (recomendado: < 300 linhas)
- [ ] 20+ PRs supervisionados com zero regressões antes de ativar auto-merge

## Observabilidade
- [ ] Logs estruturados em cada etapa do pipeline (JSON, não texto livre)
- [ ] Alertas configurados para falhas de smoke test
- [ ] Histórico de pipelines auditável em .pipeline/ com retenção adequada

## Rollback
- [ ] Procedimento de rollback documentado e testado manualmente
- [ ] Rollback automático configurado para falhas de smoke test
- [ ] Canal de comunicação (Slack/PagerDuty) para falhas críticas do pipeline

# Backend Agent com hooks ativos
claude -p "$(cat .pipeline/247/backend-brief.txt)" \
  --settings .claude/settings-strict.json &

# Test Agent com hooks ativos
claude -p "$(cat .pipeline/247/test-brief.txt)" \
  --settings .claude/settings-strict.json &

# Security Agent com hooks ativos
claude -p "$(cat .pipeline/247/security-brief.txt)" \
  --settings .claude/settings-strict.json &

wait

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [{"type": "command", "command": "node scripts/quality-gate.mjs \"$CLAUDE_TOOL_INPUT_FILE_PATH\""}]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{"type": "command", "command": "node scripts/bash-guard.mjs"}]
      }
    ],
    "Stop": [
      {
        "hooks": [{"type": "command", "command": "node scripts/agent-report.mjs"}]
      }
    ]
  }
}

#!/usr/bin/env node
// agent-report.mjs — escreve relatório de qualidade que o orchestrator lê
import { execSync, writeFileSync } from 'node:child_process';
import { mkdirSync } from 'node:fs';

const pipelineDir = process.env.PIPELINE_DIR ?? '.pipeline/current';
mkdirSync(pipelineDir, { recursive: true });

let status = 'ok';
let issues = [];

try {
  execSync('npx vitest run --reporter=json', { stdio: 'pipe' });
} catch (e) {
  status = 'failed';
  issues.push('testes falhando');
}

try {
  execSync('npm audit --audit-level high', { stdio: 'pipe' });
} catch {
  issues.push('vulnerabilidades em dependências');
}

writeFileSync(
  `${pipelineDir}/quality-report.json`,
  JSON.stringify({ status, issues, timestamp: new Date().toISOString() }, null, 2)
);

console.log(`[agent-report] status=${status}, issues=${issues.length}`);
if (status === 'failed') process.exit(1);