Vibe coding seguro: pipeline de QA para código gerado com Cursor, Aider e Cline

  Developer → Cursor / Aider / Cline / Claude Code
       │
       ▼
  ┌──────────────────────────────────────────────┐
  │ pre-commit                                   │
  │  ├─ gitleaks (secrets)                       │
  │  ├─ semgrep (quick rules)                    │
  │  ├─ bearer (PII/sensitive data)              │
  │  └─ black/ruff/eslint                        │
  └──────────────────────────────────────────────┘
       │
       ▼
  ┌──────────────────────────────────────────────┐
  │ CI (GitHub Actions)                          │
  │  ├─ semgrep full (OWASP + AI-specific)       │
  │  ├─ sonarqube community                      │
  │  ├─ trivy fs/image                           │
  │  ├─ bearer full scan                         │
  │  ├─ dspy: generate + run tests               │
  │  ├─ promptfoo: prompt validation             │
  │  └─ license check (supply chain)             │
  └──────────────────────────────────────────────┘
       │
       ▼
  ┌──────────────────────────────────────────────┐
  │ runtime                                      │
  │  ├─ dependency-track (SBOM monitoring)       │
  │  ├─ falco / tetragon (syscall anomalies)     │
  │  └─ traces to Langfuse (if there are LLMs)   │
  └──────────────────────────────────────────────┘

repos:
  - repo: https://github.com/gitleaks/gitleaks
    rev: v8.21.2
    hooks:
      - id: gitleaks

  - repo: https://github.com/returntocorp/semgrep
    rev: v1.95.0
    hooks:
      - id: semgrep
        args:
          - --config=p/owasp-top-ten
          - --config=p/secrets
          - --config=./.semgrep/ai-gen-rules.yml
          - --error
          - --skip-unknown-extensions

  - repo: https://github.com/Bearer/bearer
    rev: v1.49.0
    hooks:
      - id: bearer
        args: ["scan", ".", "--severity=critical,high,medium", "--fail-on-severity=critical,high"]

  - repo: local
    hooks:
      - id: forbidden-patterns
        name: "AI gen anti-patterns"
        entry: scripts/forbidden_patterns.sh
        language: script

#!/usr/bin/env bash
set -e
# common patterns Cursor/GPT generate that should not reach prod
grep -nR --include=*.py --include=*.ts --include=*.go \
  -E '(except:\s*pass|# FIXME|# TODO:|console\.log\("DEBUG|print\("DEBUG)' \
  -- "$@" && {
    echo "❌ anti-patterns found"
    exit 1
  } || true

rules:
  - id: hardcoded-api-key
    pattern-either:
      - pattern: api_key = "sk-..."
      - pattern: $KEY = "pk_live_..."
      - pattern: ANTHROPIC_API_KEY = "sk-ant-..."
    message: "Secret hardcoded. Use env vars."
    severity: ERROR
    languages: [python, javascript, typescript, go]

  - id: llm-without-timeout
    pattern-either:
      - pattern: openai.ChatCompletion.create(...)
      - pattern: anthropic.messages.create(...)
    pattern-not-inside: |
      $CTX.with_timeout(...)
    message: "LLM call without timeout; can hang the process."
    severity: WARNING
    languages: [python]

  - id: prompt-concat-user-input
    patterns:
      - pattern-either:
          - pattern: |
              $PROMPT = f"...{$USER_INPUT}..."
              ...
              $LLM.create(messages=[{"role": "system", "content": $PROMPT}, ...])
      - pattern: |
              $PROMPT = "..." + $USER_INPUT + "..."
              ...
              $LLM.create(...)
    message: "Possible prompt injection: user input concatenated to system prompt."
    severity: ERROR
    languages: [python, typescript]

  - id: sql-string-concat
    pattern-either:
      - pattern: 'cursor.execute(f"SELECT ... {$VAR} ...")'
      - pattern: 'conn.Exec("SELECT ... " + $VAR + " ...")'
    message: "SQL via concatenation. Use parameters."
    severity: ERROR
    languages: [python, go]

  - id: agent-tool-no-idempotency
    patterns:
      - pattern: |
          @tool
          def $FN(...):
              ...
      - pattern-not-inside: |
          def $FN(..., operation_id: str, ...):
              ...
    message: "Agent-side tool without operation_id; missing idempotency."
    severity: WARNING
    languages: [python]

import dspy

class GenerateTestFromDiff(dspy.Signature):
    """Generate pytest tests for modified functions. Use descriptive names, cover happy path and at least 2 edge cases."""
    diff: str = dspy.InputField()
    file_path: str = dspy.InputField()
    tests: str = dspy.OutputField()

lm = dspy.LM("anthropic/claude-sonnet-4-6", api_base="https://api.numoru.com/v1", api_key=os.environ["LITELLM_MASTER_KEY"])
dspy.configure(lm=lm)

generator = dspy.ChainOfThought(GenerateTestFromDiff)

def generate_and_run(diff: str, file_path: str):
    out = generator(diff=diff, file_path=file_path)
    tests_file = write_to_tmp(out.tests)
    result = subprocess.run(["pytest", tests_file, "-v"], capture_output=True)
    return result

# .github/workflows/security.yml
- name: Trivy fs scan
  uses: aquasecurity/trivy-action@master
  with:
    scan-type: fs
    severity: CRITICAL,HIGH
    ignore-unfixed: true
    exit-code: "1"

- name: Trivy image scan
  if: github.event_name == 'pull_request'
  uses: aquasecurity/trivy-action@master
  with:
    image-ref: ghcr.io/numoru/app:${{ github.sha }}
    severity: CRITICAL,HIGH

#!/usr/bin/env bash
set -e
DIFF=$(git diff --cached --unified=0 -- 'package.json' 'requirements.txt' 'go.mod')
if echo "$DIFF" | grep -q '^+[^+-]'; then
    if ! git log --format=%B -n 1 HEAD | grep -q 'new-dep:'; then
        echo "❌ new dependencies detected. Add 'new-dep: <reason>' to the commit message"
        exit 1
    fi
fi

name: secure-ai-gen
on: [pull_request]

jobs:
  semgrep:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: returntocorp/semgrep-action@v1
        with:
          config: >
            p/owasp-top-ten
            p/secrets
            p/ci
            ./.semgrep/ai-gen-rules.yml

  bearer:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: bearer/bearer-action@v2
        with:
          scan-command: "scan . --report=security --severity=critical,high"

  sonarqube:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with: { fetch-depth: 0 }
      - uses: SonarSource/sonarqube-scan-action@v3
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
          SONAR_HOST_URL: https://sonar.numoru.com

  trivy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: aquasecurity/trivy-action@master
        with: { scan-type: fs, severity: "CRITICAL,HIGH", exit-code: "1" }

  dspy-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with: { python-version: "3.12" }
      - run: pip install dspy-ai pytest
      - name: Generate + run tests from diff
        env:
          LITELLM_MASTER_KEY: ${{ secrets.LITELLM_MASTER_KEY }}
        run: python scripts/gen_tests_from_diff.py

  promptfoo:
    if: contains(github.event.pull_request.changed_files, 'prompts/')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g promptfoo
      - run: promptfoo eval -c promptfoo.yml

# Numoru rules — AI-generated code must:

1. Never hardcode API keys; use env vars via pydantic settings / viper / dotenv.
2. Every LLM call must have a timeout (<30s) and retry with backoff.
3. Prompts built with user input must use clear delimiters (<input>...).
4. Functions with external side effects must accept operation_id: str for idempotency.
5. SQL must use parameters; never f-string or concat.
6. Tests must exist for every public function. Minimum 70% coverage.
7. In Python, never except: pass. In Go, never ignore err.
8. Logs must not include plaintext PII; hash email and phone.

- macro: llm_service
  condition: (proc.name in (uvicorn, gunicorn, node, go-binary))

- rule: LLM service spawning shell
  desc: "Should never spawn a shell"
  condition: spawned_process and proc.pname in (uvicorn, gunicorn) and proc.name in (bash, sh, dash, zsh)
  output: "LLM service spawned shell (command=%proc.cmdline)"
  priority: CRITICAL
  tags: [ai, runtime]