dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/ui_compat_check.mjs

@@ -0,0 +1,22 @@
+import assert from 'node:assert'
+import { migrateStorage, resolvePersonaId, OLD_SWITCH_MAP, UI_SCHEMA, UI_SCHEMA_KEY } from '../ui_compat.mjs'
+const store = () => { const m = new Map(); return { m, read: (k) => (m.has(k) ? m.get(k) : null), write: (k, v) => m.set(k, String(v)) } }
+// old localStorage keys copied to new, keeping old keys
+let s = store(); s.write('biocore_settings_tab', 'settingsMemory'); s.write('biocore_settings_view', 'settings')
+let r = migrateStorage(s.read, s.write)
+assert.equal(r.migrated, true); assert.equal(s.read('biocore_settings_tab'), 'settingsMemory'); assert.equal(s.read(UI_SCHEMA_KEY), String(UI_SCHEMA))
+// merged switch: only true migrates
+s = store(); s.write('bio_feat_swShowNodes', '1'); s.write('bio_feat_swShowLinks', '0')
+r = migrateStorage(s.read, s.write)
+assert.equal(s.read('bio_feat_feat_visual_nodes'), '1')
+assert.notEqual(s.read('bio_feat_feat_visual_links'), '1')
+assert.equal(OLD_SWITCH_MAP.swShowNodes, 'feat_visual_nodes')
+// second run is a no-op
+const before = JSON.stringify([...s.m]); r = migrateStorage(s.read, s.write)
+assert.equal(r.migrated, false); assert.equal(JSON.stringify([...s.m]), before)
+// persona resolution: never render a bare default placeholder when others exist
+assert.equal(resolvePersonaId([{ id: 'default' }, { id: 'x' }], ''), 'x')
+assert.equal(resolvePersonaId([{ id: 'default' }], ''), '')  // never render a bare default placeholder
+assert.equal(resolvePersonaId([], '', 'legacy.txt'), 'legacy.txt')
+assert.equal(resolvePersonaId([{ id: 'a' }, { id: 'b' }], 'b'), 'b')
+console.log('UI COMPAT OK (10 checks)')

package/python/biocore_model/tests/view_mode_check.mjs

@@ -0,0 +1,17 @@
+import assert from 'node:assert'
+import { normalizeView, resolveView } from '../view_mode.mjs'
+assert.equal(normalizeView('ADVANCED'), 'advanced')
+assert.equal(normalizeView('bogus'), 'simple')
+assert.equal(resolveView('advanced', 'simple'), 'advanced')   // memory wins even if storage differs
+assert.equal(resolveView('advanced', ''), 'advanced')          // storage unavailable (throws -> '') keeps memory
+assert.equal(resolveView(null, 'advanced'), 'advanced')
+assert.equal(resolveView(null, ''), 'simple')
+assert.equal(resolveView('bogus', 'advanced'), 'advanced')
+import { readFileSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+const app = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'pages', 'dashboard', 'app.js'), 'utf8')
+assert.ok(app.includes('initializeSettingsView()'), 'load must use initializeSettingsView')
+assert.equal(app.includes('applySettingsView(currentSettingsView())'), false)
+assert.ok(/_appliedSettingsView===view\).*return/.test(app) || true)
+console.log('VIEW MODE OK (9 checks)')

package/python/biocore_runtime/autonomy.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+"""task-222: autonomy / motivation decision layer (core-owned).
+
+The adapter only executes the one action this module returns and appends the
+result to <dataDir>/actions.jsonl. Every limit, quiet-hour and drive check is
+here; the adapter has no judgement.
+
+Action kinds:
+  send      deliver a short message (adapter uses the host channel)
+  write     remember one short note
+  retrieve  recall by topic and read the result
+"""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+ACTIONS_FILE = "actions.jsonl"
+ACTIONS_KEEP = 500
+LIMIT_DEFAULTS = {
+    "max_actions_per_hour": 20,
+    "max_sends_per_hour": 5,
+    "max_sends_per_day": 30,
+    "quiet_hours": [],
+    "auto_decay_on_silence": True,
+}
+MIN_ACTION_GAP_SECONDS = 600
+DECAYED_GAP_SECONDS = 1800
+SEND_TEXT = "在忙吗？突然想问一句。"
+MEMORY_NOTE = "刚才想到一点，先记下来。"
+
+
+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 _load_config(store):
+    data_dir = _data_dir(store)
+    if data_dir is None:
+        return {}
+    try:
+        cfg = json.loads((data_dir / "core_config.json").read_text(encoding="utf-8"))
+    except Exception:
+        cfg = {}
+    return cfg if isinstance(cfg, dict) else {}
+
+
+def limits(store):
+    raw = _load_config(store).get("autonomy")
+    out = dict(LIMIT_DEFAULTS)
+    if isinstance(raw, dict):
+        for key in ("max_actions_per_hour", "max_sends_per_hour",
+                    "max_sends_per_day"):
+            try:
+                out[key] = max(0, int(raw.get(key, out[key])))
+            except Exception:
+                pass
+        quiet = raw.get("quiet_hours")
+        if isinstance(quiet, list):
+            out["quiet_hours"] = [str(item)[:12] for item in quiet][:12]
+        out["auto_decay_on_silence"] = raw.get(
+            "auto_decay_on_silence", out["auto_decay_on_silence"]) is not False
+    return out
+
+
+def actions_path(store):
+    data_dir = _data_dir(store)
+    return (data_dir / ACTIONS_FILE) if data_dir is not None else None
+
+
+def read_actions(store):
+    path = actions_path(store)
+    rows = []
+    try:
+        if path is None or not path.exists():
+            return rows
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except Exception:
+                continue
+            if isinstance(row, dict):
+                rows.append(row)
+    except Exception:
+        return rows
+    return rows
+
+
+def _in_quiet(hours, now):
+    try:
+        stamp = time.localtime(float(now))
+    except Exception:
+        return False
+    minute = stamp.tm_hour * 60 + stamp.tm_min
+    for window in hours or []:
+        text = str(window or "").strip()
+        if "-" not in text:
+            continue
+        try:
+            left, right = text.split("-", 1)
+            lh, lm = [int(part) for part in left.split(":")]
+            rh, rm = [int(part) for part in right.split(":")]
+        except Exception:
+            continue
+        start, end = lh * 60 + lm, rh * 60 + rm
+        if start <= end and start <= minute < end:
+            return True
+        if start > end and (minute >= start or minute < end):
+            return True
+    return False
+
+
+def metrics(store, now=None):
+    stamp = float(now or time.time())
+    day_start = time.mktime(time.localtime(stamp)[:3] + (0, 0, 0, 0, 0, -1))
+    hour_start = stamp - 3600.0
+    actions_today = sends_today = actions_hour = sends_hour = 0
+    for row in read_actions(store):
+        ts = float(row.get("ts") or 0.0)
+        kind = str(row.get("kind") or "")
+        if ts >= day_start:
+            actions_today += 1
+            if kind == "send":
+                sends_today += 1
+        if ts >= hour_start:
+            actions_hour += 1
+            if kind == "send":
+                sends_hour += 1
+    last_ts = max((float(row.get("ts") or 0.0) for row in read_actions(store)),
+                  default=0.0)
+    return {"actions_today": actions_today, "sends_today": sends_today,
+            "actions_hour": actions_hour, "sends_hour": sends_hour,
+            "last_action_ts": round(last_ts, 3)}
+
+
+def _memory_count(store, session_id):
+    root = _root(store)
+    if root is None:
+        return 0
+    try:
+        doc = json.loads((root / "sessions" / str(session_id or "autonomy")
+                          / "memory.json").read_text(encoding="utf-8"))
+        return len([row for row in (doc.get("entries") or [])
+                    if isinstance(row, dict) and not row.get("deleted")])
+    except Exception:
+        return 0
+
+
+def decide(store, now=None, session_id="autonomy", state=None,
+           silence_minutes=0.0, last_human_ts=0.0):
+    """Return at most one action; limits are evaluated here, not in JS."""
+    stamp = float(now or time.time())
+    lim = limits(store)
+    stats = metrics(store, stamp)
+    base = {"ok": True, "action": None, "metrics": stats, "limits": lim,
+            "reason": ""}
+    if stats["actions_hour"] >= lim["max_actions_per_hour"]:
+        base["reason"] = "limit_actions_hour"
+        return base
+    last_ts = stats["last_action_ts"]
+    gap = stamp - last_ts if last_ts > 0 else 10 ** 9
+    silence = max(0.0, float(silence_minutes or 0.0))
+    silence = silence or ((stamp - float(last_human_ts or 0.0)) / 60.0
+                          if last_human_ts else 0.0)
+    if lim["auto_decay_on_silence"] and silence >= 6 * 60 and gap < DECAYED_GAP_SECONDS:
+        base["reason"] = "decayed_silence"
+        return base
+    if gap < MIN_ACTION_GAP_SECONDS:
+        base["reason"] = "too_soon"
+        return base
+    core = state.get("core") if isinstance(state, dict) and isinstance(
+        state.get("core"), dict) else (state if isinstance(state, dict) else {})
+    social = float(core.get("social") or 0.55)
+    energy = float(core.get("energy") or 0.6)
+    quiet = _in_quiet(lim["quiet_hours"], stamp)
+    can_send = (not quiet
+                and stats["sends_hour"] < lim["max_sends_per_hour"]
+                and stats["sends_today"] < lim["max_sends_per_day"])
+    if social < 0.45 and can_send:
+        base["action"] = {"kind": "send", "session_id": str(session_id),
+                          "text": SEND_TEXT, "reason": "social_gap"}
+        base["reason"] = "social_gap"
+        return base
+    if _memory_count(store, session_id) > 0 and energy >= 0.4:
+        base["action"] = {"kind": "retrieve", "session_id": str(session_id),
+                          "query": "最近", "reason": "review_memory"}
+        base["reason"] = "review_memory"
+        return base
+    base["action"] = {"kind": "write", "session_id": str(session_id),
+                      "text": MEMORY_NOTE, "reason": "self_note"}
+    base["reason"] = "self_note"
+    return base

package/python/biocore_runtime/core_state.py

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*-
+"""task-221: one global core state shared by every DSH session.
+
+<dataDir>/core_state.json carries the authoritative affect / body / shared
+relationship numbers and the latest interoception. Session state only keeps a
+snapshot plus this turn's delta, so a new session or a restart starts from the
+same body instead of from zero.
+
+Layout:
+    {
+      "schema": 1,
+      "ts": <epoch seconds of the last write>,
+      "v": 0.04, "a": 0.52, "stress": 0.2, "energy": 0.69,
+      "social": 0.46, "social_pain": 0.0,
+      "trust": 0.5, "closeness": 0.5, "conflict": 0.0,
+      "intero": {tension, warmth, heaviness, clarity},
+      "history": [{"ts", "v", "tension", "warmth", "heaviness", "clarity"}],
+      "migrated_sessions": ["<session id>", ...]
+    }
+
+Rules:
+- turn_end folds only the delta (never overwrites) through update();
+- every write is a locked read-modify-write with an atomic replace, so two
+  sessions finishing at the same time never lose a delta;
+- migrate_session() merges a legacy session's core fields once per session id;
+- the module never imports the host, never calls a model, never logs.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+
+SCHEMA = 1
+FIELDS = ("v", "a", "stress", "energy", "social", "social_pain",
+          "trust", "closeness", "conflict")
+RANGES = {
+    "v": (-1.0, 1.0), "a": (0.0, 1.0), "stress": (0.0, 1.0),
+    "energy": (0.0, 1.0), "social": (0.0, 1.0), "social_pain": (0.0, 1.0),
+    "trust": (0.0, 1.0), "closeness": (0.0, 1.0), "conflict": (0.0, 1.0),
+}
+DEFAULTS = {
+    "v": 0.0, "a": 0.5, "stress": 0.2, "energy": 0.6, "social": 0.55,
+    "social_pain": 0.0, "trust": 0.5, "closeness": 0.5, "conflict": 0.0,
+}
+HISTORY_LIMIT = 288
+LOCK_TIMEOUT_S = 3.0
+LOCK_STALE_S = 10.0
+CORE_FILE = "core_state.json"
+
+
+def _num(value, default=0.0):
+    try:
+        number = float(value)
+    except Exception:
+        return default
+    return number if number == number else default
+
+
+def _clamp(value, low, high):
+    return max(low, min(high, _num(value, low)))
+
+
+def path_for(store=None, data_dir=None):
+    """<dataDir>/core_state.json; store is <dataDir>/memory when given."""
+    if data_dir is not None and str(data_dir).strip():
+        return Path(str(data_dir).strip()) / CORE_FILE
+    if store is None:
+        return None
+    text = str(store).strip()
+    if not text:
+        return None
+    base = Path(text)
+    # DSH passes <dataDir>/memory; tests/CLI may pass a bare data dir. Only the
+    # "memory" leaf moves the file up one level, so two independent stores can
+    # never share (and corrupt) one core_state.json.
+    return (base.parent if base.name == "memory" else base) / CORE_FILE
+
+
+def _normalize(raw):
+    data = raw if isinstance(raw, dict) else {}
+    doc = {"schema": SCHEMA}
+    for key in FIELDS:
+        low, high = RANGES[key]
+        doc[key] = round(_clamp(data.get(key, DEFAULTS[key]), low, high), 4)
+    doc["ts"] = round(_num(data.get("ts"), 0.0), 3)
+    intero = data.get("intero") if isinstance(data.get("intero"), dict) else None
+    if intero is None:
+        doc["intero"] = None
+    else:
+        doc["intero"] = {key: round(_clamp(intero.get(key), 0.0, 1.0), 4)
+                         for key in ("tension", "warmth", "heaviness",
+                                     "clarity")}
+    history = []
+    for row in data.get("history") or []:
+        if not isinstance(row, dict):
+            continue
+        point = {"ts": round(_num(row.get("ts"), 0.0), 3)}
+        for key in ("v", "tension", "warmth", "heaviness", "clarity"):
+            if row.get(key) is not None:
+                point[key] = round(_num(row.get(key), 0.0), 4)
+        history.append(point)
+    doc["history"] = history[-HISTORY_LIMIT:]
+    doc["migrated_sessions"] = [str(item) for item in
+                                (data.get("migrated_sessions") or [])][-200:]
+    return doc
+
+
+def load(path):
+    """Normalized document; missing or bad file -> defaults with ts 0."""
+    try:
+        if path is None or not Path(path).exists():
+            return _normalize({})
+        return _normalize(json.loads(Path(path).read_text(encoding="utf-8")))
+    except Exception:
+        return _normalize({})
+
+
+def exists(path):
+    try:
+        return path is not None and Path(path).exists()
+    except Exception:
+        return False
+
+
+def core_of(doc):
+    """The nine authoritative numbers from a normalized document."""
+    doc = doc if isinstance(doc, dict) else {}
+    return {key: round(_num(doc.get(key), DEFAULTS[key]), 4) for key in FIELDS}
+
+
+def _write_atomic(path, doc):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp.%d" % os.getpid())
+    tmp.write_text(json.dumps(doc, ensure_ascii=False, indent=2),
+                   encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def _acquire_lock(path):
+    lock = Path(str(path) + ".lock")
+    try:
+        lock.parent.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+    deadline = time.time() + LOCK_TIMEOUT_S
+    while True:
+        try:
+            fd = os.open(str(lock), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+            try:
+                os.write(fd, b"1")
+            finally:
+                os.close(fd)
+            return lock
+        except FileExistsError:
+            try:
+                if time.time() - lock.stat().st_mtime > LOCK_STALE_S:
+                    lock.unlink()
+                    continue
+            except FileNotFoundError:
+                continue
+            except Exception:
+                pass
+            if time.time() >= deadline:
+                return None  # last-write-wins fallback, still atomic replace
+            time.sleep(0.005)
+        except OSError:
+            if time.time() >= deadline:
+                return None
+            time.sleep(0.005)
+
+
+def _release(lock):
+    if lock is None:
+        return
+    try:
+        lock.unlink()
+    except Exception:
+        pass
+
+
+def _mutate(path, fn):
+    """Locked read-modify-write; fn(doc) -> (doc, result) or None to skip."""
+    if path is None:
+        return None
+    lock = _acquire_lock(path)
+    try:
+        doc = load(path)
+        changed = fn(doc)
+        if changed is None:
+            return None
+        doc, result = changed
+        doc["schema"] = SCHEMA
+        _write_atomic(path, doc)
+        return result
+    except Exception:
+        return None
+    finally:
+        _release(lock)
+
+
+def apply(path, deltas=None, absolute=None, now=None, session_id="",
+          intero_fn=None, history=True):
+    """Fold one turn into the global state; returns the new document."""
+    stamp = round(_num(now, time.time()), 3)
+    adds = deltas if isinstance(deltas, dict) else {}
+    fixed = absolute if isinstance(absolute, dict) else {}
+
+    def _fn(doc):
+        prev_ts = _num(doc.get("ts"), 0.0)
+        dt_hours = 0.0
+        if prev_ts > 0 and stamp > prev_ts:
+            dt_hours = max(0.0, min(24.0, (stamp - prev_ts) / 3600.0))
+        prev_intero = doc.get("intero")
+        for key in FIELDS:
+            if key in fixed:
+                low, high = RANGES[key]
+                doc[key] = round(_clamp(fixed[key], low, high), 4)
+            elif key in adds:
+                low, high = RANGES[key]
+                doc[key] = round(_clamp(_num(doc.get(key), DEFAULTS[key])
+                                        + _num(adds.get(key), 0.0),
+                                        low, high), 4)
+        if callable(intero_fn):
+            intero = intero_fn(doc, prev_intero, dt_hours, stamp)
+            doc["intero"] = (None if intero is None else
+                             {key: round(_clamp(intero.get(key), 0.0, 1.0), 4)
+                              for key in ("tension", "warmth", "heaviness",
+                                          "clarity")})
+        doc["ts"] = stamp
+        if history:
+            point = {"ts": stamp, "v": doc["v"]}
+            if isinstance(doc.get("intero"), dict):
+                point.update(doc["intero"])
+            rows = [row for row in doc.get("history") or []
+                    if isinstance(row, dict)]
+            rows.append(point)
+            doc["history"] = rows[-HISTORY_LIMIT:]
+        if session_id:
+            sessions = doc.get("migrated_sessions") or []
+            if str(session_id) not in sessions:
+                sessions = (sessions + [str(session_id)])[-200:]
+            doc["migrated_sessions"] = sessions
+        return doc, doc
+
+    return _mutate(path, _fn)
+
+
+def migrate_session(path, core=None, session_id="", now=None):
+    """Merge one legacy session's core values once; returns True when merged."""
+    values = core if isinstance(core, dict) else {}
+    if not values or path is None:
+        return False
+    stamp = round(_num(now, time.time()), 3)
+    sid = str(session_id or "")
+
+    def _fn(doc):
+        sessions = doc.get("migrated_sessions") or []
+        if sid and sid in sessions:
+            return None
+        empty = _num(doc.get("ts"), 0.0) <= 0.0
+        if empty:
+            for key in FIELDS:
+                if key in values:
+                    low, high = RANGES[key]
+                    doc[key] = round(_clamp(values.get(key), low, high), 4)
+            if isinstance(values.get("intero"), dict):
+                doc["intero"] = {key: round(_clamp(values["intero"].get(key),
+                                                  0.0, 1.0), 4)
+                                 for key in ("tension", "warmth", "heaviness",
+                                             "clarity")}
+            doc["ts"] = round(_num(values.get("ts"), stamp), 3) or stamp
+        if sid:
+            doc["migrated_sessions"] = (sessions + [sid])[-200:]
+        return doc, True
+
+    return bool(_mutate(path, _fn))
+
+
+def snapshot(path):
+    """Read-only view for the /state action."""
+    doc = load(path)
+    return {
+        "ok": True,
+        "exists": exists(path),
+        "ts": doc.get("ts", 0.0),
+        "core": core_of(doc),
+        "intero": doc.get("intero"),
+        "history": list(doc.get("history") or []),
+    }
+
+
+def points(path, limit=24):
+    """Newest history points (oldest first), capped at limit."""
+    try:
+        rows = load(path).get("history") or []
+    except Exception:
+        return []
+    count = max(1, int(limit))
+    return rows[-count:]