complexity-analyzer

# Complexity Analyzer

## Quick Start

Analyze complexity with tools:

```bash
# JavaScript
npx eslint --plugin complexity --rule 'complexity: [error, 10]' src/

# Python
pip install radon
radon cc src/ -a -nb

# General
npx complexity-report src/
```

## Instructions

### Step 1: Calculate Cyclomatic Complexity

Count decision points + 1:
- if, else, elif
- for, while loops
- case statements
- && and || operators
- ternary operators
- catch blocks

**Example:**
```javascript
function example(x) {  // +1 (base)
  if (x > 0) {         // +1
    return x;
  } else if (x < 0) {  // +1
    return -x;
  }
  return 0;
}
// Complexity: 3
```

### Step 2: Identify Complex Functions

| Complexity | Rating | Action |
|------------|--------|--------|
| 1-10 | Simple | No action needed |
| 11-20 | Moderate | Consider refactoring |
| 21-50 | Complex | Should refactor |
| 50+ | Very Complex | Must refactor |

### Step 3: Analyze Cognitive Complexity

Cognitive complexity considers:
- Nesting depth (each level adds to complexity)
- Breaks in linear flow (if, loops, catch)
- Recursion

```javascript
// Cyclomatic: 4, Cognitive: 7
function sumOfPrimes(max) {        // +0
  let total = 0;
  for (let i = 2; i <= max; i++) { // +1 (loop)
    let isPrime = true;
    for (let j = 2; j < i; j++) {  // +2 (nested loop)
      if (i % j === 0) {           // +3 (nested if)
        isPrime = false;
        break;                     // +1 (break)
      }
    }
    if (isPrime) {                 // +1 (if)
      total += i;
    }
  }
  return total;
}
```

### Step 4: Generate Report

```markdown
## Complexity Report

### High Complexity (>20)

**processOrder()** - src/orders.js:45
- Cyclomatic: 28
- Cognitive: 35
- Lines: 127
- Recommendation: Extract validation, calculation, and persistence logic

**validateUser()** - src/auth.js:12
- Cyclomatic: 22
- Cognitive: 28
- Lines: 89
- Recommendation: Extract individual validation rules

### Moderate Complexity (11-20)

[List functions with complex