controller_runtime.py

from system_registry import SystemRegistry
from controller import Controller
from abstraction_engine import AbstractionEngine
from local_llm import LocalLLM
from meta_engine import MetaEngine
from llm_world_controller import LLMWorldController
from world_validator import WorldValidator

# =====================================================
# CORE MOCK / BASE SYSTEMS
# =====================================================

class MetaEngineMock:

    def extract(self, data):
        return {
            "rules": {},
            "entities": [],
            "confidence": 0.5
        }


class LiveSyncMock:

    def tick(self):
        return {"render": True, "events": []}


class StrategyRouterMock:

    def select(self, perception):
        return {"id": "default", "strength": 0.5}


class PowerUpSystem:

    def __init__(self):
        self.active = []

    def add(self, name, effects, duration=5.0):
        self.active.append({
            "name": name,
            "effects": effects,
            "duration": duration
        })

    def modify_signals(self, signals):
        out = dict(signals)
        for p in self.active:
            for k, v in p["effects"].items():
                out[k] = out.get(k, 0) + v
        return out


class MetricsMock:

    def __init__(self):
        self.data = []

    def log(self, item):
        self.data.append(item)

    def summarize(self):
        return {"avg_reward": 0.5}


class EvolverMock:

    def evolve(self, world, metrics):
        return {}


class UpdaterMock:

    def apply(self, world, patch):
        return world


class Binding:

    def __init__(self):
        self.bindings = []

    def resolve(self, inventory, signals):
        return []


class Inventory:

    def __init__(self):
        self.items = {}

    def add(self, name, item):
        self.items[name] = item

    def get(self, name):
        return self.items.get(name)


class ShapeRenderer:

    def submit(self, shapes):
        self.shapes = shapes or []

    def render(self, screen):
        pass


# =====================================================
# BEHAVIOR SYSTEMS
# =====================================================

class BehaviorTracker:

    def __init__(self):
        self.actions = []

    def log(self, action):
        self.actions.append(action)

    def get_recent(self):
        return self.actions[-50:]


class FeatureExtractor:

    def extract(self, actions):

        if not actions:
            return {}

        counts = {}
        for a in actions:
            counts[a] = counts.get(a, 0) + 1

        total = sum(counts.values()) + 1e-5

        return {
            "ratios": {k: v / total for k, v in counts.items()},
            "repetition": max(counts.values()) / total
        }


class BehaviorModel:

    def classify(self, features):

        ratios = features.get("ratios", {})

        if ratios.get("move", 0) > 0.6:
            return "aggressive"

        if ratios.get("avoid", 0) > 0.4:
            return "cautious"

        return "balanced"


class BehaviorPatch:

    def generate(self, style):

        if style == "aggressive":
            return {"rules": {"entropy": 1}}

        if style == "cautious":
            return {"powerups": [{"name": "shield", "effect": {"stability": 0.5}}]}

        return {}


# =====================================================
# BUILD SYSTEM (AUTO-ASSEMBLY ORDER)
# =====================================================

def build_system():

    registry = SystemRegistry()

    # ---------------------------------
    # PHASE 1: CORE DEPENDENCIES
    # ---------------------------------
    meta_engine = MetaEngineMock()
    registry.add("meta_engine", meta_engine)

    # ---------------------------------
    # PHASE 2: MID-LEVEL SYSTEMS
    # ---------------------------------
    abstraction_engine = AbstractionEngine(meta_engine)
    registry.add("abstraction_engine", abstraction_engine)

    registry.add("live_sync", LiveSyncMock())
    registry.add("strategy_router", StrategyRouterMock())
    llm = LocalLLM("codegemma:7b")
    meta_engine = MetaEngine(llm)

    registry.add("meta_engine", meta_engine)
    # ---------------------------------
    # PHASE 3: GAME SYSTEMS
    # ---------------------------------
    registry.add("powerups", PowerUpSystem())
    registry.add("metrics", MetricsMock())
    registry.add("evolver", EvolverMock())
    registry.add("updater", UpdaterMock())
    registry.add("binding", Binding())
    registry.add("inventory", Inventory())
    registry.add("shape_renderer", ShapeRenderer())

    # ---------------------------------
    # PHASE 4: BEHAVIOR STACK
    # ---------------------------------
    registry.add("behavior_tracker", BehaviorTracker())
    registry.add("feature_extractor", FeatureExtractor())
    registry.add("behavior_model", BehaviorModel())
    registry.add("behavior_patch", BehaviorPatch())
    from llm_world_controller import LLMWorldController

    llm_world = LLMWorldController(model="codegemma:7b")

    registry.add("llm_world", llm_world)
    validator = WorldValidator()
    registry.add("world_validator", validator)
    # ---------------------------------
    # FINAL VALIDATION
    # ---------------------------------
    required = [
        "meta_engine",
        "abstraction_engine",
        "live_sync",
        "strategy_router",
        "powerups",
        "metrics",
        "evolver",
        "updater",
        "binding",
        "inventory",
        "shape_renderer",
        "behavior_tracker",
        "feature_extractor",
        "behavior_model",
        "behavior_patch"
    ]

    missing = [r for r in required if registry.get(r) is None]

    if missing:
        raise Exception(f"BOOT FAILED - missing systems: {missing}")

    # ---------------------------------
    # CREATE CONTROLLER LAST
    # ---------------------------------
    system = Controller(registry)

    print("🧠 SYSTEM BOOT COMPLETE")
    print("Registry:", registry.snapshot())

    return system