koishi-plugin-best-cave 2.7.26 → 2.7.28

package/lib/AIManager.d.ts

@@ -40,15 +40,6 @@ 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 - 新提交的内容元素数组。
@@ -78,7 +69,6 @@ export declare class AIManager {
      * @param {CaveObject} caveA - 第一个回声洞对象。
      * @param {CaveObject} caveB - 第二个回声洞对象。
      * @returns {Promise<boolean>} 如果内容被 AI 判断为重复，则返回 true，否则返回 false。
-     * @throws {Error} 当 AI 请求失败时抛出。
      * @private
      */
     private isContentDuplicateAI;

package/lib/index.js

@@ -1154,16 +1154,29 @@ 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);
+        let failedCount = 0;
+        for (let i = 0; i < cavesToAnalyze.length; i += 25) {
+          const batch = cavesToAnalyze.slice(i, i + 25);
           this.logger.info(`[${i + 1}/${cavesToAnalyze.length}] 正在分析 ${batch.length} 个回声洞...`);
-          successCount += await this.processCaveBatch(batch, totalToAnalyze, progress);
+          const analysisPromises = batch.map((cave2) => this.analyze([cave2]));
+          const results = await Promise.allSettled(analysisPromises);
+          const successfulAnalyses = [];
+          for (let j = 0; j < results.length; j++) {
+            const result = results[j];
+            const cave2 = batch[j];
+            if (result.status === "fulfilled" && result.value.length > 0) {
+              successfulAnalyses.push(result.value[0]);
+            } else {
+              failedCount++;
+              if (result.status === "rejected") this.logger.error(`分析回声洞（${cave2.id}）失败:`, result.reason);
+            }
+          }
+          if (successfulAnalyses.length > 0) {
+            await this.ctx.database.upsert("cave_meta", successfulAnalyses);
+            successCount += successfulAnalyses.length;
+          }
         }
-        const failedCount = totalToAnalyze - successCount;
-        if (failedCount > 0) return `已分析 ${successCount} 个回声洞（失败 ${failedCount} 个）`;
+        return `已分析 ${successCount} 个回声洞（失败 ${failedCount} 个）`;
       } catch (error) {
         this.logger.error("分析回声洞失败:", error);
         return `操作失败: ${error.message}`;
@@ -1177,8 +1190,12 @@ var AIManager = class {
         if (allMeta.length < 2) return "无可比较数据";
         const candidatePairs = generateFromLSH(allMeta, (meta) => ({ id: meta.cave, keys: meta.keywords }));
         if (candidatePairs.size === 0) return "未发现相似内容";
-        const allCaves = new Map((await this.ctx.database.get("cave", { status: "active" })).map((c) => [c.id, c]));
-        const duplicatePairs = [];
+        const idsToCompare = /* @__PURE__ */ new Set();
+        candidatePairs.forEach((pairKey) => {
+          pairKey.split("-").map(Number).forEach((id) => idsToCompare.add(id));
+        });
+        const caveData = await this.ctx.database.get("cave", { id: { $in: Array.from(idsToCompare) }, status: "active" });
+        const allCaves = new Map(caveData.map((c) => [c.id, c]));
         const comparisonPromises = Array.from(candidatePairs).map(async (pairKey) => {
           const [id1, id2] = pairKey.split("-").map(Number);
           const cave1 = allCaves.get(id1);
@@ -1187,7 +1204,7 @@ var AIManager = class {
           return null;
         });
         const results = await Promise.all(comparisonPromises);
-        duplicatePairs.push(...results.filter(Boolean));
+        const duplicatePairs = results.filter(Boolean);
         if (duplicatePairs.length === 0) return "未发现高重复性的内容";
         const dsu = new DSU();
         const allIds = /* @__PURE__ */ new Set();
@@ -1217,38 +1234,6 @@ var AIManager = class {
       }
     });
   }
-  /**
-   * @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 - 新提交的内容元素数组。
@@ -1310,12 +1295,14 @@ ${combinedText}` });
       contentForAI.push(...images);
       const userMessage = { role: "user", content: contentForAI };
       const response = await this.requestAI([userMessage], this.ANALYSIS_SYSTEM_PROMPT);
-      if (response) return {
-        cave: cave.id,
-        keywords: response.keywords || [],
-        description: response.description || "",
-        rating: Math.max(0, Math.min(100, response.rating || 0))
-      };
+      if (response) {
+        return {
+          cave: cave.id,
+          keywords: response.keywords || [],
+          description: response.description || "",
+          rating: Math.max(0, Math.min(100, response.rating || 0))
+        };
+      }
       return null;
     });
     const results = await Promise.all(analysisPromises);
@@ -1326,7 +1313,6 @@ ${combinedText}` });
    * @param {CaveObject} caveA - 第一个回声洞对象。
    * @param {CaveObject} caveB - 第二个回声洞对象。
    * @returns {Promise<boolean>} 如果内容被 AI 判断为重复，则返回 true，否则返回 false。
-   * @throws {Error} 当 AI 请求失败时抛出。
    * @private
    */
   async isContentDuplicateAI(caveA, caveB) {
@@ -1379,28 +1365,21 @@ ${combinedText}` });
       "Content-Type": "application/json",
       "Authorization": `Bearer ${this.config.aiApiKey}`
     };
-    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;
+    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));
   }
 };
 

package/package.json

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