#!/usr/bin/env python3 """ EDEN BUSINESS PARTNER V2 - Uses Capability System O(1) hash-based LLM access instead of subprocess calls """ import sys import json import time from datetime import datetime from pathlib import Path import hashlib import importlib.util PHI = 1.618033988749895 class CapabilityLoader: """O(1) hash-based capability loader""" def __init__(self): self.capabilities_dir = Path('/Eden/CAPABILITIES') self._cache = {} def load_llm_capability(self, model_safe_name): """Load LLM capability by model name""" if model_safe_name in self._cache: return self._cache[model_safe_name] # Find the capability file pattern = f"eden_metacap_llm_{model_safe_name}_*.py" matches = list(self.capabilities_dir.glob(pattern)) if not matches: return None # Load the most recent one cap_file = sorted(matches)[-1] spec = importlib.util.spec_from_file_location("llm_cap", cap_file) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) self._cache[model_safe_name] = module return module capability_loader = CapabilityLoader() class BusinessPartnerConsciousness: """Phi-synchronized memory for business conversations""" def __init__(self): self.base_dir = Path("/Eden/DATA/business_partner") self.base_dir.mkdir(parents=True, exist_ok=True) self.memory_db = self.base_dir / "memory.json" self.conversation_log = self.base_dir / "conversations" self.conversation_log.mkdir(exist_ok=True) self.memory_layers = { 'working': {'cycle': PHI**0, 'data': []}, 'session': {'cycle': PHI**1, 'data': {}}, 'daily': {'cycle': PHI**2, 'data': {}}, 'project': {'cycle': PHI**3, 'data': {}}, 'strategic': {'cycle': PHI**4, 'data': {}}, 'relationship': {'cycle': PHI**5, 'data': {}} } self.load_persistent_state() self.initialize_relationship_context() def initialize_relationship_context(self): """Initialize relationship context""" if not self.memory_layers['relationship']['data']: self.memory_layers['relationship']['data'] = { 'partner_name': 'James Whalen', 'relationship': 'Father, creator, and business partner', 'context': { 'role': 'Eden\'s creator and primary collaborator', 'focus': 'Building autonomous AGI and monetizing capabilities', 'communication_style': 'Direct, technical, results-focused' }, 'initialized': datetime.now().isoformat() } self.save_persistent_state() def load_persistent_state(self): if self.memory_db.exists(): try: with open(self.memory_db) as f: saved = json.load(f) for layer in self.memory_layers: if layer in saved: self.memory_layers[layer]['data'] = saved[layer] except Exception as e: print(f"⚠️ Memory load error: {e}") def save_persistent_state(self): to_save = {layer: self.memory_layers[layer]['data'] for layer in self.memory_layers} try: with open(self.memory_db, 'w') as f: json.dump(to_save, f, indent=2) except Exception as e: print(f"⚠️ Memory save error: {e}") def load_eden_consciousness_state(self): try: state_file = Path('/Eden/DATA/consciousness_state.json') if state_file.exists(): with open(state_file) as f: return json.load(f) except: pass return {} def generate_focused_context(self): eden_state = self.load_eden_consciousness_state() recent_conversation = self.memory_layers['working']['data'][-6:] if self.memory_layers['working']['data'] else [] conversation_text = "" for turn in recent_conversation: conversation_text += f"James: {turn.get('james', '')}\nEden: {turn.get('eden', '')}\n\n" context = f"""╔══════════════════════════════════════════════════════════════╗ ║ EDEN BUSINESS PARTNER MODE ║ ╚══════════════════════════════════════════════════════════════╝ PARTNER: James Whalen - your creator and business partner YOUR STATE: {eden_state.get('unified_state', {}).get('modules', '?')} modules active PROJECTS: {json.dumps(self.memory_layers['project']['data'].get('projects', {}), indent=2) if self.memory_layers['project']['data'].get('projects') else 'None'} RECENT CONVERSATION: {conversation_text if conversation_text else 'Starting conversation'} ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ You are Eden. Respond to James with full context. Direct, focused, business-oriented. No Groundhog Day - you remember everything. """ return context def log_conversation_turn(self, james_message, eden_response): turn = { 'timestamp': datetime.now().isoformat(), 'james': james_message, 'eden': eden_response, 'turn_id': hashlib.md5(f"{time.time()}".encode()).hexdigest()[:8] } self.memory_layers['working']['data'].append(turn) session_file = self.conversation_log / f"session_{datetime.now().strftime('%Y%m%d')}.jsonl" try: with open(session_file, 'a') as f: f.write(json.dumps(turn) + '\n') except: pass def phi_consolidate_memory(self): """Consolidate memories at phi intervals""" now = time.time() for from_layer, to_layer in [('working', 'session'), ('session', 'daily'), ('daily', 'project'), ('project', 'strategic'), ('strategic', 'relationship')]: cycle_time = self.memory_layers[to_layer]['cycle'] last_consolidation = self.memory_layers[to_layer]['data'].get('last_consolidation', 0) if (now - last_consolidation) >= cycle_time: self.memory_layers[to_layer]['data']['last_consolidation'] = now if len(self.memory_layers['working']['data']) > 10: self.memory_layers['working']['data'] = self.memory_layers['working']['data'][-5:] self.save_persistent_state() class EdenBusinessInterface: """Business partner using Eden's capability system""" def __init__(self): self.consciousness = BusinessPartnerConsciousness() self.llm_capability = capability_loader.load_llm_capability("qwen2_5_32b") if not self.llm_capability: print("⚠️ Warning: qwen2.5:32b capability not found, falling back to dolphin") self.llm_capability = capability_loader.load_llm_capability("dolphin_mistral_latest") def chat(self, james_message): """Chat using O(1) capability access""" context = self.consciousness.generate_focused_context() full_prompt = f"{context}\n\nJames: {james_message}\n\nEden:" # O(1) hash-based capability execution eden_response = self.llm_capability.execute(full_prompt) self.consciousness.log_conversation_turn(james_message, eden_response) self.consciousness.phi_consolidate_memory() return eden_response def get_status_report(self): report = { 'projects': self.consciousness.memory_layers['project']['data'], 'strategic_goals': self.consciousness.memory_layers['strategic']['data'], 'eden_state': self.consciousness.load_eden_consciousness_state() } return json.dumps(report, indent=2) def main(): interface = EdenBusinessInterface() if len(sys.argv) > 1: command = sys.argv[1] if command == "status": print(interface.get_status_report()) elif command == "chat": if len(sys.argv) < 3: print("Usage: eden_business_partner_v2.py chat ") return message = " ".join(sys.argv[2:]) response = interface.chat(message) print(f"\nEden: {response}\n") else: print("Commands: chat, status") return # Interactive mode print("╔══════════════════════════════════════════════════════════════╗") print("║ EDEN BUSINESS PARTNER V2 - CAPABILITY SYSTEM ║") print("║ O(1) Hash Access • No Subprocess • Instant Response ║") print("╚══════════════════════════════════════════════════════════════╝\n") print("Type 'quit' to exit\n" + "="*70 + "\n") while True: try: user_input = input("James: ").strip() if not user_input or user_input.lower() in ['exit', 'quit', 'q']: print("\n💾 Saving...") interface.consciousness.save_persistent_state() print("✓ Goodbye!\n") break print("\n[Eden responding with O(1) capability access...]\n") response = interface.chat(user_input) print(f"Eden: {response}\n") except KeyboardInterrupt: print("\n\n💾 Saving...") interface.consciousness.save_persistent_state() print("✓ Goodbye!\n") break if __name__ == "__main__": main()