dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_runtime/relationship_state.py

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+"""task-222: relationship governance for DSH (accumulation / memory / attachment).
+
+The shared relationship file already stores trust/closeness/conflict. This
+module adds the missing P0 pieces:
+
+  accumulation   per-message signals -> bounded deltas (warmth, disclosure,
+                 conflict, repair), applied by pipeline.relationship_update
+  memory         <store>/relationship_memory.json keeps the last N notable
+                 events (kind/ts/text preview/delta), append-only
+  attachment     style + activation derived with biocore_model
+                 attachment_state / attachment_regulation (pure, optional)
+  repair         apology-style turns lower conflict and count as repairs
+
+Never deletes relationship history and never writes memory entries.
+"""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+try:
+    from biocore_model import attachment_regulation as _attach_reg
+except Exception:  # pragma: no cover - stripped checkout
+    _attach_reg = None
+try:
+    from biocore_model import attachment_state as _attach_state
+except Exception:  # pragma: no cover
+    _attach_state = None
+
+MEMORY_FILE = "relationship_memory.json"
+EVENT_LIMIT = 50
+SCHEMA = 1
+
+_CONFLICT = ("生气", "讨厌", "闭嘴", "滚", "烦", "失望", "吵架", "别说了",
+             "你错了", "没用", "不想理")
+_REPAIR = ("对不起", "抱歉", "是我不好", "别生气", "原谅", "我错了",
+           "不好意思", "不是那个意思")
+_WARMTH = ("谢谢", "喜欢", "想你", "抱抱", "辛苦", "开心", "爱你", "陪我",
+           "在吗", "晚安")
+_TRUST = ("相信", "告诉你", "秘密", "说实话", "只跟你说", "坦白")
+_DISCLOSE = ("我其实", "我觉得", "我害怕", "我担心", "我一直")
+
+DELTAS = {
+    "warmth": {"trust": 0.004, "closeness": 0.010},
+    "conflict": {"trust": -0.012, "closeness": -0.004, "conflict": 0.020},
+    "repair": {"trust": 0.008, "closeness": 0.004, "conflict": -0.020},
+    "trust": {"trust": 0.008, "closeness": 0.002},
+    "disclose": {"trust": 0.006, "closeness": 0.006},
+}
+
+
+def _num(value, default=0.0):
+    try:
+        number = float(value)
+    except Exception:
+        return default
+    return number if number == number else default
+
+
+def _root(store):
+    if isinstance(store, dict):
+        raw = store.get("root") or store.get("store") or store.get("path")
+    else:
+        raw = store
+    text = str(raw or "").strip()
+    return Path(text) if text else None
+
+
+def _data_dir(store):
+    root = _root(store)
+    if root is None:
+        return None
+    return root.parent if root.name == "memory" else root
+
+
+def enabled(store):
+    data_dir = _data_dir(store)
+    raw = {}
+    if data_dir is not None:
+        try:
+            raw = json.loads((data_dir / "flags.json").read_text(encoding="utf-8"))
+        except Exception:
+            raw = {}
+    if not isinstance(raw, dict):
+        raw = {}
+    return raw.get("relationship_governance", True) is not False
+
+
+def signals(text):
+    """One user message -> at most one kind plus its bounded deltas."""
+    value = str(text or "")
+    if any(word in value for word in _REPAIR):
+        kind = "repair"
+    elif any(word in value for word in _CONFLICT):
+        kind = "conflict"
+    elif any(word in value for word in _WARMTH):
+        kind = "warmth"
+    elif any(word in value for word in _TRUST):
+        kind = "trust"
+    elif any(word in value for word in _DISCLOSE):
+        kind = "disclose"
+    else:
+        return {"kind": "neutral", "deltas": {}}
+    return {"kind": kind, "deltas": dict(DELTAS[kind])}
+
+
+def style_for(trust, closeness, conflict, repairs=0):
+    trust = _num(trust, 0.5)
+    closeness = _num(closeness, 0.5)
+    conflict = _num(conflict, 0.0)
+    if conflict >= 0.45 and trust < 0.55:
+        return "anxious"
+    if trust < 0.35 and closeness < 0.40:
+        return "avoidant"
+    if trust >= 0.55 and conflict < 0.25:
+        return "secure"
+    return "mixed"
+
+
+def activation_for(style, conflict=0.0, current=0.0, responded=False, hours=0.0):
+    """Attachment activation via the pure model modules (safe fallback)."""
+    style = style if style in ("secure", "anxious", "avoidant") else "secure"
+    try:
+        if _attach_reg is not None:
+            return dict(_attach_reg.activation(
+                style, threat=min(1.0, max(0.0, _num(conflict))), 
+                current=_num(current), responded=bool(responded),
+                hours=max(0.0, _num(hours))))
+    except Exception:
+        pass
+    return {"style": style, "activation": round(min(1.0, max(0.0, _num(current))), 4),
+            "mode": "comfort", "drive_mult": 1.0, "tone": "seek_comfort"}
+
+
+def memory_path(store):
+    root = _root(store)
+    return (root / MEMORY_FILE) if root is not None else None
+
+
+def read_memory(store):
+    path = memory_path(store)
+    try:
+        if path is None or not path.exists():
+            return {"schema": SCHEMA, "events": []}
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return {"schema": SCHEMA, "events": []}
+        events = [row for row in (data.get("events") or []) if isinstance(row, dict)]
+        return {"schema": SCHEMA, "events": events[-EVENT_LIMIT:]}
+    except Exception:
+        return {"schema": SCHEMA, "events": []}
+
+
+def _write_memory(store, doc):
+    path = memory_path(store)
+    if path is None:
+        return False
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(path.name + ".tmp")
+        tmp.write_text(json.dumps(doc, ensure_ascii=False, indent=2),
+                       encoding="utf-8")
+        tmp.replace(path)
+        return True
+    except Exception:
+        return False
+
+
+def record_event(store, kind, text, deltas, now=None):
+    """Append one notable relationship event (no-op for neutral turns)."""
+    if kind in ("", "neutral"):
+        return None
+    doc = read_memory(store)
+    row = {"ts": round(_num(now, time.time()), 3),
+           "kind": str(kind)[:16],
+           "text": str(text or "")[:40],
+           "delta": {key: round(_num(value, 0.0), 4)
+                     for key, value in (deltas or {}).items()}}
+    events = (doc.get("events") or []) + [row]
+    doc["events"] = events[-EVENT_LIMIT:]
+    _write_memory(store, doc)
+    return row
+
+
+def summary(store, relationship=None):
+    """Counters for /state: accumulation totals + attachment view."""
+    doc = read_memory(store)
+    events = doc.get("events") or []
+    rel = relationship if isinstance(relationship, dict) else {}
+    counts = {}
+    for row in events:
+        kind = str(row.get("kind") or "")
+        if kind:
+            counts[kind] = counts.get(kind, 0) + 1
+    style = str(rel.get("attachment_style") or "")
+    if not style:
+        style = style_for(rel.get("trust"), rel.get("closeness"),
+                          rel.get("conflict"), counts.get("repair", 0))
+    view = activation_for(style, _num(rel.get("conflict"), 0.0))
+    last = events[-1] if events else {}
+    return {
+        "events": len(events),
+        "repairs": int(counts.get("repair", 0)),
+        "warmth": int(counts.get("warmth", 0)),
+        "conflicts": int(counts.get("conflict", 0)),
+        "attachment_style": view.get("style") or style,
+        "attachment_activation": round(_num(view.get("activation"), 0.0), 4),
+        "last_event": {"kind": str(last.get("kind") or ""),
+                       "ts": round(_num(last.get("ts"), 0.0), 3),
+                       "text": str(last.get("text") or "")},
+        "enabled": enabled(store),
+    }

package/python/biocore_runtime/self_layer.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""task-222: self layer (persona lock / narrative / drift) for the DSH core."""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+IDENTITY_FILE = "identity.json"
+NARRATIVE_LIMIT = 30
+SCHEMA = 1
+
+
+def _root(store):
+    if isinstance(store, dict):
+        raw = store.get("root") or store.get("store") or store.get("path")
+    else:
+        raw = store
+    text = str(raw or "").strip()
+    return Path(text) if text else None
+
+
+def _data_dir(store):
+    root = _root(store)
+    if root is None:
+        return None
+    return root.parent if root.name == "memory" else root
+
+
+def path_for(store):
+    data_dir = _data_dir(store)
+    return (data_dir / IDENTITY_FILE) if data_dir is not None else None
+
+
+def _read(path):
+    try:
+        if path is None or not path.exists():
+            return {}
+        doc = json.loads(path.read_text(encoding="utf-8"))
+        return doc if isinstance(doc, dict) else {}
+    except Exception:
+        return {}
+
+
+def _write(path, doc):
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(path.name + ".tmp")
+        tmp.write_text(json.dumps(doc, ensure_ascii=False, indent=2),
+                       encoding="utf-8")
+        tmp.replace(path)
+        return True
+    except Exception:
+        return False
+
+
+def hash_persona(text):
+    raw = str(text or "").strip()
+    if not raw:
+        return ""
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+
+def update(store, persona_hash="", narrative=None, now=None):
+    """Lock the persona hash, append one narrative line, detect drift."""
+    path = path_for(store)
+    if path is None:
+        return None
+    stamp = round(float(now or time.time()), 3)
+    doc = _read(path)
+    locked = str(doc.get("persona_hash") or "")
+    incoming = str(persona_hash or "").strip()
+    drift = bool(locked and incoming and locked != incoming)
+    if incoming and not locked:
+        locked = incoming
+    if incoming and drift:
+        history = [row for row in (doc.get("drift") or []) if isinstance(row, dict)]
+        history.append({"ts": stamp, "from": locked, "to": incoming})
+        doc["drift"] = history[-10:]
+        locked = incoming
+    lines = [row for row in (doc.get("narrative") or []) if isinstance(row, dict)]
+    if isinstance(narrative, dict) and str(narrative.get("text") or "").strip():
+        lines.append({"ts": stamp, "kind": str(narrative.get("kind") or "note")[:16],
+                      "text": str(narrative.get("text"))[:60]})
+    doc.update({"schema": SCHEMA, "persona_hash": locked,
+                "persona_locked": bool(locked), "narrative": lines[-NARRATIVE_LIMIT:],
+                "updated_at": stamp, "drift_count": len(doc.get("drift") or [])})
+    _write(path, doc)
+    return doc
+
+
+def summary(store):
+    doc = _read(path_for(store))
+    lines = [row for row in (doc.get("narrative") or []) if isinstance(row, dict)]
+    return {
+        "persona_locked": bool(doc.get("persona_locked")),
+        "persona_hash": str(doc.get("persona_hash") or "")[:12],
+        "drift_count": int(doc.get("drift_count") or 0),
+        "narrative_count": len(lines),
+        "last_narrative": (lines[-1].get("text") if lines else ""),
+        "updated_at": float(doc.get("updated_at") or 0.0),
+    }

package/python/biocore_runtime/service.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""task-223: persistent BioCore service (one process per DSH plugin lifetime).
+
+Protocol: one JSON object per line on stdin, one JSON reply per line on stdout.
+
+    request  {"id": <str>, "action": <str>, "payload": {...}}
+    reply    {"id": <str>, "ok": true,  "result": {...}}
+             {"id": <str>, "ok": false, "reason": "...", "detail": "..."}
+
+The action is handed to biocore_runtime.pipeline.dispatch, so every policy
+stays in the existing module. A bad request or an exception is answered and
+the loop keeps running; SIGTERM/SIGINT stop it cleanly. No third-party deps.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import signal
+import sys
+import threading
+import time
+import traceback
+from pathlib import Path
+
+_PLUGIN_ROOT = str(Path(__file__).resolve().parents[1])
+if _PLUGIN_ROOT not in sys.path:
+    sys.path.insert(0, _PLUGIN_ROOT)
+_ADAPTER_DIR = str(os.environ.get("BIOCORE_ADAPTER_DIR") or "").strip()
+if _ADAPTER_DIR and _ADAPTER_DIR not in sys.path:
+    sys.path.insert(0, _ADAPTER_DIR)
+
+from biocore_runtime import pipeline  # noqa: E402
+
+STOP = False
+_IDLE_EVENT = threading.Event()
+
+
+def _install_signals():
+    def _stop(signum, frame):
+        global STOP
+        STOP = True
+        _IDLE_EVENT.set()
+    for name in ("SIGTERM", "SIGINT"):
+        handler = getattr(signal, name, None)
+        if handler is None:
+            continue
+        try:
+            signal.signal(handler, _stop)
+        except Exception:
+            pass
+
+
+def _reply(stream, req_id, ok, result=None, reason="", detail=""):
+    payload = {"id": req_id, "ok": bool(ok)}
+    if ok:
+        payload["result"] = result if result is not None else {}
+    else:
+        payload["reason"] = str(reason or "service_error")
+        if detail:
+            payload["detail"] = str(detail)[:300]
+    try:
+        stream.write(json.dumps(payload, ensure_ascii=False,
+                                separators=(",", ":")) + "\n")
+        stream.flush()
+    except Exception:
+        pass
+
+
+def handle(req):
+    """One request dict -> (ok, result, reason, detail); never raises."""
+    if not isinstance(req, dict):
+        return False, None, "bad_request", "request must be an object"
+    req_id = req.get("id")
+    action = str(req.get("action") or "").strip()
+    payload = req.get("payload")
+    payload = payload if isinstance(payload, dict) else {}
+    if not action:
+        return False, None, "bad_request", "missing action"
+    if action == "ping":
+        return True, {"pong": True, "echo_len": len(json.dumps(payload)),
+                      "pid": os.getpid()}, "", ""
+    if action == "sleep":
+        try:
+            ms = max(0, min(5000, int(payload.get("ms") or 0)))
+        except Exception:
+            ms = 0
+        time.sleep(ms / 1000.0)
+        return True, {"slept": ms}, "", ""
+    try:
+        result = pipeline.dispatch(action, payload)
+        return True, result, "", ""
+    except Exception as error:  # keep the service alive
+        detail = "%s: %s" % (type(error).__name__, str(error)[:200])
+        try:
+            traceback.print_exc(file=sys.stderr)
+        except Exception:
+            pass
+        return False, None, "service_error", detail
+
+
+def _watchdog(idle_timeout):
+    """Exit when no request arrived for idle_timeout seconds (0 = never)."""
+    if not idle_timeout or idle_timeout <= 0:
+        return
+
+    def _run():
+        while not STOP:
+            fired = _IDLE_EVENT.wait(timeout=idle_timeout)
+            if fired:
+                return
+            if STOP:
+                return
+            try:
+                sys.stderr.write("__bioService idle_timeout\n")
+                sys.stderr.flush()
+            except Exception:
+                pass
+            os._exit(0)
+
+    thread = threading.Thread(target=_run, daemon=True)
+    thread.start()
+
+
+def serve(stream_in=None, stream_out=None, idle_timeout=0.0):
+    global STOP
+    stdin = stream_in or sys.stdin
+    stdout = stream_out or sys.stdout
+    _watchdog(float(idle_timeout or 0.0))
+    for line in stdin:
+        if STOP:
+            break
+        line = str(line or "").strip()
+        if not line:
+            continue
+        _IDLE_EVENT.set()
+        _IDLE_EVENT.clear()
+        req_id = None
+        try:
+            request = json.loads(line)
+            if isinstance(request, dict):
+                req_id = request.get("id")
+            ok, result, reason, detail = handle(request)
+        except Exception as error:
+            ok, result, reason, detail = (False, None, "bad_json",
+                                          "%s: %s" % (type(error).__name__,
+                                                      str(error)[:200]))
+        _reply(stdout, req_id, ok, result, reason, detail)
+    return 0
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--idle-timeout", type=float, default=0.0)
+    args, _unknown = parser.parse_known_args(list(argv or sys.argv[1:]))
+    _install_signals()
+    return serve(idle_timeout=args.idle_timeout)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())