wb-agent-runtime-mcp 1.0.0__py3-none-any.whl

launcher.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""Universal launcher: run the original mcp_server.py exactly as `python mcp_server.py`."""
+import os
+import runpy
+
+
+def main():
+    here = os.path.dirname(os.path.abspath(__file__))
+    runpy.run_path(os.path.join(here, "mcp_server.py"), run_name="__main__")
+
+
+if __name__ == "__main__":
+    main()

scripts/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""长期记忆 / 知识图谱 会思考的进化 AI —— 记忆底座核心包（纯标准库）。"""

scripts/archive.py

@@ -0,0 +1,306 @@
+# -*- coding: utf-8 -*-
+"""
+自动归档策略 —— 冷热分层 + 时间衰减，自动控制记忆膨胀。
+
+核心算法：
+  记忆热度分 = 0.6 * ln(access_count + 1) + 0.4 * exp(-days_since_access / 30)
+
+  热 (score ≥ 0.7): 保持原样，不处理
+  温 (0.3 ≤ score < 0.7): 抽取式摘要（保留关键句），存入 archive 表
+  冷 (score < 0.3): 仅保留事实抽取结果，高压缩比归档
+
+自动触发: autopilot 末尾自动调用 archive.run()
+硬件感知: 批处理大小按 hardware.tier 分配
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import sqlite3
+from collections import Counter
+from datetime import datetime, timedelta
+
+from . import config, embeddings, store
+from .hardware import get_plan
+
+
+# ── 热度分层阈值 ─────────────────────────────────────────────────────────
+HOT_THRESHOLD = 0.7       # ≥ 此值为热
+WARM_THRESHOLD = 0.3      # ≥ 此值为温，< 此值为冷
+
+# 时间衰减半衰期（天）
+DECAY_HALF_LIFE = 30
+
+
+def compute_heat(access_count: int, days_since_access: float) -> float:
+    """
+    计算记忆热度分（0~1）。
+    
+    公式：0.6 * ln(access_count + 1) + 0.4 * exp(-days / 30)
+    - access_count 越大，热度越高（对数增长，避免刷屏）
+    - days_since_access 越大，热度越低（指数衰减）
+    """
+    freq_score = math.log(access_count + 1)  # ln(1)=0, ln(2)=0.69, ln(5)=1.61
+    # 归一化到 0~1（ln(10)≈2.3 作为上限）
+    freq_normalized = min(freq_score / 2.3, 1.0)
+    decay_score = math.exp(-days_since_access / DECAY_HALF_LIFE)
+    return 0.6 * freq_normalized + 0.4 * decay_score
+
+
+def classify_tier(heat: float) -> str:
+    """根据热度分返回 hot / warm / cold。"""
+    if heat >= HOT_THRESHOLD:
+        return "hot"
+    if heat >= WARM_THRESHOLD:
+        return "warm"
+    return "cold"
+
+
+# ── 归档器 ─────────────────────────────────────────────────────────────────
+class Archiver:
+    """自动归档器。"""
+
+    def __init__(self):
+        self._ensure_archive_table()
+
+    def _ensure_archive_table(self) -> None:
+        """确保归档表存在。"""
+        conn = store.get_conn()
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS archive (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                memory_id INTEGER NOT NULL,
+                original_text TEXT,                -- 原始文本（冷归档时保留备份）
+                compressed_text TEXT NOT NULL,     -- 压缩后的文本
+                tier TEXT NOT NULL,                -- hot / warm / cold
+                heat_score REAL NOT NULL,
+                archived_at TEXT NOT NULL,
+                FOREIGN KEY(memory_id) REFERENCES memories(id) ON DELETE CASCADE
+            )
+        """)
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_archive_memory ON archive(memory_id)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_archive_tier ON archive(tier)")
+        conn.commit()
+
+    def analyze(self) -> dict:
+        """
+        分析所有记忆的热度分布，返回统计信息。
+        不修改任何数据。
+        """
+        conn = store.get_conn()
+        rows = conn.execute(
+            "SELECT id, raw_text, access_count, last_accessed FROM memories"
+        ).fetchall()
+
+        now = datetime.now()
+        tiers = {"hot": 0, "warm": 0, "cold": 0}
+        heat_scores = []
+
+        for r in rows:
+            last_access = datetime.fromisoformat(r["last_accessed"]) if r["last_accessed"] else now
+            days_since = (now - last_access).days + (now - last_access).seconds / 86400.0
+            heat = compute_heat(r["access_count"] or 0, days_since)
+            tier = classify_tier(heat)
+            tiers[tier] += 1
+            heat_scores.append(heat)
+
+        return {
+            "total": len(rows),
+            "tiers": tiers,
+            "avg_heat": round(sum(heat_scores) / max(len(heat_scores), 1), 4),
+            "min_heat": round(min(heat_scores) if heat_scores else 0, 4),
+            "max_heat": round(max(heat_scores) if heat_scores else 0, 4),
+        }
+
+    def run(self, dry_run: bool = True) -> dict:
+        """
+        执行归档。
+        
+        dry_run=True: 只返回计划，不修改数据
+        dry_run=False: 真正执行归档
+        
+        策略：
+        - 热记忆：跳过
+        - 温记忆：抽取式摘要（保留关键句），存入 archive 表
+        - 冷记忆：高压缩比归档（仅保留事实抽取结果），存入 archive 表
+        """
+        plan = get_plan()
+        batch_size = plan.get("batch_size", 60)
+
+        conn = store.get_conn()
+        rows = conn.execute(
+            "SELECT id, raw_text, access_count, last_accessed, tokens_json FROM memories"
+        ).fetchall()
+
+        now = datetime.now()
+        archived = {"hot": 0, "warm": 0, "cold": 0}
+        archived_details = []
+
+        for r in rows:
+            last_access = datetime.fromisoformat(r["last_accessed"]) if r["last_accessed"] else now
+            days_since = (now - last_access).days + (now - last_access).seconds / 86400.0
+            heat = compute_heat(r["access_count"] or 0, days_since)
+            tier = classify_tier(heat)
+
+            if tier == "hot":
+                archived["hot"] += 1
+                continue
+
+            # 检查是否已归档
+            existing = conn.execute(
+                "SELECT id FROM archive WHERE memory_id=?", (r["id"],)
+            ).fetchone()
+            if existing:
+                archived[tier] += 1
+                continue
+
+            # 按热度分层压缩
+            if tier == "warm":
+                compressed = self._warm_compress(r["raw_text"] or "")
+            else:  # cold
+                compressed = self._cold_compress(r["raw_text"] or "")
+
+            if not dry_run:
+                conn.execute(
+                    "INSERT INTO archive(memory_id, original_text, compressed_text, tier, heat_score, archived_at) "
+                    "VALUES(?,?,?,?,?,?)",
+                    (r["id"], r["raw_text"] if tier == "cold" else None,
+                     compressed, tier, heat,
+                     now.isoformat(timespec="seconds")),
+                )
+
+            archived[tier] += 1
+            archived_details.append({
+                "memory_id": r["id"],
+                "tier": tier,
+                "heat": round(heat, 4),
+                "compressed_len": len(compressed),
+                "original_len": len(r["raw_text"] or ""),
+            })
+
+        if not dry_run:
+            conn.commit()
+
+        return {
+            "dry_run": dry_run,
+            "total": len(rows),
+            "archived": archived,
+            "details": archived_details[:20],  # 只返回前 20 条详情
+            "batch_size": batch_size,
+            "tier": plan["tier"],
+        }
+
+    def _warm_compress(self, text: str) -> str:
+        """
+        温记忆压缩：抽取式摘要，保留关键句。
+        压缩比约 30~50%。
+        """
+        sents = []
+        for s in re.split(r"[。！？\n;；]", text):
+            s = s.strip()
+            if len(s) >= 6:
+                sents.append(s)
+        if not sents:
+            return text[:100] if text else ""
+
+        # 按 token 频次打分
+        freq = Counter()
+        for s in sents:
+            for tk in embeddings.tokenize(s):
+                freq[tk] += 1
+
+        scored = sorted(sents, key=lambda s: sum(freq.get(tk, 0) for tk in embeddings.tokenize(s)),
+                        reverse=True)
+        # 保留 top-3 关键句
+        return "；".join(scored[:3])
+
+    def _cold_compress(self, text: str) -> str:
+        """
+        冷记忆压缩：仅保留事实抽取结果（实体+谓词+值）。
+        压缩比约 70~90%。
+        """
+        # 极简事实抽取：找「X的Y是Z」模式
+        facts = []
+        for m in re.finditer(r"([\u4e00-\u9fff]{1,10})的([\u4e00-\u9fff]{1,8})[是为：:]\s*([^\n。；;]{1,30})", text):
+            entity, predicate, value = m.groups()
+            # 清理首尾噪声
+            entity = entity.strip()
+            predicate = predicate.strip()
+            value = value.strip()
+            if entity and predicate and value:
+                facts.append("%s的%s是%s" % (entity, predicate, value))
+
+        if facts:
+            return " | ".join(facts[:5])  # 最多保留 5 条事实
+
+        # 回退：截断到 50 字
+        return text[:50] + "..." if len(text) > 50 else text
+
+    def restore(self, memory_id: int) -> str | None:
+        """
+        从归档恢复原始文本（仅冷归档有原始文本备份）。
+        返回原始文本，若不存在返回 None。
+        """
+        conn = store.get_conn()
+        row = conn.execute(
+            "SELECT original_text, tier FROM archive WHERE memory_id=?", (memory_id,)
+        ).fetchone()
+        if not row:
+            return None
+        return row["original_text"]  # 冷归档有，温归档为 None
+
+    def get_archive_stats(self) -> dict:
+        """获取归档统计信息。"""
+        conn = store.get_conn()
+        total = conn.execute("SELECT COUNT(*) FROM archive").fetchone()[0]
+        by_tier = {}
+        for tier in ("hot", "warm", "cold"):
+            cnt = conn.execute("SELECT COUNT(*) FROM archive WHERE tier=?", (tier,)).fetchone()[0]
+            by_tier[tier] = cnt
+
+        # 计算压缩节省的空间
+        orig_total = conn.execute(
+            "SELECT SUM(LENGTH(original_text)) FROM archive"
+        ).fetchone()[0] or 0
+        comp_total = conn.execute(
+            "SELECT SUM(LENGTH(compressed_text)) FROM archive"
+        ).fetchone()[0] or 0
+
+        saving_pct = (1 - comp_total / max(orig_total, 1)) * 100 if orig_total > 0 else 0
+
+        return {
+            "total_archived": total,
+            "by_tier": by_tier,
+            "original_size_kb": round(orig_total / 1024, 2),
+            "compressed_size_kb": round(comp_total / 1024, 2),
+            "saving_percent": round(saving_pct, 1),
+        }
+
+
+# ── 便捷函数 ─────────────────────────────────────────────────────────────────
+def analyze() -> dict:
+    """分析记忆热度分布。"""
+    return Archiver().analyze()
+
+
+def run_archive(dry_run: bool = True) -> dict:
+    """执行归档。"""
+    return Archiver().run(dry_run=dry_run)
+
+
+def get_archive_stats() -> dict:
+    """获取归档统计。"""
+    return Archiver().get_archive_stats()
+
+
+if __name__ == "__main__":
+    import pprint
+    print("=== 热度分析 ===")
+    pprint.pprint(analyze())
+    print("\n=== 归档计划 ===")
+    pprint.pprint(run_archive(dry_run=True))
+    print("\n=== 归档统计 ===")
+    pprint.pprint(get_archive_stats())

scripts/backup.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""
+备份 / 恢复 —— 导出、备份、恢复。
+
+默认目标：本地文件（零密钥、零联网、立即可用）。
+可插拔目标：百度网盘（baidunetdisk）。该适配器仅在「用户已配置本地 token」时启用；
+未配置则给出明确指引，绝不偷偷联网或要求密钥。
+
+设计原则：
+  - 备份是「可恢复」的：snapshot(JSON) + 每日日志原文一并打包到备份目录。
+  - 保留最近 N 份（config.BACKUP_KEEP），自动清理过旧备份。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from datetime import datetime
+
+from . import config, health, store, embeddings
+
+
+def export_local(backup_dir: str | None = None) -> dict:
+    """
+    导出到本地备份目录：快照 + 每日日志原文。
+    返回 {backup_path, snapshot, logs_copied}。
+    """
+    config.ensure_dirs()
+    if backup_dir is None:
+        backup_dir = str(config.ZWJH_DIR / "backups")
+    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    dest = os.path.join(backup_dir, f"zwjh_backup_{stamp}")
+    os.makedirs(dest, exist_ok=True)
+
+    # 1) 快照（图谱 + 事实 + 配置）
+    snap = health.snapshot(os.path.join(dest, "snapshot.json"))
+
+    # 2) 每日日志原文
+    logs_copied = 0
+    logs_src = config.MEMORY_DIR
+    logs_dst = os.path.join(dest, "daily_logs")
+    os.makedirs(logs_dst, exist_ok=True)
+    for fp in sorted(logs_src.glob("20??-??-??.md")):
+        try:
+            shutil.copy2(fp, os.path.join(logs_dst, fp.name))
+            logs_copied += 1
+        except Exception:
+            pass
+
+    # 3) 清理旧备份（保留最近 BACKUP_KEEP 份）
+    _prune_backups(backup_dir)
+
+    return {"backup_path": dest, "snapshot": snap, "logs_copied": logs_copied}
+
+
+def _prune_backups(backup_dir: str) -> None:
+    try:
+        items = sorted(
+            [d for d in os.listdir(backup_dir) if d.startswith("zwjh_backup_")],
+            reverse=True,
+        )
+        for old in items[config.BACKUP_KEEP:]:
+            shutil.rmtree(os.path.join(backup_dir, old), ignore_errors=True)
+    except Exception:
+        pass
+
+
+def restore_local(backup_path: str, include_logs: bool = True) -> dict:
+    """从本地备份恢复（快照写回库；可选覆盖每日日志）。"""
+    snap_file = os.path.join(backup_path, "snapshot.json")
+    if not os.path.exists(snap_file):
+        return {"status": "error", "reason": "no_snapshot"}
+    with open(snap_file, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    # 写回实体/关系/事实
+    conn = store.get_conn()
+    # 清空派生索引（保留每日日志原文）
+    store.wipe_memories_only()
+    ent_id_map = {}
+    for e in data.get("entities", []):
+        new_id = store.upsert_entity(e["type"], e["name"],
+                                     json.loads(e.get("aliases_json", "[]")),
+                                     e.get("importance", 0.5))
+        ent_id_map[e["id"]] = new_id
+    for r in data.get("relations", []):
+        frm = ent_id_map.get(r["from_id"])
+        to = ent_id_map.get(r["to_id"])
+        if frm and to:
+            store.add_relation(frm, to, r["relation"], r.get("weight", 1.0),
+                               r.get("confidence", 1.0))
+    # 事实写回
+    for fct in data.get("facts", []):
+        eid = ent_id_map.get(fct["entity_id"])
+        if eid:
+            conn.execute(
+                "INSERT INTO facts(entity_id, predicate, value, valid_from, valid_to, "
+                "superseded, source_memory_id, created_at) VALUES(?,?,?,?,?,?,?,?)",
+                (eid, fct["predicate"], fct["value"], fct.get("valid_from"),
+                 fct.get("valid_to"), fct.get("superseded", 0),
+                 None, fct.get("created_at")),
+            )
+
+    # 记忆写回（快照含记忆，避免恢复后记忆表为空导致数据丢失）
+    for m in data.get("memories", []):
+        try:
+            toks = json.loads(m.get("tokens_json", "[]"))
+        except Exception:
+            toks = embeddings.tokenize(m.get("raw_text", ""))
+        store.add_memory(
+            m.get("day", config.today_str()),
+            m.get("source", "conversation"),
+            m.get("raw_text", ""),
+            m.get("norm_hash", ""),
+            toks,
+            importance=float(m.get("importance", 0.5)),
+        )
+    conn.commit()
+
+    logs_restored = 0
+    if include_logs:
+        logs_src = os.path.join(backup_path, "daily_logs")
+        if os.path.isdir(logs_src):
+            for fp in os.listdir(logs_src):
+                if fp.endswith(".md"):
+                    try:
+                        shutil.copy2(os.path.join(logs_src, fp),
+                                     os.path.join(str(config.MEMORY_DIR), fp))
+                        logs_restored += 1
+                    except Exception:
+                        pass
+    return {"status": "ok", "entities": len(ent_id_map),
+            "logs_restored": logs_restored}
+
+
+# ── 百度网盘适配器（可插拔，零密钥默认不可用） ──────────────────────────────
+def backup_baidunetdisk(backup_dir: str | None = None) -> dict:
+    """
+    备份到百度网盘。
+
+    仅在用户本地已配置百度网盘访问凭证时可用（凭证存于本地 config，不进技能包）。
+    未配置时返回明确指引，不报错、不联网试探。
+    """
+    cfg = config.load_config()
+    token = cfg.get("baidunetdisk", {}).get("access_token")
+    if not token:
+        return {
+            "status": "unavailable",
+            "reason": "未配置百度网盘凭证",
+            "hint": "在 config.json 写入 baidunetdisk.access_token 即可启用；"
+                    "或先运行「本地备份」再做手动上传。",
+        }
+    # 已配置：本地先导出，再调用上传适配器（mixin 接口，便于替换实现）
+    local = export_local(backup_dir)
+    return _upload_to_baidu(local["backup_path"], token)
+
+
+def _upload_to_baidu(local_path: str, token: str) -> dict:
+    """
+    上传适配器占位实现：优先使用已安装的 `bypy` CLI（需用户自行授权）。
+    不内置任何密钥；这里只负责调用已授权的本地客户端。
+    """
+    import subprocess
+
+    try:
+        proc = subprocess.run(
+            ["bypy", "upload", local_path, "/zwjh_backup/"],
+            capture_output=True, text=True, timeout=120,
+        )
+        if proc.returncode == 0:
+            return {"status": "ok", "via": "bypy", "path": local_path}
+        return {"status": "error", "reason": proc.stderr[:200]}
+    except FileNotFoundError:
+        return {
+            "status": "unavailable",
+            "reason": "未找到 bypy 客户端",
+            "hint": "pip install bypy 并完成授权后可启用百度网盘自动备份。",
+        }
+    except Exception as e:
+        return {"status": "error", "reason": str(e)[:200]}
+
+
+if __name__ == "__main__":
+    print(export_local())