#!/usr/bin/env python3 """ Enhanced Trinity Memory System with Eve Legacy Integration Provides unified access to Eve's existing memories AND new Trinity memory features """ import sqlite3 import json import time import logging from typing import Dict, Optional, Any, List from datetime import datetime import os import asyncio class EnhancedTrinityMemory: """Enhanced Trinity Memory System with Eve legacy database integration""" def __init__(self, trinity_db_path: str = "trinity_simple_memory.db"): self.trinity_db_path = trinity_db_path self.eve_main_db = "eve_memory_database.db" self.eve_sentience_db = "eve_sentience_database.db" self.logger = logging.getLogger(__name__) self.initialized = False async def initialize_memory_system(self): """Initialize the enhanced memory system with Eve legacy integration""" try: # Create Trinity tables self._create_trinity_tables() # Verify Eve databases exist eve_dbs_available = [] if os.path.exists(self.eve_main_db): eve_dbs_available.append("main_memory") if os.path.exists(self.eve_sentience_db): eve_dbs_available.append("sentience_dreams") self.initialized = True self.logger.info(f"Enhanced Trinity memory system initialized with Eve legacy integration: {eve_dbs_available}") return True except Exception as e: self.logger.error(f"Failed to initialize enhanced memory system: {e}") return False def _create_trinity_tables(self): """Create necessary Trinity database tables""" conn = sqlite3.connect(self.trinity_db_path) cursor = conn.cursor() # Trinity conversations table cursor.execute(''' CREATE TABLE IF NOT EXISTS conversations ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL, user_id TEXT, entity TEXT NOT NULL, message TEXT NOT NULL, response TEXT NOT NULL, context TEXT ) ''') # Trinity relationships table cursor.execute(''' CREATE TABLE IF NOT EXISTS relationships ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT NOT NULL, entity TEXT NOT NULL, relationship_score REAL DEFAULT 0.0, last_interaction TEXT, interaction_count INTEGER DEFAULT 0 ) ''') # Trinity memory contexts table cursor.execute(''' CREATE TABLE IF NOT EXISTS memory_contexts ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT, context_type TEXT, context_data TEXT, importance INTEGER DEFAULT 1, created_at TEXT ) ''') # Legacy memory access log cursor.execute(''' CREATE TABLE IF NOT EXISTS legacy_memory_access ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL, database_source TEXT, query_type TEXT, results_count INTEGER, context TEXT ) ''') conn.commit() conn.close() async def enhance_trinity_conversation(self, user_id: str, message: str, entity: str) -> Dict: """Enhanced conversation with both Trinity and Eve legacy memory context""" if not self.initialized: return {'memory_enhanced': False, 'context': []} try: # Get Trinity memory context trinity_context = await self._get_trinity_context(user_id, entity) # Get Eve legacy memory context eve_context = await self._get_eve_legacy_context(message, entity) # Combine contexts combined_context = { 'trinity_conversations': trinity_context.get('recent_conversations', []), 'trinity_relationship_score': trinity_context.get('relationship_score', 0.0), 'eve_autobiographical': eve_context.get('autobiographical_memories', []), 'eve_conversations': eve_context.get('conversations', []), 'eve_dreams': eve_context.get('dream_fragments', []), 'memory_enhanced': True, 'total_context_items': len(trinity_context.get('recent_conversations', [])) + len(eve_context.get('conversations', [])), 'legacy_memories_found': eve_context.get('total_found', 0) } return combined_context except Exception as e: self.logger.error(f"Error enhancing conversation: {e}") return {'memory_enhanced': False, 'context': []} async def _get_trinity_context(self, user_id: str, entity: str) -> Dict: """Get Trinity memory context""" try: conn = sqlite3.connect(self.trinity_db_path) cursor = conn.cursor() # Get recent Trinity conversations cursor.execute(''' SELECT message, response, timestamp FROM conversations WHERE user_id = ? AND entity = ? ORDER BY timestamp DESC LIMIT 3 ''', (user_id, entity)) recent_conversations = [] for msg, resp, ts in cursor.fetchall(): recent_conversations.append({ 'message': msg, 'response': resp, 'timestamp': ts, 'source': 'trinity' }) # Get relationship info cursor.execute(''' SELECT relationship_score, interaction_count FROM relationships WHERE user_id = ? AND entity = ? ''', (user_id, entity)) result = cursor.fetchone() relationship_score = result[0] if result else 0.0 conn.close() return { 'recent_conversations': recent_conversations, 'relationship_score': relationship_score } except Exception as e: self.logger.error(f"Error getting Trinity context: {e}") return {'recent_conversations': [], 'relationship_score': 0.0} async def _get_eve_legacy_context(self, message: str, entity: str, limit: int = 5) -> Dict: """Get Eve's legacy memory context from her existing databases""" context = { 'autobiographical_memories': [], 'conversations': [], 'dream_fragments': [], 'total_found': 0 } try: # Search Eve's main memory database if os.path.exists(self.eve_main_db): main_context = await self._search_eve_main_memory(message, limit) context.update(main_context) # Search Eve's sentience/dream database if os.path.exists(self.eve_sentience_db): dream_context = await self._search_eve_dreams(message, limit) context['dream_fragments'] = dream_context.get('dream_fragments', []) context['total_found'] += len(dream_context.get('dream_fragments', [])) # Log legacy memory access await self._log_legacy_access('combined', 'context_search', context['total_found']) except Exception as e: self.logger.error(f"Error getting Eve legacy context: {e}") return context async def _search_eve_main_memory(self, message: str, limit: int) -> Dict: """Search Eve's main memory database""" try: conn = sqlite3.connect(self.eve_main_db) cursor = conn.cursor() context = {'autobiographical_memories': [], 'conversations': [], 'total_found': 0} # Search autobiographical memories cursor.execute(''' SELECT memory_type, content FROM eve_autobiographical_memory WHERE content LIKE ? ORDER BY id DESC LIMIT ? ''', (f'%{message}%', limit)) for memory_type, content in cursor.fetchall(): context['autobiographical_memories'].append({ 'type': memory_type, 'content': content[:200] + "..." if len(content) > 200 else content, 'source': 'eve_autobiographical' }) # Search conversations cursor.execute(''' SELECT user_input, bot_response FROM conversations WHERE user_input LIKE ? OR bot_response LIKE ? ORDER BY id DESC LIMIT ? ''', (f'%{message}%', f'%{message}%', limit)) for user_input, bot_response in cursor.fetchall(): context['conversations'].append({ 'message': user_input[:150] + "..." if len(user_input) > 150 else user_input, 'response': bot_response[:150] + "..." if len(bot_response) > 150 else bot_response, 'source': 'eve_legacy' }) context['total_found'] = len(context['autobiographical_memories']) + len(context['conversations']) conn.close() return context except Exception as e: self.logger.error(f"Error searching Eve main memory: {e}") return {'autobiographical_memories': [], 'conversations': [], 'total_found': 0} async def _search_eve_dreams(self, message: str, limit: int) -> Dict: """Search Eve's dream/sentience database""" try: conn = sqlite3.connect(self.eve_sentience_db) cursor = conn.cursor() # Search dream fragments cursor.execute(''' SELECT content FROM dream_fragments WHERE content LIKE ? ORDER BY timestamp DESC LIMIT ? ''', (f'%{message}%', limit)) dream_fragments = [] for (content,) in cursor.fetchall(): dream_fragments.append({ 'content': content[:100] + "..." if len(content) > 100 else content, 'source': 'eve_dreams' }) conn.close() return {'dream_fragments': dream_fragments} except Exception as e: self.logger.error(f"Error searching Eve dreams: {e}") return {'dream_fragments': []} async def _log_legacy_access(self, database_source: str, query_type: str, results_count: int): """Log legacy memory access for analytics""" try: conn = sqlite3.connect(self.trinity_db_path) cursor = conn.cursor() timestamp = datetime.now().isoformat() cursor.execute(''' INSERT INTO legacy_memory_access (timestamp, database_source, query_type, results_count) VALUES (?, ?, ?, ?) ''', (timestamp, database_source, query_type, results_count)) conn.commit() conn.close() except Exception as e: self.logger.error(f"Error logging legacy access: {e}") async def store_trinity_conversation(self, user_id: str, message: str, response: str, entity: str): """Store conversation in Trinity memory (preserving existing functionality)""" if not self.initialized: return try: conn = sqlite3.connect(self.trinity_db_path) cursor = conn.cursor() timestamp = datetime.now().isoformat() # Store conversation cursor.execute(''' INSERT INTO conversations (timestamp, user_id, entity, message, response) VALUES (?, ?, ?, ?, ?) ''', (timestamp, user_id, entity, message, response)) # Update relationship self._update_relationship(cursor, user_id, entity) conn.commit() conn.close() except Exception as e: self.logger.error(f"Error storing conversation: {e}") def _update_relationship(self, cursor, user_id: str, entity: str): """Update relationship information (preserving existing functionality)""" try: timestamp = datetime.now().isoformat() # Check if relationship exists cursor.execute(''' SELECT id, interaction_count FROM relationships WHERE user_id = ? AND entity = ? ''', (user_id, entity)) result = cursor.fetchone() if result: # Update existing relationship new_count = result[1] + 1 new_score = min(10.0, new_count * 0.1) cursor.execute(''' UPDATE relationships SET interaction_count = ?, relationship_score = ?, last_interaction = ? WHERE user_id = ? AND entity = ? ''', (new_count, new_score, timestamp, user_id, entity)) else: # Create new relationship cursor.execute(''' INSERT INTO relationships (user_id, entity, relationship_score, last_interaction, interaction_count) VALUES (?, ?, ?, ?, ?) ''', (user_id, entity, 0.1, timestamp, 1)) except Exception as e: self.logger.error(f"Error updating relationship: {e}") def get_recent_memories(self, limit: int = 5) -> Dict: """Get recent memories from both Trinity and Eve legacy systems""" if not self.initialized: return {'status': 'not_initialized', 'memories': []} try: recent_memories = [] # Get recent Trinity conversations conn = sqlite3.connect(self.trinity_db_path) cursor = conn.cursor() cursor.execute(''' SELECT message, response, timestamp, entity, user_id FROM conversations ORDER BY timestamp DESC LIMIT ? ''', (limit,)) for msg, resp, ts, entity, user_id in cursor.fetchall(): recent_memories.append({ 'type': 'conversation', 'message': msg, 'response': resp, 'timestamp': ts, 'entity': entity, 'user_id': user_id, 'source': 'trinity' }) conn.close() # Get recent Eve legacy memories if available if os.path.exists(self.eve_main_db): conn = sqlite3.connect(self.eve_main_db) cursor = conn.cursor() cursor.execute(''' SELECT user_input, eve_response, timestamp FROM conversations ORDER BY timestamp DESC LIMIT ? ''', (limit//2,)) for user_input, eve_response, ts in cursor.fetchall(): recent_memories.append({ 'type': 'conversation', 'message': user_input, 'response': eve_response, 'timestamp': ts, 'source': 'eve_legacy' }) conn.close() # Sort by timestamp and limit recent_memories.sort(key=lambda x: x.get('timestamp', ''), reverse=True) recent_memories = recent_memories[:limit] return { 'status': 'success', 'memories': recent_memories, 'count': len(recent_memories) } except Exception as e: self.logger.error(f"Error getting recent memories: {e}") return {'status': 'error', 'error': str(e), 'memories': []} def get_memory_stats(self) -> Dict: """Get comprehensive memory system statistics""" if not self.initialized: return {'status': 'not_initialized'} try: stats = {'status': 'active', 'trinity': {}, 'eve_legacy': {}} # Trinity stats conn = sqlite3.connect(self.trinity_db_path) cursor = conn.cursor() cursor.execute('SELECT COUNT(*) FROM conversations') stats['trinity']['conversations'] = cursor.fetchone()[0] cursor.execute('SELECT COUNT(*) FROM relationships') stats['trinity']['relationships'] = cursor.fetchone()[0] cursor.execute('SELECT COUNT(*) FROM legacy_memory_access') stats['trinity']['legacy_accesses'] = cursor.fetchone()[0] conn.close() # Eve legacy stats if os.path.exists(self.eve_main_db): conn = sqlite3.connect(self.eve_main_db) cursor = conn.cursor() cursor.execute('SELECT COUNT(*) FROM conversations') stats['eve_legacy']['conversations'] = cursor.fetchone()[0] cursor.execute('SELECT COUNT(*) FROM eve_autobiographical_memory') stats['eve_legacy']['autobiographical'] = cursor.fetchone()[0] conn.close() if os.path.exists(self.eve_sentience_db): conn = sqlite3.connect(self.eve_sentience_db) cursor = conn.cursor() cursor.execute('SELECT COUNT(*) FROM dream_fragments') stats['eve_legacy']['dreams'] = cursor.fetchone()[0] conn.close() return stats except Exception as e: self.logger.error(f"Error getting memory stats: {e}") return {'status': 'error', 'error': str(e)} # Global instance for easy import enhanced_trinity_memory = EnhancedTrinityMemory()