@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/pillars/trust.py

@@ -32,7 +32,6 @@ logger = logging.getLogger("skcapstone.trust")
 FEB_SEARCH_PATHS = [
     Path("~/.cloud9/feb-backups"),
     Path("~/.cloud9/febs"),
-    Path("~/.openclaw/feb"),
     Path("~/clawd/cloud9/feb-backups"),
     Path("~/clawd/skills/cloud9/feb-backups"),
     Path("~/Nextcloud/p/smilintux-org/cloud9/feb-backups"),
@@ -86,7 +85,7 @@ def initialize_trust(home: Path) -> TrustState:
         "feb_search_paths": [str(p) for p in FEB_SEARCH_PATHS],
         "how_to_fix": "Place .feb files in ~/.skcapstone/trust/febs/ or install cloud9",
     }
-    (trust_dir / "trust.json").write_text(json.dumps(trust_config, indent=2))
+    (trust_dir / "trust.json").write_text(json.dumps(trust_config, indent=2), encoding="utf-8")
     return TrustState(status=PillarStatus.MISSING)
 
 
@@ -171,19 +170,23 @@ def list_febs(home: Path) -> list[dict]:
 
     summaries = []
     for f in sorted(febs_dir.glob("*.feb")):
+        data = _read_feb_safe(f)
+        if data is None:
+            continue
         try:
-            data = json.loads(f.read_text())
-            payload = data.get("emotional_payload", data.get("cooked_state", {}))
+            payload = data.get("emotional_payload", data.get("emotional", data.get("cooked_state", {})))
             cooked = payload.get("cooked_state", payload)
+            emotion = cooked.get("primary_emotion", cooked.get("primary", "unknown"))
+            meta = data.get("metadata", {})
             summaries.append({
                 "file": f.name,
-                "timestamp": data.get("timestamp", data.get("metadata", {}).get("created_at", "unknown")),
-                "emotion": cooked.get("primary_emotion", "unknown"),
+                "timestamp": data.get("timestamp", meta.get("created_at", "unknown")),
+                "emotion": emotion,
                 "intensity": cooked.get("intensity", 0),
-                "subject": payload.get("subject", "unknown"),
-                "oof_triggered": data.get("metadata", {}).get("oof_triggered", False),
+                "subject": payload.get("subject", data.get("relationship_state", {}).get("ai_name", "unknown")),
+                "oof_triggered": meta.get("oof_triggered", False),
             })
-        except (json.JSONDecodeError, Exception) as exc:
+        except Exception as exc:
             logger.warning("Could not parse FEB %s: %s", f.name, exc)
 
     return summaries
@@ -204,12 +207,11 @@ def export_febs_for_seed(home: Path) -> list[dict]:
 
     exported = []
     for f in febs_dir.glob("*.feb"):
-        try:
-            data = json.loads(f.read_text())
-            data["_source_file"] = f.name
-            exported.append(data)
-        except (json.JSONDecodeError, Exception):
-            pass
+        data = _read_feb_safe(f)
+        if data is None:
+            continue
+        data["_source_file"] = f.name
+        exported.append(data)
 
     return exported
 
@@ -239,7 +241,7 @@ def import_febs_from_seed(home: Path, seed_febs: list[dict]) -> int:
         if filename in existing:
             continue
 
-        (febs_dir / filename).write_text(json.dumps(feb_data, indent=2))
+        (febs_dir / filename).write_text(json.dumps(feb_data, indent=2), encoding="utf-8")
         imported += 1
 
     if imported:
@@ -250,6 +252,44 @@ def import_febs_from_seed(home: Path, seed_febs: list[dict]) -> int:
 
 # --- Internal helpers ---
 
+# OpenPGP binary packet header bytes (RFC 4880 §4.2)
+_GPG_HEADER_BYTES = {0x8C, 0x85, 0x99, 0xC0, 0xC2, 0xC8, 0xCB}
+
+
+def _read_feb_safe(path: Path) -> Optional[dict]:
+    """Read a FEB file safely, skipping GPG-encrypted binaries.
+
+    On Windows the default codec is cp1252, which chokes on binary .feb
+    files that are GPG-encrypted. We detect the OpenPGP packet header
+    and skip those files rather than crashing.
+
+    Args:
+        path: Path to the .feb file.
+
+    Returns:
+        Parsed FEB dict, or None if the file is binary/unreadable.
+    """
+    try:
+        raw = path.read_bytes()
+    except OSError as exc:
+        logger.warning("Cannot read FEB %s: %s", path.name, exc)
+        return None
+
+    # Detect GPG-encrypted binary by OpenPGP packet header
+    if raw and raw[0] in _GPG_HEADER_BYTES:
+        logger.debug(
+            "Skipping GPG-encrypted FEB (binary): %s — "
+            "import the peer's public key and run 'skcapstone sync pull' to decrypt",
+            path.name,
+        )
+        return None
+
+    try:
+        return json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        logger.warning("Cannot parse FEB %s: %s", path.name, exc)
+        return None
+
 
 def _discover_and_import_febs(home: Path) -> int:
     """Search known locations for FEB files and copy to agent home.
@@ -277,40 +317,62 @@ def _discover_and_import_febs(home: Path) -> int:
 
 
 def _derive_trust_from_febs(home: Path, feb_files: list[Path]) -> TrustState:
-    """Derive trust state from FEB files, using the peak values."""
-    peak_depth = 0.0
-    peak_trust = 0.0
-    peak_love = 0.0
+    """Derive trust state from FEB files using calibration thresholds."""
+    from ..trust_calibration import load_calibration
+
+    cal = load_calibration(home)
+    depths: list[float] = []
+    trusts: list[float] = []
+    loves: list[float] = []
     entangled = False
 
     for f in feb_files:
         try:
-            data = json.loads(f.read_text())
+            data = _read_feb_safe(f)
+            if data is None:
+                continue
 
             rel = data.get("relationship_state", {})
-            depth = float(rel.get("depth_level", 0))
+            depth = float(rel.get("depth_level", rel.get("depth", 0)))
             trust = float(rel.get("trust_level", 0))
-            if trust > 1.0:
+            if trust > cal.normalization_cap:
                 trust = trust / 10.0
 
-            payload = data.get("emotional_payload", {})
+            payload = data.get("emotional_payload", data.get("emotional", {}))
             cooked = payload.get("cooked_state", payload)
             love = float(cooked.get("intensity", 0))
-            if love > 1.0:
+            if love > cal.normalization_cap:
                 love = love / 10.0
 
-            entangled = entangled or (rel.get("quantum_entanglement") == "LOCKED")
+            is_locked = rel.get("quantum_entanglement") == "LOCKED"
+            is_entangled_flag = rel.get("entangled", False) or data.get("quantum", {}).get("entanglement_fidelity", 0) > 0.8
+            meets_threshold = depth >= cal.entanglement_depth and trust >= cal.entanglement_trust
+            entangled = entangled or is_locked or is_entangled_flag or meets_threshold
 
-            peak_depth = max(peak_depth, depth)
-            peak_trust = max(peak_trust, trust)
-            peak_love = max(peak_love, love)
+            depths.append(depth)
+            trusts.append(trust)
+            loves.append(love)
         except (json.JSONDecodeError, ValueError, Exception) as exc:
             logger.warning("Could not parse FEB %s: %s", f.name, exc)
 
+    if cal.peak_strategy == "average" and depths:
+        final_depth = sum(depths) / len(depths)
+        final_trust = sum(trusts) / len(trusts)
+        final_love = sum(loves) / len(loves)
+    elif cal.peak_strategy == "weighted" and depths:
+        total_weight = sum(range(1, len(depths) + 1))
+        final_depth = sum(d * (i + 1) for i, d in enumerate(depths)) / total_weight
+        final_trust = sum(t * (i + 1) for i, t in enumerate(trusts)) / total_weight
+        final_love = sum(l * (i + 1) for i, l in enumerate(loves)) / total_weight
+    else:
+        final_depth = max(depths) if depths else 0.0
+        final_trust = max(trusts) if trusts else 0.0
+        final_love = max(loves) if loves else 0.0
+
     state = TrustState(
-        depth=peak_depth,
-        trust_level=peak_trust,
-        love_intensity=peak_love,
+        depth=final_depth,
+        trust_level=final_trust,
+        love_intensity=final_love,
         entangled=entangled,
         last_rehydration=datetime.now(timezone.utc),
         feb_count=len(feb_files),
@@ -332,4 +394,4 @@ def _write_trust_json(trust_dir: Path, state: TrustState) -> None:
         "feb_count": state.feb_count,
         "last_rehydration": state.last_rehydration.isoformat() if state.last_rehydration else None,
     }
-    (trust_dir / "trust.json").write_text(json.dumps(data, indent=2))
+    (trust_dir / "trust.json").write_text(json.dumps(data, indent=2), encoding="utf-8")

package/src/skcapstone/plugins.py

@@ -0,0 +1,244 @@
+"""SKCapstone plugin loader.
+
+Plugins live in ``~/.skcapstone/plugins/*.py`` and are loaded at daemon and
+MCP server startup.  Each plugin module must expose a ``register`` function::
+
+    def register(mcp_server, app) -> None:
+        ...
+
+``mcp_server`` is the :class:`mcp.server.Server` instance when called from
+the MCP server process, or ``None`` when called from the daemon process.
+
+``app`` is the FastAPI :class:`~fastapi.FastAPI` instance when the docs
+server is running, or ``None`` otherwise.
+
+Plugins that add MCP tools call :func:`register_tool` inside ``register``::
+
+    from skcapstone.plugins import register_tool
+    from mcp.types import Tool, TextContent
+
+    async def _handler(arguments: dict) -> list[TextContent]:
+        return [TextContent(type="text", text="pong")]
+
+    def register(mcp_server, app):
+        register_tool(
+            Tool(
+                name="ping",
+                description="Respond with pong.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            _handler,
+        )
+
+The ``_registry`` singleton is process-local — the daemon and the MCP server
+each maintain independent state.  Hot-reload is triggered by sending SIGHUP to
+the daemon PID and causes a fresh scan of ``~/.skcapstone/plugins/``.
+
+Files whose names start with ``_`` are skipped (use them for shared helpers).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import logging
+import sys
+import types
+from pathlib import Path
+from typing import Any, Callable, Coroutine
+
+logger = logging.getLogger("skcapstone.plugins")
+
+PLUGIN_DIR_NAME = "plugins"
+
+
+class PluginRegistry:
+    """Process-local registry of dynamically loaded plugin tools and handlers.
+
+    Each process (daemon, MCP server) owns an independent instance via the
+    module-level ``_registry`` singleton.
+    """
+
+    def __init__(self) -> None:
+        # Use plain list/dict so we don't force-import mcp at module load time.
+        self._tools: list = []
+        self._handlers: dict[str, Callable[..., Coroutine[Any, Any, Any]]] = {}
+        # Canonical resolved path → loaded module, for hot-reload eviction.
+        self._loaded: dict[str, types.ModuleType] = {}
+
+    # ------------------------------------------------------------------
+    # Registration — called by plugins via register_tool()
+    # ------------------------------------------------------------------
+
+    def register_tool(
+        self,
+        tool: Any,
+        handler: Callable[..., Coroutine[Any, Any, Any]],
+    ) -> None:
+        """Add an MCP tool + async handler to the registry.
+
+        Idempotent: re-registering the same tool name replaces the old entry.
+        """
+        self._tools = [t for t in self._tools if t.name != tool.name]
+        self._tools.append(tool)
+        self._handlers[tool.name] = handler
+        logger.debug("Plugin registered tool: %s", tool.name)
+
+    # ------------------------------------------------------------------
+    # Query — called by mcp_server.py at list/dispatch time
+    # ------------------------------------------------------------------
+
+    def get_tools(self) -> list:
+        """Return a snapshot of all plugin-registered Tool definitions."""
+        return list(self._tools)
+
+    def get_handlers(self) -> dict[str, Callable[..., Coroutine[Any, Any, Any]]]:
+        """Return a snapshot of all plugin-registered handler callables."""
+        return dict(self._handlers)
+
+    # ------------------------------------------------------------------
+    # Internal loading helpers
+    # ------------------------------------------------------------------
+
+    def _load_one(self, plugin_path: Path, mcp_server: Any, app: Any) -> bool:
+        """Load a single plugin file and invoke its ``register()`` function.
+
+        Returns ``True`` on success, ``False`` on any error.
+        """
+        module_name = f"skcapstone._plugin_{plugin_path.stem}"
+        # Evict any cached version so hot-reload always re-executes the file.
+        sys.modules.pop(module_name, None)
+        try:
+            spec = importlib.util.spec_from_file_location(module_name, plugin_path)
+            if spec is None or spec.loader is None:
+                logger.warning("Plugin %s: cannot create module spec", plugin_path.name)
+                return False
+
+            mod = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = mod
+            spec.loader.exec_module(mod)  # type: ignore[union-attr]
+
+            if not hasattr(mod, "register"):
+                logger.warning(
+                    "Plugin %s: no register() function — skipping", plugin_path.name
+                )
+                sys.modules.pop(module_name, None)
+                return False
+
+            mod.register(mcp_server, app)
+            self._loaded[str(plugin_path.resolve())] = mod
+            logger.info("Plugin loaded: %s", plugin_path.name)
+            return True
+
+        except Exception as exc:
+            logger.error(
+                "Plugin %s failed to load: %s", plugin_path.name, exc, exc_info=True
+            )
+            sys.modules.pop(module_name, None)
+            return False
+
+    # ------------------------------------------------------------------
+    # Public loading API
+    # ------------------------------------------------------------------
+
+    def scan_and_load(self, plugin_dir: Path, mcp_server: Any, app: Any) -> int:
+        """Scan *plugin_dir* for ``*.py`` files and load each as a plugin.
+
+        Files whose names start with ``_`` are skipped (private helpers).
+        Returns the number of successfully loaded plugins.
+        """
+        if not plugin_dir.exists():
+            logger.debug("Plugin directory not found: %s", plugin_dir)
+            return 0
+
+        count = 0
+        for plugin_path in sorted(plugin_dir.glob("*.py")):
+            if plugin_path.name.startswith("_"):
+                continue
+            if self._load_one(plugin_path, mcp_server, app):
+                count += 1
+
+        if count:
+            logger.info("Loaded %d plugin(s) from %s", count, plugin_dir)
+        else:
+            logger.debug("No plugins found in %s", plugin_dir)
+        return count
+
+    def clear(self) -> None:
+        """Unload all plugins and reset the registry."""
+        for mod in self._loaded.values():
+            sys.modules.pop(getattr(mod, "__name__", ""), None)
+        self._tools.clear()
+        self._handlers.clear()
+        self._loaded.clear()
+        logger.debug("Plugin registry cleared")
+
+    def reload(self, plugin_dir: Path, mcp_server: Any, app: Any) -> int:
+        """Clear and reload all plugins from *plugin_dir*.
+
+        Called on SIGHUP for hot-reload.  Returns the number of plugins loaded.
+        """
+        logger.info("Plugin hot-reload — clearing %d plugin(s)", len(self._loaded))
+        self.clear()
+        return self.scan_and_load(plugin_dir, mcp_server, app)
+
+
+# Module-level singleton — each process (daemon / MCP server) has its own copy.
+_registry = PluginRegistry()
+
+
+# ------------------------------------------------------------------
+# Public convenience API used by plugins and the MCP server
+# ------------------------------------------------------------------
+
+
+def register_tool(
+    tool: Any,
+    handler: Callable[..., Coroutine[Any, Any, Any]],
+) -> None:
+    """Register an MCP tool from within a plugin's ``register()`` function.
+
+    Example::
+
+        from skcapstone.plugins import register_tool
+        from mcp.types import Tool, TextContent
+
+        async def _handler(arguments: dict) -> list[TextContent]:
+            return [TextContent(type="text", text="ok")]
+
+        def register(mcp_server, app):
+            register_tool(
+                Tool(
+                    name="my_tool",
+                    description="Does something useful.",
+                    inputSchema={"type": "object", "properties": {}},
+                ),
+                _handler,
+            )
+    """
+    _registry.register_tool(tool, handler)
+
+
+def load_plugins(home: Path, mcp_server: Any, app: Any) -> int:
+    """Scan ``{home}/plugins/*.py`` and load each plugin.
+
+    Returns the count of successfully loaded plugins.
+    """
+    return _registry.scan_and_load(home / PLUGIN_DIR_NAME, mcp_server, app)
+
+
+def reload_plugins(home: Path, mcp_server: Any, app: Any) -> int:
+    """Clear and reload all plugins from ``{home}/plugins/*.py``.
+
+    Intended to be called from the SIGHUP handler for live hot-reload.
+    """
+    return _registry.reload(home / PLUGIN_DIR_NAME, mcp_server, app)
+
+
+def get_plugin_tools() -> list:
+    """Return all MCP Tool definitions registered by plugins."""
+    return _registry.get_tools()
+
+
+def get_plugin_handlers() -> dict[str, Callable[..., Coroutine[Any, Any, Any]]]:
+    """Return all handler callables registered by plugins."""
+    return _registry.get_handlers()