diff --git a/_conf_schema.json b/_conf_schema.json index 7d6702c..3b6d999 100644 --- a/_conf_schema.json +++ b/_conf_schema.json @@ -821,6 +821,12 @@ "type": "int", "default": 5000 }, + "enabled": { + "description": "启用 LivingMemory 兼容迁移", + "hint": "仅控制 LivingMemory 预览/导入兼容路径,不控制 MemoryCompanion Bridge 或普通聊天记忆。", + "type": "bool", + "default": true + }, "livingmemory_db_path": { "description": "LivingMemory 数据库路径", "hint": "留空则自动扫描常见位置。建议先执行 /mcomp import_livingmemory preview。", diff --git a/core/bot_personal_contract.py b/core/bot_personal_contract.py new file mode 100644 index 0000000..8e82778 --- /dev/null +++ b/core/bot_personal_contract.py @@ -0,0 +1,270 @@ +# -*- coding: utf-8 -*- +"""跨插件共享合同:Bot 个人归档 + 日程分级(陪伴分支) + +⚠️ 这个文件在两个插件里**各有一份,必须逐字相同**: + 陪伴插件:astrbot_plugin_private_companion/bot_personal_contract.py + 记忆插件:astrbot_plugin_memory_companion/core/bot_personal_contract.py + 权威副本在 peiban/doc/shared/bot_personal_contract.py。 + + 两个插件是独立的 AstrBot 插件包,互相不能 import,所以「共享常量」只能靠 + 「同一份文件复制两份 + 启动时指纹互校」来保证。任何改动必须同时满足三条: + + ① 两侧同一次提交(不允许一侧先合) + ② 升 CONTRACT_REVISION + ③ 重算并更新 CONTRACT_FINGERPRINT(python bot_personal_contract.py 会打印) + + 只依赖标准库。不要在这里 import 任何插件内部模块,否则复制到对侧会炸。 + +修改规则与背景见:peiban/doc/跨插件共享合同.md +""" +from __future__ import annotations + +import hashlib +import json + +CONTRACT_NAME = "bot_personal_archive" +CONTRACT_REVISION = 1 + +# --------------------------------------------------------------------------- +# 一、日程分级(原「四段」→ 陪伴分支五段) +# +# 这是**唯一定义源**。两侧任何地方需要窗口划分,都必须从这张表派生,不允许再写 +# 第二份硬编码——OPS 分支就是因为存在四份互不派生的副本,改一处改不动全部。 +# +# 边界与原版已持久化的主动配额桶(user["proactive_daypart_counts"], +# constants.py:489)完全对齐,所以「日程窗口」与「主动配额桶」共享切点, +# 但**仍是两套独立存储**:配额桶是计数器,窗口是快照/归档的维度,不要合并。 +# +# 字段:(slug, 中文名, 起始分钟, 结束分钟)。结束分钟 <= 起始分钟表示跨午夜。 +# --------------------------------------------------------------------------- +SCHEDULE_WINDOWS: tuple[tuple[str, str, int, int], ...] = ( + ("late_night", "深夜", 21 * 60, 6 * 60), # 21:00 - 次日 06:00 + ("morning", "早晨", 6 * 60, 11 * 60), # 06:00 - 11:00 + ("noon", "中午", 11 * 60, 14 * 60 + 30), # 11:00 - 14:30 + ("afternoon", "下午", 14 * 60 + 30, 18 * 60), # 14:30 - 18:00 + ("evening", "晚上", 18 * 60, 21 * 60), # 18:00 - 21:00 +) + +WINDOW_SLUGS: tuple[str, ...] = tuple(item[0] for item in SCHEDULE_WINDOWS) +WINDOW_NAMES: tuple[str, ...] = tuple(item[1] for item in SCHEDULE_WINDOWS) +WINDOW_SLUG_BY_NAME: dict[str, str] = {item[1]: item[0] for item in SCHEDULE_WINDOWS} +WINDOW_NAME_BY_SLUG: dict[str, str] = {item[0]: item[1] for item in SCHEDULE_WINDOWS} + +# 记忆侧 validate_bot_personal_envelope 用它做**硬校验**:不在集合里 → invalid_window, +# 归档静默失败。所以它必须由上表派生,不能手写。 +BOT_PERSONAL_WINDOWS = frozenset(WINDOW_SLUGS) + +# LLM 与用户口语里的窗口别名 → slug。只做输入归一,不参与判定。 +WINDOW_ALIASES: dict[str, str] = { + "深夜": "late_night", "凌晨": "late_night", "半夜": "late_night", "夜里": "late_night", + "早晨": "morning", "早上": "morning", "清晨": "morning", "上午": "morning", + "中午": "noon", "正午": "noon", "午间": "noon", "晌午": "noon", + "下午": "afternoon", + "晚上": "evening", "傍晚": "evening", "晚间": "evening", +} + +# 旧四段(OPS 22/06/12/18)→ 新五段的迁移映射。 +# 值为 None 表示「靠窗口名判不出来,必须看时间戳」,见 migrate_legacy_window()。 +LEGACY_WINDOW_MIGRATION: dict[str, str | None] = { + "late_night": "late_night", # 旧 22:00-06:00 ⊂ 新 21:00-06:00,可直接沿用 + "morning": None, # 旧 06:00-12:00 → 新 morning(06-11) + noon(11-12) + "afternoon": None, # 旧 12:00-18:00 → 新 noon(12-14:30) + afternoon(14:30-18) + "evening": None, # 旧 18:00-22:00 → 新 evening(18-21) + late_night(21-22) +} + + +def window_for_minutes(minutes: int) -> str: + """把「当日分钟数」归入窗口 slug。跨午夜的窗口拆成两截判定。 + + 这是**唯一判定实现**。带日期的判定(跨午夜时 window_date 归属哪一天)留在 + 陪伴侧 agenda_contracts.window_for_datetime,但它必须调用本函数取窗口名, + 不允许自己再判一次阈值。 + """ + try: + value = int(minutes) % (24 * 60) + except (TypeError, ValueError): + return "" + for slug, _name, start, end in SCHEDULE_WINDOWS: + if start < end: + if start <= value < end: + return slug + elif value >= start or value < end: + return slug + return "" + + +def normalize_window(value: object) -> str: + """把窗口名/别名/slug 归一成 slug;无法识别返回空串(**不要猜**)。""" + text = str(value or "").strip() + if not text: + return "" + lowered = text.lower() + if lowered in BOT_PERSONAL_WINDOWS: + return lowered + return WINDOW_ALIASES.get(text, "") + + +def migrate_legacy_window(old_window: object, minutes: object = None) -> str: + """旧四段窗口值 → 新五段 slug。 + + 拿得到当日分钟数就按时间重算;拿不到且旧值本身不唯一对应新值时返回空串, + 调用方应当**按旧名保留、只读不重算**,不要猜——猜错会让历史快照的窗口归属 + 和它内部的时间戳自相矛盾。 + """ + old = normalize_window(old_window) or str(old_window or "").strip().lower() + if minutes is not None: + recomputed = window_for_minutes(minutes) + if recomputed: + return recomputed + return LEGACY_WINDOW_MIGRATION.get(old) or "" + + +# --------------------------------------------------------------------------- +# 二、Bot 个人归档域 +# +# memory_domain 保持 OPS 时期的取值 "bot_self_schedule":它描述的是「Bot 自有 +# 日程域」,不含运维语义,改名要同步两侧 7 处 + 存量数据迁移,收益为零。 +# --------------------------------------------------------------------------- +BOT_PERSONAL_MEMORY_DOMAIN = "bot_self_schedule" +BOT_PERSONAL_SUBJECT = "bot_self" +BOT_PERSONAL_SESSION_ID = "bot_personal" +BOT_PERSONAL_SCOPE = "private" +BOT_PERSONAL_VISIBILITY = "bot_self" +BOT_PERSONAL_MAX_PAYLOAD_BYTES = 16 * 1024 + +# payload 结构本身未变 → 保持 1.0。 +BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION = "1.0" +# 信封字段 window 的**值域**变了(四段→五段)→ 能力版本必升,且必须在能力探测里 +# 回传 windows,让调用方启动时就能发现两侧值域不一致,而不是等到归档 invalid_window。 +BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION = "1.1" + +BOT_PERSONAL_MEMORY_TYPES: tuple[str, ...] = ( + "bot_schedule_plan", + "bot_observed_activity", + "bot_schedule_reconciliation", + "bot_window_snapshot", + "bot_daily_diary", + "bot_creative_work", + "bot_media_memory", + "bot_subjective_memory", + "bot_shared_activity", + "bot_detail_fragment", + "bot_calendar_event", + "bot_proactive_message", +) + +# memory_type → (source_kind, 默认 evidence_level, 默认 status)。 +# 记忆侧一律用合同 source_kind 覆盖调用方上报值,所以两侧必须同表, +# 否则创作/梦境/日历会被标成「真实观察」。 +TYPE_CONTRACTS: dict[str, tuple[str, str, str]] = { + "bot_schedule_plan": ("planned", "L0", "planned"), + "bot_observed_activity": ("observed", "L2", "active"), + "bot_schedule_reconciliation": ("reconciled", "L3", "completed"), + "bot_window_snapshot": ("projection", "L2", "completed"), + "bot_daily_diary": ("subjective", "L1", "completed"), + "bot_creative_work": ("creative", "L1", "active"), + "bot_media_memory": ("media", "L1", "active"), + "bot_subjective_memory": ("subjective", "L1", "active"), + "bot_shared_activity": ("shared", "L1", "active"), + "bot_detail_fragment": ("detail", "L1", "active"), + "bot_calendar_event": ("calendar", "L1", "active"), + "bot_proactive_message": ("proactive", "L1", "active"), +} + +EVIDENCE_LEVELS: tuple[str, ...] = ("L0", "L1", "L2", "L3") + +# 幂等键前缀表。归档链路每条写入都要落在这些前缀之一下,方便对账与去重排查。 +# ⚠️ agenda_snapshot / reconciliation 两类的 id 内部含窗口 slug,改分级后新旧 key +# 不同源:**旧 key 不重写,新记录用新 slug**(见迁移策略)。 +IDEMPOTENCY_KEY_PREFIXES: tuple[str, ...] = ( + "agenda_snapshot", # agenda_snapshot:{snapshot_id} 含窗口 slug + "reconciliation", # reconciliation:{reconciliation_id} 含窗口 slug + "observed", # observed:{activity_id} + "daily_plan", # daily_plan:{date} + "detail", # detail:{date}:{start}:{end} + "diary", # diary:{date} + "calendar", # calendar:{event_id}:{action} + "proactive", # proactive:{user_id}:{action}:{content[:80]} + "creative", # creative:{project_id|title}:{chunks} + "photo", # photo:{media_id} + "daily_outfit", # daily_outfit:{date} + "dream", # dream:{text[:120]}:{mood} + "qzone", # qzone:{tid|content[:100]} ← 娱乐能力,陪伴分支保留 +) + + +def capability_descriptor(*, available: bool = True, read_only: bool = False) -> dict[str, object]: + """记忆侧 probe_bot_personal_memory_capabilities 的标准返回骨架。 + + windows / memory_types / contract_fingerprint 三个字段是给陪伴侧做启动自检用的: + 对不上就说明两侧合同文件漂移了,应当直接告警并停用归档,而不是带着不一致跑。 + """ + return { + "available": bool(available), + "read_only": bool(read_only), + "memory_domain": BOT_PERSONAL_MEMORY_DOMAIN, + "contract_name": CONTRACT_NAME, + "contract_revision": CONTRACT_REVISION, + "contract_fingerprint": CONTRACT_FINGERPRINT, + "capability_schema_version": BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION, + "payload_schema_version": BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION, + "windows": list(WINDOW_SLUGS), + "memory_types": list(BOT_PERSONAL_MEMORY_TYPES), + "max_payload_bytes": BOT_PERSONAL_MAX_PAYLOAD_BYTES, + "warnings": [], + } + + +def _fingerprint_source() -> str: + """参与指纹的只有**跨插件必须一致**的值。注释、别名表、辅助函数不参与—— + 别名只影响本地输入归一,两侧不一致不会造成数据不一致。""" + canonical = { + "contract_name": CONTRACT_NAME, + "contract_revision": CONTRACT_REVISION, + "windows": [[slug, name, start, end] for slug, name, start, end in SCHEDULE_WINDOWS], + "memory_domain": BOT_PERSONAL_MEMORY_DOMAIN, + "subject": BOT_PERSONAL_SUBJECT, + "session_id": BOT_PERSONAL_SESSION_ID, + "scope": BOT_PERSONAL_SCOPE, + "visibility": BOT_PERSONAL_VISIBILITY, + "max_payload_bytes": BOT_PERSONAL_MAX_PAYLOAD_BYTES, + "payload_schema_version": BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION, + "capability_schema_version": BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION, + "memory_types": list(BOT_PERSONAL_MEMORY_TYPES), + "type_contracts": {k: list(v) for k, v in TYPE_CONTRACTS.items()}, + "evidence_levels": list(EVIDENCE_LEVELS), + "idempotency_key_prefixes": list(IDEMPOTENCY_KEY_PREFIXES), + } + return json.dumps(canonical, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + + +def compute_contract_fingerprint() -> str: + return hashlib.sha256(_fingerprint_source().encode("utf-8")).hexdigest()[:16] + + +# 由 compute_contract_fingerprint() 生成。改了上面任何常量都要重跑本文件更新它。 +CONTRACT_FINGERPRINT = "5b8a97c1527dcc62" + + +def contract_self_check() -> list[str]: + """两侧启动时各自跑一遍,再互相比对 CONTRACT_FINGERPRINT。""" + problems: list[str] = [] + if CONTRACT_FINGERPRINT != compute_contract_fingerprint(): + problems.append("contract_fingerprint_stale: 常量改过但没重算指纹") + if len(set(WINDOW_SLUGS)) != len(WINDOW_SLUGS): + problems.append("duplicate_window_slug") + if set(TYPE_CONTRACTS) != set(BOT_PERSONAL_MEMORY_TYPES): + problems.append("type_contracts_out_of_sync") + covered = {window_for_minutes(m) for m in range(0, 24 * 60)} + if covered != set(WINDOW_SLUGS): + problems.append(f"window_coverage_gap: 未覆盖或多余 {covered ^ set(WINDOW_SLUGS)}") + for alias, slug in WINDOW_ALIASES.items(): + if slug not in BOT_PERSONAL_WINDOWS: + problems.append(f"alias_points_to_unknown_window: {alias}->{slug}") + return problems + + +if __name__ == "__main__": # pragma: no cover + print("CONTRACT_FINGERPRINT =", compute_contract_fingerprint()) + issues = contract_self_check() + print("self_check:", "OK" if not issues else issues) diff --git a/core/bridge.py b/core/bridge.py index d12e82d..4440597 100644 --- a/core/bridge.py +++ b/core/bridge.py @@ -4,6 +4,7 @@ from datetime import datetime, timezone from typing import Any from zoneinfo import ZoneInfo +from . import bot_personal_contract from .models import EntityRef, MemoryRecord, SessionContext, clean_text @@ -291,10 +292,141 @@ class MemoryCompanionBridge: return await self._plugin.tool_note_delete(event, memory_id, title=title) def coordination_status(self) -> dict[str, Any]: - getter = getattr(self._plugin, "companion_coordination_status", None) - if callable(getter): - return getter() - return {"available": True} + try: + getter = getattr(self._plugin, "companion_coordination_status", None) + except Exception: + return {"available": False, "state": "degraded", "degraded": True, "reason": "bridge_exception"} + if not callable(getter): + return {"available": False, "state": "degraded", "degraded": True, "reason": "method_missing"} + try: + result = getter() + except Exception as exc: + return {"available": False, "state": "degraded", "degraded": True, "reason": "bridge_exception", "error": str(exc)[:160]} + if not isinstance(result, dict): + return {"available": False, "state": "degraded", "degraded": True, "reason": "invalid_status"} + result = dict(result) + result.setdefault("available", True) + result.setdefault("state", "ready") + result.setdefault("degraded", False) + return result + + def probe_bot_personal_memory_capabilities(self) -> dict[str, Any]: + """Return a database-free capability snapshot for the bot-personal contract. + + The probe is intentionally based only on the shared contract module. It + must remain safe to call from ordinary chat paths even when the contract + is stale or the local module is otherwise malformed. + """ + try: + descriptor = bot_personal_contract.capability_descriptor( + available=True, + read_only=False, + ) + except Exception: + return self._degraded_personal_capability_probe("contract_descriptor_exception") + + if not isinstance(descriptor, dict): + return self._degraded_personal_capability_probe("contract_descriptor_invalid") + + result = dict(descriptor) + try: + problems = bot_personal_contract.contract_self_check() + except Exception: + return self._degraded_personal_capability_probe( + "contract_self_check_exception", + base=result, + ) + + if not isinstance(problems, list): + return self._degraded_personal_capability_probe( + "contract_self_check_invalid", + base=result, + ) + if problems: + warnings = ["contract_self_check_failed"] + known_codes = { + "contract_fingerprint_stale", + "duplicate_window_slug", + "type_contracts_out_of_sync", + "window_coverage_gap", + "alias_points_to_unknown_window", + } + for problem in problems: + code = str(problem).split(":", 1)[0] + if code in known_codes and code not in warnings: + warnings.append(code) + return self._degraded_personal_capability_probe( + "contract_self_check_failed", + base=result, + warnings=warnings, + ) + + result["available"] = True + result["state"] = "ready" + result["degraded"] = False + self._add_personal_capability_contract_aliases(result) + result.setdefault("warnings", []) + return result + + @staticmethod + def _add_personal_capability_contract_aliases(result: dict[str, Any]) -> dict[str, Any]: + """Expose stable C1 aliases without changing the shared contract copy.""" + + result.setdefault("domain", result.get("memory_domain", "")) + result.setdefault("domains", [result.get("memory_domain", "")]) + result.setdefault("profiles", ["bot_personal_archive"]) + result.setdefault( + "methods", + [ + "record_event", + "record_visible_turn", + "search", + "compose_injection", + "compose_context", + "remember", + "recall", + "probe_bot_personal_memory_capabilities", + ], + ) + result.setdefault("contract_version", str(result.get("contract_revision", ""))) + result.setdefault("schema_version", str(result.get("capability_schema_version", ""))) + return result + + @staticmethod + def _degraded_personal_capability_probe( + reason: str, + *, + base: dict[str, Any] | None = None, + warnings: list[str] | None = None, + ) -> dict[str, Any]: + result = { + "available": False, + "read_only": False, + "memory_domain": getattr(bot_personal_contract, "BOT_PERSONAL_MEMORY_DOMAIN", ""), + "contract_name": getattr(bot_personal_contract, "CONTRACT_NAME", ""), + "contract_revision": getattr(bot_personal_contract, "CONTRACT_REVISION", 0), + "contract_fingerprint": getattr(bot_personal_contract, "CONTRACT_FINGERPRINT", ""), + "capability_schema_version": getattr( + bot_personal_contract, "BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION", "" + ), + "payload_schema_version": getattr( + bot_personal_contract, "BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION", "" + ), + "windows": list(getattr(bot_personal_contract, "WINDOW_SLUGS", ())), + "memory_types": list(getattr(bot_personal_contract, "BOT_PERSONAL_MEMORY_TYPES", ())), + "max_payload_bytes": getattr(bot_personal_contract, "BOT_PERSONAL_MAX_PAYLOAD_BYTES", 0), + "warnings": [], + } + result.update(base or {}) + result.update( + { + "available": False, + "state": "degraded", + "degraded": True, + "warnings": list(warnings or [reason]), + } + ) + return MemoryCompanionBridge._add_personal_capability_contract_aliases(result) def get_token_usage_summary(self) -> dict[str, Any]: getter = getattr(self._plugin, "token_usage_summary", None) diff --git a/core/config.py b/core/config.py index 3569919..b032610 100644 --- a/core/config.py +++ b/core/config.py @@ -80,6 +80,30 @@ class ConfigView: def __init__(self, raw: Any): self.raw = raw or {} + def bridge_enabled(self) -> bool: + """MemoryCompanion Bridge is independent from LivingMemory migration.""" + marker = object() + explicit = self._get_exact("enable_memory_companion_bridge", marker) + if explicit is not marker: + return self._coerce_bool(explicit, True) + return self.bool("private_companion_bridge.enabled", True) + + def livingmemory_migration_enabled(self) -> bool: + """LivingMemory controls only preview/import compatibility paths.""" + return self.bool("livingmemory_migration.enabled", True) + + @staticmethod + def _coerce_bool(value: Any, default: bool = False) -> bool: + if isinstance(value, str): + normalized = value.strip().lower() + if normalized in {"1", "true", "yes", "on", "enabled"}: + return True + if normalized in {"0", "false", "no", "off", "disabled"}: + return False + if value is None: + return default + return bool(value) + def get(self, dotted: str, default: Any = None) -> Any: marker = object() value = self._get_exact(dotted, marker) diff --git a/core/service.py b/core/service.py index d28da0f..333bf44 100644 --- a/core/service.py +++ b/core/service.py @@ -3285,6 +3285,14 @@ class MemoryCompanionService: } async def import_livingmemory(self, *, configured_path: str = "") -> dict[str, Any]: + if not self.config.livingmemory_migration_enabled(): + return { + "imported": 0, + "skipped": 0, + "disabled": True, + "state": "local_only", + "reason": "livingmemory_migration_disabled", + } if self.config.bool("maintenance.backup_before_import", True): backup = self.store.backup(".before_livingmemory_import") logger.info("[MemoryCompanion] LivingMemory 导入前已备份数据库: %s", backup) @@ -6092,9 +6100,11 @@ class MemoryCompanionService: ) def companion_coordination_status(self) -> dict[str, Any]: - bridge_enabled = self.config.bool("private_companion_bridge.enabled", True) + bridge_enabled = self.config.bridge_enabled() return { "available": True, + "state": "ready" if bridge_enabled else "local_only", + "degraded": False, "schedule_fast_context": bridge_enabled and self.config.bool( "private_companion_bridge.schedule_fast_context_enabled", True, diff --git a/main.py b/main.py index 1b9f7d0..da83c1f 100644 --- a/main.py +++ b/main.py @@ -54,15 +54,24 @@ class MemoryCompanionPlugin(Star): data_dir=data_dir, ) self.memory_companion = MemoryCompanionBridge(self.service) + self.bot_personal_capabilities = self.memory_companion.probe_bot_personal_memory_capabilities() + if not self.bot_personal_capabilities.get("available", False): + logger.warning( + "[MemoryCompanion] Bot Personal capability probe degraded: %s", + ";".join(str(item) for item in self.bot_personal_capabilities.get("warnings", [])), + ) self.commands = MemoryCompanionCommandHandler(self.service, PLUGIN_VERSION) self.page_api = None global _ACTIVE_BRIDGE - _ACTIVE_BRIDGE = self.memory_companion if self.service.config.bool("private_companion_bridge.enabled", True) else None + _ACTIVE_BRIDGE = self.memory_companion if self.service.config.bridge_enabled() else None self._register_page_api_if_available() logger.info("[MemoryCompanion] 我会牢牢记住你 已启动,数据目录=%s", self.service.data_dir) + def bot_personal_capability_status(self) -> dict[str, Any]: + return dict(self.bot_personal_capabilities) + def _register_page_api_if_available(self) -> None: if not hasattr(self.context, "register_web_api"): return diff --git a/tests/test_c1_bridge_probe.py b/tests/test_c1_bridge_probe.py new file mode 100644 index 0000000..6230d49 --- /dev/null +++ b/tests/test_c1_bridge_probe.py @@ -0,0 +1,69 @@ +from __future__ import annotations + +import sys +import types +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +if "astrabot_plugin_remember_you" not in sys.modules: + package = types.ModuleType("astrabot_plugin_remember_you") + package.__path__ = [str(ROOT)] + sys.modules["astrabot_plugin_remember_you"] = package +if str(ROOT.parent) not in sys.path: + sys.path.insert(0, str(ROOT.parent)) + +from astrabot_plugin_remember_you.core import bot_personal_contract +from astrabot_plugin_remember_you.core.bridge import MemoryCompanionBridge + + +class _PluginMustNotBeTouched: + def __getattr__(self, name: str): + raise AssertionError(f"probe touched plugin capability: {name}") + + +def test_probe_returns_ready_contract_snapshot_without_plugin_or_database_access(): + result = MemoryCompanionBridge(_PluginMustNotBeTouched()).probe_bot_personal_memory_capabilities() + + assert result["available"] is True + assert result["read_only"] is False + assert result["state"] == "ready" + assert result["degraded"] is False + assert result["warnings"] == [] + assert result["memory_domain"] == bot_personal_contract.BOT_PERSONAL_MEMORY_DOMAIN + assert result["contract_name"] == bot_personal_contract.CONTRACT_NAME + assert result["contract_revision"] == bot_personal_contract.CONTRACT_REVISION + assert result["contract_fingerprint"] == bot_personal_contract.CONTRACT_FINGERPRINT + assert result["capability_schema_version"] == bot_personal_contract.BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION + assert result["payload_schema_version"] == bot_personal_contract.BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION + assert result["windows"] == list(bot_personal_contract.WINDOW_SLUGS) + assert result["memory_types"] == list(bot_personal_contract.BOT_PERSONAL_MEMORY_TYPES) + assert result["max_payload_bytes"] == bot_personal_contract.BOT_PERSONAL_MAX_PAYLOAD_BYTES + + +def test_probe_returns_stable_degraded_shape_when_contract_self_check_fails(monkeypatch): + monkeypatch.setattr(bot_personal_contract, "contract_self_check", lambda: ["contract_fingerprint_stale: hidden"]) + + result = MemoryCompanionBridge(_PluginMustNotBeTouched()).probe_bot_personal_memory_capabilities() + + assert result["available"] is False + assert result["state"] == "degraded" + assert result["degraded"] is True + assert "contract_self_check_failed" in result["warnings"] + assert "contract_fingerprint_stale" in result["warnings"] + assert "hidden" not in result["warnings"] + + +def test_probe_converts_contract_check_exception_to_degraded_result(monkeypatch): + def broken_check(): + raise RuntimeError("raw prompt, user identity, session content, database object") + + monkeypatch.setattr(bot_personal_contract, "contract_self_check", broken_check) + + result = MemoryCompanionBridge(_PluginMustNotBeTouched()).probe_bot_personal_memory_capabilities() + + assert result["available"] is False + assert result["state"] == "degraded" + assert result["degraded"] is True + assert result["warnings"] == ["contract_self_check_exception"] + assert all(secret not in str(result) for secret in ("raw prompt", "user identity", "database object")) diff --git a/tests/test_c1_contract.py b/tests/test_c1_contract.py new file mode 100644 index 0000000..45cb5e2 --- /dev/null +++ b/tests/test_c1_contract.py @@ -0,0 +1,95 @@ +from __future__ import annotations + +import hashlib +import importlib.util +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +CONTRACT_PATH = ROOT / "astrbot_plugin_memory_companion-main" / "core" / "bot_personal_contract.py" +COMPANION_CONTRACT_PATH = ( + ROOT + / "astrbot_plugin_private_companion-main" + / "astrbot_plugin_private_companion-main" + / "bot_personal_contract.py" +) +SHARED_CONTRACT_PATH = ROOT / "doc" / "shared" / "bot_personal_contract.py" + + +def load_contract(path: Path, name: str): + spec = importlib.util.spec_from_file_location(name, path) + assert spec is not None and spec.loader is not None + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +contract = load_contract(CONTRACT_PATH, "memory_bot_personal_contract") +companion_contract = load_contract(COMPANION_CONTRACT_PATH, "companion_bot_personal_contract") + + +def test_contract_bytes_match_authority_and_other_side(): + expected = SHARED_CONTRACT_PATH.read_bytes() + assert CONTRACT_PATH.read_bytes() == expected + assert COMPANION_CONTRACT_PATH.read_bytes() == expected + assert hashlib.sha256(CONTRACT_PATH.read_bytes()).digest() == hashlib.sha256( + COMPANION_CONTRACT_PATH.read_bytes() + ).digest() + + +def test_frozen_contract_values_and_self_check(): + for module in (contract, companion_contract): + assert module.CONTRACT_FINGERPRINT == "5b8a97c1527dcc62" + assert module.CONTRACT_REVISION == 1 + assert module.BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION == "1.1" + assert module.BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION == "1.0" + assert module.BOT_PERSONAL_MEMORY_DOMAIN == "bot_self_schedule" + assert len(module.BOT_PERSONAL_MEMORY_TYPES) == 12 + assert set(module.TYPE_CONTRACTS) == set(module.BOT_PERSONAL_MEMORY_TYPES) + assert module.contract_self_check() == [] + assert module.compute_contract_fingerprint() == module.CONTRACT_FINGERPRINT + + +def test_five_window_boundaries_and_midnight_wrap(): + expected = { + 0: "late_night", + 359: "late_night", + 360: "morning", + 659: "morning", + 660: "noon", + 869: "noon", + 870: "afternoon", + 1079: "afternoon", + 1080: "evening", + 1259: "evening", + 1260: "late_night", + 1439: "late_night", + } + for minutes, slug in expected.items(): + assert contract.window_for_minutes(minutes) == slug + assert contract.window_for_minutes(-1) == "late_night" + assert contract.window_for_minutes(24 * 60) == "late_night" + + +def test_normalize_window_and_legacy_migration_never_guesses_without_timestamp(): + assert contract.normalize_window(" MORNING ") == "morning" + assert contract.normalize_window("凌晨") == "late_night" + assert contract.normalize_window("unknown") == "" + assert contract.migrate_legacy_window("late_night") == "late_night" + assert contract.migrate_legacy_window("morning") == "" + assert contract.migrate_legacy_window("afternoon") == "" + assert contract.migrate_legacy_window("evening") == "" + assert contract.migrate_legacy_window("morning", 11 * 60) == "noon" + + +def test_descriptor_fields_and_cross_side_descriptor_equality(): + memory = contract.capability_descriptor() + companion = companion_contract.capability_descriptor() + assert memory == companion + assert memory["contract_fingerprint"] == "5b8a97c1527dcc62" + assert memory["contract_revision"] == 1 + assert memory["capability_schema_version"] == "1.1" + assert memory["payload_schema_version"] == "1.0" + assert memory["memory_domain"] == "bot_self_schedule" + assert memory["windows"] == list(contract.WINDOW_SLUGS) + assert len(memory["memory_types"]) == 12 diff --git a/tests/test_c1_livingmemory_decoupling.py b/tests/test_c1_livingmemory_decoupling.py new file mode 100644 index 0000000..0656420 --- /dev/null +++ b/tests/test_c1_livingmemory_decoupling.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +import sys +import types +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +if "astrbot_plugin_remember_you" not in sys.modules: + package = types.ModuleType("astrbot_plugin_remember_you") + package.__path__ = [str(ROOT)] + sys.modules["astrbot_plugin_remember_you"] = package +if str(ROOT.parent) not in sys.path: + sys.path.insert(0, str(ROOT.parent)) + +from astrbot_plugin_remember_you.core.bridge import MemoryCompanionBridge +from astrbot_plugin_remember_you.core.config import ConfigView + + +def test_config_bridge_switch_is_independent_from_livingmemory(): + assert ConfigView({}).bridge_enabled() is True + assert ConfigView({"private_companion_bridge": {"enabled": False}}).bridge_enabled() is False + assert ConfigView({"enable_memory_companion_bridge": False, "livingmemory_migration": {"enabled": True}}).bridge_enabled() is False + assert ConfigView({"enable_memory_companion_bridge": True, "livingmemory_migration": {"enabled": False}}).bridge_enabled() is True + assert ConfigView({"livingmemory_migration": {"enabled": False}}).livingmemory_migration_enabled() is False + + +def test_bridge_missing_method_and_exception_are_degraded(): + class Missing: + pass + + class Broken: + def companion_coordination_status(self): + raise RuntimeError("boom") + + missing = MemoryCompanionBridge(Missing()).coordination_status() + broken = MemoryCompanionBridge(Broken()).coordination_status() + assert missing["state"] == "degraded" + assert missing["reason"] == "method_missing" + assert broken["state"] == "degraded" + assert broken["reason"] == "bridge_exception" + + +def test_livingmemory_migration_module_and_entrypoint_remain(): + assert (ROOT / "core" / "migration_livingmemory.py").exists() + main_text = (ROOT / "main.py").read_text(encoding="utf-8") + assert "import_livingmemory" in main_text + assert "get_active_bridge" in main_text + + +def test_schema_exposes_independent_defaults(): + import json + + companion_schema = json.loads( + (ROOT.parent / "astrbot_plugin_private_companion-main" / "astrbot_plugin_private_companion-main" / "_conf_schema.json").read_text(encoding="utf-8") + ) + memory_schema = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8")) + assert companion_schema["external_memory_config"]["items"]["enable_memory_companion_bridge"]["default"] is True + assert memory_schema["livingmemory_migration"]["items"]["enabled"]["default"] is True