Lyra/lyra/main.py

"""
Main entry point for Lyra AI Discord Chatbot.

This module initializes and runs the complete Lyra system including
personality matrix, emotional intelligence, knowledge processing,
and Discord bot integration.
"""

import asyncio
import logging
import sys
from pathlib import Path
from typing import Optional
import signal

from lyra.config import config
from lyra.database.manager import DatabaseManager
from lyra.personality.matrix import PersonalityMatrix
from lyra.emotions.system import EmotionalSystem
from lyra.core.self_evolution import SelfEvolutionEngine
from lyra.core.thinking_agent import ThinkingAgent
from lyra.knowledge.acquisition_manager import KnowledgeAcquisitionManager


# Configure logging
logging.basicConfig(
    level=getattr(logging, config.log_level.upper()),
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(config.log_file),
        logging.StreamHandler(sys.stdout)
    ]
)

logger = logging.getLogger(__name__)


class LyraSystem:
    """
    Main Lyra AI system coordinator.

    Manages initialization, coordination, and shutdown of all Lyra components.
    """

    def __init__(self):
        self.database_manager: Optional[DatabaseManager] = None
        self.personality_matrix: Optional[PersonalityMatrix] = None
        self.emotional_system: Optional[EmotionalSystem] = None
        self.evolution_engine: Optional[SelfEvolutionEngine] = None
        self.thinking_agent: Optional[ThinkingAgent] = None
        self.knowledge_manager: Optional[KnowledgeAcquisitionManager] = None
        self.discord_bot: Optional[object] = None  # Will be implemented later

        self.is_running = False
        self.shutdown_event = asyncio.Event()

    async def initialize(self):
        """Initialize all Lyra components."""
        logger.info("Initializing Lyra AI System...")

        try:
            # Ensure required directories exist
            config.ensure_directories()

            # Initialize database
            logger.info("Initializing database manager...")
            self.database_manager = DatabaseManager(
                database_url=config.database_url,
                redis_url=config.redis_url
            )
            await self.database_manager.initialize()

            # Initialize core AI components
            logger.info("Initializing personality matrix...")
            self.personality_matrix = PersonalityMatrix(
                enable_self_modification=True
            )

            logger.info("Initializing emotional system...")
            self.emotional_system = EmotionalSystem(
                input_dim=config.hidden_size,
                emotion_dim=19,
                memory_capacity=1000
            )

            logger.info("Initializing self-evolution engine...")
            self.evolution_engine = SelfEvolutionEngine(
                model_dim=config.hidden_size,
                evolution_rate=0.001,
                adaptation_threshold=0.7
            )

            logger.info("Initializing thinking agent...")
            self.thinking_agent = ThinkingAgent(
                model_dim=config.hidden_size,
                thought_types=8,
                max_thought_depth=5
            )

            # Initialize knowledge acquisition
            logger.info("Initializing knowledge acquisition manager...")
            # Will be implemented when we add the knowledge acquisition manager

            # Load any saved states
            await self._load_saved_states()

            logger.info("Lyra AI System initialized successfully!")

        except Exception as e:
            logger.error(f"Failed to initialize Lyra system: {e}")
            raise

    async def _load_saved_states(self):
        """Load saved personality and emotional states."""
        try:
            # Load personality state
            personality_path = config.data_dir / "personality" / "current_state.json"
            if personality_path.exists():
                self.personality_matrix.load_personality(personality_path)
                logger.info("Loaded saved personality state")

            # Load emotional state
            emotional_path = config.data_dir / "personality" / "emotional_state.json"
            if emotional_path.exists():
                self.emotional_system.load_emotional_state(emotional_path)
                logger.info("Loaded saved emotional state")

            # Load evolution state
            evolution_path = config.data_dir / "personality" / "evolution_state.json"
            if evolution_path.exists():
                self.evolution_engine.load_evolution_state(evolution_path)
                logger.info("Loaded saved evolution state")

        except Exception as e:
            logger.warning(f"Failed to load some saved states: {e}")

    async def start(self):
        """Start the Lyra system."""
        logger.info("Starting Lyra AI System...")

        self.is_running = True

        try:
            # Start Discord bot (when implemented)
            # await self.discord_bot.start()

            # For now, just run a placeholder
            logger.info("Lyra is ready! (Discord bot integration pending)")

            # Wait for shutdown signal
            await self.shutdown_event.wait()

        except Exception as e:
            logger.error(f"Error running Lyra system: {e}")
            raise
        finally:
            await self.shutdown()

    async def shutdown(self):
        """Shutdown the Lyra system gracefully."""
        if not self.is_running:
            return

        logger.info("Shutting down Lyra AI System...")

        try:
            # Save current states
            await self._save_current_states()

            # Shutdown components
            if self.database_manager:
                await self.database_manager.close()
                logger.info("Database manager closed")

            # Additional cleanup would go here

            self.is_running = False
            logger.info("Lyra AI System shutdown complete")

        except Exception as e:
            logger.error(f"Error during shutdown: {e}")

    async def _save_current_states(self):
        """Save current personality and emotional states."""
        try:
            # Ensure personality directory exists
            personality_dir = config.data_dir / "personality"
            personality_dir.mkdir(parents=True, exist_ok=True)

            # Save personality state
            if self.personality_matrix:
                personality_path = personality_dir / "current_state.json"
                self.personality_matrix.save_personality(personality_path)
                logger.info("Saved personality state")

            # Save emotional state
            if self.emotional_system:
                emotional_path = personality_dir / "emotional_state.json"
                self.emotional_system.save_emotional_state(emotional_path)
                logger.info("Saved emotional state")

            # Save evolution state
            if self.evolution_engine:
                evolution_path = personality_dir / "evolution_state.json"
                self.evolution_engine.save_evolution_state(evolution_path)
                logger.info("Saved evolution state")

        except Exception as e:
            logger.error(f"Failed to save states: {e}")

    def signal_handler(self, signum, frame):
        """Handle shutdown signals."""
        logger.info(f"Received signal {signum}, initiating graceful shutdown...")
        self.shutdown_event.set()


async def main():
    """Main entry point for Lyra."""
    lyra_system = LyraSystem()

    # Set up signal handlers for graceful shutdown
    for sig in [signal.SIGINT, signal.SIGTERM]:
        signal.signal(sig, lyra_system.signal_handler)

    try:
        await lyra_system.initialize()
        await lyra_system.start()
    except KeyboardInterrupt:
        logger.info("Received keyboard interrupt")
    except Exception as e:
        logger.error(f"Unhandled exception: {e}")
        sys.exit(1)


if __name__ == "__main__":
    # Run Lyra
    asyncio.run(main())