dsh-biocore 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-biocore",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "description": "BioCore DSH UI: per-session state tab, standalone instrument panel, /api/biocore/state, session/event one_turn updates, /bio sync.",
   "main": "lib/index.js",

package/python/biocore_model/tests/test_extensions.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+"""task-225 (5b): P0 memory extensions + expression modules."""
+import json
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+from biocore_model import (entity_graph, entity_resolve, expr_template,
+                           graph_extract, graph_recall, layered_memory,
+                           memory_dual, prompt_rules, prospective,
+                           reconstruction, template_expr, topic_control,
+                           turn_memory, voice_bank)
+from biocore_runtime import extensions, pipeline
+
+
+def entry(i, text, ts=1700000000.0):
+    return {"id": i, "text": text, "role": "user", "ts": ts,
+            "importance": 0.5, "hits": 1}
+
+
+class Case(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.data_dir = Path(self.tmp.name) / "data"
+        self.store = self.data_dir / "memory"
+        (self.store / "sessions" / "s1").mkdir(parents=True)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+
+class GraphTest(Case):
+    def test_entity_graph_build_search(self):
+        graph, _ = extensions._entity_graph([
+            entry("a", "苹果 很甜"), entry("b", "苹果 咖啡")])
+        self.assertGreaterEqual(len(graph.get("entities") or []), 1)
+        hits = entity_graph.search(graph, "苹果", limit=4)
+        self.assertTrue(hits)
+
+    def test_entity_resolve(self):
+        self.assertEqual(entity_resolve.normalize("苹果 甜"), "苹果甜")
+        self.assertGreaterEqual(entity_resolve.similarity("苹果", "苹果"), 0.9)
+
+    def test_graph_extract(self):
+        self.assertEqual(graph_extract.canonical_type("人物"), "person")
+        self.assertGreater(graph_extract.when_to_ts("明天", 1000.0), 1000.0)
+
+    def test_graph_recall_window(self):
+        window = graph_recall.detect_window("上周")
+        self.assertNotEqual(window, None)
+
+    def test_graph_hits_extra(self):
+        rows = [entry("a", "苹果 很甜"), entry("b", "苹果 咖啡"),
+                entry("c", "香蕉")]
+        hits, stats = extensions.graph_hits(rows, "苹果")
+        self.assertGreaterEqual(stats["hits"], 0)
+        self.assertIsInstance(hits, list)
+
+
+class MemoryExtTest(Case):
+    def test_layered_select(self):
+        result = layered_memory.select([entry("a", "早上的事"), entry("b", "刚才的事")],
+                                       recalled_ids=["b"])
+        self.assertIn("resident", result)
+        self.assertIn("retrieval", result)
+        self.assertTrue(result["resident"] or result["retrieval"])
+
+    def test_memory_dual_score(self):
+        e = memory_dual.encode("苹果", 1700000000.0, arousal=0.5)
+        self.assertGreater(memory_dual.score(e, 1700000100.0), 0)
+        self.assertTrue(memory_dual.select([e], 1700000100.0, limit=2))
+
+    def test_prospective_due(self):
+        now = time.time()
+        rec = prospective.entry("his_event", "体检", now - 10)
+        items, changed = prospective.add([], rec)
+        self.assertTrue(changed)
+        due = prospective.due_now(items, now, window_s=60)
+        self.assertEqual(len(due), 1)
+        self.assertTrue(prospective.build_hint(due[0], now))
+        self.assertEqual(prospective.stats(items)["by_status"]["pending"], 1)
+
+    def test_reconstruction(self):
+        out = reconstruction.conserve([entry("a", "旧的记忆")])
+        self.assertIn("total", out)
+
+    def test_turn_memory(self):
+        rows = turn_memory.build([{"entry_id": "a", "text": "记得喝水",
+                                   "source": "recall"}])
+        self.assertEqual(len(rows), 1)
+        record = turn_memory.build_record(rows, reply="好", ts=10.0)
+        self.assertTrue(turn_memory.render_receipt(record))
+
+    def test_recall_graph_expansion(self):
+        rows = [entry("a", "苹果 很甜", 1700000001.0),
+                entry("b", "苹果 咖啡", 1700000002.0),
+                entry("c", "香蕉 黄", 1700000003.0)]
+        (self.store / "sessions" / "s1" / "memory.json").write_text(
+            json.dumps({"entries": rows}), encoding="utf-8")
+        out = pipeline.inject_block("s1", str(self.store), query="苹果 咖啡",
+                                    mode="query", top_k=3)
+        self.assertGreaterEqual(len(out["ids"]), 2)
+        self.assertIn("b", out["ids"])
+
+
+class ExpressionTest(Case):
+    def test_expr_template(self):
+        out = expr_template.build_reply({"v": 0.2}, {"trust": 0.5})
+        self.assertIsInstance(out, dict)
+
+    def test_prompt_rules(self):
+        text = prompt_rules.render_rules(affect={"valence": -0.4, "stress": 0.7},
+                                         relation={"closeness": 0.5},
+                                         certainty=0.7, soft_target=12,
+                                         soft_max=30)
+        self.assertIsInstance(text, str)
+        self.assertTrue(text)
+
+    def test_template_expr(self):
+        self.assertEqual(template_expr.render("你好 {{name}}", {"name": "主管"}),
+                         "你好 主管")
+
+    def test_topic_control(self):
+        result = topic_control.topic_control(turns=[], state={"v": 0.0},
+                                             relationship={"trust": 0.5})
+        self.assertIsInstance(result, dict)
+        self.assertTrue("tendency" in result or "holder" in result)
+
+    def test_voice_bank(self):
+        bank = [{"id": "v1", "phrase": "嗯。", "weight": 1.0,
+                 "when": {"v_min": -1, "v_max": 1, "tension_min": 0,
+                          "tension_max": 1}, "cooldown_s": 0}]
+        picked = voice_bank.pick({"v": 0.1, "tension": 0.2},
+                                 {"stage": "normal"}, [], time.time(),
+                                 entries=bank)
+        self.assertTrue(picked)
+
+    def test_expression_block(self):
+        block = extensions.expression_block(
+            str(self.store), {"core": {"v": -0.2, "stress": 0.7}},
+            {"trust": 0.5, "closeness": 0.4, "stage": "normal"},
+            soft_target=12, soft_max=30)
+        self.assertTrue(block["rules"] or block["template"])
+        self.assertIn("template_name", block)
+
+
+class StateTest(Case):
+    def test_state_exposes_extensions(self):
+        rows = [entry("a", "苹果 很甜"), entry("b", "香蕉")]
+        (self.store / "sessions" / "s1" / "memory.json").write_text(
+            json.dumps({"entries": rows}), encoding="utf-8")
+        pipeline.dispatch("turn_end", {
+            "store": str(self.store), "session_id": "s1",
+            "user_text": "苹果很甜", "assistant_text": "嗯。",
+            "capture": False,
+            "persona_profile": str(Path(self.tmp.name) / "missing.json")})
+        body = pipeline.dispatch("state", {
+            "store": str(self.store), "session_id": "s1",
+            "persona_profile": str(Path(self.tmp.name) / "missing.json")})["state"]
+        self.assertIn("extensions", body)
+        self.assertIn("graph", body["extensions"])
+        self.assertIn("layered", body["extensions"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_signals.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""task-224 (5a): the 17 P0 modules are evaluated and exposed via /state."""
+import json
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+from biocore_runtime import pipeline, signals
+
+
+class SignalsCase(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.data_dir = Path(self.tmp.name) / "data"
+        self.store = self.data_dir / "memory"
+        (self.store / "sessions").mkdir(parents=True)
+        self.state = {"core": {"v": 0.2, "a": 0.6, "stress": 0.4,
+                               "social": 0.4, "energy": 0.7}}
+        self.rel = {"trust": 0.55, "closeness": 0.5, "conflict": 0.1,
+                    "days_known": 12}
+        self.out = signals.evaluate(self.store, "s1",
+                                    user_text="我们约好明天见面，谢谢你",
+                                    assistant_text="好。",
+                                    state=self.state, relationship=self.rel,
+                                    now=time.time())
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def module_ok(self, group, name):
+        row = self.out[group][name]
+        self.assertTrue(row.get("enabled"), row)
+        return row
+
+    def test_affective_labor(self):
+        self.module_ok("perception", "affective_labor")
+
+    def test_compassion_fatigue(self):
+        self.module_ok("perception", "compassion_fatigue")
+
+    def test_connection_bids(self):
+        self.module_ok("perception", "connection_bids")
+
+    def test_defense_mechanisms(self):
+        self.module_ok("perception", "defense_mechanisms")
+
+    def test_emotion_geometry(self):
+        self.module_ok("perception", "emotion_geometry")
+
+    def test_needs_events(self):
+        self.module_ok("perception", "needs_events")
+
+    def test_social_pain(self):
+        self.module_ok("perception", "social_pain")
+
+    def test_social_repair(self):
+        self.module_ok("perception", "social_repair")
+
+    def test_commitment_extractor(self):
+        row = self.module_ok("relationship", "commitment_extractor")
+        self.assertIsInstance(row.get("value"), dict)
+
+    def test_relation_stage(self):
+        self.module_ok("relationship", "relation_stage")
+
+    def test_relationship_stage(self):
+        self.module_ok("relationship", "relationship_stage")
+
+    def test_repair_after_boundary(self):
+        self.module_ok("relationship", "repair_after_boundary")
+
+    def test_metacog(self):
+        self.module_ok("self", "metacog")
+
+    def test_possible_selves(self):
+        self.module_ok("self", "possible_selves")
+
+    def test_self_interest(self):
+        self.module_ok("self", "self_interest")
+
+    def test_self_verification(self):
+        self.module_ok("self", "self_verification")
+
+    def test_counts_and_sidecar(self):
+        self.assertEqual(self.out["counts"]["perception"], 8)
+        self.assertEqual(self.out["counts"]["relationship"], 4)
+        self.assertEqual(self.out["counts"]["self"], 4)
+        doc = json.loads((self.data_dir / "signals.json").read_text(encoding="utf-8"))
+        self.assertEqual(doc["latest"]["session_id"], "s1")
+
+    def test_state_exposes_signals(self):
+        pipeline.dispatch("turn_start", {
+            "store": str(self.store), "session_id": "s1",
+            "user_text": "你好", "capture": False,
+            "persona_profile": str(Path(self.tmp.name) / "missing.json")})
+        body = pipeline.dispatch("state", {
+            "store": str(self.store), "session_id": "s1",
+            "persona_profile": str(Path(self.tmp.name) / "missing.json")})["state"]
+        self.assertIn("signals", body)
+        self.assertTrue(body["signals"]["enabled"]["metacog"])
+        self.assertEqual(body["signals"]["counts"]["self"], 4)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_runtime/extensions.py

@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+"""task-225 (5b): P0 memory extensions + expression extensions for the core.
+
+Recall side (all optional, failure -> current lexical path):
+  entity_graph / entity_resolve / graph_extract / graph_recall  lightweight
+      entity graph over memory entries; query entities pull neighbour entries
+  layered_memory    resident vs retrieval tiers for the injected rows
+  memory_dual       decayed dual score for ordering
+  prospective       commitments in <dataDir>/prospective.json + due hints
+  reconstruction    reconstruction drift summary (read-only)
+  turn_memory       receipt rows for the last recall batch
+
+Expression side (wording constraints only; never changes facts):
+  expr_template, prompt_rules, template_expr, topic_control, voice_bank
+
+No LLM calls. All sidecar writes are atomic and bounded.
+"""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+from biocore_model import (entity_graph as _graph,
+                           entity_resolve as _resolve,
+                           graph_extract as _extract,
+                           layered_memory as _layered,
+                           memory_dual as _dual,
+                           prospective as _prospective,
+                           reconstruction as _reconstruct,
+                           turn_memory as _turn_memory,
+                           expr_template as _expr_template,
+                           prompt_rules as _prompt_rules,
+                           template_expr as _template,
+                           topic_control as _topic,
+                           voice_bank as _voice)
+
+PROSPECTIVE_FILE = "prospective.json"
+EXTENSIONS_FILE = "extensions.json"
+VOICE_FILE = "voice_bank.json"
+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)
+    return (root.parent if root.name == "memory" else root) if root else None
+
+
+def _read(path, fallback):
+    try:
+        if path is None or not Path(path).exists():
+            return fallback
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else fallback
+    except Exception:
+        return fallback
+
+
+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 _tokens(text):
+    import re
+    lowered = str(text or "").lower()
+    out = re.findall(r"[a-z0-9_]{3,}", lowered)
+    for run in re.findall(r"[\u4e00-\u9fff]+", lowered):
+        out.extend(run[index:index + 2] for index in range(len(run) - 1))
+    return out
+
+
+def _entity_graph(entries):
+    """Tiny in-memory graph: every concept token is a node, co-occurrence an edge."""
+    graph = _graph.empty_graph()
+    names = {}
+    for entry in entries or []:
+        if not isinstance(entry, dict):
+            continue
+        tokens = list(dict.fromkeys(_tokens(entry.get("text"))))
+        for token in tokens[:12]:
+            names.setdefault(token, entry)
+        for left in tokens[:8]:
+            for right in tokens[:8]:
+                if left == right:
+                    continue
+                try:
+                    updated = _graph.upsert_edge(
+                        graph, left, right, "co_occurs",
+                        ts=float(entry.get("ts") or 0.0))
+                    graph = updated[0] if isinstance(updated, tuple) else updated
+                except Exception:
+                    pass
+    for token in names:
+        try:
+            updated = _graph.upsert_entity(graph, token, "topic")
+            graph = updated[0] if isinstance(updated, tuple) else updated
+        except Exception:
+            pass
+    return graph, names
+
+
+def graph_hits(entries, query, exclude=None):
+    """Neighbour entry ids for the query's entities (graph recall)."""
+    exclude = set(exclude or [])
+    graph, by_name = _entity_graph(entries)
+    hits = []
+    seen = set()
+    try:
+        matches = _graph.search(graph, query, limit=6)
+    except Exception:
+        matches = []
+    for item in matches or []:
+        name = item.get("name") if isinstance(item, dict) else item
+        entry = by_name.get(str(name or ""))
+        entry_id = str((entry or {}).get("id") or "")
+        if entry_id and entry_id not in exclude and entry_id not in seen:
+            seen.add(entry_id)
+            hits.append(entry)
+    stats = {"entities": len(graph.get("entities") or []),
+             "edges": len(graph.get("edges") or []),
+             "hits": len(hits)}
+    try:
+        stats.update(_graph.stats(graph))
+    except Exception:
+        pass
+    return hits, stats
+
+
+def expand_recall(store, entries, query, picked_ids, now=None):
+    """Add graph neighbours / dual-score rows; never raises."""
+    stamp = float(now or time.time())
+    picked_ids = [str(item) for item in (picked_ids or [])]
+    hits, graph_stats = graph_hits(entries, query, exclude=picked_ids)
+    extra = []
+    for entry in hits[:3]:
+        if str(entry.get("id") or "") not in picked_ids:
+            extra.append(entry)
+    dual_rows = []
+    try:
+        ordered = _dual.select(entries, stamp, limit=max(4, len(picked_ids) + 2))
+        dual_rows = [entry for entry in ordered
+                     if str(entry.get("id") or "") not in picked_ids]
+    except Exception:
+        dual_rows = []
+    for entry in dual_rows[:2]:
+        if entry not in extra:
+            extra.append(entry)
+    return {
+        "extra": extra,
+        "graph": graph_stats,
+        "dual": {"rows": len(dual_rows)},
+    }
+
+
+def layered_view(entries, picked_ids):
+    try:
+        result = _layered.select(entries, recalled_ids=picked_ids) or {}
+    except Exception:
+        result = {}
+    resident = result.get("resident") or []
+    retrieval = result.get("retrieval") or []
+    return {"selected": len(resident) + len(retrieval),
+            "resident": len(resident), "retrieval": len(retrieval)}
+
+
+def prospective_view(store, now=None):
+    data_dir = _data_dir(store)
+    path = (data_dir / PROSPECTIVE_FILE) if data_dir else None
+    doc = _read(path, {"items": []})
+    items = [row for row in (doc.get("items") or []) if isinstance(row, dict)]
+    stamp = float(now or time.time())
+    due = []
+    try:
+        due = _prospective.due_now(items, stamp, window_s=3600.0)
+    except Exception:
+        due = []
+    hint = ""
+    if due:
+        try:
+            hint = _prospective.build_hint(due[0], stamp)
+        except Exception:
+            hint = ""
+    return {"pending": len([row for row in items
+                            if row.get("status") in ("pending", "overdue")]),
+            "due": len(due), "hint": str(hint or "")[:80]}
+
+
+def add_commitment(store, text, due_ts, now=None, kind="his_event"):
+    data_dir = _data_dir(store)
+    path = (data_dir / PROSPECTIVE_FILE) if data_dir else None
+    if path is None:
+        return None
+    doc = _read(path, {"items": []})
+    items = [row for row in (doc.get("items") or []) if isinstance(row, dict)]
+    try:
+        record = _prospective.entry(kind, text, due_ts, now=now)
+        items, changed = _prospective.add(items, record)
+    except Exception:
+        return None
+    doc.update({"schema": SCHEMA, "items": items[-200:],
+                "updated_at": round(float(now or time.time()), 3)})
+    _write(path, doc)
+    return record if changed else None
+
+
+def reconstruction_view(entries):
+    try:
+        result = _reconstruct.conserve(entries) or {}
+    except Exception:
+        return {"drift": 0.0}
+    return {"drift": round(float(result.get("total") or 0.0), 4),
+            "scale": result.get("scale", 1.0)}
+
+
+def turn_memory_view(trace_rows, reply="", now=None):
+    try:
+        rows = _turn_memory.build(trace_rows)
+        record = _turn_memory.build_record(rows, reply=reply,
+                                           ts=float(now or time.time()))
+        receipt = _turn_memory.render_receipt(record)
+    except Exception:
+        rows, record, receipt = [], {}, ""
+    return {"rows": rows, "receipt": str(receipt or "")[:120],
+            "record": record}
+
+
+def expression_block(store=None, state=None, relationship=None,
+                     soft_target=0, soft_max=0, hour=None):
+    """Wording constraints from the expression P0 modules."""
+    core = (state or {}).get("core") if isinstance(state, dict) else {}
+    core = core if isinstance(core, dict) else {}
+    affect = {"valence": float(core.get("v") or 0.0),
+              "arousal": float(core.get("a") or 0.5),
+              "stress": float(core.get("stress") or 0.2)}
+    rel = relationship if isinstance(relationship, dict) else {}
+    out = {"rules": "", "template": "", "topic": "", "voice": "",
+           "template_name": "default", "topic_name": "", "voice_name": ""}
+    try:
+        out["rules"] = _prompt_rules.render_rules(
+            affect=affect, relation=rel, certainty=0.7,
+            soft_target=int(soft_target or 0), soft_max=int(soft_max or 0))
+    except Exception:
+        out["rules"] = ""
+    try:
+        built = _expr_template.build_reply({}, rel)
+        out["expr_template_order"] = [str(item) for item in
+                                      (built.get("order") or [])][:8]
+    except Exception:
+        out["expr_template_order"] = []
+    try:
+        rendered = _template.render(
+            "{{# if tense}}稳一点说。{{/ if}}{{closing}}",
+            {"tense": float(core.get("stress") or 0.0) >= 0.6,
+             "closing": "不用急着答。"})
+        out["template"] = str(rendered or "")
+        out["template_name"] = "reply-soft"
+    except Exception:
+        out["template"] = ""
+    try:
+        topic = _topic.topic_control(turns=[], state=affect, relationship=rel,
+                                     hour=hour)
+        out["topic"] = str((_topic.directives(topic) or {}).get("tone") or "")
+        out["topic_name"] = str((topic or {}).get("tendency")
+                                or (topic or {}).get("holder") or "")
+    except Exception:
+        out["topic"] = ""
+    try:
+        data_dir = _data_dir(store)
+        bank = _read((data_dir / VOICE_FILE) if data_dir else None,
+                     {"entries": []})
+        entries = [row for row in (bank.get("entries") or [])
+                   if isinstance(row, dict)]
+        picked = _voice.pick({"v": affect["valence"], "tension": affect["stress"]},
+                             rel, [], float(time.time()), entries=entries)
+        if picked:
+            out["voice"] = str(picked[0].get("phrase") or "")[:40]
+            out["voice_name"] = str(picked[0].get("id") or "voice")[:24]
+    except Exception:
+        out["voice"] = ""
+    return out
+
+
+def record_extension_snapshot(store, snapshot):
+    data_dir = _data_dir(store)
+    path = (data_dir / EXTENSIONS_FILE) if data_dir else None
+    if path is None:
+        return False
+    doc = _read(path, {})
+    doc.update({"schema": SCHEMA, "ts": round(float(time.time()), 3),
+                "latest": snapshot,
+                "history": ((doc.get("history") or [])
+                            + [snapshot])[-50:]})
+    return _write(path, doc)
+
+
+def extension_summary(store):
+    data_dir = _data_dir(store)
+    doc = _read((data_dir / EXTENSIONS_FILE) if data_dir else None, {})
+    latest = doc.get("latest") if isinstance(doc.get("latest"), dict) else {}
+    return latest