koishi-plugin-best-cave 2.7.24 → 2.7.26

package/lib/AIManager.d.ts

@@ -40,6 +40,15 @@ export declare class AIManager {
      * @param {any} cave - 主命令的实例，用于挂载子命令。
      */
     registerCommands(cave: any): void;
+    /**
+     * @description 递归处理和分析回声洞批次，失败时按 1/5 拆分以定位问题。
+     * @param {CaveObject[]} caves - 当前要处理的回声洞对象数组。
+     * @param {number} totalCaves - 要分析的回声洞总数。
+     * @param {{ count: number }} progress - 用于跟踪总体进度的计数器对象。
+     * @returns {Promise<number>} 成功分析的回声洞数量。
+     * @private
+     */
+    private processCaveBatch;
     /**
      * @description 对新提交的内容执行 AI 驱动的查重检查。
      * @param {StoredElement[]} newElements - 新提交的内容元素数组。

package/lib/index.js

@@ -103,9 +103,9 @@ var FileManager = class {
       });
       await this.s3Client.send(command);
     } else {
-      await fs.mkdir(this.resourceDir, { recursive: true }).catch((error2) => {
-        this.logger.error(`创建资源目录失败 ${this.resourceDir}:`, error2);
-        throw error2;
+      await fs.mkdir(this.resourceDir, { recursive: true }).catch((error) => {
+        this.logger.error(`创建资源目录失败 ${this.resourceDir}:`, error);
+        throw error;
       });
       const filePath = path.join(this.resourceDir, fileName);
       await this.withLock(filePath, () => fs.writeFile(filePath, data));
@@ -139,9 +139,9 @@ var FileManager = class {
         const filePath = path.join(this.resourceDir, fileIdentifier);
         await this.withLock(filePath, () => fs.unlink(filePath));
       }
-    } catch (error2) {
-      if (error2.code !== "ENOENT" && error2.name !== "NoSuchKey") {
-        this.logger.warn(`删除文件 ${fileIdentifier} 失败:`, error2);
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.name !== "NoSuchKey") {
+        this.logger.warn(`删除文件 ${fileIdentifier} 失败:`, error);
       }
     }
   }
@@ -238,8 +238,8 @@ async function buildCaveMessage(cave, config, fileManager, logger2, platform, pr
             return resultNodes;
           }));
           return (0, import_koishi.h)("message", { forward: true }, messageNodes.flat());
-        } catch (error2) {
-          logger2.warn(`解析回声洞（${cave.id}）合并转发内容失败:`, error2);
+        } catch (error) {
+          logger2.warn(`解析回声洞（${cave.id}）合并转发内容失败:`, error);
           return import_koishi.h.text("[合并转发]");
         }
       }
@@ -252,8 +252,8 @@ async function buildCaveMessage(cave, config, fileManager, logger2, platform, pr
           const data2 = await fileManager.readFile(fileName);
           const mimeType = mimeTypeMap[path2.extname(fileName).toLowerCase()] || "application/octet-stream";
           return (0, import_koishi.h)(el.type, { ...el, src: `data:${mimeType};base64,${data2.toString("base64")}` });
-        } catch (error2) {
-          logger2.warn(`转换文件 ${fileName} 为 Base64 失败:`, error2);
+        } catch (error) {
+          logger2.warn(`转换文件 ${fileName} 为 Base64 失败:`, error);
           return (0, import_koishi.h)("p", {}, `[${el.type}]`);
         }
       }
@@ -332,8 +332,8 @@ async function cleanupPendingDeletions(ctx, config, fileManager, logger2, reusab
     await ctx.database.remove("cave", { id: { $in: idsToDelete } });
     await ctx.database.remove("cave_hash", { cave: { $in: idsToDelete } });
     if (config.enableAI) await ctx.database.remove("cave_meta", { cave: { $in: idsToDelete } });
-  } catch (error2) {
-    logger2.error("清理回声洞时发生错误:", error2);
+  } catch (error) {
+    logger2.error("清理回声洞时发生错误:", error);
   }
 }
 __name(cleanupPendingDeletions, "cleanupPendingDeletions");
@@ -481,8 +481,8 @@ async function performSimilarityChecks(ctx, config, hashManager, logger2, finalE
       }
     }
     return { duplicate: false, textHashesToStore, imageHashesToStore };
-  } catch (error2) {
-    logger2.warn("相似度比较失败:", error2);
+  } catch (error) {
+    logger2.warn("相似度比较失败:", error);
     return { duplicate: false, textHashesToStore: [], imageHashesToStore: [] };
   }
 }
@@ -578,9 +578,9 @@ var DataManager = class {
       try {
         await session.send("正在处理，请稍候...");
         return await action();
-      } catch (error2) {
-        this.logger.error("数据操作时发生错误:", error2);
-        return `操作失败: ${error2.message}`;
+      } catch (error) {
+        this.logger.error("数据操作时发生错误:", error);
+        return `操作失败: ${error.message}`;
       }
     }, "commandAction");
     cave.subcommand(".export", "导出回声洞数据", { hidden: true, authority: 4 }).usage("将所有回声洞数据导出到 cave.json 中。").action(commandAction(() => this.exportData()));
@@ -607,8 +607,8 @@ var DataManager = class {
       const fileContent = await this.fileManager.readFile(fileName);
       importedCaves = JSON.parse(fileContent.toString("utf-8"));
       if (!Array.isArray(importedCaves) || !importedCaves.length) throw new Error("导入文件格式无效或为空");
-    } catch (error2) {
-      throw new Error(`读取导入文件失败: ${error2.message}`);
+    } catch (error) {
+      throw new Error(`读取导入文件失败: ${error.message}`);
     }
     const allDbCaves = await this.ctx.database.get("cave", {}, { fields: ["id"] });
     const existingIds = new Set(allDbCaves.map((c) => c.id));
@@ -703,9 +703,9 @@ ${pendingCaves.map((c) => c.id).join("|")}`;
         await this.ctx.database.upsert("cave", processedIds.map((id) => ({ id, status: targetStatus })));
         if (targetStatus === "delete") cleanupPendingDeletions(this.ctx, this.config, this.fileManager, this.logger, this.reusableIds);
         return `已${actionText}回声洞（${processedIds.join("|")}）`;
-      } catch (error2) {
-        this.logger.error(`审核操作失败:`, error2);
-        return `操作失败: ${error2.message}`;
+      } catch (error) {
+        this.logger.error(`审核操作失败:`, error);
+        return `操作失败: ${error.message}`;
       }
     }, "createPendAction");
     pend.subcommand(".Y [...ids:posint]", "通过审核").usage("通过一个或多个指定 ID 的回声洞审核。若不指定 ID，则通过所有待审核的回声洞。").action(createPendAction("approve"));
@@ -725,8 +725,8 @@ ${pendingCaves.map((c) => c.id).join("|")}`;
       const [platform] = this.config.adminChannel.split(":", 1);
       const caveMessages = await buildCaveMessage(cave, this.config, this.fileManager, this.logger, platform, "待审核");
       for (const message of caveMessages) if (message.length > 0) await this.ctx.broadcast([this.config.adminChannel], import_koishi2.h.normalize(message));
-    } catch (error2) {
-      this.logger.error(`发送回声洞（${cave.id}）审核消息失败:`, error2);
+    } catch (error) {
+      this.logger.error(`发送回声洞（${cave.id}）审核消息失败:`, error);
     }
   }
 };
@@ -809,17 +809,17 @@ var HashManager = class {
             const newHashesForCave = tempHashes;
             if (newHashesForCave.length > 0) hashesToInsert.push(...newHashesForCave);
             if (hashesToInsert.length >= 100) await flushBatch();
-          } catch (error2) {
+          } catch (error) {
             errorCount++;
-            this.logger.warn(`补全回声洞（${cave2.id}）哈希时出错: ${error2.message}`);
+            this.logger.warn(`补全回声洞（${cave2.id}）哈希时出错: ${error.message}`);
           }
         }
         await flushBatch();
         const successCount = processedCaveCount - errorCount;
         return `已补全 ${successCount} 个回声洞的 ${totalHashesGenerated} 条哈希（失败 ${errorCount} 条）`;
-      } catch (error2) {
-        this.logger.error("补全哈希失败:", error2);
-        return `操作失败: ${error2.message}`;
+      } catch (error) {
+        this.logger.error("补全哈希失败:", error);
+        return `操作失败: ${error.message}`;
       }
     });
     cave.subcommand(".check", "检查相似度", { hidden: true }).usage("检查所有回声洞，找出相似度过高的内容。").option("textThreshold", "-t <threshold:number> 文本相似度阈值 (%)").option("imageThreshold", "-i <threshold:number> 图片相似度阈值 (%)").action(async ({ session, options }) => {
@@ -903,9 +903,9 @@ ${textResult.reportLines.join("\n")}`;
 ${imageResult.reportLines.join("\n")}`;
         }
         return report.trim();
-      } catch (error2) {
-        this.logger.error("检查相似度失败:", error2);
-        return `检查失败: ${error2.message}`;
+      } catch (error) {
+        this.logger.error("检查相似度失败:", error);
+        return `检查失败: ${error.message}`;
       }
     });
     cave.subcommand(".fix [...ids:posint]", "修复回声洞", { hidden: true, authority: 3 }).usage("扫描并修复回声洞中的图片，可指定一个或多个 ID。").action(async ({ session }, ...ids) => {
@@ -931,18 +931,18 @@ ${imageResult.reportLines.join("\n")}`;
                 await this.fileManager.saveFile(element.file, sanitizedBuffer);
                 fixedFiles++;
               }
-            } catch (error2) {
-              if (error2.code !== "ENOENT" && error2.name !== "NoSuchKey") {
-                this.logger.warn(`无法修复回声洞（${cave2.id}）的图片（${element.file}）:`, error2);
+            } catch (error) {
+              if (error.code !== "ENOENT" && error.name !== "NoSuchKey") {
+                this.logger.warn(`无法修复回声洞（${cave2.id}）的图片（${element.file}）:`, error);
                 errorCount++;
               }
             }
           }
         }
         return `已修复 ${cavesToProcess.length} 个回声洞的 ${fixedFiles} 张图片（失败 ${errorCount} 条）`;
-      } catch (error2) {
-        this.logger.error("修复图像文件时发生严重错误:", error2);
-        return `操作失败: ${error2.message}`;
+      } catch (error) {
+        this.logger.error("修复图像文件时发生严重错误:", error);
+        return `操作失败: ${error.message}`;
       }
     });
   }
@@ -1083,7 +1083,6 @@ ${imageResult.reportLines.join("\n")}`;
 
 // src/AIManager.ts
 var path3 = __toESM(require("path"));
-var import_console = require("console");
 var AIManager = class {
   /**
    * @constructor
@@ -1155,20 +1154,19 @@ var AIManager = class {
         if (cavesToAnalyze.length === 0) return "无需分析回声洞";
         await session.send(`开始分析 ${cavesToAnalyze.length} 个回声洞...`);
         let successCount = 0;
+        const totalToAnalyze = cavesToAnalyze.length;
+        const progress = { count: 0 };
         const batchSize = 25;
         for (let i = 0; i < cavesToAnalyze.length; i += batchSize) {
           const batch = cavesToAnalyze.slice(i, i + batchSize);
-          this.logger.info(`[${i + 1}/${cavesToAnalyze.length}] 正在分析 ${batch.length} 条回声洞...`);
-          const analyses = await this.analyze(batch);
-          if (analyses.length > 0) {
-            await this.ctx.database.upsert("cave_meta", analyses);
-            successCount += analyses.length;
-          }
+          this.logger.info(`[${i + 1}/${cavesToAnalyze.length}] 正在分析 ${batch.length} 个回声洞...`);
+          successCount += await this.processCaveBatch(batch, totalToAnalyze, progress);
         }
-        return `已分析 ${successCount} 个回声洞`;
-      } catch (error2) {
-        this.logger.error("分析回声洞失败:", error2);
-        return `操作失败: ${error2.message}`;
+        const failedCount = totalToAnalyze - successCount;
+        if (failedCount > 0) return `已分析 ${successCount} 个回声洞（失败 ${failedCount} 个）`;
+      } catch (error) {
+        this.logger.error("分析回声洞失败:", error);
+        return `操作失败: ${error.message}`;
       }
     });
     cave.subcommand(".compare", "比较重复性", { hidden: true }).usage("检查回声洞，找出可能重复的内容。").action(async ({ session }) => {
@@ -1213,12 +1211,44 @@ var AIManager = class {
 - ${sortedCluster.join("|")}`;
         });
         return report;
-      } catch (error2) {
-        this.logger.error("检查重复性失败:", error2);
-        return `检查失败: ${error2.message}`;
+      } catch (error) {
+        this.logger.error("检查重复性失败:", error);
+        return `检查失败: ${error.message}`;
       }
     });
   }
+  /**
+   * @description 递归处理和分析回声洞批次，失败时按 1/5 拆分以定位问题。
+   * @param {CaveObject[]} caves - 当前要处理的回声洞对象数组。
+   * @param {number} totalCaves - 要分析的回声洞总数。
+   * @param {{ count: number }} progress - 用于跟踪总体进度的计数器对象。
+   * @returns {Promise<number>} 成功分析的回声洞数量。
+   * @private
+   */
+  async processCaveBatch(caves, totalCaves, progress) {
+    if (caves.length === 0) return 0;
+    this.logger.info(`[${progress.count + 1}/${totalCaves}] 正在分析回声洞（${caves.map((c) => c.id).join("|")}）...`);
+    try {
+      const analyses = await this.analyze(caves);
+      if (analyses.length > 0) await this.ctx.database.upsert("cave_meta", analyses);
+      progress.count += caves.length;
+      return analyses.length;
+    } catch (error) {
+      if (caves.length > 1) {
+        const subBatches = [];
+        const subBatchSize = Math.ceil(caves.length / 5);
+        for (let i = 0; i < caves.length; i += subBatchSize) subBatches.push(caves.slice(i, i + subBatchSize));
+        const processingPromises = subBatches.map((subBatch) => this.processCaveBatch(subBatch, totalCaves, progress));
+        const results = await Promise.all(processingPromises);
+        return results.reduce((sum, count) => sum + count, 0);
+      } else {
+        const failedCave = caves[0];
+        progress.count++;
+        this.logger.error(`[${progress.count}/${totalCaves}] 分析回声洞（${failedCave.id}）失败:`, error);
+        return 0;
+      }
+    }
+  }
   /**
    * @description 对新提交的内容执行 AI 驱动的查重检查。
    * @param {StoredElement[]} newElements - 新提交的内容元素数组。
@@ -1241,8 +1271,8 @@ var AIManager = class {
       });
       const duplicateIds = (await Promise.all(comparisonPromises)).filter((id) => id !== null);
       return { duplicate: duplicateIds.length > 0, ids: duplicateIds };
-    } catch (error2) {
-      this.logger.error("查重回声洞出错:", error2);
+    } catch (error) {
+      this.logger.error("查重回声洞出错:", error);
       return { duplicate: false };
     }
   }
@@ -1265,16 +1295,19 @@ var AIManager = class {
               type: "image_url",
               image_url: { url: `data:${mimeType};base64,${buffer.toString("base64")}` }
             };
-          } catch (error2) {
-            this.logger.warn(`读取文件（${el.file}）失败:`, error2);
+          } catch (error) {
+            this.logger.warn(`读取文件（${el.file}）失败:`, error);
+            return null;
           }
         })
       );
       const images = imageElements.filter(Boolean);
       if (!combinedText.trim() && images.length === 0) return null;
-      const contentForAI = [{ type: "text", text: `请分析以下内容：
+      const contentForAI = [];
+      if (combinedText.trim()) contentForAI.push({ type: "text", text: `请分析以下内容：
 
-${combinedText}` }, ...images];
+${combinedText}` });
+      contentForAI.push(...images);
       const userMessage = { role: "user", content: contentForAI };
       const response = await this.requestAI([userMessage], this.ANALYSIS_SYSTEM_PROMPT);
       if (response) return {
@@ -1306,8 +1339,8 @@ ${combinedText}` }, ...images];
       const userMessage = { role: "user", content: JSON.stringify(userMessageContent) };
       const response = await this.requestAI([userMessage], this.DUPLICATE_CHECK_SYSTEM_PROMPT);
       return response?.duplicate || false;
-    } catch (error2) {
-      this.logger.error(`比较回声洞（${caveA.id}）与（${caveB.id}）失败:`, error2);
+    } catch (error) {
+      this.logger.error(`比较回声洞（${caveA.id}）与（${caveB.id}）失败:`, error);
       return false;
     }
   }
@@ -1346,22 +1379,28 @@ ${combinedText}` }, ...images];
       "Content-Type": "application/json",
       "Authorization": `Bearer ${this.config.aiApiKey}`
     };
-    const response = await this.http.post(fullUrl, payload, { headers, timeout: 6e5 });
-    const content = response?.choices?.[0]?.message?.content;
-    if (!content?.trim()) throw import_console.error;
-    const candidates = [];
-    const jsonBlockMatch = content.match(/```json\s*([\s\S]*?)\s*```/i);
-    if (jsonBlockMatch && jsonBlockMatch[1]) candidates.push(jsonBlockMatch[1]);
-    candidates.push(content);
-    const firstBrace = content.indexOf("{");
-    const lastBrace = content.lastIndexOf("}");
-    if (firstBrace !== -1 && lastBrace > firstBrace) candidates.push(content.substring(firstBrace, lastBrace + 1));
-    for (const candidate of [...new Set(candidates)]) try {
-      return JSON.parse(candidate);
-    } catch {
+    try {
+      const response = await this.http.post(fullUrl, payload, { headers, timeout: 6e5 });
+      const content = response?.choices?.[0]?.message?.content;
+      if (!content?.trim()) throw new Error();
+      const candidates = [];
+      const jsonBlockMatch = content.match(/```json\s*([\s\S]*?)\s*```/i);
+      if (jsonBlockMatch && jsonBlockMatch[1]) candidates.push(jsonBlockMatch[1]);
+      candidates.push(content);
+      const firstBrace = content.indexOf("{");
+      const lastBrace = content.lastIndexOf("}");
+      if (firstBrace !== -1 && lastBrace > firstBrace) candidates.push(content.substring(firstBrace, lastBrace + 1));
+      for (const candidate of [...new Set(candidates)]) {
+        try {
+          return JSON.parse(candidate);
+        } catch (parseError) {
+        }
+      }
+      this.logger.error("解析失败", "原始响应:", JSON.stringify(response, null, 2));
+      throw new Error();
+    } catch (e) {
+      throw e;
     }
-    this.logger.error("解析失败:", import_console.error, "原始响应:", JSON.stringify(response, null, 2));
-    throw import_console.error;
   }
 };
 
@@ -1440,8 +1479,8 @@ function apply(ctx, config) {
         await ctx.database.upsert("cave", idsToMark);
         await cleanupPendingDeletions(ctx, config, fileManager, logger, reusableIds);
       }
-    } catch (error2) {
-      logger.error("清理残留回声洞时发生错误:", error2);
+    } catch (error) {
+      logger.error("清理残留回声洞时发生错误:", error);
     }
   });
   const cave = ctx.command("cave", "回声洞").option("add", "-a <content:text> 添加回声洞").option("view", "-g <id:posint> 查看指定回声洞").option("delete", "-r <id:posint> 删除指定回声洞").option("list", "-l 查询投稿统计").usage("随机抽取一条已添加的回声洞。").action(async ({ session, options }) => {
@@ -1457,8 +1496,8 @@ function apply(ctx, config) {
       const [randomCave] = await ctx.database.get("cave", { ...query, id: randomId });
       const messages = await buildCaveMessage(randomCave, config, fileManager, logger, session.platform);
       for (const message of messages) if (message.length > 0) await session.send(import_koishi3.h.normalize(message));
-    } catch (error2) {
-      logger.error("随机获取回声洞失败:", error2);
+    } catch (error) {
+      logger.error("随机获取回声洞失败:", error);
       return "随机获取回声洞失败";
     }
   });
@@ -1534,11 +1573,11 @@ function apply(ctx, config) {
           if (allHashesToInsert.length > 0) await ctx.database.upsert("cave_hash", allHashesToInsert);
         }
         if (finalStatus === "pending" && reviewManager) reviewManager.sendForPend(newCave);
-      } catch (error2) {
-        logger.error(`回声洞（${newId}）处理失败:`, error2);
+      } catch (error) {
+        logger.error(`回声洞（${newId}）处理失败:`, error);
         await ctx.database.upsert("cave", [{ id: newId, status: "delete" }]);
         await cleanupPendingDeletions(ctx, config, fileManager, logger, reusableIds);
-        await session.send(`回声洞（${newId}）处理失败: ${error2.message}`);
+        await session.send(`回声洞（${newId}）处理失败: ${error.message}`);
       }
     })();
   });
@@ -1549,8 +1588,8 @@ function apply(ctx, config) {
       if (!targetCave) return `回声洞（${id}）不存在`;
       const messages = await buildCaveMessage(targetCave, config, fileManager, logger, session.platform);
       for (const message of messages) if (message.length > 0) await session.send(import_koishi3.h.normalize(message));
-    } catch (error2) {
-      logger.error(`查看回声洞（${id}）失败:`, error2);
+    } catch (error) {
+      logger.error(`查看回声洞（${id}）失败:`, error);
       return "查看失败，请稍后再试";
     }
   });
@@ -1566,8 +1605,8 @@ function apply(ctx, config) {
       const caveMessages = await buildCaveMessage(targetCave, config, fileManager, logger, session.platform, "已删除");
       for (const message of caveMessages) if (message.length > 0) await session.send(import_koishi3.h.normalize(message));
       cleanupPendingDeletions(ctx, config, fileManager, logger, reusableIds);
-    } catch (error2) {
-      logger.error(`标记回声洞（${id}）失败:`, error2);
+    } catch (error) {
+      logger.error(`标记回声洞（${id}）失败:`, error);
       return "删除失败，请稍后再试";
     }
   });
@@ -1596,8 +1635,8 @@ function apply(ctx, config) {
 `;
         });
         return report.trim();
-      } catch (error2) {
-        logger.error("查询排行失败:", error2);
+      } catch (error) {
+        logger.error("查询排行失败:", error);
         return "查询失败，请稍后再试";
       }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "功能强大、高度可定制的回声洞插件。支持丰富的媒体类型、内容查重、AI分析、人工审核、用户昵称、数据迁移以及本地/S3 双重文件存储后端。",
-  "version": "2.7.24",
+  "version": "2.7.26",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],