tmcfarlane/oh-my-cursor/refactoring

# Find all references to a function
grep -rn "function_name" --include="*.py"
 
# Find class usages
grep -rn "ClassName" --include="*.py"
 
# Find imports
grep -rn "from .* import.*function_name" --include="*.py"

def process_order(order):
    # Validate order (candidate for extraction)
    if not order.items:
        raise ValueError("Empty order")
    if order.total < 0:
        raise ValueError("Invalid total")
    for item in order.items:
        if item.quantity <= 0:
            raise ValueError("Invalid quantity")
    # Process payment
    payment_result = gateway.charge(order.total)
    return payment_result

def validate_order(order: Order) -> None:
    """Validate order has valid items and total."""
    if not order.items:
        raise ValueError("Empty order")
    if order.total < 0:
        raise ValueError("Invalid total")
    for item in order.items:
        if item.quantity <= 0:
            raise ValueError("Invalid quantity")
def process_order(order: Order) -> PaymentResult:
    validate_order(order)
    return gateway.charge(order.total)

# Before: God class
class OrderManager:
    def create_order(self): ...
    def validate_order(self): ...
    def calculate_tax(self): ...
    def calculate_shipping(self): ...
    def send_confirmation_email(self): ...
    def send_shipping_notification(self): ...
# After: Focused classes
class OrderService:
    def create_order(self): ...
    def validate_order(self): ...
class PricingService:
    def calculate_tax(self): ...
    def calculate_shipping(self): ...
class NotificationService:
    def send_confirmation_email(self): ...
    def send_shipping_notification(self): ...

# Before: Complex switch
def calculate_price(product_type, base_price):
    if product_type == "physical":
        return base_price + shipping_cost
    elif product_type == "digital":
        return base_price
    elif product_type == "subscription":
        return base_price * 12 * 0.9
    else:
        raise ValueError("Unknown type")
# After: Polymorphism
class Product(ABC):
    @abstractmethod
    def calculate_price(self, base_price): ...
class PhysicalProduct(Product):
    def calculate_price(self, base_price):
        return base_price + self.shipping_cost
class DigitalProduct(Product):
    def calculate_price(self, base_price):
        return base_price
class Subscription(Product):
    def calculate_price(self, base_price):
        return base_price * 12 * 0.9

# Before: Nested conditionals
def process(data):
    if data:
        if data.is_valid:
            if data.is_ready:
                return do_processing(data)
    return None
# After: Guard clauses
def process(data):
    if not data:
        return None
    if not data.is_valid:
        return None
    if not data.is_ready:
        return None
    return do_processing(data)

# Before: Synchronous
def fetch_user(user_id: int) -> User:
    response = requests.get(f"/users/{user_id}")
    return User.from_dict(response.json())
# After: Asynchronous
async def fetch_user(user_id: int) -> User:
    async with aiohttp.ClientSession() as session:
        async with session.get(f"/users/{user_id}") as response:
            data = await response.json()
            return User.from_dict(data)

[ ] Tests exist for affected code
[ ] All tests pass
[ ] Change is well understood
[ ] Impact scope identified
[ ] Rollback plan exists

[ ] All tests still pass
[ ] No new linting errors
[ ] Type checking passes
[ ] Functionality unchanged
[ ] Performance acceptable

# Find and remove:
# - Unused imports
# - Unused variables
# - Unreachable code
# - Commented-out code
# - Deprecated functions
# Tools:
# - vulture (Python)
# - autoflake (Python)
# - eslint (JavaScript)

# Before
if condition == True:
    return True
else:
    return False
# After
return condition

# Before
if user.age >= 18 and user.country in ['US', 'CA'] and user.verified:
    allow_purchase()
# After
is_adult = user.age >= 18
is_supported_country = user.country in ['US', 'CA']
is_verified = user.verified
can_purchase = is_adult and is_supported_country and is_verified
if can_purchase:
    allow_purchase()