Nexus - AI Task Orchestrator

34-code-complexity-analysis
Procedimiento: Code Complexity Analysis

Calidad de Codigo
1 plugin(s)
Titulo
Descripcion
Contenido Markdown
9305 caracteres
# Procedimiento: Code Complexity Analysis

## Metadata
- **ID**: PROC-34
- **Frecuencia**: Mensual
- **Duraci├│n estimada**: 20-30 min
- **Requiere**: Acceso al c├│digo fuente
- **Dependencias**: Ninguna
- **Bloquea**: Ninguno
- **Agentes**: dotnet-architect

---

## Objetivo

Analizar la complejidad del c├│digo para:
1. Identificar m├®todos con alta complejidad ciclom├ítica (>10)
2. Detectar m├®todos muy largos (>50 l├¡neas)
3. Encontrar clases con demasiadas responsabilidades
4. Detectar code smells comunes
5. Priorizar refactorizaciones

---

## M├®tricas de Complejidad

| M├®trica | Bueno | Aceptable | Malo | Cr├¡tico |
|---------|-------|-----------|------|---------|
| Complejidad Ciclom├ítica | 1-5 | 6-10 | 11-20 | >20 |
| L├¡neas por m├®todo | <20 | 20-50 | 50-100 | >100 |
| Par├ímetros por m├®todo | 0-3 | 4-5 | 6-7 | >7 |
| M├®todos por clase | <10 | 10-20 | 20-30 | >30 |
| Profundidad de herencia | 1-2 | 3-4 | 5-6 | >6 |

---

## Herramientas

| Herramienta | Uso | Instalaci├│n |
|-------------|-----|-------------|
| dotnet-counters | .NET Metrics | `dotnet tool install` |
| NDepend | .NET completo | Licencia |
| SonarQube | Multi-lenguaje | Docker/Server |
| CodeClimate | SaaS | Integraci├│n |
| lizard | Multi-lenguaje | `pip install lizard` |

---

## Checklist Ejecutable

### 1. Configurar Herramienta

```bash
# Opci├│n 1: lizard (multi-lenguaje, gratuito)
pip install lizard

# Opci├│n 2: Roslyn Analyzers (.NET)
# Ya incluidos en .NET SDK moderno

# Verificar
lizard --version
```

- [ ] Herramienta instalada

### 2. Ejecutar An├ílisis de Complejidad

```bash
# Con lizard
lizard src/ \
  --CCN 10 \
  --length 50 \
  --arguments 5 \
  --warnings_only \
  --output_file reports/complexity.csv

# Solo archivos C#
lizard src/ -l csharp --CCN 10 --warnings_only

# Reporte HTML
lizard src/ -l csharp --html -o reports/complexity.html
```

**Columnas del reporte:**
- NLOC: Non-comment Lines of Code
- CCN: Cyclomatic Complexity Number
- Token: N├║mero de tokens
- Param: N├║mero de par├ímetros
- Length: L├¡neas totales del m├®todo

- [ ] An├ílisis ejecutado
- [ ] Reporte generado

### 3. Identificar M├®todos Complejos

```bash
# Filtrar m├®todos con CCN > 10
cat reports/complexity.csv | \
  awk -F, '$2 > 10 {print $0}' | \
  sort -t, -k2 -nr | head -20

# Ejemplo formato:
# Method,CCN,NLOC,Token,Param,File
# ProcessOrder,25,120,450,8,OrderService.cs
```

**Top 10 m├®todos complejos:**

| M├®todo | CCN | L├¡neas | Params | Archivo | Prioridad |
|--------|-----|--------|--------|---------|-----------|
| ___ | ___ | ___ | ___ | ___ | ___ |

- [ ] M├®todos con CCN > 10 identificados: ___
- [ ] M├®todos con > 50 l├¡neas identificados: ___

### 4. Identificar M├®todos Largos

```bash
# M├®todos con m├ís de 50 l├¡neas
lizard src/ -l csharp --length 50 --warnings_only 2>/dev/null | \
  grep "too long" | sort -t: -k3 -nr
```

- [ ] M├®todos largos listados
- [ ] Candidatos a split identificados

### 5. Identificar Clases Grandes

```bash
# Contar m├®todos por clase (.NET)
for file in $(find src -name "*.cs"); do
  class_name=$(grep -E "class\s+\w+" "$file" | head -1 | grep -oE "class\s+\w+" | cut -d' ' -f2)
  method_count=$(grep -cE "(public|private|protected|internal)\s+\w+\s+\w+\s*\(" "$file")
  if [ "$method_count" -gt 15 ]; then
    echo "$method_count methods: $class_name ($file)"
  fi
done | sort -rn
```

- [ ] Clases con >20 m├®todos identificadas
- [ ] Candidatas a SRP refactoring

### 6. Detectar Code Smells

**Patrones a buscar:**

```bash
# Long Parameter List (>5 params)
grep -rn "(\s*\w+\s+\w+\s*,\s*\w+\s+\w+\s*,\s*\w+\s+\w+\s*,\s*\w+\s+\w+\s*,\s*\w+\s+\w+\s*," \
  src --include="*.cs" | head -10

# Switch statements grandes (posible strategy pattern)
grep -rn "switch\s*(" src --include="*.cs" -A 20 | \
  grep -E "case\s+|default:" | wc -l

# M├®todos con nombres muy largos (posible complejidad oculta)
grep -ohE "(public|private|protected)\s+\w+\s+\w{30,}\s*\(" src --include="*.cs"

# Deep nesting (muchas llaves anidadas)
# Buscar l├¡neas con >4 tabs de indentaci├│n
grep -rn "^\t\t\t\t\t" src --include="*.cs" | wc -l
```

**Code Smells comunes:**

| Smell | Indicador | Soluci├│n |
|-------|-----------|----------|
| Long Method | >50 l├¡neas | Extract Method |
| Long Parameter List | >5 params | Parameter Object |
| Large Class | >30 m├®todos | Extract Class |
| Switch Statements | >5 cases | Strategy Pattern |
| Deep Nesting | >3 niveles | Guard Clauses |
| Primitive Obsession | Muchos strings/ints | Value Objects |

- [ ] Code smells detectados: ___

### 7. An├ílisis con Roslyn Analyzers (.NET)

```bash
# Habilitar analyzers estrictos en .csproj
# <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
# <AnalysisLevel>latest</AnalysisLevel>

# Build con an├ílisis
dotnet build /p:TreatWarningsAsErrors=false /p:RunAnalyzersDuringBuild=true 2>&1 | \
  grep -E "CA[0-9]+|IDE[0-9]+"

# Warnings de complejidad t├¡picos:
# CA1502: Avoid excessive complexity
# CA1505: Avoid unmaintainable code
# CA1506: Avoid excessive class coupling
```

- [ ] Warnings de analyzers revisados

### 8. Priorizar Refactorizaciones

**Matriz de priorizaci├│n:**

| Factor | Peso |
|--------|------|
| CCN > 20 | Alta |
| L├¡neas > 100 | Alta |
| En c├│digo cr├¡tico | Alta |
| M├║ltiples smells | Media |
| C├│digo legacy estable | Baja |

**Template de refactorizaci├│n:**

```markdown
## Refactorizaci├│n: [Nombre del m├®todo/clase]

### Ubicaci├│n
- Archivo: src/Services/OrderService.cs
- L├¡nea: 145-245

### M├®tricas Actuales
- CCN: 25
- L├¡neas: 100
- Par├ímetros: 8

### Problemas
1. Demasiada complejidad ciclom├ítica
2. M├║ltiples responsabilidades
3. Deep nesting

### Propuesta
1. Extraer validaci├│n a ValidatorService
2. Usar Strategy para tipos de orden
3. Introducir Guard Clauses

### Impacto
- CCN objetivo: <10
- L├¡neas objetivo: <30
- Esfuerzo: 4h
```

- [ ] Refactorizaciones priorizadas
- [ ] Tareas creadas

---

## Output Esperado

```
====== PROC-34 COMPLETADO [TIMESTAMP] ======
Proyecto: [nombre]

RESUMEN GENERAL:
- Archivos analizados: X
- M├®todos analizados: Y
- CCN promedio: Z

COMPLEJIDAD CICLOM├üTICA:
- M├®todos con CCN > 20: X (CR├ìTICO)
- M├®todos con CCN 11-20: Y (WARNING)
- M├®todos con CCN 6-10: Z (OK)
- M├®todos con CCN 1-5: W (EXCELENTE)

LONGITUD DE M├ëTODOS:
- >100 l├¡neas: X
- 50-100 l├¡neas: Y
- <50 l├¡neas: Z

TOP 10 M├ëTODOS COMPLEJOS:
| M├®todo | CCN | L├¡neas | Archivo |
|--------|-----|--------|---------|
| ProcessOrder | 25 | 120 | OrderService.cs |
| ...

CODE SMELLS DETECTADOS:
- Long Parameter List: X ocurrencias
- Large Classes: Y
- Deep Nesting: Z archivos

REFACTORIZACIONES PRIORITARIAS:
1. [m├®todo] - CCN 25 -> <10, esfuerzo 4h
2. [m├®todo] - 120 l├¡neas -> <50, esfuerzo 2h

TAREAS CREADAS:
- [TASK-XXX] Refactorizar ProcessOrder
```

---

## Criterios de ├ëxito

- [ ] CCN promedio < 10
- [ ] 0 m├®todos con CCN > 20
- [ ] 0 m├®todos con > 100 l├¡neas
- [ ] Refactorizaciones planificadas

---

## Alertas y Escalaci├│n

| Severidad | Condici├│n | Acci├│n |
|-----------|-----------|--------|
| CRITICAL | CCN > 25 | Refactorizar antes de release |
| CRITICAL | M├®todo > 200 l├¡neas | Dividir urgentemente |
| WARNING | CCN > 15 | Planificar refactorizaci├│n |
| WARNING | >10 smells del mismo tipo | Patr├│n a corregir |
| INFO | CCN promedio < 5 | Excelente calidad |

---

## Automatizaci├│n

En ejecuci├│n no-interactiva:
1. Ejecutar lizard/analyzers
2. Parsear resultados
3. Calcular estad├¡sticas
4. Identificar top problemas
5. Generar reporte

---


---

## Output Estructurado (Nexus)

Al finalizar, el agente DEBE generar un bloque JSON con el siguiente formato para que Nexus pueda procesarlo automaticamente:

```json
{
  "result": "success",
  "summary": "Ejecucion de PROC-34 completada. [Descripcion breve de resultados]",
  "metrics": {
    "issues_found": 0,
    "issues_resolved": 0,
    "issues_found": 10, "issues_fixed": 8,
    "custom": {
      "procedure_specific_metric": "value"
    }
  },
  "backlog_items": [
    {
      "title": "Titulo del item de seguimiento",
      "description": "Descripcion detallada si se requiere accion futura",
      "priority": "medium",
      "type": "improvement",
      "tags": ["proc-34"]
    }
  ],
  "next_steps": [
    "Accion recomendada 1",
    "Accion recomendada 2"
  ],
  "warnings": [
    "Advertencias encontradas durante la ejecucion"
  ]
}
```

**Campos requeridos:**
- `result`: `"success"` | `"partial"` | `"failed"`
- `summary`: Resumen ejecutivo en 1-3 lineas

**Metricas especificas de este procedure:**
- methods_analyzed, complexity_high, complexity_avg

**Criterios de resultado:**
- `success`: Procedimiento completado sin errores criticos
- `partial`: Completado con algunos problemas menores o items pendientes
- `failed`: Error critico o no se pudo completar

## Historial de Ejecuciones

| Fecha | Proyecto | CCN Prom | >CCN 10 | >100 L├¡neas | Refact. | Estado |
|-------|----------|----------|---------|-------------|---------|--------|
| | | | | | | |