Delete bone_inventory.py

bone_inventory.py

@@ -1,391 +0,0 @@
-import random, re
-from dataclasses import dataclass, field
-from typing import List, Dict, Tuple, Optional
-from bone_core import LoreManifest
-from bone_types import Prisma
-from bone_config import BoneConfig
-
-
-@dataclass
-class Item:
-    name: str
-    description: str
-    function: str
-    passive_traits: List[str] = field(default_factory=list)
-    spawn_context: str = "COMMON"
-    value: float = 1.0
-    usage_msg: str = "Used."
-    consume_on_use: bool = False
-    reflex_trigger: Optional[str] = None
-
-    @classmethod
-    def from_dict(cls, name: str, data: Dict):
-        return cls(
-            name=name,
-            description=data.get("description", "Unknown Artifact"),
-            function=data.get("function", "MISC"),
-            passive_traits=data.get("passive_traits", []),
-            spawn_context=data.get("spawn_context", "COMMON"),
-            value=data.get("value", 1.0),
-            usage_msg=data.get("usage_msg", f"You use the {name}."),
-            consume_on_use=data.get("consume_on_use", False),
-            reflex_trigger=data.get("reflex_trigger", None),
-        )
-
-
-class GordonKnot:
-    def __init__(self, events=None, mode="ADVENTURE"):
-        self.mode = mode.upper()
-        self.blueprints = None
-        self.events = events
-        self.inventory: List[str] = []
-        self.registry: Dict[str, Item] = {}
-        self.ITEM_REGISTRY: Dict[str, Dict] = {}
-        self.recipes: List[Dict] = []
-        self.action_coupling: Dict[str, List[str]] = {}
-        self.location_coupling: Dict[str, str] = {}
-        self.max_slots = 10
-        self.last_flinch_turn = -100
-        self.scar_tissue = {}
-        self.refusal_markers = {
-            "cannot", "can't", "unable", "fail", "too heavy",
-            "stuck", "don't", "do not", "locked", "refuse", "impossible",
-        }
-        self.loot_triggers = [
-            "found a", "picked up", "pick up", "acquired",
-            "took the", "take the", "grab the", "takes the",
-        ]
-        self.load_config()
-
-    def enforce_object_action_coupling(
-        self, user_input: str, current_zone: str
-    ) -> Optional[str]:
-        if self.mode in ["CREATIVE", "CONVERSATION", "TECHNICAL"]:
-            return None
-        text = user_input.lower()
-        for action_obj_pair, required_loc in self.location_coupling.items():
-            words = action_obj_pair.split()
-            if all(re.search(rf'\b{w}\b', text) for w in words):
-                if required_loc not in current_zone.lower():
-                    return (
-                        f"{Prisma.SLATE}🏢 GORDON [PREMISE VIOLATION]: The action requires the object "
-                        f"to be at the location '{required_loc}'. You are currently at '{current_zone}'. "
-                        f"You must bring the object to the location. Action denied.{Prisma.RST}"
-                    )
-
-        inventory_items = " ".join([i.get("name", "").lower() for i in self.get_inventory_data()])
-        for action, required_objects in self.action_coupling.items():
-
-            verb_pattern = rf"\b(?:i\s+(?:will\s+)?{action}|to\s+{action}|{action}\s+(?:the|a|an|my|some|it|this|that)|{action}ing)\b|^{action}\b"
-
-            if re.search(verb_pattern, text):
-                has_item = any(obj in inventory_items for obj in required_objects)
-                mentions_item = any(obj in text for obj in required_objects)
-                if not has_item and not mentions_item:
-                    req_str = ", ".join(required_objects)
-                    return (
-                        f"{Prisma.SLATE}🏢 GORDON [PREMISE VIOLATION]: The action '{action}' requires an object "
-                        f"of type [{req_str}]. The object is neither in your inventory nor the immediate environment. "
-                        f"Coupling failed. Action denied.{Prisma.RST}"
-                    )
-
-        interaction_verbs = ["use", "drop", "throw", "consume", "eat", "drink", "read", "activate", "give", "equip"]
-        has_interaction = any(re.search(rf'\b{v}\b', text) for v in interaction_verbs)
-
-        if has_interaction:
-            all_known = set(self.registry.keys()) | set(self.ITEM_REGISTRY.keys())
-            for item_name in all_known:
-                item_lower = item_name.lower().replace("_", " ")
-                if item_lower in text and item_name.upper() not in self.inventory:
-                    return (
-                        f"{Prisma.SLATE}🏢 GORDON [PREMISE VIOLATION]: You are attempting to interact with "
-                        f"[{item_lower}], but it is not in your inventory. Action denied.{Prisma.RST}"
-                    )
-
-        return None
-
-    def load_config(self):
-        data = LoreManifest.get_instance().get("GORDON") or {}
-        if not data and hasattr(LoreManifest, "get_raw"):
-            data = LoreManifest.get_raw("gordon.json") or {}
-        self.action_coupling = data.get("ACTION_COUPLING", {})
-        self.location_coupling = data.get("LOCATION_COUPLING", {})
-        if "REFUSAL_MARKERS" in data:
-            self.refusal_markers = set(data["REFUSAL_MARKERS"])
-        if self.mode in ["CREATIVE", "CONVERSATION"]:
-            self.loot_triggers = [
-                "grasped the concept of",
-                "held onto",
-                "felt a",
-                "internalized the",
-                "embraced the",
-                "clung to the",
-                "remembered the",
-            ]
-        elif "LOOT_TRIGGERS" in data:
-            self.loot_triggers = data["LOOT_TRIGGERS"]
-        self.blueprints = LoreManifest.get_instance().get("ITEM_GENERATION") or {}
-        self.ITEM_REGISTRY = data.get("ITEM_REGISTRY", {})
-        for name, props in self.ITEM_REGISTRY.items():
-            self.registry[name] = Item.from_dict(name, props)
-        self.recipes = data.get("RECIPES", [])
-        self.scar_tissue = data.get("SCAR_TISSUE", {})
-        starters = data.get("STARTING_INVENTORY", [])
-        if not self.inventory and starters:
-            self.inventory = [s for s in starters if isinstance(s, str)]
-        if hasattr(BoneConfig, "INVENTORY"):
-            self.max_slots = getattr(BoneConfig.INVENTORY, "MAX_SLOTS", 10)
-
-    def process_loot_tags(self, text: str, user_input: str) -> Tuple[str, List[str]]:
-        loot_pattern = r"\[\[LOOT:\s*(.*?)\]\]"
-        lost_pattern = r"\[\[LOST:\s*(.*?)\]\]"
-        raw_loot = re.findall(loot_pattern, text, re.IGNORECASE)
-        raw_lost = re.findall(lost_pattern, text, re.IGNORECASE)
-
-        def normalize(items):
-            return list({re.sub(r"[^A-Z0-9_]", "", i.strip().upper().replace(" ", "_")) for i in items if i})
-        new_loot = normalize(raw_loot)
-        lost_loot = normalize(raw_lost)
-        logs = []
-        if new_loot:
-            acquisition_verbs = [
-                "take",
-                "grab",
-                "pick",
-                "get",
-                "steal",
-                "seize",
-                "collect",
-                "snatch",
-                "acquire",
-                "pocket",
-                "loot",
-                "harvest",
-            ]
-            clean_input = user_input.lower()
-            has_intent = any(verb in clean_input for verb in acquisition_verbs)
-            if has_intent:
-                for item in new_loot:
-                    logs.append(self.acquire(item))
-                    if self.events:
-                        self.events.publish("ITEM_ACQUIRED", {"item": item})
-            else:
-                if self.events:
-                    for item in new_loot:
-                        self.events.log(
-                            f"CONSENT: Intercepted auto-loot for '{item}'. User did not ask.",
-                            "GORDON",
-                        )
-        for item in lost_loot:
-            if self.safe_remove_item(item):
-                logs.append(f"{Prisma.GRY}ENTROPY: {item} consumed/lost.{Prisma.RST}")
-            else:
-                logs.append(
-                    f"{Prisma.OCHRE}GLITCH: Tried to lose {item}, but you didn't have it.{Prisma.RST}"
-                )
-        clean_text = re.sub(loot_pattern, "", text, flags=re.IGNORECASE)
-        clean_text = re.sub(lost_pattern, "", clean_text, flags=re.IGNORECASE)
-        return clean_text.strip(), logs
-
-    def get_item_data(self, item_name: str) -> Optional[Item]:
-        if item_name in self.registry:
-            return self.registry[item_name]
-        if item_name in self.ITEM_REGISTRY:
-            raw_data = self.ITEM_REGISTRY[item_name]
-            item_obj = Item.from_dict(item_name, raw_data)
-            self.registry[item_name] = item_obj
-            return item_obj
-        return None
-
-    def get_inventory_data(self) -> List[Dict]:
-        return [item.__dict__ for name in self.inventory if (item := self.get_item_data(name))]
-
-    def acquire(self, tool_name: str) -> str:
-        tool_name = tool_name.upper() if tool_name else "UNKNOWN"
-        if tool_name in self.inventory:
-            return f"{Prisma.OCHRE}Inventory duplicate: You already have the {tool_name}.{Prisma.RST}"
-        item_obj = self.get_item_data(tool_name)
-        if not item_obj:
-            item_obj = self.get_item_data(tool_name.lower())
-        if not item_obj:
-            new_item = Item(name=tool_name, description="???", function="MISC")
-            self.registry[tool_name] = new_item
-            self.ITEM_REGISTRY[tool_name] = new_item.__dict__
-        if len(self.inventory) >= self.max_slots:
-            dropped = self.inventory.pop(0)
-            if self.events:
-                self.events.log(f"Inventory full. Dropped {dropped}.", "INV")
-        self.inventory.append(tool_name)
-        if self.events:
-            self.events.publish("ITEM_ACQUIRED", {"item": tool_name})
-        return f"{Prisma.GRN}📦 ACQUIRED: {tool_name}{Prisma.RST}"
-
-    def safe_remove_item(self, item_name: str) -> bool:
-        item_name = item_name.upper()
-        if item_name in self.inventory:
-            self.inventory.remove(item_name)
-            return True
-        return False
-
-    def rummage(
-        self, physics_ref: Dict, stamina_pool: float
-    ) -> Tuple[bool, str, float]:
-        cost = 15.0
-        if hasattr(BoneConfig, "INVENTORY"):
-            cost = getattr(BoneConfig.INVENTORY, "RUMMAGE_COST", 15.0)
-        if stamina_pool < cost:
-            return (
-                False,
-                f"{Prisma.OCHRE}Gordon sighs. 'Too tired. Eat first.'{Prisma.RST}",
-                0.0,
-            )
-        loot_table = self._get_loot_candidates(physics_ref)
-        if not loot_table:
-            return False, "Gordon dug deep but found only lint.", cost
-        found_item = random.choice(loot_table)
-        msg = self.acquire(found_item)
-        return True, msg, cost
-
-    def _get_loot_candidates(self, physics: Dict) -> List[str]:
-        candidates = []
-        voltage = physics.get("voltage", 0.0)
-        drag = physics.get("narrative_drag", 0.0)
-        psi = physics.get("psi", 0.0)
-        for name in set(self.registry) | set(self.ITEM_REGISTRY):
-            if not (item := self.get_item_data(name)):
-                continue
-            ctx = item.spawn_context
-            if ctx in ("COMMON", "STANDARD") or \
-                    (ctx == "VOLTAGE_HIGH" and voltage > 12.0) or \
-                    (ctx == "VOLTAGE_CRITICAL" and voltage > 18.0) or \
-                    (ctx == "DRAG_HEAVY" and drag > 4.0) or \
-                    (ctx == "PSI_HIGH" and psi > 0.6):
-                candidates.append(name)
-        return candidates
-
-    def register_dynamic_item(self, name: str, data: Dict):
-        name = name.upper()
-        if name not in self.registry:
-            new_item = Item.from_dict(name, data)
-            self.registry[name] = new_item
-            if self.events:
-                self.events.log(
-                    f"{Prisma.CYN}🎒 GORDON: 'I'll make space for {name}.'{Prisma.RST}",
-                    "INV",
-                )
-
-    def synthesize_item(self, physics_vector: Dict[str, float]) -> str:
-        if not hasattr(self, "blueprints") or not self.blueprints:
-            self.blueprints = LoreManifest.get_instance().get("ITEM_GENERATION") or {}
-
-        dim_map = {
-            "STR": "heavy", "VEL": "kinetic", "PHI": "thermal", 
-            "PSI": "abstract", "ENT": "void", "BET": "constructive"
-        }
-        dom_dim = max(physics_vector, key=physics_vector.get) if physics_vector else "ENT"
-        archetype = dim_map.get(dom_dim, "void")
-        prefixes = self.blueprints.get("PREFIXES", {}).get(archetype, ["Strange"])
-        suffixes = self.blueprints.get("SUFFIXES", {}).get(archetype, ["of Mystery"])
-        if self.mode in ["CREATIVE", "CONVERSATION"]:
-            base_cat = "ABSTRACT"
-            bases = self.blueprints.get("BASES", {}).get(
-                base_cat, ["Feeling", "Sense", "Memory", "Idea", "Echo"]
-            )
-            prefixes = ["A Lingering", "A Sudden", "A Distant", "A Sharp", "A Quiet"]
-            suffixes = ["of Dread", "of Hope", "of Clarity", "of Chaos", "of Stillness"]
-        else:
-            base_cat = random.choice(["TOOL", "JUNK", "ARTIFACT"])
-            bases = self.blueprints.get("BASES", {}).get(base_cat, ["Object"])
-        prefix = random.choice(prefixes)
-        base = random.choice(bases)
-        suffix = random.choice(suffixes)
-        full_name = (
-            f"{prefix} {base} {suffix}"
-            if self.mode == "ADVENTURE"
-            else f"{prefix} {base} {suffix}"
-        )
-        clean_id = full_name.upper().replace(" ", "_")
-        item_data = {
-            "description": f"A {base.lower()} manifesting {archetype} properties.",
-            "function": "ARTIFACT",
-            "passive_traits": ["DYNAMIC"],
-            "value": round(physics_vector.get(dom_dim, 0.0) * 10, 1),
-            "spawn_context": "FORGED"
-        }
-        self.register_dynamic_item(clean_id, item_data)
-        return clean_id
-
-    def parse_loot(self, user_text: str, sys_text: str) -> Optional[str]:
-        text = (user_text + " " + sys_text).lower()
-        sys_lower = sys_text.lower()
-
-        for refusal in self.refusal_markers:
-            if refusal in sys_lower:
-                return None
-
-        all_known_items = set(self.registry.keys()) | set(self.ITEM_REGISTRY.keys())
-        for name in all_known_items:
-            if name.lower() in text and name.upper() not in self.inventory:
-                for t in self.loot_triggers:
-                    if t in text:
-                        return name
-
-        sorted_triggers = sorted(self.loot_triggers, key=len, reverse=True)
-        for t in sorted_triggers:
-            if t in text:
-                pattern = f"{re.escape(t)}\\s+(?:the\\s+|a\\s+|an\\s+)?(?P<item>[\\w\\s]{{1,30}}?)(?:\\s+(?:from|on|in|under|with|by|near|at|to|you|it|he|she|we|they)|[\\.,!?]|$)"
-                match = re.search(pattern, text, re.IGNORECASE)
-
-                if match:
-                    candidate = match.group("item").strip()
-                    if (
-                        2 < len(candidate) < 40
-                        and candidate not in self.refusal_markers
-                    ):
-                        return candidate
-
-        return None
-
-    def consume(self, item_name: str) -> Tuple[bool, str]:
-        item_name = item_name.upper()
-        if item_name not in self.inventory:
-            return False, "You don't have that."
-        item = self.get_item_data(item_name)
-        if not item or not item.consume_on_use:
-            return False, f"The {item_name} cannot be consumed."
-        self.inventory.remove(item_name)
-        if item.function == "STABILITY":
-            return True, f"🍕 {item_name}: Entropy paused. Satisfaction nominal."
-        return True, f"Consumed {item_name}. {item.usage_msg}"
-
-    def emergency_reflex(self, physics_ref: Dict) -> Tuple[bool, Optional[str]]:
-        voltage = physics_ref.get("voltage", 0.0)
-        drag = physics_ref.get("narrative_drag", 0.0)
-        for name in self.inventory:
-            item = self.get_item_data(name)
-            if not item:
-                continue
-            trigger = item.reflex_trigger
-            if trigger == "VOLTAGE_CRITICAL" and voltage > 18.0:
-                self.safe_remove_item(name)
-                physics_ref["voltage"] = 12.0
-                return (
-                    True,
-                    f"{Prisma.CYN}🛡️ REFLEX: {name} sacrificed to absorb voltage spike! (Voltage -> 12.0v){Prisma.RST}",
-                )
-            if trigger == "DRIFT_CRITICAL" and drag > 6.0:
-                self.safe_remove_item(name)
-                physics_ref["narrative_drag"] = 0.0
-                return (
-                    True,
-                    f"{Prisma.OCHRE}⚓ REFLEX: {name} deployed. Drag zeroed out.{Prisma.RST}"
-                )
-            kappa = physics_ref.get("kappa", 0.5)
-            if trigger == "KAPPA_CRITICAL" and kappa < 0.2:
-                self.safe_remove_item(name)
-                physics_ref["kappa"] = 0.8
-                return (
-                    True,
-                    f"{Prisma.GRN}🍕 REFLEX: {name} consumed. Structure restored.{Prisma.RST}"
-                )
-        return False, None