4장: 코드 스멜 감지와 기술 부채 정량화

def process_order(order_data: dict) -> dict:
    """전형적인 '긴 메서드' 코드 스멜 예시"""
    # 유효성 검사 (20줄)
    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"]:
        if not item.get("product_id"):
            raise ValueError("상품 ID가 필요합니다")
        if not item.get("quantity") or item["quantity"] <= 0:
            raise ValueError("수량은 양수여야 합니다")
 
    # 가격 계산 (15줄)
    subtotal = 0
    for item in order_data["items"]:
        price = get_product_price(item["product_id"])
        discount = get_discount(
            item["product_id"], order_data["customer_id"]
        )
        item_total = price * item["quantity"] * (1 - discount)
        subtotal += item_total
 
    tax = subtotal * 0.1
    shipping = 3000 if subtotal < 50000 else 0
    total = subtotal + tax + shipping
 
    # 재고 확인 및 차감 (10줄)
    for item in order_data["items"]:
        stock = check_stock(item["product_id"])
        if stock < item["quantity"]:
            raise ValueError(f"재고 부족: {item['product_id']}")
        decrease_stock(item["product_id"], item["quantity"])
 
    # 주문 저장 (10줄)
    order = {
        "customer_id": order_data["customer_id"],
        "items": order_data["items"],
        "subtotal": subtotal,
        "tax": tax,
        "shipping": shipping,
        "total": total,
        "status": "confirmed",
    }
    save_order(order)
 
    # 알림 발송 (5줄)
    send_email(order_data["customer_id"], "주문 확인", order)
    send_push_notification(order_data["customer_id"], "주문이 확인되었습니다")
 
    return order

from dataclasses import dataclass
from enum import Enum
 
 
class SmellSeverity(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
 
class SmellCategory(Enum):
    BLOATER = "bloater"
    OO_ABUSER = "oo_abuser"
    CHANGE_PREVENTER = "change_preventer"
    DISPENSABLE = "dispensable"
    COUPLER = "coupler"
 
 
@dataclass
class CodeSmell:
    name: str
    category: SmellCategory
    severity: SmellSeverity
    location: str
    description: str
    suggestion: str
    confidence: float  # 0.0 ~ 1.0
 
 
SMELL_DETECTION_PROMPT = """다음 코드를 분석하고 코드 스멜을 탐지하세요.
 
코드:
---
{code}
---
 
메트릭 정보:
- 순환 복잡도: {complexity}
- 줄 수: {line_count}
- 매개변수 수: {param_count}
- 의존성 수: {dependency_count}
 
다음 코드 스멜 유형을 확인하세요:
1. 비대함: 긴 메서드, 큰 클래스, 긴 매개변수 목록
2. 객체지향 남용: Switch 문 남용, 거부된 유산
3. 변경 방해: 산탄총 수술, 분산된 변경
4. 불필요한 것: 중복 코드, 죽은 코드
5. 결합도: 기능 선망, 부적절한 친밀
 
각 스멜에 대해 다음을 제공하세요:
- 스멜 이름
- 심각도 (low/medium/high/critical)
- 해당 위치 (줄 번호 또는 함수명)
- 구체적 설명
- 리팩터링 제안
- 확신도 (0.0-1.0)"""
 
 
class LLMSmellDetector:
    """LLM을 활용한 코드 스멜 탐지기"""
 
    def __init__(self, llm_client, ast_analyzer):
        self.llm_client = llm_client
        self.ast_analyzer = ast_analyzer
 
    async def detect_smells(
        self, source: str, filepath: str
    ) -> list[CodeSmell]:
        # AST 기반 사전 분석
        metrics = self.ast_analyzer.analyze(source)
 
        # 메트릭 기반 1차 필터링
        candidates = self._filter_candidates(metrics)
 
        smells = []
        for candidate in candidates:
            # LLM 기반 심층 분석
            prompt = SMELL_DETECTION_PROMPT.format(
                code=candidate["code"],
                complexity=candidate["complexity"],
                line_count=candidate["line_count"],
                param_count=candidate["param_count"],
                dependency_count=candidate["dependency_count"],
            )
 
            response = await self.llm_client.generate(prompt)
            detected = self._parse_smells(response)
            smells.extend(detected)
 
        return self._deduplicate_and_rank(smells)
 
    def _filter_candidates(self, metrics: dict) -> list[dict]:
        """메트릭 임계값으로 1차 필터링"""
        candidates = []
        for func in metrics.get("functions", []):
            if (func["complexity"] > 5
                    or func["line_count"] > 20
                    or func["param_count"] > 4):
                candidates.append(func)
        return candidates
 
    def _deduplicate_and_rank(
        self, smells: list[CodeSmell]
    ) -> list[CodeSmell]:
        """중복 제거 및 심각도/확신도 기준 정렬"""
        seen = set()
        unique = []
        for smell in smells:
            key = (smell.name, smell.location)
            if key not in seen:
                seen.add(key)
                unique.append(smell)
 
        return sorted(
            unique,
            key=lambda s: (
                s.severity.value,
                -s.confidence,
            ),
            reverse=True,
        )
 
    def _parse_smells(self, response: str) -> list[CodeSmell]:
        # LLM 응답 파싱 (간략화)
        return []

import subprocess
from collections import Counter
from dataclasses import dataclass
 
 
@dataclass
class Hotspot:
    filepath: str
    change_frequency: int
    complexity: float
    hotspot_score: float
    last_change: str
 
 
class HotspotAnalyzer:
    """Git 히스토리 기반 핫스팟 분석"""
 
    def __init__(self, repo_path: str, months: int = 6):
        self.repo_path = repo_path
        self.months = months
 
    def analyze(self) -> list[Hotspot]:
        # Git 로그에서 변경 빈도 추출
        change_freq = self._get_change_frequencies()
 
        # 각 파일의 복잡도 계산
        hotspots = []
        for filepath, freq in change_freq.most_common(50):
            complexity = self._calculate_file_complexity(filepath)
            score = freq * complexity  # 핫스팟 점수
 
            hotspots.append(Hotspot(
                filepath=filepath,
                change_frequency=freq,
                complexity=round(complexity, 2),
                hotspot_score=round(score, 2),
                last_change=self._get_last_change(filepath),
            ))
 
        return sorted(hotspots, key=lambda h: h.hotspot_score, reverse=True)
 
    def _get_change_frequencies(self) -> Counter:
        result = subprocess.run(
            [
                "git", "log",
                f"--since={self.months} months ago",
                "--name-only",
                "--pretty=format:",
            ],
            capture_output=True,
            text=True,
            cwd=self.repo_path,
        )
 
        files = [
            line.strip() for line in result.stdout.splitlines()
            if line.strip() and not line.startswith(".")
        ]
        return Counter(files)
 
    def _calculate_file_complexity(self, filepath: str) -> float:
        # AST 기반 복잡도 계산 (간략화)
        return 1.0
 
    def _get_last_change(self, filepath: str) -> str:
        result = subprocess.run(
            ["git", "log", "-1", "--format=%ci", "--", filepath],
            capture_output=True,
            text=True,
            cwd=self.repo_path,
        )
        return result.stdout.strip()

from dataclasses import dataclass
from enum import Enum
 
 
class DebtCategory(Enum):
    DESIGN = "design"
    CODE = "code"
    TEST = "test"
    DOCUMENTATION = "documentation"
    DEPENDENCY = "dependency"
 
 
@dataclass
class TechnicalDebt:
    category: DebtCategory
    description: str
    estimated_hours: float
    business_impact: str  # low, medium, high, critical
    affected_files: list[str]
    priority_score: float
 
 
class DebtCalculator:
    """기술 부채를 정량화하는 도구"""
 
    SEVERITY_WEIGHTS = {
        "critical": 4.0,
        "high": 3.0,
        "medium": 2.0,
        "low": 1.0,
    }
 
    def calculate_debt(
        self,
        smells: list[dict],
        hotspots: list[dict],
        test_coverage: float,
    ) -> list[TechnicalDebt]:
        debts = []
 
        # 코드 스멜 기반 부채
        for smell in smells:
            hours = self._estimate_remediation_hours(smell)
            debts.append(TechnicalDebt(
                category=DebtCategory.CODE,
                description=smell["description"],
                estimated_hours=hours,
                business_impact=smell["severity"],
                affected_files=smell.get("files", []),
                priority_score=self._calculate_priority(
                    hours, smell["severity"],
                    smell.get("change_frequency", 1),
                ),
            ))
 
        # 핫스팟 기반 부채
        for hotspot in hotspots:
            if hotspot["complexity"] > 15:
                debts.append(TechnicalDebt(
                    category=DebtCategory.DESIGN,
                    description=(
                        f"핫스팟 파일 리팩터링 필요: {hotspot['filepath']}"
                    ),
                    estimated_hours=hotspot["complexity"] * 0.5,
                    business_impact="high",
                    affected_files=[hotspot["filepath"]],
                    priority_score=hotspot["hotspot_score"],
                ))
 
        # 테스트 커버리지 부채
        if test_coverage < 0.6:
            debts.append(TechnicalDebt(
                category=DebtCategory.TEST,
                description=(
                    f"테스트 커버리지 부족: {test_coverage:.0%}"
                ),
                estimated_hours=(0.6 - test_coverage) * 100,
                business_impact="high",
                affected_files=[],
                priority_score=100 * (0.6 - test_coverage),
            ))
 
        return sorted(debts, key=lambda d: d.priority_score, reverse=True)
 
    def _estimate_remediation_hours(self, smell: dict) -> float:
        base_hours = {
            "long_method": 2.0,
            "large_class": 4.0,
            "duplicate_code": 3.0,
            "dead_code": 0.5,
            "feature_envy": 2.0,
            "shotgun_surgery": 6.0,
        }
        return base_hours.get(smell.get("type", ""), 2.0)
 
    def _calculate_priority(
        self,
        hours: float,
        severity: str,
        change_frequency: int,
    ) -> float:
        """우선순위 = 심각도 가중치 * 변경 빈도 / 수정 시간"""
        weight = self.SEVERITY_WEIGHTS.get(severity, 1.0)
        return (weight * change_frequency) / max(hours, 0.5)