De-dupe and DRY Refactor

Follow a safe, repeatable workflow to find duplicated code, extract shared helpers, and reduce maintenance burden while preserving behavior.

Workflow

1. Check for uncommitted changes before refactor.

   • Run

     git status -sb

     and note touched files.
   • If the tree is dirty, prefer working incrementally and avoid mixing unrelated changes.

2. Identify duplication targets.

   • Scan for obvious repeats in the touched files.
   • Use

     rg

     to find similar blocks or repeated strings.
     • Example:

       rg -n "functionName|error message|regex literal" src/

     • Example:

       rg -n "(\w+\([^)]*\))" src/

       then narrow to common blocks.

3. Decide if extraction is warranted.

   • Extract when logic is repeated 2+ times and the abstraction is stable.
   • Do not extract when it makes call sites harder to read or behavior diverges.

4. Extract shared utilities.

   • Create a small function with a focused signature.
   • Place in an existing shared module or create a new

     utils

     /

     shared

     file.
   • Keep side effects explicit and minimize hidden dependencies.

5. Replace duplicates.

   • Update call sites to use the new helper.
   • Remove redundant code and keep names consistent.

6. Verify behavior.

   • Update or add tests when behavior is non-trivial.
   • Run relevant tests or linters if available.

Heuristics

• Prefer simple helpers over deep class refactors.
• Keep params explicit; avoid passing large context objects without need.
• Extract constants for repeated literals (strings, regexes, numbers).
• If duplication is across layers, consider moving logic to the lowest shared layer.

Guardrails

• Avoid introducing new dependencies for small refactors.
• Do not change public APIs unless explicitly requested.
• Preserve performance characteristics; avoid extra allocations in hot paths.

Notes for Codex

• Use

  rg

  for fast discovery and validate with context before editing.
• Keep the diff small and focused; do not mix refactors with unrelated changes.