Agent skill
quality-complexity-check
Analyze code complexity metrics including cyclomatic complexity and nesting depth. Use to identify code that needs refactoring.
Stars
163
Forks
31
Install this agent skill to your Project
npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/development/quality-complexity-check
SKILL.md
Complexity Check Skill
Analyze and report code complexity metrics.
When to Use
- Code review process
- Identifying refactoring candidates
- Maintaining code quality
- Before major releases
Quick Reference
bash
# Analyze Python code
./scripts/check_complexity.py
# Generate full report
./scripts/complexity_report.sh > complexity.txt
# Check Mojo code
./scripts/check_mojo_complexity.sh
Complexity Metrics
Cyclomatic Complexity (CC)
Measures decision points (if, for, while):
| CC Range | Assessment | Action |
|---|---|---|
| 1-10 | Simple | Keep as is |
| 11-20 | Moderate | Consider refactoring |
| 21+ | Complex | Needs refactoring |
Nesting Depth
Maximum levels of nesting in function:
| Depth | Assessment | Action |
|---|---|---|
| 1-3 | Good | Keep as is |
| 4-5 | High | Consider flattening |
| 6+ | Very High | Refactor required |
Function Length
Lines of code in function:
| LOC | Assessment | Action |
|---|---|---|
| 1-20 | Good | Keep as is |
| 21-50 | Acceptable | Monitor |
| 51+ | Too long | Consider splitting |
Refactoring Patterns
Extract Function (High CC)
python
# Before (CC: 15)
def process(data):
if condition1:
if condition2:
if condition3:
for item in data:
if item.valid:
# process
# After (CC: 5)
def process(data):
if not is_valid(data):
return
filtered = filter_valid_items(data)
return process_items(filtered)
Flatten Nesting
Replace nested ifs with early returns:
python
# Before (depth: 5)
fn process(data):
if check1(data):
if check2(data):
if check3(data):
# complex logic
# After (depth: 2)
fn process(data):
if not check1(data): return
if not check2(data): return
if not check3(data): return
# complex logic
Workflow
bash
# 1. Analyze code
./scripts/check_complexity.py
# 2. Review high-complexity functions
grep "CC:" complexity.txt | grep -E "CC: [2-9][0-9]|CC: [1-9][0-9]{2}"
# 3. Plan refactoring
# ... extract functions, flatten nesting ...
# 4. Re-analyze
./scripts/check_complexity.py
# 5. Verify improved
git diff complexity.txt
Error Handling
| Issue | Fix |
|---|---|
| Script not found | Check scripts/ directory |
| Syntax errors | Fix code syntax before analyzing |
| No output | Verify source files exist |
Thresholds
Project thresholds:
- Max CC per function: 15
- Max nesting depth: 4
- Max function length: 50 LOC
- Minimum test coverage: 80%
References
- Related skill:
phase-cleanupfor refactoring guidelines - Related skill:
quality-run-lintersfor complete quality check
Didn't find tool you were looking for?