koishi-plugin-group-verification 1.0.14 → 1.0.16

package/lib/index.d.ts

@@ -12,9 +12,7 @@ export interface GroupVerificationConfig {
     groupId: string;
     keywords: string[];
     reviewMethod: 0 | 1 | 2 | 3;
-    reviewParameters: {
-        threshold?: number;
-    };
+    reviewParameters: number;
     reminderEnabled: boolean;
     reminderMessage: string;
     createdBy: string;
@@ -40,6 +38,7 @@ export interface PendingVerification {
 }
 export interface Config {
     defaultReminderMessage?: string;
+    enableStrictGroupCheck?: boolean;
     logLevel?: 'debug' | 'info' | 'warn' | 'error';
 }
 export declare const Config: Schema<Config>;

package/lib/index.js

@@ -29,14 +29,15 @@ module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
 var name = "group-verification";
 var Config = import_koishi.Schema.object({
-  defaultReminderMessage: import_koishi.Schema.string().default(
+  defaultReminderMessage: import_koishi.Schema.string().description("默认提醒消息模板").default(
     `用户 {user}({id}) 申请加入群 {gname}({group})
 申请理由：{question}
 答对情况：{answer}
 阈值要求：{threshold}
 请管理员使用 #同意 或 #拒绝 来处理此申请`
-  ).description("默认提醒消息模板"),
-  logLevel: import_koishi.Schema.union(["debug", "info", "warn", "error"]).default("info").description("日志级别")
+  ),
+  enableStrictGroupCheck: import_koishi.Schema.boolean().description("是否启用严格的群号检查（验证机器人是否在群中）").default(true),
+  logLevel: import_koishi.Schema.union(["debug", "info", "warn", "error"]).description("日志级别").default("info")
 }).description("群组验证插件配置");
 var inject = ["database"];
 function apply(ctx, config) {
@@ -45,7 +46,8 @@ function apply(ctx, config) {
     groupId: "string",
     keywords: "list",
     reviewMethod: "integer",
-    reviewParameters: "json",
+    reviewParameters: "integer",
+    // 直接存储数字
     reminderEnabled: "boolean",
     reminderMessage: "string",
     createdBy: "string",
@@ -156,14 +158,14 @@ function apply(ctx, config) {
         requiredThreshold = "null";
         break;
       case 1:
-        isValid = matchedCount >= (config2.reviewParameters.threshold || 1);
-        requiredThreshold = `${config2.reviewParameters.threshold || 1}`;
+        isValid = matchedCount >= (config2.reviewParameters || 1);
+        requiredThreshold = `${config2.reviewParameters || 1}`;
         break;
       case 2:
         const ratio = matchedCount / config2.keywords.length;
-        const requiredRatio = (config2.reviewParameters.threshold || 100) / 100;
+        const requiredRatio = (config2.reviewParameters || 100) / 100;
         isValid = ratio >= requiredRatio;
-        requiredThreshold = `${config2.reviewParameters.threshold || 100}%`;
+        requiredThreshold = `${config2.reviewParameters || 100}%`;
         break;
       case 3:
         isValid = false;
@@ -265,23 +267,57 @@ ${debugInfo}`];
     "group-verify.配置",
     "gvc"
   ).option("groupId", "-i <groupId> 指定群号").option("method", "-m <method> 审核方式 (0-3)").option("threshold", "-t <threshold> 阈值参数").option("message", "-msg [message] 自定义提醒消息").option("disableMessage", "-nomsg 禁用提醒消息").option("query", "-? 查询当前配置").option("remove", "-r 删除配置").action(async ({ session, options }, keywords) => {
+    logger.info(`=== 命令解析调试 ===`);
+    logger.info(`原始keywords: "${keywords}" (类型: ${typeof keywords})`);
+    logger.info(`options对象: ${JSON.stringify(options, null, 2)}`);
+    logger.info(`session内容: guildId=${session.guildId}, userId=${session.userId}`);
+    logger.info(`==================`);
     const targetGroupId = options.groupId || session.guildId;
-    const [hasPermission, errorMsg] = await checkPermission(session, targetGroupId);
-    if (!hasPermission) {
-      return errorMsg || "权限不足";
-    }
-    let groupName = "未知群组";
     if (targetGroupId) {
       try {
-        const guild = await session.bot.getGuild(targetGroupId);
-        groupName = guild.name || groupName;
+        if (config.enableStrictGroupCheck) {
+          await session.bot.getGuild(targetGroupId);
+        }
+        const [hasPermission, errorMsg] = await checkPermission(session, targetGroupId);
+        if (!hasPermission) {
+          return errorMsg || "权限不足";
+        }
       } catch (error) {
+        if (config.enableStrictGroupCheck) {
+          return `群号 ${targetGroupId} 无效或机器人不在该群中`;
+        } else {
+          const [hasPermission, errorMsg] = await checkPermission(session, targetGroupId);
+          if (!hasPermission) {
+            return errorMsg || "权限不足";
+          }
+        }
       }
+    } else {
+      return "请在群聊中使用此命令或指定群号(-i参数)";
+    }
+    if (options.message !== void 0 && options.disableMessage) {
+      return "参数冲突：不能同时使用 -msg 和 -nomsg";
+    }
+    const usedOptions = [];
+    if (options.method !== void 0) usedOptions.push("-m");
+    if (options.threshold !== void 0) usedOptions.push("-t");
+    if (options.groupId !== void 0) usedOptions.push("-i");
+    if (options.message !== void 0) usedOptions.push("-msg");
+    if (options.disableMessage) usedOptions.push("-nomsg");
+    if (usedOptions.length > new Set(usedOptions).size) {
+      return `检测到重复参数: ${usedOptions.join(", ")}，将使用最后一次出现的值`;
+    }
+    let groupName = "未知群组";
+    try {
+      const guild = await session.bot.getGuild(targetGroupId);
+      groupName = guild.name || groupName;
+    } catch (error) {
     }
     if (options.remove) {
       const existingConfig2 = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
       if (existingConfig2.length > 0) {
         await ctx.database.remove("group_verification_config", { id: existingConfig2[0].id });
+        logger.info(`配置删除 - 用户ID:${session.userId}, 群号:${targetGroupId}`);
         return `已删除群 ${targetGroupId} 的验证配置`;
       } else {
         return `群 ${targetGroupId} 无验证配置`;
@@ -291,31 +327,34 @@ ${debugInfo}`];
       const existingConfig2 = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
       if (existingConfig2.length > 0) {
         const config2 = existingConfig2[0];
+        const decodedKeywords2 = config2.keywords.map((keyword) => {
+          return keyword.replace(/\[\[COMMA\]\]/g, ",");
+        });
         let methodDesc = "";
         let thresholdInfo = "";
         switch (config2.reviewMethod) {
           case 0:
             methodDesc = "全部同意";
-            thresholdInfo = "null";
+            thresholdInfo = "无";
             break;
           case 1:
             methodDesc = `按数量同意`;
-            thresholdInfo = `${config2.reviewParameters.threshold || 1}`;
+            thresholdInfo = config2.reviewParameters?.toString() || "无";
             break;
           case 2:
             methodDesc = `按比例同意`;
-            thresholdInfo = `${config2.reviewParameters.threshold || 100}%`;
+            thresholdInfo = config2.reviewParameters ? `${config2.reviewParameters}%` : "无";
             break;
           case 3:
             methodDesc = "全部拒绝";
-            thresholdInfo = "null";
+            thresholdInfo = "无";
             break;
         }
         const createTime = new Date(config2.createdAt).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
         const updateTime = new Date(config2.updatedAt).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
         const reminderStatus = config2.reminderEnabled ? "启用" : "禁用";
         return `群 ${targetGroupId} 配置：
-关键词: ${config2.keywords.join(", ")}
+关键词: ${decodedKeywords2.join(", ")}
 审核方式: ${methodDesc}
 阈值: ${thresholdInfo}
 提醒消息: ${reminderStatus}
@@ -328,8 +367,92 @@ ${debugInfo}`];
         return `群 ${targetGroupId} 无验证配置`;
       }
     }
-    let keywordList = keywords ? keywords.split(",").map((k) => k.trim()).filter((k) => k) : [];
-    if (!keywords && !options.query && !options.remove) {
+    let keywordList = [];
+    if (keywords) {
+      logger.info(`开始处理关键词: "${keywords}"`);
+      let processedInput = keywords.trim();
+      let keywordSection = processedInput;
+      let paramSection = "";
+      const paramMatch = processedInput.match(/\s+-(?:m|t|i|msg|nomsg|\?|r)\s+/);
+      if (paramMatch) {
+        const paramIndex = paramMatch.index;
+        keywordSection = processedInput.substring(0, paramIndex).trim();
+        paramSection = processedInput.substring(paramIndex).trim();
+        logger.info(`参数分离: 关键词="${keywordSection}", 参数="${paramSection}"`);
+      }
+      if (options.method !== void 0) {
+        logger.info(`检测到 -m 参数: ${options.method}`);
+      }
+      if (options.threshold !== void 0) {
+        logger.info(`检测到 -t 参数: ${options.threshold}`);
+      }
+      if (typeof paramSection !== "undefined" && paramSection) {
+        logger.info(`手动解析参数部分: "${paramSection}"`);
+        const mMatch = paramSection.match(/-m\s+(\d+)/);
+        if (mMatch && options.method === void 0) {
+          options.method = mMatch[1];
+          logger.info(`手动解析 -m: ${options.method}`);
+        }
+        const tMatch = paramSection.match(/-t\s+(\d+)/);
+        if (tMatch && options.threshold === void 0) {
+          options.threshold = tMatch[1];
+          logger.info(`手动解析 -t: ${options.threshold}`);
+        }
+      }
+      if (keywordSection) {
+        logger.info(`开始处理关键词部分: "${keywordSection}"`);
+        const result = [];
+        let i = 0;
+        while (i < keywordSection.length) {
+          const char = keywordSection[i];
+          if (char === '"') {
+            i++;
+            let content = "";
+            let foundEndQuote = false;
+            while (i < keywordSection.length) {
+              if (keywordSection[i] === '"' && (i === 0 || keywordSection[i - 1] !== "\\")) {
+                foundEndQuote = true;
+                i++;
+                break;
+              } else {
+                content += keywordSection[i];
+                i++;
+              }
+            }
+            let hasNextComma = false;
+            if (i < keywordSection.length && keywordSection[i] === ",") {
+              hasNextComma = true;
+              i++;
+            }
+            result.push(content);
+            logger.info(`引号处理: "${content}", 下一个逗号: ${hasNextComma}`);
+            if (!foundEndQuote) {
+              logger.info("未找到结束引号，前引号作为内容处理");
+            }
+          } else if (char === "," || char === " ") {
+            i++;
+          } else {
+            let content = "";
+            while (i < keywordSection.length && keywordSection[i] !== "," && keywordSection[i] !== " ") {
+              content += keywordSection[i];
+              i++;
+            }
+            if (content) {
+              result.push(content);
+              logger.info(`普通内容处理: "${content}"`);
+            }
+            if (i < keywordSection.length && (keywordSection[i] === "," || keywordSection[i] === " ")) {
+              i++;
+            }
+          }
+        }
+        keywordList = result.filter((item) => item.length > 0);
+        logger.info(`最终处理结果: [${keywordList.map((k) => `"${k}"`).join(", ")}]`);
+      }
+      logger.info(`最终关键词列表: [${keywordList.map((k) => `"${k}"`).join(", ")}]`);
+    }
+    logger.info(`关键词解析结果: [${keywordList.join(", ")}] - 原始输入: "${keywords}"`);
+    if (keywordList.length === 0 && !options.query && !options.remove) {
       const hasConfigParams = options.method !== void 0 || options.threshold !== void 0 || options.message !== void 0 || options.disableMessage !== void 0;
       if (!hasConfigParams) {
         return `用法：
@@ -357,28 +480,25 @@ gvc -r                          # 删除配置`;
       reminderMessage = "";
     } else if (options.message !== void 0) {
       reminderEnabled = true;
-      reminderMessage = options.message || config.defaultReminderMessage || `用户 {user}({id}) 申请加入群 {gname}({group})
-申请理由：{question}
-答对情况：{answer}
-阈值要求：{threshold}
-请管理员使用 #同意 或 #拒绝 来处理此申请`;
+      if (options.message !== "") {
+        reminderMessage = options.message;
+      }
     }
     if (reminderEnabled && reminderMessage) {
       reminderMessage = reminderMessage.replace(/\\n/g, "\n");
     }
     let reviewMethod = 0;
-    let reviewParameters = {};
-    if (!keywords && !options.query && !options.remove) {
-      const existingConfig2 = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
-      if (existingConfig2.length > 0) {
-        reviewMethod = existingConfig2[0].reviewMethod;
-        if (existingConfig2[0].reviewParameters?.threshold) {
-          reviewParameters.threshold = existingConfig2[0].reviewParameters.threshold;
-        }
-        if (options.disableMessage === void 0 && options.message === void 0) {
-          reminderEnabled = existingConfig2[0].reminderEnabled;
-          reminderMessage = existingConfig2[0].reminderMessage;
-        }
+    let reviewParameters = 0;
+    let existingConfig = null;
+    const configs = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
+    if (configs.length > 0) {
+      existingConfig = configs[0];
+      reviewMethod = existingConfig.reviewMethod;
+      if (existingConfig.reviewParameters === void 0 || existingConfig.reviewParameters === null || isNaN(existingConfig.reviewParameters)) {
+        reviewParameters = 0;
+        logger.info(`检测到老版本数据或无效值，使用默认阈值: 0`);
+      } else {
+        reviewParameters = existingConfig.reviewParameters;
       }
     }
     if (options.method !== void 0) {
@@ -387,48 +507,115 @@ gvc -r                          # 删除配置`;
         return "审核方式参数错误：0-全部同意, 1-按数量同意, 2-按比例同意, 3-全部拒绝";
       }
       reviewMethod = methodNum;
+      logger.info(`审核方式明确指定为: ${reviewMethod}`);
+      if (reviewMethod === 0 || reviewMethod === 3) {
+        reviewParameters = 0;
+      } else if (reviewParameters === 0) {
+        reviewParameters = reviewMethod === 1 ? keywordList.length : 100;
+      }
+    } else {
+      logger.info(`未指定审核方式，保持原有值: ${reviewMethod}`);
     }
-    if ((reviewMethod === 1 || reviewMethod === 2) && options.threshold !== void 0) {
+    if (options.threshold !== void 0) {
       const thresholdNum = parseInt(options.threshold);
       if (isNaN(thresholdNum)) {
         return "阈值参数必须为数字";
       }
       if (reviewMethod === 1) {
-        if (thresholdNum <= 0 || thresholdNum > keywordList.length) {
-          return `数量阈值必须在1-${keywordList.length}之间`;
+        if (thresholdNum < 0 || thresholdNum > keywordList.length) {
+          return `数量阈值必须在0-${keywordList.length}之间（0表示全部同意）`;
         }
-        reviewParameters.threshold = thresholdNum;
+        reviewParameters = thresholdNum;
+        logger.info(`明确指定阈值: ${thresholdNum}`);
       } else if (reviewMethod === 2) {
-        if (thresholdNum <= 0 || thresholdNum > 100) {
-          return "比例阈值必须在1-100之间";
+        if (thresholdNum < 0 || thresholdNum > 100) {
+          return "比例阈值必须在0-100之间（0表示全部同意）";
         }
-        reviewParameters.threshold = thresholdNum;
+        reviewParameters = thresholdNum;
+        logger.info(`明确指定阈值: ${thresholdNum}%`);
+      }
+    } else if (existingConfig && reviewMethod === 1 && reviewParameters !== 0) {
+      const oldKeywordCount = existingConfig.keywords.length;
+      const newKeywordCount = keywordList.length;
+      if (oldKeywordCount !== newKeywordCount) {
+        reviewParameters = newKeywordCount;
+        logger.info(`关键词数量从${oldKeywordCount}变为${newKeywordCount}，自动调整阈值`);
+        await ctx.database.set("group_verification_config", { id: existingConfig.id }, {
+          reviewParameters,
+          updatedBy: session.username || session.userId,
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+        logger.info(`已更新数据库阈值为: ${reviewParameters}`);
+      } else {
+        logger.info(`关键词数量未变化(${newKeywordCount})，保持原阈值: ${reviewParameters}`);
       }
     }
-    const existingConfig = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
-    const configData = {
-      keywords: keywordList,
+    const existingConfigs = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
+    const encodedKeywords = keywordList.map((keyword) => {
+      return keyword.replace(/,/g, "[[COMMA]]");
+    });
+    logger.info(`编码后准备存储的关键词: ${JSON.stringify(encodedKeywords)}`);
+    const dbData = {
+      keywords: encodedKeywords,
       reviewMethod,
       reviewParameters,
+      // 直接存储数字
       reminderEnabled,
       reminderMessage,
       updatedBy: session.username || session.userId,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    if (existingConfig.length > 0) {
-      await ctx.database.set("group_verification_config", { id: existingConfig[0].id }, configData);
-      logger.info(`配置更新成功 - 用户ID:${session.userId}, 群号:${targetGroupId}, 操作:更新`);
-      return `已更新群 ${targetGroupId} 的验证配置`;
+    if (existingConfigs.length > 0) {
+      await ctx.database.set("group_verification_config", { id: existingConfigs[0].id }, dbData);
+      logger.info(`更新配置成功 - 审核方式: ${reviewMethod}, 阈值: ${reviewParameters}`);
     } else {
       await ctx.database.create("group_verification_config", {
-        ...configData,
         groupId: targetGroupId,
+        ...dbData,
         createdBy: session.username || session.userId,
         createdAt: /* @__PURE__ */ new Date()
       });
-      logger.info(`配置创建成功 - 用户ID:${session.userId}, 群号:${targetGroupId}, 操作:创建`);
-      return `已为群 ${targetGroupId} 创建验证配置`;
+      logger.info(`创建配置成功 - 审核方式: ${reviewMethod}, 阈值: ${reviewParameters}`);
     }
+    const decodedKeywords = keywordList;
+    let feedbackMessage = `群 ${targetGroupId} 配置已更新:
+`;
+    feedbackMessage += `关键词: ${decodedKeywords.map((k) => `"${k}"`).join(", ")}
+`;
+    const methodMap = { 0: "全部同意", 1: "按数量", 2: "按比例", 3: "全部拒绝" };
+    feedbackMessage += `审核方式: ${methodMap[reviewMethod]}
+`;
+    if (reviewParameters !== 0) {
+      const thresholdDisplay = reviewMethod === 2 ? `${reviewParameters}%` : reviewParameters.toString();
+      feedbackMessage += `阈值: ${thresholdDisplay}
+`;
+    }
+    feedbackMessage += `提醒状态: ${reminderEnabled ? "启用" : "禁用"}
+`;
+    if (reminderMessage && reminderEnabled) {
+      feedbackMessage += `提醒消息: ${reminderMessage.substring(0, 30)}${reminderMessage.length > 30 ? "..." : ""}
+`;
+    }
+    if (existingConfig && reviewMethod === 1 && keywordList.length !== existingConfig.keywords.length) {
+      feedbackMessage += `⚠️ 关键词数量从${existingConfig.keywords.length}变为${keywordList.length}，阈值已自动调整为${keywordList.length}
+`;
+    }
+    logger.info(`准备存储到数据库的关键词: ${JSON.stringify(encodedKeywords)}`);
+    logger.info(`=== 配置处理详情 ===`);
+    logger.info(`原始输入: ${keywords || "无关键词"}`);
+    logger.info(`审核方式: ${reviewMethod} (${["全部同意", "按数量", "按比例", "全部拒绝"][reviewMethod]})`);
+    logger.info(`阈值参数: ${JSON.stringify(reviewParameters)}`);
+    logger.info(`关键词列表: [${keywordList.map((k) => `"${k}"`).join(", ")}]`);
+    logger.info(`现有配置: ${existingConfig ? "存在" : "不存在"}`);
+    if (existingConfig) {
+      logger.info(`原审核方式: ${existingConfig.reviewMethod}`);
+      logger.info(`原阈值: ${JSON.stringify(existingConfig.reviewParameters)}`);
+      logger.info(`原关键词数: ${existingConfig.keywords.length}`);
+      logger.info(`新关键词数: ${keywordList.length}`);
+    }
+    logger.info(`==================`);
+    logger.info(feedbackMessage.replace(/\n/g, "; "));
+    return feedbackMessage;
   });
   groupVerify.subcommand(".approve [userId]", "同意加群申请").alias(
     "gv.accept",
@@ -639,25 +826,38 @@ gvc -r                          # 删除配置`;
   参数说明：
     -i <群号>     指定群号（私聊时必需）
     -m <方式>     审核方式 (0=全部同意, 1=按数量, 2=按比例, 3=全部拒绝)
-    -t <阈值>     阈值参数（方式1或2时必需）
-    -msg [消息]   自定义提醒消息（不带参数显示帮助）
+    -t <阈值>     阈值参数（方式1:0-关键词数, 方式2:0-100）
+    -msg [消息]   自定义提醒消息（支持引号和\\n换行）
     -nomsg        禁用提醒消息
     -?           查询当前配置
     -r           删除配置
   
-提醒消息变量：
-  {user} - 用户名
-  {id} - 用户ID  
-  {group} - 群号
-  {gname} - 群名称
-  {question} - 申请理由
-  {answer} - 答对数量/比例
-  {threshold} - 阈值要求
+  引号使用规则：
+    • 关键词包含空格：gv.cfg "关键词1,关键词 2,关键词3"
+    • 提醒消息包含空格：gv.cfg -msg "这是包含空格的消息"
+    • 内部引号转义：gv.cfg -msg "包含\\"引号\\"的内容"
+    • 换行符：gv.cfg -msg "第一行\\n第二行"
+  
+  特殊说明：
+    • 阈值可设为0表示全部同意
+    • 关键词数量变化时阈值会自动调整
+    • 重复参数会使用最后出现的值并提醒
+    • 群号检查可在插件配置中开关
+  
+  提醒消息变量：
+    {user} - 用户名
+    {id} - 用户ID  
+    {group} - 群号
+    {gname} - 群名称
+    {question} - 申请理由
+    {answer} - 答对数量/比例
+    {threshold} - 阈值要求
   
-消息格式化：
-  \\n - 换行符
-  可以组合使用变量和换行符创建格式化的消息
-  示例：gv.cfg -msg "用户 {user}\\n申请理由：{question}\\n匹配：{answer}/{threshold}"
+  使用示例：
+    gv.cfg "关键词1,关键词2" -m 1 -t 2
+    gv.cfg -msg "用户 {user}\\n申请理由：{question}"
+    gv.cfg -m 2 -t 80
+    gv.cfg -nomsg
 
 快捷命令：
   gvc - 配置命令快捷方式

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-group-verification",
-  "description": "Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能",
-  "version": "1.0.14",
+  "description": "[WIP] Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能（开发中）",
+  "version": "1.0.16",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -1,4 +1,4 @@
-# Koishi 群组验证插件
+# Koishi 群组验证插件 [WIP]
 
 一个功能完整的 Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能。
 
@@ -13,7 +13,7 @@
 
 ## 🚀 安装使用
 
-```bash
+```
 # 在 Koishi 控制台中搜索并安装
 koishi-plugin-group-verification
 ```
@@ -21,62 +21,70 @@ koishi-plugin-group-verification
 ## 📋 命令说明
 
 ### 主指令别名
-- `group-verify` (完整名称)
-- `gv` (快捷别名)
-- `gverify` (中等长度别名)
+- `group-verify` (完整英文名称)
+- `gv` (英文快捷别名)
+- `gverify` (英文中等长度别名)
 
 ### 配置命令
 ```
-# 创建新配置
-gvc 关键词1,关键词2,关键词3 -m 1 -t 2
+# 创建新配置（支持引号和逗号组合）
+group-verify.config "关键词1,关键词2",关键词3 -m 1 -t 2
+# 别名：gv.cfg gverify.cfg group-verify.cfg gv.配置 gverify.配置 group-verify.配置 gvc
 
 # 修改审核参数
-gvc -m 2 -t 60
+group-verify.config -m 2 -t 60
 
 # 启用自定义提醒消息
-gvc -msg "用户 {user} 申请入群，匹配 {answer} 个关键词"
+group-verify.config -msg "用户 {user} 申请入群，匹配 {answer} 个关键词"
 
 # 禁用提醒消息
-gvc -nomsg
+group-verify.config -nomsg
 
 # 查询当前配置
-gvc -?
+group-verify.config -?
 
 # 删除配置
-gvc -r
+group-verify.config -r
+
+# 指定群号配置
+group-verify.config -i 123456789 关键词1,关键词2 -m 1 -t 1
 ```
 
 ### 审核命令
 ```
 # 同意申请（处理最近一个）
-gva
+group-verify.approve
+# 别名：gv.accept gverify.accept group-verify.accept gv.同意 gverify.同意 group-verify.同意 gva
 
 # 同意指定用户
-gva 123456789
+group-verify.approve 123456789
 
 # 同意所有申请
-gva all
+group-verify.approve all
 
 # 拒绝申请
-gvr 123456789
+group-verify.reject 123456789
+# 别名：gv.reject gverify.reject group-verify.reject gv.拒绝 gverify.拒绝 group-verify.拒绝 gvr
 
 # 拒绝所有申请
-gvr all
+group-verify.reject all
 ```
 
 ### 查询命令
 ```
 # 查看待审核列表
-gvp
+group-verify.pending
+# 别名：gv.list gverify.list group-verify.list gv.待审 gverify.待审 group-verify.待审 gvp
 
 # 查看统计信息
-gvs
+group-verify.stats
+# 别名：gv.stats gverify.stats group-verify.stats gv.统计 gverify.统计 group-verify.统计 gvs
 
 # 查看指定群统计
-gvs 123456789
+group-verify.stats 123456789
 
 # 查看总计统计（需要权限）
-gvs total
+group-verify.stats total
 ```
 
 ## ⚙️ 参数说明