---
name: swl-revisar-impacto
description: >
  Analiza el impacto de cambios en el codebase usando code-review-graph.
  Ejecuta get_minimal_context → risk_score → get_impact_radius → detect_changes.
  Activa cuando el usuario quiere saber qué se ve afectado por un cambio,
  antes de modificar un componente crítico, o para análisis de riesgo pre-commit.
user-invocable: false
version: "1.0.0"
herramientasPermitidas: [Read, Bash]
exclusiones:
  - "No cargar si el grafo `code-review-graph` no está disponible (`.code-review-graph/graph.db` ausente) — sin grafo construido el skill retorna MISSING en el prerequisito y no puede ejecutar ningún análisis."
  - "No cargar para revisar calidad de código (linting, estilo, cobertura de tests) — eso es `calidad-pre-commit.js` o `/swl:revisar`; este skill evalúa impacto estructural en el grafo de dependencias."
  - "No cargar en proyectos con codebase < 500 LOC o sin dependencias cruzadas significativas — el grafo de comunidades y blast radius no aportan información útil si el proyecto no tiene estructura modular suficiente."
  - "No cargar para analizar impacto de cambios en documentación, SKILL.md o archivos de configuración que no tienen nodos en el grafo de código — el grafo solo indexa código fuente con llamadas/importaciones."
evolvable: true  # default para skill estandar
---
# Skill: swl-revisar-impacto

Analiza el impacto estructural de cambios usando el knowledge graph persistente
del codebase (code-review-graph). Proporciona blast radius, risk score y flujos
afectados antes de aplicar modificaciones.

## Prerequisito — Verificar grafo disponible

```bash
PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
python -c "
import sys, os
db = os.path.join('$PROJECT_ROOT', '.code-review-graph', 'graph.db')
print('OK' if os.path.exists(db) else 'MISSING')
"
```

Si dice MISSING:
```
⚠ El grafo de código no está inicializado.
  Ejecuta primero: /swl:revisar-impacto build
  O directamente: python -c "import sys; sys.argv=['crg','build']; from code_review_graph.cli import main; main()"
```

## Subcomandos

### `build` — Construir/reconstruir el grafo

```bash
PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
cd "$PROJECT_ROOT" && python -c "
import sys
sys.argv = ['code-review-graph', 'build']
from code_review_graph.cli import main
main()
"
```

Mostrar al usuario:
```
Grafo construido:
  Archivos:  {N}
  Nodos:     {N}
  Edges:     {N}
  Lenguajes: {lista}
  Actualizado: {ts}
```

### `status` — Estado actual del grafo

```bash
PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
cd "$PROJECT_ROOT" && python -c "
import sys
sys.argv = ['code-review-graph', 'status']
from code_review_graph.cli import main
main()
"
```

### `contexto` (o vacío) — Análisis de riesgo general

Obtiene el contexto mínimo de riesgo actual (~100 tokens):

Usar la herramienta MCP `get_minimal_context` con:
```json
{ "task": "review", "detail_level": "minimal" }
```

Mostrar resultado al usuario:
```
Estado del grafo:
  Nodos: {N} | Edges: {N} | Archivos: {N}
  Lenguajes: {lista}

Riesgo actual: {low | medium | high} ({score:.2f})

Archivos afectados top:
  - {nombre_función}: {razón}

Test gaps: {N} funciones sin cobertura de tests

Comunidades activas: {top 3}
Flujos críticos: {top 3}

Siguiente paso sugerido:
  {tool_suggestion_1}
  {tool_suggestion_2}
```

### `impacto <archivo_o_función>` — Blast radius de un componente

Determinar el nodo a analizar: si el usuario proveyó un nombre de archivo o función,
buscar su qualified_name en el grafo.

Usar la herramienta MCP `get_impact_radius` con:
```json
{
  "node_name": "<qualified_name>",
  "depth": 3,
  "detail_level": "standard"
}
```

Mostrar al usuario:
```
Blast radius de {nombre}:
  Impacto directo ({N} nodos):
    - {nodo_1}: {tipo} ({archivo}:{línea})
    - {nodo_2}: ...
  
  Impacto transitivo (profundidad 3):
    - {N} nodos adicionales
  
  Tests que cubren este nodo: {N}
  Tests en riesgo: {lista}
  
  ⚠ Modificar este nodo afecta {N_total} componentes del sistema.
```

Si N_total > 20: mostrar advertencia de alto impacto y sugerir `/swl:checkpoint` antes de proceder.

### `cambios` — Análisis de riesgo de cambios actuales (pre-commit)

Usar la herramienta MCP `detect_changes` con:
```json
{ "detail_level": "standard" }
```

Mostrar al usuario:
```
Análisis de cambios actuales:
  Risk score: {score:.2f} ({low|medium|high})
  
  Funciones modificadas ({N}):
    - {función}: riesgo {score} — {razón}
  
  Funciones sin tests ({N}):
    - {función} ({archivo}:{línea})
  
  Flujos afectados ({N}):
    - {flujo}: criticidad {score}
  
  {si risk_score > 0.7}
  ⛔ RIESGO ALTO — Se recomienda:
    1. Ejecutar /swl:checkpoint antes de continuar
    2. Revisar cobertura de tests en funciones modificadas
    3. Confirmar con el usuario antes del commit
```

### `comunidades` — Ver estructura modular del codebase

Usar la herramienta MCP `list_communities` con:
```json
{ "detail_level": "standard" }
```

Mostrar tabla de comunidades:
```
Comunidades detectadas ({N}):
  ID  | Nombre              | Nodos | Cohesión | Acoplamiento
  ----|---------------------|-------|----------|-------------
  1   | gateway-core        | 45    | 0.91     | 0.23
  2   | hooks-observability | 38    | 0.87     | 0.31
  ...

Comunidades con alto acoplamiento (> 0.6): candidatas a refactor
Comunidades con alta cohesión (> 0.8): estables — no tocar sin análisis
```

### `flujos` — Ver flujos de ejecución críticos

Usar la herramienta MCP `list_flows` con:
```json
{ "detail_level": "standard", "limit": 10 }
```

Mostrar flujos ordenados por criticidad:
```
Flujos críticos del sistema (top 10):
  1. {nombre_flujo} — criticidad: {score}
     Entry point: {función}:{archivo}
     Nodos: {N} | Terminales: {N}
  ...
```

## Integración con flujo de trabajo SWL

Invocar automáticamente este skill en estos momentos:
1. **Antes de modificar agentes críticos** (orquestador, implementador, ejecutar-fase)
2. **Antes de un release** (`/swl:release`) para detectar cambios riesgosos
3. **Cuando el pre-commit bloquea** con risk score alto
4. **Durante auto-evolución** para priorizar qué módulo optimizar primero

## Relación con otros componentes

| Componente       | Scope                          | Complemento                          |
|------------------|--------------------------------|--------------------------------------|
| `/swl:status metricas`  | Costo/tokens de sesión actual  | revisar-impacto agrega análisis estructural |
| `calidad-pre-commit.js` | Lint + secretos pre-commit | revisar-impacto agrega risk score semántico |
| `auto-evolucion-swl` | Mejora de agentes         | revisar-impacto prioriza por comunidades |
| `run-log.js`     | Observabilidad de sesión       | revisar-impacto agrega contexto de código |

## Cuándo NO cargar

- El prerequisito del Paso 0 retorna MISSING — sin `graph.db` construido, ningún subcomando funciona; primero construir el grafo con `code-review-graph`.
- El objetivo es revisar calidad de código (lint, style, cobertura) — usar `/swl:revisar` o `calidad-pre-commit.js`; este skill evalúa blast radius estructural, no issues de calidad.
- El proyecto es pequeño (< 500 LOC, sin módulos bien separados) — el análisis de comunidades y flujos críticos no aporta información útil cuando casi todo el código está acoplado en un único módulo.
- Los archivos modificados son documentación, SKILL.md o configuración YAML — el grafo solo indexa código fuente con llamadas e importaciones; los cambios a archivos no-código no tienen nodos en el grafo.

## Gotchas / Errores comunes no obvios

- **`get_minimal_context` retorna nodos con `qualified_name` diferente al nombre de la función en el código**: el grafo indexa nombres calificados (ej. `api.routes.facturas.crear_factura`) mientras el código usa el nombre simple. Causa: el grafo usa el path completo como identificador de nodo. Solución: para el subcomando `impacto`, usar `get_minimal_context` primero para obtener el `qualified_name` correcto del nodo antes de pasar a `get_impact_radius` — nunca construir el qualified_name a mano.
- **Blast radius N_total inflado por nodos de tipo "import" sin dependencia real**: el grafo muestra 40 nodos afectados pero la mayoría son módulos que solo importan el paquete raíz, no que usan la función modificada. Causa: el grafo indexa importaciones como edges, incluyendo `from modulo import *`. Solución: filtrar los resultados de `get_impact_radius` por `tipo: "call"` para obtener el blast radius real de llamadas directas, no el inflado por importaciones transitivas.
- **Advertencia de alto impacto (N_total > 20) sin sugerir `/swl:checkpoint`**: el skill documenta que cuando N_total supera 20 se debe mostrar advertencia y sugerir checkpoint, pero el agente solo muestra el número sin la advertencia. Causa: omitir la condición `if N_total > 20` al construir el output del subcomando `impacto`. Solución: el bloque condicional de advertencia es parte del protocolo, no opcional — si N_total > 20, mostrar el aviso y sugerir checkpoint antes de continuar.
- **`risk_score` del subcomando `cambios` calculado con grafo desactualizado**: el grafo fue construido hace 3 semanas y el codebase cambió significativamente. Causa: `graph.db` no se reconstruye automáticamente con cada commit. Solución: si la última actualización del grafo (verificar metadata) supera 7 días o hay más de 50 commits desde la última build, reconstruir el grafo antes de confiar en el risk score.
