Universal List Architecture - Systematic Refactoring Methodology

@dataclass
class List:
    """Universal List model for ANY item type (todo, feature, bug, attendee)"""

    id: str = field(default_factory=lambda: str(uuid4()))
    name: str = ""
    description: str = ""
    item_type: str = "todo"  # todo, feature, bug, attendee, etc.
    list_type: str = "personal"  # personal, shared, project
    ordering_strategy: str = "manual"  # manual, due_date, priority, created
    color: Optional[str] = None  # Hex color for UI theming
    emoji: Optional[str] = None  # Emoji for visual identification
    is_archived: bool = False
    is_default: bool = False  # Default list for new items of this type

    # Metadata for PM-040 Knowledge Graph integration
    metadata: Dict[str, Any] = field(default_factory=dict)
    tags: List[str] = field(default_factory=list)

    # Timestamps
    created_at: datetime = field(default_factory=datetime.now)
    updated_at: datetime = field(default_factory=datetime.now)

@dataclass
class ListItem:
    """Universal ListItem relationship - polymorphic with item_type discriminator"""

    id: str = field(default_factory=lambda: str(uuid4()))
    list_id: str = ""
    item_id: str = ""
    item_type: str = "todo"  # todo, feature, bug, attendee, etc.
    position: int = 0  # Order within the list

    # Membership metadata
    added_at: datetime = field(default_factory=datetime.now)
    added_by: str = ""  # User who added item to this list

    # List-specific overrides (optional)
    list_priority: Optional[str] = None  # Override item's default priority
    list_due_date: Optional[datetime] = None  # Override item's default due date
    list_notes: str = ""  # List-specific notes

@dataclass
class Todo:
    """Standalone Todo domain object - no coupling to TodoList"""

    id: str = field(default_factory=lambda: str(uuid4()))
    title: str = ""
    description: str = ""
    priority: str = "medium"  # low, medium, high, urgent
    status: str = "pending"  # pending, in_progress, completed, cancelled
    due_date: Optional[datetime] = None
    tags: List[str] = field(default_factory=list)
    assignee_id: Optional[str] = None

    # Metadata for PM-040 Knowledge Graph integration
    metadata: Dict[str, Any] = field(default_factory=dict)

    # Timestamps
    created_at: datetime = field(default_factory=datetime.now)
    updated_at: datetime = field(default_factory=datetime.now)
    completed_at: Optional[datetime] = None

# Future: Feature Lists
class FeatureList:
    """Backward compatibility alias for List(item_type='feature')"""
    def __init__(self, **kwargs):
        list_data = {**kwargs, "item_type": "feature"}
        self._list = List(**list_data)

# Future: Bug Lists
class BugList:
    """Backward compatibility alias for List(item_type='bug')"""
    def __init__(self, **kwargs):
        list_data = {**kwargs, "item_type": "bug"}
        self._list = List(**list_data)

# Future: Attendee Lists
class AttendeeList:
    """Backward compatibility alias for List(item_type='attendee')"""
    def __init__(self, **kwargs):
        list_data = {**kwargs, "item_type": "attendee"}
        self._list = List(**list_data)

# These endpoints work exactly as before
POST /api/v1/todos/lists          # Creates List(item_type='todo')
GET  /api/v1/todos/lists/{id}     # Gets List(item_type='todo')
PUT  /api/v1/todos/lists/{id}     # Updates List(item_type='todo')
DELETE /api/v1/todos/lists/{id}   # Deletes List(item_type='todo')
GET  /api/v1/todos/lists          # Lists List(item_type='todo')

# API endpoints now use universal services internally
async def create_todo_list(
    list_data: TodoListCreateRequest,
    universal_list_service=Depends(get_universal_list_service),
    knowledge_graph=Depends(get_knowledge_graph_service)
):
    """
    Create a new todo list with PM-040 Knowledge Graph integration
    Universal List with item_type='todo' - Chief Architect's universal composition pattern
    """
    # Internally creates List(item_type='todo')
    # API response maintains backward compatibility

async def test_universal_composition_pattern(self, client, sample_todo_list_data):
    """Test Chief Architect's universal composition over specialization principle"""
    # Create a todo list - should use universal List with item_type='todo'
    response = client.post("/api/v1/todos/lists", json=sample_todo_list_data)
    assert response.status_code == 201

    data = response.json()

    # Verify universal composition pattern
    assert data["item_type"] == "todo"  # Universal List discriminator
    assert data["list_type"] == sample_todo_list_data["list_type"]
    assert data["ordering_strategy"] == sample_todo_list_data["ordering_strategy"]

    # Verify that this pattern can be extended for other item types
    # (feature, bug, attendee, etc.) without breaking existing functionality
    assert "todo_count" in data  # Backward compatibility field
    assert data["todo_count"] == 0  # Computed field for backward compatibility

async def test_backward_compatibility(self, client):
    """Test that API maintains backward compatibility"""
    # Verify that existing endpoints work unchanged
    response = client.get("/api/v1/todos/")
    assert response.status_code == 200

    response = client.get("/api/v1/todos/lists")
    assert response.status_code == 200

    # Verify that response structures are compatible
    data = response.json()
    assert "lists" in data  # Backward compatible field name
    assert "total_count" in data
    assert "page" in data
    assert "page_size" in data

# Universal list caching
@cache(expire=300)  # 5 minutes
async def get_list_with_items(list_id: str, item_type: str) -> Dict[str, Any]:
    """Get list with items, cached by list_id and item_type"""
    list_data = await get_list(list_id)
    items = await get_list_items(list_id, item_type)
    return {"list": list_data, "items": items}

# Universal List becomes Knowledge Graph node
async def add_list_to_knowledge_graph(list_id: str, item_type: str):
    """Add universal list to knowledge graph"""
    list_data = await get_list(list_id)

    # Create knowledge graph node
    node = KnowledgeNode(
        id=f"list_{list_id}",
        type=NodeType.LIST,
        metadata={
            "item_type": item_type,
            "list_type": list_data.list_type,
            "name": list_data.name
        }
    )

    await knowledge_graph_service.add_node(node)

# Universal search across all item types
async def search_lists_by_intent(query: str) -> List[Dict[str, Any]]:
    """Search lists using PM-034 intent classification"""
    intent = await query_router.classify_and_route(query)

    if intent.category == IntentCategory.SEARCH_LISTS:
        # Search universal lists based on intent
        item_type = intent.context.get("item_type", "todo")
        return await search_lists_by_item_type(item_type, intent.context)

    return []

# Future: Feature Lists
class FeatureList:
    """Backward compatibility alias for List(item_type='feature')"""
    def __init__(self, **kwargs):
        list_data = {**kwargs, "item_type": "feature"}
        self._list = List(**list_data)

# Future: Bug Lists
class BugList:
    """Backward compatibility alias for List(item_type='bug')"""
    def __init__(self, **kwargs):
        list_data = {**kwargs, "item_type": "bug"}
        self._list = List(**list_data)

# Future: Attendee Lists
class AttendeeList:
    """Backward compatibility alias for List(item_type='attendee')"""
    def __init__(self, **kwargs):
        list_data = {**kwargs, "item_type": "attendee"}
        self._list = List(**list_data)

class UniversalListService:
    """Universal service for managing lists of any item type"""

    async def create_list(self, item_type: str, **kwargs) -> List:
        """Create a universal list for any item type"""
        list_data = {**kwargs, "item_type": item_type}
        return List(**list_data)

    async def add_item_to_list(self, list_id: str, item_id: str, item_type: str, **kwargs) -> ListItem:
        """Add any item type to a universal list"""
        item_data = {**kwargs, "list_id": list_id, "item_id": item_id, "item_type": item_type}
        return ListItem(**item_data)

    async def get_list_items(self, list_id: str, item_type: str) -> List[ListItem]:
        """Get all items of a specific type from a list"""
        # Implementation would query ListItem with item_type discriminator
        pass