traditional_migration:
  challenges:
    - Thousands of files to change
    - Subtle pattern variations
    - Breaking changes everywhere
    - Testing burden
    - Developer tedium

  typical_timeline:
    small_codebase: "2-4 weeks"
    medium_codebase: "2-3 months"
    large_codebase: "6-12 months"

  failure_modes:
    - Inconsistent transformations
    - Missed edge cases
    - Developer burnout
    - Abandoned migrations

ai_assisted_migration:
  advantages:
    - Consistent transformation
    - Handles variations
    - Never gets bored
    - Fast iteration

  timeline_improvement:
    typical: "50-80% faster"
    caveat: "With good setup"

  still_required:
    - Human review
    - Test validation
    - Edge case handling

class MigrationAnalyzer:
    """Analyze codebase to understand migration scope."""

    async def analyze_codebase(
        self,
        repo_path: str,
        migration_type: str
    ) -> MigrationAnalysis:
        # Find all files needing migration
        files = await self._find_affected_files(repo_path, migration_type)

        # Analyze patterns
        patterns = await self._analyze_patterns(files)

        # Estimate complexity
        complexity = await self._estimate_complexity(patterns)

        return MigrationAnalysis(
            total_files=len(files),
            patterns=patterns,
            complexity=complexity,
            estimated_effort=self._estimate_effort(complexity)
        )

    async def _analyze_patterns(self, files: list[str]) -> list[Pattern]:
        """Use LLM to identify common patterns."""
        sample_files = self._sample_files(files, n=20)

        patterns = await self.llm.generate(
            prompt=f"""Analyze these code samples and identify common patterns
that will need to be migrated.

{self._format_samples(sample_files)}

List each pattern with:
- Pattern name
- Frequency estimate
- Transformation complexity
"""
        )
        return self._parse_patterns(patterns)

class MigrationTemplates:
    """Develop and test migration templates."""

    def __init__(self, llm):
        self.llm = llm
        self.templates = {}

    async def develop_template(
        self,
        pattern_name: str,
        examples: list[CodeExample]
    ) -> MigrationTemplate:
        # Generate initial template
        template = await self.llm.generate(
            prompt=f"""Create a code transformation template for this pattern.

Pattern: {pattern_name}

Before/After Examples:
{self._format_examples(examples)}

Provide:
1. Detection pattern (regex or AST)
2. Transformation rules
3. Edge cases to handle
"""
        )

        # Test template on examples
        results = await self._test_template(template, examples)

        # Iterate if needed
        while results.accuracy < 0.95:
            template = await self._refine_template(template, results.failures)
            results = await self._test_template(template, examples)

        return template

    async def _refine_template(
        self,
        template: MigrationTemplate,
        failures: list[FailedCase]
    ) -> MigrationTemplate:
        return await self.llm.generate(
            prompt=f"""This migration template failed on some cases.

Template: {template}

Failed cases:
{self._format_failures(failures)}

Refine the template to handle these cases:"""
        )

class BatchMigrator:
    """Apply migrations across codebase."""

    async def migrate_file(
        self,
        file_path: str,
        templates: list[MigrationTemplate]
    ) -> MigrationResult:
        original_content = await self._read_file(file_path)

        # Try templates first (fast, deterministic)
        content = original_content
        for template in templates:
            if template.matches(content):
                content = template.apply(content)

        # Use LLM for remaining transformations
        if self._needs_llm_migration(content):
            content = await self._llm_migrate(content)

        # Validate syntax
        if not await self._validate_syntax(content, file_path):
            return MigrationResult(
                file=file_path,
                status="syntax_error",
                needs_review=True
            )

        return MigrationResult(
            file=file_path,
            status="migrated",
            original=original_content,
            migrated=content
        )

    async def _llm_migrate(self, content: str) -> str:
        """Use LLM for complex/novel transformations."""
        return await self.llm.generate(
            prompt=f"""Migrate this code from [old pattern] to [new pattern].

Rules:
- Preserve functionality
- Maintain code style
- Handle edge cases

Original:

class MigrationValidator:
    """Validate migrated code."""

    async def validate_migration(
        self,
        original: str,
        migrated: str
    ) -> ValidationResult:
        checks = await asyncio.gather(
            self._check_syntax(migrated),
            self._check_semantic_equivalence(original, migrated),
            self._check_style_consistency(migrated),
            self._run_tests(migrated)
        )

        return ValidationResult(
            syntax_valid=checks[0],
            semantically_equivalent=checks[1],
            style_consistent=checks[2],
            tests_passing=checks[3]
        )

    async def _check_semantic_equivalence(
        self,
        original: str,
        migrated: str
    ) -> bool:
        """Use LLM to verify semantic equivalence."""
        result = await self.llm.generate(
            prompt=f"""Compare these two code versions.
Are they semantically equivalent (same behavior)?

Original:

# Migration prompt for React class → hooks
REACT_MIGRATION_PROMPT = """Migrate this React class component to a functional component with hooks.

Rules:
- Convert this.state to useState
- Convert lifecycle methods:
  - componentDidMount → useEffect(..., [])
  - componentDidUpdate → useEffect with dependencies
  - componentWillUnmount → useEffect cleanup
- Convert this.props to destructured props
- Preserve all functionality

Original:
```jsx
{original_code}