6장: 코드 마이그레이션 자동화

// 마이그레이션 전: Java
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
 
    public UserService(UserRepository userRepository,
                       EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
 
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }
 
    public User createUser(String name, String email) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty");
        }
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid email");
        }
 
        User user = new User();
        user.setName(name);
        user.setEmail(email);
        user.setCreatedAt(LocalDateTime.now());
 
        User saved = userRepository.save(user);
        emailService.sendWelcomeEmail(saved);
        return saved;
    }
 
    public List<User> findActiveUsers() {
        return userRepository.findAll().stream()
            .filter(User::isActive)
            .sorted(Comparator.comparing(User::getCreatedAt).reversed())
            .collect(Collectors.toList());
    }
}

// 마이그레이션 후: Kotlin
class UserService(
    private val userRepository: UserRepository,
    private val emailService: EmailService,
) {
    fun findById(id: Long): User? =
        userRepository.findById(id).orElse(null)
 
    fun createUser(name: String, email: String): User {
        require(name.isNotBlank()) { "Name cannot be empty" }
        require(email.contains("@")) { "Invalid email" }
 
        val user = User(
            name = name,
            email = email,
            createdAt = LocalDateTime.now(),
        )
 
        return userRepository.save(user).also { saved ->
            emailService.sendWelcomeEmail(saved)
        }
    }
 
    fun findActiveUsers(): List<User> =
        userRepository.findAll()
            .filter { it.isActive }
            .sortedByDescending { it.createdAt }
}

interface MigrationConfig {
  sourceDir: string;
  targetDir: string;
  tsConfigPath: string;
  strictMode: boolean;
}
 
interface MigrationResult {
  file: string;
  status: "success" | "partial" | "failed";
  typesAdded: number;
  anyTypesRemaining: number;
  errors: string[];
}
 
async function migrateJsToTs(
  config: MigrationConfig,
  llmClient: LLMClient,
): Promise<MigrationResult[]> {
  const results: MigrationResult[] = [];
  const jsFiles = await glob(`${config.sourceDir}/**/*.js`);
 
  for (const jsFile of jsFiles) {
    const source = await readFile(jsFile, "utf-8");
    const tsFile = jsFile.replace(/\.js$/, ".ts");
 
    // 1단계: 기본 변환 (확장자 변경 + import 수정)
    let converted = convertBasicSyntax(source);
 
    // 2단계: LLM 기반 타입 추론
    const prompt = buildTypeInferencePrompt(converted, config.strictMode);
    const typed = await llmClient.generate(prompt);
 
    // 3단계: 타입 검증
    const validationResult = await validateTypes(typed, config.tsConfigPath);
 
    if (validationResult.errors.length > 0) {
      // 4단계: 오류 수정 시도
      const fixPrompt = buildFixPrompt(typed, validationResult.errors);
      const fixed = await llmClient.generate(fixPrompt);
      await writeFile(tsFile, fixed);
    } else {
      await writeFile(tsFile, typed);
    }
 
    results.push({
      file: tsFile,
      status: validationResult.errors.length === 0 ? "success" : "partial",
      typesAdded: countTypes(typed),
      anyTypesRemaining: countAnyTypes(typed),
      errors: validationResult.errors,
    });
  }
 
  return results;
}

// 마이그레이션 전: Class 컴포넌트
interface UserProfileProps {
  userId: string;
}
 
interface UserProfileState {
  user: User | null;
  loading: boolean;
  error: string | null;
}
 
class UserProfile extends React.Component<UserProfileProps, UserProfileState> {
  state: UserProfileState = {
    user: null,
    loading: true,
    error: null,
  };
 
  componentDidMount() {
    this.fetchUser();
  }
 
  componentDidUpdate(prevProps: UserProfileProps) {
    if (prevProps.userId !== this.props.userId) {
      this.fetchUser();
    }
  }
 
  componentWillUnmount() {
    this.abortController?.abort();
  }
 
  private abortController: AbortController | null = null;
 
  async fetchUser() {
    this.abortController?.abort();
    this.abortController = new AbortController();
 
    this.setState({ loading: true, error: null });
 
    try {
      const response = await fetch(`/api/users/${this.props.userId}`, {
        signal: this.abortController.signal,
      });
      const user = await response.json();
      this.setState({ user, loading: false });
    } catch (err) {
      if (err instanceof Error && err.name !== "AbortError") {
        this.setState({ error: err.message, loading: false });
      }
    }
  }
 
  render() {
    const { user, loading, error } = this.state;
 
    if (loading) return <div>Loading...</div>;
    if (error) return <div>Error: {error}</div>;
    if (!user) return null;
 
    return (
      <div>
        <h1>{user.name}</h1>
        <p>{user.email}</p>
      </div>
    );
  }
}

// 마이그레이션 후: Hooks 기반 함수형 컴포넌트
interface UserProfileProps {
  userId: string;
}
 
function useUser(userId: string) {
  const [user, setUser] = useState<User | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
 
  useEffect(() => {
    const abortController = new AbortController();
 
    async function fetchUser() {
      setLoading(true);
      setError(null);
 
      try {
        const response = await fetch(`/api/users/${userId}`, {
          signal: abortController.signal,
        });
        const data = await response.json();
        setUser(data);
        setLoading(false);
      } catch (err) {
        if (err instanceof Error && err.name !== "AbortError") {
          setError(err.message);
          setLoading(false);
        }
      }
    }
 
    fetchUser();
    return () => abortController.abort();
  }, [userId]);
 
  return { user, loading, error };
}
 
function UserProfile({ userId }: UserProfileProps) {
  const { user, loading, error } = useUser(userId);
 
  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;
  if (!user) return null;
 
  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.email}</p>
    </div>
  );
}

import subprocess
import json
from dataclasses import dataclass
 
 
@dataclass
class EquivalenceResult:
    test_case: str
    original_output: str
    migrated_output: str
    is_equivalent: bool
    difference: str | None
 
 
class EquivalenceTester:
    """원본과 마이그레이션 코드의 동작 동등성 검증"""
 
    def __init__(
        self,
        original_runner: str,
        migrated_runner: str,
    ):
        self.original_runner = original_runner
        self.migrated_runner = migrated_runner
 
    def test_equivalence(
        self,
        test_cases: list[dict],
    ) -> list[EquivalenceResult]:
        results = []
 
        for case in test_cases:
            original_output = self._run(
                self.original_runner, case["input"]
            )
            migrated_output = self._run(
                self.migrated_runner, case["input"]
            )
 
            is_eq = self._compare_outputs(
                original_output, migrated_output,
                tolerance=case.get("tolerance", 0),
            )
 
            results.append(EquivalenceResult(
                test_case=case["name"],
                original_output=original_output,
                migrated_output=migrated_output,
                is_equivalent=is_eq,
                difference=None if is_eq else self._diff(
                    original_output, migrated_output
                ),
            ))
 
        return results
 
    def _run(self, runner: str, input_data: str) -> str:
        result = subprocess.run(
            [runner],
            input=input_data,
            capture_output=True,
            text=True,
            timeout=30,
        )
        return result.stdout
 
    def _compare_outputs(
        self,
        original: str,
        migrated: str,
        tolerance: float = 0,
    ) -> bool:
        if tolerance == 0:
            return original.strip() == migrated.strip()
 
        # 수치 비교 시 허용 오차 적용
        try:
            orig_val = float(original.strip())
            migr_val = float(migrated.strip())
            return abs(orig_val - migr_val) <= tolerance
        except ValueError:
            return original.strip() == migrated.strip()
 
    def _diff(self, original: str, migrated: str) -> str:
        orig_lines = original.splitlines()
        migr_lines = migrated.splitlines()
        diffs = []
        for i, (o, m) in enumerate(zip(orig_lines, migr_lines)):
            if o != m:
                diffs.append(f"줄 {i + 1}: '{o}' != '{m}'")
        return "\n".join(diffs[:10])