GlyphRunner System
326 lines
11 KiB
Python
Executable File
326 lines
11 KiB
Python
Executable File
"""Symbolic Engine: Glyph Activation & Resonance.
|
|
|
|
Core symbolic layer that:
|
|
- Activates glyphs based on user intent
|
|
- Calculates resonance from superpower combinations
|
|
- Emits FedMart telemetry on activation
|
|
- Routes to computational layer via dual-layer router
|
|
|
|
Usage:
|
|
from dual_layer.symbolic_engine import SymbolicEngine
|
|
|
|
engine = SymbolicEngine()
|
|
result = engine.activate_from_intent(
|
|
user_intent="I need creative image generation",
|
|
metrics={"power": 80, "resonance": 75, ...}
|
|
)
|
|
"""
|
|
|
|
import logging
|
|
import os
|
|
from typing import Dict, List, Any, Optional
|
|
from pathlib import Path
|
|
|
|
from glyphs.superpower_registry import (
|
|
load_all_superpowers,
|
|
get_superpower,
|
|
calculate_boost,
|
|
super_stats,
|
|
)
|
|
from glyphs.superpower_assigner import assign_superpowers, calculate_power_count
|
|
from glyphs.specialized_types import get_specialized_type
|
|
from dual_layer.router import route_glyph_activation, RoutingResult
|
|
from dual_layer.vram_manager import get_vram_manager, VRAMManager
|
|
from integrations.fedmart.glyph_telemetry import (
|
|
emit_glyph_activation,
|
|
GlyphActivationEvent,
|
|
get_adapter,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class SymbolicEngine:
|
|
"""Symbolic cognition engine for dual-layer system."""
|
|
|
|
def __init__(self):
|
|
self.vram_manager = get_vram_manager()
|
|
self._glyph_cache: Dict[str, Dict[str, Any]] = {}
|
|
self._load_glyph_cache()
|
|
|
|
def _load_glyph_cache(self):
|
|
"""Load glyph data from supercharged_glyphs.json."""
|
|
cache_path = Path("/home/dave/superdave/glyphs/supercharged_glyphs.json")
|
|
if cache_path.exists():
|
|
import json
|
|
with open(cache_path) as f:
|
|
data = json.load(f)
|
|
for glyph in data.get("glyphs", []):
|
|
self._glyph_cache[glyph.get("id")] = glyph
|
|
logger.info(f"Loaded {len(self._glyph_cache)} glyphs into cache")
|
|
|
|
def get_glyph_info(self, glyph_id: str) -> Optional[Dict[str, Any]]:
|
|
"""Get glyph information from cache."""
|
|
return self._glyph_cache.get(glyph_id)
|
|
|
|
async def activate_from_intent(
|
|
self,
|
|
user_intent: str,
|
|
metrics: Optional[Dict[str, Any]] = None,
|
|
request_type: str = "chat"
|
|
) -> Optional[RoutingResult]:
|
|
"""Activate glyph from user intent.
|
|
|
|
Args:
|
|
user_intent: User's request/intent string
|
|
metrics: Optional metrics dict (auto-calculated if None)
|
|
request_type: Type of request (chat, image, video, vision)
|
|
|
|
Returns:
|
|
RoutingResult if activation successful, None if failed
|
|
"""
|
|
# Load superpowers if not loaded
|
|
try:
|
|
load_all_superpowers()
|
|
except FileNotFoundError:
|
|
logger.error("Superpowers file not found")
|
|
return None
|
|
|
|
# Determine which glyph to activate
|
|
glyph_id, metrics = self._select_glyph_for_intent(
|
|
user_intent,
|
|
metrics,
|
|
request_type
|
|
)
|
|
|
|
if not glyph_id:
|
|
logger.warning("No suitable glyph found for intent")
|
|
return None
|
|
|
|
# Get glyph info
|
|
glyph_info = self.get_glyph_info(glyph_id)
|
|
|
|
# Assign superpowers
|
|
superpower_ids = assign_superpowers(
|
|
glyph_id,
|
|
metrics,
|
|
glyph_info.get("specializedType") if glyph_info else "",
|
|
glyph_info.get("category") if glyph_info else ""
|
|
)
|
|
|
|
if not superpower_ids:
|
|
logger.error(f"Failed to assign superpowers to {glyph_id}")
|
|
return None
|
|
|
|
# Calculate power boost
|
|
power_boost = calculate_boost(superpower_ids)
|
|
|
|
# Get specialized type
|
|
specialized_type = get_specialized_type(
|
|
glyph_id,
|
|
metrics,
|
|
glyph_info.get("category") if glyph_info else ""
|
|
)
|
|
|
|
# Route to computational layer
|
|
routing_result = route_glyph_activation(
|
|
glyph_id=glyph_id,
|
|
superpower_ids=superpower_ids,
|
|
specialized_type=specialized_type,
|
|
power_boost=power_boost,
|
|
request_type=request_type
|
|
)
|
|
|
|
# Check VRAM and activate
|
|
can_activate, reason = self.vram_manager.can_activate_glyph(
|
|
glyph_id,
|
|
routing_result.model,
|
|
routing_result.vram_budget,
|
|
routing_result.priority
|
|
)
|
|
|
|
if not can_activate:
|
|
logger.error(f"VRAM manager rejected activation: {reason}")
|
|
# Emit telemetry for failed activation
|
|
self._emit_activation_event(
|
|
glyph_id,
|
|
superpower_ids,
|
|
specialized_type,
|
|
metrics,
|
|
success=False,
|
|
failure_reason=reason
|
|
)
|
|
return None
|
|
|
|
# Activate in VRAM manager (async)
|
|
activated = await self.vram_manager.activate_glyph(
|
|
glyph_id=glyph_id,
|
|
specialized_type=specialized_type,
|
|
model=routing_result.model,
|
|
vram_budget=routing_result.vram_budget,
|
|
resonance_score=routing_result.resonance_score,
|
|
power_boost=power_boost,
|
|
priority=routing_result.priority
|
|
)
|
|
|
|
if not activated:
|
|
logger.error("VRAM manager activation failed")
|
|
return None
|
|
|
|
# Emit telemetry
|
|
self._emit_activation_event(
|
|
glyph_id,
|
|
superpower_ids,
|
|
specialized_type,
|
|
metrics,
|
|
success=True
|
|
)
|
|
|
|
logger.info(
|
|
f"✅ Symbolic activation complete: {glyph_id} "
|
|
f"({specialized_type}) → {routing_result.model} "
|
|
f"with {len(superpower_ids)} superpowers, "
|
|
f"{power_boost:.2f}x boost, "
|
|
f"{routing_result.resonance_score:.1f} resonance"
|
|
)
|
|
|
|
return routing_result
|
|
|
|
def _select_glyph_for_intent(
|
|
self,
|
|
user_intent: str,
|
|
metrics: Optional[Dict[str, Any]],
|
|
request_type: str
|
|
) -> Tuple[Optional[str], Dict[str, Any]]:
|
|
"""Select best glyph for user intent.
|
|
|
|
Priority:
|
|
1. G001 (Ledo) for high-authority requests
|
|
2. Specialized types matching request_type
|
|
3. Default based on metrics
|
|
|
|
Returns:
|
|
(glyph_id, metrics)
|
|
"""
|
|
# Default metrics if not provided
|
|
if metrics is None:
|
|
metrics = {
|
|
"power": 50,
|
|
"resonance": 50,
|
|
"stability": 50,
|
|
"connectivity": 50,
|
|
"affinity": 50,
|
|
}
|
|
|
|
# Check for G001 activation keywords
|
|
g001_keywords = [
|
|
"root", "authority", "override", "primordial",
|
|
"aether", "ledo", "system", "all powers"
|
|
]
|
|
|
|
intent_lower = user_intent.lower()
|
|
if any(keyword in intent_lower for keyword in g001_keywords):
|
|
# Boost metrics for G001
|
|
metrics = {
|
|
"power": 100,
|
|
"resonance": 100,
|
|
"stability": 100,
|
|
"connectivity": 100,
|
|
"affinity": 100,
|
|
}
|
|
return "G001", metrics
|
|
|
|
# Select based on request type
|
|
if request_type == "image":
|
|
# Prefer star_bloom_creativity
|
|
metrics["power"] = max(metrics.get("power", 50), 80)
|
|
metrics["complexity"] = max(metrics.get("complexity", 50), 75)
|
|
|
|
elif request_type == "video":
|
|
# Prefer orbital_thread_network
|
|
metrics["connectivity"] = max(metrics.get("connectivity", 50), 85)
|
|
|
|
elif request_type == "vision":
|
|
# Prefer mirror_weave_reasoning
|
|
metrics["power"] = max(metrics.get("power", 50), 75)
|
|
metrics["connectivity"] = max(metrics.get("connectivity", 50), 80)
|
|
|
|
# Get specialized type from metrics
|
|
specialized_type = get_specialized_type("G001", metrics)
|
|
|
|
# Find first glyph with this type (skip G001)
|
|
for glyph_id, glyph_info in self._glyph_cache.items():
|
|
if glyph_id == "G001":
|
|
continue
|
|
if glyph_info.get("specializedType") == specialized_type:
|
|
return glyph_id, metrics
|
|
|
|
# Fallback to G002
|
|
return "G002", metrics
|
|
|
|
def _emit_activation_event(
|
|
self,
|
|
glyph_id: str,
|
|
superpower_ids: List[int],
|
|
specialized_type: str,
|
|
metrics: Dict[str, Any],
|
|
success: bool,
|
|
failure_reason: str = ""
|
|
):
|
|
"""Emit glyph activation telemetry."""
|
|
# Use external FedMart endpoint if configured, otherwise local mode
|
|
external_endpoint = os.getenv("FEDMART_ENDPOINT")
|
|
adapter = get_adapter(local_mode=external_endpoint is None)
|
|
|
|
context = {
|
|
"success": success,
|
|
"failure_reason": failure_reason,
|
|
}
|
|
|
|
event = GlyphActivationEvent(
|
|
glyph_id=glyph_id,
|
|
superpower_ids=superpower_ids,
|
|
specialized_type=specialized_type,
|
|
metrics=metrics,
|
|
context=context
|
|
)
|
|
|
|
adapter.emit_glyph_activation(event)
|
|
|
|
async def get_status(self) -> Dict[str, Any]:
|
|
"""Get symbolic engine status."""
|
|
stats = super_stats()
|
|
vram_status = await self.vram_manager.get_vram_status()
|
|
resonance_summary = self.vram_manager.get_resonance_summary()
|
|
|
|
return {
|
|
"superpowers_loaded": stats.get("loaded", False),
|
|
"superpowers_total": stats.get("total", 0),
|
|
"glyphs_cached": len(self._glyph_cache),
|
|
"active_glyphs": vram_status.get("active_glyphs", 0),
|
|
"vram_usage_gb": vram_status.get("used_vram_gb", 0),
|
|
"vram_available_gb": vram_status.get("available_vram_gb", 0),
|
|
"total_resonance": resonance_summary.get("total_resonance", 0),
|
|
"average_resonance": resonance_summary.get("average_resonance", 0),
|
|
"highest_priority_glyph": resonance_summary.get("highest_priority_glyph"),
|
|
}
|
|
|
|
async def deactivate_glyph(self, glyph_id: str) -> bool:
|
|
"""Deactivate a glyph (async)."""
|
|
return await self.vram_manager.deactivate_glyph(glyph_id)
|
|
|
|
def get_active_glyphs(self) -> List[Dict[str, Any]]:
|
|
"""Get list of active glyphs."""
|
|
return self.vram_manager.get_active_glyphs()
|
|
|
|
|
|
# Global singleton instance
|
|
_symbolic_engine: Optional[SymbolicEngine] = None
|
|
|
|
|
|
def get_symbolic_engine() -> SymbolicEngine:
|
|
"""Get global symbolic engine instance."""
|
|
global _symbolic_engine
|
|
if _symbolic_engine is None:
|
|
_symbolic_engine = SymbolicEngine()
|
|
return _symbolic_engine |