refactor-method-complexity-reduce

SKILL.md

Refactor Method to Reduce Cognitive Complexity

Objective

Refactor the method ${input:methodName}, to reduce its cognitive complexity to ${input:complexityThreshold} or below, by extracting logic into focused helper methods.

Instructions

Analyze the current method to identify sources of cognitive complexity:

Nested conditional statements

Multiple if-else or switch chains

Repeated code blocks

Multiple loops with conditions

Complex boolean expressions

Identify extraction opportunities:

Validation logic that can be extracted into a separate method

Type-specific or case-specific processing that repeats

Complex transformations or calculations

Common patterns that appear multiple times

Extract focused helper methods:

Each helper should have a single, clear responsibility

Extract validation into separate Validate* methods

Extract type-specific logic into handler methods

Create utility methods for common operations

Use appropriate access levels (static, private, async)

Simplify the main method:

Reduce nesting depth

Replace massive if-else chains with smaller orchestrated calls

Use switch statements where appropriate for cleaner dispatch

Ensure the main method reads as a high-level flow

Preserve functionality:

Maintain the same input/output behavior

Keep all validation and error handling

Preserve exception types and error messages

Ensure all parameters are properly passed to helpers

Best practices:

Make helper methods static when they don't need instance state

Use null checks and guard clauses early

Avoid creating unnecessary local variables

Consider using tuples for multiple return values

Group related helper methods together

Implementation Approach

Extract helper methods before refactoring the main flow

Test incrementally to ensure no regressions

Use meaningful names that describe the extracted responsibility

Keep extracted methods close to where they're used

Consider making repeated code patterns into generic methods

Result

The refactored method should:

Have cognitive complexity reduced to the target threshold of ${input:complexityThreshold} or below

Be more readable and maintainable

Have clear separation of concerns

Be easier to test and debug

Retain all original functionality

Testing and Validation

CRITICAL: After completing the refactoring, you MUST:

Run all existing tests related to the refactored method and its surrounding functionality

MANDATORY: Explicitly verify test results show "failed=0"

NEVER assume tests passed - always examine the actual test output

Search for the summary line containing pass/fail counts (e.g., "passed=X failed=Y")

If the summary shows any number other than "failed=0", tests have FAILED

If test output is in a file, read the entire file to locate and verify the failure count

Running tests is NOT the same as verifying tests passed

Do not proceed until you have explicitly confirmed zero failures

If any tests fail (failed > 0):

State clearly how many tests failed

Analyze each failure to understand what functionality was broken

Common causes: null handling, empty collection checks, condition logic errors

Identify the root cause in the refactored code

Correct the refactored code to restore the original behavior

Re-run tests and verify "failed=0" in the output

Repeat until all tests pass (failed=0)

Verify compilation - Ensure there are no compilation errors

Check cognitive complexity - Confirm the metric is at or below the target threshold of ${input:complexityThreshold}

Confirmation Checklist

 Code compiles without errors

 Test results explicitly state "failed=0" (verified by reading the output)

 All test failures analyzed and corrected (if any occurred)

 Cognitive complexity is at or below the target threshold of ${input:complexityThreshold}

 All original functionality is preserved

 Code follows project conventions and standards