@sophiacyl/dsh-plugin-waves 0.0.0-stage → 0.1.0-beta.1

package/service/rover/knowledge.py

@@ -0,0 +1,235 @@
+"""游戏常识知识库: service/knowledge/ 下 jsonl 的加载、词法检索与世界书触发查询。
+
+纯 stdlib、不依赖 rover 其它模块, wwdata 脚本可直接 import 复用。
+存储粒度是"小节": {id: "<entry>#<n>", entry, title: "条目/小节", tags, source, triggers, content}
+检索按小节返回; kb_get 传小节 id 取小节、传条目 id 取整条拼装。
+"""
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+SERVICE = Path(__file__).resolve().parents[1]
+KB_DIR = SERVICE / "knowledge"
+CHAR_ALIAS = SERVICE / "data" / "XutheringWavesUID" / "alias" / "char_alias.json"
+
+_CJK = re.compile(r"[一-鿿]")
+TRIGGER_MIN_LEN = 2
+# 过泛词不做自动注入触发(检索不受影响)
+BROAD_TRIGGERS = {"声骸", "资源", "补给", "头像", "武器", "角色", "攻略", "活动", "任务", "成就", "套装"}
+# 只有这些层参与自动注入; event/article/story 只可检索
+INJECT_TIERS = {"core", "guide"}
+LOOKUP_MAX_HITS = 2
+SNIPPET_LEN = 160
+INJECT_CONTENT_LEN = 600
+
+# tags → 触发优先级; 数值大者先注入
+_PRIORITY_TAGS = [
+    (10, ("共鸣者", "武器", "声骸", "合鸣效果")),
+    (8, ("角色攻略", "游戏机制", "名词注释")),
+    (7, ("游戏百科", "教程百科", "玩法攻略")),
+]
+
+_state: Optional[Dict[str, Any]] = None
+
+
+def _canonical_chars() -> Set[str]:
+    try:
+        return set(json.loads(CHAR_ALIAS.read_text("utf-8")).keys())
+    except (OSError, ValueError):
+        return set()
+
+
+def _priority(rec: dict) -> int:
+    tags = set(rec.get("tags") or [])
+    for score, keys in _PRIORITY_TAGS:
+        if tags & set(keys):
+            return score
+    return 5
+
+
+def _entry_title(sec: dict) -> str:
+    return str(sec.get("entry_title") or "").strip() or str(sec.get("title") or "").rsplit("/", 1)[0]
+
+
+def _load() -> Dict[str, Any]:
+    global _state
+    if _state is not None:
+        return _state
+    sections: Dict[str, dict] = {}
+    entry_secs: Dict[str, List[str]] = {}
+    for path in sorted(KB_DIR.rglob("*.jsonl")):
+        source_kind = path.parent.name if path.parent != KB_DIR else path.stem
+        for line in path.read_text("utf-8").splitlines():
+            try:
+                rec = json.loads(line)
+            except ValueError:
+                continue
+            if not rec.get("id") or not rec.get("content"):
+                continue
+            rec["_kind"] = source_kind
+            sections[rec["id"]] = rec
+            entry_secs.setdefault(rec.get("entry") or rec["id"], []).append(rec["id"])
+
+    chars = _canonical_chars()
+    # (触发词, 条目 id, 注入的小节 id, 优先级); 每条目同一词只登记最先声明它的小节
+    triggers: List[Tuple[str, str, str, int]] = []
+    for entry_id, sec_ids in entry_secs.items():
+        first = sections[sec_ids[0]]
+        if first.get("tier") and first["tier"] not in INJECT_TIERS:
+            continue
+        prio = int(first.get("priority") or _priority(first))
+        title = _entry_title(first)
+        word_sec: Dict[str, str] = {}
+        for sid in sec_ids:
+            for word in sections[sid].get("triggers") or []:
+                word_sec.setdefault(str(word).strip(), sid)
+        if title:
+            word_sec.setdefault(title, sec_ids[0])
+        # 标题里含角色正式名时(如"【WIKI】椿角色攻略"), 允许按角色名触发
+        for char_name in chars:
+            if char_name and char_name in title:
+                word_sec.setdefault(char_name, sec_ids[0])
+        for word, sid in word_sec.items():
+            if not word or not _CJK.search(word) or word in BROAD_TRIGGERS:
+                continue
+            if len(word) < TRIGGER_MIN_LEN and word not in chars:
+                continue
+            triggers.append((word, entry_id, sid, prio))
+    triggers.sort(key=lambda t: (-len(t[0]), -t[3]))
+    _state = {"sections": sections, "entries": entry_secs, "triggers": triggers}
+    return _state
+
+
+def reload() -> int:
+    global _state
+    _state = None
+    return len(_load()["sections"])
+
+
+def get(kid: str) -> Optional[dict]:
+    """小节 id → 小节记录; 条目 id → 全部小节拼装的整条。"""
+    state = _load()
+    if kid in state["sections"]:
+        return {k: v for k, v in state["sections"][kid].items() if not k.startswith("_")}
+    sec_ids = state["entries"].get(kid)
+    if not sec_ids:
+        return None
+    first = state["sections"][sec_ids[0]]
+    parts = []
+    for sid in sec_ids:
+        sec = state["sections"][sid]
+        sec_name = str(sec.get("section_title") or "").strip() or str(sec.get("title") or "").rsplit("/", 1)[-1]
+        parts.append(f"## {sec_name}\n{sec['content']}")
+    return {
+        "id": kid,
+        "title": _entry_title(first),
+        "tags": first.get("tags") or [],
+        "source": first.get("source"),
+        "sections": [
+            {"id": sid, "title": state["sections"][sid].get("title")} for sid in sec_ids
+        ],
+        "content": "\n\n".join(parts),
+    }
+
+
+def lookup(text: str, exclude: Optional[Set[str]] = None,
+           limit: int = LOOKUP_MAX_HITS) -> List[Dict[str, Any]]:
+    """世界书触发: 在一段话里扫触发词, 长词优先, 注入声明该触发词的小节。
+
+    exclude 是条目 id 集合; 已排除条目的同名条目一并跳过(多源同名词条只注入一次)。
+    """
+    text = (text or "").strip()
+    if not text:
+        return []
+    exclude = exclude or set()
+    state = _load()
+    excluded_titles = set()
+    for entry_id in exclude:
+        sec_ids = state["entries"].get(entry_id)
+        if sec_ids:
+            excluded_titles.add(_entry_title(state["sections"][sec_ids[0]]))
+    hits: List[Dict[str, Any]] = []
+    seen_entries: Set[str] = set()
+    taken_words: List[str] = []
+    for word, entry_id, sec_id, _prio in state["triggers"]:
+        if entry_id in exclude or entry_id in seen_entries or word not in text:
+            continue
+        sec = state["sections"][sec_id]
+        if _entry_title(sec) in excluded_titles:
+            continue
+        if any(word in longer for longer in taken_words):
+            continue
+        content = sec["content"]
+        if len(content) > INJECT_CONTENT_LEN:
+            content = content[:INJECT_CONTENT_LEN] + f"…(截断, 整条 kb_get('{entry_id}'))"
+        hits.append({"id": sec["id"], "entry": entry_id, "title": sec.get("title"),
+                     "trigger": word, "tags": sec.get("tags") or [], "content": content})
+        seen_entries.add(entry_id)
+        taken_words.append(word)
+        if len(hits) >= limit:
+            break
+    return hits
+
+
+def _terms(q: str) -> List[str]:
+    parts = [p for p in re.split(r"[\s,，、/]+", (q or "").strip()) if p]
+    return parts or ([q.strip()] if q.strip() else [])
+
+
+def search(q: str, source: Optional[str] = None, tags: Optional[List[str]] = None,
+           limit: int = 5, full: bool = False) -> List[Dict[str, Any]]:
+    """按小节词法检索: title/triggers/tags 命中权重高于 content, 多词全含加分。"""
+    terms = _terms(q)
+    if not terms:
+        return []
+    state = _load()
+    want_tags = set(tags or [])
+    scored: List[Tuple[float, dict]] = []
+    for rec in state["sections"].values():
+        if source and rec.get("_kind") != source:
+            continue
+        if want_tags and not (want_tags & set(rec.get("tags") or [])):
+            continue
+        title = str(rec.get("title") or "")
+        trig = " ".join(rec.get("triggers") or [])
+        tag_text = " ".join(rec.get("tags") or [])
+        content = rec["content"]
+        score = 0.0
+        matched = 0
+        for term in terms:
+            hit = False
+            if term == _entry_title(rec):
+                score += 100; hit = True
+            elif term in title:
+                score += 30; hit = True
+            if term in trig:
+                score += 25; hit = True
+            if term in tag_text:
+                score += 15; hit = True
+            occurrences = content.count(term)
+            if occurrences:
+                score += 5 * min(occurrences, 3); hit = True
+            if hit:
+                matched += 1
+        if not matched:
+            continue
+        if matched == len(terms) and len(terms) > 1:
+            score *= 1.5
+        scored.append((score, rec))
+    scored.sort(key=lambda x: -x[0])
+    out = []
+    for score, rec in scored[:limit]:
+        item = {"id": rec["id"], "entry": rec.get("entry"), "title": rec.get("title"),
+                "source": rec.get("source"), "kind": rec.get("_kind"),
+                "tags": rec.get("tags") or [], "score": round(score, 1)}
+        if full:
+            item["content"] = rec["content"]
+        else:
+            pos = min((rec["content"].find(t) for t in terms
+                       if rec["content"].find(t) >= 0), default=0)
+            start = max(0, pos - 40)
+            item["snippet"] = rec["content"][start:start + SNIPPET_LEN].replace("\n", " ")
+        out.append(item)
+    return out

package/service/rover/logger.py

@@ -0,0 +1,102 @@
+"""日志。标准 logging + success/trace 两个额外级别。"""
+
+import logging
+import os
+import sys
+from typing import Any
+
+SUCCESS = 25
+TRACE = 5
+logging.addLevelName(SUCCESS, "SUCCESS")
+logging.addLevelName(TRACE, "TRACE")
+
+
+class RoverLogger(logging.Logger):
+    def success(self, msg: Any, *args: Any, **kwargs: Any) -> None:
+        if self.isEnabledFor(SUCCESS):
+            self._log(SUCCESS, msg, args, **kwargs)
+
+    def trace(self, msg: Any, *args: Any, **kwargs: Any) -> None:
+        if self.isEnabledFor(TRACE):
+            self._log(TRACE, msg, args, **kwargs)
+
+
+logging.setLoggerClass(RoverLogger)
+
+_COLORS = {
+    "TRACE": "\033[36m",
+    "DEBUG": "\033[36m",
+    "INFO": "\033[0m",
+    "SUCCESS": "\033[32m",
+    "WARNING": "\033[33m",
+    "ERROR": "\033[31m",
+    "CRITICAL": "\033[35m",
+}
+
+
+class _Formatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        color = _COLORS.get(record.levelname, "")
+        plain = record.levelname
+        record.levelname = f"{color}{plain:<8}\033[0m"
+        try:
+            return super().format(record)
+        finally:
+            # 同一条记录还要交给文件处理器, 不能把颜色码留在上面
+            record.levelname = plain
+
+
+# 落盘日志的容量上限: 单个文件 2MB, 连备份最多 4 个文件
+FILE_MAX_BYTES = 2 * 1024 * 1024
+FILE_BACKUPS = 3
+
+
+def _level() -> str:
+    try:
+        from rover.config import core_config
+
+        value = core_config.get_config("log_level")
+    except Exception:
+        value = ""
+    return str(os.getenv("ROVER_LOG_LEVEL") or value or "INFO").upper()
+
+
+def _file_handler() -> logging.Handler:
+    from logging.handlers import RotatingFileHandler
+
+    from rover.data_store import get_res_path
+
+    return RotatingFileHandler(
+        get_res_path("logs") / "service.log",
+        maxBytes=FILE_MAX_BYTES,
+        backupCount=FILE_BACKUPS,
+        encoding="utf-8",
+    )
+
+
+def _build() -> RoverLogger:
+    lg = logging.getLogger("rover")
+    if not isinstance(lg, RoverLogger):
+        # 本模块之前已有人建过同名 logger, 换成带 success/trace 的实现
+        lg.__class__ = RoverLogger
+    if lg.handlers:
+        return lg  # type: ignore[return-value]
+
+    lg.setLevel(_level())
+    fmt = "%(asctime)s | %(levelname)s | %(message)s"
+
+    stdout = logging.StreamHandler(sys.stdout)
+    stdout.setFormatter(_Formatter(fmt, "%m-%d %H:%M:%S"))
+    lg.addHandler(stdout)
+    try:
+        handler = _file_handler()
+        # 文件里不要 ANSI 颜色码
+        handler.setFormatter(logging.Formatter(fmt, "%m-%d %H:%M:%S"))
+        lg.addHandler(handler)
+    except OSError:
+        pass
+    lg.propagate = False
+    return lg  # type: ignore[return-value]
+
+
+logger: RoverLogger = _build()

package/service/rover/main.py

@@ -0,0 +1,33 @@
+"""服务入口: python -m rover.main [--host 127.0.0.1] [--port 9777]"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="鸣潮服务")
+    parser.add_argument("--host", default=os.getenv("ROVER_HOST", "127.0.0.1"))
+    parser.add_argument("--port", type=int, default=int(os.getenv("ROVER_PORT", "9777")))
+    args = parser.parse_args()
+
+    from rover.config import core_config
+
+    if str(core_config.get_config("PORT")) != str(args.port):
+        core_config.set_config("PORT", str(args.port))
+    if core_config.get_config("HOST") != args.host:
+        core_config.set_config("HOST", args.host)
+
+    import uvicorn
+
+    import rover.api  # noqa: F401  注册路由
+    from rover.app_life import app
+
+    uvicorn.run(app, host=args.host, port=args.port, log_level="warning", access_log=False)
+
+
+if __name__ == "__main__":
+    main()

package/service/rover/media.py

@@ -0,0 +1,222 @@
+"""媒体落盘与 HTML 载体。渲染产物存文件、对外给 /api/media/<id> 链接。"""
+
+import asyncio
+import hashlib
+import os
+import time
+from pathlib import Path
+from stat import S_ISREG
+from typing import Dict, List, Optional, Tuple
+
+from rover.data_store import get_res_path
+from rover.logger import logger
+
+MEDIA_DIR: Path = get_res_path() / "media"
+
+# 刚落盘的产物在此秒数内不参与超限淘汰, 避免删掉前端正在加载的卡片
+GRACE_SECONDS = 300
+# 超限淘汰的目标水位
+TARGET_RATIO = 0.8
+# 累计写入量达到此值才做一次目录扫描清理
+CHECK_BYTES = 32 * 1024 * 1024
+# 访问时刷新 mtime 的最小间隔
+TOUCH_INTERVAL = 60
+
+_written_bytes = 0
+
+
+def _max_bytes() -> int:
+    from rover.config import core_config
+
+    try:
+        return int(core_config.get_config("media_max_mb") or 0) * 1024 * 1024
+    except Exception:
+        return 512 * 1024 * 1024
+
+
+class HtmlBytes(bytes):
+    """HTML 渲染产物。是 bytes 子类, 因此能穿透插件内所有 `if img_bytes:` 判断。"""
+
+    html: str
+    template_name: str
+
+    def __new__(cls, html: str, template_name: str = ""):
+        obj = super().__new__(cls, html.encode("utf-8"))
+        obj.html = html
+        obj.template_name = template_name
+        return obj
+
+
+def save_media(data: bytes, ext: str = "jpg") -> str:
+    MEDIA_DIR.mkdir(parents=True, exist_ok=True)
+    digest = hashlib.sha1(data).hexdigest()[:20]
+    name = f"{digest}.{ext}"
+    path = MEDIA_DIR / name
+    if path.exists():
+        _touch(path)
+    else:
+        path.write_bytes(data)
+        _on_written(len(data))
+    return name
+
+
+async def render_png(name: str) -> Optional[Path]:
+    """把存好的 HTML 卡片用无头浏览器拍成 PNG, 按原始设计宽度出图, 结果缓存复用。"""
+    source = media_path(name)
+    if source is None or source.suffix != ".html":
+        return None
+    target = source.with_suffix(".png")
+    if target.is_file() and target.stat().st_mtime >= source.stat().st_mtime:
+        _touch(target)
+        return target
+
+    from playwright.async_api import async_playwright
+
+    async with async_playwright() as driver:
+        browser = await driver.chromium.launch(args=["--disable-gpu", "--disable-dev-shm-usage"])
+        try:
+            page = await browser.new_page(viewport={"width": 1600, "height": 1200})
+            await page.goto(source.as_uri(), wait_until="load")
+            # 桥接脚本没收到宿主宽度时不缩放, 量到的就是设计尺寸
+            await page.wait_for_timeout(600)
+            size = await page.evaluate(
+                "() => { const el = document.querySelector('.container') || document.body;"
+                " return { w: Math.ceil(el.scrollWidth), h: Math.ceil(el.scrollHeight) }; }"
+            )
+            width = max(1, min(int(size["w"]), 4000))
+            height = max(1, min(int(size["h"]), 30000))
+            await page.set_viewport_size({"width": width, "height": min(height, 2000)})
+            await page.wait_for_timeout(400)
+            data = await page.screenshot(
+                full_page=True, clip={"x": 0, "y": 0, "width": width, "height": height}
+            )
+        finally:
+            await browser.close()
+
+    target.write_bytes(data)
+    _on_written(len(data))
+    logger.info(f"[媒体] 卡片截图 {name} → {width}x{height} {len(data) // 1024}KB")
+    return target
+
+
+def media_url(name: str) -> str:
+    return f"/api/media/{name}"
+
+
+def media_path(name: str) -> Optional[Path]:
+    if "/" in name or "\\" in name or name.startswith("."):
+        return None
+    path = MEDIA_DIR / name
+    if not path.is_file():
+        return None
+    _touch(path)
+    return path
+
+
+def _touch(path: Path) -> None:
+    """刷新 mtime, 使淘汰顺序按最近使用时间。"""
+    try:
+        if time.time() - path.stat().st_mtime > TOUCH_INTERVAL:
+            os.utime(path, None)
+    except OSError:
+        pass
+
+
+def _on_written(size: int) -> None:
+    global _written_bytes
+    _written_bytes += size
+    if _written_bytes < CHECK_BYTES:
+        return
+    _written_bytes = 0
+    try:
+        cleanup_media()
+    except Exception as e:
+        logger.warning(f"[媒体清理] 写入触发的清理失败: {e}")
+
+
+def _scan() -> Tuple[List[Tuple[float, int, Path]], int]:
+    entries: List[Tuple[float, int, Path]] = []
+    total = 0
+    try:
+        it = list(MEDIA_DIR.iterdir())
+    except OSError:
+        return entries, total
+    for path in it:
+        try:
+            st = path.stat()
+        except OSError:
+            continue
+        if not S_ISREG(st.st_mode):
+            continue
+        entries.append((st.st_mtime, st.st_size, path))
+        total += st.st_size
+    return entries, total
+
+
+def media_usage() -> Dict[str, float]:
+    if not MEDIA_DIR.is_dir():
+        return {"files": 0, "bytes": 0, "mb": 0.0}
+    files = 0
+    total = 0
+    for path in MEDIA_DIR.iterdir():
+        if path.is_file():
+            files += 1
+            total += path.stat().st_size
+    return {"files": files, "bytes": total, "mb": total / 1024 / 1024}
+
+
+def cleanup_media() -> Dict[str, int]:
+    if not MEDIA_DIR.is_dir():
+        return {"removed": 0, "freed": 0, "remain": 0}
+    """超容量上限时按最久未使用淘汰到目标水位; 不按时间删, 历史卡片还引用着。"""
+    now = time.time()
+    limit = _max_bytes()
+    entries, total = _scan()
+    removed = 0
+    freed = 0
+    alive: List[Tuple[float, int, Path]] = list(entries)
+
+    if limit > 0 and total > limit:
+        target = int(limit * TARGET_RATIO)
+        alive.sort(key=lambda item: item[0])
+        for mtime, size, path in alive:
+            if total <= target:
+                break
+            if now - mtime < GRACE_SECONDS:
+                continue
+            try:
+                path.unlink()
+            except OSError:
+                continue
+            removed += 1
+            freed += size
+            total -= size
+
+    if removed:
+        logger.info(
+            f"[媒体清理] 删除 {removed} 个, 释放 {freed / 1048576:.1f}MB, "
+            f"剩余 {total / 1048576:.1f}MB / 上限 {limit / 1048576:.0f}MB"
+        )
+    return {
+        "removed": removed,
+        "freed_bytes": freed,
+        "remaining_bytes": total,
+        "limit_bytes": limit,
+    }
+
+
+async def _scheduled_cleanup() -> None:
+    await asyncio.to_thread(cleanup_media)
+
+
+def register_cleanup_job() -> None:
+    """注册周期清理, 由 app_life 在调度器启动前调用。"""
+    from rover.aps import scheduler
+
+    scheduler.add_job(
+        _scheduled_cleanup,
+        "interval",
+        minutes=30,
+        id="media_cleanup",
+        replace_existing=True,
+    )

package/service/rover/message_models.py

@@ -0,0 +1,23 @@
+from typing import List, Union, Literal, TypeVar, Optional
+
+from msgspec import Struct
+
+
+class Button(Struct):
+    text: str
+    data: str  # 具体数据
+    pressed_text: Optional[str] = None  # 按下之后显示的值
+    style: Literal[0, 1] = 1  # 0灰色线框，1蓝色线框
+    action: Literal[-1, 0, 1, 2] = -1  # 0跳转按钮，1回调按钮，2命令按钮, 【-1自适应】
+    permisson: Literal[0, 1, 2, 3] = 2  # 0指定用户，1管理者，2所有人可按，3指定身份组
+    specify_role_ids: List[str] = []  # 仅限频道可用
+    specify_user_ids: List[str] = []  # 指定用户
+    unsupport_tips: str = "您的客户端暂不支持该功能, 请升级后适配..."
+    prefix: str = ""  # 命令前缀, 使用时请直接继承该类重写该值, 避免重复定义
+    _edited: bool = False  # 是否编辑过
+
+
+T = TypeVar("T", bound=Button)
+
+ButtonType = Union[List[str], List[T], List[List[str]], List[List[T]]]
+ButtonList = Union[List[T], List[List[T]]]