9장: CI/CD 통합과 지속적 코드 품질 관리

name: Code Analysis
 
on:
  pull_request:
    branches: [main, develop]
    paths:
      - "src/**"
      - "lib/**"
 
permissions:
  contents: read
  pull-requests: write
 
jobs:
  analyze:
    runs-on: ubuntu-latest
    timeout-minutes: 15
 
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
 
      - name: 의존성 설치
        run: pip install -r requirements-analysis.txt
 
      - name: 변경 파일 목록 추출
        id: changed
        run: |
          FILES=$(git diff --name-only origin/main...HEAD -- '*.py' '*.ts')
          echo "files=$FILES" >> $GITHUB_OUTPUT
 
      - name: AST 기반 메트릭 분석
        run: |
          python scripts/analyze_metrics.py \
            --files="${{ steps.changed.outputs.files }}" \
            --output=metrics.json
 
      - name: 코드 스멜 탐지
        run: |
          python scripts/detect_smells.py \
            --metrics=metrics.json \
            --output=smells.json
 
      - name: LLM 심층 분석
        if: steps.changed.outputs.files != ''
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          python scripts/llm_analysis.py \
            --smells=smells.json \
            --output=analysis.json
 
      - name: 품질 게이트 평가
        id: gate
        run: |
          python scripts/quality_gate.py \
            --analysis=analysis.json \
            --policy=.quality-gate.yml
 
      - name: PR 코멘트 작성
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const analysis = JSON.parse(
              fs.readFileSync('analysis.json', 'utf8')
            );
            const report = buildReport(analysis);
 
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: report,
            });

#!/usr/bin/env python3
"""PR 변경 파일의 메트릭을 분석하는 스크립트"""
 
import argparse
import ast
import json
from pathlib import Path
 
 
def analyze_file(filepath: str) -> dict:
    source = Path(filepath).read_text()
    tree = ast.parse(source)
 
    functions = []
    for node in ast.walk(tree):
        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
            complexity = calculate_complexity(node)
            functions.append({
                "name": node.name,
                "line_start": node.lineno,
                "line_end": node.end_lineno,
                "complexity": complexity,
                "param_count": len(node.args.args),
                "line_count": (node.end_lineno or node.lineno) - node.lineno + 1,
            })
 
    return {
        "filepath": filepath,
        "total_lines": len(source.splitlines()),
        "function_count": len(functions),
        "functions": functions,
        "avg_complexity": (
            sum(f["complexity"] for f in functions) / len(functions)
            if functions else 0
        ),
        "max_complexity": (
            max(f["complexity"] for f in functions)
            if functions else 0
        ),
    }
 
 
def calculate_complexity(node: ast.AST) -> int:
    complexity = 1
    for child in ast.walk(node):
        if isinstance(child, (ast.If, ast.While, ast.For, ast.ExceptHandler)):
            complexity += 1
        elif isinstance(child, ast.BoolOp):
            complexity += len(child.values) - 1
    return complexity
 
 
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--files", required=True)
    parser.add_argument("--output", required=True)
    args = parser.parse_args()
 
    files = [f.strip() for f in args.files.split() if f.strip()]
    results = []
 
    for filepath in files:
        if filepath.endswith(".py") and Path(filepath).exists():
            try:
                results.append(analyze_file(filepath))
            except SyntaxError:
                results.append({
                    "filepath": filepath,
                    "error": "구문 분석 실패",
                })
 
    with open(args.output, "w") as f:
        json.dump(results, f, indent=2, ensure_ascii=False)
 
 
if __name__ == "__main__":
    main()

# 품질 게이트 정책
version: 1
 
# 새 코드에만 적용되는 규칙
new_code:
  max_complexity: 15
  max_function_length: 50
  max_file_length: 400
  max_parameters: 5
  min_test_coverage: 0.8
 
# 전체 코드베이스 규칙 (경고만)
overall:
  max_avg_complexity: 8
  max_tech_debt_hours: 200
  min_code_health: 6
 
# 게이트 동작
actions:
  block:
    - new_code.max_complexity
    - new_code.max_function_length
  warn:
    - new_code.max_parameters
    - overall.max_avg_complexity
  info:
    - overall.max_tech_debt_hours
 
# 예외 허용
exceptions:
  files:
    - "**/*_test.py"
    - "**/*.test.ts"
    - "**/migrations/**"

#!/usr/bin/env python3
"""품질 게이트 평가 스크립트"""
 
import argparse
import json
from dataclasses import dataclass
 
import yaml
 
 
@dataclass
class GateResult:
    passed: bool
    blockers: list[str]
    warnings: list[str]
    info: list[str]
 
 
class QualityGate:
    def __init__(self, policy_path: str):
        with open(policy_path) as f:
            self.policy = yaml.safe_load(f)
 
    def evaluate(self, analysis: list[dict]) -> GateResult:
        blockers = []
        warnings = []
        info_items = []
 
        new_code_rules = self.policy.get("new_code", {})
 
        for file_result in analysis:
            if file_result.get("error"):
                continue
 
            filepath = file_result["filepath"]
 
            # 예외 파일 건너뛰기
            if self._is_exception(filepath):
                continue
 
            for func in file_result.get("functions", []):
                # 복잡도 검사
                max_cx = new_code_rules.get("max_complexity", 15)
                if func["complexity"] > max_cx:
                    blockers.append(
                        f"{filepath}:{func['line_start']} "
                        f"- {func['name']}의 순환 복잡도가 "
                        f"{func['complexity']}입니다 (최대: {max_cx})"
                    )
 
                # 함수 길이 검사
                max_len = new_code_rules.get("max_function_length", 50)
                if func["line_count"] > max_len:
                    blockers.append(
                        f"{filepath}:{func['line_start']} "
                        f"- {func['name']}이(가) {func['line_count']}줄입니다 "
                        f"(최대: {max_len})"
                    )
 
                # 매개변수 수 검사
                max_params = new_code_rules.get("max_parameters", 5)
                if func["param_count"] > max_params:
                    warnings.append(
                        f"{filepath}:{func['line_start']} "
                        f"- {func['name']}의 매개변수가 "
                        f"{func['param_count']}개입니다 (권장: {max_params}개 이하)"
                    )
 
        return GateResult(
            passed=len(blockers) == 0,
            blockers=blockers,
            warnings=warnings,
            info=info_items,
        )
 
    def _is_exception(self, filepath: str) -> bool:
        exceptions = self.policy.get("exceptions", {}).get("files", [])
        from fnmatch import fnmatch
        return any(fnmatch(filepath, pattern) for pattern in exceptions)
 
 
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--analysis", required=True)
    parser.add_argument("--policy", required=True)
    args = parser.parse_args()
 
    with open(args.analysis) as f:
        analysis = json.load(f)
 
    gate = QualityGate(args.policy)
    result = gate.evaluate(analysis)
 
    print(f"품질 게이트: {'통과' if result.passed else '실패'}")
 
    if result.blockers:
        print(f"\n차단 사항 ({len(result.blockers)}건):")
        for b in result.blockers:
            print(f"  - {b}")
 
    if result.warnings:
        print(f"\n경고 ({len(result.warnings)}건):")
        for w in result.warnings:
            print(f"  - {w}")
 
    if not result.passed:
        exit(1)
 
 
if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""LLM 기반 심층 분석 및 리팩터링 제안"""
 
import argparse
import json
from anthropic import Anthropic
 
 
REVIEW_PROMPT = """코드 리뷰어로서 다음 코드 변경을 분석하세요.
 
파일: {filepath}
문제가 있는 함수:
{code}
 
감지된 메트릭:
- 순환 복잡도: {complexity}
- 줄 수: {line_count}
- 매개변수 수: {param_count}
 
다음 형식으로 리뷰를 작성하세요:
 
## 문제 요약
(한 문장으로 핵심 문제를 설명)
 
## 리팩터링 제안
(구체적인 개선 방안을 코드와 함께 제시)
 
### 예상 효과
(리팩터링 후 개선되는 메트릭)"""
 
 
def analyze_with_llm(
    smells_data: list[dict],
    api_key: str,
) -> list[dict]:
    client = Anthropic(api_key=api_key)
    results = []
 
    for file_data in smells_data:
        filepath = file_data["filepath"]
        for smell in file_data.get("smells", []):
            prompt = REVIEW_PROMPT.format(
                filepath=filepath,
                code=smell["code"],
                complexity=smell.get("complexity", "N/A"),
                line_count=smell.get("line_count", "N/A"),
                param_count=smell.get("param_count", "N/A"),
            )
 
            response = client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=[{"role": "user", "content": prompt}],
            )
 
            results.append({
                "filepath": filepath,
                "line": smell.get("line_start", 0),
                "review": response.content[0].text,
                "severity": smell.get("severity", "medium"),
            })
 
    return results
 
 
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--smells", required=True)
    parser.add_argument("--output", required=True)
    args = parser.parse_args()
 
    import os
    api_key = os.environ.get("ANTHROPIC_API_KEY")
    if not api_key:
        print("ANTHROPIC_API_KEY가 설정되지 않았습니다")
        exit(1)
 
    with open(args.smells) as f:
        smells_data = json.load(f)
 
    results = analyze_with_llm(smells_data, api_key)
 
    with open(args.output, "w") as f:
        json.dump(results, f, indent=2, ensure_ascii=False)
 
 
if __name__ == "__main__":
    main()

## Code Analysis Report
 
### 품질 게이트: 실패
 
**차단 사항 (2건)**
- `src/services/order.py:45` - process_order의 순환 복잡도가 23입니다 (최대: 15)
- `src/services/order.py:45` - process_order이(가) 78줄입니다 (최대: 50)
 
---
 
### process_order 리팩터링 제안
 
**문제 요약**: 주문 처리 함수가 유효성 검사, 가격 계산, 재고 관리, 알림까지
다섯 가지 책임을 가지고 있어 순환 복잡도가 23에 달합니다.
 
**리팩터링 제안**: 각 책임을 별도 함수로 추출하고,
오케스트레이션 패턴을 적용하세요.
 
**예상 효과**: 순환 복잡도 23에서 5 이하로, 함수 길이 78줄에서 15줄 이하로 감소

#!/usr/bin/env python3
"""분석 결과를 시계열 데이터로 저장"""
 
import json
from datetime import datetime
from pathlib import Path
 
 
def collect_trend_data(analysis_path: str, output_dir: str):
    with open(analysis_path) as f:
        analysis = json.load(f)
 
    today = datetime.now().strftime("%Y-%m-%d")
    trend_entry = {
        "date": today,
        "total_files": len(analysis),
        "total_functions": sum(
            len(f.get("functions", []))
            for f in analysis if not f.get("error")
        ),
        "avg_complexity": round(
            sum(
                f.get("avg_complexity", 0)
                for f in analysis if not f.get("error")
            ) / max(len(analysis), 1),
            2,
        ),
        "max_complexity": max(
            (f.get("max_complexity", 0) for f in analysis),
            default=0,
        ),
        "high_complexity_count": sum(
            1 for f in analysis
            for func in f.get("functions", [])
            if func.get("complexity", 0) > 15
        ),
        "smell_count": sum(
            len(f.get("smells", []))
            for f in analysis
        ),
    }
 
    # 기존 트렌드 데이터에 추가
    output_path = Path(output_dir) / "trends.json"
    trends = []
    if output_path.exists():
        trends = json.loads(output_path.read_text())
 
    trends.append(trend_entry)
 
    # 최근 90일만 유지
    if len(trends) > 90:
        trends = trends[-90:]
 
    output_path.write_text(
        json.dumps(trends, indent=2, ensure_ascii=False)
    )

name: SonarQube + AI Analysis
 
on:
  pull_request:
    branches: [main]
 
jobs:
  sonar:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: SonarQube 스캔
        uses: sonarsource/sonarqube-scan-action@v2
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
          SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}
 
      - name: SonarQube 결과 대기
        uses: sonarsource/sonarqube-quality-gate-action@v1
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
 
      - name: SonarQube 이슈 추출
        run: |
          curl -s -u "${{ secrets.SONAR_TOKEN }}:" \
            "${{ secrets.SONAR_HOST_URL }}/api/issues/search?componentKeys=my-project&resolved=false" \
            > sonar-issues.json
 
      - name: LLM 기반 이슈 분석 및 수정 제안
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          python scripts/enhance_sonar_issues.py \
            --issues=sonar-issues.json \
            --output=enhanced-analysis.json
 
      - name: PR 코멘트 작성
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const analysis = JSON.parse(
              fs.readFileSync('enhanced-analysis.json', 'utf8')
            );
            // PR 코멘트 작성 로직