KnowledgeProcessor.py

from typing import Dict
from pathlib import Path


class KnowledgeProcessor:
    """
    A class to handle reading and processing knowledge files from the Knowledge folder.
    All files are expected to be in .md format.
    """
    
    def __init__(self, knowledge_folder: str = "Knowledge"):
        """
        Initialize the KnowledgeProcessor class.
        
        Args:
            knowledge_folder (str): Path to the knowledge folder containing .md files
        """
        self.knowledge_folder = Path(knowledge_folder)
    
    def read_all_knowledge_files(self) -> Dict[str, str]:
        """
        Read all .md files from the Knowledge folder and return their contents.
        
        Returns:
            Dict[str, str]: Dictionary with filename as key and file content as value
            
        Raises:
            FileNotFoundError: If the Knowledge folder doesn't exist
            IOError: If there are issues reading the files
        """
        if not self.knowledge_folder.exists():
            raise FileNotFoundError(f"Knowledge folder '{self.knowledge_folder}' not found")
        
        knowledge_contents = {}
        
        # Get all .md files in the Knowledge folder
        md_files = list(self.knowledge_folder.glob("*.md"))
        
        if not md_files:
            return knowledge_contents  # Return empty dict if no .md files found
        
        for md_file in md_files:
            try:
                with open(md_file, 'r', encoding='utf-8') as file:
                    content = file.read()
                    knowledge_contents[md_file.name] = content
            except IOError as e:
                print(f"Warning: Could not read file {md_file.name}: {e}")
                continue
        
        return knowledge_contents
    
    def get_knowledge_summary(self) -> Dict[str, any]:
        """
        Get a summary of all knowledge files including file count and total content length.
        
        Returns:
            Dict[str, any]: Summary information about the knowledge files
        """
        knowledge_contents = self.read_all_knowledge_files()
        
        total_files = len(knowledge_contents)
        total_content_length = sum(len(content) for content in knowledge_contents.values())
        file_names = list(knowledge_contents.keys())
        
        return {
            "total_files": total_files,
            "total_content_length": total_content_length,
            "file_names": file_names,
            "contents": knowledge_contents
        }
    
    def knowledgeprocessor(self) -> Dict[str, any]:
        """
        Convenience method that calls get_knowledge_summary.
        
        Returns:
            Dict[str, any]: Knowledge processing summary
        """
        return self.get_knowledge_summary()


# Convenience function for direct usage
def get_all_knowledge_contents() -> Dict[str, str]:
    """
    Convenience function to get all knowledge file contents.
    
    Returns:
        Dict[str, str]: Dictionary with filename as key and file content as value
    """
    processor = KnowledgeProcessor()
    return processor.read_all_knowledge_files()


def knowledgeprocessor() -> Dict[str, any]:
    """
    Convenience function to get knowledge summary.
    
    Returns:
        Dict[str, any]: Summary information about the knowledge files
    """
    processor = KnowledgeProcessor()
    return processor.get_knowledge_summary()