nonebot-plugin-shitbot 0.1.1__tar.gz → 0.1.2__tar.gz

{nonebot_plugin_shitbot-0.1.1 → nonebot_plugin_shitbot-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-shitbot
-Version: 0.1.1
+Version: 0.1.2
 Summary: NoneBot shitpost plugin
 Requires-Python: >=3.10
 License-File: LICENSE

{nonebot_plugin_shitbot-0.1.1 → nonebot_plugin_shitbot-0.1.2}/README.md

@@ -1,6 +1,6 @@
 # Shitbot
 
-这项目目前是我自用的QQ机器人插件，正在逐步完善中
+这项目目前是我自用的基于Napcat端的QQ机器人插件，正在逐步完善中
 
 ## 已实现的功能
 
@@ -20,21 +20,30 @@
 
 ## TODO List（大致按优先级排序 但随缘想先解决哪个就解决哪个）
 
-- 实现自动回复管理系统
+- B站视频解析并下载（支持链接块或者BV号）
 
 - 添加单元测试
 
-- B站视频解析并下载（支持链接块或者BV号）
-
 - 实现 /stop 用于终止当前会话
 
 - 为代码添加更多注释 并按照nonebot所说的插件规范修改代码（？）
 
-- 给史搭一个数据库存起来管理 智能化/shitpost
-  - 提一嘴我打算怎么搭建数据库吧 将史的message键保存为json 如果是forward类型的则将其转换为node列表后打包为{"type": forward, "data": {"content": [node]}} 将json中提及的富媒体信息全部下载后重命名为其0xsha256sum值保存 并将json富媒体信息的url替换为对应的本地路径 最后将json重命名为其0xsha256sum值 这样无论是富媒体还是代表史的json文件都可以通过计算哈希值与已有的文件名比对来去重
-  - 添加一个记录json文件元数据的json文件（这算不算元元数据？）类型大概是Dict[str, Dict[str, Any]] 键是史的文件名 也就是哈希值 值中保存着史的：real_id列表 时间戳 好评数 发送失败次数 存储着已经发送过该史的群号的列表
+- 手搓数据库 用于自动回复系统以及搬史系统
+  - 数据库由两部分组成: messages以及medias
+  - messages用于存储信息 通过将 Message 转化为 DumpedMsg 后以 yaml 格式存储
+    -  文件名为该文件的sha256sum值 通过比较文件名去重
+    -  维护一个映射表（的yaml文件） 用于记录信息的引用数（由数据库用户维护） 通常若元信息的引用数为0 则删除元信息
+  - medias用于messages中信息中可能存在的多媒体文件
+    -  文件名为该文件的sha256sum值 通过比较文件名去重
+    -  维护一个映射表（的yaml文件） 用于记录文件的引用数（只会被messages中的信息引用 因此仅由数据库本身维护） 通常若元信息的引用数为0 则删除元信息
+
+- 基于上一点重构 /autoreply
+
+- 智能化/shitpost
+  - 使用用上面提到的数据库 
+  - 添加一个元信息映射表（yaml） 类型大概是Dict[str, Dict[str, Any]] 键是史的文件名 也就是哈希值 值中保存着史的：real_id列表 时间戳 好评数 发送失败次数 存储着已经发送过该史的群号的列表
 
-  - 添加一个json文件用于记录各个real_id对应的史的哈希值
+  - 维护一个yaml文件用于记录各个real_id对应的史的哈希值
 
   - 根据以上信息我瞎编了一个可能有用的发史优先级公式：
 

{nonebot_plugin_shitbot-0.1.1 → nonebot_plugin_shitbot-0.1.2}/nonebot_plugin_shitbot/aux.py

@@ -1,3 +1,4 @@
+import hashlib
 import shutil
 from pathlib import Path
 from typing import Any
@@ -50,6 +51,20 @@ async def rm_cache(group_id: str, user_id: str, pid: str):
     logger.info(f"已删除缓存: {cache_path}")
 
 
+def rename_file_to_sha256(file_path: Path | str):
+    file = Path(file_path) if isinstance(file_path, str) else file_path
+    if not file.is_file():
+        raise FileNotFoundError(f"No such file or not a regular file: {file}")
+    # Compute sha256sum
+    with file.open("rb") as f:
+        hash_hex = hashlib.file_digest(f, "sha256").hexdigest()
+    # Rename
+    new_name = hash_hex
+    new_path = file.with_name(new_name)
+    file.rename(new_path)
+    return new_path
+
+
 async def stuff_download(
     client: httpx.AsyncClient,
     url: str | httpx.URL,

nonebot_plugin_shitbot-0.1.2/nonebot_plugin_shitbot/commands/autoreply_cmd.py

@@ -0,0 +1,486 @@
+from __future__ import annotations
+
+import asyncio
+import uuid
+from pathlib import Path
+
+import httpx
+import yaml
+from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
+from nonebot.log import logger
+
+from ..aux import rename_file_to_sha256, rm_cache, stuff_download
+from ..command import BotCommand
+from ..config import config
+from ..msgutils import (
+    DataVariables,
+    DumpedMsg,
+    DumpedSeg,
+    dump_message,
+    get_multimedias_url,
+    modify_msg_data,
+    msg_filter,
+)
+from ..parser import BotArgParser
+from ..session import BotSession
+from ..tasks import EndOfQueue, autoreply_lock, prod_cons
+from .autoreply_main_cmd import BotCommandAutoReplyMain
+
+# Will be reconstructed after I implement the database
+class BotCommandAutoreply(BotCommand):
+    _name = "autoreply"
+    _autoreply_dir = BotCommandAutoReplyMain._autoreply_dir
+    _rule_path = BotCommandAutoReplyMain._rule_path
+    _msg_dir = BotCommandAutoReplyMain._msg_dir
+    _image_dir = BotCommandAutoReplyMain._image_dir
+
+    def __init__(self, bot: Bot, session: BotSession, *, _pid: int, _internal=None):
+        super().__init__(bot, session, _pid=_pid, _internal=_internal)
+        self._k: list[str] = []
+        self._v: list[str] = []
+        self._vstate: str = ""
+        self._l: int = 1
+        self._sum: list[str] = []
+        self._st: list[int] = []
+        self._d: list[str] = []
+        self._tm: list[str] = []
+        self._m: str = "equal"
+
+        self._prod_lock = asyncio.Lock()
+        self._cons_lock = asyncio.Lock()
+        self._is_accept_pic = False
+        self._urls = asyncio.Queue()
+        self._downloads = asyncio.Queue()
+        self._pics = asyncio.Queue()
+
+        self._rule = {}
+        self._temp_msg: DumpedMsg = []
+
+    async def _guard_state(self, new_argv=None):
+        if new_argv is None:
+            return False
+        # If new_argv is not value --start or not value --stop, handle it as normal
+        self._parser.parse_argv(new_argv)
+        subcmd = self._parser.subcmd
+        if subcmd != "value":
+            return await super()._guard_state()
+        subparser = self._parser.subparsers[subcmd]
+        is_stop = subparser.opts_value["--stop"][0]
+        is_start = subparser.opts_value["--start"][0] if not is_stop else 0
+        if not is_start and not is_stop:
+            return await super()._guard_state()
+
+        # Handle the case where new_argv is value --start
+        if self._argv is not None and is_start:
+            return await super()._guard_state()
+        if self._argv is None and is_start:
+            return True
+
+        # Handle the case where new_argv is value --stop and self._argv is None
+        if self._argv is None and is_stop:
+            tip = "错误：会话未开始\n"
+            tip += "尚未开始收集自动信息，请先使用 /autoreply value --start 开始收集。"
+            await self.send_msg(tip)
+            self.unlock()
+            return False
+        if self._argv is None:
+            return False
+
+        # Now handle the case where new_argv is value --stop and self._argv is not None
+        if self._vstate != "start":
+            return await super()._guard_state()
+        return True
+
+    def _init_parser(self):
+        parser = BotArgParser()
+        parser.set_rule(max=0, need_subcmd=True)
+
+        start = parser.add_subparser("start")
+        start.set_rule(max=0)
+
+        stop = parser.add_subparser("stop")
+        stop.set_rule(max=0)
+
+        create = parser.add_subparser("create")
+        create.set_rule(max=0)
+        create.add_opt("-k", required=True, max_appeared=None)
+        create.add_opt("-v", required=True, max_appeared=None)
+
+        delete = parser.add_subparser("delete")
+        delete.set_rule(max=0)
+        delete.add_opt("-k", required=True, max_appeared=None)
+        delete.add_opt("-v", required=True, max_appeared=None)
+
+        value = parser.add_subparser("value")
+        value.set_rule(min=1, max=1)
+        value.add_opt("--stop", default=[0])
+        value.add_opt("--start", default=[0])
+        value.add_opt("-l", required=True, type=int, default=[1])
+        value.add_opt("--sum", required=True, max_appeared=None)
+        value.add_opt("--st", required=True, type=int, max_appeared=None)
+
+        key = parser.add_subparser("key")
+        key.set_rule(min=1, max=1)
+        key.add_opt(
+            "--tm",
+            required=True,
+            choice=["delspace", "delmarks", "uppercase", "lowercase"],
+            max_appeared=None,
+            default=[],
+        )
+        key.add_opt("-d", required=True, max_appeared=None, default=[])
+        key.add_opt("-m", required=True, choice=["equal", "contain"], default=["equal"])
+        key.add_opt("-v", required=True, max_appeared=None, default=[])
+
+        return parser
+
+    @staticmethod
+    def _invert(flag: bool, exp: bool):
+        if flag:
+            return not exp
+        return exp
+
+    def _load_rule(self):
+        _rule = yaml.safe_load(self._rule_path.read_text(encoding="utf-8"))
+        if _rule is not None and not isinstance(_rule, dict):
+            raise ValueError
+        self._rule = _rule if _rule is not None else {}
+
+    def _update_rule(self):
+        with self._rule_path.open("w", encoding="utf-8") as f:
+            yaml.safe_dump(self._rule, f, allow_unicode=True)
+            arsession = BotSession.get_obj("public", "autoreply")
+            if arsession is None:
+                return
+            main_command = arsession.commands.get(arsession.curpid)
+            if main_command is None or not isinstance(
+                main_command, BotCommandAutoReplyMain
+            ):
+                return
+            main_command.load_rule()
+
+    @staticmethod
+    async def _url_to_download(
+        download_url: str, client: httpx.AsyncClient, download_dir: Path
+    ):
+        try:
+            filename = f"{uuid.uuid4().hex}"
+            save_path = download_dir / filename
+            await stuff_download(client, download_url, save_path)
+            logger.info(f"下载图片成功: {save_path}")
+            return str(save_path)
+        except Exception as e:
+            logger.error(f"下载图片失败 {download_url}: {e}")
+            return ""
+
+    @staticmethod
+    async def _download_to_pic(download_path: str, pic_dir: Path):
+        if download_path == "":
+            return ""
+
+        rename_path = rename_file_to_sha256(download_path)
+        pic_path = pic_dir / rename_path.name
+        async with autoreply_lock:
+            if not pic_path.exists():
+                rename_path.rename(pic_path)
+        return str(pic_path)
+
+    async def _start(self):
+        autoreply_session = BotSession.make("public", "autoreply")
+        main_command = BotCommandAutoReplyMain.make(
+            self.bot, autoreply_session, _pid=autoreply_session.curpid
+        )
+        if main_command is None:
+            await self.send_msg("警告: 自动回复正在运行中")
+        await self.send_msg("自动回复已开启")
+        self.unlock()
+
+    async def _stop(self):
+        async def _exe():
+            autoreply_session = BotSession.get_obj("public", "autoreply")
+            if autoreply_session is None:
+                await self.send_msg("警告: 自动回复未开启")
+                return
+            main_command = autoreply_session.commands.get(autoreply_session.curpid)
+            if main_command is None:
+                await self.send_msg("警告: 自动回复未开启")
+                return
+            main_command.unlock()
+
+        await _exe()
+        await self.send_msg("自动回复已关闭")
+        self.unlock()
+
+    async def _create_delete(self, mode):
+        if mode not in ["create", "delete"]:
+            return
+
+        verb = "创建" if mode == "create" else "删除"
+        flag = not mode == "create"
+        ptcl = "已" if mode == "create" else "不"
+
+        def _op1(flag: bool, dic: dict, key: str):
+            if flag:
+                return dic.pop(key)
+            dic[key] = [[], [], False, []]
+
+        def _op2(flag: bool, path: Path):
+            if flag:
+                return path.unlink()
+            path.touch(exist_ok=True)
+
+        async with autoreply_lock:
+            self._load_rule()
+            is_edited = False
+            for key in self._k:
+                if self._invert(flag, key in self._rule):
+                    await self.send_msg(f"警告: {key} {ptcl}存在")
+                    continue
+                _op1(flag, self._rule, key)
+                is_edited = True
+            if is_edited:
+                self._update_rule()
+            for value in self._v:
+                value_path = self._msg_dir / f"{value}.yaml"
+                if self._invert(flag, value_path.exists()):
+                    await self.send_msg(f"警告: {value} {ptcl}存在")
+                    continue
+                _op2(flag, value_path)
+            await self.send_msg(f"{verb}成功")
+            self.unlock()
+
+    async def _value_start(self, value_name: str):
+        if self._session is None:
+            return
+        value_path = self._msg_dir / f"{value_name}.yaml"
+        if not value_path.exists():
+            await self.send_msg(f"错误: {value_name} 不存在")
+            self.unlock()
+            return
+        downloads_dir = (
+            config.cache
+            / self._session.group_id
+            / self._session.user_id
+            / str(self._pid)
+            / "autoreply"
+        )
+        downloads_dir.mkdir(parents=True, exist_ok=True)
+
+        async def _urls_to_downloads():
+            try:
+                async with httpx.AsyncClient() as client:
+                    await prod_cons(
+                        self._urls,
+                        self._downloads,
+                        self._url_to_download,
+                        client,
+                        downloads_dir,
+                    )
+            except Exception as e:
+                logger.exception(f"urls_to_downloads 管道异常退出: {e}")
+
+        async def _downloads_to_pics():
+            try:
+                async with self._cons_lock:
+                    await prod_cons(
+                        self._downloads,
+                        self._pics,
+                        self._download_to_pic,
+                        self._image_dir,
+                    )
+            except Exception as e:
+                logger.exception(f"downloads_to_pics 管道异常退出: {e}")
+
+        asyncio.create_task(_urls_to_downloads())
+        asyncio.create_task(_downloads_to_pics())
+
+        logger.info(f"用户 {self._session.user_id} 开始为 {value_name} 设置具体信息")
+        await self.send_msg(
+            f"请发送仅包含图片或文字的信息, 或者发送 /autoreply value --stop {value_name} 停止设置"
+        )
+
+        self._is_accept_pic = True
+        self._value_name = value_name
+        return
+
+    async def _value_stop(self, value_name: str):
+        if not self.session:
+            return
+        self._is_accept_pic = False
+
+        async with self._prod_lock:
+            await self._urls.put(EndOfQueue())
+        async with self._cons_lock:
+            pass
+
+        pics = []
+        while True:
+            pic = await self._pics.get()
+            if isinstance(pic, EndOfQueue):
+                break
+            pics.append(pic)
+
+        self._temp_msg = modify_msg_data(
+            self._temp_msg,
+            {
+                "file": DataVariables([f"{Path(path).name}" for path in pics]),
+                "summary": DataVariables(self._sum),
+                "sub_type": DataVariables(self._st),
+            },
+            ["image"],
+            replace=True,
+        )
+        if self._temp_msg == []:
+            await self.send_msg("错误: 未受到任何信息")
+            await rm_cache(self.session.group_id, self.session.user_id, str(self._pid))
+            self.unlock()
+            return
+        async with autoreply_lock:
+            value_path = self._msg_dir / f"{value_name}.yaml"
+            value_path.write_text(yaml.safe_dump(self._temp_msg))
+
+        await self.send_msg("设置成功")
+        await rm_cache(self.session.group_id, self.session.user_id, str(self._pid))
+        self.unlock()
+        return
+
+    async def _value_modify(self, value_name: str):
+        if not self.session:
+            return
+        value_path = self._msg_dir / f"{value_name}.yaml"
+        if not value_path.exists():
+            await self.send_msg(f"错误: {value_name} 不存在")
+            self.unlock()
+            return
+        async with autoreply_lock:
+            self._temp_msg = yaml.safe_load(value_path.read_text(encoding="utf-8"))
+            self._temp_msg = modify_msg_data(
+                self._temp_msg,
+                {
+                    "summary": DataVariables(self._sum),
+                    "sub_type": DataVariables(self._st),
+                },
+                ["image"],
+                replace=False,
+            )
+            value_path.write_text(yaml.safe_dump(self._temp_msg))
+        await self.send_msg("修改成功")
+        self.unlock()
+
+    async def _key(self, key_name: str):
+        if not self.session:
+            return
+        key = key_name
+        async with autoreply_lock:
+            self._load_rule()
+            if key not in self._rule:
+                await self.send_msg(f"错误: {key} 不存在")
+                self.unlock()
+                return
+            self._rule[key][0] = self._tm[:]
+            self._rule[key][1] = self._d[:]
+            self._rule[key][2] = self._m == "contain"
+            self._rule[key][3] = self._v[:]
+            self._update_rule()
+            await self.send_msg("设置成功")
+            self.unlock()
+
+    async def roger(self, event: MessageEvent):
+        async with self._prod_lock:
+            if not self._is_accept_pic:
+                return
+            if self._l <= 0:
+                return
+            msg = await dump_message(self.bot, event.get_message())
+
+            def _filter(seg: DumpedSeg) -> bool:
+                if seg["type"] != "text" and seg["type"] != "image":
+                    return False
+                if seg["type"] == "text" and seg["data"].get("text") is None:
+                    return False
+                if seg["type"] == "image" and seg["data"].get("url") is None:
+                    return False
+                return True
+
+            msg = msg_filter(_filter, msg)
+            url_list = get_multimedias_url(msg, basetypes=["image"])
+            for url in url_list:
+                await self._urls.put(url)
+            self._temp_msg.extend(msg)
+            self._l -= 1
+            if self._l <= 0:
+                value_name = getattr(self, "_value_name", None)
+                if value_name is None:
+                    raise ValueError
+                asyncio.create_task(self.run(Message(f"value --stop {value_name}")))
+
+    async def run(self, args: Message):
+        if not self.session:
+            return
+        new_argv = args.extract_plain_text().strip().split()
+
+        if not await self._legal_case(new_argv):
+            if self._argv is None:
+                self.unlock()
+            return
+
+        if not await self._guard_state(new_argv):
+            return
+
+        self._argv = new_argv
+        self._parser.parse_argv(self._argv)
+        subcmd = self._parser.subcmd
+        if subcmd is None:
+            self.unlock()
+            return
+
+        if not self._check_perm("autoreplymanager"):
+            await self.send_msg("权限不足")
+            self.unlock()
+            return
+
+        subparser = self._parser.subparsers[subcmd]
+        self._k = subparser.opts_value.get("-k", [])
+        self._v = subparser.opts_value.get("-v", [])
+        if subparser.opts_value.get("--start", [0])[0]:
+            self._vstate = "start"
+        if subparser.opts_value.get("--stop", [0])[0]:
+            self._vstate = "stop"
+        _sum = subparser.opts_value.get("--sum", [])
+        _st = subparser.opts_value.get("--st", [])
+        if _sum or self._vstate != "stop":
+            self._sum = _sum
+        if _st or self._vstate != "stop":
+            self._st = _st
+        self._l = subparser.opts_value.get("-l", [1])[0]
+        self._d = subparser.opts_value.get("-d", [])
+        self._tm = subparser.opts_value.get("--tm", [])
+        self._m = subparser.opts_value.get("-m", ["equal"])[0]
+
+        if subcmd == "start":
+            await self._start()
+            return
+
+        if subcmd == "stop":
+            await self._stop()
+            return
+
+        if subcmd in ["create", "delete"]:
+            await self._create_delete(subcmd)
+            return
+
+        if subcmd == "value":
+            value_name = subparser.value[0]
+            if self._vstate == "start":
+                await self._value_start(value_name)
+                return
+            if self._vstate == "stop":
+                await self._value_stop(value_name)
+                return
+            await self._value_modify(value_name)
+            return
+
+        if subcmd == "key":
+            key_name = subparser.value[0]
+            await self._key(key_name)
+            return

nonebot_plugin_shitbot-0.1.2/nonebot_plugin_shitbot/commands/autoreply_main_cmd.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import random
+import re
+from typing import TYPE_CHECKING, Any
+
+import yaml
+from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
+
+from ..aux import validate_schema
+from ..command import BotCommand
+from ..config import config
+from ..msgutils import MSG_SCHEMA, DumpedSeg, msg_map, undump_message
+from ..tasks import autoreply_lock
+
+if TYPE_CHECKING:
+    from ..session import BotSession
+
+
+_LIST_SCHEMA = [[str], [str], bool, [str], None]
+
+
+# Simple auto reply, reconstructing.
+class BotCommandAutoReplyMain(BotCommand):
+    _name = "autoreply_main"
+    _autoreply_dir = config.data / "autoreply"
+    _rule_path = _autoreply_dir / "rule.yaml"
+    _msg_dir = _autoreply_dir / "messages"
+    _image_dir = _autoreply_dir / "images"
+    _contain_image_dir = config.client_base / _image_dir.relative_to(config.bot_base)
+    _rule: dict[str, list[Any]]
+
+    def __init__(self, bot: Bot, session: BotSession, *, _pid: int, _internal=None):
+        super().__init__(bot, session, _pid=_pid, _internal=_internal)
+        self._rule = {}
+
+    def load_rule(self):
+        _rule = yaml.safe_load(self._rule_path.read_text(encoding="utf-8"))
+        if _rule is not None and not isinstance(_rule, dict):
+            raise ValueError
+        self._rule = _rule if _rule is not None else {}
+
+    async def roger(self, event: MessageEvent):
+        group_id = str(getattr(event, "group_id", "private"))
+        if event.message_type == "private":
+            group_id = "private"
+        user_id = str(event.user_id)
+
+        rule_keys = self._rule.keys()
+        raw = event.get_message().extract_plain_text()
+
+        for key in rule_keys:
+            if len(self._rule[key]) < 4 or not validate_schema(
+                self._rule[key], _LIST_SCHEMA
+            ):
+                continue
+            text = raw
+            for trans in self._rule[key][0]:
+                if trans == "delspace":
+                    text = text.replace(" ", "")
+                if trans == "delmarks":
+                    text = re.sub(r"[^\w\s]", "", text)
+                if trans == "uppercase":
+                    text = text.upper()
+                if trans == "lowercase":
+                    text = text.lower()
+            for substr in self._rule[key][1]:
+                text = text.replace(substr, "")
+            if not (
+                (self._rule[key][2] and key in text)
+                or (not self._rule[key][2] and key == text)
+            ):
+                continue
+            if len(self._rule[key][3]) == 0:
+                continue
+            index = random.randint(0, len(self._rule[key][3]) - 1)
+            msg_name = self._rule[key][3][index]
+            msg_path = self._msg_dir / f"{msg_name}.yaml"
+            if not msg_path.exists():
+                continue
+            dumped_msg = yaml.safe_load(msg_path.read_text(encoding="utf-8"))
+            if not validate_schema(dumped_msg, MSG_SCHEMA):
+                continue
+
+            def _map(seg: DumpedSeg) -> DumpedSeg:
+                if seg["type"] != "image":
+                    return seg
+                seg["data"]["file"] = (
+                    f"file://{self._contain_image_dir / seg['data']['file']!s}"
+                )
+                return seg
+
+            dumped_msg = msg_map(_map, dumped_msg)
+
+            msg = undump_message(dumped_msg)
+            await self.send_msg(msg, group_id=group_id, user_id=user_id)
+            return
+
+    async def run(self, args: Message):
+        async with autoreply_lock:
+            self._autoreply_dir.mkdir(exist_ok=True, parents=True)
+            self._image_dir.mkdir(exist_ok=True)
+            self._msg_dir.mkdir(exist_ok=True)
+            self._rule_path.touch(exist_ok=True)
+            self.load_rule()

{nonebot_plugin_shitbot-0.1.1 → nonebot_plugin_shitbot-0.1.2}/nonebot_plugin_shitbot/commands/help_cmd.py

@@ -31,6 +31,7 @@ class BotCommandHelp(BotCommand):
         parser.add_subparser("advrandpic")
         parser.add_subparser("md2pic")
         parser.add_subparser("pixiv")
+        parser.add_subparser("autoreply")
         return parser
 
     async def run(self, args: Message):
@@ -52,7 +53,7 @@ class BotCommandHelp(BotCommand):
             self.unlock()
             return
 
-        help_dir = Path(__file__).resolve().parent.parent / "docs" / "help"
+        help_dir = Path(__file__).resolve().parent.parent / "help"
         tip = "错误: 帮助文档目录不存在"
         if help_dir.exists():
             tip = "错误: 帮助文档 index.md 不存在"
@@ -69,6 +70,7 @@ class BotCommandHelp(BotCommand):
             "advrandpic",
             "md2pic",
             "pixiv",
+            "autoreply",
         ):
             tip = f"错误: 帮助文档 {subcmd}.md 不存在"
             help_path = help_dir / f"{subcmd}.md"