feat(c1): decouple memory bridge and livingmemory

这个提交存在于:
Codex Local 2026-07-30 02:22:30 +08:00
父节点 1cd06dcf95
当前提交 8536d100ac
共有 9 个文件被更改,包括 680 次插入 和 6 次删除

查看文件

@ -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。",

查看文件

@ -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)

查看文件

@ -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)

查看文件

@ -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)

查看文件

@ -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,

11
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

查看文件

@ -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"))

95
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

查看文件

@ -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