nonebot-plugin-keyreply 0.1.3__tar.gz → 0.1.4__tar.gz

nonebot_plugin_keyreply-0.1.4/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: nonebot-plugin-keyreply
+Version: 0.1.4
+Summary: 基于NoneBot2的轻量级关键词自动回复插件
+Keywords: nonebot,nonebot2,keyreply,reply
+Author: yuexps@qq.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: nonebot-adapter-onebot (>=2.4.0,<3.0.0)
+Requires-Dist: nonebot-plugin-localstore (>=0.6.0,<1.0.0)
+Requires-Dist: nonebot2 (>=2.2.0,<3.0.0)
+Project-URL: Homepage, https://github.com/yuexps/nonebot-plugin-keyreply
+Project-URL: Repository, https://github.com/yuexps/nonebot-plugin-keyreply
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://adapter-onebot.netlify.app/"><img src="https://img.shields.io/badge/nonebot2-plugin-red.svg" alt="nonebot2"></a>
+  <a href="https://pypi.org/project/nonebot-plugin-keyreply"><img src="https://img.shields.io/pypi/v/nonebot-plugin-keyreply.svg" alt="pypi"></a>
+  <img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="python">
+</p>
+
+# nonebot-plugin-keyreply
+
+基于 NoneBot2 的轻量级关键词自动回复插件。
+
+## 特性
+
+- **群聊隔离**：各群聊及私聊数据完全独立，互不干扰。
+- **多种匹配**：支持 精确匹配（默认）、模糊匹配、正则匹配。
+- **权限受控**：管理指令限超级用户（`SUPERUSER`）或群管理（`GROUP_ADMIN | GROUP_OWNER`）执行。
+
+## 安装
+
+推荐使用 `nb-cli` 安装：
+```bash
+nb plugin install nonebot-plugin-keyreply
+```
+<details>
+<summary>或使用包管理器</summary>
+
+```bash
+pip install nonebot-plugin-keyreply
+```
+并在 `pyproject.toml` 或 `bot.py` 中加载插件：
+```toml
+plugins = ["nonebot_plugin_keyreply"]
+```
+</details>
+
+## 指令说明
+
+指令前缀默认为 `/reply`（实际取决于 `COMMAND_START` 配置）。
+
+| 指令格式 | 参数说明 | 匹配范围参数 | 示例 |
+| :--- | :--- | :--- | :--- |
+| `/reply add <关键词> <回复>` | `-f` 模糊匹配<br>`-r` 正则匹配 | `-g` 全局词条<br>`-p` 私聊词条 | `/reply add 菜单 "群菜单内容"`<br>`/reply add -f -g 帮助 帮助文档`<br>`/reply add -r -p "hi\|hello" 你好` |
+| `/reply edit <关键词> <新回复>` | - | `-g` 全局 / `-p` 私聊 | `/reply edit 菜单 "新菜单"` |
+| `/reply del <关键词>` | - | `-g` 全局 / `-p` 私聊 | `/reply del 菜单` |
+| `/reply list [关键词]` | - | `-g` 全局 / `-p` 私聊 | `/reply list`<br>`/reply list 菜单` |
+
+> [!IMPORTANT]
+> 添加、修改和删除全局（`-g`）与私聊（`-p`）规则仅限超级用户（`SUPERUSER`）执行，查询列表（`list`）不受此限制。
+> 如果关键词或回复内容**包含空格**，请使用双引号包裹，例如：`/reply add "早上 好" "您好！"`
+

nonebot_plugin_keyreply-0.1.4/README.md

@@ -0,0 +1,48 @@
+<p align="center">
+  <a href="https://adapter-onebot.netlify.app/"><img src="https://img.shields.io/badge/nonebot2-plugin-red.svg" alt="nonebot2"></a>
+  <a href="https://pypi.org/project/nonebot-plugin-keyreply"><img src="https://img.shields.io/pypi/v/nonebot-plugin-keyreply.svg" alt="pypi"></a>
+  <img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="python">
+</p>
+
+# nonebot-plugin-keyreply
+
+基于 NoneBot2 的轻量级关键词自动回复插件。
+
+## 特性
+
+- **群聊隔离**：各群聊及私聊数据完全独立，互不干扰。
+- **多种匹配**：支持 精确匹配（默认）、模糊匹配、正则匹配。
+- **权限受控**：管理指令限超级用户（`SUPERUSER`）或群管理（`GROUP_ADMIN | GROUP_OWNER`）执行。
+
+## 安装
+
+推荐使用 `nb-cli` 安装：
+```bash
+nb plugin install nonebot-plugin-keyreply
+```
+<details>
+<summary>或使用包管理器</summary>
+
+```bash
+pip install nonebot-plugin-keyreply
+```
+并在 `pyproject.toml` 或 `bot.py` 中加载插件：
+```toml
+plugins = ["nonebot_plugin_keyreply"]
+```
+</details>
+
+## 指令说明
+
+指令前缀默认为 `/reply`（实际取决于 `COMMAND_START` 配置）。
+
+| 指令格式 | 参数说明 | 匹配范围参数 | 示例 |
+| :--- | :--- | :--- | :--- |
+| `/reply add <关键词> <回复>` | `-f` 模糊匹配<br>`-r` 正则匹配 | `-g` 全局词条<br>`-p` 私聊词条 | `/reply add 菜单 "群菜单内容"`<br>`/reply add -f -g 帮助 帮助文档`<br>`/reply add -r -p "hi\|hello" 你好` |
+| `/reply edit <关键词> <新回复>` | - | `-g` 全局 / `-p` 私聊 | `/reply edit 菜单 "新菜单"` |
+| `/reply del <关键词>` | - | `-g` 全局 / `-p` 私聊 | `/reply del 菜单` |
+| `/reply list [关键词]` | - | `-g` 全局 / `-p` 私聊 | `/reply list`<br>`/reply list 菜单` |
+
+> [!IMPORTANT]
+> 添加、修改和删除全局（`-g`）与私聊（`-p`）规则仅限超级用户（`SUPERUSER`）执行，查询列表（`list`）不受此限制。
+> 如果关键词或回复内容**包含空格**，请使用双引号包裹，例如：`/reply add "早上 好" "您好！"`

nonebot_plugin_keyreply-0.1.4/nonebot_plugin_keyreply/__init__.py

@@ -0,0 +1,277 @@
+import shlex
+from nonebot import on_command, on_message, require
+from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
+from nonebot.adapters.onebot.v11.permission import GROUP_ADMIN, GROUP_OWNER
+from nonebot.params import CommandArg
+from nonebot.permission import SUPERUSER
+from nonebot.plugin import PluginMetadata
+
+require("nonebot_plugin_localstore")
+import nonebot_plugin_localstore as store
+
+from .rule_manager import RuleManager
+
+__plugin_meta__ = PluginMetadata(
+    name="KeyReply",
+    description="基于 NoneBot2 的轻量级关键词自动回复插件",
+    usage=(
+        "管理指令：/reply\n"
+        "1. 添加：/reply add [-f 模糊 | -r 正则] [-g 全局 | -p 私聊] <关键词> <回复内容>\n"
+        "2. 修改：/reply edit [-g 全局 | -p 私聊] <关键词> <新回复内容>\n"
+        "3. 删除：/reply del [-g 全局 | -p 私聊] <关键词>\n"
+        "4. 列表/查看：/reply list [-g 全局 | -p 私聊] [关键词]"
+    ),
+    type="application",
+    homepage="https://github.com/yuexps/nonebot-plugin-keyreply",
+    supported_adapters={"~onebot.v11"},
+)
+
+rule_manager = RuleManager(store.get_plugin_data_file("rules.json"))
+
+# 管理命令
+reply_cmd = on_command(
+    "reply",
+    permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER,
+    priority=5,
+    block=True,
+)
+
+
+@reply_cmd.handle()
+async def handle_reply(bot: Bot, event: MessageEvent, command_arg: Message = CommandArg()):
+    # 提取参数文本
+    args_str = command_arg.extract_plain_text().strip()
+    if not args_str:
+        await reply_cmd.finish(__plugin_meta__.usage)
+
+    # 解析参数
+    try:
+        args = shlex.split(args_str)
+    except ValueError as e:
+        await reply_cmd.finish(f"参数解析错误：{str(e)}（请检查双引号是否闭合）")
+
+    sub_cmd = args[0].lower()
+    is_superuser = await SUPERUSER(bot, event)
+
+    if sub_cmd == "add":
+        match_type = "exact"
+        is_global = False
+        is_private = False
+        clean_args = []
+        for arg in args[1:]:
+            if arg in ("-f", "--fuzzy"):
+                match_type = "fuzzy"
+            elif arg in ("-r", "--regex"):
+                match_type = "regex"
+            elif arg in ("-g", "--global"):
+                is_global = True
+            elif arg in ("-p", "--private"):
+                is_private = True
+            else:
+                clean_args.append(arg)
+
+        if len(clean_args) < 2:
+            await reply_cmd.finish("格式错误：reply add [-f|-r] [-g|-p] <关键词> <回复内容>")
+
+        if is_global and is_private:
+            await reply_cmd.finish("格式错误：不能同时指定全局(-g)和私聊(-p)")
+
+        if (is_global or is_private) and not is_superuser:
+            await reply_cmd.finish("权限不足：仅超级用户有权配置全局/私聊词条")
+
+        if is_global:
+            group_id = "global"
+        elif is_private:
+            group_id = "private"
+        else:
+            group_id = str(event.group_id) if isinstance(event, GroupMessageEvent) else "private"
+
+        key = clean_args[0]
+        reply = " ".join(clean_args[1:])
+
+        match_types = {"exact": "精确匹配", "fuzzy": "模糊匹配", "regex": "正则匹配"}
+        rule_manager.add_rule(key, reply, match_type, group_id)
+        scope_map = {"global": "全局", "private": "私聊"}
+        scope = scope_map.get(group_id, f"群 {group_id}")
+        await reply_cmd.finish(f"添加成功！[{scope}] 关键词「{key}」-> 「{reply}」[类型: {match_types.get(match_type, match_type)}]")
+
+    elif sub_cmd == "edit":
+        is_global = False
+        is_private = False
+        clean_args = []
+        for arg in args[1:]:
+            if arg in ("-g", "--global"):
+                is_global = True
+            elif arg in ("-p", "--private"):
+                is_private = True
+            else:
+                clean_args.append(arg)
+
+        if len(clean_args) < 2:
+            await reply_cmd.finish("格式错误：reply edit [-g|-p] <关键词> <新回复内容>")
+
+        if is_global and is_private:
+            await reply_cmd.finish("格式错误：不能同时指定全局(-g)和私聊(-p)")
+
+        if (is_global or is_private) and not is_superuser:
+            await reply_cmd.finish("权限不足：仅超级用户有权配置全局/私聊词条")
+
+        if is_global:
+            group_id = "global"
+        elif is_private:
+            group_id = "private"
+        else:
+            group_id = str(event.group_id) if isinstance(event, GroupMessageEvent) else "private"
+
+        key = clean_args[0]
+        reply = " ".join(clean_args[1:])
+
+        success = rule_manager.edit_rule(key, reply, group_id)
+        if success:
+            scope_map = {"global": "全局", "private": "私聊"}
+            scope = scope_map.get(group_id, f"群 {group_id}")
+            await reply_cmd.finish(f"修改成功！已覆盖 [{scope}] 关键词「{key}」的回复")
+        else:
+            await reply_cmd.finish(f"修改失败：未找到该范围内对应的关键词「{key}」")
+
+    elif sub_cmd == "del":
+        is_global = False
+        is_private = False
+        clean_args = []
+        for arg in args[1:]:
+            if arg in ("-g", "--global"):
+                is_global = True
+            elif arg in ("-p", "--private"):
+                is_private = True
+            else:
+                clean_args.append(arg)
+
+        if len(clean_args) < 1:
+            await reply_cmd.finish("格式错误：reply del [-g|-p] <关键词>")
+
+        if is_global and is_private:
+            await reply_cmd.finish("格式错误：不能同时指定全局(-g)和私聊(-p)")
+
+        if (is_global or is_private) and not is_superuser:
+            await reply_cmd.finish("权限不足：仅超级用户有权配置全局/私聊词条")
+
+        if is_global:
+            group_id = "global"
+        elif is_private:
+            group_id = "private"
+        else:
+            group_id = str(event.group_id) if isinstance(event, GroupMessageEvent) else "private"
+            
+        key = clean_args[0]
+
+        success = rule_manager.del_rule(key, group_id)
+        if success:
+            scope_map = {"global": "全局", "private": "私聊"}
+            scope = scope_map.get(group_id, f"群 {group_id}")
+            await reply_cmd.finish(f"删除成功！已移除 [{scope}] 关键词「{key}」")
+        else:
+            await reply_cmd.finish(f"删除失败：未找到该范围内对应的关键词「{key}」")
+
+    elif sub_cmd == "list":
+        is_global = False
+        is_private = False
+        clean_args = []
+        for arg in args[1:]:
+            if arg in ("-g", "--global"):
+                is_global = True
+            elif arg in ("-p", "--private"):
+                is_private = True
+            else:
+                clean_args.append(arg)
+
+        if is_global and is_private:
+            await reply_cmd.finish("格式错误：不能同时指定全局(-g)和私聊(-p)")
+
+        if is_global:
+            group_id = "global"
+        elif is_private:
+            group_id = "private"
+        else:
+            group_id = str(event.group_id) if isinstance(event, GroupMessageEvent) else "private"
+
+        if len(clean_args) == 0:
+            if is_global or group_id == "global":
+                rules = rule_manager.get_rules_for_group("global")
+                if not rules:
+                    await reply_cmd.finish("当前无生效的全局词条")
+                lines = [f"- {r.key}" for r in rules]
+                await reply_cmd.finish("当前生效的全局词条关键词列表：\n" + "\n".join(lines))
+            elif is_private or group_id == "private":
+                private_rules = rule_manager.get_rules_for_group("private")
+                global_rules = rule_manager.get_rules_for_group("global")
+                if not private_rules and not global_rules:
+                    await reply_cmd.finish("当前无生效的私聊词条")
+
+                msg_parts = []
+                if private_rules:
+                    msg_parts.append("【私聊词条】")
+                    msg_parts.extend(f"- {r.key}" for r in private_rules)
+                if global_rules:
+                    if msg_parts:
+                        msg_parts.append("")
+                    msg_parts.append("【全局词条】")
+                    msg_parts.extend(f"- {r.key}" for r in global_rules)
+
+                await reply_cmd.finish("当前生效的词条关键词列表：\n" + "\n".join(msg_parts))
+            else:
+                group_rules = rule_manager.get_rules_for_group(group_id)
+                global_rules = rule_manager.get_rules_for_group("global")
+                if not group_rules and not global_rules:
+                    await reply_cmd.finish("当前无生效的词条")
+
+                msg_parts = []
+                if group_rules:
+                    msg_parts.append("【本群词条】")
+                    msg_parts.extend(f"- {r.key}" for r in group_rules)
+                if global_rules:
+                    if msg_parts:
+                        msg_parts.append("")
+                    msg_parts.append("【全局词条】")
+                    msg_parts.extend(f"- {r.key}" for r in global_rules)
+
+                await reply_cmd.finish("当前生效的词条关键词列表：\n" + "\n".join(msg_parts))
+        else:
+            # 查询指定关键词
+            key = clean_args[0]
+            rule = rule_manager.get_rule(key, group_id)
+            if not rule and group_id != "global":
+                # 在当前上下文没找到时，也去全局找一下
+                rule = rule_manager.get_rule(key, "global")
+
+            if rule:
+                scope_map = {"global": "全局", "private": "私聊"}
+                scope = scope_map.get(rule.group_id, f"群 {rule.group_id}")
+                match_types = {"exact": "精确匹配", "fuzzy": "模糊匹配", "regex": "正则匹配"}
+                reply_text = (
+                    f"词条信息：\n"
+                    f"关键词：{rule.key}\n"
+                    f"回复内容：{rule.reply}\n"
+                    f"匹配类型：{match_types.get(rule.match_type, rule.match_type)}\n"
+                    f"生效范围：{scope}"
+                )
+                await reply_cmd.finish(reply_text)
+            else:
+                await reply_cmd.finish(f"未找到对应的关键词「{key}」")
+    else:
+        await reply_cmd.finish(f"未知子命令：{sub_cmd}\n{__plugin_meta__.usage}")
+
+
+# 自动回复监听器
+message_reply = on_message(priority=99, block=False)
+
+
+@message_reply.handle()
+async def handle_message(bot: Bot, event: MessageEvent):
+    text = event.get_plaintext().strip()
+    if not text:
+        return
+
+    group_id = str(event.group_id) if isinstance(event, GroupMessageEvent) else "private"
+    matched = rule_manager.match(text, group_id)
+    if matched:
+        await message_reply.send(message=matched.reply)

nonebot_plugin_keyreply-0.1.4/nonebot_plugin_keyreply/rule_manager.py

@@ -0,0 +1,136 @@
+import json
+import re
+from pathlib import Path
+from typing import Dict, List, Literal, Optional
+from pydantic import BaseModel
+
+
+class ReplyRule(BaseModel):
+    key: str
+    reply: str
+    match_type: Literal["exact", "fuzzy", "regex"] = "exact"
+    group_id: str = "global"
+
+
+class RuleManager:
+    def __init__(self, data_path: Path):
+        self.data_path = data_path
+        self._rules: Dict[str, List[ReplyRule]] = {}
+        self.load()
+
+    @property
+    def rules(self) -> List[ReplyRule]:
+        """获取扁平化的所有规则列表"""
+        all_rules = []
+        for group_rules in self._rules.values():
+            all_rules.extend(group_rules)
+        return all_rules
+
+    def load(self) -> None:
+        """从本地文件加载规则字典"""
+        if not self.data_path.exists():
+            self._rules = {}
+            return
+        try:
+            with open(self.data_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                self._rules = {}
+                if isinstance(data, dict):
+                    for group_id, items in data.items():
+                        rules_list = []
+                        for item in items:
+                            item["group_id"] = group_id
+                            rules_list.append(ReplyRule(**item))
+                        self._rules[group_id] = rules_list
+        except Exception:
+            self._rules = {}
+
+    def save(self) -> None:
+        """保存规则字典到本地文件"""
+        try:
+            self.data_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.data_path, "w", encoding="utf-8") as f:
+                data_to_save = {}
+                for group_id, rules in self._rules.items():
+                    group_rules = []
+                    for r in rules:
+                        if hasattr(r, "model_dump"):
+                            r_dict = r.model_dump()
+                        else:
+                            r_dict = r.dict()
+                        r_dict.pop("group_id", None)
+                        group_rules.append(r_dict)
+                    data_to_save[group_id] = group_rules
+                json.dump(data_to_save, f, ensure_ascii=False, indent=2)
+        except Exception:
+            pass
+
+    def add_rule(self, key: str, reply: str, match_type: Literal["exact", "fuzzy", "regex"], group_id: str) -> None:
+        """添加或覆盖规则"""
+        if group_id not in self._rules:
+            self._rules[group_id] = []
+        self._rules[group_id] = [r for r in self._rules[group_id] if r.key != key]
+        self._rules[group_id].append(ReplyRule(key=key, reply=reply, match_type=match_type, group_id=group_id))
+        self.save()
+
+    def edit_rule(self, key: str, reply: str, group_id: str) -> bool:
+        """修改规则，若不存在则返回 False"""
+        if group_id in self._rules:
+            for r in self._rules[group_id]:
+                if r.key == key:
+                    r.reply = reply
+                    self.save()
+                    return True
+        return False
+
+    def del_rule(self, key: str, group_id: str) -> bool:
+        """删除指定规则，若不存在则返回 False"""
+        if group_id not in self._rules:
+            return False
+        original_len = len(self._rules[group_id])
+        self._rules[group_id] = [r for r in self._rules[group_id] if r.key != key]
+        if len(self._rules[group_id]) < original_len:
+            if not self._rules[group_id]:
+                del self._rules[group_id]
+            self.save()
+            return True
+        return False
+
+    def get_rule(self, key: str, group_id: str) -> Optional[ReplyRule]:
+        """获取特定的规则"""
+        if group_id in self._rules:
+            for r in self._rules[group_id]:
+                if r.key == key:
+                    return r
+        return None
+
+    def get_rules_for_group(self, group_id: str) -> List[ReplyRule]:
+        """获取指定群/范围生效的规则"""
+        return self._rules.get(group_id, [])
+
+    def _match_rules(self, text: str, rules: List[ReplyRule]) -> Optional[ReplyRule]:
+        """匹配规则列表"""
+        for rule in rules:
+            if rule.match_type == "exact":
+                if text == rule.key:
+                    return rule
+            elif rule.match_type == "fuzzy":
+                if rule.key in text:
+                    return rule
+            elif rule.match_type == "regex":
+                try:
+                    if re.search(rule.key, text):
+                        return rule
+                except re.error:
+                    continue
+        return None
+
+    def match(self, text: str, group_id: str) -> Optional[ReplyRule]:
+        """匹配规则，群聊未中时回退全局"""
+        matched = self._match_rules(text, self.get_rules_for_group(group_id))
+        if matched:
+            return matched
+        if group_id != "global":
+            return self._match_rules(text, self.get_rules_for_group("global"))
+        return None
+

{nonebot_plugin_keyreply-0.1.3 → nonebot_plugin_keyreply-0.1.4}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "nonebot-plugin-keyreply"
-version = "0.1.3"
-description = "根据设定好的关键词进行自动回复词条的插件"
+version = "0.1.4"
+description = "基于NoneBot2的轻量级关键词自动回复插件"
 authors = ["yuexps@qq.com"]
 readme = "README.md"
 homepage = "https://github.com/yuexps/nonebot-plugin-keyreply"
@@ -23,6 +23,7 @@ packages = [
 python = "^3.9"
 nonebot2 = "^2.2.0"
 nonebot-adapter-onebot = "^2.4.0"
+nonebot-plugin-localstore = ">=0.6.0,<1.0.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

nonebot_plugin_keyreply-0.1.3/PKG-INFO

@@ -1,103 +0,0 @@
-Metadata-Version: 2.4
-Name: nonebot-plugin-keyreply
-Version: 0.1.3
-Summary: 根据设定好的关键词进行自动回复词条的插件
-Keywords: nonebot,nonebot2,keyreply,reply
-Author: yuexps@qq.com
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: nonebot-adapter-onebot (>=2.4.0,<3.0.0)
-Requires-Dist: nonebot2 (>=2.2.0,<3.0.0)
-Project-URL: Homepage, https://github.com/yuexps/nonebot-plugin-keyreply
-Project-URL: Repository, https://github.com/yuexps/nonebot-plugin-keyreply
-Description-Content-Type: text/markdown
-
-# KeyReply 插件
-
-Nonebot2 根据关键词自动回复设定词条的插件。
-
-## 安装
-
-### 使用 nb-cli 安装 (推荐)
-在你的 NoneBot 项目根目录下运行：
-```bash
-nb plugin install nonebot-plugin-keyreply
-```
-
-<details>
-<summary><b>使用包管理器安装</b></summary>
-
-根据你使用的包管理器，在 NoneBot 项目中运行：
-
-* **pip**:
-  ```bash
-  pip install nonebot-plugin-keyreply
-  ```
-* **pdm**:
-  ```bash
-  pdm add nonebot-plugin-keyreply
-  ```
-* **poetry**:
-  ```bash
-  poetry add nonebot-plugin-keyreply
-  ```
-
-随后在项目的配置文件中（如 `pyproject.toml` 的 `plugins` 列表中）添加：
-```toml
-plugins = ["nonebot_plugin_keyreply"]
-```
-</details>
-
-## 核心特性
-
-- **群聊隔离**：群聊自动回复仅匹配当前群配置的专属词条，各群数据完全隔离，不互相干扰。
-- **多种匹配模式**：支持精确匹配（默认）、模糊匹配（包含匹配）以及正则表达式匹配。
-- **管理权限受控**：词条的添加、修改和删除指令仅限超级用户（`SUPERUSER`）或群管理员/群主（`GROUP_ADMIN | GROUP_OWNER`）执行。
-
-## 指令说明
-
-所有指令前缀默认为 `/reply`（实际前缀取决于您的 Nonebot 配置文件中的 `COMMAND_START` 设定）。
-
-### 1. 添加词条
-* **指令格式**：`/reply add [-f|-r] [-g] <关键词> <回复内容>`
-* **参数说明**：
-  - `-f` / `--fuzzy`：设置为模糊匹配（即消息中包含该关键词即可触发回复）。
-  - `-r` / `--regex`：设置为正则表达式匹配（消息内容符合该正则表达式即可触发回复）。
-  - `-g` / `--global`：设置为全局词条（仅超级用户可配置）。若在群聊中不加此参数，词条将仅在当前群生效；若在私聊中配置，默认即为全局生效。
-* **双引号规范**：
-  - 如果关键词或回复内容**不含空格**，直接以空格分隔即可：  
-    `/reply add 测试 收到`
-  - 如果关键词或回复内容中**包含空格**，请使用双引号包裹：  
-    `/reply add "早上 好" "您好！今天也是元气满满的一天！"`
-
-### 2. 修改词条（覆盖）
-* **指令格式**：`/reply edit [-g] <关键词> <新回复内容>`
-* **说明**：覆盖修改指定关键词的回复内容。
-
-### 3. 删除词条
-* **指令格式**：`/reply del [-g] <关键词>`
-* **说明**：删除指定关键词的回复规则。
-
-### 4. 列表与详情查询
-* **指令格式**：
-  - `/reply list [-g]`：列出当前生效的所有词条关键词列表。
-  - `/reply list [-g] <关键词>`：查看指定关键词的匹配规则、具体回复内容与生效范围等详情。
-
----
-
-## 插件配置项
-
-您可以在 Nonebot2 的 `.env.*` 配置文件中添加以下配置：
-
-```env
-# 词条规则保存的文件路径（相对于项目根目录）
-KEYREPLY_DATA_PATH="data/keyreply/rules.json"
-```
-

nonebot_plugin_keyreply-0.1.3/README.md

@@ -1,81 +0,0 @@
-# KeyReply 插件
-
-Nonebot2 根据关键词自动回复设定词条的插件。
-
-## 安装
-
-### 使用 nb-cli 安装 (推荐)
-在你的 NoneBot 项目根目录下运行：
-```bash
-nb plugin install nonebot-plugin-keyreply
-```
-
-<details>
-<summary><b>使用包管理器安装</b></summary>
-
-根据你使用的包管理器，在 NoneBot 项目中运行：
-
-* **pip**:
-  ```bash
-  pip install nonebot-plugin-keyreply
-  ```
-* **pdm**:
-  ```bash
-  pdm add nonebot-plugin-keyreply
-  ```
-* **poetry**:
-  ```bash
-  poetry add nonebot-plugin-keyreply
-  ```
-
-随后在项目的配置文件中（如 `pyproject.toml` 的 `plugins` 列表中）添加：
-```toml
-plugins = ["nonebot_plugin_keyreply"]
-```
-</details>
-
-## 核心特性
-
-- **群聊隔离**：群聊自动回复仅匹配当前群配置的专属词条，各群数据完全隔离，不互相干扰。
-- **多种匹配模式**：支持精确匹配（默认）、模糊匹配（包含匹配）以及正则表达式匹配。
-- **管理权限受控**：词条的添加、修改和删除指令仅限超级用户（`SUPERUSER`）或群管理员/群主（`GROUP_ADMIN | GROUP_OWNER`）执行。
-
-## 指令说明
-
-所有指令前缀默认为 `/reply`（实际前缀取决于您的 Nonebot 配置文件中的 `COMMAND_START` 设定）。
-
-### 1. 添加词条
-* **指令格式**：`/reply add [-f|-r] [-g] <关键词> <回复内容>`
-* **参数说明**：
-  - `-f` / `--fuzzy`：设置为模糊匹配（即消息中包含该关键词即可触发回复）。
-  - `-r` / `--regex`：设置为正则表达式匹配（消息内容符合该正则表达式即可触发回复）。
-  - `-g` / `--global`：设置为全局词条（仅超级用户可配置）。若在群聊中不加此参数，词条将仅在当前群生效；若在私聊中配置，默认即为全局生效。
-* **双引号规范**：
-  - 如果关键词或回复内容**不含空格**，直接以空格分隔即可：  
-    `/reply add 测试 收到`
-  - 如果关键词或回复内容中**包含空格**，请使用双引号包裹：  
-    `/reply add "早上 好" "您好！今天也是元气满满的一天！"`
-
-### 2. 修改词条（覆盖）
-* **指令格式**：`/reply edit [-g] <关键词> <新回复内容>`
-* **说明**：覆盖修改指定关键词的回复内容。
-
-### 3. 删除词条
-* **指令格式**：`/reply del [-g] <关键词>`
-* **说明**：删除指定关键词的回复规则。
-
-### 4. 列表与详情查询
-* **指令格式**：
-  - `/reply list [-g]`：列出当前生效的所有词条关键词列表。
-  - `/reply list [-g] <关键词>`：查看指定关键词的匹配规则、具体回复内容与生效范围等详情。
-
----
-
-## 插件配置项
-
-您可以在 Nonebot2 的 `.env.*` 配置文件中添加以下配置：
-
-```env
-# 词条规则保存的文件路径（相对于项目根目录）
-KEYREPLY_DATA_PATH="data/keyreply/rules.json"
-```

nonebot_plugin_keyreply-0.1.3/nonebot_plugin_keyreply/__init__.py

@@ -1,200 +0,0 @@
-import shlex
-from nonebot import get_plugin_config, on_command, on_message
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
-from nonebot.adapters.onebot.v11.permission import GROUP_ADMIN, GROUP_OWNER
-from nonebot.params import CommandArg
-from nonebot.permission import SUPERUSER
-from nonebot.plugin import PluginMetadata
-
-from .config import Config
-from .rule_manager import RuleManager
-
-__plugin_meta__ = PluginMetadata(
-    name="KeyReply",
-    description="根据设定好的关键词进行自动回复词条的插件",
-    usage=(
-        "管理指令：/reply\n"
-        "1. 添加：/reply add [-f 模糊 | -r 正则] [-g 全局] <关键词> <回复内容>\n"
-        "2. 修改：/reply edit [-g 全局] <关键词> <新回复内容>\n"
-        "3. 删除：/reply del [-g 全局] <关键词>\n"
-        "4. 列表/查看：/reply list [-g 全局] [关键词]"
-    ),
-    type="application",
-    homepage="https://github.com/yuexps/nonebot-plugin-keyreply",
-    config=Config,
-    supported_adapters={"~onebot.v11"},
-)
-
-config = get_plugin_config(Config)
-rule_manager = RuleManager(config.keyreply_data_path)
-
-# 管理命令
-reply_cmd = on_command(
-    "reply",
-    permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER,
-    priority=5,
-    block=True,
-)
-
-
-@reply_cmd.handle()
-async def handle_reply(bot: Bot, event: MessageEvent, command_arg: Message = CommandArg()):
-    # 提取参数文本
-    args_str = command_arg.extract_plain_text().strip()
-    if not args_str:
-        await reply_cmd.finish(__plugin_meta__.usage)
-
-    # 解析参数
-    try:
-        args = shlex.split(args_str)
-    except ValueError as e:
-        await reply_cmd.finish(f"参数解析错误：{str(e)}（请检查双引号是否闭合）")
-
-    sub_cmd = args[0].lower()
-    is_superuser = await SUPERUSER(bot, event)
-
-    if sub_cmd == "add":
-        # 解析参数
-        match_type = "exact"
-        is_global = False
-        clean_args = []
-        for arg in args[1:]:
-            if arg in ("-f", "--fuzzy"):
-                match_type = "fuzzy"
-            elif arg in ("-r", "--regex"):
-                match_type = "regex"
-            elif arg in ("-g", "--global"):
-                is_global = True
-            else:
-                clean_args.append(arg)
-
-        if len(clean_args) < 2:
-            await reply_cmd.finish("格式错误：reply add [-f|-r] [-g] <关键词> <回复内容>")
-
-        if is_global and not is_superuser:
-            await reply_cmd.finish("权限不足：仅超级用户有权配置全局词条")
-
-        group_id = "global" if (is_global or not isinstance(event, GroupMessageEvent)) else str(event.group_id)
-        key = clean_args[0]
-        reply = " ".join(clean_args[1:])
-
-        match_types = {"exact": "精确匹配", "fuzzy": "模糊匹配", "regex": "正则匹配"}
-        rule_manager.add_rule(key, reply, match_type, group_id)
-        scope = "全局" if group_id == "global" else f"群 {group_id}"
-        await reply_cmd.finish(f"添加成功！[{scope}] 关键词「{key}」-> 「{reply}」[类型: {match_types.get(match_type, match_type)}]")
-
-    elif sub_cmd == "edit":
-        is_global = False
-        clean_args = []
-        for arg in args[1:]:
-            if arg in ("-g", "--global"):
-                is_global = True
-            else:
-                clean_args.append(arg)
-
-        if len(clean_args) < 2:
-            await reply_cmd.finish("格式错误：reply edit [-g] <关键词> <新回复内容>")
-
-        if is_global and not is_superuser:
-            await reply_cmd.finish("权限不足：仅超级用户有权配置全局词条")
-
-        group_id = "global" if (is_global or not isinstance(event, GroupMessageEvent)) else str(event.group_id)
-        key = clean_args[0]
-        reply = " ".join(clean_args[1:])
-
-        success = rule_manager.edit_rule(key, reply, group_id)
-        if success:
-            scope = "全局" if group_id == "global" else f"群 {group_id}"
-            await reply_cmd.finish(f"修改成功！已覆盖 [{scope}] 关键词「{key}」的回复")
-        else:
-            await reply_cmd.finish(f"修改失败：未找到该范围内对应的关键词「{key}」")
-
-    elif sub_cmd == "del":
-        is_global = False
-        clean_args = []
-        for arg in args[1:]:
-            if arg in ("-g", "--global"):
-                is_global = True
-            else:
-                clean_args.append(arg)
-
-        if len(clean_args) < 1:
-            await reply_cmd.finish("格式错误：reply del [-g] <关键词>")
-
-        if is_global and not is_superuser:
-            await reply_cmd.finish("权限不足：仅超级用户有权配置全局词条")
-
-        group_id = "global" if (is_global or not isinstance(event, GroupMessageEvent)) else str(event.group_id)
-        key = clean_args[0]
-
-        success = rule_manager.del_rule(key, group_id)
-        if success:
-            scope = "全局" if group_id == "global" else f"群 {group_id}"
-            await reply_cmd.finish(f"删除成功！已移除 [{scope}] 关键词「{key}」")
-        else:
-            await reply_cmd.finish(f"删除失败：未找到该范围内对应的关键词「{key}」")
-
-    elif sub_cmd == "list":
-        is_global = False
-        clean_args = []
-        for arg in args[1:]:
-            if arg in ("-g", "--global"):
-                is_global = True
-            else:
-                clean_args.append(arg)
-
-        group_id = "global" if (is_global or not isinstance(event, GroupMessageEvent)) else str(event.group_id)
-
-        if len(clean_args) == 0:
-            # 获取当前上下文生效的词条列表
-            if is_global:
-                rules = [r for r in rule_manager.rules if r.group_id == "global"]
-            else:
-                rules = rule_manager.get_rules_for_group(group_id)
-
-            if not rules:
-                await reply_cmd.finish("当前无生效 of 词条")
-
-            lines = []
-            for r in rules:
-                lines.append(f"- {r.key}")
-            await reply_cmd.finish("当前生效的词条关键词列表：\n" + "\n".join(lines))
-        else:
-            # 查询指定关键词
-            key = clean_args[0]
-            rule = rule_manager.get_rule(key, group_id)
-            if not rule and group_id != "global":
-                # 在当前群没找到时，也去全局找一下
-                rule = rule_manager.get_rule(key, "global")
-
-            if rule:
-                scope = "全局" if rule.group_id == "global" else f"群 {rule.group_id}"
-                match_types = {"exact": "精确匹配", "fuzzy": "模糊匹配", "regex": "正则匹配"}
-                reply_text = (
-                    f"词条信息：\n"
-                    f"关键词：{rule.key}\n"
-                    f"回复内容：{rule.reply}\n"
-                    f"匹配类型：{match_types.get(rule.match_type, rule.match_type)}\n"
-                    f"生效范围：{scope}"
-                )
-                await reply_cmd.finish(reply_text)
-            else:
-                await reply_cmd.finish(f"未找到对应的关键词「{key}」")
-    else:
-        await reply_cmd.finish(f"未知子命令：{sub_cmd}\n{__plugin_meta__.usage}")
-
-
-# 自动回复监听器
-message_reply = on_message(priority=99, block=False)
-
-
-@message_reply.handle()
-async def handle_message(bot: Bot, event: MessageEvent):
-    text = event.get_plaintext().strip()
-    if not text:
-        return
-
-    group_id = str(event.group_id) if isinstance(event, GroupMessageEvent) else "global"
-    matched = rule_manager.match(text, group_id)
-    if matched:
-        await message_reply.send(message=matched.reply)

nonebot_plugin_keyreply-0.1.3/nonebot_plugin_keyreply/config.py

@@ -1,7 +0,0 @@
-from pydantic import BaseModel
-from pathlib import Path
-
-
-class Config(BaseModel):
-    """Plugin Config Here"""
-    keyreply_data_path: Path = Path("data/keyreply/rules.json")

nonebot_plugin_keyreply-0.1.3/nonebot_plugin_keyreply/rule_manager.py

@@ -1,102 +0,0 @@
-import json
-import re
-from pathlib import Path
-from typing import List, Literal, Optional
-from pydantic import BaseModel
-
-
-class ReplyRule(BaseModel):
-    key: str
-    reply: str
-    match_type: Literal["exact", "fuzzy", "regex"] = "exact"
-    group_id: str = "global"
-
-
-class RuleManager:
-    def __init__(self, data_path: Path):
-        self.data_path = data_path
-        self.rules: List[ReplyRule] = []
-        self.load()
-
-    def load(self) -> None:
-        """从本地文件加载规则列表"""
-        if not self.data_path.exists():
-            self.rules = []
-            return
-        try:
-            with open(self.data_path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-                self.rules = [ReplyRule(**item) for item in data]
-        except Exception:
-            self.rules = []
-
-    def save(self) -> None:
-        """保存规则列表到本地文件"""
-        try:
-            self.data_path.parent.mkdir(parents=True, exist_ok=True)
-            with open(self.data_path, "w", encoding="utf-8") as f:
-                # 兼容 Pydantic v1 & v2
-                rules_data = []
-                for r in self.rules:
-                    if hasattr(r, "model_dump"):
-                        rules_data.append(r.model_dump())
-                    else:
-                        rules_data.append(r.dict())
-                json.dump(rules_data, f, ensure_ascii=False, indent=2)
-        except Exception:
-            pass
-
-    def add_rule(self, key: str, reply: str, match_type: Literal["exact", "fuzzy", "regex"], group_id: str) -> None:
-        """添加或覆盖规则"""
-        # 移除已有的同群同关键词规则
-        self.rules = [r for r in self.rules if not (r.key == key and r.group_id == group_id)]
-        self.rules.append(ReplyRule(key=key, reply=reply, match_type=match_type, group_id=group_id))
-        self.save()
-
-    def edit_rule(self, key: str, reply: str, group_id: str) -> bool:
-        """修改规则，若不存在则返回 False"""
-        for r in self.rules:
-            if r.key == key and r.group_id == group_id:
-                r.reply = reply
-                self.save()
-                return True
-        return False
-
-    def del_rule(self, key: str, group_id: str) -> bool:
-        """删除指定规则，若不存在则返回 False"""
-        original_len = len(self.rules)
-        self.rules = [r for r in self.rules if not (r.key == key and r.group_id == group_id)]
-        if len(self.rules) < original_len:
-            self.save()
-            return True
-        return False
-
-    def get_rule(self, key: str, group_id: str) -> Optional[ReplyRule]:
-        """获取特定的规则"""
-        for r in self.rules:
-            if r.key == key and r.group_id == group_id:
-                return r
-        return None
-
-    def get_rules_for_group(self, group_id: str) -> List[ReplyRule]:
-        """获取指定群/范围生效的规则"""
-        return [r for r in self.rules if r.group_id == group_id]
-
-    def match(self, text: str, group_id: str) -> Optional[ReplyRule]:
-        """根据输入文本匹配首个符合条件的规则"""
-        active_rules = self.get_rules_for_group(group_id)
-        for rule in active_rules:
-            if rule.match_type == "exact":
-                if text == rule.key:
-                    return rule
-            elif rule.match_type == "fuzzy":
-                if rule.key in text:
-                    return rule
-            elif rule.match_type == "regex":
-                try:
-                    if re.search(rule.key, text):
-                        return rule
-                except re.error:
-                    # 忽略无效的正则表达式
-                    continue
-        return None