koishi-plugin-best-cave 2.7.11 → 2.7.13

package/lib/AIManager.d.ts

@@ -48,55 +48,44 @@ export declare class AIManager {
      * @description 对新提交的内容执行 AI 驱动的查重检查。
      * @param {StoredElement[]} newElements - 新提交的内容元素数组。
      * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组。
-     * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID（如果存在）。
+     * @returns {Promise<{ duplicate: boolean; ids?: number[] }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID 数组（如果存在）。
      */
     checkForDuplicates(newElements: StoredElement[], mediaBuffers?: {
         fileName: string;
         buffer: Buffer;
     }[]): Promise<{
         duplicate: boolean;
-        id?: number;
+        ids?: number[];
     }>;
     /**
-     * @description 对单个回声洞对象执行完整的分析和存储流程。
-     * @param {CaveObject} cave - 要分析的回声洞对象。
-     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，用于新提交内容的分析。
-     * @returns {Promise<void>} 分析和存储操作完成后解析的 Promise。
-     */
-    analyzeAndStore(cave: CaveObject, mediaBuffers?: {
-        fileName: string;
-        buffer: Buffer;
-    }[]): Promise<void>;
-    /**
-     * @description 对一批回声洞执行分析并存储结果。
+     * @description 对单个或批量回声洞执行完整的分析和存储流程。
      * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，仅在分析新内容时使用。
      * @returns {Promise<number>} 一个 Promise，解析为成功分析和存储的条目数。
      */
-    private analyzeAndStoreBatch;
+    analyzeAndStore(caves: CaveObject[], mediaBuffers?: {
+        fileName: string;
+        buffer: Buffer;
+    }[]): Promise<number>;
     /**
-     * @description 根据新内容的关键词，查找并返回可能重复的回声洞。
-     * @param {string[]} newKeywords - 新内容的关键词数组。
-     * @returns {Promise<CaveObject[]>} 一个 Promise，解析为可能重复的回声洞对象数组。
+     * @description 调用 AI 判断两个回声洞内容是否重复或高度相似。
+     * @param {CaveObject} caveA - 第一个回声洞对象。
+     * @param {CaveObject} caveB - 第二个回声洞对象。
+     * @returns {Promise<boolean>} 如果内容相似则返回 true，否则返回 false。
      */
-    private findPotentialDuplicates;
+    private isContentDuplicateAI;
     /**
      * @description 为一批回声洞准备内容，并向 AI 发送单个请求以获取所有分析结果。
      * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
      * @param {Map<string, Buffer>} [mediaBufferMap] - 可选的媒体文件名到其缓冲区的映射。
-     * @returns {Promise<any[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
+     * @returns {Promise<AnalysisResult[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
      */
     private getAnalyses;
     /**
-     * @description 确保请求不会超过设定的速率限制（RPM）。如果需要，会延迟执行。
-     * @returns {Promise<void>} 当可以继续发送请求时解析的 Promise。
-     */
-    private ensureRateLimit;
-    /**
-     * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑。
+     * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑，并稳健地解析 JSON 响应。
      * @param {any[]} messages - 发送给 AI 的消息数组，遵循 OpenAI 格式。
      * @param {string} systemPrompt - 系统提示词，用于指导 AI 的行为。
-     * @param {string} schemaString - 定义期望响应格式的 JSON Schema 字符串。
-     * @returns {Promise<any>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
+     * @returns {Promise<T>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
      * @throws {Error} 当 AI 返回空或无效内容时抛出错误。
      */
     private requestAI;

package/lib/HashManager.d.ts

@@ -32,6 +32,12 @@ export declare class HashManager {
      * @param cave - 主 `cave` 命令实例。
      */
     registerCommands(cave: any): void;
+    /**
+     * @description 扫描并修复单个图片 Buffer，移除文件结束符之后的多余数据。
+     * @param imageBuffer - 原始的图片 Buffer。
+     * @returns 修复后的图片 Buffer。如果无需修复，则返回原始 Buffer。
+     */
+    sanitizeImageBuffer(imageBuffer: Buffer): Buffer;
     /**
      * @description 执行一维离散余弦变换 (DCT-II) 的方法。
      * @param input - 输入的数字数组。

package/lib/Utils.d.ts

@@ -57,7 +57,7 @@ export declare function processMessageElements(sourceElements: h[], newId: numbe
  * @description 执行文本 (Simhash) 和图片 (pHash) 相似度查重。
  * @returns 一个对象，指示是否发现重复项；如果未发现，则返回生成的哈希。
  */
-export declare function performSimilarityChecks(ctx: Context, config: Config, hashManager: HashManager, finalElementsForDb: StoredElement[], downloadedMedia: {
+export declare function performSimilarityChecks(ctx: Context, config: Config, hashManager: HashManager, logger: Logger, finalElementsForDb: StoredElement[], downloadedMedia: {
     fileName: string;
     buffer: Buffer;
 }[]): Promise<{
@@ -81,7 +81,7 @@ export declare function performSimilarityChecks(ctx: Context, config: Config, ha
 export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, cave: CaveObject, downloadedMedia: {
     fileName: string;
     buffer: Buffer;
-}[], reusableIds: Set<number>, session: Session): Promise<'pending' | 'active'>;
+}[], reusableIds: Set<number>, needsReview: boolean): Promise<'pending' | 'active'>;
 /**
  * @description 校验会话是否来自指定的管理群组。
  * @param session 当前会话。

package/lib/index.d.ts

@@ -62,10 +62,6 @@ export interface Config {
     aiApiKey?: string;
     aiModel?: string;
     aiRPM?: number;
-    AnalysePrompt?: string;
-    aiCheckPrompt?: string;
-    aiAnalyseSchema?: string;
-    aiCheckSchema?: string;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -450,42 +450,46 @@ async function processMessageElements(sourceElements, newId, session, creationTi
   return { finalElementsForDb, mediaToSave };
 }
 __name(processMessageElements, "processMessageElements");
-async function performSimilarityChecks(ctx, config, hashManager, finalElementsForDb, downloadedMedia) {
-  const textHashesToStore = [];
-  const imageHashesToStore = [];
-  const combinedText = finalElementsForDb.filter((el) => el.type === "text" && typeof el.content === "string").map((el) => el.content).join(" ");
-  if (combinedText) {
-    const newSimhash = hashManager.generateTextSimhash(combinedText);
-    if (newSimhash) {
-      const existingTextHashes = await ctx.database.get("cave_hash", { type: "text" });
-      for (const existing of existingTextHashes) {
-        const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
-        if (similarity >= config.textThreshold) return { duplicate: true, message: `文本与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+async function performSimilarityChecks(ctx, config, hashManager, logger2, finalElementsForDb, downloadedMedia) {
+  try {
+    const textHashesToStore = [];
+    const imageHashesToStore = [];
+    const combinedText = finalElementsForDb.filter((el) => el.type === "text" && typeof el.content === "string").map((el) => el.content).join(" ");
+    if (combinedText) {
+      const newSimhash = hashManager.generateTextSimhash(combinedText);
+      if (newSimhash) {
+        const existingTextHashes = await ctx.database.get("cave_hash", { type: "text" });
+        for (const existing of existingTextHashes) {
+          const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
+          if (similarity >= config.textThreshold) return { duplicate: true, message: `文本与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+        }
+        textHashesToStore.push({ hash: newSimhash, type: "text" });
       }
-      textHashesToStore.push({ hash: newSimhash, type: "text" });
     }
-  }
-  if (downloadedMedia.length > 0) {
-    const allExistingImageHashes = await ctx.database.get("cave_hash", { type: "image" });
-    for (const media of downloadedMedia) {
-      if ([".png", ".jpg", ".jpeg", ".webp"].includes(path2.extname(media.fileName).toLowerCase())) {
-        const imageHash = await hashManager.generatePHash(media.buffer);
-        for (const existing of allExistingImageHashes) {
-          const similarity = hashManager.calculateSimilarity(imageHash, existing.hash);
-          if (similarity >= config.imageThreshold) return { duplicate: true, message: `图片与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+    if (downloadedMedia.length > 0) {
+      const allExistingImageHashes = await ctx.database.get("cave_hash", { type: "image" });
+      for (const media of downloadedMedia) {
+        if ([".png", ".jpg", ".jpeg", ".webp"].includes(path2.extname(media.fileName).toLowerCase())) {
+          const imageHash = await hashManager.generatePHash(media.buffer);
+          for (const existing of allExistingImageHashes) {
+            const similarity = hashManager.calculateSimilarity(imageHash, existing.hash);
+            if (similarity >= config.imageThreshold) return { duplicate: true, message: `图片与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+          }
+          imageHashesToStore.push({ hash: imageHash, type: "image" });
+          allExistingImageHashes.push({ cave: 0, hash: imageHash, type: "image" });
         }
-        imageHashesToStore.push({ hash: imageHash, type: "image" });
-        allExistingImageHashes.push({ cave: 0, hash: imageHash, type: "image" });
       }
     }
+    return { duplicate: false, textHashesToStore, imageHashesToStore };
+  } catch (error) {
+    logger2.warn("相似度比较失败:", error);
+    return { duplicate: false, textHashesToStore: [], imageHashesToStore: [] };
   }
-  return { duplicate: false, textHashesToStore, imageHashesToStore };
 }
 __name(performSimilarityChecks, "performSimilarityChecks");
-async function handleFileUploads(ctx, config, fileManager, logger2, cave, downloadedMedia, reusableIds, session) {
+async function handleFileUploads(ctx, config, fileManager, logger2, cave, downloadedMedia, reusableIds, needsReview) {
   try {
     await Promise.all(downloadedMedia.map((item) => fileManager.saveFile(item.fileName, item.buffer)));
-    const needsReview = config.enablePend && session.channelId !== config.adminChannel?.split(":")[1];
     const finalStatus = needsReview ? "pending" : "active";
     await ctx.database.upsert("cave", [{ id: cave.id, status: finalStatus }]);
     return finalStatus;
@@ -845,37 +849,12 @@ var HashManager = class {
         if (!cavesToProcess.length) return "无可修复的回声洞";
         let fixedFiles = 0;
         let errorCount = 0;
-        const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-        const JPEG_SIGNATURE = Buffer.from([255, 216]);
-        const GIF_SIGNATURE = Buffer.from("GIF");
         for (const cave2 of cavesToProcess) {
           const imageElements = cave2.elements.filter((el) => el.type === "image" && el.file);
           for (const element of imageElements) {
             try {
               const originalBuffer = await this.fileManager.readFile(element.file);
-              let sanitizedBuffer = originalBuffer;
-              if (originalBuffer.slice(0, 8).equals(PNG_SIGNATURE)) {
-                const IEND_CHUNK = Buffer.from("IEND");
-                const iendIndex = originalBuffer.lastIndexOf(IEND_CHUNK);
-                if (iendIndex !== -1) {
-                  const endOfPngData = iendIndex + 8;
-                  if (originalBuffer.length > endOfPngData) sanitizedBuffer = originalBuffer.slice(0, endOfPngData);
-                }
-              } else if (originalBuffer.slice(0, 2).equals(JPEG_SIGNATURE)) {
-                const EOI_MARKER = Buffer.from([255, 217]);
-                const eoiIndex = originalBuffer.lastIndexOf(EOI_MARKER);
-                if (eoiIndex !== -1) {
-                  const endOfJpegData = eoiIndex + 2;
-                  if (originalBuffer.length > endOfJpegData) sanitizedBuffer = originalBuffer.slice(0, endOfJpegData);
-                }
-              } else if (originalBuffer.slice(0, 3).equals(GIF_SIGNATURE)) {
-                const GIF_TERMINATOR = Buffer.from([59]);
-                const terminatorIndex = originalBuffer.lastIndexOf(GIF_TERMINATOR);
-                if (terminatorIndex !== -1) {
-                  const endOfGifData = terminatorIndex + 1;
-                  if (originalBuffer.length > endOfGifData) sanitizedBuffer = originalBuffer.slice(0, endOfGifData);
-                }
-              }
+              const sanitizedBuffer = this.sanitizeImageBuffer(originalBuffer);
               if (!originalBuffer.equals(sanitizedBuffer)) {
                 await this.fileManager.saveFile(element.file, sanitizedBuffer);
                 fixedFiles++;
@@ -895,6 +874,40 @@ var HashManager = class {
       }
     });
   }
+  /**
+   * @description 扫描并修复单个图片 Buffer，移除文件结束符之后的多余数据。
+   * @param imageBuffer - 原始的图片 Buffer。
+   * @returns 修复后的图片 Buffer。如果无需修复，则返回原始 Buffer。
+   */
+  sanitizeImageBuffer(imageBuffer) {
+    const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    const JPEG_SIGNATURE = Buffer.from([255, 216]);
+    const GIF_SIGNATURE = Buffer.from("GIF");
+    let sanitizedBuffer = imageBuffer;
+    if (imageBuffer.slice(0, 8).equals(PNG_SIGNATURE)) {
+      const IEND_CHUNK = Buffer.from("IEND");
+      const iendIndex = imageBuffer.lastIndexOf(IEND_CHUNK);
+      if (iendIndex !== -1) {
+        const endOfPngData = iendIndex + 8;
+        if (imageBuffer.length > endOfPngData) sanitizedBuffer = imageBuffer.slice(0, endOfPngData);
+      }
+    } else if (imageBuffer.slice(0, 2).equals(JPEG_SIGNATURE)) {
+      const EOI_MARKER = Buffer.from([255, 217]);
+      const eoiIndex = imageBuffer.lastIndexOf(EOI_MARKER);
+      if (eoiIndex !== -1) {
+        const endOfJpegData = eoiIndex + 2;
+        if (imageBuffer.length > endOfJpegData) sanitizedBuffer = imageBuffer.slice(0, endOfJpegData);
+      }
+    } else if (imageBuffer.slice(0, 3).equals(GIF_SIGNATURE)) {
+      const GIF_TERMINATOR = Buffer.from([59]);
+      const terminatorIndex = imageBuffer.lastIndexOf(GIF_TERMINATOR);
+      if (terminatorIndex !== -1) {
+        const endOfGifData = terminatorIndex + 1;
+        if (imageBuffer.length > endOfGifData) sanitizedBuffer = imageBuffer.slice(0, endOfGifData);
+      }
+    }
+    return sanitizedBuffer;
+  }
   /**
    * @description 执行一维离散余弦变换 (DCT-II) 的方法。
    * @param input - 输入的数字数组。
@@ -1045,7 +1058,7 @@ var AIManager = class {
         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 successCountInBatch = await this.analyzeAndStoreBatch(batch);
+          const successCountInBatch = await this.analyzeAndStore(batch);
           totalSuccessCount += successCountInBatch;
         }
         return `已分析 ${totalSuccessCount} 个回声洞`;
@@ -1054,98 +1067,130 @@ var AIManager = class {
         return `操作失败: ${error.message}`;
       }
     });
+    cave.subcommand(".compare", "比较重复性", { hidden: true }).usage("检查回声洞，找出可能重复的内容。").action(async ({ session }) => {
+      if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
+      await session.send("正在检查，请稍候...");
+      try {
+        const allMeta = await this.ctx.database.get("cave_meta", {});
+        if (allMeta.length < 2) return "无可比较数据";
+        const allCaves = new Map((await this.ctx.database.get("cave", { status: "active" })).map((c) => [c.id, c]));
+        const foundPairs = /* @__PURE__ */ new Set();
+        const checkedPairs = /* @__PURE__ */ new Set();
+        for (let i = 0; i < allMeta.length; i++) {
+          for (let j = i + 1; j < allMeta.length; j++) {
+            const meta1 = allMeta[i];
+            const meta2 = allMeta[j];
+            const pairKey = [meta1.cave, meta2.cave].sort((a, b) => a - b).join("-");
+            if (checkedPairs.has(pairKey)) continue;
+            const keywords1 = new Set(meta1.keywords);
+            const keywords2 = new Set(meta2.keywords);
+            const intersection = new Set([...keywords1].filter((x) => keywords2.has(x)));
+            const union = /* @__PURE__ */ new Set([...keywords1, ...keywords2]);
+            const similarity = union.size > 0 ? intersection.size / union.size : 0;
+            if (similarity * 100 >= 80) {
+              const cave1 = allCaves.get(meta1.cave);
+              const cave2 = allCaves.get(meta2.cave);
+              if (cave1 && cave2 && await this.isContentDuplicateAI(cave1, cave2)) foundPairs.add(`${cave1.id} & ${cave2.id}`);
+              checkedPairs.add(pairKey);
+            }
+          }
+        }
+        if (foundPairs.size === 0) return "未发现高重复性的内容";
+        let report = `已发现 ${foundPairs.size} 组高重复性的内容:
+`;
+        report += [...foundPairs].join("\n");
+        return report.trim();
+      } catch (error) {
+        this.logger.error("检查重复性失败:", error);
+        return `检查失败: ${error.message}`;
+      }
+    });
   }
   /**
    * @description 对新提交的内容执行 AI 驱动的查重检查。
    * @param {StoredElement[]} newElements - 新提交的内容元素数组。
    * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组。
-   * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID（如果存在）。
+   * @returns {Promise<{ duplicate: boolean; ids?: number[] }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID 数组（如果存在）。
    */
   async checkForDuplicates(newElements, mediaBuffers) {
     try {
       const dummyCave = { id: 0, elements: newElements, channelId: "", userId: "", userName: "", status: "preload", time: /* @__PURE__ */ new Date() };
-      const mediaMap = mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0;
-      const [newAnalysis] = await this.getAnalyses([dummyCave], mediaMap);
-      if (!newAnalysis?.keywords?.length) return { duplicate: false };
-      const potentialDuplicates = await this.findPotentialDuplicates(newAnalysis.keywords);
-      if (potentialDuplicates.length === 0) return { duplicate: false };
-      const formatContent = /* @__PURE__ */ __name((elements) => elements.filter((el) => el.type === "text").map((el) => el.content).join(" "), "formatContent");
-      const userMessage = {
-        role: "user",
-        content: JSON.stringify({
-          new_content: { text: formatContent(newElements) },
-          existing_contents: potentialDuplicates.map((cave) => ({ id: cave.id, text: formatContent(cave.elements) }))
-        })
-      };
-      const response = await this.requestAI([userMessage], this.config.aiCheckPrompt, this.config.aiCheckSchema);
-      return {
-        duplicate: response.duplicate || false,
-        id: response.id ? Number(response.id) : void 0
-      };
+      const [newAnalysis] = await this.getAnalyses([dummyCave], mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0);
+      if (!newAnalysis?.keywords?.length) return { duplicate: false, ids: [] };
+      const allMeta = await this.ctx.database.get("cave_meta", {}, { fields: ["cave", "keywords"] });
+      const newKeywordsSet = new Set(newAnalysis.keywords);
+      const similarCaveIds = allMeta.filter((meta) => {
+        if (!meta.keywords?.length) return false;
+        const existingKeywordsSet = new Set(meta.keywords);
+        const intersection = new Set([...newKeywordsSet].filter((x) => existingKeywordsSet.has(x)));
+        const union = /* @__PURE__ */ new Set([...newKeywordsSet, ...existingKeywordsSet]);
+        const similarity = union.size > 0 ? intersection.size / union.size : 0;
+        return similarity * 100 >= 80;
+      }).map((meta) => meta.cave);
+      if (similarCaveIds.length === 0) return { duplicate: false, ids: [] };
+      const potentialDuplicates = await this.ctx.database.get("cave", { id: { $in: similarCaveIds } });
+      const duplicateIds = [];
+      for (const existingCave of potentialDuplicates) if (await this.isContentDuplicateAI(dummyCave, existingCave)) duplicateIds.push(existingCave.id);
+      return { duplicate: duplicateIds.length > 0, ids: duplicateIds };
     } catch (error) {
       this.logger.error("查重回声洞出错:", error);
-      return { duplicate: false };
+      return { duplicate: false, ids: [] };
     }
   }
   /**
-   * @description 对单个回声洞对象执行完整的分析和存储流程。
-   * @param {CaveObject} cave - 要分析的回声洞对象。
-   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，用于新提交内容的分析。
-   * @returns {Promise<void>} 分析和存储操作完成后解析的 Promise。
-   */
-  async analyzeAndStore(cave, mediaBuffers) {
-    const mediaMap = mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0;
-    const [result] = await this.getAnalyses([cave], mediaMap);
-    if (result) {
-      await this.ctx.database.upsert("cave_meta", [{
-        cave: cave.id,
-        keywords: result.keywords || [],
-        description: result.description || "",
-        rating: Math.max(0, Math.min(100, result.rating || 0))
-      }]);
-    }
-  }
-  /**
-   * @description 对一批回声洞执行分析并存储结果。
+   * @description 对单个或批量回声洞执行完整的分析和存储流程。
    * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，仅在分析新内容时使用。
    * @returns {Promise<number>} 一个 Promise，解析为成功分析和存储的条目数。
    */
-  async analyzeAndStoreBatch(caves) {
-    const results = await this.getAnalyses(caves);
-    if (!results?.length) return 0;
-    const caveMetaObjects = results.map((res) => ({
-      cave: res.id,
-      keywords: res.keywords || [],
-      description: res.description || "",
-      rating: Math.max(0, Math.min(100, res.rating || 0))
-    }));
-    await this.ctx.database.upsert("cave_meta", caveMetaObjects);
-    return caveMetaObjects.length;
+  async analyzeAndStore(caves, mediaBuffers) {
+    try {
+      const mediaMap = mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0;
+      const results = await this.getAnalyses(caves, mediaMap);
+      if (!results?.length) return 0;
+      const caveMetaObjects = results.map((res) => ({
+        cave: res.id,
+        keywords: res.keywords || [],
+        description: res.description || "",
+        rating: Math.max(0, Math.min(100, res.rating || 0))
+      }));
+      await this.ctx.database.upsert("cave_meta", caveMetaObjects);
+      return caveMetaObjects.length;
+    } catch (error) {
+      const caveIds = caves.map((c) => c.id).join(", ");
+      this.logger.error(`分析回声洞 (${caveIds}) 出错:`, error);
+      return 0;
+    }
   }
   /**
-   * @description 根据新内容的关键词，查找并返回可能重复的回声洞。
-   * @param {string[]} newKeywords - 新内容的关键词数组。
-   * @returns {Promise<CaveObject[]>} 一个 Promise，解析为可能重复的回声洞对象数组。
+   * @description 调用 AI 判断两个回声洞内容是否重复或高度相似。
+   * @param {CaveObject} caveA - 第一个回声洞对象。
+   * @param {CaveObject} caveB - 第二个回声洞对象。
+   * @returns {Promise<boolean>} 如果内容相似则返回 true，否则返回 false。
    */
-  async findPotentialDuplicates(newKeywords) {
-    const allMeta = await this.ctx.database.get("cave_meta", {}, { fields: ["cave", "keywords"] });
-    const newKeywordsSet = new Set(newKeywords);
-    const similarCaveIds = allMeta.filter((meta) => {
-      if (!meta.keywords?.length) return false;
-      const existingKeywordsSet = new Set(meta.keywords);
-      const intersection = new Set([...newKeywordsSet].filter((x) => existingKeywordsSet.has(x)));
-      const union = /* @__PURE__ */ new Set([...newKeywordsSet, ...existingKeywordsSet]);
-      const similarity = union.size > 0 ? intersection.size / union.size : 0;
-      return similarity * 100 >= 80;
-    }).map((meta) => meta.cave);
-    if (similarCaveIds.length === 0) return [];
-    return this.ctx.database.get("cave", { id: { $in: similarCaveIds } });
+  async isContentDuplicateAI(caveA, caveB) {
+    try {
+      const formatContent = /* @__PURE__ */ __name((elements) => elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" "), "formatContent");
+      const userMessage = {
+        role: "user",
+        content: JSON.stringify({
+          content_a: { id: caveA.id, text: formatContent(caveA.elements) },
+          content_b: { id: caveB.id, text: formatContent(caveB.elements) }
+        })
+      };
+      const prompt = `你是一位内容查重专家。请判断 content_a 和 content_b 是否重复或高度相似。你的回复必须且只能是一个包裹在 \`\`\`json ... \`\`\` 代码块中的 JSON 对象，该对象仅包含一个键 "duplicate" (布尔值)。`;
+      const response = await this.requestAI([userMessage], prompt);
+      return response.duplicate || false;
+    } catch (error) {
+      this.logger.error(`比较回声洞（${caveA.id}）与（${caveB.id}）失败:`, error);
+      return false;
+    }
   }
   /**
    * @description 为一批回声洞准备内容，并向 AI 发送单个请求以获取所有分析结果。
    * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
    * @param {Map<string, Buffer>} [mediaBufferMap] - 可选的媒体文件名到其缓冲区的映射。
-   * @returns {Promise<any[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
+   * @returns {Promise<AnalysisResult[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
    */
   async getAnalyses(caves, mediaBufferMap) {
     const batchPayload = await Promise.all(caves.map(async (cave) => {
@@ -1167,14 +1212,18 @@ var AIManager = class {
     const nonEmptyPayload = batchPayload.filter((p) => p.text.trim() || p.images.length > 0);
     if (nonEmptyPayload.length === 0) return [];
     const userMessage = { role: "user", content: JSON.stringify(nonEmptyPayload) };
-    const response = await this.requestAI([userMessage], this.config.AnalysePrompt, this.config.aiAnalyseSchema);
+    const analysePrompt = `你是一位内容分析专家。请使用中文，分析我以JSON格式提供的一组内容，为每一项内容总结关键词、概括内容并评分。你的回复必须且只能是一个包裹在 \`\`\`json ... \`\`\` 代码块中的有效 JSON 对象。该JSON对象应有一个 "analyses" 键，其值为一个数组。数组中的每个对象都必须包含 "id" (整数), "keywords" (字符串数组), "description" (字符串), 和 "rating" (0-100的整数)。`;
+    const response = await this.requestAI([userMessage], analysePrompt);
     return response.analyses || [];
   }
   /**
-   * @description 确保请求不会超过设定的速率限制（RPM）。如果需要，会延迟执行。
-   * @returns {Promise<void>} 当可以继续发送请求时解析的 Promise。
+   * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑，并稳健地解析 JSON 响应。
+   * @param {any[]} messages - 发送给 AI 的消息数组，遵循 OpenAI 格式。
+   * @param {string} systemPrompt - 系统提示词，用于指导 AI 的行为。
+   * @returns {Promise<T>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
+   * @throws {Error} 当 AI 返回空或无效内容时抛出错误。
    */
-  async ensureRateLimit() {
+  async requestAI(messages, systemPrompt) {
     const now = Date.now();
     if (now > this.rateLimitResetTime) {
       this.rateLimitResetTime = now + 6e4;
@@ -1186,28 +1235,9 @@ var AIManager = class {
       this.rateLimitResetTime = Date.now() + 6e4;
       this.requestCount = 0;
     }
-  }
-  /**
-   * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑。
-   * @param {any[]} messages - 发送给 AI 的消息数组，遵循 OpenAI 格式。
-   * @param {string} systemPrompt - 系统提示词，用于指导 AI 的行为。
-   * @param {string} schemaString - 定义期望响应格式的 JSON Schema 字符串。
-   * @returns {Promise<any>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
-   * @throws {Error} 当 AI 返回空或无效内容时抛出错误。
-   */
-  async requestAI(messages, systemPrompt, schemaString) {
-    await this.ensureRateLimit();
     const payload = {
       model: this.config.aiModel,
-      messages: [{ role: "system", content: systemPrompt }, ...messages],
-      response_format: {
-        type: "json_schema",
-        json_schema: {
-          name: "extract_data",
-          description: "根据提供的内容提取或分析信息。",
-          schema: JSON.parse(schemaString)
-        }
-      }
+      messages: [{ role: "system", content: systemPrompt }, ...messages]
     };
     const fullUrl = `${this.config.aiEndpoint.replace(/\/$/, "")}/chat/completions`;
     const headers = {
@@ -1217,8 +1247,22 @@ var AIManager = class {
     this.requestCount++;
     const response = await this.http.post(fullUrl, payload, { headers, timeout: 9e4 });
     const content = response.choices?.[0]?.message?.content;
-    if (typeof content === "string" && content.trim()) return JSON.parse(content);
-    throw new Error("响应无效");
+    if (typeof content !== "string" || !content.trim()) throw new Error("响应无效");
+    try {
+      const jsonRegex = /```json\s*([\s\S]*?)\s*```/;
+      const match = content.match(jsonRegex);
+      let jsonString = "";
+      if (match && match[1]) {
+        jsonString = match[1];
+      } else {
+        jsonString = content;
+      }
+      return JSON.parse(jsonString);
+    } catch (error) {
+      this.logger.error("解析 JSON 失败:", error);
+      this.logger.error("原始响应:", content);
+      throw new Error("解析失败");
+    }
   }
 };
 
@@ -1257,62 +1301,7 @@ var Config = import_koishi3.Schema.intersect([
     aiEndpoint: import_koishi3.Schema.string().description("端点 (Endpoint)").role("link").default("https://generativelanguage.googleapis.com/v1beta/openai"),
     aiApiKey: import_koishi3.Schema.string().description("密钥 (Key)").role("secret"),
     aiModel: import_koishi3.Schema.string().description("模型 (Model)").default("gemini-2.5-flash"),
-    aiRPM: import_koishi3.Schema.number().description("每分钟请求数 (RPM)").default(60),
-    AnalysePrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我以JSON格式提供的一组内容（每项包含ID、文本和图片），为每一项内容总结关键词、概括内容并评分。你需要返回一个包含所有分析结果的JSON对象。`).description("分析 Prompt"),
-    aiAnalyseSchema: import_koishi3.Schema.string().role("textarea").default(
-      `{
-        "type": "object",
-        "properties": {
-          "analyses": {
-            "type": "array",
-            "description": "分析结果的数组",
-            "items": {
-              "type": "object",
-              "properties": {
-                "id": {
-                  "type": "integer",
-                  "description": "内容的唯一ID"
-                },
-                "keywords": {
-                  "type": "array",
-                  "items": { "type": "string" },
-                  "description": "使用尽可能多的关键词准确形容内容"
-                },
-                "description": {
-                  "type": "string",
-                  "description": "概括或描述这部分内容"
-                },
-                "rating": {
-                  "type": "integer",
-                  "description": "对内容的综合质量进行评分",
-                  "minimum": 0,
-                  "maximum": 100
-                }
-              },
-              "required": ["id", "keywords", "description", "rating"]
-            }
-          }
-        },
-        "required": ["analyses"]
-      }`
-    ).description("分析 JSON Schema"),
-    aiCheckPrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容查重专家。请判断我提供的"新内容"是否与"已有内容"重复或高度相似。`).description("查重 Prompt"),
-    aiCheckSchema: import_koishi3.Schema.string().role("textarea").default(
-      `{
-        "type": "object",
-        "properties": {
-          "duplicate": {
-            "type": "boolean",
-            "description": "新内容是否与已有内容重复"
-          },
-          "id": {
-            "type": "integer",
-            "description": "如果重复，此为第一个重复的已有内容的ID"
-          }
-        },
-        "required": ["duplicate"]
-      }`
-    ).description("查重 JSON Schema")
+    aiRPM: import_koishi3.Schema.number().description("每分钟请求数 (RPM)").default(60)
   }).description("模型配置"),
   import_koishi3.Schema.object({
     localPath: import_koishi3.Schema.string().description("文件映射路径"),
@@ -1403,17 +1392,18 @@ function apply(ctx, config) {
       let textHashesToStore = [];
       let imageHashesToStore = [];
       if (hashManager) {
-        const checkResult = await performSimilarityChecks(ctx, config, hashManager, finalElementsForDb, downloadedMedia);
+        for (const media of downloadedMedia) media.buffer = hashManager.sanitizeImageBuffer(media.buffer);
+        const checkResult = await performSimilarityChecks(ctx, config, hashManager, logger, finalElementsForDb, downloadedMedia);
         if (checkResult.duplicate) return checkResult.message;
         textHashesToStore = checkResult.textHashesToStore;
         imageHashesToStore = checkResult.imageHashesToStore;
       }
       if (aiManager) {
         const duplicateResult = await aiManager.checkForDuplicates(finalElementsForDb, downloadedMedia);
-        if (duplicateResult && duplicateResult.duplicate) return `内容与回声洞（${duplicateResult.id}）重复`;
+        if (duplicateResult?.duplicate && duplicateResult.ids?.length > 0) return `内容与回声洞（${duplicateResult.ids.join("|")}）重复`;
       }
       const userName = (config.enableName ? await profileManager.getNickname(session.userId) : null) || session.username;
-      const needsReview = config.enablePend && session.channelId !== config.adminChannel?.split(":")[1];
+      const needsReview = config.enablePend && session.cid !== config.adminChannel;
       let finalStatus = hasMedia ? "preload" : needsReview ? "pending" : "active";
       const newCave = await ctx.database.create("cave", {
         id: newId,
@@ -1424,10 +1414,10 @@ function apply(ctx, config) {
         status: finalStatus,
         time: creationTime
       });
-      if (hasMedia) finalStatus = await handleFileUploads(ctx, config, fileManager, logger, newCave, downloadedMedia, reusableIds, session);
+      if (hasMedia) finalStatus = await handleFileUploads(ctx, config, fileManager, logger, newCave, downloadedMedia, reusableIds, needsReview);
       if (finalStatus !== "preload") {
         newCave.status = finalStatus;
-        if (aiManager) await aiManager.analyzeAndStore(newCave, downloadedMedia);
+        if (aiManager) await aiManager.analyzeAndStore([newCave], downloadedMedia);
         if (hashManager) {
           const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h4) => ({ ...h4, cave: newCave.id }));
           if (allHashesToInsert.length > 0) await ctx.database.upsert("cave_hash", allHashesToInsert);
@@ -1458,7 +1448,7 @@ function apply(ctx, config) {
       const [targetCave] = await ctx.database.get("cave", { id, status: "active" });
       if (!targetCave) return `回声洞（${id}）不存在`;
       const isAuthor = targetCave.userId === session.userId;
-      const isAdmin = session.channelId === config.adminChannel?.split(":")[1];
+      const isAdmin = session.cid === config.adminChannel;
       if (!isAuthor && !isAdmin) return "你没有权限删除这条回声洞";
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessages = await buildCaveMessage(targetCave, config, fileManager, logger, session.platform, "已删除");
@@ -1471,8 +1461,8 @@ function apply(ctx, config) {
   });
   cave.subcommand(".list", "查询投稿统计").option("user", "-u <user:user> 指定用户").option("all", "-a 查看排行").action(async ({ session, options }) => {
     if (options.all) {
-      const adminChannelId = config.adminChannel?.split(":")[1];
-      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
+      const adminError = requireAdmin(session, config);
+      if (adminError) return adminError;
       try {
         const aggregatedStats = await ctx.database.select("cave", { status: "active" }).groupBy(["userId", "userName"], { count: /* @__PURE__ */ __name((row) => import_koishi3.$.count(row.id), "count") }).execute();
         if (!aggregatedStats.length) return "目前没有回声洞投稿";

package/package.json

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