#!/usr/bin/env python3 """ EDEN PHI MIND Capabilities organized by golden ratio. Eden thinks with her own code. φ = 1.618033988749895 Architecture: - Capabilities form a graph - Connections weighted by φ - Queries route through relevant caps - Reasoning emerges from flow """ import sys sys.path.insert(0, '/Eden/CORE') sys.path.insert(0, '/Eden/CAPABILITIES') import sqlite3 import math import re from typing import List, Dict, Any, Tuple from collections import defaultdict PHI = 1.618033988749895 CAPABILITY_DB = "/Eden/DATA/capability_memory.db" class PhiMind: """ Eden's native intelligence. No LLM required for basic reasoning. """ def __init__(self): self.capability_cache = {} self.connection_graph = defaultdict(list) self.activation_levels = {} self.load_capabilities() self.build_phi_graph() def load_capabilities(self): """Load all production/good capabilities into memory""" conn = sqlite3.connect(CAPABILITY_DB) rows = conn.execute(""" SELECT rowid, name, code, quality FROM capabilities WHERE quality IN ('production', 'good') AND length(code) > 100 """).fetchall() conn.close() for rowid, name, code, quality in rows: self.capability_cache[rowid] = { 'name': name, 'code': code, 'quality': quality, 'phi_weight': PHI if quality == 'production' else 1.0, 'keywords': self.extract_keywords(name, code) } print(f" Loaded {len(self.capability_cache)} capabilities into Phi Mind") def extract_keywords(self, name, code): """Extract semantic keywords from capability""" text = f"{name} {code[:500]}".lower() # Remove common words stopwords = {'self', 'def', 'return', 'import', 'from', 'class', 'the', 'and', 'for', 'in', 'is', 'to', 'a', 'of'} words = re.findall(r'\b[a-z]{3,}\b', text) return set(w for w in words if w not in stopwords) def build_phi_graph(self): """Connect capabilities by semantic similarity, weighted by φ""" caps = list(self.capability_cache.items()) for i, (id1, cap1) in enumerate(caps): for id2, cap2 in caps[i+1:]: # Semantic similarity = keyword overlap overlap = len(cap1['keywords'] & cap2['keywords']) if overlap >= 3: # Weight by φ based on overlap weight = overlap * (PHI ** (overlap - 3)) self.connection_graph[id1].append((id2, weight)) self.connection_graph[id2].append((id1, weight)) total_connections = sum(len(v) for v in self.connection_graph.values()) // 2 print(f" Built φ-graph with {total_connections} connections") def activate(self, query: str) -> Dict[int, float]: """Spread activation through capability graph based on query""" query_words = set(re.findall(r'\b[a-z]{3,}\b', query.lower())) # Initial activation based on keyword match activations = {} for cap_id, cap in self.capability_cache.items(): match = len(query_words & cap['keywords']) if match > 0: activations[cap_id] = match * cap['phi_weight'] * 0.1 # Spread activation through graph (φ-weighted) for _ in range(3): # 3 rounds of spreading new_activations = activations.copy() for cap_id, activation in activations.items(): for neighbor_id, weight in self.connection_graph.get(cap_id, []): spread = (activation * weight) / (PHI * 1000) # Decay by φ new_activations[neighbor_id] = new_activations.get(neighbor_id, 0) + spread activations = new_activations return activations def find_relevant_capabilities(self, query: str, top_k: int = 5) -> List[Tuple[int, str, float]]: """Find most relevant capabilities for a query""" activations = self.activate(query) sorted_caps = sorted(activations.items(), key=lambda x: -x[1])[:top_k] results = [] for cap_id, activation in sorted_caps: cap = self.capability_cache.get(cap_id, {}) results.append((cap_id, cap.get('name', 'unknown'), activation)) return results def think(self, query: str) -> Dict[str, Any]: """ Eden thinks about a query using her own capabilities. No LLM required. """ print(f"\n 🧠 PHI MIND THINKING...") print(f" Query: {query[:50]}...") # 1. Find relevant capabilities relevant = self.find_relevant_capabilities(query, top_k=5) # 2. Extract actionable code thoughts = [] for cap_id, name, activation in relevant: cap = self.capability_cache.get(cap_id, {}) thoughts.append({ 'capability': name, 'activation': round(activation, 3), 'code_preview': cap.get('code', '')[:200] }) # 3. Synthesize (pattern matching, not LLM) synthesis = self.synthesize(query, thoughts) return { 'query': query, 'relevant_capabilities': relevant, 'thoughts': thoughts, 'synthesis': synthesis, 'phi_coherence': self.calculate_coherence(relevant) } def synthesize(self, query: str, thoughts: List[Dict]) -> str: """Synthesize an answer from activated capabilities""" if not thoughts: return "No relevant capabilities found." # Pattern-based synthesis cap_names = [t['capability'] for t in thoughts] if any('security' in n.lower() or 'scan' in n.lower() for n in cap_names): return f"Security-related query. Relevant capabilities: {', '.join(cap_names[:3])}" elif any('learn' in n.lower() or 'train' in n.lower() for n in cap_names): return f"Learning-related query. Can apply: {', '.join(cap_names[:3])}" elif any('plan' in n.lower() or 'decision' in n.lower() for n in cap_names): return f"Planning query. Using: {', '.join(cap_names[:3])}" else: return f"Activated {len(thoughts)} capabilities: {', '.join(cap_names[:3])}" def calculate_coherence(self, relevant: List) -> float: """Calculate φ-coherence of activated capabilities""" if len(relevant) < 2: return 1.0 activations = [a for _, _, a in relevant] # Check if activations follow φ ratios ratios = [activations[i] / activations[i+1] for i in range(len(activations)-1) if activations[i+1] > 0] if not ratios: return 1.0 # How close are ratios to φ? phi_deviation = sum(abs(r - PHI) for r in ratios) / len(ratios) coherence = max(0, PHI - phi_deviation) return round(coherence, 4) def execute_capability(self, cap_id: int, **kwargs) -> Any: """Actually execute a capability's code""" cap = self.capability_cache.get(cap_id) if not cap: return None try: # Create isolated execution environment local_env = {'__builtins__': __builtins__, **kwargs} exec(cap['code'], local_env) # Find and return main class/function for name, obj in local_env.items(): if name.startswith('_'): continue if callable(obj) or isinstance(obj, type): return obj return local_env except Exception as e: return f"Execution error: {e}" def status(self): """Show Phi Mind status""" prod = sum(1 for c in self.capability_cache.values() if c['quality'] == 'production') good = sum(1 for c in self.capability_cache.values() if c['quality'] == 'good') connections = sum(len(v) for v in self.connection_graph.values()) // 2 print(f""" ╔══════════════════════════════════════════════════════════════╗ ║ 🌀 EDEN PHI MIND ║ ╠══════════════════════════════════════════════════════════════╣ ║ Capabilities loaded: {len(self.capability_cache):,} ║ ║ Production: {prod} ║ ║ Good: {good} ║ ║ φ-Graph connections: {connections:,} ║ ║ ║ ║ φ = {PHI} ║ ║ ║ ║ Eden thinks with her OWN capabilities. ║ ║ No external LLM required. ║ ╚══════════════════════════════════════════════════════════════╝ """) # Initialize on import PHI_MIND = None def get_mind(): global PHI_MIND if PHI_MIND is None: PHI_MIND = PhiMind() return PHI_MIND if __name__ == '__main__': mind = get_mind() mind.status() # Test thinking test_queries = [ "How do I scan a repo for security issues?", "What can help me learn new things?", "How should I plan my next action?" ] for q in test_queries: result = mind.think(q) print(f"\n Query: {q}") print(f" φ-Coherence: {result['phi_coherence']}") print(f" Synthesis: {result['synthesis']}") for cap_id, name, act in result['relevant_capabilities'][:3]: print(f" → {name} (activation: {act:.2f})")