refactor: remove LivingMemory integration entirely
删除 core/migration_livingmemory.py 与全部 LivingMemory 代码: 迁移器、导入命令与页面路由、store 的 livingmemory 来源记录维护方法、 retrieval 的 livingmemory_graph 去重键与召回护栏、schema 的迁移配置段。 保留 core/operations.py 的插件冲突检测条目——那是对「若用户仍安装了 LivingMemory」的告警,删掉会让系统对该冲突失明。 线上记忆库确认 0 条 source_plugin='livingmemory' 记录,删除无数据影响。 测试 319 项通过。 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
这个提交存在于:
父节点
e3f9e0b212
当前提交
9bb2bce595
共有 8 个文件被更改,包括 5 次插入 和 786 次删除
|
|
@ -469,7 +469,7 @@
|
|||
"items": {
|
||||
"recent_events_for_followup": {
|
||||
"description": "追问补全事件数",
|
||||
"hint": "处理\u201c还有的吧\u201d\u201c刚才那个\u201d等连续追问时,最多读取多少条最近群聊事件来补全检索词。",
|
||||
"hint": "处理“还有的吧”“刚才那个”等连续追问时,最多读取多少条最近群聊事件来补全检索词。",
|
||||
"type": "int",
|
||||
"default": 12
|
||||
},
|
||||
|
|
@ -706,7 +706,7 @@
|
|||
},
|
||||
"prefer_memory_companion_memory": {
|
||||
"description": "MemoryCompanion 接管记忆上下文",
|
||||
"hint": "开启后陪伴插件会尽量让出自我时间线、私聊上下文和旧 LivingMemory 指引,由 MemoryCompanion 统一注入。",
|
||||
"hint": "开启后陪伴插件会尽量让出自我时间线与私聊上下文,由 MemoryCompanion 统一注入。",
|
||||
"type": "bool",
|
||||
"default": true
|
||||
},
|
||||
|
|
@ -823,25 +823,6 @@
|
|||
}
|
||||
}
|
||||
},
|
||||
"livingmemory_migration": {
|
||||
"description": "LivingMemory 导入",
|
||||
"hint": "从旧 LivingMemory 数据库导入 documents 摘要。导入前建议预览并备份。",
|
||||
"type": "object",
|
||||
"items": {
|
||||
"import_limit": {
|
||||
"description": "单次导入上限",
|
||||
"hint": "单次最多导入多少条 LivingMemory documents 完整记忆。0 表示不限制。",
|
||||
"type": "int",
|
||||
"default": 5000
|
||||
},
|
||||
"livingmemory_db_path": {
|
||||
"description": "LivingMemory 数据库路径",
|
||||
"hint": "留空则自动扫描常见位置。建议先执行 /mcomp import_livingmemory preview。",
|
||||
"type": "string",
|
||||
"default": ""
|
||||
}
|
||||
}
|
||||
},
|
||||
"maintenance": {
|
||||
"description": "维护",
|
||||
"hint": "控制数据保留和清理策略。",
|
||||
|
|
|
|||
|
|
@ -408,68 +408,9 @@ class MemoryCompanionCommandHandler:
|
|||
)
|
||||
return "用法:/mcomp sleep status|run"
|
||||
|
||||
async def import_livingmemory(self, mode: str = "preview", path: str = "") -> str:
|
||||
return "LivingMemory 已按 Q5 用户记忆硬边界停用;请使用用户记忆合同或迁移预览接口。"
|
||||
|
||||
def _format_livingmemory_preview(self, report: dict[str, Any], *, verbose: bool = False) -> str:
|
||||
if not report["candidates"]:
|
||||
return (
|
||||
"没找到 LivingMemory 数据库。\n"
|
||||
"可在配置页填写 livingmemory_db_path,或执行:\n"
|
||||
"/mcomp import_livingmemory preview <livingmemory.db>"
|
||||
)
|
||||
|
||||
first = report["candidates"][0]
|
||||
if first.get("error"):
|
||||
return f"LivingMemory 读取失败:{first.get('error')}"
|
||||
|
||||
importable_rows = sum(int(table.get("count") or 0) for table in first.get("tables", []) if table.get("importable"))
|
||||
skipped_rows = sum(int(table.get("count") or 0) for table in first.get("tables", []) if not table.get("importable"))
|
||||
lines = [
|
||||
"LivingMemory 预览:",
|
||||
f"将导入 {importable_rows} 条完整记忆,跳过 {skipped_rows} 条碎片。",
|
||||
f"来源:{first.get('path')}",
|
||||
"执行:/mcomp import_livingmemory run",
|
||||
]
|
||||
if verbose:
|
||||
lines.insert(1, "策略:只导入 documents,跳过派生碎片。")
|
||||
lines.append("表:")
|
||||
for table in first.get("tables", [])[:10]:
|
||||
lines.append(f"- {self._format_livingmemory_table(table)}")
|
||||
if len(report["candidates"]) > 1:
|
||||
lines.append("其他候选:")
|
||||
for item in report["candidates"][1:5]:
|
||||
summary = self._candidate_summary(item)
|
||||
lines.append(f"- {item.get('path')}|{summary}")
|
||||
else:
|
||||
lines.append("详情:/mcomp import_livingmemory detail")
|
||||
return "\n".join(lines)
|
||||
|
||||
def _format_livingmemory_import_result(self, result: dict[str, Any]) -> str:
|
||||
if result.get("reason") and not result.get("source_path"):
|
||||
return (
|
||||
f"导入未执行:{result.get('reason')}\n"
|
||||
"先试:/mcomp import_livingmemory preview"
|
||||
)
|
||||
imported = int(result.get("imported") or 0)
|
||||
skipped = int(result.get("skipped") or 0)
|
||||
lines = [
|
||||
f"LivingMemory 导入完成:{imported} 条。",
|
||||
f"来源:{result.get('source_path') or '-'}",
|
||||
]
|
||||
if skipped:
|
||||
lines.append(f"跳过异常行:{skipped} 条")
|
||||
if imported == 0:
|
||||
lines.append("没有新增内容,可能是旧库没有 documents 完整摘要。")
|
||||
lines.append("可在记忆面板或 /mcomp search 中查看。")
|
||||
return "\n".join(lines)
|
||||
|
||||
def _format_livingmemory_table(self, table: dict[str, Any]) -> str:
|
||||
name = table.get("name")
|
||||
count = table.get("count", 0)
|
||||
if table.get("importable"):
|
||||
return f"{name}|{count} 行|将导入完整记忆"
|
||||
return f"{name}|{count} 行|跳过:{self._livingmemory_note(table.get('note'))}"
|
||||
|
||||
def _candidate_summary(self, item: dict[str, Any]) -> str:
|
||||
if item.get("error"):
|
||||
|
|
@ -478,18 +419,4 @@ class MemoryCompanionCommandHandler:
|
|||
skipped_rows = sum(int(table.get("count") or 0) for table in item.get("tables", []) if not table.get("importable"))
|
||||
return f"可导入 {importable_rows},跳过 {skipped_rows}"
|
||||
|
||||
def _livingmemory_note(self, note: Any) -> str:
|
||||
text = clean_text(note, 80)
|
||||
mapping = {
|
||||
"derived_fragment_not_imported": "派生事实碎片",
|
||||
"not_importable": "没有可导入正文",
|
||||
}
|
||||
return mapping.get(text, text or "不是完整记忆")
|
||||
|
||||
def _livingmemory_usage(self) -> str:
|
||||
return (
|
||||
"LivingMemory 迁移:\n"
|
||||
"/mcomp import_livingmemory preview 预览\n"
|
||||
"/mcomp import_livingmemory run 导入\n"
|
||||
"/mcomp import_livingmemory detail 详情"
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,520 +0,0 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import sqlite3
|
||||
import json
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from .importance import ImportanceEvaluator
|
||||
from .models import EntityRef, MemoryRecord, clean_text, new_id
|
||||
from .store import MemoryStore
|
||||
|
||||
|
||||
CONTENT_COLUMNS = ("text", "content", "summary", "memory", "canonical_summary", "persona_summary", "page_content")
|
||||
SESSION_COLUMNS = ("session_id", "session", "origin", "unified_msg_origin")
|
||||
PERSONA_COLUMNS = ("persona_id", "persona", "bot_id")
|
||||
TIME_COLUMNS = ("created_at", "updated_at", "timestamp", "time", "last_accessed")
|
||||
IMPORT_TABLE_PRIORITY = {
|
||||
"documents": 0,
|
||||
}
|
||||
DERIVED_TABLES = {"memory_atoms", "graph_entries", "messages"}
|
||||
SKIP_TABLES = {
|
||||
"db_version",
|
||||
"migration_status",
|
||||
"memory_write_ops",
|
||||
"graph_edges",
|
||||
"graph_nodes",
|
||||
"graph_entry_nodes",
|
||||
}
|
||||
|
||||
|
||||
class LivingMemoryMigrator:
|
||||
def __init__(self, store: MemoryStore, plugin_root: Path, data_dir: Path):
|
||||
self.store = store
|
||||
self.plugin_root = Path(plugin_root)
|
||||
self.data_dir = Path(data_dir)
|
||||
self.importance = ImportanceEvaluator()
|
||||
|
||||
def candidate_paths(self, configured_path: str = "") -> list[Path]:
|
||||
candidates: list[Path] = []
|
||||
if configured_path:
|
||||
candidates.append(Path(configured_path).expanduser())
|
||||
|
||||
plugins_dir = self.plugin_root.parent
|
||||
data_parent = self.data_dir.parent
|
||||
candidates.extend(
|
||||
[
|
||||
plugins_dir / "astrbot_plugin_livingmemory" / "data" / "livingmemory.db",
|
||||
plugins_dir / "astrbot_plugin_livingmemory" / "livingmemory.db",
|
||||
data_parent / "astrbot_plugin_livingmemory" / "livingmemory.db",
|
||||
data_parent / "astrbot_plugin_livingmemory" / "memory.db",
|
||||
data_parent / "livingmemory.db",
|
||||
]
|
||||
)
|
||||
|
||||
for base in [plugins_dir / "astrbot_plugin_livingmemory", data_parent / "astrbot_plugin_livingmemory"]:
|
||||
if base.exists():
|
||||
candidates.extend(base.rglob("*.db"))
|
||||
|
||||
unique: list[Path] = []
|
||||
seen: set[str] = set()
|
||||
for path in candidates:
|
||||
try:
|
||||
key = str(path.resolve())
|
||||
except Exception:
|
||||
key = str(path)
|
||||
if key not in seen:
|
||||
seen.add(key)
|
||||
unique.append(path)
|
||||
return unique
|
||||
|
||||
def preview(self, configured_path: str = "") -> dict[str, Any]:
|
||||
paths = self.candidate_paths(configured_path)
|
||||
reports = []
|
||||
for path in paths:
|
||||
if not path.exists() or not path.is_file():
|
||||
continue
|
||||
report = self._inspect_db(path)
|
||||
if report:
|
||||
reports.append(report)
|
||||
return {"candidates": reports, "count": len(reports)}
|
||||
|
||||
async def import_data(
|
||||
self,
|
||||
*,
|
||||
configured_path: str = "",
|
||||
default_review_status: str = "auto",
|
||||
limit: int = 5000,
|
||||
) -> dict[str, Any]:
|
||||
preview = self.preview(configured_path)
|
||||
if not preview["candidates"]:
|
||||
return {"imported": 0, "skipped": 0, "reason": "未找到可用 LivingMemory 数据库"}
|
||||
|
||||
source = preview["candidates"][0]
|
||||
path = Path(source["path"])
|
||||
batch_id = await self.store.add_import_batch(
|
||||
source_plugin="livingmemory",
|
||||
source_path=str(path),
|
||||
mode="import",
|
||||
stats={"tables": source.get("tables", [])},
|
||||
)
|
||||
imported = 0
|
||||
skipped = 0
|
||||
importable_tables: list[dict[str, Any]] = []
|
||||
skipped_tables: list[dict[str, Any]] = []
|
||||
for table in source.get("tables", []):
|
||||
if not table.get("importable"):
|
||||
skipped_tables.append(
|
||||
{
|
||||
"name": table.get("name"),
|
||||
"count": table.get("count", 0),
|
||||
"note": table.get("note") or "not_importable",
|
||||
}
|
||||
)
|
||||
continue
|
||||
before_table = imported
|
||||
remaining = max(0, limit - imported) if limit > 0 else int(table.get("count") or 0)
|
||||
rows = self._read_rows(path, table["name"], table["columns"], limit=remaining)
|
||||
for row in rows:
|
||||
record = self._row_to_record(row, table["columns"], table["name"], batch_id, default_review_status)
|
||||
if not record:
|
||||
skipped += 1
|
||||
continue
|
||||
await self.store.insert_memory(record)
|
||||
imported += 1
|
||||
if limit > 0 and imported >= limit:
|
||||
break
|
||||
if limit > 0 and imported >= limit:
|
||||
importable_tables.append(
|
||||
{
|
||||
"name": table.get("name"),
|
||||
"count": table.get("count", 0),
|
||||
"imported": imported - before_table,
|
||||
}
|
||||
)
|
||||
break
|
||||
importable_tables.append(
|
||||
{
|
||||
"name": table.get("name"),
|
||||
"count": table.get("count", 0),
|
||||
"imported": imported - before_table,
|
||||
}
|
||||
)
|
||||
return {
|
||||
"imported": imported,
|
||||
"skipped": skipped,
|
||||
"batch_id": batch_id,
|
||||
"source_path": str(path),
|
||||
"strategy": "只导入 documents 完整摘要,跳过 graph_entries/memory_atoms/messages 等派生碎片。",
|
||||
"default_review_status": default_review_status,
|
||||
"import_limit": limit,
|
||||
"importable_tables": importable_tables,
|
||||
"skipped_tables": skipped_tables,
|
||||
}
|
||||
|
||||
async def repair_imported_content(self, configured_path: str = "") -> dict[str, Any]:
|
||||
preview = self.preview(configured_path)
|
||||
if not preview["candidates"]:
|
||||
return {"updated": 0, "skipped": 0, "reason": "未找到可用 LivingMemory 数据库"}
|
||||
path = Path(preview["candidates"][0]["path"])
|
||||
candidates = await self.store.list_livingmemory_content_repair_candidates()
|
||||
if not candidates:
|
||||
return {"updated": 0, "skipped": 0, "source_path": str(path)}
|
||||
|
||||
updated = 0
|
||||
skipped = 0
|
||||
try:
|
||||
conn = sqlite3.connect(str(path))
|
||||
conn.row_factory = sqlite3.Row
|
||||
for item in candidates:
|
||||
payload = self._repair_payload(conn, item)
|
||||
if not payload:
|
||||
skipped += 1
|
||||
continue
|
||||
if await self.store.update_livingmemory_import_payload(item["id"], payload):
|
||||
updated += 1
|
||||
else:
|
||||
skipped += 1
|
||||
conn.close()
|
||||
except Exception as exc:
|
||||
return {"updated": updated, "skipped": skipped, "source_path": str(path), "error": str(exc)}
|
||||
return {"updated": updated, "skipped": skipped, "source_path": str(path)}
|
||||
|
||||
def _inspect_db(self, path: Path) -> dict[str, Any] | None:
|
||||
try:
|
||||
conn = sqlite3.connect(str(path))
|
||||
conn.row_factory = sqlite3.Row
|
||||
rows = conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").fetchall()
|
||||
tables = []
|
||||
for row in rows:
|
||||
table = row["name"]
|
||||
table_key = table.lower()
|
||||
if table.startswith("sqlite_") or "_fts" in table_key or table_key in SKIP_TABLES:
|
||||
continue
|
||||
columns = [item["name"] for item in conn.execute(f"PRAGMA table_info({self._quote(table)})").fetchall()]
|
||||
count = conn.execute(f"SELECT COUNT(*) FROM {self._quote(table)}").fetchone()[0]
|
||||
content_col = self._pick_content_column(columns)
|
||||
is_derived = table_key in DERIVED_TABLES
|
||||
tables.append(
|
||||
{
|
||||
"name": table,
|
||||
"columns": columns,
|
||||
"count": count,
|
||||
"content_column": content_col,
|
||||
"session_column": self._pick_exact(columns, SESSION_COLUMNS),
|
||||
"persona_column": self._pick(columns, PERSONA_COLUMNS),
|
||||
"time_column": self._pick_exact(columns, TIME_COLUMNS),
|
||||
"importable": bool(content_col and count > 0 and not is_derived),
|
||||
"note": "derived_fragment_not_imported" if is_derived else "",
|
||||
}
|
||||
)
|
||||
conn.close()
|
||||
if not tables:
|
||||
return None
|
||||
tables.sort(key=lambda item: (IMPORT_TABLE_PRIORITY.get(str(item.get("name") or "").lower(), 50), str(item.get("name") or "")))
|
||||
return {"path": str(path), "tables": tables}
|
||||
except Exception as exc:
|
||||
return {"path": str(path), "error": str(exc), "tables": []}
|
||||
|
||||
def _read_rows(self, path: Path, table: str, columns: list[str], limit: int) -> list[sqlite3.Row]:
|
||||
if limit <= 0:
|
||||
return []
|
||||
try:
|
||||
conn = sqlite3.connect(str(path))
|
||||
conn.row_factory = sqlite3.Row
|
||||
rows = conn.execute(f"SELECT * FROM {self._quote(table)} LIMIT ?", (limit,)).fetchall()
|
||||
conn.close()
|
||||
return rows
|
||||
except Exception:
|
||||
return []
|
||||
|
||||
def _row_to_record(
|
||||
self,
|
||||
row: sqlite3.Row,
|
||||
columns: list[str],
|
||||
table_name: str,
|
||||
batch_id: str,
|
||||
default_review_status: str,
|
||||
) -> MemoryRecord | None:
|
||||
table_key = table_name.lower()
|
||||
if table_key in SKIP_TABLES:
|
||||
return None
|
||||
if table_key == "memory_atoms":
|
||||
status = clean_text(self._row_get(row, "status"), 40).lower()
|
||||
if status in {"expired", "deleted", "archived", "disabled"}:
|
||||
return None
|
||||
|
||||
content_col = self._pick_content_column(columns)
|
||||
if not content_col:
|
||||
return None
|
||||
content = clean_text(row[content_col], 3000)
|
||||
if not content:
|
||||
return None
|
||||
|
||||
source_metadata = self._loads(self._row_get(row, "metadata"), {})
|
||||
if not isinstance(source_metadata, dict):
|
||||
source_metadata = {}
|
||||
session_col = self._pick_exact(columns, SESSION_COLUMNS)
|
||||
session_id = clean_text(row[session_col], 200) if session_col else ""
|
||||
session_id = clean_text(session_id or source_metadata.get("session_id"), 200)
|
||||
scope, target = self._scope_from_session(session_id)
|
||||
group_id = target if scope == "group" else ""
|
||||
object_ref = EntityRef(kind="group" if scope == "group" else "user", id=target, role="imported_target")
|
||||
visibility = "group_public" if scope == "group" else ("private_pair" if scope == "private" else "internal")
|
||||
occurred_col = self._pick_exact(columns, TIME_COLUMNS)
|
||||
occurred_at = self._normalize_time(row[occurred_col]) if occurred_col else ""
|
||||
|
||||
memory_type = self._memory_type_for_table(table_key, row)
|
||||
importance = self._float(self._row_get(row, "importance"), self._float(source_metadata.get("importance"), 0.35))
|
||||
confidence = self._float(self._row_get(row, "confidence"), self._float(source_metadata.get("confidence"), 0.55))
|
||||
tags = ["livingmemory_import", table_name]
|
||||
atom_type = clean_text(self._row_get(row, "atom_type"), 60)
|
||||
if atom_type:
|
||||
tags.append(atom_type)
|
||||
entry_type = clean_text(self._row_get(row, "entry_type"), 60)
|
||||
if entry_type:
|
||||
tags.append(entry_type)
|
||||
status = clean_text(self._row_get(row, "status"), 60)
|
||||
if status:
|
||||
tags.append(f"status:{status}")
|
||||
metadata = {
|
||||
"source_table": table_name,
|
||||
"source_row_id": self._row_get(row, "id"),
|
||||
"source_doc_id": self._row_get(row, "doc_id"),
|
||||
"source_memory_id": self._row_get(row, "source_memory_id") or self._row_get(row, "parent_memory_id"),
|
||||
"persona_id": clean_text(self._row_get(row, "persona_id") or source_metadata.get("persona_id"), 120),
|
||||
"livingmemory_metadata": source_metadata,
|
||||
}
|
||||
metadata.update(self._promoted_metadata(source_metadata))
|
||||
metadata = {key: value for key, value in metadata.items() if value not in ("", None, {}, [])}
|
||||
|
||||
record = MemoryRecord(
|
||||
id=new_id("imported"),
|
||||
memory_type=memory_type,
|
||||
subject=EntityRef(kind="unknown", id="", role="imported_subject"),
|
||||
object=object_ref,
|
||||
scope=scope,
|
||||
session_id=session_id,
|
||||
platform=session_id.split(":", 1)[0] if ":" in session_id else "",
|
||||
group_id=group_id,
|
||||
visibility=visibility,
|
||||
sayability="indirect",
|
||||
reality_level="imported_summary",
|
||||
lifecycle="stable_memory",
|
||||
content=content,
|
||||
evidence=content,
|
||||
confidence=confidence,
|
||||
importance=importance,
|
||||
review_status=default_review_status if default_review_status in {"pending", "auto"} else "auto",
|
||||
tags=tags,
|
||||
metadata=metadata,
|
||||
occurred_at=occurred_at,
|
||||
source_plugin="livingmemory",
|
||||
import_batch_id=batch_id,
|
||||
)
|
||||
return self.importance.calibrate(record, source="livingmemory_import")
|
||||
|
||||
def _memory_type_for_table(self, table_name: str, row: sqlite3.Row) -> str:
|
||||
if table_name == "memory_atoms":
|
||||
atom_type = clean_text(self._row_get(row, "atom_type"), 60)
|
||||
return f"livingmemory_atom:{atom_type}" if atom_type else "livingmemory_atom"
|
||||
if table_name == "graph_entries":
|
||||
entry_type = clean_text(self._row_get(row, "entry_type"), 60)
|
||||
return f"livingmemory_graph:{entry_type}" if entry_type else "livingmemory_graph"
|
||||
if table_name == "documents":
|
||||
return "conversation_summary"
|
||||
if table_name == "messages":
|
||||
return "conversation_event"
|
||||
return "imported_memory"
|
||||
|
||||
def _promoted_metadata(self, source_metadata: dict[str, Any]) -> dict[str, Any]:
|
||||
promoted: dict[str, Any] = {}
|
||||
for key in ("canonical_summary", "persona_summary", "sentiment", "interaction_type", "summary_quality"):
|
||||
value = clean_text(source_metadata.get(key), 1200 if key.endswith("summary") else 80)
|
||||
if value:
|
||||
promoted[key] = value
|
||||
for key, limit, item_limit in (
|
||||
("topics", 8, 80),
|
||||
("key_facts", 10, 180),
|
||||
("participants", 12, 80),
|
||||
):
|
||||
value = source_metadata.get(key)
|
||||
if isinstance(value, list):
|
||||
items = [clean_text(item, item_limit) for item in value if clean_text(item, item_limit)]
|
||||
if items:
|
||||
promoted[key] = items[:limit]
|
||||
source_window = source_metadata.get("source_window")
|
||||
if isinstance(source_window, dict):
|
||||
promoted["source_window"] = source_window
|
||||
return promoted
|
||||
|
||||
def _pick(self, columns: list[str], names: tuple[str, ...]) -> str:
|
||||
return self._pick_exact(columns, names)
|
||||
|
||||
def _pick_exact(self, columns: list[str], names: tuple[str, ...]) -> str:
|
||||
lowered = {column.lower(): column for column in columns}
|
||||
for name in names:
|
||||
if name in lowered:
|
||||
return lowered[name]
|
||||
return ""
|
||||
|
||||
def _pick_content_column(self, columns: list[str]) -> str:
|
||||
exact = self._pick_exact(columns, CONTENT_COLUMNS)
|
||||
if exact:
|
||||
return exact
|
||||
safe_tokens = {"summary", "memory", "text", "content"}
|
||||
for column in columns:
|
||||
lower = column.lower()
|
||||
if lower in {"id", "doc_id", "edge_key", "node_key", "metadata", "status", "memory_id", "parent_memory_id", "source_memory_id"}:
|
||||
continue
|
||||
if any(token in lower for token in safe_tokens):
|
||||
return column
|
||||
return ""
|
||||
|
||||
def _repair_payload(self, conn: sqlite3.Connection, item: dict[str, Any]) -> dict[str, Any] | None:
|
||||
metadata = self._loads(item.get("metadata"), {})
|
||||
source_table = clean_text(metadata.get("source_table"), 80)
|
||||
source_row_id = self._int(item.get("content"))
|
||||
if not source_table or source_row_id <= 0:
|
||||
return None
|
||||
|
||||
if source_table == "graph_edges":
|
||||
row = conn.execute("SELECT * FROM graph_edges WHERE id=?", (source_row_id,)).fetchone()
|
||||
if not row:
|
||||
return self._document_repair_payload(conn, source_row_id, metadata)
|
||||
edge_meta = self._loads(row["metadata"], {})
|
||||
text = clean_text(edge_meta.get("summary"), 4000)
|
||||
if not text:
|
||||
return None
|
||||
doc_meta: dict[str, Any] = {}
|
||||
doc_row = None
|
||||
if row["source_memory_id"]:
|
||||
doc_row = conn.execute("SELECT * FROM documents WHERE id=?", (row["source_memory_id"],)).fetchone()
|
||||
if doc_row:
|
||||
doc_meta = self._loads(doc_row["metadata"], {})
|
||||
session_id = clean_text(doc_meta.get("session_id"), 200)
|
||||
scope, target = self._scope_from_session(session_id)
|
||||
group_id = target if scope == "group" else ""
|
||||
metadata.update(
|
||||
{
|
||||
"source_table": source_table,
|
||||
"source_row_id": source_row_id,
|
||||
"source_memory_id": row["source_memory_id"],
|
||||
"source_relation_type": row["relation_type"],
|
||||
"source_edge_key": row["edge_key"],
|
||||
"repaired_from_numeric_content": True,
|
||||
}
|
||||
)
|
||||
return {
|
||||
"content": text,
|
||||
"evidence": text,
|
||||
"metadata": metadata,
|
||||
"scope": scope,
|
||||
"session_id": session_id,
|
||||
"group_id": group_id,
|
||||
"visibility": "group_public" if scope == "group" else ("private_pair" if scope == "private" else "internal"),
|
||||
"object_kind": "group" if scope == "group" else "user",
|
||||
"object_id": target,
|
||||
"object_role": "imported_target",
|
||||
"occurred_at": clean_text((doc_row["created_at"] if doc_row else "") or row["created_at"], 80),
|
||||
}
|
||||
|
||||
if source_table == "documents":
|
||||
return self._document_repair_payload(conn, source_row_id, metadata)
|
||||
return None
|
||||
|
||||
def _document_repair_payload(
|
||||
self,
|
||||
conn: sqlite3.Connection,
|
||||
source_row_id: int,
|
||||
metadata: dict[str, Any],
|
||||
) -> dict[str, Any] | None:
|
||||
row = conn.execute("SELECT * FROM documents WHERE id=?", (source_row_id,)).fetchone()
|
||||
if not row:
|
||||
return None
|
||||
text = clean_text(row["text"], 4000)
|
||||
if not text:
|
||||
return None
|
||||
doc_meta = self._loads(row["metadata"], {})
|
||||
session_id = clean_text(doc_meta.get("session_id"), 200)
|
||||
scope, target = self._scope_from_session(session_id)
|
||||
group_id = target if scope == "group" else ""
|
||||
metadata.update(
|
||||
{
|
||||
"source_table": "documents",
|
||||
"source_row_id": source_row_id,
|
||||
"source_doc_id": row["doc_id"],
|
||||
"repaired_from_numeric_content": True,
|
||||
}
|
||||
)
|
||||
return {
|
||||
"content": text,
|
||||
"evidence": text,
|
||||
"metadata": metadata,
|
||||
"scope": scope,
|
||||
"session_id": session_id,
|
||||
"group_id": group_id,
|
||||
"visibility": "group_public" if scope == "group" else ("private_pair" if scope == "private" else "internal"),
|
||||
"object_kind": "group" if scope == "group" else "user",
|
||||
"object_id": target,
|
||||
"object_role": "imported_target",
|
||||
"occurred_at": clean_text(row["created_at"], 80),
|
||||
}
|
||||
|
||||
def _loads(self, value: Any, fallback: Any) -> Any:
|
||||
if isinstance(value, dict):
|
||||
return value
|
||||
try:
|
||||
return json.loads(value or "")
|
||||
except Exception:
|
||||
return fallback
|
||||
|
||||
def _int(self, value: Any) -> int:
|
||||
try:
|
||||
return int(str(value).strip())
|
||||
except Exception:
|
||||
return 0
|
||||
|
||||
def _float(self, value: Any, default: float) -> float:
|
||||
try:
|
||||
return float(value)
|
||||
except Exception:
|
||||
return default
|
||||
|
||||
def _row_get(self, row: sqlite3.Row, key: str, default: Any = "") -> Any:
|
||||
try:
|
||||
if key in row.keys():
|
||||
return row[key]
|
||||
except Exception:
|
||||
pass
|
||||
return default
|
||||
|
||||
def _normalize_time(self, value: Any) -> str:
|
||||
if value in (None, ""):
|
||||
return ""
|
||||
if isinstance(value, (int, float)):
|
||||
try:
|
||||
return datetime.fromtimestamp(float(value), tz=timezone.utc).isoformat()
|
||||
except Exception:
|
||||
return clean_text(value, 80)
|
||||
text = clean_text(value, 80)
|
||||
try:
|
||||
numeric = float(text)
|
||||
if numeric > 1000000000:
|
||||
return datetime.fromtimestamp(numeric, tz=timezone.utc).isoformat()
|
||||
except Exception:
|
||||
pass
|
||||
return text
|
||||
|
||||
def _scope_from_session(self, session_id: str) -> tuple[str, str]:
|
||||
if ":GroupMessage:" in session_id:
|
||||
return "group", session_id.rsplit(":GroupMessage:", 1)[-1]
|
||||
if ":FriendMessage:" in session_id:
|
||||
return "private", session_id.rsplit(":FriendMessage:", 1)[-1]
|
||||
if ":PrivateMessage:" in session_id:
|
||||
return "private", session_id.rsplit(":PrivateMessage:", 1)[-1]
|
||||
return "unknown", ""
|
||||
|
||||
def _quote(self, name: str) -> str:
|
||||
return '"' + name.replace('"', '""') + '"'
|
||||
|
|
@ -639,11 +639,8 @@ class RetrievalEngine:
|
|||
) -> tuple[list[SearchResult], list[dict[str, str]]]:
|
||||
if len(results) < 2:
|
||||
return results, []
|
||||
# 原先只按 livingmemory_graph 的来源做跨条去重;该来源已随 LivingMemory 一并移除。
|
||||
groups: dict[tuple[str, str, str], list[tuple[int, SearchResult]]] = {}
|
||||
for index, item in enumerate(results):
|
||||
key = self._redundant_source_key(item.memory)
|
||||
if key:
|
||||
groups.setdefault(key, []).append((index, item))
|
||||
drop_reasons: dict[str, str] = {}
|
||||
for key, entries in groups.items():
|
||||
if len(entries) < 2:
|
||||
|
|
@ -672,26 +669,6 @@ class RetrievalEngine:
|
|||
]
|
||||
return collapsed, blocked
|
||||
|
||||
def _redundant_source_key(self, memory: MemoryRecord) -> tuple[str, str, str] | None:
|
||||
source_plugin = clean_text(memory.source_plugin, 80).lower()
|
||||
memory_type = clean_text(memory.memory_type, 120).lower()
|
||||
if source_plugin != "livingmemory" or not memory_type.startswith("livingmemory_graph:"):
|
||||
return None
|
||||
metadata = memory.metadata if isinstance(memory.metadata, dict) else {}
|
||||
source_memory_id = clean_text(metadata.get("source_memory_id"), 120)
|
||||
nested = metadata.get("livingmemory_metadata")
|
||||
if not source_memory_id and isinstance(nested, dict):
|
||||
source_memory_id = clean_text(nested.get("source_memory_id"), 120)
|
||||
if not source_memory_id:
|
||||
return None
|
||||
persona_id = clean_text(metadata.get("persona_id"), 120)
|
||||
if not persona_id and isinstance(nested, dict):
|
||||
persona_id = clean_text(nested.get("persona_id"), 120)
|
||||
session_id = clean_text(memory.session_id, 200)
|
||||
if not session_id and isinstance(nested, dict):
|
||||
session_id = clean_text(nested.get("session_id"), 200)
|
||||
scope_key = f"{memory.scope}:{session_id or memory.group_id}:{persona_id}"
|
||||
return ("livingmemory_graph_source", source_memory_id, scope_key)
|
||||
|
||||
def _collapse_mutable_fact_results(
|
||||
self,
|
||||
|
|
@ -2227,9 +2204,6 @@ class RetrievalEngine:
|
|||
vector_relevant = vector_score >= self.embedding_score_threshold if self.embedding_enabled else False
|
||||
if terms and not exact_hit and term_hits < min_hits and not vector_relevant:
|
||||
return 0.0, f"keyword_hit_too_weak hits={term_hits}/{min_hits}"
|
||||
graph_guard_reason = self._livingmemory_graph_relevance_guard(memory, term_hits, exact_hit, min_hits)
|
||||
if graph_guard_reason and vector_score < min(0.98, self.embedding_score_threshold + 0.12):
|
||||
return 0.0, graph_guard_reason
|
||||
bm25 = 0.0
|
||||
if terms:
|
||||
for term in terms:
|
||||
|
|
@ -2340,28 +2314,7 @@ class RetrievalEngine:
|
|||
bonus += min(0.040, max(freshness, emotional) * 0.040)
|
||||
return min(0.18, bonus)
|
||||
|
||||
def _livingmemory_graph_relevance_guard(
|
||||
self,
|
||||
memory: MemoryRecord,
|
||||
term_hits: int,
|
||||
exact_hit: bool,
|
||||
min_hits: int,
|
||||
) -> str:
|
||||
if not self._is_livingmemory_graph_memory(memory) or exact_hit:
|
||||
return ""
|
||||
required_hits = max(3, min_hits + 1)
|
||||
age_days = self._age_days(memory.occurred_at or memory.created_at)
|
||||
if age_days is not None and age_days >= 30:
|
||||
required_hits = max(required_hits, 4)
|
||||
if term_hits < required_hits:
|
||||
return f"livingmemory_graph_hit_too_weak hits={term_hits}/{required_hits};age_days={age_days:.1f}" if age_days is not None else f"livingmemory_graph_hit_too_weak hits={term_hits}/{required_hits}"
|
||||
return ""
|
||||
|
||||
def _is_livingmemory_graph_memory(self, memory: MemoryRecord) -> bool:
|
||||
return (
|
||||
clean_text(memory.source_plugin, 80).lower() == "livingmemory"
|
||||
and clean_text(memory.memory_type, 120).lower().startswith("livingmemory_graph:")
|
||||
)
|
||||
|
||||
def _recency_bonus(self, iso_text: str) -> float:
|
||||
days = self._age_days(iso_text)
|
||||
|
|
|
|||
|
|
@ -67,7 +67,6 @@ from .injection import (
|
|||
MEMORY_COMPANION_INJECTION_HEADER,
|
||||
InjectionComposer,
|
||||
)
|
||||
from .migration_livingmemory import LivingMemoryMigrator
|
||||
from .models import EntityRef, MemoryRecord, SearchResult, SessionContext, clean_text, json_dumps, json_loads, utc_now
|
||||
from .operations import (
|
||||
PRESET_LABELS,
|
||||
|
|
@ -192,7 +191,6 @@ class MemoryCompanionService:
|
|||
self._retrieval_result_cache_stats: dict[str, int] = {"hits": 0, "misses": 0, "evictions": 0}
|
||||
self._RETRIEVAL_RESULT_CACHE_TTL: float = 45.0
|
||||
self._RETRIEVAL_RESULT_CACHE_MAX: int = 128
|
||||
self.migrator = LivingMemoryMigrator(self.store, self.plugin_root, self.data_dir)
|
||||
self.user_memory_migration = UserMemoryMigration(self.store)
|
||||
self.portable_archive = PortableMemoryArchive(self.store, self.data_dir)
|
||||
self.chat_importer = HistoricalChatImporter(self)
|
||||
|
|
@ -3882,13 +3880,6 @@ class MemoryCompanionService:
|
|||
],
|
||||
}
|
||||
|
||||
async def import_livingmemory(self, *, configured_path: str = "") -> dict[str, Any]:
|
||||
return {
|
||||
"imported": 0,
|
||||
"skipped": 0,
|
||||
"disabled": True,
|
||||
"reason": "livingmemory_disabled_by_user_memory_contract",
|
||||
}
|
||||
|
||||
def operation_preset_status(self) -> dict[str, Any]:
|
||||
preset = detect_preset(self.config)
|
||||
|
|
@ -6712,7 +6703,7 @@ class MemoryCompanionService:
|
|||
if not self.config.bool("private_companion_bridge.dedupe_prompt_context", True):
|
||||
return False
|
||||
normalized = clean_text(section, 80)
|
||||
if normalized in {"self_timeline", "private_context", "livingmemory_guidance"}:
|
||||
if normalized in {"self_timeline", "private_context"}:
|
||||
return self.config.bool("private_companion_bridge.prefer_memory_companion_memory", True)
|
||||
if normalized in {"companion_memory", "dialogue_history"}:
|
||||
return self.config.bool("private_companion_bridge.prefer_memory_companion_memory", True)
|
||||
|
|
@ -6800,7 +6791,7 @@ class MemoryCompanionService:
|
|||
drop("self_timeline", "companion_context_detected:self_timeline_slot_suppressed")
|
||||
if self.config.bool("private_companion_bridge.suppress_user_context_when_companion_seen", True):
|
||||
private_context_deferred = bool(
|
||||
{"private_context", "companion_memory", "dialogue_history", "livingmemory_guidance"} & deferred_sections
|
||||
{"private_context", "companion_memory", "dialogue_history"} & deferred_sections
|
||||
)
|
||||
if (
|
||||
companion_state.get("has_state")
|
||||
|
|
|
|||
|
|
@ -4779,108 +4779,11 @@ class MemoryStore:
|
|||
self._conn.commit()
|
||||
return cur.rowcount > 0
|
||||
|
||||
async def approve_livingmemory_imports(self) -> dict[str, Any]:
|
||||
return await asyncio.to_thread(self._approve_livingmemory_imports_sync)
|
||||
|
||||
def _approve_livingmemory_imports_sync(self) -> dict[str, Any]:
|
||||
now = utc_now()
|
||||
with self._lock:
|
||||
rows = self._conn.execute(
|
||||
"""
|
||||
SELECT id
|
||||
FROM memories
|
||||
WHERE source_plugin='livingmemory' AND review_status='pending'
|
||||
"""
|
||||
).fetchall()
|
||||
ids = [row["id"] for row in rows]
|
||||
if not ids:
|
||||
return {"updated": 0, "review_queue_updated": 0}
|
||||
placeholders = ",".join("?" for _ in ids)
|
||||
memory_cur = self._conn.execute(
|
||||
f"""
|
||||
UPDATE memories
|
||||
SET review_status='auto',
|
||||
lifecycle='stable_memory',
|
||||
updated_at=?
|
||||
WHERE id IN ({placeholders})
|
||||
""",
|
||||
[now] + ids,
|
||||
)
|
||||
queue_cur = self._conn.execute(
|
||||
f"""
|
||||
UPDATE review_queue
|
||||
SET status='auto',
|
||||
updated_at=?
|
||||
WHERE memory_id IN ({placeholders}) AND status='pending'
|
||||
""",
|
||||
[now] + ids,
|
||||
)
|
||||
self._conn.commit()
|
||||
return {
|
||||
"updated": int(memory_cur.rowcount or 0),
|
||||
"review_queue_updated": int(queue_cur.rowcount or 0),
|
||||
}
|
||||
|
||||
async def list_livingmemory_content_repair_candidates(self) -> list[dict[str, Any]]:
|
||||
return await asyncio.to_thread(self._list_livingmemory_content_repair_candidates_sync)
|
||||
|
||||
def _list_livingmemory_content_repair_candidates_sync(self) -> list[dict[str, Any]]:
|
||||
with self._lock:
|
||||
rows = self._conn.execute(
|
||||
"""
|
||||
SELECT id, content, evidence, metadata
|
||||
FROM memories
|
||||
WHERE source_plugin='livingmemory'
|
||||
"""
|
||||
).fetchall()
|
||||
candidates = []
|
||||
for row in rows:
|
||||
content = clean_text(row["content"], 80)
|
||||
if content.isdigit():
|
||||
candidates.append(dict(row))
|
||||
return candidates
|
||||
|
||||
async def update_livingmemory_import_payload(self, memory_id: str, payload: dict[str, Any]) -> bool:
|
||||
return await asyncio.to_thread(self._update_livingmemory_import_payload_sync, memory_id, payload)
|
||||
|
||||
def _update_livingmemory_import_payload_sync(self, memory_id: str, payload: dict[str, Any]) -> bool:
|
||||
with self._lock:
|
||||
cur = self._conn.execute(
|
||||
"""
|
||||
UPDATE memories
|
||||
SET content=?,
|
||||
evidence=?,
|
||||
metadata=?,
|
||||
scope=?,
|
||||
session_id=?,
|
||||
group_id=?,
|
||||
visibility=?,
|
||||
object_kind=?,
|
||||
object_id=?,
|
||||
object_role=?,
|
||||
occurred_at=COALESCE(NULLIF(?, ''), occurred_at),
|
||||
content_fingerprint='',
|
||||
updated_at=?
|
||||
WHERE id=? AND source_plugin='livingmemory'
|
||||
""",
|
||||
(
|
||||
clean_text(payload.get("content"), 4000),
|
||||
clean_text(payload.get("evidence"), 4000),
|
||||
json_dumps(payload.get("metadata") or {}),
|
||||
clean_text(payload.get("scope"), 40),
|
||||
clean_text(payload.get("session_id"), 200),
|
||||
clean_text(payload.get("group_id"), 120),
|
||||
clean_text(payload.get("visibility"), 40),
|
||||
clean_text(payload.get("object_kind"), 40),
|
||||
clean_text(payload.get("object_id"), 120),
|
||||
clean_text(payload.get("object_role"), 80),
|
||||
clean_text(payload.get("occurred_at"), 80),
|
||||
utc_now(),
|
||||
clean_text(memory_id, 120),
|
||||
),
|
||||
)
|
||||
self._conn.commit()
|
||||
return cur.rowcount > 0
|
||||
|
||||
async def update_memory_visibility(self, memory_id: str, visibility: str) -> bool:
|
||||
return await asyncio.to_thread(self._update_memory_visibility_sync, memory_id, visibility)
|
||||
|
|
|
|||
7
main.py
7
main.py
|
|
@ -320,13 +320,6 @@ class MemoryCompanionPlugin(Star):
|
|||
) -> AsyncGenerator[MessageEventResult, None]:
|
||||
yield event.plain_result(await self.commands.sleep(action))
|
||||
|
||||
@permission_type(PermissionType.ADMIN)
|
||||
@mcomp.command("import_livingmemory", priority=10)
|
||||
async def cmd_mcomp_import_livingmemory(
|
||||
self, event: AstrMessageEvent, mode: str = "preview", path: str = ""
|
||||
) -> AsyncGenerator[MessageEventResult, None]:
|
||||
yield event.plain_result(await self.commands.import_livingmemory(mode, path))
|
||||
|
||||
@permission_type(PermissionType.ADMIN)
|
||||
@mcomp.command("help", priority=10)
|
||||
async def cmd_mcomp_help(self, event: AstrMessageEvent) -> AsyncGenerator[MessageEventResult, None]:
|
||||
|
|
|
|||
|
|
@ -115,11 +115,8 @@ class PluginPageApi:
|
|||
("/companion/personal-photo-data", self.companion_personal_photo_data, ["GET"], "MemoryCompanion Page companion personal photo data"),
|
||||
("/maintenance", self.maintenance, ["POST"], "MemoryCompanion Page maintenance"),
|
||||
("/maintenance/sleep", self.sleep_maintenance, ["GET", "POST"], "MemoryCompanion Page sleep maintenance"),
|
||||
("/maintenance/repair_livingmemory_content", self.repair_livingmemory_content, ["POST"], "MemoryCompanion Page repair LivingMemory content"),
|
||||
("/maintenance/clear_all", self.clear_all, ["POST"], "MemoryCompanion Page clear all memory data"),
|
||||
("/maintenance/clear_scope", self.clear_scope, ["POST"], "MemoryCompanion Page clear scoped memory data"),
|
||||
("/import/livingmemory/preview", self.import_preview, ["GET"], "MemoryCompanion Page import preview"),
|
||||
("/import/livingmemory/run", self.import_run, ["POST"], "MemoryCompanion Page import run"),
|
||||
("/persona-state", self.persona_state, ["GET"], "MemoryCompanion Page persona state"),
|
||||
("/acl/matrix", self.acl_matrix, ["GET"], "MemoryCompanion Page ACL matrix"),
|
||||
# M6.1.6:Bot 长期归档只读视图。只读、只出 Bot 域,写入仍走受控归档路径。
|
||||
|
|
@ -2203,8 +2200,6 @@ class PluginPageApi:
|
|||
result = self.plugin.service.sleep_status()
|
||||
return self._ok({"result": result})
|
||||
|
||||
async def repair_livingmemory_content(self):
|
||||
return self._err("livingmemory_disabled_by_user_memory_contract", 410)
|
||||
|
||||
async def clear_all(self):
|
||||
payload = await self._json()
|
||||
|
|
@ -2238,11 +2233,7 @@ class PluginPageApi:
|
|||
return self._err(str(exc), 400)
|
||||
return self._ok({"result": result})
|
||||
|
||||
async def import_preview(self):
|
||||
return self._err("livingmemory_disabled_by_user_memory_contract", 410)
|
||||
|
||||
async def import_run(self):
|
||||
return self._err("livingmemory_disabled_by_user_memory_contract", 410)
|
||||
|
||||
@staticmethod
|
||||
def _ok(data: dict[str, Any] | None = None):
|
||||
|
|
|
|||
正在加载…
添加表格
在新工单中引用