---
name: swl:revisar
description: >
  Ejecuta revisión de código especializada por tecnología. Detecta automáticamente
  el stack del proyecto o acepta argumento explícito. Delega al agente revisor
  correspondiente con el skill de lenguaje cargado. Produce reporte con severidades.
allowed_tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Agent"]
---

# /swl:revisar — Revisión de código por tecnología

Comando unificado de revisión que detecta la tecnología y delega al revisor especializado.
Soporta revisión genérica, por lenguaje, por stack y por archivo específico.

## Uso

```
/swl:revisar                    — Auto-detecta stack y revisa todo
/swl:revisar python             — Revisión Python (FastAPI, Django, patrones)
/swl:revisar java               — Revisión Java (Spring Boot, JPA, streams)
/swl:revisar go                 — Revisión Go (concurrency, error handling, interfaces)
/swl:revisar rust               — Revisión Rust (ownership, unsafe, async)
/swl:revisar csharp             — Revisión C# (ASP.NET Core, EF Core, async)
/swl:revisar kotlin             — Revisión Kotlin (coroutines, Compose, null safety)
/swl:revisar swift              — Revisión Swift (SwiftUI, actors, concurrency)
/swl:revisar php                — Revisión PHP (Laravel, Eloquent, seguridad)
/swl:revisar nextjs             — Revisión Next.js (RSC, Server Actions, caching)
/swl:revisar react              — Revisión React (hooks, state, performance)
/swl:revisar angular            — Revisión Angular (signals, standalone, OnPush)
/swl:revisar typescript         — Revisión TypeScript (tipos, patrones, testing)
/swl:revisar sql                — Revisión SQL/PostgreSQL (queries, indices, N+1)
/swl:revisar seguridad          — Revisión de seguridad OWASP (todos los lenguajes)
/swl:revisar <archivo>          — Revisa un archivo específico (detecta lenguaje por extensión)
```

## Paso 0 — Detección de tecnología

Si no se proporciona argumento, detectar automáticamente:

```bash
ls package.json pyproject.toml requirements.txt go.mod Cargo.toml \
   *.csproj *.sln build.gradle.kts Package.swift composer.json 2>/dev/null
```

Reglas de detección:
- `package.json` con `"next"` → nextjs
- `package.json` con `"@angular/core"` → angular
- `package.json` con `"react"` (sin next ni angular) → react
- `package.json` sin frameworks conocidos → typescript
- `pyproject.toml` o `requirements.txt` → python
- `go.mod` → go
- `Cargo.toml` → rust
- `*.csproj` o `*.sln` → csharp
- `build.gradle.kts` → kotlin
- `Package.swift` → swift
- `composer.json` → php
- Múltiples detectados → revisión en paralelo (ver Paso 3b)

Si se proporciona un archivo como argumento, detectar por extension:
`.py` → python | `.go` → go | `.rs` → rust | `.cs` → csharp |
`.kt` → kotlin | `.swift` → swift | `.php` → php |
`.ts` / `.tsx` → typescript | `.sql` → sql |
`.js` / `.jsx` → typescript

## Paso 1 — Determinar alcance

```bash
# Archivos cambiados respecto a main (preferido)
git diff --name-only main...HEAD 2>/dev/null

# O archivos staged
git diff --cached --name-only 2>/dev/null

# O commits recientes si lo anterior esta vacio
git diff --name-only HEAD~10 2>/dev/null
```

Filtrar por extensión del lenguaje detectado. Anunciar al usuario:

```
Revisión [tecnología]: [N] archivos en alcance
Agente: [nombre-del-revisor]
Skills: [lista de skills que cargará]
```

## Paso 2 — Tabla de delegación

| Argumento    | Agente                     | Skills principales                                              |
|--------------|---------------------------|-----------------------------------------------------------------|
| `python`     | `revisor-codigo-swl`      | `patrones-python`, `fastapi-experto`, `testing-python`          |
| `java`       | `revisor-java-swl`        | `java-experto`, `java-testing`, `java-patrones`                 |
| `go`         | `revisor-go-swl`          | `go-experto`, `go-testing`, `go-patrones`                       |
| `rust`       | `revisor-rust-swl`        | `rust-experto`, `rust-testing`, `rust-patrones`                 |
| `csharp`     | `revisor-csharp-swl`      | `csharp-experto`, `csharp-testing`, `csharp-patrones`           |
| `kotlin`     | `revisor-kotlin-swl`      | `kotlin-experto`, `kotlin-testing`, `kotlin-compose`            |
| `swift`      | `revisor-swift-swl`       | `swift-experto`, `swift-testing`, `swift-patrones`              |
| `php`        | `revisor-php-swl`         | `php-experto`, `php-testing`, `php-patrones`                    |
| `nextjs`     | `revisor-nextjs-swl`      | `nextjs-experto`, `nextjs-testing`, `nextjs-patrones`           |
| `react`      | `revisor-react-swl`       | `react-experto`, `react-optimizacion`, `typescript-avanzado`    |
| `angular`    | `revisor-angular-swl`     | `angular-moderno`, `angular-avanzado`, `typescript-avanzado`    |
| `typescript` | `revisor-typescript-swl`  | `typescript-avanzado`, `node-experto`                           |
| `sql`        | `revisor-codigo-swl`      | `postgresql-experto`, `sql-optimizacion`                        |
| `seguridad`  | `revisor-seguridad-swl`   | `checklist-seguridad`, `auth-patrones`, `iam-secretos`          |

## Paso 3a — Revisión de un solo stack

Construir la instrucción al agente y delegarla con `Agent()`:

```
Revisa el código [tecnología] del proyecto.

Archivos a revisar:
[lista de archivos filtrados por extension]

Carga antes de empezar:
[skills segun tabla del Paso 2]

Aplica revision en dos capas:

CAPA 1 — Correctitud y spec compliance:
- La implementación cumple los requisitos visibles (PLAN.md, criterios de aceptación)
- No hay scope creep ni código muerto
- Los casos borde están manejados

CAPA 2 — Calidad idiomática del lenguaje [tecnología]:
- Patrones idiomáticos del lenguaje (no anti-patrones)
- Error handling correcto y explícito
- Sin código de debug (console.log, print, breakpoints)
- Cobertura de tests básica
- Performance obvios: N+1, loops anidados O(n²), carga innecesaria en memoria
- Seguridad básica: inputs validados, sin secrets hardcodeados, sin SQL crudo

Reporta cada hallazgo con:
- Archivo y línea exacta
- Severidad: CRITICO | IMPORTANTE | MENOR
- Descripción clara del problema
- Corrección recomendada con fragmento de código cuando aplique

Al final, produce un veredicto: APROBADO | CON OBSERVACIONES | RECHAZADO
```

## Paso 3b — Revisión de múltiples stacks (auto-detect)

Si el proyecto tiene varios lenguajes, lanzar los revisores en paralelo en un mismo mensaje:

```
Agent("revisor-python",     description="Revisar archivos Python del proyecto")
Agent("revisor-frontend",   description="Revisar archivos TypeScript/React/Angular del proyecto")
Agent("revisor-sql",        description="Revisar queries SQL y migraciones del proyecto")
```

Consolidar los reportes de todos los agentes en un solo reporte final al usuario.

## Paso 4 — Verificaciones automáticas por tecnología

Ejecutar ANTES de la revisión manual del agente. Los resultados se incluyen en el reporte.

### Python
```bash
ruff check . --output-format=concise 2>/dev/null
mypy . --ignore-missing-imports --no-error-summary 2>/dev/null
pytest --tb=short -q 2>/dev/null
```

### Go
```bash
go vet ./... 2>/dev/null
go test -race ./... 2>/dev/null
```

### Rust
```bash
cargo clippy -- -D warnings 2>/dev/null
cargo test 2>/dev/null
```

### C#
```bash
dotnet build -warnaserror 2>/dev/null
dotnet test 2>/dev/null
```

### TypeScript / React / Angular / Next.js
```bash
npx tsc --noEmit 2>/dev/null
npx eslint src/ --format=compact 2>/dev/null
npm test -- --watchAll=false --passWithNoTests 2>/dev/null
```

### PHP
```bash
vendor/bin/phpstan analyse 2>/dev/null
php artisan test 2>/dev/null
```

### Kotlin
```bash
./gradlew detekt 2>/dev/null
./gradlew test 2>/dev/null
```

### Swift
```bash
swift build 2>/dev/null
swift test 2>/dev/null
```

### SQL / PostgreSQL
```bash
# Buscar queries dentro de loops (potencial N+1)
grep -rn "execute\|query\|SELECT" --include="*.py" --include="*.ts" . 2>/dev/null | head -40
# Buscar SQL crudo sin parametrizar
grep -rn 'f"SELECT\|f"INSERT\|f"UPDATE\|"SELECT.*+\|"INSERT.*+' . 2>/dev/null
```

### Seguridad (todos los lenguajes)
```bash
# Secrets potenciales
git grep -i "password\|secret\|api_key\|token\s*=" -- "*.py" "*.ts" "*.js" "*.go" 2>/dev/null | grep -v "test\|spec\|\.example" | head -20
# Funciones peligrosas
grep -rn "eval(\|exec(\|shell=True\|pickle.loads\|yaml.load(" . 2>/dev/null | grep -v "test\|spec" | head -20
```

## Paso 5 — Reporte consolidado

Produce el reporte directamente en la conversación con este formato:

```markdown
# Revisión de Código — [tecnología]

**Proyecto**: [nombre del directorio raíz]
**Fecha**: [fecha actual]
**Archivos revisados**: [N]

## Resumen

| Severidad  | Cantidad |
|------------|----------|
| Crítico    | N        |
| Importante | N        |
| Menor      | N        |

## Verificaciones automáticas

| Verificación | Resultado              |
|--------------|------------------------|
| Linter       | PASA / N errores       |
| Type check   | PASA / N errores       |
| Tests        | N pasan, N fallan      |
| Build        | PASA / FALLA           |

## Hallazgos

### Crítico

1. **[archivo:línea]** — [descripción]
   ```[lang]
   // código problemático
   ```
   **Corrección:**
   ```[lang]
   // código corregido
   ```

### Importante

[idem]

### Menor

[idem]

## Veredicto

**[APROBADO | CON OBSERVACIONES | RECHAZADO]**

[Una línea explicando el veredicto]
```

## Paso 6 — Revisión multi-agente en paralelo (modo profundo)

Cuando el usuario dice `/swl:revisar profundo`, `/swl:revisar --profundo` o
"revisión completa con todos los agentes":

Lanzar **en paralelo** hasta 5 revisores especializados (además del revisor de stack):

```
Agent("revisor-seguridad-swl", "Auditar seguridad OWASP de archivos cambiados")
Agent("revisor-codigo-swl",    "Auditar errores silenciosos: catch vacíos, except:pass, error checks sin log")
Agent("tdd-qa-swl",            "Evaluar cobertura de tests: gaps críticos, tests faltantes para código nuevo")
Agent("documentador-swl",      "Verificar documentación afectada por los cambios: README, CHANGELOG, docstrings")
Agent("rendimiento-swl",       "Detectar N+1, loops O(n²), carga innecesaria en memoria en archivos cambiados")
```

Cada agente recibe:
- Lista de archivos en alcance (del Paso 1)
- Instrucción de reportar SOLO hallazgos con confianza >= 80%
- Formato de salida: severidad + archivo:línea + descripción + corrección

Consolidar todos los reportes en un solo reporte con secciones por agente:

```markdown
## Revisión multi-agente — [N] agentes, [M] hallazgos

### Seguridad (revisor-seguridad-swl)
[hallazgos o "Sin hallazgos"]

### Errores silenciosos (revisor-codigo-swl)
[hallazgos o "Sin hallazgos"]

### Cobertura de tests (tdd-qa-swl)
[hallazgos o "Sin hallazgos"]

### Documentación afectada (documentador-swl)
[hallazgos o "Sin hallazgos"]

### Rendimiento (rendimiento-swl)
[hallazgos o "Sin hallazgos"]
```

## Reglas de comportamiento

- NUNCA corregir código directamente — solo identificar y recomendar.
- SIEMPRE ejecutar las verificaciones automáticas del Paso 4 antes de delegar al agente.
- Si los tests fallan es CRITICO sin excepción, independientemente del lenguaje.
- Para SQL: buscar siempre N+1 queries y SQL crudo sin parametrizar.
- Para seguridad: aplicar `Skill("checklist-seguridad")` y verificar OWASP Top 10.
- Si el argumento es un archivo que no existe, informar y terminar.
- El reporte se emite siempre en la conversación. No crear archivo a menos que el usuario lo pida.
- En modo profundo: lanzar los 5 agentes en paralelo para máxima eficiencia.
