factorize

Scan the codebase to detect duplicated code, repeated patterns, and factorization opportunities. Unlike /simplify (which refines recently changed code), this command performs a project-wide analysis.

Modes:

• /factorize — full scan, all source files
• /factorize src/services — scoped to a specific directory
• /factorize --dry-run — report only, no code changes
• /factorize --scope small — override auto-detected project size

Step 1 — Context

1. Read CLAUDE.md to understand:

   • Stack (language, framework, conventions)
   • Project structure (where source lives, what's generated/vendored)
   • Naming conventions and existing abstractions

2. Detect project size:

   • Count source files (exclude tests, config, generated, vendor, node_modules)
   • Small (< 30 files): 1 analysis agent
   • Medium (30-100 files): 2 agents (split by directory)
   • Large (> 100 files): 3 agents (split by layer/concern)

3. Present the plan:

   FACTORIZE — [project name]
   Stack: [detected]
   Scope: [full / directory]
   Size: [X source files] → [small/medium/large]
   Agents: [1-3]
   Mode: [analysis + refactor / dry-run (report only)]
   
   Proceed? [Y/n]
   

Step 2 — Detection phase

Launch agents in parallel (subagent_type: feature-dev:code-explorer).

Each agent receives its assigned files and this mission:

You are analyzing [project name] ([stack]) for factorization opportunities.
Your assigned files: [list].

Scan for these patterns:

1. **DUPLICATED CODE** — identical or near-identical blocks (>5 lines) that appear in 2+ files.
   Report: both locations, the duplicated block, and a suggested shared function/module name.

2. **REPEATED PATTERNS** — same logical pattern implemented differently across files
   (e.g., 3 different ways to validate input, 4 similar API call wrappers).
   Report: all occurrences, the common pattern, and a suggested unified approach.

3. **MISSED ABSTRACTIONS** — operations that could benefit from a shared utility
   (e.g., repeated string transformations, common data reshaping, recurring error handling).
   Report: occurrences and suggested abstraction.

4. **COPY-PASTE DRIFT** — code that was clearly copied then modified slightly,
   creating divergence that will cause bugs (one copy gets fixed, others don't).
   Report: all copies, the differences, and which version is likely "correct".

For each finding, report:
- **Type**: DUPLICATION / PATTERN / ABSTRACTION / DRIFT
- **Impact**: HIGH (>3 occurrences or >20 lines each) / MEDIUM (2-3 occurrences) / LOW (minor)
- **Locations**: file:line for each occurrence
- **Code snippets**: the duplicated/similar blocks (abbreviated if >15 lines)
- **Suggestion**: concrete refactoring approach (function name, module location, signature)

Do NOT report:
- Similar test setup code (tests are allowed to be repetitive for readability)
- Framework boilerplate that cannot be abstracted (e.g., route definitions)
- Config files or generated code
- Differences that are intentional (check comments, commit messages)