complexity-analyzer
Analyzes cyclomatic and cognitive complexity, identifies overly complex functions. Use when assessing code complexity or identifying functions that need simplification.
When & Why to Use This Skill
The Complexity Analyzer is a specialized Claude skill designed to evaluate code quality by measuring cyclomatic and cognitive complexity. It helps developers identify 'spaghetti code' and overly intricate functions that are difficult to maintain or test. By providing actionable metrics and refactoring strategies like 'Extract Method' or 'Replace Nested Conditionals,' it empowers teams to reduce technical debt, improve codebase readability, and ensure long-term maintainability.
Use Cases
- Automated Code Reviews: Scan new pull requests to identify functions exceeding complexity thresholds before they are merged into the main branch.
- Legacy Code Auditing: Analyze existing codebases to pinpoint high-risk, complex modules that require urgent refactoring to prevent bugs.
- Technical Debt Assessment: Generate detailed reports to quantify code maintainability and prioritize engineering efforts for stakeholders.
- Developer Mentorship: Provide junior developers with immediate, objective feedback on code structure to encourage modular and clean coding habits.
| name | complexity-analyzer |
|---|---|
| description | Analyzes cyclomatic and cognitive complexity, identifies overly complex functions. Use when assessing code complexity or identifying functions that need simplification. |
Complexity Analyzer
Quick Start
Analyze complexity with tools:
# 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:
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
// 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
## 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 complexity 11-20]
Simplification Strategies
Extract Method
// Before: Complexity 15
function processData(data) {
if (data.type === 'A') {
// 20 lines of processing
} else if (data.type === 'B') {
// 20 lines of processing
}
}
// After: Complexity 3
function processData(data) {
if (data.type === 'A') return processTypeA(data);
if (data.type === 'B') return processTypeB(data);
}
Replace Nested Conditionals
// Before: Cognitive 12
function getPrice(user, product) {
if (user) {
if (user.isPremium) {
if (product.onSale) {
return product.price * 0.7;
} else {
return product.price * 0.9;
}
}
}
return product.price;
}
// After: Cognitive 4
function getPrice(user, product) {
if (!user || !user.isPremium) return product.price;
if (product.onSale) return product.price * 0.7;
return product.price * 0.9;
}
Use Polymorphism
// Before: Complexity 8
function getArea(shape) {
if (shape.type === 'circle') {
return Math.PI * shape.radius ** 2;
} else if (shape.type === 'square') {
return shape.side ** 2;
}
// ... more types
}
// After: Complexity 1 per class
class Circle {
getArea() { return Math.PI * this.radius ** 2; }
}
class Square {
getArea() { return this.side ** 2; }
}