Add boss seed data pipeline for export and import

Add seeder support for boss battles so new database instances come
pre-populated. Adds --export-bosses CLI flag to dump boss data from the
database to JSON seed files, and loads those files during normal seeding.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

backend/src/app/seeds/run.py

@@ -5,14 +5,18 @@ from pathlib import Path
 
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
 
 from app.core.database import async_session
+from app.models.boss_battle import BossBattle
+from app.models.boss_pokemon import BossPokemon
 from app.models.game import Game
 from app.models.pokemon import Pokemon
 from app.models.route import Route
 from app.models.route_encounter import RouteEncounter
 from app.models.version_group import VersionGroup
 from app.seeds.loader import (
+    upsert_bosses,
     upsert_evolutions,
     upsert_games,
     upsert_pokemon,
@@ -129,7 +133,26 @@ async def seed():
             print(f"\nTotal routes: {total_routes}")
             print(f"Total encounters: {total_encounters}")
 
-            # 5. Upsert evolutions
+            # 5. Per version group: upsert bosses
+            total_bosses = 0
+            for vg_slug, vg_info in vg_data.items():
+                vg_id = vg_slug_to_id[vg_slug]
+                first_game_slug = list(vg_info["games"].keys())[0]
+                bosses_file = DATA_DIR / f"{first_game_slug}-bosses.json"
+                if not bosses_file.exists():
+                    continue
+
+                bosses_data = load_json(f"{first_game_slug}-bosses.json")
+                if not bosses_data:
+                    continue
+
+                boss_count = await upsert_bosses(session, vg_id, bosses_data, dex_to_id)
+                total_bosses += boss_count
+                print(f"  {vg_slug}: {boss_count} bosses")
+
+            print(f"Total bosses: {total_bosses}")
+
+            # 6. Upsert evolutions
             evolutions_path = DATA_DIR / "evolutions.json"
             if evolutions_path.exists():
                 evolutions_data = load_json("evolutions.json")
@@ -152,12 +175,14 @@ async def verify():
         pokemon_count = (await session.execute(select(func.count(Pokemon.id)))).scalar()
         routes_count = (await session.execute(select(func.count(Route.id)))).scalar()
         enc_count = (await session.execute(select(func.count(RouteEncounter.id)))).scalar()
+        boss_count = (await session.execute(select(func.count(BossBattle.id)))).scalar()
 
         print(f"Version Groups: {vg_count}")
         print(f"Games: {games_count}")
         print(f"Pokemon: {pokemon_count}")
         print(f"Routes: {routes_count}")
         print(f"Route Encounters: {enc_count}")
+        print(f"Boss Battles: {boss_count}")
 
         # Per-version-group route counts
         result = await session.execute(
@@ -181,4 +206,87 @@ async def verify():
         for row in result:
             print(f"  {row[0]}: {row[1]}")
 
+        # Per-version-group boss counts
+        result = await session.execute(
+            select(VersionGroup.slug, func.count(BossBattle.id))
+            .join(BossBattle, BossBattle.version_group_id == VersionGroup.id)
+            .group_by(VersionGroup.slug)
+            .order_by(VersionGroup.slug)
+        )
+        print("\nBosses per version group:")
+        for row in result:
+            print(f"  {row[0]}: {row[1]}")
+
     print("\nVerification complete!")
+
+
+async def export_bosses():
+    """Export boss battles from the database to seed JSON files."""
+    print("Exporting boss battles...")
+
+    async with async_session() as session:
+        # Load version group data to get the first game slug for filenames
+        with open(VG_JSON) as f:
+            vg_data = json.load(f)
+
+        # Query all version groups with their games
+        vg_result = await session.execute(
+            select(VersionGroup).options(selectinload(VersionGroup.games))
+        )
+        version_groups = vg_result.scalars().all()
+
+        slug_to_vg = {vg.slug: vg for vg in version_groups}
+
+        exported = 0
+        for vg_slug, vg_info in vg_data.items():
+            vg = slug_to_vg.get(vg_slug)
+            if vg is None:
+                continue
+
+            # Query boss battles for this version group
+            result = await session.execute(
+                select(BossBattle)
+                .where(BossBattle.version_group_id == vg.id)
+                .options(
+                    selectinload(BossBattle.pokemon).selectinload(BossPokemon.pokemon),
+                )
+                .order_by(BossBattle.order)
+            )
+            bosses = result.scalars().all()
+
+            if not bosses:
+                continue
+
+            first_game_slug = list(vg_info["games"].keys())[0]
+            data = [
+                {
+                    "name": b.name,
+                    "boss_type": b.boss_type,
+                    "badge_name": b.badge_name,
+                    "badge_image_url": b.badge_image_url,
+                    "level_cap": b.level_cap,
+                    "order": b.order,
+                    "location": b.location,
+                    "sprite_url": b.sprite_url,
+                    "pokemon": [
+                        {
+                            "pokeapi_id": bp.pokemon.pokeapi_id,
+                            "pokemon_name": bp.pokemon.name,
+                            "level": bp.level,
+                            "order": bp.order,
+                        }
+                        for bp in sorted(b.pokemon, key=lambda p: p.order)
+                    ],
+                }
+                for b in bosses
+            ]
+
+            out_path = DATA_DIR / f"{first_game_slug}-bosses.json"
+            with open(out_path, "w") as f:
+                json.dump(data, f, indent=2)
+                f.write("\n")
+
+            print(f"  {vg_slug}: {len(bosses)} bosses -> {out_path.name}")
+            exported += 1
+
+    print(f"Exported bosses for {exported} version groups.")