""" 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())