ghocentric-ghost-engine 0.1.1__tar.gz

ghocentric_ghost_engine-0.1.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: ghocentric-ghost-engine
+Version: 0.1.1
+Summary: Ghost cognitive engine
+Author: Shane Heckathorn
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ghocentric-ghost-engine
+
+A lightweight internal state reasoning engine (proof-of-architecture).
+
+This package contains the core Ghost Engine, designed to experiment with
+stateful reasoning, internal memory, symbolic processing, and emergent behavior.
+It is intentionally minimal and focused on architecture rather than polish.
+
+INSTALLATION
+
+pip install ghocentric-ghost-engine
+
+BASIC USAGE
+
+from ghost import engine
+
+Note: This is an early-stage engine. APIs may change as the architecture evolves.
+
+PROJECT STRUCTURE
+
+ghost/        core engine modules  
+tests/        internal test cases  
+npc_demo.py   simple demonstration script  
+pyproject.toml build and packaging configuration  
+
+STATUS
+
+This project is currently in v0.1.x and should be considered a
+proof-of-concept. Stability is not yet guaranteed.
+
+LICENSE
+
+MIT License

ghocentric_ghost_engine-0.1.1/README.md

@@ -0,0 +1,33 @@
+# ghocentric-ghost-engine
+
+A lightweight internal state reasoning engine (proof-of-architecture).
+
+This package contains the core Ghost Engine, designed to experiment with
+stateful reasoning, internal memory, symbolic processing, and emergent behavior.
+It is intentionally minimal and focused on architecture rather than polish.
+
+INSTALLATION
+
+pip install ghocentric-ghost-engine
+
+BASIC USAGE
+
+from ghost import engine
+
+Note: This is an early-stage engine. APIs may change as the architecture evolves.
+
+PROJECT STRUCTURE
+
+ghost/        core engine modules  
+tests/        internal test cases  
+npc_demo.py   simple demonstration script  
+pyproject.toml build and packaging configuration  
+
+STATUS
+
+This project is currently in v0.1.x and should be considered a
+proof-of-concept. Stability is not yet guaranteed.
+
+LICENSE
+
+MIT License

ghocentric_ghost_engine-0.1.1/ghocentric_ghost_engine.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: ghocentric-ghost-engine
+Version: 0.1.1
+Summary: Ghost cognitive engine
+Author: Shane Heckathorn
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ghocentric-ghost-engine
+
+A lightweight internal state reasoning engine (proof-of-architecture).
+
+This package contains the core Ghost Engine, designed to experiment with
+stateful reasoning, internal memory, symbolic processing, and emergent behavior.
+It is intentionally minimal and focused on architecture rather than polish.
+
+INSTALLATION
+
+pip install ghocentric-ghost-engine
+
+BASIC USAGE
+
+from ghost import engine
+
+Note: This is an early-stage engine. APIs may change as the architecture evolves.
+
+PROJECT STRUCTURE
+
+ghost/        core engine modules  
+tests/        internal test cases  
+npc_demo.py   simple demonstration script  
+pyproject.toml build and packaging configuration  
+
+STATUS
+
+This project is currently in v0.1.x and should be considered a
+proof-of-concept. Stability is not yet guaranteed.
+
+LICENSE
+
+MIT License

ghocentric_ghost_engine-0.1.1/ghocentric_ghost_engine.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+ghocentric_ghost_engine.egg-info/PKG-INFO
+ghocentric_ghost_engine.egg-info/SOURCES.txt
+ghocentric_ghost_engine.egg-info/dependency_links.txt
+ghocentric_ghost_engine.egg-info/top_level.txt
+ghost/__init__.py
+ghost/engine.py
+tests/test_environment_isolation.py
+tests/test_explicit_run_control.py
+tests/test_external_input.py
+tests/test_npc_actor_memory.py
+tests/test_npc_emotional_modulation.py
+tests/test_npc_intent_decay.py
+tests/test_npc_intent_processing.py
+tests/test_public_api.py

ghocentric_ghost_engine-0.1.1/ghocentric_ghost_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ghocentric_ghost_engine-0.1.1/ghocentric_ghost_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+ghost

ghocentric_ghost_engine-0.1.1/ghost/__init__.py

@@ -0,0 +1,43 @@
+"""
+Ghost public API (pip-facing).
+This file defines the ONLY supported entry points.
+"""
+
+from .engine import GhostEngine
+
+_ENGINE = None
+
+
+def init():
+    """Initialize a new Ghost engine."""
+    global _ENGINE
+    _ENGINE = GhostEngine()
+    return _ENGINE
+
+
+def step(input_data=None):
+    """Advance the engine by one cycle."""
+    if _ENGINE is None:
+        raise RuntimeError("Ghost not initialized. Call ghost.init() first.")
+    return _ENGINE.step(input_data)
+
+
+def state():
+    """Return a mutable view of the current state."""
+    if _ENGINE is None:
+        raise RuntimeError("Ghost not initialized. Call ghost.init() first.")
+    return _ENGINE.state()
+
+
+def snapshot():
+    """Return an immutable snapshot of the current state."""
+    if _ENGINE is None:
+        raise RuntimeError("Ghost not initialized. Call ghost.init() first.")
+    return _ENGINE.snapshot()
+
+
+def reset():
+    """Reset the engine."""
+    global _ENGINE
+    _ENGINE = GhostEngine()
+    return _ENGINE

ghocentric_ghost_engine-0.1.1/ghost/engine.py

@@ -0,0 +1,77 @@
+class GhostEngine:
+    def __init__(self, context: dict | None = None):
+        """
+        Core Ghost engine.
+        Monolithic, self-contained v0.1 implementation.
+        """
+
+        # Initialize context if not provided
+        if context is None:
+            context = {}
+
+        self._ctx = context
+
+        # Required baseline state
+        self._ctx.setdefault("cycles", 0)
+        self._ctx.setdefault("input", None)
+        self._ctx.setdefault("last_step", None)
+
+    def step(self, input_data=None):
+        """
+        Advance the Ghost engine by one cycle.
+        """
+
+        ctx = self._ctx
+        ctx["cycles"] += 1
+
+        # Ensure npc bucket exists
+        npc = ctx.setdefault("npc", {})
+        npc.setdefault("threat_level", 0.0)
+        npc.setdefault("last_intent", None)
+        npc.setdefault("actors", {})
+
+        # --- PROCESS INPUT FIRST ---
+        received_threat = False
+
+        if input_data:
+            ctx["raw_input"] = input_data
+            ctx["input"] = input_data
+
+            if input_data.get("source") == "npc_engine":
+                intent = input_data.get("intent")
+                intensity = float(input_data.get("intensity", 0.0))
+                actor = input_data.get("actor", "unknown")
+
+                if intent == "threat":
+                    received_threat = True
+
+                    # Actor memory
+                    actor_bucket = npc["actors"].setdefault(
+                        actor,
+                        {"threat_count": 0}
+                    )
+                    actor_bucket["threat_count"] += 1
+
+                    # Mood modulation
+                    mood = ctx.get("state", {}).get("mood", 0.5)
+                    mood_multiplier = 0.5 + mood  # 0.5 → 1.5
+
+                    threat_gain = intensity * mood_multiplier
+                    npc["threat_level"] += threat_gain
+                    npc["last_intent"] = "threat"
+
+        # --- DECAY ONLY IF NO NEW THREAT ---
+        if not received_threat:
+            DECAY_RATE = 0.15
+            npc["threat_level"] = max(0.0, npc["threat_level"] - DECAY_RATE)
+
+        return ctx
+    
+    def state(self):
+        """Return the live engine state (mutable)."""
+        return self._ctx
+
+    def snapshot(self):
+        """Return an immutable snapshot of engine state."""
+        import copy
+        return copy.deepcopy(self._ctx)

ghocentric_ghost_engine-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ghocentric-ghost-engine"
+version = "0.1.1"
+description = "Ghost cognitive engine"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+  { name="Shane Heckathorn" }
+]
+
+dependencies = []
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ghost*"]

ghocentric_ghost_engine-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ghocentric_ghost_engine-0.1.1/tests/test_environment_isolation.py

@@ -0,0 +1,23 @@
+# tests/test_environment_isolation.py
+
+import os
+import sys
+import copy
+
+
+def test_no_environment_side_effects():
+    """
+    Importing and initializing Ghost must not mutate
+    global environment variables or sys.path.
+    """
+
+    env_before = dict(os.environ)
+    path_before = list(sys.path)
+
+    import ghost
+
+    # Explicit init is allowed, but must be clean
+    ghost.init()
+
+    assert dict(os.environ) == env_before
+    assert list(sys.path) == path_before

ghocentric_ghost_engine-0.1.1/tests/test_explicit_run_control.py

@@ -0,0 +1,24 @@
+import copy
+import time
+
+
+def test_no_implicit_execution():
+    """
+    Ghost must not mutate state unless explicitly stepped.
+    """
+
+    from ghost.engine import GhostEngine
+
+    engine = GhostEngine()
+
+    # Capture initial engine state
+    initial_state = engine.state()
+
+    # Wait to catch any background mutation
+    time.sleep(0.2)
+
+    # Capture state again without stepping
+    later_state = engine.state()
+
+    # State must be identical
+    assert later_state == initial_state

ghocentric_ghost_engine-0.1.1/tests/test_external_input.py

@@ -0,0 +1,23 @@
+def test_external_input_passthrough():
+    """
+    External input passed to step() must be recorded in state.
+    """
+
+    from ghost.engine import GhostEngine
+
+    engine = GhostEngine()
+
+    event = {
+        "source": "npc_engine",
+        "intent": "threat",
+        "actor": "player",
+        "intensity": 0.5,
+    }
+
+    engine.step(event)
+    state = engine.state()
+
+    assert "input" in state
+    assert state["input"] is not None
+    assert isinstance(state["input"], dict)
+    assert state["input"] == event

ghocentric_ghost_engine-0.1.1/tests/test_npc_actor_memory.py

@@ -0,0 +1,41 @@
+def test_actor_memory_tracks_threat_counts():
+    """
+    Ghost must track per-actor threat counts independently.
+    """
+
+    from ghost.engine import GhostEngine
+
+    engine = GhostEngine()
+
+    engine.step({
+        "source": "npc_engine",
+        "actor": "player",
+        "intent": "threat",
+        "intensity": 0.7,
+    })
+
+    engine.step({
+        "source": "npc_engine",
+        "actor": "player",
+        "intent": "threat",
+        "intensity": 0.4,
+    })
+
+    engine.step({
+        "source": "npc_engine",
+        "actor": "guard",
+        "intent": "threat",
+        "intensity": 0.9,
+    })
+
+    state = engine.state()
+
+    assert "npc" in state
+    assert "actors" in state["npc"]
+
+    # Per-actor memory exists
+    assert "player" in state["npc"]["actors"]
+    assert "guard" in state["npc"]["actors"]
+
+    assert state["npc"]["actors"]["player"]["threat_count"] == 2
+    assert state["npc"]["actors"]["guard"]["threat_count"] == 1

ghocentric_ghost_engine-0.1.1/tests/test_npc_emotional_modulation.py

@@ -0,0 +1,40 @@
+def test_emotional_modulation_affects_threat_gain():
+    """
+    Same threat input, different mood → different threat accumulation.
+    Higher mood (anxious) should amplify threat gain.
+    """
+
+    from ghost.engine import GhostEngine
+
+    # ---- Calm mood engine ----
+    calm_engine = GhostEngine()
+
+    # Inject calm mood into engine state
+    calm_state = calm_engine.state()
+    calm_state.setdefault("state", {})
+    calm_state["state"]["mood"] = 0.1  # calm / low arousal
+
+    calm_engine.step({
+        "source": "npc_engine",
+        "intent": "threat",
+        "intensity": 1.0,
+    })
+
+    calm_threat = calm_engine.state()["npc"]["threat_level"]
+
+    # ---- Anxious mood engine ----
+    anxious_engine = GhostEngine()
+
+    anxious_state = anxious_engine.state()
+    anxious_state.setdefault("state", {})
+    anxious_state["state"]["mood"] = 0.9  # anxious / high arousal
+
+    anxious_engine.step({
+        "source": "npc_engine",
+        "intent": "threat",
+        "intensity": 1.0,
+    })
+
+    anxious_threat = anxious_engine.state()["npc"]["threat_level"]
+
+    assert anxious_threat > calm_threat

ghocentric_ghost_engine-0.1.1/tests/test_npc_intent_decay.py

@@ -0,0 +1,36 @@
+def test_threat_decays_without_new_input():
+    """
+    Threat level should decay over time if no new threat input is received.
+    """
+
+    from ghost.engine import GhostEngine
+
+    engine = GhostEngine()
+
+    # --- Spike threat ---
+    engine.step({
+        "source": "npc_engine",
+        "intent": "threat",
+        "intensity": 1.0,
+    })
+
+    s1 = engine.state()
+    threat_after_spike = s1["npc"]["threat_level"]
+
+    # --- Advance cycles with no input (decay only) ---
+    engine.step()
+    engine.step()
+    engine.step()
+
+    s2 = engine.state()
+    threat_after_decay = s2["npc"]["threat_level"]
+
+    # --- Contracts ---
+    assert "npc" in s1
+    assert "npc" in s2
+
+    assert "threat_level" in s1["npc"]
+    assert "threat_level" in s2["npc"]
+
+    # Core invariant: decay must reduce threat without new input
+    assert threat_after_decay < threat_after_spike

ghocentric_ghost_engine-0.1.1/tests/test_npc_intent_processing.py

@@ -0,0 +1,21 @@
+def test_npc_intent_is_classified():
+    """
+    NPC intent input should be classified and reflected in engine state.
+    """
+
+    from ghost.engine import GhostEngine
+
+    engine = GhostEngine()
+
+    engine.step({
+        "source": "npc_engine",
+        "intent": "threat",
+        "intensity": 0.8
+    })
+
+    state = engine.state()
+
+    # --- Contracts ---
+    assert "npc" in state
+    assert state["npc"]["last_intent"] == "threat"
+    assert state["npc"]["threat_level"] > 0

ghocentric_ghost_engine-0.1.1/tests/test_public_api.py

@@ -0,0 +1,28 @@
+def test_public_api_surface():
+    """
+    Ghost exposes a stable, minimal public API.
+    This is the pip-facing contract.
+    """
+
+    import ghost
+
+    assert hasattr(ghost, "init")
+    assert hasattr(ghost, "step")
+    assert hasattr(ghost, "reset")
+    assert hasattr(ghost, "state")
+    assert hasattr(ghost, "snapshot")
+
+
+def test_public_api_behavior():
+    """
+    Public API functions must work end-to-end without importing internals.
+    """
+
+    import ghost
+
+    ghost.init()
+    ghost.step()
+    state = ghost.state()
+
+    assert isinstance(state, dict)
+    assert "cycles" in state