koishi-plugin-group-verification 1.0.28 → 1.0.29

package/lib/index.d.ts

@@ -42,6 +42,10 @@ export interface Config {
     defaultReminderMessage?: string;
     enableStrictGroupCheck?: boolean;
     logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    permissionDeniedMessage?: string;
+    invalidGroupMessage?: string;
+    parameterConflictMessage?: string;
+    noKeywordsMessage?: string;
 }
 export declare const Config: Schema<Config>;
 export declare const inject: string[];
@@ -87,13 +91,19 @@ export declare function mergeReminder(existingConfig: any | null, cleanedOptions
     message?: string;
     enableMessage?: boolean;
     disableMessage?: boolean;
-}, hasRealMessageParam: boolean, hasRealEnableMessageParam: boolean, hasRealDisableMessageParam: boolean, logger: any): {
+}, hasRealMessageParam: boolean, hasRealEnableMessageParam: boolean, hasRealDisableMessageParam: boolean, logger: any, defaultMessage?: string): {
     reminderEnabled: boolean;
     reminderMessage: string;
 };
 export declare function syncTotalStats(ctx: Context): Promise<void>;
 export declare function updateStats(ctx: Context, groupId: string, action: 'autoApproved' | 'manuallyApproved' | 'rejected'): Promise<void>;
 export declare function incrementTotal(ctx: Context, groupId: string): Promise<void>;
+export interface ThresholdResult {
+    reviewParameters: number;
+    error?: string;
+    autoInfo?: 'methodChange' | 'kwChange';
+}
+export declare function resolveThreshold(existingConfig: any | null, keywordList: string[], reviewMethod: 0 | 1 | 2 | 3, thresholdStr?: string, methodChanged?: boolean): ThresholdResult;
 export declare function checkPermission(session: any, targetGroupId?: string): Promise<[boolean, string?]>;
 export declare function handleGuildMemberRequestEvent(ctx: Context, session: any): Promise<void>;
 export declare function __getAutoQueue(): Map<string, Set<string>>;

package/lib/index.js

@@ -31,6 +31,7 @@ __export(src_exports, {
   mergeReminder: () => mergeReminder,
   name: () => name,
   parseConfigArgs: () => parseConfigArgs,
+  resolveThreshold: () => resolveThreshold,
   syncTotalStats: () => syncTotalStats,
   tokenize: () => tokenize,
   updateStats: () => updateStats,
@@ -42,9 +43,13 @@ var import_koishi = require("koishi");
 var name = "group-verification";
 var logger = console;
 var Config = import_koishi.Schema.object({
-  defaultReminderMessage: import_koishi.Schema.string().description("默认提醒消息模板（使用 \n 表示换行，可包含下方变量）").default("{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}\n使用 gva 同意或 gvr 拒绝申请"),
+  defaultReminderMessage: import_koishi.Schema.string().description("默认提醒消息模板（使用 \\n 表示换行，可包含下方变量）").default("{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}\n使用 gva 同意或 gvr 拒绝申请"),
   enableStrictGroupCheck: import_koishi.Schema.boolean().description("是否启用严格的群号检查（检查群号长度）").default(false),
-  logLevel: import_koishi.Schema.union(["debug", "info", "warn", "error"]).description("日志级别").default("info")
+  logLevel: import_koishi.Schema.union(["debug", "info", "warn", "error"]).description("日志级别").default("info"),
+  permissionDeniedMessage: import_koishi.Schema.string().description("权限不足时返回给调用者的提示").default("权限不足：需要群主/管理员权限或koishi三级以上权限"),
+  invalidGroupMessage: import_koishi.Schema.string().description("无效群号或机器人未在该群时的提示").default("群号 {group} 格式不合法或机器人不在该群中"),
+  parameterConflictMessage: import_koishi.Schema.string().description("参数冲突时提示").default("参数冲突：-? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）"),
+  noKeywordsMessage: import_koishi.Schema.string().description("未提供关键词且无法从现有配置继承时的提示").default("请先提供关键词创建配置，或使用 -? 查询配置，-r 删除配置")
 }).description("群组验证插件配置");
 var inject = ["database"];
 var ESC_QUOTE = "\0";
@@ -175,24 +180,24 @@ function usageString() {
     使用 \\n   换行`;
 }
 __name(usageString, "usageString");
-function mergeReminder(existingConfig, cleanedOptions, hasRealMessageParam, hasRealEnableMessageParam, hasRealDisableMessageParam, logger2) {
+function mergeReminder(existingConfig, cleanedOptions, hasRealMessageParam, hasRealEnableMessageParam, hasRealDisableMessageParam, logger2, defaultMessage) {
   let reminderEnabled = true;
-  let reminderMessage = "{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}";
+  let reminderMessage = defaultMessage || "{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}";
   if (existingConfig) {
     reminderEnabled = existingConfig.reminderEnabled;
     reminderMessage = existingConfig.reminderMessage || reminderMessage;
   }
   if (hasRealDisableMessageParam) {
     reminderEnabled = false;
-    logger2.info("禁用提醒消息功能 (保留现有内容)");
+    logger2.debug("禁用提醒消息功能 (保留现有内容)");
   } else if (hasRealEnableMessageParam) {
     reminderEnabled = true;
-    logger2.info(`启用提醒消息（保留原消息）: ${reminderMessage.substring(0, 50)}...`);
+    logger2.debug(`启用提醒消息（保留原消息）: ${reminderMessage.substring(0, 50)}...`);
   } else if (hasRealMessageParam) {
     reminderEnabled = true;
     if (cleanedOptions.message !== void 0) {
       reminderMessage = cleanedOptions.message.replace(/\\n/g, "\n");
-      logger2.info(`设置自定义提醒消息: ${reminderMessage.substring(0, 50)}...`);
+      logger2.debug(`设置自定义提醒消息: ${reminderMessage.substring(0, 50)}...`);
     }
   }
   return { reminderEnabled, reminderMessage };
@@ -216,7 +221,7 @@ async function syncTotalStats(ctx) {
         totalJoined,
         lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger.info(`总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}, 入群${totalJoined}`);
+      logger.debug(`总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}, 入群${totalJoined}`);
     }
   } catch (error) {
     logger.error("同步总计统计时出错:", error);
@@ -265,30 +270,72 @@ async function incrementTotal(ctx, groupId) {
   await syncTotalStats(ctx);
 }
 __name(incrementTotal, "incrementTotal");
+function resolveThreshold(existingConfig, keywordList, reviewMethod, thresholdStr, methodChanged = false) {
+  let reviewParameters = 0;
+  if (existingConfig) {
+    reviewParameters = existingConfig.reviewParameters || 0;
+    if (isNaN(reviewParameters)) reviewParameters = 0;
+  }
+  if (thresholdStr !== void 0) {
+    const thresholdNum = parseInt(thresholdStr);
+    if (isNaN(thresholdNum)) {
+      return { reviewParameters, error: "阈值参数必须为数字" };
+    }
+    if (reviewMethod === 1) {
+      if (thresholdNum < 0 || thresholdNum > keywordList.length) {
+        return { reviewParameters, error: `数量阈值必须在0-${keywordList.length}之间（0表示全部同意）` };
+      }
+    } else if (reviewMethod === 2) {
+      if (thresholdNum < 0 || thresholdNum > 100) {
+        return { reviewParameters, error: "比例阈值必须在0-100之间（0表示全部同意）" };
+      }
+    }
+    return { reviewParameters: thresholdNum };
+  }
+  if (methodChanged) {
+    if (reviewMethod === 1) {
+      reviewParameters = keywordList.length;
+      return { reviewParameters, autoInfo: "methodChange" };
+    }
+    if (reviewMethod === 2) {
+      reviewParameters = 100;
+      return { reviewParameters, autoInfo: "methodChange" };
+    }
+  }
+  if (existingConfig && reviewMethod === 1 && reviewParameters !== 0) {
+    const oldKeywordCount = existingConfig.keywords.length;
+    const newKeywordCount = keywordList.length;
+    if (oldKeywordCount !== newKeywordCount) {
+      reviewParameters = newKeywordCount;
+      return { reviewParameters, autoInfo: "kwChange" };
+    }
+  }
+  return { reviewParameters };
+}
+__name(resolveThreshold, "resolveThreshold");
 async function checkPermission(session, targetGroupId) {
   const groupId = targetGroupId || session.guildId;
   if (!groupId) {
     return [false, "请在群聊中使用此命令或使用 -i 参数指定群号"];
   }
-  logger.info(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
+  logger.debug(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
   const koishiAuthority = session.author?.authority || session.user?.authority;
-  logger.info(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
+  logger.debug(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
   if (!session.author) {
-    logger.info(`权限检查 - session中可能的权限字段:`, {
+    logger.debug(`权限检查 - session中可能的权限字段:`, {
       authority: session.authority,
       permission: session.permission,
       role: session.role
     });
   } else {
-    logger.info(`权限检查 - author对象中的字段:`, {
-      authority: session.author.authority,
+    logger.debug(`权限检查 - author对象中的字段:`, {
       permission: session.author.permission,
       role: session.author.role,
       permissions: session.author.permissions
     });
   }
   if (session.user) {
-    logger.info(`权限检查 - user对象中的权限信息:`, {
+    logger.debug(`权限检查 - user对象中的权限信息:`, {
       authority: session.user.authority,
       permission: session.user.permission,
       role: session.user.role
@@ -346,12 +393,12 @@ async function handleGuildMemberRequestEvent(ctx, session) {
     return;
   }
   const { isValid, matchedCount, requiredThreshold } = await verifyApplication(config, message, session);
-  logger.info(`验证结果 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
+  logger.debug(`验证结果 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
   if (isValid) {
     if (requestId) {
       try {
         await session.bot.handleGuildMemberRequest(requestId, true);
-        logger.info(`自动同意 requestId=${requestId}`);
+        logger.debug(`自动同意 requestId=${requestId}`);
         if (!autoQueue.has(guildId)) autoQueue.set(guildId, /* @__PURE__ */ new Set());
         autoQueue.get(guildId).add(userId);
       } catch (e) {
@@ -491,7 +538,7 @@ async function verifyApplication(config, message, session) {
       isValid = false;
       requiredThreshold = "null";
   }
-  logger.info(`verifyApplication msg="${message}" keywords=${JSON.stringify(config.keywords)} matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
+  logger.debug(`verifyApplication msg="${message}" keywords=${JSON.stringify(config.keywords)} matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
   return { isValid, matchedCount, requiredThreshold };
 }
 __name(verifyApplication, "verifyApplication");
@@ -504,7 +551,7 @@ async function handleFailedVerification(ctx, session, config, matchedCount, requ
   }
   const username = session.username || "未知用户";
   const message = session.content || "";
-  logger.info(`处理失败验证 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold}`);
+  logger.debug(`处理失败验证 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold}`);
   if (matchedCount === void 0 || requiredThreshold === void 0) {
     const result = await verifyApplication(config, message, session);
     matchedCount = result.matchedCount;
@@ -527,7 +574,7 @@ async function handleFailedVerification(ctx, session, config, matchedCount, requ
     applyTime: (/* @__PURE__ */ new Date()).toISOString()
   });
   if (!config.reminderEnabled || !config.reminderMessage || config.reminderMessage === "") {
-    logger.info(`群 ${guildId} 的提醒消息已被禁用，跳过发送`);
+    logger.debug(`群 ${guildId} 的提醒消息已被禁用，跳过发送`);
     return;
   }
   let reminderMsg = config.reminderMessage;
@@ -575,6 +622,7 @@ function apply(ctx, config) {
     autoInc: true
   });
   logger = ctx.logger("group-verification");
+  if (config.logLevel) logger.level = config.logLevel;
   logger.info("群组验证插件已启动");
   logger.info(`默认提醒消息: ${config.defaultReminderMessage}`);
   logger.info(`严格群号检查: ${config.enableStrictGroupCheck ? "启用" : "禁用"}`);
@@ -640,19 +688,19 @@ function apply(ctx, config) {
   async function checkPermission2(session, targetGroupId) {
     const groupId = targetGroupId || session.guildId;
     if (!groupId) {
-      return [false, "请在群聊中使用此命令或使用 -i 参数指定群号"];
+      return [false, config.invalidGroupMessage || "请在群聊中使用此命令或使用 -i 参数指定群号"];
     }
-    logger.info(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
+    logger.debug(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
     const koishiAuthority = session.author?.authority || session.user?.authority;
-    logger.info(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
+    logger.debug(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
     if (!session.author) {
-      logger.info(`权限检查 - session中可能的权限字段:`, {
+      logger.debug(`权限检查 - session中可能的权限字段:`, {
         authority: session.authority,
         permission: session.permission,
         role: session.role
       });
     } else {
-      logger.info(`权限检查 - author对象中的字段:`, {
+      logger.debug(`权限检查 - author对象中的字段:`, {
         authority: session.author.authority,
         permission: session.author.permission,
         role: session.author.role,
@@ -660,19 +708,19 @@ function apply(ctx, config) {
       });
     }
     if (session.user) {
-      logger.info(`权限检查 - user对象中的权限信息:`, {
+      logger.debug(`权限检查 - user对象中的权限信息:`, {
         authority: session.user.authority,
         permission: session.user.permission,
         role: session.user.role
       });
     }
     if (koishiAuthority && koishiAuthority >= 3) {
-      logger.info(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`);
+      logger.debug(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`);
       return [true];
     }
     try {
       const member = await session.bot.getGuildMember(groupId, session.userId);
-      logger.info(`权限检查 - 获取到成员信息:`, {
+      logger.debug(`权限检查 - 获取到成员信息:`, {
         roles: member?.roles,
         permissions: member?.permissions
       });
@@ -682,7 +730,7 @@ function apply(ctx, config) {
           return [true];
         }
         if (member.roles?.includes("admin") || member.permissions?.includes("ADMINISTRATOR")) {
-          logger.info(`权限检查 - 用户是管理员`);
+          logger.debug(`权限检查 - 用户是管理员`);
           return [true];
         }
       }
@@ -690,9 +738,9 @@ function apply(ctx, config) {
       logger.warn(`权限检查 - 获取群成员信息失败:`, error);
       return [false, `无法获取群 ${groupId} 的成员信息，请确认机器人已在该群中`];
     }
-    logger.info(`权限检查 - 权限不足`);
+    logger.debug(`权限检查 - 权限不足`);
     const debugInfo = `调试信息 - 用户ID:${session.userId}, 群号:${groupId}, 权限等级:${koishiAuthority || "未知"}`;
-    return [false, `权限不足：需要群主/管理员权限或koishi三级以上权限
+    return [false, (config.permissionDeniedMessage || "权限不足：需要群主/管理员权限或koishi三级以上权限") + `
 ${debugInfo}`];
   }
   __name(checkPermission2, "checkPermission");
@@ -729,7 +777,7 @@ ${debugInfo}`];
     };
     logger.info(`合并后options: ${JSON.stringify(cleanedOptions, null, 2)}`);
     if ((cleanedOptions.query || cleanedOptions.remove) && (parsedKeywords.length > 0 || cleanedOptions.method !== void 0 || cleanedOptions.threshold !== void 0 || cleanedOptions.message !== void 0 || cleanedOptions.enableMessage || cleanedOptions.disableMessage)) {
-      return "参数冲突：-? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）";
+      return config.parameterConflictMessage || "参数冲突：-? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）";
     }
     const hasRealMessageParam = cleanedOptions.message !== void 0;
     const hasRealEnableMessageParam = cleanedOptions.enableMessage === true;
@@ -841,7 +889,7 @@ ${debugInfo}`];
     }
     if (keywordList.length === 0 && !cleanedOptions.query && !cleanedOptions.remove) {
       if (!existingConfig) {
-        return "请先提供关键词创建配置，或使用 -? 查询配置，-r 删除配置";
+        return config.noKeywordsMessage || "请先提供关键词创建配置，或使用 -? 查询配置，-r 删除配置";
       }
       keywordList = existingConfig.keywords;
     }
@@ -851,7 +899,8 @@ ${debugInfo}`];
       hasRealMessageParam,
       hasRealEnableMessageParam,
       hasRealDisableMessageParam,
-      logger
+      logger,
+      config.defaultReminderMessage
     );
     let reviewMethod = 0;
     let reviewParameters = 0;
@@ -869,44 +918,45 @@ ${debugInfo}`];
       if (isNaN(methodNum) || methodNum < 0 || methodNum > 3) {
         return "审核方式参数错误：0-全部同意, 1-按数量同意, 2-按比例同意, 3-全部拒绝";
       }
+      const oldMethod = reviewMethod;
       reviewMethod = methodNum;
-      logger.info(`审核方式明确指定为: ${reviewMethod}`);
+      logger.debug(`审核方式明确指定为: ${reviewMethod}`);
+      var methodChanged = oldMethod !== reviewMethod;
     } else {
-      logger.info(`未指定审核方式，保持原有值: ${reviewMethod}`);
+      logger.debug(`未指定审核方式，保持原有值: ${reviewMethod}`);
+      var methodChanged = false;
     }
-    if (cleanedOptions.threshold !== void 0) {
-      const thresholdNum = parseInt(cleanedOptions.threshold);
-      if (isNaN(thresholdNum)) {
-        return "阈值参数必须为数字";
-      }
+    const thresholdResult = resolveThreshold(
+      existingConfig,
+      keywordList,
+      reviewMethod,
+      cleanedOptions.threshold,
+      methodChanged
+    );
+    if (thresholdResult.error) {
+      return thresholdResult.error;
+    }
+    reviewParameters = thresholdResult.reviewParameters;
+    if (existingConfig && reviewParameters !== existingConfig.reviewParameters) {
+      await ctx.database.set("group_verification_config", { id: existingConfig.id }, {
+        reviewParameters,
+        updatedBy: session.username || session.userId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      logger.debug(`自动调整并更新数据库阈值为: ${reviewParameters}`);
+    }
+    let autoAdjustNote = "";
+    if (thresholdResult.autoInfo === "methodChange") {
       if (reviewMethod === 1) {
-        if (thresholdNum < 0 || thresholdNum > keywordList.length) {
-          return `数量阈值必须在0-${keywordList.length}之间（0表示全部同意）`;
-        }
-        reviewParameters = thresholdNum;
-        logger.info(`明确指定阈值: ${thresholdNum}`);
+        autoAdjustNote = `⚠️ 审核方式由 ${existingConfig?.reviewMethod} 改为 ${reviewMethod}，阈值自动设为 ${reviewParameters}
+`;
       } else if (reviewMethod === 2) {
-        if (thresholdNum < 0 || thresholdNum > 100) {
-          return "比例阈值必须在0-100之间（0表示全部同意）";
-        }
-        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()).toISOString()
-        });
-        logger.info(`已更新数据库阈值为: ${reviewParameters}`);
-      } else {
-        logger.info(`关键词数量未变化(${newKeywordCount})，保持原阈值: ${reviewParameters}`);
+        autoAdjustNote = `⚠️ 审核方式由 ${existingConfig?.reviewMethod} 改为 ${reviewMethod}，阈值自动设为 ${reviewParameters}%
+`;
       }
+    } else if (thresholdResult.autoInfo === "kwChange") {
+      autoAdjustNote = `⚠️ 关键词数量从${existingConfig?.keywords.length}变为${keywordList.length}，阈值已自动调整为${reviewParameters}
+`;
     }
     const encodedKeywords = keywordList.map((keyword) => {
       return keyword.replace(/,/g, "[[COMMA]]");
@@ -940,6 +990,7 @@ ${debugInfo}`];
     const decodedKeywords = keywordList;
     let feedbackMessage = `群 ${targetGroupId} 配置已更新:
 `;
+    if (autoAdjustNote) feedbackMessage += autoAdjustNote;
     const displayKeywords = keywordList.map((k) => k.replace(/\[\[COMMA\]\]/g, ","));
     feedbackMessage += `关键词: ${displayKeywords.map((k) => `"${k}"`).join(", ")}
 `;
@@ -955,10 +1006,6 @@ ${debugInfo}`];
 `;
     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)}`);
@@ -1363,6 +1410,7 @@ __name(apply, "apply");
   mergeReminder,
   name,
   parseConfigArgs,
+  resolveThreshold,
   syncTotalStats,
   tokenize,
   updateStats,

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "koishi-plugin-group-verification",
-  "description": "[WIP] Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能（开发中）",
-  "version": "1.0.28",
+  "description": "Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能。",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LHDyx/koishi-plugin-group-verification.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LHDyx/koishi-plugin-group-verification/issues"
+  },
+  "version": "1.0.29",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -1,7 +1,10 @@
-# Koishi 群组验证插件 [WIP]
+# Koishi 群组验证插件
 
 一个功能完整的 Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能。
 
+**仓库**: https://github.com/LHDyx/koishi-plugin-group-verification  
+**问题反馈**: https://github.com/LHDyx/koishi-plugin-group-verification/issues
+
 ## 🌟 主要特性
 
 - **多关键词匹配**：支持多个关键词的灵活配置
@@ -13,6 +16,8 @@
 
 ## 🚀 安装使用
 
+> 本插件已脱离开发阶段，可在 Koishi 插件管理页直接安装并配置。部分提示词可在管理界面自定义。
+
 ```
 # 在 Koishi 控制台中搜索并安装
 koishi-plugin-group-verification
@@ -99,6 +104,8 @@ group-verify.stats total
 ## ⚙️ 参数说明
 
 ### 审核方式 (-m)
+
+*如果改变审核方式而未提供 `-t`，阈值会自动设置为最大值（方式1为关键词数量，方式2为100）。*
 - `0` - 全部同意（默认）
 - `1` - 按数量同意（需配合 -t 使用）
 - `2` - 按比例同意（需配合 -t 使用）

package/src/index.ts

@@ -57,15 +57,25 @@ export interface Config {
   defaultReminderMessage?: string
   enableStrictGroupCheck?: boolean  // 群号合法性检查配置
   logLevel?: 'debug' | 'info' | 'warn' | 'error'  // 日志等级配置
+  // 以下为可自定义的命令反馈提示词，可在插件管理界面调整
+  permissionDeniedMessage?: string
+  invalidGroupMessage?: string
+  parameterConflictMessage?: string
+  noKeywordsMessage?: string
 }
 
 export const Config: Schema<Config> = Schema.object({
   defaultReminderMessage: Schema.string()
-    .description('默认提醒消息模板（使用 \n 表示换行，可包含下方变量）')
+    .description('默认提醒消息模板（使用 \\n 表示换行，可包含下方变量）')
     .default('{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}\n使用 gva 同意或 gvr 拒绝申请'),
   enableStrictGroupCheck: Schema.boolean().description('是否启用严格的群号检查（检查群号长度）').default(false),
-  logLevel: Schema.union(['debug', 'info', 'warn', 'error']).description('日志级别').default('info')
-}).description('群组验证插件配置')
+  logLevel: Schema.union(['debug', 'info', 'warn', 'error']).description('日志级别').default('info'),
+  permissionDeniedMessage: Schema.string().description('权限不足时返回给调用者的提示').default('权限不足：需要群主/管理员权限或koishi三级以上权限'),
+  invalidGroupMessage: Schema.string().description('无效群号或机器人未在该群时的提示').default('群号 {group} 格式不合法或机器人不在该群中'),
+  parameterConflictMessage: Schema.string().description('参数冲突时提示').default('参数冲突：-? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）'),
+  noKeywordsMessage: Schema.string().description('未提供关键词且无法从现有配置继承时的提示').default('请先提供关键词创建配置，或使用 -? 查询配置，-r 删除配置'),
+})
+  .description('群组验证插件配置')
 
 export const inject = ['database']
 
@@ -257,10 +267,12 @@ export function mergeReminder(
   hasRealMessageParam: boolean,
   hasRealEnableMessageParam: boolean,
   hasRealDisableMessageParam: boolean,
-  logger: any
+  logger: any,
+  defaultMessage?: string
 ) {
   let reminderEnabled = true;
-  let reminderMessage = '{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}';
+  // 优先使用传入的默认模板，其次使用已有配置，再 fallback 到老写死的样式
+  let reminderMessage = defaultMessage || '{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}';
 
   if (existingConfig) {
     reminderEnabled = existingConfig.reminderEnabled;
@@ -271,15 +283,15 @@ export function mergeReminder(
   // 优先级：disable > bare enable > new message content
   if (hasRealDisableMessageParam) {
     reminderEnabled = false;
-    logger.info('禁用提醒消息功能 (保留现有内容)');
+    logger.debug('禁用提醒消息功能 (保留现有内容)');
   } else if (hasRealEnableMessageParam) {
     reminderEnabled = true;
-    logger.info(`启用提醒消息（保留原消息）: ${reminderMessage.substring(0, 50)}...`);
+    logger.debug(`启用提醒消息（保留原消息）: ${reminderMessage.substring(0, 50)}...`);
   } else if (hasRealMessageParam) {
     reminderEnabled = true;
     if (cleanedOptions.message !== undefined) {
       reminderMessage = cleanedOptions.message.replace(/\\n/g, '\n');
-      logger.info(`设置自定义提醒消息: ${reminderMessage.substring(0, 50)}...`);
+      logger.debug(`设置自定义提醒消息: ${reminderMessage.substring(0, 50)}...`);
     }
   }
   return { reminderEnabled, reminderMessage };
@@ -319,7 +331,7 @@ export async function syncTotalStats(ctx: Context) {
         lastUpdated: new Date().toISOString()
       })
       
-      logger.info(`总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}, 入群${totalJoined}`)
+      logger.debug(`总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}, 入群${totalJoined}`)
     }
   } catch (error) {
     logger.error('同步总计统计时出错:', error)
@@ -373,6 +385,65 @@ export async function incrementTotal(ctx: Context, groupId: string) {
   await syncTotalStats(ctx)
 }
 
+// helper to decide reviewParameters based on existing configuration, keyword list, user inputs,
+// and whether the audit method has been changed by the command.
+export interface ThresholdResult {
+  reviewParameters: number
+  error?: string
+  autoInfo?: 'methodChange' | 'kwChange'
+}
+
+export function resolveThreshold(
+  existingConfig: any | null,
+  keywordList: string[],
+  reviewMethod: 0 | 1 | 2 | 3,
+  thresholdStr?: string,
+  methodChanged: boolean = false
+): ThresholdResult {
+  let reviewParameters = 0
+  if (existingConfig) {
+    reviewParameters = existingConfig.reviewParameters || 0
+    if (isNaN(reviewParameters)) reviewParameters = 0
+  }
+  // explicit threshold provided by user
+  if (thresholdStr !== undefined) {
+    const thresholdNum = parseInt(thresholdStr)
+    if (isNaN(thresholdNum)) {
+      return { reviewParameters, error: '阈值参数必须为数字' }
+    }
+    if (reviewMethod === 1) {
+      if (thresholdNum < 0 || thresholdNum > keywordList.length) {
+        return { reviewParameters, error: `数量阈值必须在0-${keywordList.length}之间（0表示全部同意）` }
+      }
+    } else if (reviewMethod === 2) {
+      if (thresholdNum < 0 || thresholdNum > 100) {
+        return { reviewParameters, error: '比例阈值必须在0-100之间（0表示全部同意）' }
+      }
+    }
+    return { reviewParameters: thresholdNum }
+  }
+  // no threshold specified by user
+  if (methodChanged) {
+    if (reviewMethod === 1) {
+      reviewParameters = keywordList.length
+      return { reviewParameters, autoInfo: 'methodChange' }
+    }
+    if (reviewMethod === 2) {
+      reviewParameters = 100
+      return { reviewParameters, autoInfo: 'methodChange' }
+    }
+  }
+  if (existingConfig && reviewMethod === 1 && reviewParameters !== 0) {
+    const oldKeywordCount = existingConfig.keywords.length
+    const newKeywordCount = keywordList.length
+    if (oldKeywordCount !== newKeywordCount) {
+      reviewParameters = newKeywordCount
+      return { reviewParameters, autoInfo: 'kwChange' }
+    }
+  }
+  return { reviewParameters }
+}
+
 // 权限检查函数（也可用于命令）
 export async function checkPermission(session: any, targetGroupId?: string): Promise<[boolean, string?]> {
   const groupId = targetGroupId || session.guildId
@@ -382,19 +453,18 @@ export async function checkPermission(session: any, targetGroupId?: string): Pro
     return [false, '请在群聊中使用此命令或使用 -i 参数指定群号']
   }
   
-  logger.info(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`)
+  logger.debug(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`)
   const koishiAuthority = session.author?.authority || session.user?.authority
-  logger.info(`权限检查 - Koishi权限等级: ${koishiAuthority || '未获取到'}`)
+  logger.debug(`权限检查 - Koishi权限等级: ${koishiAuthority || '未获取到'}`)
   
   if (!session.author) {
-    logger.info(`权限检查 - session中可能的权限字段:`, {
+    logger.debug(`权限检查 - session中可能的权限字段:`, {
       authority: session.authority,
       permission: session.permission,
       role: session.role
     })
   } else {
-    logger.info(`权限检查 - author对象中的字段:`, {
-      authority: session.author.authority,
+    logger.debug(`权限检查 - author对象中的字段:`, {
       permission: session.author.permission,
       role: session.author.role,
       permissions: session.author.permissions
@@ -402,7 +472,7 @@ export async function checkPermission(session: any, targetGroupId?: string): Pro
   }
   
   if (session.user) {
-    logger.info(`权限检查 - user对象中的权限信息:`, {
+    logger.debug(`权限检查 - user对象中的权限信息:`, {
       authority: session.user.authority,
       permission: session.user.permission,
       role: session.user.role
@@ -464,13 +534,13 @@ export async function handleGuildMemberRequestEvent(ctx: Context, session: any)
   }
 
   const { isValid, matchedCount, requiredThreshold } = await verifyApplication(config, message, session);
-  logger.info(`验证结果 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
+  logger.debug(`验证结果 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
 
   if (isValid) {
     if (requestId) {
       try {
         await session.bot.handleGuildMemberRequest(requestId, true);
-        logger.info(`自动同意 requestId=${requestId}`);
+        logger.debug(`自动同意 requestId=${requestId}`);
         if (!autoQueue.has(guildId)) autoQueue.set(guildId, new Set());
         autoQueue.get(guildId)!.add(userId);
       } catch (e) {
@@ -640,7 +710,7 @@ export async function verifyApplication(config: GroupVerificationConfig, message
       requiredThreshold = 'null'
   }
 
-  logger.info(`verifyApplication msg="${message}" keywords=${JSON.stringify(config.keywords)} matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`)
+  logger.debug(`verifyApplication msg="${message}" keywords=${JSON.stringify(config.keywords)} matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`)
   return { isValid, matchedCount, requiredThreshold }
 }
 
@@ -661,7 +731,7 @@ export async function handleFailedVerification(
   }
   const username = session.username || '未知用户'
   const message = session.content || ''
-  logger.info(`处理失败验证 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold}`)
+  logger.debug(`处理失败验证 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold}`)
   // 如果未传入匹配信息，则重新计算一次（老调用）
   if (matchedCount === undefined || requiredThreshold === undefined) {
     const result = await verifyApplication(config, message, session)
@@ -695,7 +765,7 @@ export async function handleFailedVerification(
   })
   // 如果提醒消息被禁用，直接返回
   if (!config.reminderEnabled || !config.reminderMessage || config.reminderMessage === '') {
-    logger.info(`群 ${guildId} 的提醒消息已被禁用，跳过发送`)
+    logger.debug(`群 ${guildId} 的提醒消息已被禁用，跳过发送`)
     return
   }
 
@@ -760,6 +830,8 @@ export function apply(ctx: Context, config: Config) {
 
   // 获取logger实例并保存到模块级变量
   logger = ctx.logger('group-verification')
+  // 根据配置调整日志等级
+  if (config.logLevel) logger.level = config.logLevel
   
   // 设置日志级别
   // 注意：Koishi logger的level设置可能需要不同的方式
@@ -857,26 +929,26 @@ export function apply(ctx: Context, config: Config) {
     
     // 私聊情况下必须指定群号
     if (!groupId) {
-      return [false, '请在群聊中使用此命令或使用 -i 参数指定群号']
+      return [false, config.invalidGroupMessage || '请在群聊中使用此命令或使用 -i 参数指定群号']
     }
     
     // 使用Koishi logger输出调试信息
-    logger.info(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`)
+    logger.debug(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`)
     
     // 检查koishi权限等级（最高优先级）
     const koishiAuthority = session.author?.authority || session.user?.authority
-    logger.info(`权限检查 - Koishi权限等级: ${koishiAuthority || '未获取到'}`)
+    logger.debug(`权限检查 - Koishi权限等级: ${koishiAuthority || '未获取到'}`)
     
     // 尝试其他可能的权限字段
     if (!session.author) {
-      logger.info(`权限检查 - session中可能的权限字段:`, {
+      logger.debug(`权限检查 - session中可能的权限字段:`, {
         authority: session.authority,
         permission: session.permission,
         role: session.role
       })
     } else {
       // 检查author对象中的其他权限字段
-      logger.info(`权限检查 - author对象中的字段:`, {
+      logger.debug(`权限检查 - author对象中的字段:`, {
         authority: session.author.authority,
         permission: session.author.permission,
         role: session.author.role,
@@ -886,7 +958,7 @@ export function apply(ctx: Context, config: Config) {
     
     // 尝试从user对象获取权限信息
     if (session.user) {
-      logger.info(`权限检查 - user对象中的权限信息:`, {
+      logger.debug(`权限检查 - user对象中的权限信息:`, {
         authority: session.user.authority,
         permission: session.user.permission,
         role: session.user.role
@@ -895,14 +967,14 @@ export function apply(ctx: Context, config: Config) {
     
     // 先检查koishi权限等级（最高优先级）
     if (koishiAuthority && koishiAuthority >= 3) {
-      logger.info(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`)
+      logger.debug(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`)
       return [true]
     }
     
     // 再检查是否为群主或管理员（次优先级）
     try {
       const member = await session.bot.getGuildMember(groupId, session.userId)
-      logger.info(`权限检查 - 获取到成员信息:`, {
+      logger.debug(`权限检查 - 获取到成员信息:`, {
         roles: member?.roles,
         permissions: member?.permissions
       })
@@ -915,7 +987,7 @@ export function apply(ctx: Context, config: Config) {
         }
         // 检查管理员权限
         if (member.roles?.includes('admin') || member.permissions?.includes('ADMINISTRATOR')) {
-          logger.info(`权限检查 - 用户是管理员`)
+          logger.debug(`权限检查 - 用户是管理员`)
           return [true]
         }
       }
@@ -924,9 +996,9 @@ export function apply(ctx: Context, config: Config) {
       return [false, `无法获取群 ${groupId} 的成员信息，请确认机器人已在该群中`]
     }
     
-    logger.info(`权限检查 - 权限不足`)
+    logger.debug(`权限检查 - 权限不足`)
     const debugInfo = `调试信息 - 用户ID:${session.userId}, 群号:${groupId}, 权限等级:${koishiAuthority || '未知'}`
-    return [false, `权限不足：需要群主/管理员权限或koishi三级以上权限\n${debugInfo}`]
+    return [false, (config.permissionDeniedMessage || '权限不足：需要群主/管理员权限或koishi三级以上权限') + `\n${debugInfo}`]
   }
 
   // Create main command with aliases
@@ -985,7 +1057,7 @@ export function apply(ctx: Context, config: Config) {
       if ((cleanedOptions.query || cleanedOptions.remove) &&
           (parsedKeywords.length > 0 || cleanedOptions.method !== undefined || cleanedOptions.threshold !== undefined ||
            cleanedOptions.message !== undefined || cleanedOptions.enableMessage || cleanedOptions.disableMessage)) {
-        return '参数冲突：-? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）'
+        return config.parameterConflictMessage || '参数冲突：-? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）'
       }
 
       // 检查消息参数冲突
@@ -1138,7 +1210,7 @@ export function apply(ctx: Context, config: Config) {
       // 处理关键词：如果没有关键词但有其他参数，从现有配置中获取
       if (keywordList.length === 0 && !cleanedOptions.query && !cleanedOptions.remove) {
         if (!existingConfig) {
-          return '请先提供关键词创建配置，或使用 -? 查询配置，-r 删除配置'
+          return config.noKeywordsMessage || '请先提供关键词创建配置，或使用 -? 查询配置，-r 删除配置'
         }
         keywordList = existingConfig.keywords
       }
@@ -1150,7 +1222,8 @@ export function apply(ctx: Context, config: Config) {
         hasRealMessageParam,
         hasRealEnableMessageParam,
         hasRealDisableMessageParam,
-        logger
+        logger,
+        config.defaultReminderMessage
       )
       
       // 解析审核方式和阈值（基于新的数据库模型设计）
@@ -1178,54 +1251,48 @@ export function apply(ctx: Context, config: Config) {
         if (isNaN(methodNum) || methodNum < 0 || methodNum > 3) {
           return '审核方式参数错误：0-全部同意, 1-按数量同意, 2-按比例同意, 3-全部拒绝'
         }
+        const oldMethod = reviewMethod
         reviewMethod = methodNum as 0 | 1 | 2 | 3
-        logger.info(`审核方式明确指定为: ${reviewMethod}`)
+        logger.debug(`审核方式明确指定为: ${reviewMethod}`)
+        var methodChanged = oldMethod !== reviewMethod
       } else {
-        logger.info(`未指定审核方式，保持原有值: ${reviewMethod}`)
+        logger.debug(`未指定审核方式，保持原有值: ${reviewMethod}`)
+        var methodChanged = false
       }
-      
-      // 处理阈值参数
-      if (cleanedOptions.threshold !== undefined) {
-        // 用户明确指定了阈值
-        const thresholdNum = parseInt(cleanedOptions.threshold)
-        if (isNaN(thresholdNum)) {
-          return '阈值参数必须为数字'
-        }
-        
-        if (reviewMethod === 1) { // 按数量同意
-          if (thresholdNum < 0 || thresholdNum > keywordList.length) {
-            return `数量阈值必须在0-${keywordList.length}之间（0表示全部同意）`
-          }
-          reviewParameters = thresholdNum
-          logger.info(`明确指定阈值: ${thresholdNum}`)
-        } else if (reviewMethod === 2) { // 按比例同意
-          if (thresholdNum < 0 || thresholdNum > 100) {
-            return '比例阈值必须在0-100之间（0表示全部同意）'
-          }
-          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: reviewParameters,
-            updatedBy: session.username || session.userId,
-            updatedAt: new Date().toISOString()
-          })
-          logger.info(`已更新数据库阈值为: ${reviewParameters}`)
-        } else {
-          // 关键词数量相同，保持原阈值
-          logger.info(`关键词数量未变化(${newKeywordCount})，保持原阈值: ${reviewParameters}`)
+
+      // 决定最终的阈值，可能会触发自动调整
+      const thresholdResult = resolveThreshold(
+        existingConfig,
+        keywordList,
+        reviewMethod,
+        cleanedOptions.threshold,
+        methodChanged
+      )
+      if (thresholdResult.error) {
+        return thresholdResult.error
+      }
+      reviewParameters = thresholdResult.reviewParameters
+
+      // 如果参数通过自动逻辑发生变化，回写数据库并记录提示
+      if (existingConfig && reviewParameters !== existingConfig.reviewParameters) {
+        await ctx.database.set('group_verification_config', { id: existingConfig.id }, {
+          reviewParameters,
+          updatedBy: session.username || session.userId,
+          updatedAt: new Date().toISOString()
+        })
+        logger.debug(`自动调整并更新数据库阈值为: ${reviewParameters}`)
+      }
+
+      // 自动调整说明，用于反馈消息
+      let autoAdjustNote = ''
+      if (thresholdResult.autoInfo === 'methodChange') {
+        if (reviewMethod === 1) {
+          autoAdjustNote = `⚠️ 审核方式由 ${existingConfig?.reviewMethod} 改为 ${reviewMethod}，阈值自动设为 ${reviewParameters}\n`
+        } else if (reviewMethod === 2) {
+          autoAdjustNote = `⚠️ 审核方式由 ${existingConfig?.reviewMethod} 改为 ${reviewMethod}，阈值自动设为 ${reviewParameters}%\n`
         }
+      } else if (thresholdResult.autoInfo === 'kwChange') {
+        autoAdjustNote = `⚠️ 关键词数量从${existingConfig?.keywords.length}变为${keywordList.length}，阈值已自动调整为${reviewParameters}\n`
       }
       
       // 数据库存储前的关键词编码处理
@@ -1270,6 +1337,7 @@ export function apply(ctx: Context, config: Config) {
       
       // 构建完整的配置反馈信息
       let feedbackMessage = `群 ${targetGroupId} 配置已更新:\n`
+      if (autoAdjustNote) feedbackMessage += autoAdjustNote
       // 使用原始输入的关键词显示，而不是处理后的keywordList
       const displayKeywords = keywordList.map(k => k.replace(/\[\[COMMA\]\]/g, ','))
       feedbackMessage += `关键词: ${displayKeywords.map(k => `"${k}"`).join(', ')}\n`
@@ -1288,11 +1356,6 @@ export function apply(ctx: Context, config: Config) {
         feedbackMessage += `提醒消息: ${reminderMessage.substring(0, 30)}${reminderMessage.length > 30 ? '...' : ''}\n`
       }
       
-      // 添加阈值自动调整提醒（如果有）
-      if (existingConfig && reviewMethod === 1 && 
-          keywordList.length !== existingConfig.keywords.length) {
-        feedbackMessage += `⚠️ 关键词数量从${existingConfig.keywords.length}变为${keywordList.length}，阈值已自动调整为${keywordList.length}\n`
-      }
       
       // 同时更新数据库存储时也要确保正确格式
       logger.info(`准备存储到数据库的关键词: ${JSON.stringify(encodedKeywords)}`)