atlas/home-voice-agent/memory/schema.py

"""
Memory schema and data models.
"""

from dataclasses import dataclass
from datetime import datetime
from typing import Optional, List
from enum import Enum


class MemoryCategory(Enum):
    """Memory categories."""
    PERSONAL = "personal"
    FAMILY = "family"
    PREFERENCES = "preferences"
    ROUTINES = "routines"
    FACTS = "facts"


class MemorySource(Enum):
    """Source of memory entry."""
    EXPLICIT = "explicit"  # User explicitly stated
    INFERRED = "inferred"  # Inferred from conversation
    CONFIRMED = "confirmed"  # User confirmed inferred fact


@dataclass
class MemoryEntry:
    """A single memory entry."""
    id: str
    category: MemoryCategory
    key: str
    value: str
    confidence: float  # 0.0 to 1.0
    source: MemorySource
    timestamp: datetime
    last_accessed: Optional[datetime] = None
    access_count: int = 0
    tags: List[str] = None
    context: Optional[str] = None
    
    def __post_init__(self):
        """Initialize default values."""
        if self.tags is None:
            self.tags = []
        if self.last_accessed is None:
            self.last_accessed = self.timestamp
    
    def to_dict(self) -> dict:
        """Convert to dictionary."""
        return {
            "id": self.id,
            "category": self.category.value,
            "key": self.key,
            "value": self.value,
            "confidence": self.confidence,
            "source": self.source.value,
            "timestamp": self.timestamp.isoformat(),
            "last_accessed": self.last_accessed.isoformat() if self.last_accessed else None,
            "access_count": self.access_count,
            "tags": self.tags,
            "context": self.context
        }
    
    @classmethod
    def from_dict(cls, data: dict) -> "MemoryEntry":
        """Create from dictionary."""
        return cls(
            id=data["id"],
            category=MemoryCategory(data["category"]),
            key=data["key"],
            value=data["value"],
            confidence=data["confidence"],
            source=MemorySource(data["source"]),
            timestamp=datetime.fromisoformat(data["timestamp"]),
            last_accessed=datetime.fromisoformat(data["last_accessed"]) if data.get("last_accessed") else None,
            access_count=data.get("access_count", 0),
            tags=data.get("tags", []),
            context=data.get("context")
        )