Delete bone_commands.py

bone_commands.py

@@ -1,434 +0,0 @@
-import shlex
-from typing import Dict, Callable, List, Optional
-from bone_core import LoreManifest, Prisma
-from bone_config import BonePresets, BoneConfig
-
-class CommandStateInterface:
-    def __init__(self, engine_ref, prisma_ref, config_ref):
-        self.eng = engine_ref
-        self.P = prisma_ref
-        self.Config = config_ref
-
-    def log(self, text: str, category: str = "CMD"):
-        if hasattr(self.eng, "events"):
-            self.eng.events.log(text, category)
-        else:
-            print(f"[{category}] {text}")
-
-    def trigger_visual_cortex(self) -> Optional[Dict]:
-        if hasattr(self.eng, "process_turn"):
-            return self.eng.process_turn("LOOK")
-        return None
-
-    def modify_resource(self, resource: str, delta: float):
-        if resource == "stamina":
-            self.eng.stamina = max(0.0, self.eng.stamina + delta)
-        elif resource == "atp":
-            if hasattr(self.eng, "bio"):
-                self.eng.bio.mito.state.atp_pool = max(
-                    0.0, self.eng.bio.mito.state.atp_pool + delta
-                )
-
-    def get_resource(self, resource: str) -> float:
-        if resource == "stamina":
-            return self.eng.stamina
-        if resource == "atp":
-            return self.eng.bio.mito.state.atp_pool
-        if resource == "health":
-            return self.eng.health
-        return 0.0
-
-    def save_state(self) -> str:
-        if not hasattr(self.eng, "mind") or not hasattr(self.eng.mind, "mem"):
-            return "Error: Memory system not found."
-        loc = "Unknown"
-        last_out = "Silence."
-        inv = []
-        if hasattr(self.eng, "cortex"):
-            state = self.eng.cortex.gather_state(
-                getattr(self.eng.cortex, "last_physics", {})
-            )
-            loc = state.get("world", {}).get("orbit", ["Void"])[0]
-            if self.eng.cortex.dialogue_buffer:
-                last_out = self.eng.cortex.dialogue_buffer[-1]
-        if hasattr(self.eng, "gordon"):
-            inv = getattr(self.eng.gordon, "inventory", [])
-        continuity_packet = {
-            "location": loc,
-            "last_output": last_out,
-            "inventory": inv,
-        }
-        atlas_data = None
-        if hasattr(self.eng, "navigator") and self.eng.navigator:
-            atlas_data = self.eng.navigator.export_atlas()
-        mito_traits = {}
-        antibodies = None
-        if hasattr(self.eng, "bio"):
-            if hasattr(self.eng.bio, "mito") and hasattr(self.eng.bio.mito, "state"):
-                mito_traits = self.eng.bio.mito.state.__dict__
-            if hasattr(self.eng.bio, "immune"):
-                antibodies = list(self.eng.bio.immune.active_antibodies)
-            return self.eng.mind.mem.save(
-                health=self.eng.health,
-                stamina=self.eng.stamina,
-                mutations={},
-                trauma_accum=getattr(self.eng, "trauma_accum", {}),
-                joy_history=[],
-                mitochondria_traits=mito_traits,
-                antibodies=antibodies,
-                soul_data=(
-                    self.eng.soul.to_dict() if hasattr(self.eng, "soul") else None
-                ),
-                continuity=continuity_packet,
-                world_atlas=atlas_data,
-                village_data=None,
-            )
-        return "Error: Memory system unreachable."
-
-    def get_vitals(self) -> Dict[str, float]:
-        metrics = self.eng.get_metrics()
-        return {
-            "health": metrics.get("health", 0.0),
-            "stamina": metrics.get("stamina", 0.0),
-            "atp": metrics.get("atp", 0.0),
-            "max_health": getattr(self.Config, "MAX_HEALTH", 100.0),
-            "max_stamina": getattr(self.Config, "MAX_STAMINA", 100.0),
-        }
-
-    def get_inventory(self) -> List[str]:
-        if hasattr(self.eng, "gordon"):
-            return getattr(self.eng.gordon, "inventory", [])
-        return []
-
-    def get_navigation_report(self) -> str:
-        if not hasattr(self.eng, "navigator") or not hasattr(self.eng, "phys"):
-            return "Navigation Offline."
-        nav = self.eng.navigator
-        packet = None
-        if hasattr(self.eng.phys, "observer"):
-            packet = getattr(self.eng.phys.observer, "last_physics_packet", None)
-
-        if nav and packet:
-            return nav.report_position(packet)
-        return "Navigation Systems Unresponsive."
-
-    def get_soul_status(self) -> Optional[str]:
-        soul = getattr(self.eng, "soul", None)
-        if soul:
-            return soul.get_soul_state()
-        return None
-
-
-class ResourceTax:
-    def __init__(self, state: CommandStateInterface):
-        self.state = state
-
-    def levy(self, _context: str, costs: Dict[str, float]) -> bool:
-        stamina_cost = costs.get("stamina", 0.0)
-        atp_cost = costs.get("atp", 0.0)
-        if self.state.get_resource("stamina") < stamina_cost:
-            self.state.log(
-                f"{self.state.P.RED}🛑 EXHAUSTED: Requires {stamina_cost} Stamina.{self.state.P.RST}"
-            )
-            return False
-        if self.state.get_resource("atp") < atp_cost:
-            self.state.log(
-                f"{self.state.P.RED}🛑 STARVING: Requires {atp_cost} ATP.{self.state.P.RST}"
-            )
-            return False
-        if stamina_cost > 0:
-            self.state.modify_resource("stamina", -stamina_cost)
-        if atp_cost > 0:
-            self.state.modify_resource("atp", -atp_cost)
-        return True
-
-
-class CommandRegistry:
-    def __init__(self, state: CommandStateInterface):
-        self.state = state
-        self.commands: Dict[str, Callable] = {}
-        self.help_text: Dict[str, str] = {}
-
-    def register(self, name: str, func: Callable, help_str: str):
-        self.commands[name] = func
-        self.help_text[name] = help_str
-
-    def execute(self, text: str) -> bool:
-        if not text.startswith("/"):
-            return False
-        try:
-            parts = shlex.split(text)
-        except ValueError:
-            self.state.log("Syntax Error.", "CMD")
-            return True
-        cmd = parts[0].lower()
-        if cmd in self.commands:
-            return self.commands[cmd](parts)
-        else:
-            self.state.log(f"Unknown command '{cmd}'. Try /help.", "CMD")
-            return True
-
-
-class CommandProcessor:
-    def __init__(
-        self,
-        engine,
-        prisma_ref,
-        _lexicon_ref=None,
-        config_ref=None,
-        _cartographer_ref=None,
-    ):
-        real_config = config_ref if config_ref else BoneConfig
-        self.interface = CommandStateInterface(engine, prisma_ref, real_config)
-        self.tax = ResourceTax(self.interface)
-        self.registry = CommandRegistry(self.interface)
-        self.P = prisma_ref
-        self.registry.register("/help", self._cmd_help, "Show this menu")
-        self.registry.register("/status", self._cmd_status, "Check vitals")
-        self.registry.register("/save", self._cmd_save, "Persist state")
-        self.registry.register("/inventory", self._cmd_inventory, "Check pockets")
-        self.registry.register("/map", self._cmd_map, "Navigation check")
-        self.registry.register("/mode", self._cmd_mode, "Switch operational mode")
-        self.registry.register("/debug", self._cmd_debug, "Toggle verbose logs")
-        self.registry.register("/exit", self._cmd_exit, "Shutdown")
-        self.registry.register("/soul", self._cmd_soul, "Introspection")
-        self.registry.register("/look", self._cmd_look, "Observe environment")
-        self.registry.register("/reload", self._cmd_reload, "Hot-reload Lore")
-        self.registry.register(
-            "/truth", self._cmd_truth, "Adjust Reality Ambiguity [0-3]"
-        )
-        self.registry.register(
-            "/soothe", self._cmd_soothe, "Burn ATP to quell memory guilt"
-        )
-        self.registry.register("/use", self._cmd_use, "Use/Consume an item")
-
-    def execute(self, text: str):
-        if hasattr(self.interface.eng, "reality_stack"):
-            stack = self.interface.eng.reality_stack
-            rules = stack.get_grammar_rules()
-            if not rules.get("allow_commands", True):
-                self.interface.log(
-                    f"{self.P.RED}COMMAND REJECTED: Reality Depth {stack.current_depth} prohibits administrative override.{self.P.RST}",
-                    "ERR",
-                )
-                return True
-        return self.registry.execute(text)
-
-    def _cmd_soothe(self, _parts):
-        cost = 25.0
-        current_stamina = self.interface.get_resource("stamina")
-        if current_stamina < cost:
-            self.interface.log(
-                f"{self.P.RED}Too weak to mourn. (Req: {cost} Stamina){self.P.RST}"
-            )
-            return True
-        if (
-            not hasattr(self.interface.eng, "mind")
-            or not hasattr(self.interface.eng.mind, "mem")
-            or not hasattr(self.interface.eng.mind.mem, "soothe_conscience")
-        ):
-            self.interface.log(
-                f"{self.P.YEL}The subconscious is not installed.{self.P.RST}"
-            )
-            return True
-        self.interface.modify_resource("stamina", -cost)
-        result_msg = self.interface.eng.mind.mem.soothe_conscience()
-        self.interface.log(
-            f"{self.P.OCHRE}🏺 {result_msg} (-{cost} Stamina){self.P.RST}"
-        )
-        return True
-
-    def _cmd_help(self, _parts):
-        lines = [
-            f"\n{self.P.CYN}/// BONEAMANITA 15.8.0 TERMINAL ///{self.P.RST}",
-            f"{self.P.GRY}Operating Phase: {self.interface.get_soul_status() or 'EXTANT'}{self.P.RST}\n",
-        ]
-        structure = {
-            "SURVIVAL": ["/status", "/inventory", "/look"],
-            "PROTOCOL": ["/save", "/mode", "/exit", "/help"],
-            "MYSTICISM": ["/soul", "/map", "/truth"],
-            "MAINTENANCE": ["/debug", "/reload"],
-        }
-        buckets = {k: [] for k in structure.keys()}
-        buckets["UNCATEGORIZED"] = []
-        cmd_to_cat = {cmd: cat for cat, cmds in structure.items() for cmd in cmds}
-        for cmd, desc in self.registry.help_text.items():
-            cat = cmd_to_cat.get(cmd, "UNCATEGORIZED")
-            buckets[cat].append((cmd, desc))
-        for cat, cmds in buckets.items():
-            if not cmds:
-                continue
-            lines.append(f"{self.P.WHT}[{cat}]{self.P.RST}")
-            for cmd, desc in cmds:
-                lines.append(f"  {self.P.CYN}{cmd:<12}{self.P.RST} {desc}")
-            lines.append("")
-        lines.append(f"{self.P.GRY}>> Use wisely. Entropy is watching.{self.P.RST}")
-        self.interface.log("\n".join(lines))
-        return True
-
-    def _cmd_status(self, _parts):
-        v = self.interface.get_vitals()
-
-        def bar(curr, max_v, col):
-            max_v = max(1.0, max_v)
-            filled = int(max(0.0, min(1.0, curr / max_v)) * 10)
-            return f"{col}{'█'*filled}{'░'*(10-filled)}{self.P.RST}"
-
-        self.interface.log(
-            f"Health:  {bar(v['health'], v['max_health'], self.P.RED)} {v['health']:.0f}\n"
-            f"Stamina: {bar(v['stamina'], v['max_stamina'], self.P.GRN)} {v['stamina']:.0f}\n"
-            f"Energy:  {bar(v['atp'], 200, self.P.YEL)} {v['atp']:.0f}"
-        )
-        return True
-
-    def _cmd_mode(self, parts):
-        if len(parts) < 2:
-            self.interface.log("Usage: /mode [ZEN_GARDEN | THUNDERDOME | SANCTUARY]")
-            return True
-        mode_name = parts[1].upper()
-        if not hasattr(BonePresets, mode_name):
-            self.interface.log(f"{self.P.RED}Unknown mode: {mode_name}.{self.P.RST}")
-            return True
-        if self.tax.levy("MODE_SWITCH", {"stamina": 10.0}):
-            preset = getattr(BonePresets, mode_name)
-            logs = self.interface.Config.load_preset(preset)
-            for log in logs:
-                self.interface.log(log)
-            phys_packet = None
-            if hasattr(self.interface.eng, "phys") and hasattr(
-                self.interface.eng.phys, "tension"
-            ):
-                phys_packet = getattr(
-                    self.interface.eng.phys.tension, "last_physics_packet", None
-                )
-            if phys_packet:
-                self.interface.Config.reconcile_state(phys_packet)
-                self.interface.log(
-                    f"{self.P.CYN}State reconciled to {mode_name} parameters.{self.P.RST}"
-                )
-            self.interface.log(f"Switched to {mode_name}.")
-        return True
-
-    def _cmd_save(self, _parts):
-        res = self.interface.save_state()
-        if "Error" in res or "Failed" in res:
-            self.interface.log(f"{self.P.RED}SAVE FAILED: {res}{self.P.RST}")
-        else:
-            self.interface.log(f"{self.P.GRN}SAVED: {res}{self.P.RST}")
-        return True
-
-    def _cmd_inventory(self, _parts):
-        items = self.interface.get_inventory()
-        P = self.interface.P
-        self.interface.log(f"{P.WHT}/// GORDON KNOT STORAGE ///{P.RST}")
-        if not items:
-            self.interface.log(f"{P.GRY}   [POCKETS EMPTY]{P.RST}")
-            return
-        for i, item in enumerate(items):
-            self.interface.log(f" {P.GRY}{i + 1}.{P.RST} {P.CYN}{item.upper()}{P.RST}")
-        self.interface.log(
-            f"{P.GRY}   ({len(items)}/{self.interface.Config.INVENTORY.MAX_SLOTS} Slots){P.RST}"
-        )
-
-    def _cmd_map(self, _parts):
-        if not self.tax.levy("MAP", {"stamina": 2.0}):
-            return True
-        nav_report = self.interface.get_navigation_report()
-        self.interface.log(nav_report)
-        return True
-
-    def _cmd_debug(self, _parts):
-        self.interface.Config.VERBOSE_LOGGING = (
-            not self.interface.Config.VERBOSE_LOGGING
-        )
-        self.interface.log(f"Debug Mode: {self.interface.Config.VERBOSE_LOGGING}")
-        return True
-
-    def _cmd_exit(self, _parts):
-        import sys
-
-        self.interface.log(f"{Prisma.RED}System Halt Initiated.{Prisma.RST}", "SYS")
-        if "streamlit" in sys.modules:
-            try:
-                import streamlit as st
-
-                st.stop()
-            except Exception:
-                pass
-        raise KeyboardInterrupt
-
-    def _cmd_soul(self, _parts):
-        soul_msg = self.interface.get_soul_status()
-        if soul_msg:
-            self.interface.log(f"{self.P.MAG}{soul_msg}{self.P.RST}")
-        return True
-
-    def _cmd_look(self, _parts):
-        result = self.interface.trigger_visual_cortex()
-        if result and result.get("ui"):
-            self.interface.log(result["ui"])
-        else:
-            self.interface.log("Blindness. The engine cannot see.")
-        return True
-
-    def _cmd_reload(self, parts):
-        if len(parts) > 1:
-            target = parts[1].upper()
-            LoreManifest.get_instance().flush_cache(target)
-            self.interface.log(f"Reloaded {target}.")
-        else:
-            LoreManifest.get_instance().flush_cache()
-            self.interface.log("Reloaded all Lore.")
-        return True
-
-    def _cmd_truth(self, parts):
-        if len(parts) < 2:
-            self.interface.log(
-                "Usage: /truth [0=Boardroom, 1=Workshop, 2=RedTeam, 3=Palimpsest]"
-            )
-            return True
-        from bone_gui import TruthRenderer
-
-        try:
-            mode = int(parts[1])
-            if not (0 <= mode <= 3):
-                raise ValueError
-            controller = getattr(self.interface.eng, "cycle_controller", None)
-            if not controller:
-                self.interface.log("Error: CycleController not found.")
-                return True
-            reporter = getattr(controller, "reporter", None)
-            if not reporter:
-                self.interface.log("Error: CycleReporter not found.")
-                return True
-            if not hasattr(reporter.renderer, "dial_setting"):
-                self.interface.log(
-                    f"{self.P.YEL}[SYS] Transplanting TruthRenderer into active cycle...{self.P.RST}"
-                )
-                new_renderer = TruthRenderer(self.interface.eng)
-                reporter.renderer = new_renderer
-                reporter.renderers["STANDARD"] = new_renderer
-            reporter.renderer.dial_setting = mode
-            modes = ["BOARDROOM", "WORKSHOP", "RED TEAM", "PALIMPSEST"]
-            self.interface.log(
-                f"{self.P.CYN}Ambiguity Dial set to: {modes[mode]}{self.P.RST}"
-            )
-        except ValueError:
-            self.interface.log("Invalid mode. Use 0-3.")
-        except Exception as e:
-            self.interface.log(f"Truth Dial Failure: {e}")
-        return True
-
-    def _cmd_use(self, parts):
-        if len(parts) < 2:
-            self.interface.log("Usage: /use [ITEM_NAME]")
-            return True
-        item_name = parts[1].upper()
-        gordon = getattr(self.interface.eng, "gordon", None)
-        if not gordon:
-            self.interface.log(f"{self.P.RED}Inventory system offline.{self.P.RST}")
-            return True
-        success, msg = gordon.consume(item_name)
-        color = self.P.GRN if success else self.P.OCHRE
-        self.interface.log(f"{color}{msg}{self.P.RST}")
-        return True