5장: LLM 기반 자동 리팩터링

# 리팩터링 전: 하나의 함수에 모든 로직
def process_order(order_data: dict) -> dict:
    # 유효성 검사
    if not order_data.get("customer_id"):
        raise ValueError("고객 ID가 필요합니다")
    if not order_data.get("items"):
        raise ValueError("주문 항목이 필요합니다")
    # ... 50줄 이상의 코드

# 리팩터링 후: 책임별로 분리
def process_order(order_data: dict) -> dict:
    """주문 처리의 오케스트레이션 함수"""
    validate_order(order_data)
    pricing = calculate_pricing(order_data["items"], order_data["customer_id"])
    verify_and_reserve_stock(order_data["items"])
    order = save_order(order_data, pricing)
    notify_customer(order_data["customer_id"], order)
    return order
 
 
def validate_order(order_data: dict) -> None:
    """주문 데이터의 유효성을 검사합니다"""
    if not order_data.get("customer_id"):
        raise ValueError("고객 ID가 필요합니다")
    if not order_data.get("items"):
        raise ValueError("주문 항목이 필요합니다")
    if not isinstance(order_data["items"], list):
        raise TypeError("주문 항목은 리스트여야 합니다")
    for item in order_data["items"]:
        _validate_order_item(item)
 
 
def _validate_order_item(item: dict) -> None:
    if not item.get("product_id"):
        raise ValueError("상품 ID가 필요합니다")
    if not item.get("quantity") or item["quantity"] <= 0:
        raise ValueError("수량은 양수여야 합니다")
 
 
@dataclass
class OrderPricing:
    subtotal: float
    tax: float
    shipping: float
    total: float
 
 
def calculate_pricing(
    items: list[dict], customer_id: str
) -> OrderPricing:
    """주문 금액을 계산합니다"""
    subtotal = sum(
        get_product_price(item["product_id"])
        * item["quantity"]
        * (1 - get_discount(item["product_id"], customer_id))
        for item in items
    )
    tax = subtotal * 0.1
    shipping = 3000 if subtotal < 50000 else 0
    return OrderPricing(
        subtotal=subtotal,
        tax=tax,
        shipping=shipping,
        total=subtotal + tax + shipping,
    )

# 리팩터링 전
def proc(d, f=None, t=None):
    r = []
    for i in d:
        if f and not f(i):
            continue
        if t:
            i = t(i)
        r.append(i)
    return r
 
# 리팩터링 후
def filter_and_transform(
    items: list,
    predicate: Callable | None = None,
    transformer: Callable | None = None,
) -> list:
    results = []
    for item in items:
        if predicate and not predicate(item):
            continue
        if transformer:
            item = transformer(item)
        results.append(item)
    return results

// 리팩터링 전: OrderService가 Product의 내부에 지나치게 의존
class OrderService {
  calculateItemPrice(product: Product, quantity: number): number {
    const basePrice = product.price * quantity;
    const discount = product.category === "premium"
      ? basePrice * 0.1
      : product.category === "sale"
        ? basePrice * 0.2
        : 0;
    return basePrice - discount;
  }
}

// 리팩터링 후: 가격 계산 로직을 Product로 이동
class Product {
  price: number;
  category: string;
 
  calculatePrice(quantity: number): number {
    const basePrice = this.price * quantity;
    return basePrice - this.getDiscount(basePrice);
  }
 
  private getDiscount(basePrice: number): number {
    const discountRates: Record<string, number> = {
      premium: 0.1,
      sale: 0.2,
    };
    return basePrice * (discountRates[this.category] ?? 0);
  }
}
 
class OrderService {
  calculateItemPrice(product: Product, quantity: number): number {
    return product.calculatePrice(quantity);
  }
}

from dataclasses import dataclass
from abc import ABC, abstractmethod
 
 
@dataclass
class RefactorPlan:
    target_files: list[str]
    changes: list[dict]
    rationale: str
    test_strategy: str
 
 
@dataclass
class RefactorResult:
    original_code: dict[str, str]
    refactored_code: dict[str, str]
    compilation_passed: bool
    tests_passed: bool
    reflection_notes: list[str]
    iterations: int
 
 
class BaseAgent(ABC):
    def __init__(self, llm_client):
        self.llm_client = llm_client
 
    @abstractmethod
    async def execute(self, context: dict) -> dict:
        pass
 
 
class PlannerAgent(BaseAgent):
    """1단계: 리팩터링 계획 수립"""
 
    async def execute(self, context: dict) -> dict:
        prompt = f"""다음 코드의 리팩터링 계획을 수립하세요.
 
코드 스멜: {context['smells']}
영향받는 파일: {context['files']}
의존성 그래프: {context['dependencies']}
 
다음을 포함하세요:
1. 변경할 파일과 변경 내용
2. 변경 순서 (의존성 고려)
3. 각 변경의 근거
4. 테스트 전략"""
 
        plan = await self.llm_client.generate(prompt)
        return {"plan": plan}
 
 
class GeneratorAgent(BaseAgent):
    """2단계: 리팩터링된 코드 생성"""
 
    async def execute(self, context: dict) -> dict:
        prompt = f"""다음 계획에 따라 리팩터링된 코드를 생성하세요.
 
원본 코드:
{context['original_code']}
 
리팩터링 계획:
{context['plan']}
 
이전 시도의 피드백:
{context.get('reflection', '첫 번째 시도')}
 
규칙:
- 외부 동작은 변경하지 않습니다
- 기존 테스트가 모두 통과해야 합니다
- 타입 안전성을 유지합니다"""
 
        code = await self.llm_client.generate(prompt)
        return {"refactored_code": code}
 
 
class CompilerAgent(BaseAgent):
    """3단계: 컴파일 검증"""
 
    async def execute(self, context: dict) -> dict:
        # 실제로는 subprocess로 컴파일러를 실행
        code = context["refactored_code"]
        compilation_result = await self._compile(code)
 
        return {
            "compilation_passed": compilation_result["success"],
            "errors": compilation_result.get("errors", []),
        }
 
    async def _compile(self, code: str) -> dict:
        # TypeScript: tsc --noEmit
        # Python: py_compile + mypy
        # Java: javac
        return {"success": True}
 
 
class TesterAgent(BaseAgent):
    """4단계: 테스트 실행"""
 
    async def execute(self, context: dict) -> dict:
        test_result = await self._run_tests(context["refactored_code"])
        return {
            "tests_passed": test_result["all_passed"],
            "failed_tests": test_result.get("failures", []),
            "coverage": test_result.get("coverage", 0),
        }
 
    async def _run_tests(self, code: str) -> dict:
        # pytest, jest, junit 등 실행
        return {"all_passed": True}
 
 
class ReflectionAgent(BaseAgent):
    """5단계: 실패 시 자기 반성 및 피드백"""
 
    async def execute(self, context: dict) -> dict:
        prompt = f"""리팩터링이 실패했습니다. 원인을 분석하세요.
 
컴파일 오류: {context.get('compile_errors', '없음')}
실패한 테스트: {context.get('failed_tests', '없음')}
이전 리팩터링 코드: {context['refactored_code']}
 
다음을 제공하세요:
1. 실패 원인 분석
2. 수정 방향
3. Generator Agent에 전달할 구체적 지시"""
 
        reflection = await self.llm_client.generate(prompt)
        return {"reflection": reflection}

class RefactorOrchestrator:
    """멀티에이전트 리팩터링 오케스트레이터"""
 
    MAX_ITERATIONS = 5
 
    def __init__(self, llm_client):
        self.planner = PlannerAgent(llm_client)
        self.generator = GeneratorAgent(llm_client)
        self.compiler = CompilerAgent(llm_client)
        self.tester = TesterAgent(llm_client)
        self.reflector = ReflectionAgent(llm_client)
 
    async def refactor(
        self,
        original_code: dict[str, str],
        smells: list[dict],
        dependencies: dict,
    ) -> RefactorResult:
        # 1단계: 계획 수립
        context = {
            "smells": smells,
            "files": list(original_code.keys()),
            "dependencies": dependencies,
            "original_code": original_code,
        }
        plan_result = await self.planner.execute(context)
        context.update(plan_result)
 
        iterations = 0
        reflection_notes = []
 
        while iterations < self.MAX_ITERATIONS:
            iterations += 1
 
            # 2단계: 코드 생성
            gen_result = await self.generator.execute(context)
            context.update(gen_result)
 
            # 3단계: 컴파일 검증
            compile_result = await self.compiler.execute(context)
 
            if not compile_result["compilation_passed"]:
                context["compile_errors"] = compile_result["errors"]
                reflect_result = await self.reflector.execute(context)
                context.update(reflect_result)
                reflection_notes.append(
                    f"반복 {iterations}: 컴파일 실패"
                )
                continue
 
            # 4단계: 테스트 실행
            test_result = await self.tester.execute(context)
 
            if test_result["tests_passed"]:
                return RefactorResult(
                    original_code=original_code,
                    refactored_code=context["refactored_code"],
                    compilation_passed=True,
                    tests_passed=True,
                    reflection_notes=reflection_notes,
                    iterations=iterations,
                )
 
            # 5단계: 반성
            context["failed_tests"] = test_result["failed_tests"]
            reflect_result = await self.reflector.execute(context)
            context.update(reflect_result)
            reflection_notes.append(
                f"반복 {iterations}: 테스트 실패 "
                f"({len(test_result['failed_tests'])}건)"
            )
 
        raise RuntimeError(
            f"{self.MAX_ITERATIONS}회 반복 후에도 리팩터링 실패"
        )

# Spring Boot 2에서 3으로 마이그레이션 레시피
type: specs.openrewrite.org/v1beta/recipe
name: org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_0
displayName: Migrate to Spring Boot 3.0
description: >
  Spring Boot 2.x 애플리케이션을 3.0으로 마이그레이션합니다.
  Jakarta EE 전환, 설정 변경, 더 이상 사용하지 않는 API 교체를 포함합니다.
recipeList:
  - org.openrewrite.java.spring.boot3.RemoveEnableBatchProcessing
  - org.openrewrite.java.migrate.jakarta.JavaxMigrationToJakarta
  - org.openrewrite.java.spring.boot3.ConfigurationOverEnableSecurity