feat: implement 1B domain entities/repos + 1H library API routes

1B — domain layer:
- New entities: Album, Playlist, Like, PlayHistoryEntry
- Track entity extended with album_id, genre, year fields
- New protocols: AlbumRepository, PlaylistRepository, LikeRepository, HistoryRepository
- ArtistRepository / TrackRepository protocols extended (list, count, update, get_many, etc.)
- New repos: SqlAlchemyAlbum/Playlist/Like/HistoryRepository
- Artist and track repos updated to match extended protocols

1H — library API:
- Pagination: PagedResponse[T] generic, offset-based, limit default 50 max 200
- Schemas: TrackOut, AlbumOut, ArtistOut, PlaylistOut/Create/Update,
  LikeEvent/State, HistoryIn/Out, LibrarySearchResponse
- GET/PATCH/DELETE /tracks with filters, sort, pagination
- GET /albums, /albums/{id}, /albums/{id}/tracks
- GET /artists, /artists/{id}, /artists/{id}/albums, /artists/{id}/tracks
- GET /search/library (ILIKE across tracks/albums/artists)
- Full /playlists CRUD + track add/remove (append-only version bump)
- POST /likes (append-only event log), GET /likes, GET /likes/state
- POST /history (scrobble), GET /history
- deps.py: TrackRepoDep, ArtistRepoDep, AlbumRepoDep, PlaylistRepoDep,
  LikeRepoDep, HistoryRepoDep

ruff ✅  mypy ✅  pytest 45/45 ✅

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

app/api/v1/artists.py

@@ -3,26 +3,125 @@
 import uuid
 from typing import Any
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Query
+
+from app.api.deps import AlbumRepoDep, ArtistRepoDep, CurrentUser, TrackRepoDep
+from app.api.schemas.album import AlbumOut
+from app.api.schemas.artist import ArtistOut
+from app.api.schemas.pagination import PagedResponse
+from app.api.schemas.track import TrackOut
+from app.api.v1.albums import _build_album_out
+from app.api.v1.tracks import _build_track_out
+from app.domain.errors import NotFoundError
 
 router = APIRouter(prefix="/artists", tags=["artists"])
 
 
 @router.get("")
-async def list_artists() -> Any: ...
+async def list_artists(
+    artist_repo: ArtistRepoDep,
+    _: CurrentUser,
+    q: str | None = None,
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> PagedResponse[ArtistOut]:
+    artists = await artist_repo.list(q=q, limit=limit, offset=offset)
+    total = await artist_repo.count(q=q)
+
+    items = []
+    for a in artists:
+        album_cnt = await artist_repo.album_count(a.id)
+        track_cnt = await artist_repo.track_count(a.id)
+        items.append(
+            ArtistOut(
+                id=a.id,
+                name=a.name,
+                album_count=album_cnt,
+                track_count=track_cnt,
+                created_at=a.created_at,
+            )
+        )
+
+    return PagedResponse(items=items, total=total, limit=limit, offset=offset)
 
 
 @router.get("/{artist_id}")
-async def get_artist(artist_id: uuid.UUID) -> Any: ...
+async def get_artist(
+    artist_id: uuid.UUID,
+    artist_repo: ArtistRepoDep,
+    _: CurrentUser,
+) -> ArtistOut:
+    artist = await artist_repo.get_by_id(artist_id)
+    if artist is None:
+        raise NotFoundError(f"Artist {artist_id} not found.")
+
+    album_cnt = await artist_repo.album_count(artist_id)
+    track_cnt = await artist_repo.track_count(artist_id)
+
+    return ArtistOut(
+        id=artist.id,
+        name=artist.name,
+        album_count=album_cnt,
+        track_count=track_cnt,
+        created_at=artist.created_at,
+    )
 
 
 @router.get("/{artist_id}/albums")
-async def get_artist_albums(artist_id: uuid.UUID) -> Any: ...
+async def get_artist_albums(
+    artist_id: uuid.UUID,
+    artist_repo: ArtistRepoDep,
+    album_repo: AlbumRepoDep,
+    _: CurrentUser,
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> PagedResponse[AlbumOut]:
+    artist = await artist_repo.get_by_id(artist_id)
+    if artist is None:
+        raise NotFoundError(f"Artist {artist_id} not found.")
+
+    albums = await album_repo.list(artist_id=artist_id, q=None, limit=limit, offset=offset)
+    total = await album_repo.count(artist_id=artist_id, q=None)
+
+    artists_map = {artist.id: artist}
+    track_counts = await album_repo.track_count_many([a.id for a in albums])
+
+    items = await _build_album_out(albums, artists_map, track_counts)
+    return PagedResponse(items=items, total=total, limit=limit, offset=offset)
 
 
 @router.get("/{artist_id}/tracks")
-async def get_artist_tracks(artist_id: uuid.UUID) -> Any: ...
+async def get_artist_tracks(
+    artist_id: uuid.UUID,
+    artist_repo: ArtistRepoDep,
+    track_repo: TrackRepoDep,
+    album_repo: AlbumRepoDep,
+    _: CurrentUser,
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> PagedResponse[TrackOut]:
+    artist = await artist_repo.get_by_id(artist_id)
+    if artist is None:
+        raise NotFoundError(f"Artist {artist_id} not found.")
+
+    tracks = await track_repo.list(
+        artist_id=artist_id,
+        album_id=None,
+        q=None,
+        sort_by="title",
+        order="asc",
+        limit=limit,
+        offset=offset,
+    )
+    total = await track_repo.count(artist_id=artist_id, album_id=None, q=None)
+
+    album_ids = list({t.album_id for t in tracks if t.album_id is not None})
+    artists_map = {artist.id: artist}
+    albums_map = {a.id: a for a in await album_repo.get_many(album_ids)}
+
+    items = await _build_track_out(tracks, artists_map, albums_map)
+    return PagedResponse(items=items, total=total, limit=limit, offset=offset)
 
 
 @router.get("/{artist_id}/similar")
-async def get_similar_artists(artist_id: uuid.UUID) -> Any: ...
+async def get_similar_artists(artist_id: uuid.UUID, _: CurrentUser) -> Any: ...