Lsp Refactoring

LSP Refactoring

Refactoring workflow that combines language server capabilities with code search and test-driven verification for safe, precise code transformations.

When to Use This Skill

• Renaming symbols across an entire workspace
• Extracting functions, classes, or modules
• Moving code between files with automatic reference updates
• Large-scale pattern-based code transformations
• Any refactoring where manual find-replace is error-prone

What This Skill Does

Phase 1: Analysis — Understand Before Changing

• Scope assessment: Find all usages of the target symbol using grep or IDE references
• Dependency graph: Trace where the symbol is defined and what depends on it
• Impact analysis: Identify all files that will be affected
• Pattern discovery: Search for similar patterns that should be refactored consistently

# Find all usages of a function
grep -rn "getUserData" src/ --include="*.ts"

# Find pattern across codebase with AST-aware tools (if available)
# e.g., ast-grep, semgrep, or comby
ast-grep --pattern 'console.log($MSG)' --lang typescript

Phase 2: Plan — Design the Transformation

• Pre-flight check: Run the type checker / linter to capture baseline errors
• Rename validation: Verify the symbol can be safely renamed (no conflicts)
• Transformation plan: List each change with file, line, before/after
• Test identification: Find tests covering the code being refactored

Phase 3: Execute — Apply Changes Safely

For renames (use IDE/editor capabilities when available):

# Using sed for simple renames
find src/ -name "*.ts" -exec sed -i '' 's/getUserData/fetchUserProfile/g' {} +

# Or use language-specific tools
# TypeScript: ts-morph, jscodeshift
# Python: rope, bowler
# Go: gorename

For pattern-based transformations:

# Using ast-grep (if installed)
ast-grep --pattern 'console.log($MSG)' --rewrite 'logger.info($MSG)' --lang typescript

# Using comby
comby 'console.log(:[msg])' 'logger.info(:[msg])' .ts

For structural changes (extract/move):

• Create the new target (file, function, class)
• Move the code
• Update all references using LSP rename
• Remove the old code
• Verify no dangling references

Phase 4: Verify — TDD Confirmation

• Type check: Run the project type checker — must be clean

   npx tsc --noEmit          # TypeScript
   mypy src/                  # Python
   go vet ./...               # Go

• Build check: Run project build — must pass
• Test check: Run test suite — all previously passing tests must still pass
• Diff review: git diff to review the complete changes for unintended modifications

If any check fails:

• Revert changes: git checkout -- .
• Analyze the failure
• Adjust approach and retry

Approach by Language

| Language | Rename Tool | Pattern Search | Type Check |

|----------|-------------|----------------|------------|

| TypeScript | ts-morph, jscodeshift | ast-grep, semgrep | tsc --noEmit |

| Python | rope, bowler | ast-grep, semgrep | mypy, pyright |

| Go | gorename, gopls | ast-grep, semgrep | go vet |

| Java | IntelliJ refactor, openrewrite | semgrep | javac |

| Rust | rust-analyzer | ast-grep | cargo check |

Anti-Patterns

• Manual find-replace without verifying all references — misses dynamic usages
• Skipping type check after rename — may introduce type errors
• Not running tests after refactoring — behavior may have changed
• Refactoring while fixing bugs — do one or the other, never both

Example

User: "Rename getUserData to fetchUserProfile across the project"

Output:

• grep -rn finds 23 usages across 8 files
• Applies rename using sed/jscodeshift across all locations
• tsc --noEmit passes with no errors
• npm test — 47 tests pass
• git diff shows clean, focused changes

Inspired by: oh-my-opencode /refactor command