loader.py

from pathlib import Path
from typing import Any
import logging

from models import Document

logger = logging.getLogger(__name__)

class DocumentLoader:
    """
    Loads text documents from the specified directory.
    """
    def __init__(self, data_dir: str | Path = "data") -> None:
        self.data_dir = Path(data_dir)

    def load(self) -> list[Document]:
        documents: list[Document] = []
        
        if not self.data_dir.exists():
            logger.warning("Data directory '%s' does not exist.", self.data_dir)
            self.data_dir.mkdir(parents=True, exist_ok=True)
            return documents

        for filepath in self.data_dir.rglob("*.txt"):
            try:
                with open(filepath, "r", encoding="utf-8") as f:
                    content = f.read()

                documents.append(
                    Document(
                        title=filepath.stem,
                        category="unknown",
                        topic="general",
                        content=content,
                        metadata={"source": str(filepath)},
                        source_path=filepath,
                    )
                )
            except Exception as e:
                logger.error("Failed to load %s: %s", filepath, e)

        logger.info("Loaded %d documents.", len(documents))
        return documents


import json
from pathlib import Path
from models import Document

class MemoryLoader:
    """Loads past session abstracts into the RAG pipeline."""
    
    def __init__(self, history_dir: str = "history"):
        self.history_dir = Path(history_dir)

    def load_abstracts(self) -> list[Document]:
        documents = []
        if not self.history_dir.exists():
            return documents

        # Find all abstract files
        for filepath in self.history_dir.rglob("*_abstract.json"):
            try:
                with open(filepath, "r", encoding="utf-8") as f:
                    data = json.load(f)
                
                # Format the JSON into a readable text chunk for the LLM
                content = (
                    f"Session Date: {data.get('last_updated')}\n"
                    f"User's Emotion: {data.get('dominant_emotion')}\n"
                    f"Summary: {data.get('session_summary')}\n"
                    f"Topics: {', '.join(data.get('key_topics', []))}"
                )

                documents.append(
                    Document(
                        title=f"Session {data.get('session_id')} Memory",
                        category="user_memory",
                        topic="past_conversation",
                        content=content,
                        metadata={"source": str(filepath), "type": "memory"},
                        source_path=filepath,
                    )
                )
            except Exception as e:
                print(f"[Error] Failed to load memory {filepath}: {e}")

        return documents