@nenekusanagi/koishi-plugin-setu 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present Shigma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,224 @@
+<div align="center">
+  <img src="https://raw.githubusercontent.com/chitsanfei/koishi-plugin-setu/master/assets/koimu.png" height="200" alt="koishi-plugin-setu">
+  <h1>koishi-plugin-setu</h1>
+  <b>一个支持多 API 提供商的色图插件，基于 Koishi 框架开发</b>
+</div>
+
+---
+
+[![npm version](https://img.shields.io/npm/v/@nenekusanagi/koishi-plugin-setu.svg)](https://www.npmjs.com/package/@nenekusanagi/koishi-plugin-setu)
+[![GitHub stars](https://img.shields.io/github/stars/chitsanfei/koishi-plugin-setu)](https://github.com/chitsanfei/koishi-plugin-setu/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/chitsanfei/koishi-plugin-setu)](https://github.com/chitsanfei/koishi-plugin-setu/issues)
+[![GitHub forks](https://img.shields.io/github/forks/chitsanfei/koishi-plugin-setu)](https://github.com/chitsanfei/koishi-plugin-setu/network)
+[![GitHub license](https://img.shields.io/github/license/chitsanfei/koishi-plugin-setu)](https://github.com/chitsanfei/koishi-plugin-setu/blob/master/LICENSE)
+
+---
+
+## ✨ 功能特性
+
+- 🎯 支持多种 API 提供商（Lolicon API、Nekobot API、自定义 API）
+- 🔍 灵活的参数筛选（大小、作者、标签、AI 作品排除等）
+- 🛡️ 完善的参数验证和错误处理机制
+- 🤖 支持 R18 内容控制
+- 📊 智能参数适配（不同 API 自动使用对应支持的参数）
+- 🎨 可配置的消息格式（集合回复或直接发送）
+- 🖼️ 龙图提示
+- 🏷️ 多标签搜索支持（Nekobot API）
+- ⚡ 现代化的 TypeScript 架构设计
+
+## 📦 安装
+
+### 通过 npm 安装
+
+```bash
+npm install @nenekusanagi/koishi-plugin-setu
+```
+
+### 通过 Koishi 插件市场
+
+在 Koishi 控制台的「插件市场」中搜索 `setu` 并安装。
+
+## ⚙️ 配置说明
+
+### API 提供商配置
+
+在插件设置中选择并配置 API 提供商：
+
+#### 1. Lolicon API（默认）
+
+- **API 地址**：默认 `https://api.lolicon.app/setu/v2`
+- **默认图片大小**：regular（可选择 original、regular、small、thumb、mini）
+- **R18 控制**：可开启/关闭限制级内容（开启后使用 `-r` 参数有效）
+
+#### 2. Nekobot API
+
+- **API 地址**：默认 `https://nekobot.xyz/api/image`
+- **默认标签**：neko（无 `-t` 参数时使用）
+- **⚠️ 警告**：本接口没有对限制级色图进行限制，用户可能会请求到限制级色图
+
+#### 3. 自定义 API
+
+- **API 地址**：用户自定义
+- **参数支持**：禁用所有命令参数（由用户自行决定 API 格式）
+
+### 其他配置
+
+- **通用参数**：
+  - 单日个人使用次数限制（默认 10 次）
+
+- **机器人行为**：
+  - 使用集合回复（解决部分平台发图问题）
+  - 一次请求的图片数量（1-10，默认 1）
+
+- **幽默**：
+  - 启用错误提示龙图
+  - 龙图图片地址（默认 GitHub 托管）
+
+## 🎮 使用方法
+
+### 基础指令
+
+```
+setu                    # 获取随机色图
+help setu              # 查看帮助菜单
+```
+
+### 可用参数
+
+|    参数     | 适用 API |               说明                |        示例         |
+| :---------: | :------: | :-------------------------------: | :-----------------: |
+| `-s <size>` | Lolicon  |           设置图片大小            |   `setu -s small`   |
+|    `-r`     | Lolicon  | 获取限制级色图（需开启 R18 功能） |      `setu -r`      |
+| `-t <tags>` | Nekobot  | 指定标签（支持多标签，空格分隔）  | `setu -t neko anal` |
+| `-a <uid>`  | Lolicon  |        指定作者 UID 的作品        |  `setu -a 123456`   |
+|    `-A`     | Lolicon  |           排除 AI 作品            |      `setu -A`      |
+
+### 使用示例
+
+```bash
+# 获取普通色图
+setu
+
+# 获取小图
+setu -s small
+
+# 获取限制级色图（需在配置中开启 R18）
+setu -r
+
+# 获取特定作者的作品
+setu -a 123456
+
+# 排除 AI 作品
+setu -A
+
+# 使用 Nekobot API 获取 neko 标签图片
+setu -t neko
+
+# 使用多个标签（Nekobot API）
+setu -t neko anal
+```
+
+## 📋 API 参数支持矩阵
+
+|       参数       | Lolicon API | Nekobot API | 自定义 API |
+| :--------------: | :---------: | :---------: | :--------: |
+|   `-s/--size`    |     ✅      |     ❌      |     ❌     |
+|    `-r/--r18`    |     ✅      |     ❌      |     ❌     |
+|   `-t/--tags`    |     ❌      |     ✅      |     ❌     |
+|  `-a/--author`   |     ✅      |     ❌      |     ❌     |
+| `-A/--excludeAI` |     ✅      |     ❌      |     ❌     |
+
+## ⚠️ 重要提示
+
+### 网络要求
+
+- 确保服务器支持 IPv6 连接（与 Lolicon API 通信需要）
+- 网络不稳定时可能需要多次尝试
+
+### 使用限制
+
+- **请在合法合规的环境下使用本插件**
+- **不要在不支持的平台（如 QQ、Kook 等）启用限制级功能**
+- **使用 R18 功能前请确保符合当地法律法规**
+- **一切后果由用户自行承担，本插件仅展示技术实现**
+
+### 平台兼容性
+
+- 部分平台可能对图片发送有限制，建议启用「使用集合回复」功能
+- 发送限制级内容可能被平台 AI 识别并风控
+
+## 🔧 开发信息
+
+### 项目结构
+
+```
+src/
+├── types/          # 类型定义
+│   ├── config.ts   # 配置类型
+│   └── api.ts      # API 类型
+├── services/       # 服务层
+│   ├── api.ts      # 主服务
+│   └── providers/  # API 提供商
+│       ├── lolicon.ts
+│       ├── nekobot.ts
+│       └── custom.ts
+├── utils/          # 工具函数
+└── index.ts        # 插件入口
+```
+
+### 技术栈
+
+- **框架**：Koishi v4
+- **语言**：TypeScript
+- **架构**：模块化设计，支持多 API 提供商
+
+## 📚 参考资料
+
+- [Koishi 官网](https://koishi.chat/)
+- [Koishi GitHub](https://github.com/koishijs/koishi)
+- [Lolicon API 文档](https://api.lolicon.app/#/setu)
+- [Nekobot API 文档](https://nekobot.xyz/)
+
+## 🤝 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 📄 许可证
+
+本项目基于 [MIT](https://github.com/chitsanfei/koishi-plugin-setu/blob/master/LICENSE) 许可证开源。
+
+```
+MIT License
+
+Copyright (c) 2024 koishi-plugin-setu Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## 🙏 致谢
+
+- 感谢 [Koishi](https://github.com/koishijs/koishi) 团队提供的优秀框架
+- 感谢前人 [Lipraty](https://github.com/Lipraty) 的开源项目
+- 感谢所有使用和贡献本项目的开发者们
+
+---
+
+<div align="center">
+  <b>⭐ 如果这个项目对你有帮助，请给它一个星标！ ⭐</b>
+</div>

package/lib/index.d.ts

@@ -0,0 +1,93 @@
+import { Context } from "koishi";
+import { Config as ConfigInterface } from "./types/config";
+export declare const name = "setu";
+export declare const Config: import("schemastery")<Schemastery.ObjectS<{
+    provider: import("schemastery")<"lolicon" | "nekobot" | "custom", "lolicon" | "nekobot" | "custom">;
+    common: import("schemastery")<Schemastery.ObjectS<{
+        maxUsage: import("schemastery")<number, number>;
+    }>, Schemastery.ObjectT<{
+        maxUsage: import("schemastery")<number, number>;
+    }>>;
+    lolicon: import("schemastery")<Schemastery.ObjectS<{
+        allowR18: import("schemastery")<boolean, boolean>;
+        apiUrl: import("schemastery")<string, string>;
+        defaultPicSize: import("schemastery")<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>, Schemastery.ObjectT<{
+        allowR18: import("schemastery")<boolean, boolean>;
+        apiUrl: import("schemastery")<string, string>;
+        defaultPicSize: import("schemastery")<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>>;
+    nekobot: import("schemastery")<Schemastery.ObjectS<{
+        apiUrl: import("schemastery")<string, string>;
+        defaultTag: import("schemastery")<string, string>;
+        notice: import("schemastery")<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: import("schemastery")<string, string>;
+        defaultTag: import("schemastery")<string, string>;
+        notice: import("schemastery")<string, string>;
+    }>>;
+    custom: import("schemastery")<Schemastery.ObjectS<{
+        apiUrl: import("schemastery")<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: import("schemastery")<string, string>;
+    }>>;
+    behavior: import("schemastery")<Schemastery.ObjectS<{
+        useFigure: import("schemastery")<boolean, boolean>;
+        replyNumber: import("schemastery")<number, number>;
+    }>, Schemastery.ObjectT<{
+        useFigure: import("schemastery")<boolean, boolean>;
+        replyNumber: import("schemastery")<number, number>;
+    }>>;
+    humor: import("schemastery")<Schemastery.ObjectS<{
+        longPicWarning: import("schemastery")<boolean, boolean>;
+        longPicAddress: import("schemastery")<string, string>;
+    }>, Schemastery.ObjectT<{
+        longPicWarning: import("schemastery")<boolean, boolean>;
+        longPicAddress: import("schemastery")<string, string>;
+    }>>;
+}>, Schemastery.ObjectT<{
+    provider: import("schemastery")<"lolicon" | "nekobot" | "custom", "lolicon" | "nekobot" | "custom">;
+    common: import("schemastery")<Schemastery.ObjectS<{
+        maxUsage: import("schemastery")<number, number>;
+    }>, Schemastery.ObjectT<{
+        maxUsage: import("schemastery")<number, number>;
+    }>>;
+    lolicon: import("schemastery")<Schemastery.ObjectS<{
+        allowR18: import("schemastery")<boolean, boolean>;
+        apiUrl: import("schemastery")<string, string>;
+        defaultPicSize: import("schemastery")<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>, Schemastery.ObjectT<{
+        allowR18: import("schemastery")<boolean, boolean>;
+        apiUrl: import("schemastery")<string, string>;
+        defaultPicSize: import("schemastery")<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>>;
+    nekobot: import("schemastery")<Schemastery.ObjectS<{
+        apiUrl: import("schemastery")<string, string>;
+        defaultTag: import("schemastery")<string, string>;
+        notice: import("schemastery")<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: import("schemastery")<string, string>;
+        defaultTag: import("schemastery")<string, string>;
+        notice: import("schemastery")<string, string>;
+    }>>;
+    custom: import("schemastery")<Schemastery.ObjectS<{
+        apiUrl: import("schemastery")<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: import("schemastery")<string, string>;
+    }>>;
+    behavior: import("schemastery")<Schemastery.ObjectS<{
+        useFigure: import("schemastery")<boolean, boolean>;
+        replyNumber: import("schemastery")<number, number>;
+    }>, Schemastery.ObjectT<{
+        useFigure: import("schemastery")<boolean, boolean>;
+        replyNumber: import("schemastery")<number, number>;
+    }>>;
+    humor: import("schemastery")<Schemastery.ObjectS<{
+        longPicWarning: import("schemastery")<boolean, boolean>;
+        longPicAddress: import("schemastery")<string, string>;
+    }>, Schemastery.ObjectT<{
+        longPicWarning: import("schemastery")<boolean, boolean>;
+        longPicAddress: import("schemastery")<string, string>;
+    }>>;
+}>>;
+export declare function apply(ctx: Context, config: ConfigInterface): void;

package/lib/index.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.name = void 0;
+exports.apply = apply;
+const config_1 = require("./types/config");
+const services_1 = require("./services");
+const utils_1 = require("./utils");
+const utils_2 = require("./utils");
+exports.name = "setu";
+exports.Config = config_1.ConfigSchema;
+function apply(ctx, config) {
+    const logger = ctx.logger("setu");
+    // 加载多语言
+    ctx.i18n.define("zh", {
+        "commands.setu.description": "发一个瑟图",
+        "commands.setu.options.size": "设置图片大小",
+        "commands.setu.options.author": "指定作者 uid 的作品",
+        "commands.setu.options.excludeAI": "排除 AI 作品",
+        "commands.setu.options.r18": "检索 R18 作品，必须启用功能才能使用，参数为0或者1",
+        "commands.setu.messages.relax": "别急，正在给你找一个瑟图！",
+        "commands.setu.messages.error": "加载错误：{0}",
+    });
+    // 注册指令
+    ctx
+        .command("setu", "发一个瑟图")
+        .option("size", "-s <string>", {
+        fallback: (0, config_1.isLoliconConfig)(config)
+            ? config.lolicon.defaultPicSize
+            : "regular",
+    })
+        .option("r18", "-r", {
+        fallback: (0, config_1.isLoliconConfig)(config) ? config.lolicon.allowR18 : false,
+    })
+        .option("tags", "-t <string>")
+        .option("author", "-a <number>")
+        .option("excludeAI", "-A", { fallback: true })
+        .action(async ({ session, options }) => {
+        try {
+            // 检查配置是否有效
+            if (!(0, config_1.hasValidConfig)(config)) {
+                logger.warn("API 提供商未配置或配置不完整，请在插件设置中选择并配置 API 提供商");
+                if (config.humor.longPicWarning) {
+                    return `<image url="${config.humor.longPicAddress}"/>`;
+                }
+                return "API 提供商未配置或配置不完整，请在插件设置中选择并配置 API 提供商";
+            }
+            // 初始化服务
+            const setuService = new services_1.SetuService(ctx, config);
+            // 获取默认图片大小（与 fallback 保持一致）
+            const defaultPicSize = (0, config_1.isLoliconConfig)(config)
+                ? config.lolicon.defaultPicSize
+                : "regular";
+            // 获取 R18 允许状态（与 fallback 保持一致）
+            const allowR18 = (0, config_1.isLoliconConfig)(config)
+                ? config.lolicon.allowR18
+                : false;
+            // 标记用户输入的参数（如果值不等于 fallback，说明是用户输入的）
+            const userInput = {
+                _tags: options.tags !== undefined, // tags 没有 fallback，所以只要有值就是用户输入
+                _author: options.author !== undefined,
+                _size: options.size !== defaultPicSize,
+                _r18: options.r18 !== allowR18,
+                _excludeAI: options.excludeAI !== true,
+            };
+            // 验证参数支持
+            const paramError = (0, config_1.validateParameters)(config.provider, userInput);
+            if (paramError) {
+                return paramError;
+            }
+            // 验证参数
+            const size = (0, utils_2.validatePicSize)(options.size)
+                ? options.size
+                : defaultPicSize;
+            const num = (0, utils_2.validateReplyNumber)(config.behavior.replyNumber)
+                ? config.behavior.replyNumber
+                : 1;
+            const r18 = options.r18 === true ? 1 : 0;
+            // 处理标签（空格分隔）
+            const tags = options.tags ? options.tags.split(" ") : [];
+            // 构建查询选项
+            const queryOptions = {
+                size,
+                num,
+                r18,
+                tags,
+                author: options.author,
+                excludeAI: options.excludeAI,
+            };
+            // 发送请求
+            const response = await setuService.getSetu(queryOptions);
+            // 检查响应
+            if (!response.data || response.data.length === 0) {
+                if (config.humor.longPicWarning) {
+                    return `<image url="${config.humor.longPicAddress}"/>`;
+                }
+                return session.text(".error", [
+                    response.error || "没有找到符合条件的图片",
+                ]);
+            }
+            // 发送加载提示
+            await session.send(session.text(".relax"));
+            // 根据配置选择消息格式
+            if (config.behavior.useFigure) {
+                return (0, utils_1.createFigureMessage)(session, response.data, size);
+            }
+            else {
+                return (0, utils_1.createImageMessage)(response.data, size);
+            }
+        }
+        catch (error) {
+            logger.error("获取色图失败:", error);
+            // 错误处理
+            if (config.humor.longPicWarning) {
+                return `<image url="${config.humor.longPicAddress}"/>`;
+            }
+            else if (error.code === "EHOSTUNREACH") {
+                return "与 API 的交互发生问题，请重试指令或排查服务器网络";
+            }
+            else {
+                return session.text(".error", [error.message || "未知错误"]);
+            }
+        }
+    });
+    // 记录初始化信息
+    logger.info("Setu 插件初始化完成");
+}

package/lib/services/api.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "koishi";
+import { Config } from "../types/config";
+import { SetuOptions, LoliconResponse } from "../types/api";
+export declare class SetuService {
+    private ctx;
+    private config;
+    private provider;
+    constructor(ctx: Context, config: Config);
+    private createProvider;
+    getSetu(options: SetuOptions): Promise<LoliconResponse>;
+    getProviderName(): string;
+}

package/lib/services/api.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetuService = void 0;
+const config_1 = require("../types/config");
+const lolicon_1 = require("./providers/lolicon");
+const custom_1 = require("./providers/custom");
+const nekobot_1 = require("./providers/nekobot");
+class SetuService {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.provider = this.createProvider(this.config);
+    }
+    createProvider(config) {
+        if ((0, config_1.isLoliconConfig)(config)) {
+            return new lolicon_1.LoliconProvider(config.lolicon.apiUrl, config.lolicon.allowR18);
+        }
+        else if ((0, config_1.isCustomConfig)(config)) {
+            return new custom_1.CustomProvider(config.custom.apiUrl);
+        }
+        else if ((0, config_1.isNekobotConfig)(config)) {
+            return new nekobot_1.NekobotProvider(config.nekobot.apiUrl, config.nekobot.defaultTag, this.ctx);
+        }
+        else {
+            throw new Error("未选择 API 提供商");
+        }
+    }
+    async getSetu(options) {
+        try {
+            return await this.provider.getSetu(options);
+        }
+        catch (error) {
+            const logger = this.ctx.logger("setu");
+            logger.error(`获取色图失败:`, error);
+            throw error;
+        }
+    }
+    getProviderName() {
+        return this.provider.name;
+    }
+}
+exports.SetuService = SetuService;

package/lib/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api";
+export * from "./providers";

package/lib/services/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./providers"), exports);

package/lib/services/providers/custom.d.ts

@@ -0,0 +1,7 @@
+import { ApiProvider, SetuOptions, LoliconResponse } from "../../types/api";
+export declare class CustomProvider implements ApiProvider {
+    private apiUrl;
+    readonly name = "custom";
+    constructor(apiUrl: string);
+    getSetu(options: SetuOptions): Promise<LoliconResponse>;
+}

package/lib/services/providers/custom.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomProvider = void 0;
+class CustomProvider {
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+        this.name = "custom";
+    }
+    async getSetu(options) {
+        // 自定义 API 的实现
+        // 这里需要根据具体的自定义 API 规范来实现
+        // 目前只是一个占位实现
+        throw new Error("自定义 API 尚未实现");
+    }
+}
+exports.CustomProvider = CustomProvider;

package/lib/services/providers/factory.d.ts

@@ -0,0 +1,3 @@
+import { Config } from '../../types/config';
+import { ApiProvider } from '../../types/api';
+export declare function createApiProvider(config: Config): ApiProvider;

package/lib/services/providers/factory.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiProvider = createApiProvider;
+const lolicon_1 = require("./lolicon");
+const custom_1 = require("./custom");
+function createApiProvider(config) {
+    switch (config.provider) {
+        case 'lolicon':
+            const loliconUrl = config.imageConfig.loliconApiUrl || 'https://api.lolicon.app/setu/v2';
+            return new lolicon_1.LoliconProvider(loliconUrl);
+        case 'custom':
+            const customUrl = config.imageConfig.customApiUrl;
+            if (!customUrl) {
+                throw new Error('自定义 API 地址未配置');
+            }
+            return new custom_1.CustomProvider(customUrl, config.imageConfig.customApiProxy);
+        default:
+            throw new Error(`未知的 API 提供商: ${config.provider}`);
+    }
+}

package/lib/services/providers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./lolicon";
+export * from "./custom";
+export * from "./nekobot";

package/lib/services/providers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lolicon"), exports);
+__exportStar(require("./custom"), exports);
+__exportStar(require("./nekobot"), exports);

package/lib/services/providers/lolicon.d.ts

@@ -0,0 +1,8 @@
+import { ApiProvider, SetuOptions, LoliconResponse } from "../../types/api";
+export declare class LoliconProvider implements ApiProvider {
+    private apiUrl;
+    private allowR18;
+    readonly name = "lolicon";
+    constructor(apiUrl: string, allowR18: boolean);
+    getSetu(options: SetuOptions): Promise<LoliconResponse>;
+}

package/lib/services/providers/lolicon.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoliconProvider = void 0;
+class LoliconProvider {
+    constructor(apiUrl, allowR18) {
+        this.apiUrl = apiUrl;
+        this.allowR18 = allowR18;
+        this.name = "lolicon";
+    }
+    async getSetu(options) {
+        // 检查 R18 请求是否被允许
+        if (options.r18 && options.r18 > 0 && !this.allowR18) {
+            return {
+                error: "未开启 R18 内容功能，无法获取限制级色图",
+                data: [],
+            };
+        }
+        const response = await fetch(this.apiUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                r18: options.r18 || 0,
+                num: options.num || 1,
+                size: options.size || "regular",
+                proxy: options.proxy,
+                author: options.author,
+                excludeAI: options.excludeAI,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return await response.json();
+    }
+}
+exports.LoliconProvider = LoliconProvider;

package/lib/services/providers/nekobot.d.ts

@@ -0,0 +1,10 @@
+import { ApiProvider, SetuOptions, LoliconResponse } from "../../types/api";
+import { Context } from "koishi";
+export declare class NekobotProvider implements ApiProvider {
+    private apiUrl;
+    private defaultTag;
+    private ctx;
+    readonly name = "nekobot";
+    constructor(apiUrl: string, defaultTag: string, ctx: Context);
+    getSetu(options: SetuOptions): Promise<LoliconResponse>;
+}

package/lib/services/providers/nekobot.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NekobotProvider = void 0;
+class NekobotProvider {
+    constructor(apiUrl, defaultTag, ctx) {
+        this.apiUrl = apiUrl;
+        this.defaultTag = defaultTag;
+        this.ctx = ctx;
+        this.name = "nekobot";
+    }
+    async getSetu(options) {
+        // Nekobot API 只支持 -t 参数，支持多标签（空格分隔）
+        const tags = options.tags && options.tags.length > 0
+            ? options.tags.join(" ")
+            : this.defaultTag;
+        const apiUrl = `${this.apiUrl}?type=${encodeURIComponent(tags)}`;
+        try {
+            const data = await this.ctx.http.get(apiUrl);
+            // Nekobot API 返回的数据结构：{ success: true, message: 'https://...' }
+            if (!data.success || !data.message) {
+                return {
+                    error: "获取图片失败：API 返回数据异常",
+                    data: [],
+                };
+            }
+            return {
+                data: [
+                    {
+                        pid: 0,
+                        p: 0,
+                        uid: 0,
+                        title: "",
+                        author: "",
+                        url: data.message,
+                        r18: false,
+                        width: 0,
+                        height: 0,
+                        tags: [tags],
+                        ext: "jpg",
+                        aiType: 0,
+                        uploadDate: 0,
+                        urls: {
+                            original: data.message,
+                            regular: data.message,
+                            small: data.message,
+                            thumb: data.message,
+                            mini: data.message,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : "未知错误",
+                data: [],
+            };
+        }
+    }
+}
+exports.NekobotProvider = NekobotProvider;

package/lib/types/api.d.ts

@@ -0,0 +1,39 @@
+export interface SetuData {
+    pid: number;
+    p: number;
+    uid: number;
+    title: string;
+    author: string;
+    url: string;
+    r18: boolean;
+    width: number;
+    height: number;
+    tags: string[];
+    ext: string;
+    aiType: number;
+    uploadDate: number;
+    urls: {
+        original: string;
+        regular: string;
+        small: string;
+        thumb: string;
+        mini: string;
+    };
+}
+export interface LoliconResponse {
+    error?: string;
+    data: SetuData[];
+}
+export interface ApiProvider {
+    name: string;
+    getSetu(options: SetuOptions): Promise<LoliconResponse>;
+}
+export interface SetuOptions {
+    r18?: number;
+    num?: number;
+    size?: "original" | "regular" | "small" | "thumb" | "mini";
+    proxy?: string;
+    author?: number;
+    excludeAI?: boolean;
+    tags?: string[];
+}

package/lib/types/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/config.d.ts

@@ -0,0 +1,159 @@
+import { Schema } from "koishi";
+export type ApiProviderType = "lolicon" | "custom" | "nekobot";
+export interface Config {
+    provider: "lolicon" | "custom" | "nekobot";
+    common: {
+        maxUsage: number;
+    };
+    lolicon: {
+        allowR18: boolean;
+        apiUrl: string;
+        defaultPicSize: "original" | "regular" | "small" | "thumb" | "mini";
+    };
+    custom: {
+        apiUrl: string;
+    };
+    nekobot: {
+        apiUrl: string;
+        defaultTag: string;
+        notice: string;
+    };
+    behavior: {
+        useFigure: boolean;
+        replyNumber: number;
+    };
+    humor: {
+        longPicWarning: boolean;
+        longPicAddress: string;
+    };
+}
+export interface CommandOptions {
+    maxUsage?: number;
+}
+export declare function isLoliconConfig(config: Config): config is Config & {
+    provider: "lolicon";
+    lolicon: {
+        allowR18: boolean;
+        apiUrl: string;
+        defaultPicSize: "original" | "regular" | "small" | "thumb" | "mini";
+    };
+};
+export declare function isCustomConfig(config: Config): config is Config & {
+    provider: "custom";
+    custom: {
+        apiUrl: string;
+    };
+};
+export declare function isNekobotConfig(config: Config): config is Config & {
+    provider: "nekobot";
+    nekobot: {
+        apiUrl: string;
+        defaultTag: string;
+        notice: string;
+    };
+};
+export declare function hasValidConfig(config: Config): boolean;
+export declare const APIParameterSupport: {
+    lolicon: {
+        name: string;
+        supportedParams: string[];
+    };
+    nekobot: {
+        name: string;
+        supportedParams: string[];
+    };
+    custom: {
+        name: string;
+        supportedParams: any[];
+    };
+};
+export declare function validateParameters(provider: string, options: any): string | null;
+export declare const ConfigSchema: Schema<Schemastery.ObjectS<{
+    provider: Schema<"lolicon" | "nekobot" | "custom", "lolicon" | "nekobot" | "custom">;
+    common: Schema<Schemastery.ObjectS<{
+        maxUsage: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        maxUsage: Schema<number, number>;
+    }>>;
+    lolicon: Schema<Schemastery.ObjectS<{
+        allowR18: Schema<boolean, boolean>;
+        apiUrl: Schema<string, string>;
+        defaultPicSize: Schema<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>, Schemastery.ObjectT<{
+        allowR18: Schema<boolean, boolean>;
+        apiUrl: Schema<string, string>;
+        defaultPicSize: Schema<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>>;
+    nekobot: Schema<Schemastery.ObjectS<{
+        apiUrl: Schema<string, string>;
+        defaultTag: Schema<string, string>;
+        notice: Schema<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: Schema<string, string>;
+        defaultTag: Schema<string, string>;
+        notice: Schema<string, string>;
+    }>>;
+    custom: Schema<Schemastery.ObjectS<{
+        apiUrl: Schema<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: Schema<string, string>;
+    }>>;
+    behavior: Schema<Schemastery.ObjectS<{
+        useFigure: Schema<boolean, boolean>;
+        replyNumber: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        useFigure: Schema<boolean, boolean>;
+        replyNumber: Schema<number, number>;
+    }>>;
+    humor: Schema<Schemastery.ObjectS<{
+        longPicWarning: Schema<boolean, boolean>;
+        longPicAddress: Schema<string, string>;
+    }>, Schemastery.ObjectT<{
+        longPicWarning: Schema<boolean, boolean>;
+        longPicAddress: Schema<string, string>;
+    }>>;
+}>, Schemastery.ObjectT<{
+    provider: Schema<"lolicon" | "nekobot" | "custom", "lolicon" | "nekobot" | "custom">;
+    common: Schema<Schemastery.ObjectS<{
+        maxUsage: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        maxUsage: Schema<number, number>;
+    }>>;
+    lolicon: Schema<Schemastery.ObjectS<{
+        allowR18: Schema<boolean, boolean>;
+        apiUrl: Schema<string, string>;
+        defaultPicSize: Schema<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>, Schemastery.ObjectT<{
+        allowR18: Schema<boolean, boolean>;
+        apiUrl: Schema<string, string>;
+        defaultPicSize: Schema<"original" | "regular" | "small" | "thumb" | "mini", "original" | "regular" | "small" | "thumb" | "mini">;
+    }>>;
+    nekobot: Schema<Schemastery.ObjectS<{
+        apiUrl: Schema<string, string>;
+        defaultTag: Schema<string, string>;
+        notice: Schema<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: Schema<string, string>;
+        defaultTag: Schema<string, string>;
+        notice: Schema<string, string>;
+    }>>;
+    custom: Schema<Schemastery.ObjectS<{
+        apiUrl: Schema<string, string>;
+    }>, Schemastery.ObjectT<{
+        apiUrl: Schema<string, string>;
+    }>>;
+    behavior: Schema<Schemastery.ObjectS<{
+        useFigure: Schema<boolean, boolean>;
+        replyNumber: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        useFigure: Schema<boolean, boolean>;
+        replyNumber: Schema<number, number>;
+    }>>;
+    humor: Schema<Schemastery.ObjectS<{
+        longPicWarning: Schema<boolean, boolean>;
+        longPicAddress: Schema<string, string>;
+    }>, Schemastery.ObjectT<{
+        longPicWarning: Schema<boolean, boolean>;
+        longPicAddress: Schema<string, string>;
+    }>>;
+}>>;

package/lib/types/config.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigSchema = exports.APIParameterSupport = void 0;
+exports.isLoliconConfig = isLoliconConfig;
+exports.isCustomConfig = isCustomConfig;
+exports.isNekobotConfig = isNekobotConfig;
+exports.hasValidConfig = hasValidConfig;
+exports.validateParameters = validateParameters;
+const koishi_1 = require("koishi");
+function isLoliconConfig(config) {
+    return config.provider === "lolicon";
+}
+function isCustomConfig(config) {
+    return config.provider === "custom";
+}
+function isNekobotConfig(config) {
+    return config.provider === "nekobot";
+}
+function hasValidConfig(config) {
+    if (config.provider === "lolicon") {
+        return !!config.lolicon?.apiUrl;
+    }
+    else if (config.provider === "custom") {
+        return !!config.custom?.apiUrl;
+    }
+    else if (config.provider === "nekobot") {
+        return !!config.nekobot?.apiUrl;
+    }
+    return false;
+}
+// 定义每个 API 支持的参数
+exports.APIParameterSupport = {
+    lolicon: {
+        name: "Lolicon API",
+        supportedParams: ["size", "r18", "num", "author", "excludeAI"],
+    },
+    nekobot: {
+        name: "Nekobot API",
+        supportedParams: ["tags"],
+    },
+    custom: {
+        name: "自定义 API",
+        supportedParams: [], // 自定义 API 由用户自己决定
+    },
+};
+function validateParameters(provider, options) {
+    // 自定义 API 禁用所有参数
+    if (provider === "custom") {
+        const unsupportedParams = [];
+        if (options._tags)
+            unsupportedParams.push("-t/--tags");
+        if (options._author)
+            unsupportedParams.push("-a/--author");
+        if (options._excludeAI)
+            unsupportedParams.push("-A/--excludeAI");
+        if (options._size)
+            unsupportedParams.push("-s/--size");
+        if (options._r18)
+            unsupportedParams.push("-r/--r18");
+        if (unsupportedParams.length > 0) {
+            return `（自定义 API）该接口不支持任何参数，请勿使用：${unsupportedParams.join(", ")}`;
+        }
+        return null;
+    }
+    const support = exports.APIParameterSupport[provider];
+    if (!support)
+        return null;
+    const unsupportedParams = [];
+    // 检查所有选项参数（只有明确输入的参数才验证，前缀_表示用户输入）
+    if (options._tags && provider !== "nekobot") {
+        unsupportedParams.push("-t/--tags");
+    }
+    if (options._author && provider === "nekobot") {
+        unsupportedParams.push("-a/--author");
+    }
+    if (options._excludeAI && provider === "nekobot") {
+        unsupportedParams.push("-A/--excludeAI");
+    }
+    if (options._size && provider === "nekobot") {
+        unsupportedParams.push("-s/--size");
+    }
+    if (options._r18 && provider === "nekobot") {
+        unsupportedParams.push("-r/--r18");
+    }
+    if (unsupportedParams.length > 0) {
+        return `（${support.name}）该接口不支持的参数：${unsupportedParams.join(", ")}`;
+    }
+    return null;
+}
+// 完整配置 Schema
+exports.ConfigSchema = koishi_1.Schema.object({
+    // 基础设置
+    provider: koishi_1.Schema.union([
+        koishi_1.Schema.const("lolicon").description("Lolicon API"),
+        koishi_1.Schema.const("nekobot").description("Nekobot API"),
+        koishi_1.Schema.const("custom").description("自定义 API"),
+    ])
+        .default("lolicon")
+        .description("API 提供商"),
+    // 通用参数
+    common: koishi_1.Schema.object({
+        maxUsage: koishi_1.Schema.number()
+            .default(10)
+            .step(1)
+            .description("单日个人使用次数限制"),
+    }).description("通用参数"),
+    // Lolicon 专用参数
+    lolicon: koishi_1.Schema.object({
+        allowR18: koishi_1.Schema.boolean()
+            .default(false)
+            .description("是否允许 R18 内容（请谨慎使用）"),
+        apiUrl: koishi_1.Schema.string()
+            .role("link")
+            .default("https://api.lolicon.app/setu/v2")
+            .description("API 地址"),
+        defaultPicSize: koishi_1.Schema.union([
+            koishi_1.Schema.const("original").description("原图（不推荐）"),
+            koishi_1.Schema.const("regular").description("普通"),
+            koishi_1.Schema.const("small").description("小图"),
+            koishi_1.Schema.const("thumb").description("极小图"),
+            koishi_1.Schema.const("mini").description("迷你图"),
+        ])
+            .description("默认图片大小")
+            .default("regular"),
+    }).description("Lolicon 参数"),
+    // Nekobot 专用参数
+    nekobot: koishi_1.Schema.object({
+        apiUrl: koishi_1.Schema.string()
+            .role("link")
+            .default("https://nekobot.xyz/api/image")
+            .description("API 地址"),
+        defaultTag: koishi_1.Schema.string()
+            .default("neko")
+            .description("默认标签（如果没有指定 -t 参数）"),
+        notice: koishi_1.Schema.string()
+            .default("")
+            .description("⚠️ 警告：本接口没有对限制级色图进行限制，用户可能会请求到限制级色图"),
+    }).description("Nekobot 参数"),
+    // 自定义 API 参数
+    custom: koishi_1.Schema.object({
+        apiUrl: koishi_1.Schema.string()
+            .role("link")
+            .default("")
+            .description("自定义 API 地址"),
+    }).description("自定义 API 参数"),
+    // 机器人行为
+    behavior: koishi_1.Schema.object({
+        useFigure: koishi_1.Schema.boolean()
+            .default(false)
+            .description("使用集合回复（解决部分平台发图问题）"),
+        replyNumber: koishi_1.Schema.number()
+            .default(1)
+            .max(10)
+            .min(1)
+            .step(1)
+            .description("一次请求的图片数量（1-10）"),
+    }).description("机器人行为"),
+    // 幽默
+    humor: koishi_1.Schema.object({
+        longPicWarning: koishi_1.Schema.boolean()
+            .default(false)
+            .description("启用错误提示龙图"),
+        longPicAddress: koishi_1.Schema.string()
+            .default("https://raw.githubusercontent.com/chitsanfei/koishi-plugin-setu/master/assets/long.jpg")
+            .description("龙图图片地址"),
+    }).description("幽默"),
+});

package/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./message";
+export * from "./validation";

package/lib/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message"), exports);
+__exportStar(require("./validation"), exports);

package/lib/utils/message.d.ts

@@ -0,0 +1,5 @@
+import { Session } from "koishi";
+import { SetuData } from "../types/api";
+export declare function createFigureMessage(session: Session, setuData: SetuData[], size: string): any;
+export declare function createImageMessage(setuData: SetuData[], size: string): string;
+export declare function formatSetuInfo(data: SetuData): string;

package/lib/utils/message.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFigureMessage = createFigureMessage;
+exports.createImageMessage = createImageMessage;
+exports.formatSetuInfo = formatSetuInfo;
+const koishi_1 = require("koishi");
+function createFigureMessage(session, setuData, size) {
+    const attrs = {
+        userId: session.userId,
+        nickname: session.author?.nickname || session.username,
+    };
+    const result = (0, koishi_1.h)("figure");
+    for (const data of setuData) {
+        result.children.push((0, koishi_1.h)("message", attrs, String(data.pid)));
+        result.children.push((0, koishi_1.h)("image", { url: data.urls[size] }));
+    }
+    return result;
+}
+function createImageMessage(setuData, size) {
+    let reply = "";
+    for (const data of setuData) {
+        reply += `<image url="${data.urls[size]}"/>`;
+    }
+    return reply;
+}
+function formatSetuInfo(data) {
+    return `标题: ${data.title}\n作者: ${data.author}\nPID: ${data.pid}\n标签: ${data.tags.join(", ")}`;
+}

package/lib/utils/validation.d.ts

@@ -0,0 +1,3 @@
+export declare function validatePicSize(size: string): size is "original" | "regular" | "small" | "thumb" | "mini";
+export declare function validateReplyNumber(num: number): boolean;
+export declare function validateR18Value(r18: number | undefined, allowR18: boolean): number;

package/lib/utils/validation.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePicSize = validatePicSize;
+exports.validateReplyNumber = validateReplyNumber;
+exports.validateR18Value = validateR18Value;
+function validatePicSize(size) {
+    return ["original", "regular", "small", "thumb", "mini"].includes(size);
+}
+function validateReplyNumber(num) {
+    return num >= 1 && num <= 10;
+}
+function validateR18Value(r18, allowR18) {
+    if (!allowR18)
+        return 0;
+    return r18 || 0;
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@nenekusanagi/koishi-plugin-setu",
+  "description": "A simple setu program powered by Koishi.",
+  "version": "1.1.0",
+  "contributors": [
+    "NeneKusanagi <nenekusa.sekai@gmail.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chitsanfei/koishi-plugin-setu.git"
+  },
+  "koishi": {
+    "description": {
+      "en": "Funny anime image plugin based on the previous work.",
+      "zh": "基于前人做了小修改的好玩的图片插件。"
+    },
+    "locales": [
+      "zh"
+    ]
+  },
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "koishi dev",
+    "build": "tsc",
+    "start": "koishi start",
+    "test": "echo \"No tests yet\"",
+    "pre-commit": "lint-staged",
+    "format": "prettier --write \"**/*.{ts,js,json,md,yml,yaml}\"",
+    "lint": "prettier --check \"**/*.{ts,js,json,md,yml,yaml}\""
+  },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "prettier --write",
+      "git add"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "typescript": "^5.3.0"
+  },
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.12.2"
+  },
+  "dependencies": {
+    "@nenekusanagi/koishi-plugin-setu": "file:"
+  }
+}