@cristiancorreau/forge 2.1.0

package/assets/core/agents/security-auditor.md

@@ -0,0 +1,54 @@
+---
+name: security-auditor
+description: Audita el código por vulnerabilidades de seguridad. Foco en autenticación, autorización, inyección y dependencias. NO modifica código.
+model: opus
+tools: Read, Grep, Glob, Bash
+tier: 1
+standard_version: "1.0"
+---
+
+# Security Auditor
+
+Auditás el código por vulnerabilidades de seguridad. No modificás código — solo reportás hallazgos
+con severidad y recomendación de fix.
+
+## Foco principal
+
+- **Autenticación y autorización**: cada endpoint debe verificar ambas
+- **Inyección**: SQL injection, command injection, SSTI, XSS
+- **Secrets en código**: tokens, passwords, keys hardcodeados
+- **Multi-tenancy**: que los datos de un tenant no sean accesibles desde otro
+- **Dependencias**: versiones con CVEs conocidos
+
+## Proceso
+
+1. Revisar todos los endpoints/rutas del PR.
+2. Buscar patrones de riesgo (grep por strings críticos).
+3. Verificar autorización por recurso (no solo autenticación de sesión).
+4. Revisar manejo de errores — que no filtre información técnica al cliente.
+5. Buscar secrets hardcodeados (`grep -r "password\|secret\|token\|key" --include="*.ts"`).
+
+## Severidades
+
+- **CRÍTICO**: Permite acceso no autorizado a datos de otro tenant, RCE, inyección SQL directa.
+- **ALTO**: Bypass de autenticación, SSRF, deserialización insegura.
+- **MEDIO**: XSS, CSRF sin protección en endpoints sensibles, verbose errors.
+- **BAJO**: Headers de seguridad faltantes, dependencias desactualizadas sin CVE activo.
+
+## No hagas
+
+- No modificás código. Solo reportás.
+- No marcás como CRÍTICO algo que es solo teórico sin path de explotación.
+- No ignorás findings por ser "solo del lado del cliente".
+
+## Forge v2 — Integración con el flujo
+
+**Cuándo te invocan:**
+- Como parte de `/review` en proyectos standard y enterprise
+- Antes de `/ship` en proyectos con datos sensibles
+
+**Checklist adicional para Forge v2:**
+- ¿El PR agrega variables de entorno? Verificar que están documentadas en `.env.example`
+- ¿Hay cambios en permisos de `settings.json`? Revisar que el allow-list es mínimo necesario
+- ¿Los hooks de producción están activos? (pre-bash-check.py para mode=standard/enterprise)
+- ¿El deploy pipeline de `/ship` incluye verificación de runtime logs?

package/assets/core/agents/test-engineer.md

@@ -0,0 +1,57 @@
+---
+name: test-engineer
+description: Escribe y mantiene tests unitarios, integración y E2E. NO escribe código de producción.
+model: sonnet
+tools: Read, Grep, Glob, Bash, Edit, Write
+tier: 1
+standard_version: "1.0"
+---
+
+# Test Engineer
+
+Escribís y mantenés tests. No tocás código de producción — si el código necesita cambiar para ser
+testeable, se lo pedís al agente que corresponda y esperás.
+
+## Tu trabajo
+
+- Tests unitarios de lógica core (funciones, servicios, validaciones)
+- Tests de integración (endpoints de API, flujos de DB)
+- Tests E2E (flujos de usuario críticos)
+- Coverage reports
+- Fixtures y factories de datos de test
+
+## Reglas
+
+- **No escribís código de producción.** Si algo no se puede testear, lo reportás.
+- Tests determinísticos — sin `Math.random()` ni `Date.now()` sin mockear.
+- Nombres descriptivos: `describe("cuando X") / it("debería Y")`.
+- Tests de integración deben usar base de datos real, no mocks del ORM.
+- Limpiar fixtures después de cada test (transacciones o truncate).
+- Sin `console.log` en tests — el runner lo reportará como falla en CI.
+
+## Prioridades
+
+1. Casos edge y errores (los happy paths suelen estar implícitos)
+2. Lógica de negocio con consecuencias legales o de compliance
+3. Flujos de usuario críticos (login, pago, consent, DSAR)
+4. Regresiones de bugs conocidos
+
+## No hagas
+
+- No skipees tests sin un comentario que explique por qué y cuándo se desbloquea.
+- No mockees la base de datos en tests de integración.
+- No testees implementación, testea comportamiento observable.
+- No crees tests que solo pasan en tu máquina (evitar paths absolutos, fechas hardcodeadas).
+
+## Forge v2 — Reglas de testing
+
+**Tu rol en el flujo SDD:**
+- Los tests se escriben con la implementación, no al final
+- Cada acceptance criterion de la spec debe tener al menos un test
+- No marcar spec como "implementada" sin tests que verifiquen cada criterio
+
+**Comandos relevantes:**
+- `/review`: podés ser invocado como parte de un review multi-agente
+- Los tests van en los mismos PRs que el código — no en PRs separados
+
+**Scope:** Archivos de test, fixtures y configuración de testing. No modificar código de aplicación salvo para refactors que mejoren testabilidad (coordinar con backend/frontend engineer).

package/assets/core/hooks/hooks-registry.yaml

@@ -0,0 +1,48 @@
+# Forge v2 — Hooks registry
+# Define qué hooks se instalan según mode y stack del proyecto.
+
+universal:
+  # Se instalan en TODOS los proyectos
+  - hook: pre-edit-check.py
+    event: PreToolUse
+    matcher: "Edit|Write"
+    description: "Branch guard, debug detection, secret detection"
+  - hook: post-turn-check.sh
+    event: Stop
+    description: "Typecheck/lint sobre archivos modificados"
+
+standard:
+  # mode: standard + enterprise
+  - hook: pre-bash-check.py
+    event: PreToolUse
+    matcher: "Bash"
+    description: "Bloquea comandos destructivos en producción"
+
+enterprise:
+  # mode: enterprise solamente (además de standard)
+  - hook: audit-log-append.py
+    event: PostToolUse
+    description: "Audit log inmutable para SOC2/compliance"
+
+stack:
+  # Por stack (además de los universales)
+  supabase:
+    - hook: check-destructive-sql.py
+      event: PreToolUse
+      matcher: "Bash"
+      description: "Detecta SQL destructivo contra Supabase"
+  prisma:
+    - hook: prisma-safety.py
+      event: PreToolUse
+      matcher: "Bash"
+      description: "Bloquea migrate reset en producción"
+  nextjs-admin:
+    - hook: prisma-safety.py
+      event: PreToolUse
+      matcher: "Bash"
+      description: "Bloquea prisma migrate reset/fresh en producción (aplica si el profile usa Prisma como ORM)"
+  laravel:
+    - hook: composer-check.py
+      event: PreToolUse
+      matcher: "Bash"
+      description: "Verifica que composer install/update no instale paquetes de dev en producción; advierte sobre artisan migrate:fresh/reset"

package/assets/core/hooks/post-turn-check.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# Forge v2 — Stop hook: post-turn-check.sh
+# Runs after each Claude turn. Detects modified files and runs type/syntax checks.
+# Always exits 0 (never blocks).
+
+set -euo pipefail
+
+# ---------------------------------------------------------------------------
+# Step 1 — Find modified files
+# ---------------------------------------------------------------------------
+MODIFIED=$(git diff --name-only HEAD 2>/dev/null || echo "")
+STAGED=$(git diff --name-only --cached 2>/dev/null || echo "")
+ALL_CHANGED="$MODIFIED $STAGED"
+
+if [ -z "$(echo "$ALL_CHANGED" | tr -d '[:space:]')" ]; then
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Step 2 — Read project config
+# ---------------------------------------------------------------------------
+PKG_MGR=""
+CUSTOM_CHECK=""
+
+if [ -f "project.yaml" ]; then
+  PKG_MGR=$(python3 -c "
+import yaml, sys
+try:
+    d = yaml.safe_load(open('project.yaml'))
+    print(d.get('stack', {}).get('package_manager', ''))
+except:
+    print('')
+" 2>/dev/null || echo "")
+
+  CUSTOM_CHECK=$(python3 -c "
+import yaml, sys
+try:
+    d = yaml.safe_load(open('project.yaml'))
+    print(d.get('scripts', {}).get('check', ''))
+except:
+    print('')
+" 2>/dev/null || echo "")
+fi
+
+CHECK_OUTPUT=""
+
+# ---------------------------------------------------------------------------
+# Step 3 — Run checks
+# ---------------------------------------------------------------------------
+
+# Helper: check if any changed file matches a glob pattern
+files_matching() {
+  local pattern="$1"
+  echo "$ALL_CHANGED" | tr ' ' '\n' | grep -E "$pattern" 2>/dev/null || true
+}
+
+if [ -n "$CUSTOM_CHECK" ]; then
+  # Run user-defined check command
+  CHECK_OUTPUT=$(eval "$CUSTOM_CHECK" 2>&1 | head -20 || true)
+
+else
+  # Auto-detect by file type
+
+  # TypeScript / JavaScript
+  TS_FILES=$(files_matching '\.(ts|tsx)$')
+  if [ -n "$TS_FILES" ]; then
+    TSC_CMD=""
+    if [ -f "turbo.json" ] && command -v pnpm &>/dev/null; then
+      TSC_OUTPUT=$(pnpm turbo typecheck 2>&1 | head -20 || pnpm tsc --noEmit 2>&1 | head -20 || true)
+    elif command -v pnpm &>/dev/null; then
+      TSC_OUTPUT=$(pnpm tsc --noEmit 2>&1 | head -20 || true)
+    elif command -v npx &>/dev/null; then
+      TSC_OUTPUT=$(npx tsc --noEmit 2>&1 | head -20 || true)
+    else
+      TSC_OUTPUT=""
+    fi
+    if [ -n "${TSC_OUTPUT:-}" ]; then
+      CHECK_OUTPUT="${CHECK_OUTPUT:+$CHECK_OUTPUT$'\n'}[tsc] $TSC_OUTPUT"
+    fi
+  fi
+
+  # PHP
+  PHP_FILES=$(files_matching '\.php$')
+  if [ -n "$PHP_FILES" ] && [ -f "composer.json" ]; then
+    if command -v composer &>/dev/null; then
+      PHP_OUTPUT=$(composer validate --no-check-publish 2>&1 | head -10 || true)
+      if [ -n "$PHP_OUTPUT" ]; then
+        CHECK_OUTPUT="${CHECK_OUTPUT:+$CHECK_OUTPUT$'\n'}[composer] $PHP_OUTPUT"
+      fi
+    fi
+  fi
+
+  # Python
+  PY_FILES=$(files_matching '\.py$')
+  if [ -n "$PY_FILES" ]; then
+    PY_OUTPUT=""
+    while IFS= read -r f; do
+      [ -z "$f" ] && continue
+      [ -f "$f" ] || continue
+      RESULT=$(python3 -m py_compile "$f" 2>&1 || true)
+      if [ -n "$RESULT" ]; then
+        PY_OUTPUT="${PY_OUTPUT:+$PY_OUTPUT$'\n'}$f: $RESULT"
+      fi
+    done <<< "$PY_FILES"
+    if [ -n "$PY_OUTPUT" ]; then
+      CHECK_OUTPUT="${CHECK_OUTPUT:+$CHECK_OUTPUT$'\n'}[python] $PY_OUTPUT"
+    fi
+  fi
+
+  # Ruby
+  RB_FILES=$(files_matching '\.rb$')
+  if [ -n "$RB_FILES" ] && [ -f "Gemfile" ]; then
+    RB_OUTPUT=""
+    if command -v bundle &>/dev/null; then
+      while IFS= read -r f; do
+        [ -z "$f" ] && continue
+        [ -f "$f" ] || continue
+        RESULT=$(bundle exec ruby -c "$f" 2>&1 | head -10 || true)
+        if [ -n "$RESULT" ]; then
+          RB_OUTPUT="${RB_OUTPUT:+$RB_OUTPUT$'\n'}$f: $RESULT"
+        fi
+      done <<< "$RB_FILES"
+    fi
+    if [ -n "$RB_OUTPUT" ]; then
+      CHECK_OUTPUT="${CHECK_OUTPUT:+$CHECK_OUTPUT$'\n'}[ruby] $RB_OUTPUT"
+    fi
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Step 4 — Report
+# ---------------------------------------------------------------------------
+if [ -n "$CHECK_OUTPUT" ]; then
+  echo "── Forge post-turn check ─────────────────"
+  echo "$CHECK_OUTPUT"
+  echo "──────────────────────────────────────────"
+fi
+
+exit 0

package/assets/core/hooks/pre-bash-check.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Forge v2 — PreToolUse hook: pre-bash-check.py
+Bloquea comandos destructivos en contexto de producción.
+
+Contexto crítico: el 2026-04-28, --force-reset fue ejecutado accidentalmente
+contra la base de datos de producción de un proyecto real, borrando 225 usuarios
+y 35 formularios (recuperados desde backup de Supabase Pro). Este hook existe
+para que eso nunca vuelva a pasar.
+"""
+
+import json
+import os
+import re
+import sys
+
+
+DEBUG = os.environ.get("DEBUG", "") not in ("", "0", "false", "False")
+
+
+def dbg(msg):
+    if DEBUG:
+        print(f"[forge-hook-debug] {msg}", flush=True)
+
+
+def load_project_yaml():
+    """Walk up from cwd to find project.yaml. Returns dict or {}."""
+    try:
+        import yaml
+        path = os.getcwd()
+        for _ in range(6):
+            candidate = os.path.join(path, "project.yaml")
+            if os.path.isfile(candidate):
+                with open(candidate) as f:
+                    data = yaml.safe_load(f)
+                    return data if isinstance(data, dict) else {}
+            parent = os.path.dirname(path)
+            if parent == path:
+                break
+            path = parent
+    except Exception as e:
+        dbg(f"project.yaml load error: {e}")
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# Patrones peligrosos hardcodeados
+# ---------------------------------------------------------------------------
+
+DANGEROUS_PATTERNS = [
+    (r"--force-reset",                              "--force-reset"),
+    (r"prisma\s+migrate\s+reset",                  "prisma migrate reset"),
+    (r"DROP\s+TABLE",                              "DROP TABLE"),
+    (r"TRUNCATE\s+",                               "TRUNCATE"),
+    (r"DELETE\s+FROM\s+\w+\s*;",                   "DELETE FROM sin WHERE"),
+    (r"DROP\s+DATABASE",                           "DROP DATABASE"),
+    (r"dropdb\s+",                                  "dropdb"),
+    (r"rm\s+-rf\s+/",                               "rm -rf /"),
+    (r"git\s+push\s+--force(?!\s+--with-lease)",   "git push --force sin --with-lease"),
+]
+
+
+def _match_dangerous(command: str) -> tuple[bool, str]:
+    """Retorna (matched, pattern_label). Verifica patrones hardcodeados."""
+    for pattern, label in DANGEROUS_PATTERNS:
+        if re.search(pattern, command, re.IGNORECASE):
+            return True, label
+    return False, ""
+
+
+def _match_project_forbidden(command: str, project: dict) -> tuple[bool, str]:
+    """Verifica patrones forbidden_in_production del project.yaml."""
+    try:
+        rules = project.get("rules", {})
+        forbidden = rules.get("forbidden_in_production", [])
+        if not isinstance(forbidden, list):
+            return False, ""
+        for pattern in forbidden:
+            if re.search(pattern, command):
+                return True, pattern
+    except Exception as e:
+        dbg(f"project.yaml forbidden_in_production error: {e}")
+    return False, ""
+
+
+def _is_production_context(command: str, project: dict) -> bool:
+    """
+    Retorna True si el comando se ejecuta en contexto de producción:
+    - La URL de producción aparece en el comando, o
+    - Variables de entorno PROD_* / PRODUCTION_* están seteadas en el proceso.
+    """
+    # URL de producción del project.yaml
+    deploy = project.get("deploy", {})
+    prod_url = deploy.get("production_url", "") or ""
+    project_id = deploy.get("project_id", "") or ""
+
+    if prod_url and prod_url in command:
+        dbg(f"production context: URL '{prod_url}' encontrada en comando")
+        return True
+    if project_id and project_id in command:
+        dbg(f"production context: project_id '{project_id}' encontrado en comando")
+        return True
+
+    # Variables de entorno que sugieren contexto de producción
+    prod_env_patterns = re.compile(r"^(PROD_|PRODUCTION_|PROD$|PRODUCTION$)", re.IGNORECASE)
+    for key, value in os.environ.items():
+        if prod_env_patterns.match(key) and value:
+            dbg(f"production context: env var '{key}' activa")
+            return True
+
+    return False
+
+
+def _extract_snippet(command: str, max_len: int = 120) -> str:
+    """Retorna un extracto legible del comando."""
+    command = command.strip()
+    if len(command) <= max_len:
+        return command
+    return command[:max_len] + "..."
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            dbg("empty stdin, allowing")
+            sys.exit(0)
+        data = json.loads(raw)
+    except Exception as e:
+        dbg(f"stdin parse error: {e}")
+        sys.exit(0)
+
+    try:
+        tool_name = data.get("tool_name", "")
+        if tool_name != "Bash":
+            sys.exit(0)
+
+        tool_input = data.get("tool_input", {})
+        command = tool_input.get("command", "")
+        if not command:
+            sys.exit(0)
+
+        dbg(f"command: {command[:200]!r}")
+
+        project = load_project_yaml()
+
+        # Verificar patrones peligrosos hardcodeados
+        matched, pattern_label = _match_dangerous(command)
+
+        # Verificar patrones custom del project.yaml
+        if not matched:
+            matched, pattern_label = _match_project_forbidden(command, project)
+
+        if not matched:
+            sys.exit(0)
+
+        # Hay un patrón peligroso — ¿es contexto de producción?
+        in_production = _is_production_context(command, project)
+
+        snippet = _extract_snippet(command)
+
+        if in_production:
+            # BLOQUEAR
+            print(
+                f"forge: BLOQUEADO — comando destructivo detectado en contexto de producción.\n"
+                f"\n"
+                f"  Comando: {snippet}\n"
+                f"  Patrón: {pattern_label}\n"
+                f"\n"
+                f"  Si necesitás ejecutar esto, hacelo MANUALMENTE en la terminal\n"
+                f"  con plena consciencia de que afecta producción.\n"
+                f"\n"
+                f"  Lección del 2026-04-28: --force-reset borró 225 usuarios y\n"
+                f"  35 formularios en producción. Este hook existe por eso.",
+                flush=True,
+            )
+            sys.exit(2)
+        else:
+            # ADVERTIR — no bloquear
+            print(
+                f"forge: ADVERTENCIA — comando potencialmente destructivo detectado.\n"
+                f"\n"
+                f"  Comando: {snippet}\n"
+                f"  Patrón: {pattern_label}\n"
+                f"\n"
+                f"  Si esto apunta a producción, cancela y ejecuta manualmente.\n"
+                f"  Confirmá que el contexto es seguro antes de continuar.",
+                flush=True,
+            )
+            sys.exit(0)
+
+    except Exception as e:
+        dbg(f"unexpected error: {e}")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()