koishi-plugin-best-cave 1.5.4 → 1.5.6

package/lib/index.d.ts

@@ -1,6 +1,30 @@
 import { Context, Schema } from 'koishi';
 export declare const name = "best-cave";
 export declare const inject: string[];
+export interface BaseElement {
+    type: 'text' | 'img' | 'video';
+    index: number;
+}
+export interface TextElement extends BaseElement {
+    type: 'text';
+    content: string;
+}
+export interface MediaElement extends BaseElement {
+    type: 'img' | 'video';
+    file?: string;
+    fileName?: string;
+    fileSize?: string;
+    filePath?: string;
+}
+export type Element = TextElement | MediaElement;
+export interface CaveObject {
+    cave_id: number;
+    elements: Element[];
+    contributor_number: string;
+    contributor_name: string;
+}
+export interface PendingCave extends CaveObject {
+}
 /**
  * 插件配置项
  * @type {Schema}

package/lib/index.js

@@ -54,10 +54,10 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_koishi6 = require("koishi");
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 
-// src/utils/FileHandle.ts
+// src/utils/FileHandler.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var import_koishi = require("koishi");
@@ -216,7 +216,7 @@ var FileHandler = class {
   }
 };
 
-// src/utils/IdManage.ts
+// src/utils/IdManager.ts
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 var import_koishi2 = require("koishi");
@@ -440,12 +440,12 @@ var IdManager = class {
   }
 };
 
-// src/utils/HashManage.ts
+// src/utils/HashManager.ts
 var import_koishi3 = require("koishi");
 var fs3 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 
-// src/utils/ContentHash.ts
+// src/utils/ContentHasher.ts
 var import_sharp = __toESM(require("sharp"));
 var ContentHasher = class {
   static {
@@ -605,22 +605,13 @@ var ContentHasher = class {
     }
     return hash.toString(36);
   }
-  /**
-   * 批量比较一个新哈希值与多个已存在哈希值的相似度
-   * @param newHash - 新的哈希值
-   * @param existingHashes - 已存在的哈希值数组
-   * @returns 相似度数组，每个元素对应一个已存在哈希值的相似度
-   */
-  static batchCompareSimilarity(newHash, existingHashes) {
-    return existingHashes.map((hash) => this.calculateSimilarity(newHash, hash));
-  }
 };
 
-// src/utils/HashManage.ts
+// src/utils/HashManager.ts
 var import_util = require("util");
 var logger3 = new import_koishi3.Logger("HashManager");
 var readFileAsync = (0, import_util.promisify)(fs3.readFile);
-var ContentHashManager = class _ContentHashManager {
+var HashManager = class _HashManager {
   /**
    * 初始化HashManager实例
    * @param caveDir 回声洞数据目录路径
@@ -629,7 +620,7 @@ var ContentHashManager = class _ContentHashManager {
     this.caveDir = caveDir;
   }
   static {
-    __name(this, "ContentHashManager");
+    __name(this, "HashManager");
   }
   // 哈希数据文件名
   static HASH_FILE = "hash.json";
@@ -643,13 +634,13 @@ var ContentHashManager = class _ContentHashManager {
   // 初始化状态标志
   initialized = false;
   get filePath() {
-    return path3.join(this.caveDir, _ContentHashManager.HASH_FILE);
+    return path3.join(this.caveDir, _HashManager.HASH_FILE);
   }
   get resourceDir() {
     return path3.join(this.caveDir, "resources");
   }
   get caveFilePath() {
-    return path3.join(this.caveDir, _ContentHashManager.CAVE_FILE);
+    return path3.join(this.caveDir, _HashManager.CAVE_FILE);
   }
   /**
    * 初始化哈希存储
@@ -973,7 +964,7 @@ var ContentHashManager = class _ContentHashManager {
    * @param batchSize 批处理大小
    * @private
    */
-  async processBatch(items, processor, batchSize = _ContentHashManager.BATCH_SIZE) {
+  async processBatch(items, processor, batchSize = _HashManager.BATCH_SIZE) {
     for (let i = 0; i < items.length; i += batchSize) {
       const batch = items.slice(i, i + batchSize);
       await Promise.all(
@@ -989,15 +980,14 @@ var ContentHashManager = class _ContentHashManager {
   }
 };
 
-// src/utils/AuditManage.ts
+// src/utils/AuditHandler.ts
 var import_koishi4 = require("koishi");
 var fs4 = __toESM(require("fs"));
 var path4 = __toESM(require("path"));
 var AuditManager = class {
-  constructor(ctx, config, caveDir, idManager) {
+  constructor(ctx, config, idManager) {
     this.ctx = ctx;
     this.config = config;
-    this.caveDir = caveDir;
     this.idManager = idManager;
   }
   static {
@@ -1188,11 +1178,70 @@ ${session.text("commands.cave.audit.from")}${cave.contributor_number}`;
   }
 };
 
-// src/utils/MediaHandle.ts
+// src/utils/MediaHandler.ts
 var import_koishi5 = require("koishi");
 var fs5 = __toESM(require("fs"));
 var path5 = __toESM(require("path"));
 var logger4 = new import_koishi5.Logger("MediaHandle");
+async function buildMessage(cave, resourceDir, session) {
+  if (!cave?.elements?.length) {
+    return session.text("commands.cave.error.noContent");
+  }
+  const videoElement = cave.elements.find((el) => el.type === "video");
+  const nonVideoElements = cave.elements.filter((el) => el.type !== "video").sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+  if (videoElement?.file) {
+    const basicInfo = [
+      session.text("commands.cave.message.caveTitle", [cave.cave_id]),
+      session.text("commands.cave.message.contributorSuffix", [cave.contributor_name])
+    ].join("\n");
+    await session?.send(basicInfo);
+    const filePath = path5.join(resourceDir, videoElement.file);
+    const base64Data = await processMediaFile(filePath, "video");
+    if (base64Data && session) {
+      await session.send((0, import_koishi5.h)("video", { src: base64Data }));
+    }
+    return "";
+  }
+  const lines = [session.text("commands.cave.message.caveTitle", [cave.cave_id])];
+  for (const element of nonVideoElements) {
+    if (element.type === "text") {
+      lines.push(element.content);
+    } else if (element.type === "img" && element.file) {
+      const filePath = path5.join(resourceDir, element.file);
+      const base64Data = await processMediaFile(filePath, "image");
+      if (base64Data) {
+        lines.push((0, import_koishi5.h)("image", { src: base64Data }));
+      }
+    }
+  }
+  lines.push(session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]));
+  return lines.join("\n");
+}
+__name(buildMessage, "buildMessage");
+async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
+  try {
+    const msg = await session.send(session.text(key, params));
+    if (isTemp && msg) {
+      setTimeout(async () => {
+        try {
+          await session.bot.deleteMessage(session.channelId, msg);
+        } catch (error) {
+          logger4.debug(`Failed to delete temporary message: ${error.message}`);
+        }
+      }, timeout);
+    }
+  } catch (error) {
+    logger4.error(`Failed to send message: ${error.message}`);
+  }
+  return "";
+}
+__name(sendMessage, "sendMessage");
+async function processMediaFile(filePath, type) {
+  const data = await fs5.promises.readFile(filePath).catch(() => null);
+  if (!data) return null;
+  return `data:${type}/${type === "image" ? "png" : "mp4"};base64,${data.toString("base64")}`;
+}
+__name(processMediaFile, "processMediaFile");
 async function extractMediaContent(originalContent, config, session) {
   const textParts = originalContent.split(/<(img|video)[^>]+>/).map((text, idx) => text.trim() && {
     type: "text",
@@ -1236,7 +1285,7 @@ async function extractMediaContent(originalContent, config, session) {
 __name(extractMediaContent, "extractMediaContent");
 async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config, ctx, session, buffers) {
   const accept = mediaType === "img" ? "image/*" : "video/*";
-  const hashStorage = new ContentHashManager(path5.join(ctx.baseDir, "data", "cave"));
+  const hashStorage = new HashManager(path5.join(ctx.baseDir, "data", "cave"));
   await hashStorage.initialize();
   const downloadTasks = urls.map(async (url, i) => {
     const fileName = fileNames[i];
@@ -1317,20 +1366,99 @@ async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config
   return Promise.all(downloadTasks);
 }
 __name(saveMedia, "saveMedia");
-async function buildMessage(cave, resourceDir, session) {
-  if (!cave?.elements?.length) {
-    return session.text("commands.cave.error.noContent");
+
+// src/utils/ProcessHandle.ts
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+async function processList(session, config, idManager, userId, pageNum = 1) {
+  const stats = idManager.getStats();
+  if (userId && userId in stats) {
+    const ids = stats[userId];
+    return session.text("commands.cave.list.totalItems", [userId, ids.length]) + "\n" + session.text("commands.cave.list.idsLine", [ids.join(",")]);
+  }
+  const lines = Object.entries(stats).map(([cid, ids]) => {
+    return session.text("commands.cave.list.totalItems", [cid, ids.length]) + "\n" + session.text("commands.cave.list.idsLine", [ids.join(",")]);
+  });
+  const totalSubmissions = Object.values(stats).reduce((sum, arr) => sum + arr.length, 0);
+  if (config.enablePagination) {
+    const itemsPerPage = config.itemsPerPage;
+    const totalPages = Math.max(1, Math.ceil(lines.length / itemsPerPage));
+    pageNum = Math.min(Math.max(1, pageNum), totalPages);
+    const start = (pageNum - 1) * itemsPerPage;
+    const paginatedLines = lines.slice(start, start + itemsPerPage);
+    return session.text("commands.cave.list.header", [totalSubmissions]) + "\n" + paginatedLines.join("\n") + "\n" + session.text("commands.cave.list.pageInfo", [pageNum, totalPages]);
+  } else {
+    return session.text("commands.cave.list.header", [totalSubmissions]) + "\n" + lines.join("\n");
   }
-  const lines = [session.text("commands.cave.message.caveTitle", [cave.cave_id])];
-  for (const element of cave.elements) {
-    if (element.type === "text") {
-      lines.push(element.content);
+}
+__name(processList, "processList");
+async function processView(caveFilePath, resourceDir, session, options, content) {
+  const caveId = parseInt(content[0] || (typeof options.g === "string" ? options.g : ""));
+  if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
+  const data = await FileHandler.readJsonData(caveFilePath);
+  const cave = data.find((item) => item.cave_id === caveId);
+  if (!cave) return sendMessage(session, "commands.cave.error.notFound", [], true);
+  return buildMessage(cave, resourceDir, session);
+}
+__name(processView, "processView");
+async function processRandom(caveFilePath, resourceDir, session) {
+  const data = await FileHandler.readJsonData(caveFilePath);
+  if (data.length === 0) {
+    return sendMessage(session, "commands.cave.error.noCave", [], true);
+  }
+  const cave = (() => {
+    const validCaves = data.filter((cave2) => cave2.elements && cave2.elements.length > 0);
+    if (!validCaves.length) return void 0;
+    const randomIndex = Math.floor(Math.random() * validCaves.length);
+    return validCaves[randomIndex];
+  })();
+  return cave ? buildMessage(cave, resourceDir, session) : sendMessage(session, "commands.cave.error.getCave", [], true);
+}
+__name(processRandom, "processRandom");
+async function processDelete(caveFilePath, resourceDir, pendingFilePath, session, config, options, content, idManager, HashManager2) {
+  const caveId = parseInt(content[0] || (typeof options.r === "string" ? options.r : ""));
+  if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
+  const data = await FileHandler.readJsonData(caveFilePath);
+  const pendingData = await FileHandler.readJsonData(pendingFilePath);
+  const targetInData = data.find((item) => item.cave_id === caveId);
+  const targetInPending = pendingData.find((item) => item.cave_id === caveId);
+  if (!targetInData && !targetInPending) {
+    return sendMessage(session, "commands.cave.error.notFound", [], true);
+  }
+  const targetCave = targetInData || targetInPending;
+  const isPending = !targetInData;
+  if (targetCave.contributor_number !== session.userId && !config.manager.includes(session.userId)) {
+    return sendMessage(session, "commands.cave.remove.noPermission", [], true);
+  }
+  const caveContent = await buildMessage(targetCave, resourceDir, session);
+  if (targetCave.elements) {
+    await HashManager2.updateCaveContent(caveId, {
+      images: void 0,
+      texts: void 0
+    });
+    for (const element of targetCave.elements) {
+      if ((element.type === "img" || element.type === "video") && element.file) {
+        const fullPath = path6.join(resourceDir, element.file);
+        if (fs6.existsSync(fullPath)) {
+          await fs6.promises.unlink(fullPath);
+        }
+      }
     }
   }
-  lines.push(session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]));
-  return lines.join("\n");
+  if (isPending) {
+    const newPendingData = pendingData.filter((item) => item.cave_id !== caveId);
+    await FileHandler.writeJsonData(pendingFilePath, newPendingData);
+  } else {
+    const newData = data.filter((item) => item.cave_id !== caveId);
+    await FileHandler.writeJsonData(caveFilePath, newData);
+    await idManager.removeStat(targetCave.contributor_number, caveId);
+  }
+  await idManager.markDeleted(caveId);
+  const deleteStatus = isPending ? session.text("commands.cave.remove.deletePending") : "";
+  const deleteMessage = session.text("commands.cave.remove.deleted");
+  return `${deleteMessage}${deleteStatus}${caveContent}`;
 }
-__name(buildMessage, "buildMessage");
+__name(processDelete, "processDelete");
 
 // src/index.ts
 var name = "best-cave";
@@ -1371,111 +1499,21 @@ var Config = import_koishi6.Schema.object({
 async function apply(ctx, config) {
   ctx.i18n.define("zh-CN", require_zh_CN());
   ctx.i18n.define("en-US", require_en_US());
-  const dataDir = path6.join(ctx.baseDir, "data");
-  const caveDir = path6.join(dataDir, "cave");
-  await FileHandler.ensureDirectory(dataDir);
+  const dataDir = path7.join(ctx.baseDir, "data");
+  const caveDir = path7.join(dataDir, "cave");
   await FileHandler.ensureDirectory(caveDir);
-  await FileHandler.ensureDirectory(path6.join(caveDir, "resources"));
-  await FileHandler.ensureJsonFile(path6.join(caveDir, "cave.json"));
-  await FileHandler.ensureJsonFile(path6.join(caveDir, "pending.json"));
-  await FileHandler.ensureJsonFile(path6.join(caveDir, "hash.json"));
+  await FileHandler.ensureDirectory(path7.join(caveDir, "resources"));
+  await FileHandler.ensureJsonFile(path7.join(caveDir, "cave.json"));
+  await FileHandler.ensureJsonFile(path7.join(caveDir, "pending.json"));
+  await FileHandler.ensureJsonFile(path7.join(caveDir, "hash.json"));
   const idManager = new IdManager(ctx.baseDir);
-  const contentHashManager = new ContentHashManager(caveDir);
-  const auditManager = new AuditManager(ctx, config, caveDir, idManager);
+  const contentHashManager = new HashManager(caveDir);
+  const auditManager = new AuditManager(ctx, config, idManager);
   await Promise.all([
-    idManager.initialize(path6.join(caveDir, "cave.json"), path6.join(caveDir, "pending.json")),
+    idManager.initialize(path7.join(caveDir, "cave.json"), path7.join(caveDir, "pending.json")),
     contentHashManager.initialize()
   ]);
   const lastUsed = /* @__PURE__ */ new Map();
-  async function processList(session, config2, userId, pageNum = 1) {
-    const stats = idManager.getStats();
-    if (userId && userId in stats) {
-      const ids = stats[userId];
-      return session.text("commands.cave.list.totalItems", [userId, ids.length]) + "\n" + session.text("commands.cave.list.idsLine", [ids.join(",")]);
-    }
-    const lines = Object.entries(stats).map(([cid, ids]) => {
-      return session.text("commands.cave.list.totalItems", [cid, ids.length]) + "\n" + session.text("commands.cave.list.idsLine", [ids.join(",")]);
-    });
-    const totalSubmissions = Object.values(stats).reduce((sum, arr) => sum + arr.length, 0);
-    if (config2.enablePagination) {
-      const itemsPerPage = config2.itemsPerPage;
-      const totalPages = Math.max(1, Math.ceil(lines.length / itemsPerPage));
-      pageNum = Math.min(Math.max(1, pageNum), totalPages);
-      const start = (pageNum - 1) * itemsPerPage;
-      const paginatedLines = lines.slice(start, start + itemsPerPage);
-      return session.text("commands.cave.list.header", [totalSubmissions]) + "\n" + paginatedLines.join("\n") + "\n" + session.text("commands.cave.list.pageInfo", [pageNum, totalPages]);
-    } else {
-      return session.text("commands.cave.list.header", [totalSubmissions]) + "\n" + lines.join("\n");
-    }
-  }
-  __name(processList, "processList");
-  async function processView(caveFilePath, resourceDir, session, options, content) {
-    const caveId = parseInt(content[0] || (typeof options.g === "string" ? options.g : ""));
-    if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
-    const data = await FileHandler.readJsonData(caveFilePath);
-    const cave = data.find((item) => item.cave_id === caveId);
-    if (!cave) return sendMessage(session, "commands.cave.error.notFound", [], true);
-    return buildMessage2(cave, resourceDir, session);
-  }
-  __name(processView, "processView");
-  async function processRandom(caveFilePath, resourceDir, session) {
-    const data = await FileHandler.readJsonData(caveFilePath);
-    if (data.length === 0) {
-      return sendMessage(session, "commands.cave.error.noCave", [], true);
-    }
-    const cave = (() => {
-      const validCaves = data.filter((cave2) => cave2.elements && cave2.elements.length > 0);
-      if (!validCaves.length) return void 0;
-      const randomIndex = Math.floor(Math.random() * validCaves.length);
-      return validCaves[randomIndex];
-    })();
-    return cave ? buildMessage2(cave, resourceDir, session) : sendMessage(session, "commands.cave.error.getCave", [], true);
-  }
-  __name(processRandom, "processRandom");
-  async function processDelete(caveFilePath, resourceDir, pendingFilePath, session, config2, options, content) {
-    const caveId = parseInt(content[0] || (typeof options.r === "string" ? options.r : ""));
-    if (isNaN(caveId)) return sendMessage(session, "commands.cave.error.invalidId", [], true);
-    const data = await FileHandler.readJsonData(caveFilePath);
-    const pendingData = await FileHandler.readJsonData(pendingFilePath);
-    const targetInData = data.find((item) => item.cave_id === caveId);
-    const targetInPending = pendingData.find((item) => item.cave_id === caveId);
-    if (!targetInData && !targetInPending) {
-      return sendMessage(session, "commands.cave.error.notFound", [], true);
-    }
-    const targetCave = targetInData || targetInPending;
-    const isPending = !targetInData;
-    if (targetCave.contributor_number !== session.userId && !config2.manager.includes(session.userId)) {
-      return sendMessage(session, "commands.cave.remove.noPermission", [], true);
-    }
-    const caveContent = await buildMessage2(targetCave, resourceDir, session);
-    if (targetCave.elements) {
-      await contentHashManager.updateCaveContent(caveId, {
-        images: void 0,
-        texts: void 0
-      });
-      for (const element of targetCave.elements) {
-        if ((element.type === "img" || element.type === "video") && element.file) {
-          const fullPath = path6.join(resourceDir, element.file);
-          if (fs6.existsSync(fullPath)) {
-            await fs6.promises.unlink(fullPath);
-          }
-        }
-      }
-    }
-    if (isPending) {
-      const newPendingData = pendingData.filter((item) => item.cave_id !== caveId);
-      await FileHandler.writeJsonData(pendingFilePath, newPendingData);
-    } else {
-      const newData = data.filter((item) => item.cave_id !== caveId);
-      await FileHandler.writeJsonData(caveFilePath, newData);
-      await idManager.removeStat(targetCave.contributor_number, caveId);
-    }
-    await idManager.markDeleted(caveId);
-    const deleteStatus = isPending ? session.text("commands.cave.remove.deletePending") : "";
-    const deleteMessage = session.text("commands.cave.remove.deleted");
-    return `${deleteMessage}${deleteStatus}${caveContent}`;
-  }
-  __name(processDelete, "processDelete");
   async function processAdd(ctx2, config2, caveFilePath, resourceDir, pendingFilePath, session, content) {
     let caveId;
     try {
@@ -1552,7 +1590,7 @@ async function apply(ctx, config) {
           index: Number.MAX_SAFE_INTEGER
         });
       }
-      const hashStorage = new ContentHashManager(path6.join(ctx2.baseDir, "data", "cave"));
+      const hashStorage = new HashManager(path7.join(ctx2.baseDir, "data", "cave"));
       await hashStorage.initialize();
       const hashStatus = await hashStorage.getStatus();
       if (!hashStatus.lastUpdated || hashStatus.entries.length === 0) {
@@ -1569,7 +1607,7 @@ async function apply(ctx, config) {
         pendingData.push(newCave);
         await Promise.all([
           FileHandler.writeJsonData(pendingFilePath, pendingData),
-          auditManager.sendAuditMessage(newCave, await buildMessage2(newCave, resourceDir, session), session)
+          auditManager.sendAuditMessage(newCave, await buildMessage(newCave, resourceDir, session), session)
         ]);
         return sendMessage(session, "commands.cave.add.submitPending", [caveId], false);
       }
@@ -1595,14 +1633,14 @@ async function apply(ctx, config) {
             "commands.cave.error.similarDuplicateFound",
             [(result.similarity * 100).toFixed(1)]
           );
-          await session.send(duplicateMessage + await buildMessage2(originalCave, resourceDir, session));
+          await session.send(duplicateMessage + await buildMessage(originalCave, resourceDir, session));
           throw new Error("duplicate_found");
         }
       }
       await Promise.all([
         FileHandler.writeJsonData(caveFilePath, data),
         contentHashManager.updateCaveContent(caveId, {
-          images: savedImages.length > 0 ? await Promise.all(savedImages.map((file) => fs6.promises.readFile(path6.join(resourceDir, file)))) : void 0,
+          images: savedImages.length > 0 ? await Promise.all(savedImages.map((file) => fs7.promises.readFile(path7.join(resourceDir, file)))) : void 0,
           texts: textParts.filter((p) => p.type === "text").map((p) => p.content)
         })
       ]);
@@ -1625,11 +1663,11 @@ async function apply(ctx, config) {
       return sendMessage(session, "commands.cave.message.blacklisted", [], true);
     }
   }).action(async ({ session, options }, ...content) => {
-    const dataDir2 = path6.join(ctx.baseDir, "data");
-    const caveDir2 = path6.join(dataDir2, "cave");
-    const caveFilePath = path6.join(caveDir2, "cave.json");
-    const resourceDir = path6.join(caveDir2, "resources");
-    const pendingFilePath = path6.join(caveDir2, "pending.json");
+    const dataDir2 = path7.join(ctx.baseDir, "data");
+    const caveDir2 = path7.join(dataDir2, "cave");
+    const caveFilePath = path7.join(caveDir2, "cave.json");
+    const resourceDir = path7.join(caveDir2, "resources");
+    const pendingFilePath = path7.join(caveDir2, "pending.json");
     const needsCooldown = !options.l && !options.a;
     if (needsCooldown) {
       const guildId = session.guildId;
@@ -1648,23 +1686,23 @@ async function apply(ctx, config) {
       if (config.manager.includes(session.userId)) {
         if (!isNaN(num)) {
           if (num < 1e4) {
-            return await processList(session, config, void 0, num);
+            return await processList(session, config, idManager, void 0, num);
           } else {
-            return await processList(session, config, num.toString());
+            return await processList(session, config, idManager, num.toString());
           }
         } else if (input) {
-          return await processList(session, config, input);
+          return await processList(session, config, idManager, input);
         }
-        return await processList(session, config);
+        return await processList(session, config, idManager);
       } else {
-        return await processList(session, config, session.userId);
+        return await processList(session, config, idManager, session.userId);
       }
     }
     if (options.g) {
       return await processView(caveFilePath, resourceDir, session, options, content);
     }
     if (options.r) {
-      return await processDelete(caveFilePath, resourceDir, pendingFilePath, session, config, options, content);
+      return await processDelete(caveFilePath, resourceDir, pendingFilePath, session, config, options, content, idManager, contentHashManager);
     }
     if (options.a) {
       return await processAdd(ctx, config, caveFilePath, resourceDir, pendingFilePath, session, content);
@@ -1676,11 +1714,11 @@ async function apply(ctx, config) {
       return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
   }).action(async ({ session }, id) => {
-    const dataDir2 = path6.join(ctx.baseDir, "data");
-    const caveDir2 = path6.join(dataDir2, "cave");
-    const caveFilePath = path6.join(caveDir2, "cave.json");
-    const resourceDir = path6.join(caveDir2, "resources");
-    const pendingFilePath = path6.join(caveDir2, "pending.json");
+    const dataDir2 = path7.join(ctx.baseDir, "data");
+    const caveDir2 = path7.join(dataDir2, "cave");
+    const caveFilePath = path7.join(caveDir2, "cave.json");
+    const resourceDir = path7.join(caveDir2, "resources");
+    const pendingFilePath = path7.join(caveDir2, "pending.json");
     const pendingData = await FileHandler.readJsonData(pendingFilePath);
     return await auditManager.processAudit(pendingData, true, caveFilePath, resourceDir, pendingFilePath, session, id === "all" ? void 0 : parseInt(id));
   });
@@ -1689,35 +1727,17 @@ async function apply(ctx, config) {
       return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
   }).action(async ({ session }, id) => {
-    const dataDir2 = path6.join(ctx.baseDir, "data");
-    const caveDir2 = path6.join(dataDir2, "cave");
-    const caveFilePath = path6.join(caveDir2, "cave.json");
-    const resourceDir = path6.join(caveDir2, "resources");
-    const pendingFilePath = path6.join(caveDir2, "pending.json");
+    const dataDir2 = path7.join(ctx.baseDir, "data");
+    const caveDir2 = path7.join(dataDir2, "cave");
+    const caveFilePath = path7.join(caveDir2, "cave.json");
+    const resourceDir = path7.join(caveDir2, "resources");
+    const pendingFilePath = path7.join(caveDir2, "pending.json");
     const pendingData = await FileHandler.readJsonData(pendingFilePath);
     return await auditManager.processAudit(pendingData, false, caveFilePath, resourceDir, pendingFilePath, session, id === "all" ? void 0 : parseInt(id));
   });
 }
 __name(apply, "apply");
 var logger5 = new import_koishi6.Logger("cave");
-async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
-  try {
-    const msg = await session.send(session.text(key, params));
-    if (isTemp && msg) {
-      setTimeout(async () => {
-        try {
-          await session.bot.deleteMessage(session.channelId, msg);
-        } catch (error) {
-          logger5.debug(`Failed to delete temporary message: ${error.message}`);
-        }
-      }, timeout);
-    }
-  } catch (error) {
-    logger5.error(`Failed to send message: ${error.message}`);
-  }
-  return "";
-}
-__name(sendMessage, "sendMessage");
 function cleanElementsForSave(elements, keepIndex = false) {
   if (!elements?.length) return [];
   const cleanedElements = elements.map((element) => {
@@ -1742,47 +1762,6 @@ function cleanElementsForSave(elements, keepIndex = false) {
   return keepIndex ? cleanedElements.sort((a, b) => (a.index || 0) - (b.index || 0)) : cleanedElements;
 }
 __name(cleanElementsForSave, "cleanElementsForSave");
-async function processMediaFile(filePath, type) {
-  const data = await fs6.promises.readFile(filePath).catch(() => null);
-  if (!data) return null;
-  return `data:${type}/${type === "image" ? "png" : "mp4"};base64,${data.toString("base64")}`;
-}
-__name(processMediaFile, "processMediaFile");
-async function buildMessage2(cave, resourceDir, session) {
-  if (!cave?.elements?.length) {
-    return session.text("commands.cave.error.noContent");
-  }
-  const videoElement = cave.elements.find((el) => el.type === "video");
-  const nonVideoElements = cave.elements.filter((el) => el.type !== "video").sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
-  if (videoElement?.file) {
-    const basicInfo = [
-      session.text("commands.cave.message.caveTitle", [cave.cave_id]),
-      session.text("commands.cave.message.contributorSuffix", [cave.contributor_name])
-    ].join("\n");
-    await session?.send(basicInfo);
-    const filePath = path6.join(resourceDir, videoElement.file);
-    const base64Data = await processMediaFile(filePath, "video");
-    if (base64Data && session) {
-      await session.send((0, import_koishi6.h)("video", { src: base64Data }));
-    }
-    return "";
-  }
-  const lines = [session.text("commands.cave.message.caveTitle", [cave.cave_id])];
-  for (const element of nonVideoElements) {
-    if (element.type === "text") {
-      lines.push(element.content);
-    } else if (element.type === "img" && element.file) {
-      const filePath = path6.join(resourceDir, element.file);
-      const base64Data = await processMediaFile(filePath, "image");
-      if (base64Data) {
-        lines.push((0, import_koishi6.h)("image", { src: base64Data }));
-      }
-    }
-  }
-  lines.push(session.text("commands.cave.message.contributorSuffix", [cave.contributor_name]));
-  return lines.join("\n");
-}
-__name(buildMessage2, "buildMessage");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,

package/lib/types.d.ts

@@ -0,0 +1,24 @@
+export interface BaseElement {
+    type: 'text' | 'img' | 'video';
+    index: number;
+}
+export interface TextElement extends BaseElement {
+    type: 'text';
+    content: string;
+}
+export interface MediaElement extends BaseElement {
+    type: 'img' | 'video';
+    file?: string;
+    fileName?: string;
+    fileSize?: string;
+    filePath?: string;
+}
+export type Element = TextElement | MediaElement;
+export interface CaveObject {
+    cave_id: number;
+    elements: Element[];
+    contributor_number: string;
+    contributor_name: string;
+}
+export interface PendingCave extends CaveObject {
+}

package/lib/utils/AuditHandler.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'koishi';
+import { Config, PendingCave } from '..';
+import { IdManager } from './IdManager';
+export declare class AuditManager {
+    private ctx;
+    private config;
+    private idManager;
+    private logger;
+    constructor(ctx: Context, config: Config, idManager: IdManager);
+    processAudit(pendingData: PendingCave[], isApprove: boolean, caveFilePath: string, resourceDir: string, pendingFilePath: string, session: any, targetId?: number): Promise<string>;
+    private handleSingleAudit;
+    private handleBatchAudit;
+    sendAuditMessage(cave: PendingCave, content: string, session: any): Promise<void>;
+    private deleteMediaFiles;
+    private cleanElementsForSave;
+    private sendMessage;
+}

package/lib/utils/ContentHasher.d.ts

@@ -0,0 +1,80 @@
+import { Buffer } from 'buffer';
+/**
+ * 图片哈希计算工具类
+ * 使用 DCT(离散余弦变换)方法计算图片的感知哈希值，可用于图片相似度比较
+ */
+export declare class ContentHasher {
+    /**
+     * 计算图片的感知哈希值
+     * @param imageBuffer - 图片的二进制数据
+     * @returns 返回64位的十六进制哈希字符串
+     * @throws 当图片处理失败时可能抛出错误
+     */
+    static calculateHash(imageBuffer: Buffer): Promise<string>;
+    /**
+     * 将二进制字符串转换为十六进制
+     * @param binary - 二进制字符串
+     * @returns 十六进制字符串
+     * @private
+     */
+    private static binaryToHex;
+    /**
+     * 将十六进制字符串转换为二进制
+     * @param hex - 十六进制字符串
+     * @returns 二进制字符串
+     * @private
+     */
+    private static hexToBinary;
+    /**
+     * 计算图像的DCT(离散余弦变换)
+     * @param data - 图像数据
+     * @param size - 图像尺寸
+     * @returns DCT变换后的矩阵
+     * @private
+     */
+    private static computeDCT;
+    /**
+     * 获取DCT系数
+     * @param index - 索引值
+     * @param size - 矩阵大小
+     * @returns DCT系数
+     * @private
+     */
+    private static getDCTCoefficient;
+    /**
+     * 计算数组的中位数
+     * @param arr - 输入数组
+     * @returns 中位数
+     * @private
+     */
+    private static calculateMedian;
+    /**
+     * 从DCT矩阵中提取特征值
+     * @param matrix - DCT矩阵
+     * @param size - 矩阵大小
+     * @returns 特征值数组
+     * @private
+     */
+    private static extractFeatures;
+    /**
+     * 计算两个哈希值之间的汉明距离
+     * @param hash1 - 第一个哈希值
+     * @param hash2 - 第二个哈希值
+     * @returns 汉明距离
+     * @throws 当两个哈希值长度不等时抛出错误
+     */
+    static calculateDistance(hash1: string, hash2: string): number;
+    /**
+     * 计算两个图片哈希值的相似度
+     * @param hash1 - 第一个哈希值
+     * @param hash2 - 第二个哈希值
+     * @returns 返回0-1之间的相似度值，1表示完全相同，0表示完全不同
+     */
+    static calculateSimilarity(hash1: string, hash2: string): number;
+    /**
+     * 计算文本的哈希值
+     * @param text - 输入文本
+     * @returns 文本的哈希值(36进制字符串)
+     */
+    static calculateTextHash(text: string): string;
+}

package/lib/utils/FileHandler.d.ts

@@ -0,0 +1,63 @@
+export declare class FileHandler {
+    private static locks;
+    private static readonly RETRY_COUNT;
+    private static readonly RETRY_DELAY;
+    private static readonly CONCURRENCY_LIMIT;
+    /**
+     * 并发控制
+     * @param operation 要执行的操作
+     * @param limit 并发限制
+     * @returns 操作结果
+     */
+    private static withConcurrencyLimit;
+    /**
+     * 文件操作包装器
+     * @param filePath 文件路径
+     * @param operation 要执行的操作
+     * @returns 操作结果
+     */
+    private static withFileOp;
+    /**
+     * 事务处理
+     * @param operations 要执行的操作数组
+     * @returns 操作结果数组
+     */
+    static withTransaction<T>(operations: Array<{
+        filePath: string;
+        operation: () => Promise<T>;
+        rollback?: () => Promise<void>;
+    }>): Promise<T[]>;
+    /**
+     * 读取 JSON 数据
+     * @param filePath 文件路径
+     * @returns JSON 数据
+     */
+    static readJsonData<T>(filePath: string): Promise<T[]>;
+    /**
+     * 写入 JSON 数据
+     * @param filePath 文件路径
+     * @param data 要写入的数据
+     */
+    static writeJsonData<T>(filePath: string, data: T[]): Promise<void>;
+    /**
+     * 确保目录存在
+     * @param dir 目录路径
+     */
+    static ensureDirectory(dir: string): Promise<void>;
+    /**
+     * 确保 JSON 文件存在
+     * @param filePath 文件路径
+     */
+    static ensureJsonFile(filePath: string): Promise<void>;
+    /**
+     * 保存媒体文件
+     * @param filePath 文件路径
+     * @param data 文件数据
+     */
+    static saveMediaFile(filePath: string, data: Buffer | string): Promise<void>;
+    /**
+     * 删除媒体文件
+     * @param filePath 文件路径
+     */
+    static deleteMediaFile(filePath: string): Promise<void>;
+}

package/lib/utils/HashManager.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 哈希存储状态类型
+ */
+interface HashStorageStatus {
+    lastUpdated: string;
+    entries: Array<{
+        caveId: number;
+        imageHashes: string[];
+        textHashes: string[];
+    }>;
+}
+/**
+ * 图片哈希值存储管理类
+ * 负责管理和维护回声洞图片的哈希值
+ */
+export declare class HashManager {
+    private readonly caveDir;
+    private static readonly HASH_FILE;
+    private static readonly CAVE_FILE;
+    private static readonly BATCH_SIZE;
+    private imageHashes;
+    private textHashes;
+    private initialized;
+    /**
+     * 初始化HashManager实例
+     * @param caveDir 回声洞数据目录路径
+     */
+    constructor(caveDir: string);
+    private get filePath();
+    private get resourceDir();
+    private get caveFilePath();
+    /**
+     * 初始化哈希存储
+     * 读取现有哈希数据或重新构建哈希值
+     * @throws 初始化失败时抛出错误
+     */
+    initialize(): Promise<void>;
+    /**
+     * 获取当前哈希存储状态
+     * @returns 包含最后更新时间和所有条目的状态对象
+     */
+    getStatus(): Promise<HashStorageStatus>;
+    /**
+     * 更新指定回声洞的图片哈希值
+     * @param caveId 回声洞ID
+     * @param content 图片buffer数组
+     */
+    updateCaveContent(caveId: number, content: {
+        images?: Buffer[];
+        texts?: string[];
+    }): Promise<void>;
+    /**
+     * 更新所有回声洞的哈希值
+     * @param isInitialBuild 是否为初始构建
+     */
+    updateAllCaves(isInitialBuild?: boolean): Promise<void>;
+    /**
+     * 查找重复的图片
+     * @param content 待查找的图片buffer数组
+     * @param thresholds 相似度阈值
+     * @returns 匹配结果数组，包含索引、回声洞ID和相似度
+     */
+    findDuplicates(content: {
+        images?: Buffer[];
+        texts?: string[];
+    }, thresholds: {
+        image: number;
+        text: number;
+    }): Promise<Array<{
+        type: 'image' | 'text';
+        index: number;
+        caveId: number;
+        similarity: number;
+    } | null>>;
+    private findTextDuplicates;
+    private calculateTextSimilarity;
+    private findImageDuplicates;
+    /**
+     * 加载回声洞数据
+     * @returns 回声洞数据数组
+     * @private
+     */
+    private loadCaveData;
+    /**
+     * 保存哈希数据到文件
+     * @private
+     */
+    private saveContentHashes;
+    /**
+     * 构建初始哈希数据
+     * @private
+     */
+    private buildInitialHashes;
+    /**
+     * 更新缺失的哈希值
+     * @private
+     */
+    private updateMissingHashes;
+    /**
+     * 批量处理数组项
+     * @param items 待处理项数组
+     * @param processor 处理函数
+     * @param batchSize 批处理大小
+     * @private
+     */
+    private processBatch;
+}
+export {};

package/lib/utils/IdManager.d.ts

@@ -0,0 +1,69 @@
+/**
+ * ID管理器类
+ * 负责管理回声洞ID的分配、删除和统计信息
+ */
+export declare class IdManager {
+    private deletedIds;
+    private maxId;
+    private initialized;
+    private readonly statusFilePath;
+    private stats;
+    private usedIds;
+    /**
+     * 初始化ID管理器
+     * @param baseDir - 基础目录路径
+     */
+    constructor(baseDir: string);
+    /**
+     * 初始化ID管理系统
+     * @param caveFilePath - 正式回声洞数据文件路径
+     * @param pendingFilePath - 待处理回声洞数据文件路径
+     * @throws 当初始化失败时抛出错误
+     */
+    initialize(caveFilePath: string, pendingFilePath: string): Promise<void>;
+    /**
+     * 处理ID冲突
+     * @param conflicts - ID冲突映射表
+     * @param caveFilePath - 正式回声洞数据文件路径
+     * @param pendingFilePath - 待处理回声洞数据文件路径
+     * @param caveData - 正式回声洞数据
+     * @param pendingData - 待处理回声洞数据
+     * @private
+     */
+    private handleConflicts;
+    /**
+     * 获取下一个可用的ID
+     * @returns 下一个可用的ID
+     * @throws 当ID管理器未初始化时抛出错误
+     */
+    getNextId(): number;
+    /**
+     * 标记ID为已删除状态
+     * @param id - 要标记为删除的ID
+     * @throws 当ID管理器未初始化时抛出错误
+     */
+    markDeleted(id: number): Promise<void>;
+    /**
+     * 添加贡献统计
+     * @param contributorNumber - 贡献者编号
+     * @param caveId - 回声洞ID
+     */
+    addStat(contributorNumber: string, caveId: number): Promise<void>;
+    /**
+     * 移除贡献统计
+     * @param contributorNumber - 贡献者编号
+     * @param caveId - 回声洞ID
+     */
+    removeStat(contributorNumber: string, caveId: number): Promise<void>;
+    /**
+     * 获取所有贡献统计信息
+     * @returns 贡献者编号到回声洞ID列表的映射
+     */
+    getStats(): Record<string, number[]>;
+    /**
+     * 保存当前状态到文件
+     * @private
+     * @throws 当保存失败时抛出错误
+     */
+    private saveStatus;
+}

package/lib/utils/MediaHandler.d.ts

@@ -0,0 +1,30 @@
+import { Context } from 'koishi';
+import { Element, CaveObject } from '..';
+export declare function buildMessage(cave: CaveObject, resourceDir: string, session?: any): Promise<string>;
+export declare function sendMessage(session: any, key: string, params?: any[], isTemp?: boolean, timeout?: number): Promise<string>;
+export declare function processMediaFile(filePath: string, type: 'image' | 'video'): Promise<string | null>;
+export declare function extractMediaContent(originalContent: string, config: {
+    imageMaxSize: number;
+    videoMaxSize: number;
+}, session: any): Promise<{
+    imageUrls: string[];
+    imageElements: Array<{
+        type: 'img';
+        index: number;
+        fileName?: string;
+        fileSize?: string;
+    }>;
+    videoUrls: string[];
+    videoElements: Array<{
+        type: 'video';
+        index: number;
+        fileName?: string;
+        fileSize?: string;
+    }>;
+    textParts: Element[];
+}>;
+export declare function saveMedia(urls: string[], fileNames: (string | undefined)[], resourceDir: string, caveId: number, mediaType: 'img' | 'video', config: {
+    enableImageDuplicate: boolean;
+    imageDuplicateThreshold: number;
+    textDuplicateThreshold: number;
+}, ctx: Context, session: any, buffers?: Buffer[]): Promise<string[]>;

package/lib/utils/ProcessHandle.d.ts

@@ -0,0 +1,7 @@
+import { Config } from '..';
+import { IdManager } from './IdManager';
+import { HashManager } from './HashManager';
+export declare function processList(session: any, config: Config, idManager: IdManager, userId?: string, pageNum?: number): Promise<string>;
+export declare function processView(caveFilePath: string, resourceDir: string, session: any, options: any, content: string[]): Promise<string>;
+export declare function processRandom(caveFilePath: string, resourceDir: string, session: any): Promise<string | void>;
+export declare function processDelete(caveFilePath: string, resourceDir: string, pendingFilePath: string, session: any, config: Config, options: any, content: string[], idManager: IdManager, HashManager: HashManager): Promise<string>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "最好的 cave 插件，可开关的审核系统，可引用添加，支持图文混合内容，可查阅投稿列表，完美复刻你的 .cave 体验！",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],