theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/skills/validacion-config-red/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: validacion-config-red
+description: Verificaciones previas al despliegue de configuración de routers y switches — comandos peligrosos, direcciones duplicadas, solapamiento de subredes, referencias huérfanas, riesgo del plano de gestión e higiene de seguridad estilo IOS.
+---
+
+# Validación de configuración de red
+
+Usa esta skill para revisar configuración de red antes de una ventana de cambio o
+antes de que una corrida de automatización toque dispositivos de producción.
+
+## Cuándo usarla
+
+- Al revisar fragmentos estilo Cisco IOS o IOS-XE antes del despliegue.
+- Al auditar configuración generada por scripts o plantillas.
+- Al buscar comandos peligrosos, direcciones IP duplicadas o solapamientos de subredes.
+- Al comprobar si hay ACL, route-maps, prefix-lists o políticas de línea referenciadas
+  pero no definidas.
+- Al construir scripts ligeros de pre-vuelo para automatización de red.
+
+## Cómo funciona
+
+Trata la validación de configuración como evidencia por capas, no como un parser
+completo. Las comprobaciones con regex sirven para advertencias de pre-vuelo,
+pero la aprobación final sigue requiriendo que un ingeniero de red revise la
+intención, la sintaxis de la plataforma y los pasos de rollback.
+
+Valida en este orden:
+
+1. Comandos destructivos.
+2. Exposición de credenciales y del plano de gestión.
+3. Direcciones duplicadas y subredes solapadas.
+4. Referencias huérfanas a ACL, route-maps, prefix-lists e interfaces.
+5. Higiene operativa: NTP, timestamps, logging remoto y banners.
+
+## Detección de comandos peligrosos
+
+```python
+import re
+
+DANGEROUS_PATTERNS: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"\breload\b", re.I), "reload provoca una caída del servicio"),
+    (re.compile(r"\berase\s+(startup|nvram|flash)", re.I), "borra almacenamiento persistente"),
+    (re.compile(r"\bformat\b", re.I), "formatea un sistema de archivos del dispositivo"),
+    (re.compile(r"\bno\s+router\s+(bgp|ospf|eigrp)\b", re.I), "elimina un proceso de enrutamiento"),
+    (re.compile(r"\bno\s+interface\s+\S+", re.I), "elimina configuración de una interfaz"),
+    (re.compile(r"\baaa\s+new-model\b", re.I), "cambia el comportamiento de autenticación"),
+    (re.compile(r"\bcrypto\s+key\s+(zeroize|generate)\b", re.I), "cambia las llaves SSH del dispositivo"),
+]
+
+def find_dangerous_commands(lines: list[str]) -> list[dict[str, str | int]]:
+    findings = []
+    for line_number, line in enumerate(lines, start=1):
+        stripped = line.strip()
+        for pattern, reason in DANGEROUS_PATTERNS:
+            if pattern.search(stripped):
+                findings.append({
+                    "line": line_number,
+                    "command": stripped,
+                    "reason": reason,
+                })
+    return findings
+```
+
+## IPs duplicadas y solapamiento de subredes
+
+```python
+import ipaddress
+import re
+from collections import Counter
+
+IP_ADDRESS_RE = re.compile(
+    r"^\s*ip address\s+"
+    r"(?P<ip>\d{1,3}(?:\.\d{1,3}){3})\s+"
+    r"(?P<mask>\d{1,3}(?:\.\d{1,3}){3})\b",
+    re.I | re.M,
+)
+
+def extract_interfaces(config: str) -> list[dict[str, str]]:
+    results = []
+    current = None
+    for line in config.splitlines():
+        if line.startswith("interface "):
+            current = line.split(maxsplit=1)[1]
+            continue
+        match = IP_ADDRESS_RE.match(line)
+        if current and match:
+            ip = match.group("ip")
+            mask = match.group("mask")
+            network = ipaddress.ip_interface(f"{ip}/{mask}").network
+            results.append({"interface": current, "ip": ip, "network": str(network)})
+    return results
+
+def find_duplicate_ips(config: str) -> list[str]:
+    ips = [entry["ip"] for entry in extract_interfaces(config)]
+    counts = Counter(ips)
+    return sorted(ip for ip, count in counts.items() if count > 1)
+
+def find_subnet_overlaps(config: str) -> list[tuple[str, str]]:
+    networks = [ipaddress.ip_network(entry["network"]) for entry in extract_interfaces(config)]
+    overlaps = []
+    for index, left in enumerate(networks):
+        for right in networks[index + 1:]:
+            if left.overlaps(right):
+                overlaps.append((str(left), str(right)))
+    return overlaps
+```
+
+## Comprobaciones del plano de gestión
+
+Parsea los bloques VTY por sección para que las comprobaciones de access-class no
+se derramen sobre líneas no relacionadas.
+
+```python
+import re
+
+def iter_blocks(config: str, starts_with: str) -> list[str]:
+    blocks = []
+    current: list[str] = []
+    for line in config.splitlines():
+        if line.startswith(starts_with):
+            if current:
+                blocks.append("\n".join(current))
+            current = [line]
+            continue
+        if current:
+            if line and not line.startswith(" "):
+                blocks.append("\n".join(current))
+                current = []
+            else:
+                current.append(line)
+    if current:
+        blocks.append("\n".join(current))
+    return blocks
+
+def check_vty_blocks(config: str) -> list[str]:
+    issues = []
+    for block in iter_blocks(config, "line vty"):
+        if re.search(r"transport\s+input\s+.*telnet", block, re.I):
+            issues.append("Las líneas VTY permiten Telnet; exige solo SSH.")
+        if not re.search(r"\baccess-class\s+\S+\s+in\b", block, re.I):
+            issues.append("El bloque VTY no restringe el origen con un access-class entrante.")
+        if not re.search(r"\bexec-timeout\s+\d+\s+\d+\b", block, re.I):
+            issues.append("El bloque VTY no tiene un exec-timeout explícito.")
+    return issues
+```
+
+## Comprobaciones de higiene de seguridad
+
+```python
+SECURITY_PATTERNS = [
+    (re.compile(r"\bsnmp-server community\s+(public|private)\b", re.I),
+     "community SNMP por defecto configurada"),
+    (re.compile(r"\bsnmp-server community\s+\S+", re.I),
+     "community string SNMPv2 configurada; prefiere SNMPv3 authPriv"),
+    (re.compile(r"\bip ssh version 1\b", re.I),
+     "SSH versión 1 habilitado"),
+    (re.compile(r"\benable password\b", re.I),
+     "hay un enable password; usa enable secret"),
+    (re.compile(r"\busername\s+\S+\s+password\b", re.I),
+     "un usuario local usa password en lugar de secret"),
+]
+
+BEST_PRACTICE_PATTERNS = [
+    (re.compile(r"\bntp server\b", re.I), "servidor NTP"),
+    (re.compile(r"\bservice timestamps\b", re.I), "timestamps en los logs"),
+    (re.compile(r"\blogging\s+\S+", re.I), "destino o buffer de logging"),
+    (re.compile(r"\bsnmp-server group\s+\S+\s+v3\s+priv\b", re.I), "grupo SNMPv3 authPriv"),
+    (re.compile(r"\bbanner\s+(login|motd)\b", re.I), "banner de inicio de sesión"),
+]
+
+def check_security(config: str) -> list[str]:
+    return [message for pattern, message in SECURITY_PATTERNS if pattern.search(config)]
+
+def check_missing_hygiene(config: str) -> list[str]:
+    return [
+        f"Falta {description}"
+        for pattern, description in BEST_PRACTICE_PATTERNS
+        if not pattern.search(config)
+    ]
+```
+
+## Ejemplos
+
+### Pre-vuelo de ventana de cambio
+
+1. Ejecuta las comprobaciones de comandos peligrosos sobre el fragmento exacto que se va a pegar.
+2. Ejecuta las comprobaciones de IPs duplicadas y solapamiento de subredes contra la configuración candidata completa.
+3. Confirma que toda ACL, route-map y prefix-list referenciada existe.
+4. Confirma los comandos de rollback y el acceso fuera de banda antes de cualquier
+   cambio del plano de gestión.
+
+### Pre-vuelo de automatización
+
+Usa la validación como compuerta bloqueante antes de que Netmiko, NAPALM, Ansible
+o la API del fabricante empujen una configuración generada. Falla en cerrado ante
+comandos peligrosos y credenciales. Advierte sobre brechas de buenas prácticas
+que estén fuera del alcance del cambio.
+
+## Antipatrones
+
+- Tratar la validación con regex como un parser del dispositivo.
+- Aplicar configuración generada sin un diff de simulación (dry-run).
+- Recomendar community strings SNMPv2 como requisito de monitoreo.
+- Comprobar bloques VTY con regex que pueden abarcar secciones no relacionadas por accidente.
+- Probar el comportamiento del firewall deshabilitando ACL en lugar de leer contadores y logs.
+
+## Ver también
+
+- Agente: `revisor-config-red`
+- Agente: `diagnosticador-redes`
+- Skill: `salud-interfaces-red`

package/vendor/theus-arsenal/skills/verificacion-django/SKILL.md

@@ -0,0 +1,470 @@
+---
+name: verificacion-django
+description: Bucle de verificación para proyectos Django; migraciones, linting, tests con
+  cobertura, escaneos de seguridad y comprobaciones de preparación para el despliegue antes
+  de un release o un PR.
+---
+
+# Bucle de verificación Django
+
+Ejecútalo antes de abrir un PR, después de cambios importantes y antes de desplegar, para garantizar la calidad y seguridad de la aplicación Django.
+
+## Cuándo usarla
+
+- Antes de abrir un pull request en un proyecto Django.
+- Después de cambios importantes en modelos, actualizaciones de migraciones o upgrades de dependencias.
+- Verificación previa al despliegue en staging o producción.
+- Para ejecutar el pipeline completo: entorno → lint → tests → seguridad → preparación de despliegue.
+- Para validar la seguridad de las migraciones y la cobertura de tests.
+
+## Fase 1: verificación del entorno
+
+```bash
+# Verifica la versión de Python
+python --version  # Debe coincidir con los requisitos del proyecto
+
+# Comprueba el entorno virtual
+which python
+pip list --outdated
+
+# Verifica las variables de entorno
+python -c "import os; import environ; print('DJANGO_SECRET_KEY definida' if os.environ.get('DJANGO_SECRET_KEY') else 'FALTA: DJANGO_SECRET_KEY')"
+```
+
+Si el entorno está mal configurado, detente y corrígelo antes de seguir.
+
+## Fase 2: calidad de código y formato
+
+```bash
+# Chequeo de tipos
+mypy . --config-file pyproject.toml
+
+# Linting con ruff
+ruff check . --fix
+
+# Formato con black
+black . --check
+black .  # Corrección automática
+
+# Orden de imports
+isort . --check-only
+isort .  # Corrección automática
+
+# Chequeos específicos de Django
+python manage.py check --deploy
+```
+
+Problemas comunes:
+- Anotaciones de tipo faltantes en funciones públicas.
+- Violaciones de formato PEP 8.
+- Imports sin ordenar.
+- Configuración de debug olvidada en los settings de producción.
+
+## Fase 3: migraciones
+
+```bash
+# Busca migraciones sin aplicar
+python manage.py showmigrations
+
+# Detecta migraciones faltantes
+python manage.py makemigrations --check
+
+# Simulación de la aplicación de migraciones
+python manage.py migrate --plan
+
+# Aplica migraciones (entorno de prueba)
+python manage.py migrate
+
+# Comprueba conflictos de migraciones
+python manage.py makemigrations --merge  # Solo si existen conflictos
+```
+
+Reporta:
+- Número de migraciones pendientes.
+- Conflictos de migraciones, si los hay.
+- Cambios de modelos sin migración asociada.
+
+## Fase 4: tests + cobertura
+
+```bash
+# Ejecuta todos los tests con pytest
+pytest --cov=apps --cov-report=html --cov-report=term-missing --reuse-db
+
+# Tests de una app concreta
+pytest apps/users/tests/
+
+# Con marcadores
+pytest -m "not slow"  # Omite los tests lentos
+pytest -m integration  # Solo tests de integración
+
+# Informe de cobertura
+open htmlcov/index.html
+```
+
+Reporta:
+- Total de tests: X aprobados, Y fallidos, Z omitidos.
+- Cobertura global: XX %.
+- Desglose de cobertura por app.
+
+Objetivos de cobertura:
+
+| Componente | Objetivo |
+|-----------|--------|
+| Modelos | 90 %+ |
+| Serializers | 85 %+ |
+| Vistas | 80 %+ |
+| Servicios | 90 %+ |
+| Global | 80 %+ |
+
+## Fase 5: escaneo de seguridad
+
+```bash
+# Vulnerabilidades en dependencias
+pip-audit
+safety check --full-report
+
+# Chequeos de seguridad de Django
+python manage.py check --deploy
+
+# Linter de seguridad Bandit
+bandit -r . -f json -o bandit-report.json
+
+# Escaneo de secretos (si gitleaks está instalado)
+gitleaks detect --source . --verbose
+
+# Verificación de variables de entorno
+python -c "from django.core.exceptions import ImproperlyConfigured; from django.conf import settings; settings.DEBUG"
+```
+
+Reporta:
+- Dependencias vulnerables encontradas.
+- Problemas de configuración de seguridad.
+- Secretos hardcodeados detectados.
+- Estado del modo DEBUG (debe ser False en producción).
+
+## Fase 6: comandos de gestión de Django
+
+```bash
+# Comprueba problemas en los modelos
+python manage.py check
+
+# Recolecta archivos estáticos
+python manage.py collectstatic --noinput --clear
+
+# Crea un superusuario (si los tests lo necesitan)
+echo "from apps.users.models import User; User.objects.create_superuser('admin@example.com', 'admin')" | python manage.py shell
+
+# Integridad de la base de datos
+python manage.py check --database default
+
+# Verificación de caché (si usas Redis)
+python -c "from django.core.cache import cache; cache.set('test', 'value', 10); print(cache.get('test'))"
+```
+
+## Fase 7: chequeos de rendimiento
+
+```bash
+# Salida de Django Debug Toolbar (busca consultas N+1)
+# Ejecuta en modo dev con DEBUG=True y visita una página
+# Revisa consultas duplicadas en el panel SQL
+
+# Análisis de número de consultas
+django-admin debugsqlshell  # Si django-debug-sqlshell está instalado
+
+# Busca índices faltantes
+python manage.py shell << EOF
+from django.db import connection
+with connection.cursor() as cursor:
+    cursor.execute("SELECT table_name, index_name FROM information_schema.statistics WHERE table_schema = 'public'")
+    print(cursor.fetchall())
+EOF
+```
+
+Reporta:
+- Número de consultas por página (idealmente < 50 en páginas típicas).
+- Índices de base de datos faltantes.
+- Consultas duplicadas detectadas.
+
+## Fase 8: assets estáticos
+
+```bash
+# Comprueba dependencias npm (si aplica)
+npm audit
+npm audit fix
+
+# Compila los archivos estáticos (si usas webpack/vite)
+npm run build
+
+# Verifica los archivos estáticos
+ls -la staticfiles/
+python manage.py findstatic css/style.css
+```
+
+## Fase 9: revisión de configuración
+
+```python
+# Ejecuta en el shell de Python para verificar los settings
+python manage.py shell << EOF
+from django.conf import settings
+import os
+
+# Chequeos críticos
+checks = {
+    'DEBUG es False': not settings.DEBUG,
+    'SECRET_KEY definida': bool(settings.SECRET_KEY and len(settings.SECRET_KEY) > 30),
+    'ALLOWED_HOSTS definido': len(settings.ALLOWED_HOSTS) > 0,
+    'HTTPS habilitado': getattr(settings, 'SECURE_SSL_REDIRECT', False),
+    'HSTS habilitado': getattr(settings, 'SECURE_HSTS_SECONDS', 0) > 0,
+    'Base de datos configurada': settings.DATABASES['default']['ENGINE'] != 'django.db.backends.sqlite3',
+}
+
+for check, result in checks.items():
+    status = '✓' if result else '✗'
+    print(f"{status} {check}")
+EOF
+```
+
+## Fase 10: configuración de logging
+
+```bash
+# Prueba la salida de logs
+python manage.py shell << EOF
+import logging
+logger = logging.getLogger('django')
+logger.warning('Mensaje de advertencia de prueba')
+logger.error('Mensaje de error de prueba')
+EOF
+
+# Revisa los archivos de log (si están configurados)
+tail -f /var/log/django/django.log
+```
+
+## Fase 11: documentación de la API (si usas DRF)
+
+```bash
+# Genera el esquema
+python manage.py generateschema --format openapi-json > schema.json
+
+# Valida el esquema
+# Comprueba que schema.json sea JSON válido
+python -c "import json; json.load(open('schema.json'))"
+
+# Accede a Swagger UI (si usas drf-yasg)
+# Visita http://localhost:8000/swagger/ en el navegador
+```
+
+## Fase 12: revisión del diff
+
+```bash
+# Estadísticas del diff
+git diff --stat
+
+# Cambios reales
+git diff
+
+# Archivos modificados
+git diff --name-only
+
+# Busca problemas comunes
+git diff | grep -i "todo\|fixme\|hack\|xxx"
+git diff | grep "print("  # Sentencias de depuración
+git diff | grep "DEBUG = True"  # Modo debug
+git diff | grep "import pdb"  # Depurador
+```
+
+Lista de verificación:
+- Sin sentencias de depuración (print, pdb, breakpoint()).
+- Sin comentarios TODO/FIXME en código crítico.
+- Sin secretos ni credenciales hardcodeadas.
+- Migraciones incluidas para los cambios de modelos.
+- Cambios de configuración documentados.
+- Manejo de errores presente en llamadas externas.
+- Gestión de transacciones donde corresponda.
+
+## Plantilla de salida
+
+```
+INFORME DE VERIFICACIÓN DJANGO
+==============================
+
+Fase 1: Entorno
+  ✓ Python 3.11.5
+  ✓ Entorno virtual activo
+  ✓ Variables de entorno definidas
+
+Fase 2: Calidad de código
+  ✓ mypy: sin errores de tipos
+  ✗ ruff: 3 problemas encontrados (corregidos automáticamente)
+  ✓ black: sin problemas de formato
+  ✓ isort: imports ordenados
+  ✓ manage.py check: sin problemas
+
+Fase 3: Migraciones
+  ✓ Sin migraciones pendientes
+  ✓ Sin conflictos de migraciones
+  ✓ Todos los modelos tienen migración
+
+Fase 4: Tests + cobertura
+  Tests: 247 aprobados, 0 fallidos, 5 omitidos
+  Cobertura:
+    Global: 87 %
+    users: 92 %
+    products: 89 %
+    orders: 85 %
+    payments: 91 %
+
+Fase 5: Seguridad
+  ✗ pip-audit: 2 vulnerabilidades encontradas (corrección requerida)
+  ✓ safety check: sin problemas
+  ✓ bandit: sin problemas de seguridad
+  ✓ Sin secretos detectados
+  ✓ DEBUG = False
+
+Fase 6: Comandos de Django
+  ✓ collectstatic completado
+  ✓ Integridad de base de datos OK
+  ✓ Backend de caché accesible
+
+Fase 7: Rendimiento
+  ✓ Sin consultas N+1 detectadas
+  ✓ Índices de base de datos configurados
+  ✓ Número de consultas aceptable
+
+Fase 8: Assets estáticos
+  ✓ npm audit: sin vulnerabilidades
+  ✓ Assets compilados correctamente
+  ✓ Archivos estáticos recolectados
+
+Fase 9: Configuración
+  ✓ DEBUG = False
+  ✓ SECRET_KEY configurada
+  ✓ ALLOWED_HOSTS definido
+  ✓ HTTPS habilitado
+  ✓ HSTS habilitado
+  ✓ Base de datos configurada
+
+Fase 10: Logging
+  ✓ Logging configurado
+  ✓ Archivos de log escribibles
+
+Fase 11: Documentación de API
+  ✓ Esquema generado
+  ✓ Swagger UI accesible
+
+Fase 12: Revisión del diff
+  Archivos modificados: 12
+  +450, -120 líneas
+  ✓ Sin sentencias de depuración
+  ✓ Sin secretos hardcodeados
+  ✓ Migraciones incluidas
+
+RECOMENDACIÓN: ADVERTENCIA: corrige las vulnerabilidades de pip-audit antes de desplegar
+
+PRÓXIMOS PASOS:
+1. Actualizar las dependencias vulnerables
+2. Reejecutar el escaneo de seguridad
+3. Desplegar a staging para la prueba final
+```
+
+## Lista de verificación pre-despliegue
+
+- [ ] Todos los tests pasan.
+- [ ] Cobertura ≥ 80 %.
+- [ ] Sin vulnerabilidades de seguridad.
+- [ ] Sin migraciones pendientes.
+- [ ] DEBUG = False en los settings de producción.
+- [ ] SECRET_KEY correctamente configurada.
+- [ ] ALLOWED_HOSTS bien definido.
+- [ ] Backups de base de datos habilitados.
+- [ ] Archivos estáticos recolectados y servidos.
+- [ ] Logging configurado y funcionando.
+- [ ] Monitoreo de errores (Sentry u otro) configurado.
+- [ ] CDN configurado (si aplica).
+- [ ] Backend de caché/Redis configurado.
+- [ ] Workers de Celery en ejecución (si aplica).
+- [ ] HTTPS/SSL configurado.
+- [ ] Variables de entorno documentadas.
+
+## Integración continua
+
+### Ejemplo con GitHub Actions
+
+```yaml
+# .github/workflows/verificacion-django.yml
+name: Verificacion Django
+
+on: [push, pull_request]
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:14
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Configurar Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+
+      - name: Cachear pip
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+
+      - name: Instalar dependencias
+        run: |
+          pip install -r requirements.txt
+          pip install ruff black mypy pytest pytest-django pytest-cov bandit safety pip-audit
+
+      - name: Chequeos de calidad de código
+        run: |
+          ruff check .
+          black . --check
+          isort . --check-only
+          mypy .
+
+      - name: Escaneo de seguridad
+        run: |
+          bandit -r . -f json -o bandit-report.json
+          safety check --full-report
+          pip-audit
+
+      - name: Ejecutar tests
+        env:
+          DATABASE_URL: postgres://postgres:postgres@localhost:5432/test
+          DJANGO_SECRET_KEY: test-secret-key
+        run: |
+          pytest --cov=apps --cov-report=xml --cov-report=term-missing
+
+      - name: Subir cobertura
+        uses: codecov/codecov-action@v3
+```
+
+## Referencia rápida
+
+| Chequeo | Comando |
+|-------|---------|
+| Entorno | `python --version` |
+| Tipos | `mypy .` |
+| Linting | `ruff check .` |
+| Formato | `black . --check` |
+| Migraciones | `python manage.py makemigrations --check` |
+| Tests | `pytest --cov=apps` |
+| Seguridad | `pip-audit && bandit -r .` |
+| Chequeo Django | `python manage.py check --deploy` |
+| Collectstatic | `python manage.py collectstatic --noinput` |
+| Estadísticas del diff | `git diff --stat` |
+
+Recuerda: la verificación automatizada detecta problemas comunes, pero no sustituye la revisión de código manual ni las pruebas en un entorno de staging.