refactor: add pagination to list endpoints and extract calendar components

Backend:
- Add proper pagination (offset/limit) to people and connections list endpoints
- Update people_service.list_people to return tuple (people, total)
- Update connection_service.get_connections to return tuple (connections, total)

Mobile:
- Extract DateStripScroller to separate component
- Extract MeetingTypeConfig and MeetingTypeLogo to separate module
- Reduce calendar.tsx from 2796 to 2532 lines (-264 lines)

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

Author: 2 people

backend/app/api/connections.py

@@ -48,18 +48,20 @@ async def list_connections(
     current_user: CurrentUser,
     db: Database,
     limit: int = Query(20, ge=1, le=50),
+    offset: int = Query(0, ge=0),
     unnotified_only: bool = Query(False),
 ):
     """
-    List discovered memory connections.
+    List discovered memory connections with pagination.
 
     Connections show related memories that were discovered automatically.
     Use unnotified_only=true to get only new connections.
     """
     connection_service = ConnectionService(db)
-    connections = await connection_service.get_connections(
+    connections, total = await connection_service.get_connections(
         user_id=current_user.id,
         limit=limit,
+        offset=offset,
         unnotified_only=unnotified_only,
     )
 
@@ -100,7 +102,7 @@ async def list_connections(
 
     return ConnectionListResponse(
         connections=results,
-        total=len(results),
+        total=total,
     )
 
 

backend/app/api/people.py

@@ -109,25 +109,27 @@ async def list_people(
     db: Database,
     sort_by: str = Query("recent", enum=["recent", "frequent", "alphabetical"]),
     limit: int = Query(50, ge=1, le=100),
+    offset: int = Query(0, ge=0),
 ):
     """
-    List all people the user knows about.
+    List all people the user knows about with pagination.
 
     Sort options:
     - recent: Most recently mentioned first
     - frequent: Most frequently mentioned first
     - alphabetical: Alphabetically by name
     """
     people_service = PeopleService(db)
-    people = await people_service.list_people(
+    people, total = await people_service.list_people(
         user_id=current_user.id,
         sort_by=sort_by,
         limit=limit,
+        offset=offset,
     )
 
     return PeopleListResponse(
         people=[PersonSummary(**p) for p in people],
-        total=len(people),
+        total=total,
     )
 
 

backend/app/services/connection_service.py

@@ -3,7 +3,7 @@
 import logging
 from uuid import UUID
 from datetime import datetime, timedelta
-from sqlalchemy import select, and_, or_
+from sqlalchemy import select, and_, or_, func
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 from openai import AsyncOpenAI
@@ -222,25 +222,32 @@ async def get_connections(
         self,
         user_id: UUID,
         limit: int = 20,
+        offset: int = 0,
         unnotified_only: bool = False,
         undismissed_only: bool = True,
-    ) -> list[MemoryConnection]:
-        """Get connections for a user."""
-        query = (
+    ) -> tuple[list[MemoryConnection], int]:
+        """Get connections for a user with pagination."""
+        # Base query for filtering
+        base_query = (
             select(MemoryConnection)
             .where(MemoryConnection.user_id == user_id)
-            .order_by(MemoryConnection.created_at.desc())
         )
 
         if unnotified_only:
-            query = query.where(MemoryConnection.notified_at.is_(None))
+            base_query = base_query.where(MemoryConnection.notified_at.is_(None))
 
         if undismissed_only:
-            query = query.where(MemoryConnection.dismissed_at.is_(None))
+            base_query = base_query.where(MemoryConnection.dismissed_at.is_(None))
+
+        # Get total count
+        count_query = select(func.count()).select_from(base_query.subquery())
+        total_result = await self.db.execute(count_query)
+        total = total_result.scalar() or 0
 
-        query = query.limit(limit)
+        # Apply ordering and pagination
+        query = base_query.order_by(MemoryConnection.created_at.desc()).offset(offset).limit(limit)
         result = await self.db.execute(query)
-        return list(result.scalars().all())
+        return list(result.scalars().all()), total
 
     async def get_connection_with_memories(
         self, connection_id: UUID, user_id: UUID

backend/app/services/people_service.py

@@ -61,28 +61,37 @@ async def list_people(
         sort_by: str = "recent",  # 'recent', 'frequent', 'alphabetical'
         entity_type: str = "person",
         limit: int = 50,
-    ) -> list[dict]:
-        """List all people (entities) with stats."""
-        query = (
+        offset: int = 0,
+    ) -> tuple[list[dict], int]:
+        """List all people (entities) with stats and pagination."""
+        # Base query for filtering
+        base_query = (
             select(Entity)
             .where(Entity.user_id == user_id)
             .where(Entity.entity_type == entity_type)
         )
 
+        # Get total count
+        count_query = select(func.count()).select_from(base_query.subquery())
+        total_result = await self.db.execute(count_query)
+        total = total_result.scalar() or 0
+
+        # Apply sorting
         if sort_by == "recent":
-            query = query.order_by(Entity.last_seen.desc())
+            base_query = base_query.order_by(Entity.last_seen.desc())
         elif sort_by == "frequent":
-            query = query.order_by(Entity.mention_count.desc())
+            base_query = base_query.order_by(Entity.mention_count.desc())
         elif sort_by == "alphabetical":
-            query = query.order_by(Entity.name.asc())
+            base_query = base_query.order_by(Entity.name.asc())
         else:
-            query = query.order_by(Entity.last_seen.desc())
+            base_query = base_query.order_by(Entity.last_seen.desc())
 
-        query = query.limit(limit)
+        # Apply pagination
+        query = base_query.offset(offset).limit(limit)
         result = await self.db.execute(query)
         entities = list(result.scalars().all())
 
-        return [
+        people = [
             {
                 "id": str(e.id),
                 "name": e.name,
@@ -94,6 +103,7 @@ async def list_people(
             }
             for e in entities
         ]
+        return people, total
 
     async def search_contacts(
         self,