core/codex_informer.py

# core/codex_informer.py
# Master Emotional Core (MEC) - Codex Informer v3 (Memory-Optimized)

import yaml
import random

class CodexInformer:
    def __init__(
        self,
        emotion_families_path='config/emotion_families.yaml',
        arc_mapping_path='config/arc_mapping.yaml',
        resonance_mapping_path='config/resonance_mapping.yaml'
    ):
        # Load emotion families YAML
        with open(emotion_families_path, 'r', encoding='utf-8') as f:
            data = yaml.safe_load(f)
        self.emotion_families = data.get('emotion_families', [])

        # Build lookup maps
        self.family_lookup = {}      # code -> True
        self.family_names  = {}      # code -> human-readable name

        for family in self.emotion_families:
            code = family['code']
            name = family.get('name', code)
            self.family_lookup[code] = True
            self.family_names[code] = name

        # Load arc & resonance mappings
        with open(arc_mapping_path, 'r', encoding='utf-8') as f:
            self.arc_lookup = yaml.safe_load(f).get('arc_mapping', {})
        with open(resonance_mapping_path, 'r', encoding='utf-8') as f:
            self.resonance_lookup = yaml.safe_load(f).get('resonance_mapping', {})

        # Optionally load variants (omitted here for brevity)
        self.variant_lookup = {}

        print(
            f"[CodexInformer] Loaded {len(self.family_lookup)} families, "
            f"{len(self.variant_lookup)} variants, "
            f"{len(self.arc_lookup)} arcs, "
            f"{len(self.resonance_lookup)} resonance patterns"
        )

    def resolve_emotion_family(self, emotion_code):
        """
        Always returns a dict with:
          primary_emotion_code, emotion_family, arc, resonance
        """
        # If exact family code
        if emotion_code.startswith("FAM-") and emotion_code in self.family_lookup:
            arc       = self.arc_lookup.get(emotion_code)
            resonance = self.resonance_lookup.get(emotion_code, "Neutral")
        
            return {
                'primary_emotion_code': emotion_code,
                'emotion_family': emotion_code,
                'arc': arc,
                'resonance': resonance
            }

        # If variant code
        if emotion_code.startswith("VAR-") and emotion_code in self.variant_lookup:
            fam_code  = self.variant_lookup[emotion_code]['family_code']
            arc       = self.arc_lookup.get(fam_code, "associate_families")
            resonance = self.resonance_lookup.get(fam_code, "Neutral")
            return {
                'primary_emotion_code': emotion_code,
                'emotion_family': fam_code,
                'arc': arc,
                'resonance': resonance
            }
        else:
            # If emotion_code doesn't match "FAM-" structure, don't default to Stable"    
            arc = self.arc_lookup.get(emotion_code, "Unknown")
            return {
                'primary_emotion_code': emotion_code,
                'emotion_family': emotion_code,
                'arc': arc,
                'resonance': "Unknown"
            }

        # Fallback: unknown code → treat as family, use fallback name logic
        arc       = "Unknown"
        resonance = "Unknown"
        return {
            'primary_emotion_code': emotion_code,
            'emotion_family': emotion_code,
            'arc': arc,
            'resonance': resonance
        }

    def get_family_name(self, code):
        """
        Return the human-readable name for a given family code.
        If not in your YAML, strip "FAM-" and capitalize.
        """
        if code in self.family_names:
            return self.family_names[code]
        # Fallback: strip prefix and make title-case
        if code.startswith("FAM-"):
            raw = code[len("FAM-"):]
            return raw.capitalize()
        return code

    def build_alias_lookup(self):
        # your existing alias logic...
        alias_lookup = {}
        # ...
        return alias_lookup

    def get_family_choices(self):
        """
        For UI dropdown: a list of {label: human-name, value: code}
        """
        return [
            {'label': self.get_family_name(code), 'value': code}
            for code in self.family_names.keys()
        ]

    def select_random_scenario(self, family_code=None):
        # your scenario logic if needed...
        return ""