mcpField
C
code-refactor

code-refactor

github.com/laurigatesDevelopment5972 installsUpdated 1d ago
Repository

About code-refactor

code-refactor is a skill that delegates refactoring of a specified file or directory to the agents-plugin:refactor agent. It targets functional programming improvements while requiring behavior and external API contracts to remain unchanged.

Key features

  1. 01Delegate a target path to a specialized agent
  2. 02Identify side effects, mutable state, and deep nesting
  3. 03Apply pure functions, immutable transformations, and composition
  4. 04Preserve existing behavior and external APIs
  5. 05Require existing tests to pass

Use cases

  1. 01Separate business logic from I/O
  2. 02Reduce in-place mutation of state or parameters
  3. 03Replace imperative loops with higher-order functions
  4. 04Make intent clearer by reducing deep nesting

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/laurigates/claude-plugins --skill code-refactor

After installing, type/code-refactorin Claude Code to confirm it loaded.

Details

From the project README

When to Use This Skill

Use this skill when...Use something else when...
A file or directory has mixed side effects and business logicDeduplicating code across files → /code:dry-consolidation
Functions mutate state or parametersDetecting code smells without fixing → /code:antipatterns
Business logic is tangled with I/O or loggingReviewing overall quality and architecture → /code:review
Imperative loops can be replaced with map/filter/reduceLarge multi-phase refactor spanning 10+ files → /workflow:checkpoint-refactor
Deep nesting obscures intent

Context

  • Target path: !echo "$1"

Parameters

  • $1: Required file path or directory to refactor

Your task

Delegate this task to the agents-plugin:refactor agent.

Use the Agent tool with subagent_type: agents-plugin:refactor to refactor the specified code. Pass all the context gathered in Context to the agent.

The refactor agent should:

  1. Identify refactoring opportunities — look for these FP code smells:

    • Side effects (mutation, I/O, logging) mixed into computation functions
    • Parameters or external state mutated in place
    • Imperative loops (for, while) that could be map, filter, reduce, or flatMap
    • Shared mutable state accessed across functions
    • Deep nesting where early returns or guard clauses would clarify intent
    • Business logic entangled with I/O at call sites
    • Duplicated transformation logic

  2. Apply functional programming principles:

    • Pure functions: Extract computation into functions with no side effects — same input always produces same output
    • Immutability: Replace in-place mutation with data transformations (spread, map, Object.assign, structural copies)
    • Composition: Build complex behavior from small, focused, single-purpose functions
    • Higher-order functions: Replace imperative loops with map, filter, reduce, flatMap, find
    • Explicit effects: Push I/O, logging, and mutations to the outermost boundary; keep inner functions pure
    • Early returns / guard clauses: Validate preconditions at the top, return early to avoid deep nesting
    • DRY / KISS: Eliminate repetition; prefer the simplest shape that works

  3. Preserve functionality:

    • Ensure all existing tests pass
    • Maintain the external API contract
    • No behavioral changes

  4. Output the refactored code with clear structure

Provide the agent with:

  • The target file or directory path
  • The detected programming language
  • Any style guide examples from the project

The agent has expertise in:

  • Behavior-preserving code transformations
  • Functional refactoring patterns
  • Code smell detection and remediation
  • Semantic code search for similar patterns

Related Skills

  • If complexity metrics needed before refactoring → /code:complexity
  • If duplicated code needs consolidation → /code:dry-consolidation
  • If linting standards not configured → /configure:linting

Comments

Markdown supported