@the-bearded-bear/claude-craft 3.0.0

package/Dev/i18n/es/Python/commands/check-code-quality.md

@@ -0,0 +1,174 @@
+---
+description: Verificar Calidad del Código Python
+argument-hint: [arguments]
+---
+
+# Verificar Calidad del Código Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: ruta al proyecto a analizar)
+
+## MISIÓN
+
+Realizar una auditoría completa de calidad del código del proyecto Python verificando cumplimiento de PEP8, tipado, legibilidad y mejores prácticas definidas en las reglas del proyecto.
+
+### Paso 1: Estándares de Codificación PEP8
+
+Verificar cumplimiento de convenciones de Python:
+- [ ] Nomenclatura: snake_case para funciones/variables, PascalCase para clases
+- [ ] Indentación: 4 espacios (sin tabs)
+- [ ] Longitud de línea: máximo 88 caracteres (Black)
+- [ ] Importaciones: organizadas (stdlib, third-party, local) y ordenadas
+- [ ] Espacios: alrededor de operadores, después de comas
+- [ ] Docstrings: presentes para módulos, clases, funciones públicas
+
+**Comando**: Ejecutar `docker run --rm -v $(pwd):/app python:3.11 python -m flake8 /app --max-line-length=88`
+
+**Referencia**: `rules/03-coding-standards.md` sección "Cumplimiento de PEP 8"
+
+### Paso 2: Anotaciones de Tipo y MyPy
+
+Verificar uso de tipado estático:
+- [ ] Type hints en todos los parámetros de función
+- [ ] Type hints en valores de retorno
+- [ ] Anotaciones para atributos de clase
+- [ ] Uso de `typing` para tipos complejos (Optional, Union, List, Dict)
+- [ ] Sin errores MyPy en modo estricto
+
+**Comando**: Ejecutar `docker run --rm -v $(pwd):/app python:3.11 python -m mypy /app --strict`
+
+**Referencia**: `rules/03-coding-standards.md` sección "Anotaciones de Tipo"
+
+### Paso 3: Linting con Ruff
+
+Analizar código con Ruff (reemplaza Flake8, isort, pydocstyle):
+- [ ] Sin importaciones no usadas
+- [ ] Sin variables no usadas
+- [ ] Sin código muerto (código inalcanzable)
+- [ ] Complejidad ciclomática aceptable (<10)
+- [ ] Reglas de seguridad respetadas (reglas S)
+
+**Comando**: Ejecutar `docker run --rm -v $(pwd):/app python:3.11 pip install ruff && ruff check /app`
+
+**Referencia**: `rules/06-tooling.md` sección "Linting y Formato"
+
+### Paso 4: Formato con Black
+
+Verificar consistencia de formato:
+- [ ] Código formateado con Black
+- [ ] Configuración de Black en pyproject.toml
+- [ ] Sin diferencias después de `black --check`
+- [ ] Longitud de línea consistente (88 caracteres)
+
+**Comando**: Ejecutar `docker run --rm -v $(pwd):/app python:3.11 pip install black && black --check /app`
+
+**Referencia**: `rules/06-tooling.md` sección "Formato de Código"
+
+### Paso 5: Principios KISS, DRY, YAGNI
+
+Analizar simplicidad y claridad del código:
+- [ ] Funciones cortas (<20 líneas idealmente)
+- [ ] Sin duplicación de código (DRY)
+- [ ] Sin sobre-ingeniería (YAGNI)
+- [ ] Nomenclatura explícita y auto-documentada
+- [ ] Nivel único de abstracción por función
+- [ ] Retornos tempranos para reducir complejidad
+
+**Referencia**: `rules/05-kiss-dry-yagni.md`
+
+### Paso 6: Comentarios y Documentación
+
+Evaluar calidad de documentación:
+- [ ] Docstrings estilo Google o NumPy
+- [ ] Comentarios solo para "por qué", no "qué"
+- [ ] README.md completo con setup y uso
+- [ ] Sin código comentado (usar git)
+- [ ] Documentación de decisiones arquitectónicas importantes
+
+**Referencia**: `rules/03-coding-standards.md` sección "Documentación"
+
+### Paso 7: Manejo de Errores
+
+Verificar robustez del código:
+- [ ] Excepciones específicas (no Exception genérica)
+- [ ] Sin `pass` silencioso en except
+- [ ] Mensajes de error informativos
+- [ ] Validación de entrada de usuario
+- [ ] Gestión apropiada de recursos (gestores de contexto)
+
+**Referencia**: `rules/03-coding-standards.md` sección "Manejo de Errores"
+
+### Paso 8: Calcular Puntuación
+
+Atribución de puntos (sobre 25):
+- PEP8 y formato: 5 puntos
+- Type hints y MyPy: 5 puntos
+- Linting con Ruff: 4 puntos
+- KISS/DRY/YAGNI: 4 puntos
+- Documentación: 4 puntos
+- Manejo de errores: 3 puntos
+
+## FORMATO DE SALIDA
+
+```
+AUDITORÍA DE CALIDAD DEL CÓDIGO PYTHON
+================================
+
+PUNTUACIÓN GENERAL: XX/25
+
+FORTALEZAS:
+- [Lista de buenas prácticas observadas]
+
+MEJORAS:
+- [Lista de mejoras menores]
+
+PROBLEMAS CRÍTICOS:
+- [Lista de violaciones graves de estándares]
+
+DETALLES POR CATEGORÍA:
+
+1. PEP8 Y FORMATO (XX/5)
+   Estado: [Cumplimiento de estándares Python]
+   Errores Flake8: XX
+   Diferencias Black: XX archivos
+
+2. ANOTACIONES DE TIPO (XX/5)
+   Estado: [Cobertura de tipado estático]
+   Errores MyPy: XX
+   Cobertura: XX%
+
+3. LINTING RUFF (XX/4)
+   Estado: [Calidad del código]
+   Advertencias: XX
+   Importaciones No Usadas: XX
+   Complejidad Máxima: XX
+
+4. KISS/DRY/YAGNI (XX/4)
+   Estado: [Simplicidad y claridad]
+   Funciones >20 líneas: XX
+   Código Duplicado: XX instancias
+
+5. DOCUMENTACIÓN (XX/4)
+   Estado: [Calidad de documentación]
+   Docstrings Faltantes: XX
+   Cobertura: XX%
+
+6. MANEJO DE ERRORES (XX/3)
+   Estado: [Robustez del código]
+   Excepciones Genéricas: XX
+   `except pass`: XX
+
+TOP 3 ACCIONES PRIORITARIAS:
+1. [Acción más crítica para mejorar calidad]
+2. [Segunda acción prioritaria]
+3. [Tercera acción prioritaria]
+```
+
+## NOTAS
+
+- Ejecutar todas las herramientas de linting disponibles en el proyecto
+- Usar Docker para abstraerse del entorno local
+- Proporcionar ejemplos de archivos/líneas problemáticas
+- Sugerir correcciones automatizables (hooks pre-commit)
+- Priorizar victorias rápidas (auto formato) vs refactorización profunda

package/Dev/i18n/es/Python/commands/check-compliance.md

@@ -0,0 +1,199 @@
+---
+description: Verificación Completa de Cumplimiento Python
+argument-hint: [arguments]
+---
+
+# Verificación Completa de Cumplimiento Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: ruta al proyecto a analizar)
+
+## MISIÓN
+
+Realizar una auditoría completa de cumplimiento del proyecto Python orquestando las 4 verificaciones principales: Arquitectura, Calidad del Código, Pruebas y Seguridad. Producir un informe consolidado con una puntuación general sobre 100 puntos.
+
+### Paso 1: Preparación de Auditoría
+
+Preparar entorno de auditoría:
+- [ ] Identificar ruta del proyecto a auditar
+- [ ] Verificar presencia de archivos de configuración (pyproject.toml, requirements.txt)
+- [ ] Listar directorios principales (src/, tests/, etc.)
+- [ ] Identificar estructura del proyecto
+
+**Nota**: Si se proporciona $ARGUMENTS, usarlo como ruta del proyecto, de lo contrario usar directorio actual.
+
+### Paso 2: Auditoría de Arquitectura (25 puntos)
+
+Ejecutar verificación completa de arquitectura:
+
+**Comando**: Usar comando slash `/check-architecture` o seguir pasos en `check-architecture.md` manualmente
+
+**Criterios Evaluados**:
+- Estructura y separación de capas (6 pts)
+- Respeto de dependencias (6 pts)
+- Ports and Adapters (4 pts)
+- Modelado de dominio (4 pts)
+- Casos de Uso y Servicios (3 pts)
+- Principios SOLID (2 pts)
+
+**Referencia**: `claude-commands/python/check-architecture.md`
+
+### Paso 3: Auditoría de Calidad del Código (25 puntos)
+
+Ejecutar verificación de calidad del código:
+
+**Comando**: Usar comando slash `/check-code-quality` o seguir pasos en `check-code-quality.md` manualmente
+
+**Criterios Evaluados**:
+- PEP8 y formato (5 pts)
+- Type hints y MyPy (5 pts)
+- Linting con Ruff (4 pts)
+- KISS/DRY/YAGNI (4 pts)
+- Documentación (4 pts)
+- Manejo de errores (3 pts)
+
+**Referencia**: `claude-commands/python/check-code-quality.md`
+
+### Paso 4: Auditoría de Pruebas (25 puntos)
+
+Ejecutar verificación de pruebas:
+
+**Comando**: Usar comando slash `/check-testing` o seguir pasos en `check-testing.md` manualmente
+
+**Criterios Evaluados**:
+- Cobertura de código (7 pts)
+- Pruebas unitarias (6 pts)
+- Pruebas de integración (4 pts)
+- Calidad de aserciones (3 pts)
+- Fixtures y organización (3 pts)
+- Rendimiento (2 pts)
+
+**Referencia**: `claude-commands/python/check-testing.md`
+
+### Paso 5: Auditoría de Seguridad (25 puntos)
+
+Ejecutar verificación de seguridad:
+
+**Comando**: Usar comando slash `/check-security` o seguir pasos en `check-security.md` manualmente
+
+**Criterios Evaluados**:
+- Escaneo Bandit (6 pts)
+- Secretos y credenciales (5 pts)
+- Validación de entrada (4 pts)
+- Dependencias seguras (4 pts)
+- Manejo de errores (3 pts)
+- Auth/Authz (2 pts)
+- Inyecciones (1 pt)
+
+**Referencia**: `claude-commands/python/check-security.md`
+
+### Paso 6: Consolidación y Puntuación Global
+
+Calcular puntuación general y producir informe consolidado:
+- [ ] Sumar las 4 puntuaciones (máx 100 puntos)
+- [ ] Identificar categorías críticas (<50%)
+- [ ] Listar todos los problemas críticos transversales
+- [ ] Priorizar acciones por impacto/esfuerzo
+- [ ] Producir informe consolidado final
+
+**Escala de Calificación**:
+- 90-100: Excelente - Proyecto de referencia
+- 75-89: Muy Bueno - Algunas mejoras menores
+- 60-74: Aceptable - Requiere mejoras
+- 40-59: Insuficiente - Requiere refactorización mayor
+- 0-39: Crítico - Necesaria revisión completa
+
+### Paso 7: Recomendaciones y Plan de Acción
+
+Producir recomendaciones finales:
+- [ ] Identificar top 3 acciones prioritarias entre todas las categorías
+- [ ] Estimar esfuerzo (Bajo/Medio/Alto) para cada acción
+- [ ] Estimar impacto (Bajo/Medio/Alto) para cada acción
+- [ ] Proponer orden de implementación
+- [ ] Sugerir victorias rápidas (alta relación impacto/esfuerzo)
+
+## FORMATO DE SALIDA
+
+```
+AUDITORÍA DE CUMPLIMIENTO PYTHON - INFORME COMPLETO
+=============================================
+
+PUNTUACIÓN GENERAL: XX/100
+
+NIVEL DE CUMPLIMIENTO: [Excelente/Muy Bueno/Aceptable/Insuficiente/Crítico]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+PUNTUACIONES POR CATEGORÍA:
+
+ARQUITECTURA       : XX/25  [██████████░░░░░░░░░░] XX%
+CALIDAD DEL CÓDIGO : XX/25  [██████████░░░░░░░░░░] XX%
+PRUEBAS            : XX/25  [██████████░░░░░░░░░░] XX%
+SEGURIDAD          : XX/25  [██████████░░░░░░░░░░] XX%
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+FORTALEZAS GENERALES:
+1. [Fortaleza identificada en múltiples categorías]
+2. [Otra fortaleza importante]
+3. [Tercera fortaleza]
+
+MEJORAS GENERALES:
+1. [Mejora transversal menor]
+2. [Otra mejora recomendada]
+3. [Tercera mejora]
+
+PROBLEMAS CRÍTICOS:
+1. [Problema crítico #1 - categoría afectada]
+2. [Problema crítico #2 - categoría afectada]
+3. [Problema crítico #3 - categoría afectada]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+TOP 3 ACCIONES PRIORITARIAS (TODAS LAS CATEGORÍAS):
+
+1. CRÍTICO - [Acción #1]
+   Categoría  : [Arquitectura/Calidad/Pruebas/Seguridad]
+   Impacto    : [Alto/Medio/Bajo]
+   Esfuerzo   : [Alto/Medio/Bajo]
+   Prioridad  : INMEDIATA
+
+2. IMPORTANTE - [Acción #2]
+   [Mismo formato...]
+
+3. RECOMENDADO - [Acción #3]
+   [Mismo formato...]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+VICTORIAS RÁPIDAS (Alto Impacto / Bajo Esfuerzo):
+
+- [Victoria rápida #1] - Categoría: [X] - Impacto: [X] - Esfuerzo: [X]
+- [Victoria rápida #2] - Categoría: [X] - Impacto: [X] - Esfuerzo: [X]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+RESUMEN EJECUTIVO:
+
+[Párrafo resumen sobre estado general del proyecto, fortalezas principales,
+debilidades principales, y trayectoria recomendada para mejorar
+cumplimiento. Mencionar si proyecto está listo para producción,
+requiere correcciones, o necesita refactorización.]
+
+Recomendación General: [Listo para producción / Correcciones menores /
+Refactorización mayor / Revisión completa necesaria]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## NOTAS IMPORTANTES
+
+- Este comando orquesta las 4 auditorías especializadas
+- Usar Docker para todas las herramientas de análisis
+- Proporcionar ejemplos concretos con archivo:línea para cada problema
+- Priorizar acciones según matriz Impacto/Esfuerzo
+- Los problemas de seguridad son SIEMPRE prioridad máxima
+- Proponer correcciones automatizables (scripts, hooks pre-commit)
+- El informe debe ser accionable, no solo descriptivo
+- Adaptar recomendaciones al contexto de negocio del proyecto

package/Dev/i18n/es/Python/commands/check-security.md

@@ -0,0 +1,207 @@
+---
+description: Verificar Seguridad Python
+argument-hint: [arguments]
+---
+
+# Verificar Seguridad Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: ruta al proyecto a analizar)
+
+## MISIÓN
+
+Realizar una auditoría completa de seguridad del proyecto Python identificando vulnerabilidades, secretos expuestos y malas prácticas de seguridad definidas en las reglas del proyecto.
+
+### Paso 1: Análisis de Seguridad con Bandit
+
+Escanear código con Bandit para detectar vulnerabilidades:
+- [ ] Sin contraseñas/secretos codificados en duro
+- [ ] Sin uso de `eval()` o `exec()`
+- [ ] Sin deserialización insegura (pickle)
+- [ ] Sin inyección SQL (ORM o consultas parametrizadas)
+- [ ] Sin inyección de comandos shell
+- [ ] Criptografía segura (no MD5/SHA1)
+
+**Comando**: Ejecutar `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install bandit && bandit -r /app -f json"`
+
+**Referencia**: `rules/06-tooling.md` sección "Análisis de Seguridad"
+
+### Paso 2: Detección de Secretos
+
+Buscar secretos y credenciales en el código:
+- [ ] Sin claves API en código fuente
+- [ ] Sin tokens en archivos
+- [ ] Sin contraseñas en texto plano
+- [ ] Variables de entorno para configuración sensible
+- [ ] .env en .gitignore
+- [ ] .env.example proporcionado (sin valores reales)
+
+**Comando**: Usar grep/buscar para detectar patrones de secretos
+
+**Patrones a buscar**:
+- `password\s*=\s*["'][^"']+["']`
+- `api_key\s*=\s*["'][^"']+["']`
+- `secret\s*=\s*["'][^"']+["']`
+- `token\s*=\s*["'][^"']+["']`
+
+**Referencia**: `rules/03-coding-standards.md` sección "Mejores Prácticas de Seguridad"
+
+### Paso 3: Validación de Entrada de Usuario
+
+Verificar validación y sanitización de datos:
+- [ ] Validación de todas las entradas de usuario
+- [ ] Uso de Pydantic para validación
+- [ ] Sanitización de datos antes de procesarlos
+- [ ] Sin confianza ciega en datos externos
+- [ ] Validación de tipo y formato
+- [ ] Límites en tamaño de entrada
+
+**Referencia**: `rules/03-coding-standards.md` sección "Validación de Entrada"
+
+### Paso 4: Dependencias y Vulnerabilidades
+
+Analizar dependencias para vulnerabilidades conocidas:
+- [ ] Sin dependencias con CVEs críticos
+- [ ] Versiones de librerías actualizadas
+- [ ] requirements.txt con versiones fijadas
+- [ ] Uso de `pip-audit` o `safety`
+- [ ] Sin dependencias obsoletas
+
+**Comando**: Ejecutar `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install pip-audit && pip-audit --requirement /app/requirements.txt"`
+
+**Referencia**: `rules/06-tooling.md` sección "Gestión de Dependencias"
+
+### Paso 5: Manejo de Errores y Logs
+
+Verificar manejo seguro de errores:
+- [ ] Sin stack traces expuestos en producción
+- [ ] Mensajes de error genéricos para usuarios
+- [ ] Logs seguros (sin datos sensibles)
+- [ ] Sin modo debug en producción
+- [ ] Manejo apropiado de excepciones
+- [ ] Registro de eventos de seguridad
+
+**Referencia**: `rules/03-coding-standards.md` sección "Manejo de Errores"
+
+### Paso 6: Autenticación y Autorización
+
+Verificar seguridad de autenticación:
+- [ ] Sin gestión manual de contraseñas (usar bcrypt/argon2)
+- [ ] Tokens JWT con expiración
+- [ ] HTTPS obligatorio para endpoints sensibles
+- [ ] Protección CSRF si aplica
+- [ ] Rate limiting en endpoints sensibles
+- [ ] Validación de permisos (RBAC/ABAC)
+
+**Referencia**: `rules/02-architecture.md` sección "Capa de Seguridad"
+
+### Paso 7: Configuración y Entorno
+
+Analizar configuración de seguridad:
+- [ ] Variables de entorno para secretos
+- [ ] Configuración diferente por entorno (dev/staging/prod)
+- [ ] Sin secretos en docker-compose.yml
+- [ ] Secretos en variables de entorno o vault
+- [ ] .env.example documentado
+- [ ] DEBUG=False en producción
+
+**Referencia**: `rules/06-tooling.md` sección "Configuración de Entorno"
+
+### Paso 8: Inyecciones y XSS
+
+Verificar protección contra inyecciones:
+- [ ] Sin inyección SQL (ORM o consultas parametrizadas)
+- [ ] Escapado de datos en templates
+- [ ] Sin inyección de comandos (subprocess seguro)
+- [ ] Validación de rutas de archivo (path traversal)
+- [ ] Content-Security-Policy si aplicación web
+- [ ] Sanitización de entrada HTML
+
+**Referencia**: `rules/03-coding-standards.md` sección "Mejores Prácticas de Seguridad"
+
+### Paso 9: Calcular Puntuación
+
+Atribución de puntos (sobre 25):
+- Bandit (vulnerabilidades): 6 puntos
+- Secretos y credenciales: 5 puntos
+- Validación de entrada: 4 puntos
+- Dependencias seguras: 4 puntos
+- Manejo de errores: 3 puntos
+- Auth/Authz: 2 puntos
+- Inyección/XSS: 1 punto
+
+## FORMATO DE SALIDA
+
+```
+AUDITORÍA DE SEGURIDAD PYTHON
+================================
+
+PUNTUACIÓN GENERAL: XX/25
+
+FORTALEZAS:
+- [Lista de buenas prácticas de seguridad observadas]
+
+MEJORAS:
+- [Lista de mejoras menores de seguridad]
+
+PROBLEMAS CRÍTICOS:
+- [Lista de vulnerabilidades críticas a corregir INMEDIATAMENTE]
+
+DETALLES POR CATEGORÍA:
+
+1. ESCANEO BANDIT (XX/6)
+   Estado: [Análisis de vulnerabilidades]
+   Problemas Críticos: XX
+   Problemas Medios: XX
+   Problemas Bajos: XX
+
+2. SECRETOS EXPUESTOS (XX/5)
+   Estado: [Detección de secretos]
+   Secretos Codificados: XX
+   Archivos .env Seguros: ✅/❌
+
+3. VALIDACIÓN DE ENTRADA (XX/4)
+   Estado: [Validación y sanitización]
+   Entradas Sin Validar: XX
+   Uso de Pydantic: ✅/❌
+
+4. DEPENDENCIAS (XX/4)
+   Estado: [Vulnerabilidades de dependencias]
+   CVEs Críticos: XX
+   CVEs Medios: XX
+   Dependencias Obsoletas: XX
+
+5. MANEJO DE ERRORES (XX/3)
+   Estado: [Seguridad de errores y logs]
+   Stack Traces Expuestos: XX
+   Datos Sensibles en Logs: XX
+
+6. AUTENTICACIÓN (XX/2)
+   Estado: [Auth/Authz]
+   Hash Seguro: ✅/❌
+   JWT con Expiración: ✅/❌
+
+7. INYECCIONES (XX/1)
+   Estado: [Protección contra inyecciones]
+   Riesgos de Inyección SQL: XX
+   Riesgos de Inyección de Comandos: XX
+
+VULNERABILIDADES CRÍTICAS:
+[Lista detallada de vulnerabilidades a corregir inmediatamente con archivo:línea]
+
+TOP 3 ACCIONES PRIORITARIAS:
+1. [Acción de seguridad más crítica - URGENTE]
+2. [Segunda acción prioritaria - IMPORTANTE]
+3. [Tercera acción prioritaria - RECOMENDADO]
+```
+
+## NOTAS
+
+- Los problemas de seguridad DEBEN tratarse con prioridad absoluta
+- Usar Docker para ejecutar herramientas de seguridad
+- Proporcionar archivo y línea exactos para cada vulnerabilidad
+- Proponer correcciones concretas para cada problema
+- Documentar riesgos e impacto potencial
+- Probar correcciones sugeridas
+- NUNCA commitear secretos en el código