/cm-clean-code

name: cm-clean-code
description: "Code hygiene gate — detect and eliminate dead code, duplicates, naming mess, and code smells. TRIZ-powered. Run after features, before PRs, during debt sprints."
token_budget: 1200
compressed: true
deprecated: false

Clean Code — Code Hygiene Gate

TL;DR

• **Use after** a feature lands, before PR review
• **Detects**: dead code, duplicates, naming smells, dependency drift
• **Powered by** TRIZ contradictions and Boy Scout rule
• **Next**: cm-code-review

> **Code that works is not enough. Code must be CLEAN.** > Inspired by Clean Code (Robert C. Martin) + Refactoring (Martin Fowler) + TRIZ.

When to Use

**ALWAYS when:**

• After completing a feature (mandatory hygiene pass before PR)
• After `cm-reactor` migration (cleanup dead code from migration)
• Before code review (`cm-code-review`) — clean FIRST, review AFTER
• During technical debt sprints
• When code smells are detected (see Detection section)
• After AI-generated code sessions (AI tends to leave mess)
• When file grows beyond 300 lines

**Run automatically after:**

• `cm-execution` completes a task batch
• `cm-reactor` Phase 5 (post-migration cleanup)
• `cm-tdd` Refactor phase (Red → Green → **Refactor**)

**Skip when:**

• Quick hotfix (patch first, clean later — but schedule the cleanup!)
• Prototype/spike code (will be thrown away)

TRIZ Principles Applied

| # | Principle | How Applied | |---|-----------|-------------| | **#1** | Segmentation | Break large files/functions into focused units | | **#10** | Prior Action | Clean BEFORE it rots — don't wait for tech debt sprint | | **#6** | Universality | One function should serve one purpose (SRP) | | **#27** | Cheap Short-living | Quick small cleanups > expensive large refactors | | **#2** | Taking Out | Extract what doesn't belong — separate concerns |

The 7-Point Hygiene Checklist

Run this checklist on every file touched. Each point has auto-detect criteria:

┌───┬──────────────────────┬──────────────────────────────┬────────────────────────┐
│ # │ Check                │ Auto-Detect                  │ Action                 │
├───┼──────────────────────┼──────────────────────────────┼────────────────────────┤
│ 1 │ Dead Code            │ Unused exports, unreachable  │ DELETE — don't comment │
│   │                      │ branches, commented-out code │ out, DELETE            │
├───┼──────────────────────┼──────────────────────────────┼────────────────────────┤
│ 2 │ Unused Imports       │ Import not used in file      │ REMOVE import line     │
├───┼──────────────────────┼──────────────────────────────┼────────────────────────┤
│ 3 │ Magic Numbers        │ Literal numbers in logic     │ EXTRACT to named const │
│   │ & Strings            │ Repeated string literals     │                        │
├───┼──────────────────────┼──────────────────────────────┼────────────────────────┤
│ 4 │ Naming               │ Single-letter vars (not i,j) │ RENAME to describe     │
│   │                      │ Abbreviations, inconsistent  │ intent clearly         │
├───┼──────────────────────┼──────────────────────────────┼────────────────────────┤
│ 5 │ Single Responsibility│ Function does 2+ things      │ EXTRACT into separate  │
│   │ (SRP)                │ Class has 5+ public methods  │ focused units          │
├───┼──────────────────────┼──────────────────────────────┼────────────────────────┤
│ 6 │ DRY (Don't Repeat)   │ Similar code blocks in 2+    │ EXTRACT shared logic   │
│   │                      │ places                       │ into reusable function │
├───┼──────────────────────┼──────────────────────────────┼────────────────────────┤
│ 7 │ Nesting Depth        │ if/for/while nested > 3      │ EXTRACT, early return, │
│   │                      │ levels deep                  │ guard clauses          │
└───┴──────────────────────┴──────────────────────────────┴────────────────────────┘

The Process

Phase 1: SCAN — Detect Code Smells

> **Goal:** Find what's dirty before cleaning.

**Automated scan (file-by-file):**

For each file modified in current task:

  1. SIZE CHECK:
     IF lines > 300 → FLAG "Large file — consider splitting"
     IF any function > 50 lines → FLAG "Long function — extract methods"
  
  2. IMPORT CHECK:
     Scan imports → cross-reference with usage in file body
     Unused import → FLAG for removal
  
  3. DEAD CODE CHECK:
     Commented-out code blocks → FLAG for deletion
     Functions not called anywhere → FLAG (verify with codeintell)
     Unreachable code after return/throw → FLAG
  
  4. DUPLICATION CHECK:
     Similar code blocks (>5 lines identical/near-identical) → FLAG
     Copy-paste patterns → FLAG
  
  5. NAMING CHECK:
     Single-char variables (except loop vars i,j,k) → FLAG
     Inconsistent casing (camelCase vs snake_case in same file) → FLAG
     Generic names (data, result, temp, item, value, obj) → FLAG
  
  6. COMPLEXITY CHECK:
     Nesting > 3 levels → FLAG
     Function with > 4 parameters → FLAG
     Cyclomatic complexity > 10 → FLAG

**Output: Smell Report**

## Clean Code Scan: [filename]

| # | Smell | Line | Severity | Auto-fix? |
|---|-------|------|----------|-----------|
| 1 | Unused import: lodash | 3 | Low | ✅ Yes |
| 2 | Magic number: 86400 | 47 | Medium | ✅ Yes |
| 3 | Long function: processData (78 lines) | 23-101 | High | 🔧 Manual |
| 4 | Dead code: commented block | 112-125 | Low | ✅ Yes |

**Total smells: 4 | Auto-fixable: 3 | Manual: 1**

Phase 2: CLEAN — Apply Fixes

> **Goal:** Fix each smell, one at a time, with tests passing between each fix.

**Rules (from refactoring.guru + Martin Fowler):** 1. **Tests first:** Ensure tests exist and pass BEFORE cleaning 2. **One change at a time:** Fix one smell → run tests → commit → next smell 3. **Behavior preservation:** Clean code MUST NOT change functionality 4. **No feature additions:** Cleaning and feature work are SEPARATE commits

**Fix patterns:**

Fix 1: Dead Code &