1
2
3
4
5
6
7
8
9

graph TD
    A[사용자: 버그 수정 요청] --> B[LLM: 코드 분석]
    B --> C[LLM: 수정 코드 생성]
    C --> D[LLM: 수정 완료 응답]
    D --> E[사용자: 코드 실행]
    E --> F{실행 결과}
    F -->|성공| G[문제 해결]
    F -->|실패| H[다시 수정 요청]
    H --> B

1
2
3
4
5
6
7
8
9

graph TD
    A[수정 요청] --> B[LLM: 코드 분석]
    B --> C[LLM: 수정 코드 생성]
    C --> D[샌드박스: 코드 실행]
    D --> E[실행 결과 수집]
    E --> F{결과 검증}
    F -->|성공| G[수정 코드 + 증거 출력]
    F -->|실패| H[LLM: 재시도]
    H --> C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import subprocess
import tempfile
import os
from dataclasses import dataclass
from typing import Optional, Tuple

@dataclass
class Leceipt:
    """AI 응답의 신뢰성을 증명하는 영수증"""
    code: str
    output: str
    exit_code: int
    execution_time: float
    is_successful: bool
    
    def to_markdown(self) -> str:
        status = "✅ 성공" if self.is_successful else "❌ 실패"
        return f"""
### 실행 결과 (Leceipt)
- **상태**: {status}
- **종료 코드**: {self.exit_code}
- **실행 시간**: {self.execution_time:.3f}초

**출력**:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

"""

def execute_code_safely(code: str, timeout: int = 10) -> Leceipt:
    """샌드박스 환경에서 코드를 실행하고 결과를 반환"""
    import time
    
    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
        f.write(code)
        temp_file = f.name
    
    try:
        start_time = time.time()
        result = subprocess.run(
            ['python', temp_file],
            capture_output=True,
            text=True,
            timeout=timeout
        )
        execution_time = time.time() - start_time
        
        return Leceipt(
            code=code,
            output=result.stdout + result.stderr,
            exit_code=result.returncode,
            execution_time=execution_time,
            is_successful=result.returncode == 0
        )
    except subprocess.TimeoutExpired:
        return Leceipt(
            code=code,
            output="실행 시간 초과",
            exit_code=-1,
            execution_time=timeout,
            is_successful=False
        )
    finally:
        os.unlink(temp_file)

def verify_fix_with_leceipt(
    original_code: str,
    fixed_code: str,
    test_input: Optional[str] = None
) -> Tuple[Leceipt, Leceipt]:
    """수정 전후 코드를 실행하고 결과를 비교"""
    before_receipt = execute_code_safely(original_code)
    after_receipt = execute_code_safely(fixed_code)
    
    print("=== 수정 전 ===")
    print(before_receipt.to_markdown())
    print("
=== 수정 후 ===")
    print(after_receipt.to_markdown())
    
    if not after_receipt.is_successful:
        print("⚠️ 경고: 수정된 코드가 여전히 실패합니다!")
    
    return before_receipt, after_receipt

# 사용 예시
original = """
def calculate_average(numbers):
    return sum(numbers) / len(numbers)

result = calculate_average([])
print(result)
"""

fixed = """
def calculate_average(numbers):
    if len(numbers) == 0:
        return 0
    return sum(numbers) / len(numbers)

result = calculate_average([])
print(result)
"""

verify_fix_with_leceipt(original, fixed)

1
2
3
4
5
6
7
8

SHOW_GN_PROMPT = """
당신은 코드 수정 어시스턴트입니다. 다음 규칙을 엄격히 준수하세요:

1. 코드를 수정한 후, 반드시 수정된 전체 코드를 제공하세요.
2. 수정된 코드가 실제로 실행 가능한지 확인하는 테스트 케이스를 작성하세요.
3. 다음 형식으로 응답하세요:

## 수정된 코드

1
2

## 테스트 케이스

1
2

## 예상 출력

1
2
3
4

중요: 테스트 케이스 없는 수정은 제공하지 마세요.
"수정했습니다"라는 응답만으로는 충분하지 않습니다.
"""

1
2
3
4

# Docker를 활용한 샌드박스 환경
docker run -d --name code-sandbox \
  -v /tmp/code-execution:/workspace \
  python:3.11-slim

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

from typing import Protocol

class CodeExecutor(Protocol):
    def execute(self, code: str) -> Leceipt: ...

class VerificationPipeline:
    def __init__(self, executor: CodeExecutor, max_retries: int = 3):
        self.executor = executor
        self.max_retries = max_retries
    
    def verify_and_fix(
        self,
        llm_client,
        original_code: str,
        error_message: str
    ) -> Tuple[str, Leceipt]:
        
        for attempt in range(self.max_retries):
            # LLM에게 수정 요청
            fix_prompt = f"""
            다음 코드의 버그를 수정하세요:
            
            원본 코드:
            ```
            {original_code}
            ```
            
            에러 메시지:
            ```
            {error_message}
            ```
            
            Show GN 규칙: 반드시 실행 가능한 코드만 제공하세요.
            """
            
            fixed_code = llm_client.generate(fix_prompt)
            receipt = self.executor.execute(fixed_code)
            
            if receipt.is_successful:
                return fixed_code, receipt
            
            error_message = receipt.output
        
        raise RuntimeError(f"수정 실패: {self.max_retries}회 시도 후에도 해결 불가")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import logging
from collections import defaultdict

class VerificationMonitor:
    def __init__(self):
        self.stats = defaultdict(int)
        self.logger = logging.getLogger("show_gn")
    
    def record_verification(
        self,
        success: bool,
        attempt_count: int,
        execution_time: float
    ):
        self.stats["total_verifications"] += 1
        if success:
            self.stats["successful"] += 1
        self.stats["avg_attempts"] = (
            (self.stats["avg_attempts"] * (self.stats["total_verifications"] - 1) + attempt_count)
            / self.stats["total_verifications"]
        )
        
        self.logger.info(
            f"검증 완료 - 성공: {success}, 시도: {attempt_count}, "
            f"소요 시간: {execution_time:.2f}초"
        )