koishi-plugin-chatluna-character 0.0.30

package/lib/index.d.ts

@@ -0,0 +1,29 @@
+import { Context, Logger, Schema } from 'koishi';
+import { ChatLunaPlugin } from 'koishi-plugin-chatluna/lib/services/chat';
+import { MessageCollector } from './service/message';
+import { StickerService } from './service/sticker';
+import { Preset } from './preset';
+export declare let service: MessageCollector;
+export declare let stickerService: StickerService;
+export declare let preset: Preset;
+export declare let logger: Logger;
+export declare function apply(ctx: Context, config: Config): void;
+export interface Config extends ChatLunaPlugin.Config {
+    model: string;
+    maxMessages: number;
+    messageInterval: number;
+    checkPromptInject: boolean;
+    maxTokens: number;
+    applyGroup: string[];
+    defaultPreset: string;
+    isNickname: boolean;
+    isForceMute: boolean;
+    sendStickerProbability: number;
+    coolDownTime: number;
+    typingTime: number;
+    muteTime: number;
+    disableChatHub: boolean;
+}
+export declare const Config: Schema<Config>;
+export declare const inject: string[];
+export declare const name = "chatluna-character";

package/lib/index.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.name = exports.inject = exports.Config = exports.apply = exports.logger = exports.preset = exports.stickerService = exports.service = void 0;
+/* eslint-disable max-len */
+const koishi_1 = require("koishi");
+const plugin_1 = require("./plugin");
+const message_1 = require("./service/message");
+const sticker_1 = require("./service/sticker");
+const preset_1 = require("./preset");
+const logger_1 = require("koishi-plugin-chatluna/lib/utils/logger");
+function apply(ctx, config) {
+    exports.logger = (0, logger_1.createLogger)(ctx, 'chathub-character');
+    ctx.on('ready', async () => {
+        exports.service = new message_1.MessageCollector(config);
+        exports.stickerService = new sticker_1.StickerService(ctx, config);
+        exports.preset = new preset_1.Preset(ctx);
+        await exports.stickerService.init();
+        await exports.preset.loadAllPreset();
+        await (0, plugin_1.plugins)(ctx, config);
+    });
+    ctx.on('message', async (session) => {
+        if (!exports.service) {
+            return;
+        }
+        if (!session.isDirect &&
+            config.applyGroup.some((group) => group === session.guildId)) {
+            await exports.service.broadcast(session);
+        }
+    });
+    ctx.on('dispose', async () => {
+        exports.service = null;
+        exports.stickerService = null;
+        exports.preset = null;
+    });
+}
+exports.apply = apply;
+exports.Config = koishi_1.Schema.intersect([
+    koishi_1.Schema.object({
+        applyGroup: koishi_1.Schema.array(koishi_1.Schema.string()).description('应用到的群组'),
+        maxMessages: koishi_1.Schema.number()
+            .description('存储在内存里的最大消息数量')
+            .default(10)
+            .min(7)
+            .role('slider')
+            .max(40),
+        disableChatHub: koishi_1.Schema.boolean()
+            .default(true)
+            .description('在使用此插件时，是否禁用 chathub 的功能')
+    }).description('基础配置'),
+    koishi_1.Schema.object({
+        model: koishi_1.Schema.dynamic('model').description('使用的模型'),
+        maxTokens: koishi_1.Schema.number()
+            .default(2048)
+            .min(1024)
+            .max(8072)
+            .description('使用聊天的最大 token 数')
+    }).description('模型配置'),
+    koishi_1.Schema.object({
+        isNickname: koishi_1.Schema.boolean()
+            .description('允许 bot 配置中的昵称引发回复')
+            .default(true),
+        isForceMute: koishi_1.Schema.boolean()
+            .description('是否启用强制禁言（当聊天涉及到关键词时则会禁言，关键词需要在预设文件里配置）')
+            .default(true),
+        messageInterval: koishi_1.Schema.number()
+            .default(14)
+            .min(0)
+            .role('slider')
+            .max(30)
+            .description('随机发送消息的间隔'),
+        coolDownTime: koishi_1.Schema.number()
+            .default(10)
+            .min(1)
+            .max(60 * 24)
+            .description('冷却发言时间（秒）'),
+        typingTime: koishi_1.Schema.number()
+            .default(440)
+            .min(100)
+            .role('slider')
+            .max(1000)
+            .description('模拟打字时的间隔（毫秒）'),
+        muteTime: koishi_1.Schema.number()
+            .default(1000 * 60)
+            .min(1000)
+            .max(1000 * 60 * 10 * 10)
+            .description('闭嘴时的禁言时间（毫秒）'),
+        sendStickerProbability: koishi_1.Schema.number()
+            .default(0.6)
+            .min(0)
+            .max(1)
+            .role('slider')
+            .step(0.01)
+            .description('发送表情的概率')
+    }).description('对话设置'),
+    koishi_1.Schema.object({
+        defaultPreset: koishi_1.Schema.dynamic('character-preset')
+            .description('使用的伪装预设')
+            .default('旧梦旧念')
+    })
+]);
+exports.inject = ['chatluna'];
+exports.name = 'chatluna-character';

package/lib/plugin.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+import { Config } from '.';
+export declare function plugins(ctx: Context, config: Config): Promise<void>;

package/lib/plugin.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugins = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+async function plugins(ctx, config) {
+    const list = await promises_1.default.readdir(path_1.default.join(__dirname, 'plugins'));
+    for (const file of list) {
+        if (file.endsWith('.d.ts')) {
+            continue;
+        }
+        const command = await require(`./plugins/${file}`);
+        if (command.apply) {
+            await command.apply(ctx, config);
+        }
+    }
+}
+exports.plugins = plugins;

package/lib/plugins/chat.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+import { Config } from '..';
+export declare function apply(ctx: Context, config: Config): Promise<void>;

package/lib/plugins/chat.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply = void 0;
+const koishi_1 = require("koishi");
+const __1 = require("..");
+const count_tokens_1 = require("koishi-plugin-chatluna/lib/llm-core/utils/count_tokens");
+const schema_1 = require("langchain/schema");
+async function apply(ctx, config) {
+    const [platform, modelName] = (0, count_tokens_1.parseRawModelName)(config.model);
+    const model = (await ctx.chatluna.createChatModel(platform, modelName));
+    const selectedPreset = await __1.preset.getPreset(config.defaultPreset);
+    const systemPrompt = selectedPreset.system;
+    const completionPrompt = selectedPreset.input;
+    __1.service.collect(async (session, messages) => {
+        const [recentMessage, lastMessage] = await formatMessage(messages, config, model, systemPrompt.template, completionPrompt.template);
+        const temp = await __1.service.getTemp(session);
+        const formattedSystemPrompt = await systemPrompt.format({
+            time: new Date().toLocaleString()
+        });
+        __1.logger.debug('messages_new: ' + JSON.stringify(recentMessage));
+        __1.logger.debug('messages_last: ' + JSON.stringify(lastMessage));
+        const humanMessage = new schema_1.HumanMessage(await completionPrompt.format({
+            history_new: recentMessage,
+            history_last: lastMessage,
+            time: new Date().toLocaleString()
+        }));
+        const completionMessages = await formatCompletionMessages([new schema_1.SystemMessage(formattedSystemPrompt)].concat(temp.completionMessages), humanMessage, config, model);
+        __1.logger.debug('completion message: ' +
+            JSON.stringify(completionMessages.map((it) => it.content)));
+        let responseMessage;
+        for (let i = 0; i < 3; i++) {
+            try {
+                responseMessage = await model.call(completionMessages);
+                break;
+            }
+            catch (e) {
+                __1.logger.error(e);
+                await (0, koishi_1.sleep)(2000);
+                continue;
+            }
+        }
+        __1.logger.debug('model response: ' + responseMessage.content);
+        const response = parseResponse(responseMessage.content);
+        temp.completionMessages.push(humanMessage, responseMessage);
+        if (temp.completionMessages.length > 30) {
+            while (temp.completionMessages.length <= 30) {
+                temp.completionMessages.shift();
+            }
+        }
+        if (response.length < 1) {
+            __1.service.mute(session, config.muteTime);
+            return;
+        }
+        const random = new koishi_1.Random();
+        for (const elements of response) {
+            const text = elements
+                .map((element) => element.attrs.content ?? '')
+                .join('');
+            const maxTime = text.length * config.typingTime + 100;
+            await (0, koishi_1.sleep)(random.int(maxTime / 2, maxTime));
+            session.send(elements);
+        }
+        const sticker = await __1.stickerService.randomStick();
+        if (sticker) {
+            session.send(sticker);
+        }
+        __1.service.mute(session, config.coolDownTime * 1000);
+        __1.service.broadcastOnBot(session, response.flat());
+    });
+}
+exports.apply = apply;
+function parseResponse(response) {
+    let message;
+    try {
+        const match = response.matchAll(/\[.*?\]/g);
+        message = [...match].pop()?.[0] ?? '';
+        __1.logger.debug('message: ' + message);
+        message = message.match(/\[.*(:|：).*(:|：)(.*)\]/)?.[3] ?? '';
+        message = message.match(/"(.*)"/)?.[1] ?? message;
+        __1.logger.debug('message: ' + message);
+        if (typeof message !== 'string') {
+            __1.logger.error('Failed to parse response: ' + response);
+            return [];
+        }
+    }
+    catch (e) {
+        __1.logger.error(e);
+        __1.logger.error('Failed to parse response: ' + response);
+        return [];
+    }
+    const resultElements = [];
+    const currentElements = [];
+    // match [at:name:id] -> id
+    const atMatch = matchAt(message);
+    __1.logger.debug('atMatch: ' + JSON.stringify(atMatch));
+    if (atMatch.length > 0) {
+        let lastAtIndex = 0;
+        for (const at of atMatch) {
+            const before = message.substring(lastAtIndex, at.start);
+            if (before.length > 0) {
+                currentElements.push(koishi_1.h.text(before));
+            }
+            currentElements.push(koishi_1.h.at(at.at));
+            lastAtIndex = at.end;
+        }
+        const after = message.substring(lastAtIndex);
+        if (after.length > 0) {
+            currentElements.push(koishi_1.h.text(after));
+        }
+    }
+    else {
+        currentElements.push(koishi_1.h.text(message));
+    }
+    for (let currentElement of currentElements) {
+        if (currentElement.type === 'text') {
+            const text = currentElement.attrs.content;
+            const matchArray = splitSentence(text).filter((x) => x.length > 0);
+            for (const match of matchArray) {
+                currentElement = koishi_1.h.text(match);
+                resultElements.push([currentElement]);
+            }
+        }
+        else {
+            resultElements.push([currentElement]);
+        }
+    }
+    if (resultElements[0]?.[0]?.type === 'at') {
+        resultElements[1].unshift(koishi_1.h.text(' '));
+        resultElements[1].unshift(resultElements[0][0]);
+        resultElements.shift();
+    }
+    return resultElements;
+}
+function splitSentence(text) {
+    const result = [];
+    const lines = text
+        .split('\n')
+        .filter((line) => line.trim().length > 0)
+        .join(' ');
+    const state = {
+        bracket: 0,
+        text: 0
+    };
+    let current = '';
+    const punctuations = [
+        '，',
+        '。',
+        '？',
+        '！',
+        '；',
+        '：',
+        ',',
+        '?',
+        '!',
+        ';',
+        ':',
+        '、',
+        '~',
+        '—',
+        '\r'
+    ];
+    const retainPunctuations = ['?', '!', '？', '！', '~'];
+    const mustPunctuations = ['。', '?', '！', '?', '！', ':', '：', '~'];
+    const brackets = ['【', '】', '《', '》', '(', ')', '（', '）'];
+    for (let index = 0; index < lines.length; index++) {
+        const char = lines[index];
+        const nextChar = lines?.[index + 1];
+        const indexOfBrackets = brackets.indexOf(char);
+        if (indexOfBrackets > -1) {
+            state.bracket += indexOfBrackets % 2 === 0 ? 1 : -1;
+        }
+        if (indexOfBrackets > -1 && state.bracket === 0 && state.text > 0) {
+            current += char;
+            result.push(current);
+            state.text = 0;
+            current = '';
+            continue;
+        }
+        else if (indexOfBrackets % 2 === 0 && state.bracket === 1) {
+            result.push(current);
+            state.text = 0;
+            current = char;
+            continue;
+        }
+        else if (state.bracket > 0) {
+            current += char;
+            state.text++;
+            continue;
+        }
+        if (!punctuations.includes(char)) {
+            current += char;
+            continue;
+        }
+        if (retainPunctuations.includes(char)) {
+            current += char;
+        }
+        if (retainPunctuations.indexOf(nextChar) % 2 === 0 &&
+            retainPunctuations.indexOf(char) % 2 === 1) {
+            index += 1;
+        }
+        if (current.length < 1) {
+            continue;
+        }
+        if (current.length > 2 || mustPunctuations.includes(char)) {
+            result.push(current.trimStart().trimEnd());
+            current = '';
+        }
+        else if (!retainPunctuations.includes(char)) {
+            current += char;
+        }
+    }
+    if (current.length > 0) {
+        result.push(current.trimStart().trimEnd());
+    }
+    return result.filter((item) => punctuations.indexOf(item) === -1);
+}
+function matchAt(str) {
+    // (旧梦旧念:3510003509:<at>)
+    // /\(.*\-(\d+)\-<at>\)/g
+    const atRegex = /(\(|（).*\-(\d+)\-<at>(\)|）)/g;
+    return [...str.matchAll(atRegex)].map((item) => {
+        return {
+            at: item[2],
+            start: item.index,
+            end: item.index + item[0].length
+        };
+    });
+}
+async function formatCompletionMessages(messages, humanMessage, config, model) {
+    const maxTokens = config.maxTokens - 600;
+    const systemMessage = messages.shift();
+    let currentTokens = 0;
+    currentTokens += await model.getNumTokens(systemMessage.content);
+    currentTokens += await model.getNumTokens(humanMessage.content);
+    const result = [];
+    result.unshift(humanMessage);
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        const messageTokens = await model.getNumTokens(message.content);
+        if (currentTokens + messageTokens > maxTokens) {
+            break;
+        }
+        currentTokens += messageTokens;
+        result.unshift(message);
+    }
+    __1.logger.debug(`maxTokens: ${maxTokens}, currentTokens: ${currentTokens}`);
+    result.unshift(systemMessage);
+    return result;
+}
+async function formatMessage(messages, config, model, systemPrompt, historyPrompt) {
+    const maxTokens = config.maxTokens - 300;
+    let currentTokens = 0;
+    currentTokens += await model.getNumTokens(systemPrompt);
+    currentTokens += await model.getNumTokens(historyPrompt);
+    const calculatedMessages = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        const jsonMessage = `[${message.name}:${message.id}:${JSON.stringify(message.content)}]"`;
+        const jsonMessageToken = await model.getNumTokens(jsonMessage);
+        if (currentTokens + jsonMessageToken > maxTokens - 4) {
+            break;
+        }
+        currentTokens += jsonMessageToken;
+        calculatedMessages.unshift(jsonMessage);
+    }
+    const lastMessage = calculatedMessages.pop();
+    return [calculatedMessages, lastMessage];
+}

package/lib/plugins/commands.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+import { Config } from '..';
+export declare function apply(ctx: Context, config: Config): void;

package/lib/plugins/commands.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply = void 0;
+const __1 = require("..");
+const filter_1 = require("./filter");
+function apply(ctx, config) {
+    ctx.command('chathub.character', '角色扮演相关命令');
+    ctx.command('chathub.character.clear [group]', '清除群组的聊天记录').action(async ({ session }, group) => {
+        if (!session.isDirect) {
+            return;
+        }
+        const groupId = group ?? session.guildId;
+        if (!groupId) {
+            return '请检查你是否提供了群组id';
+        }
+        const groupInfo = filter_1.groupInfos[groupId];
+        if (!groupInfo) {
+            return '没有找到群组信息';
+        }
+        groupInfo.messageCount = 0;
+        groupInfo.messageSendProbability = 0;
+        __1.service.clear(groupId);
+        return `已清除群组 ${groupId} 的聊天记录`;
+    });
+}
+exports.apply = apply;

package/lib/plugins/config.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+import { Config } from '..';
+export declare function apply(ctx: Context, config: Config): void;

package/lib/plugins/config.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply = void 0;
+const koishi_1 = require("koishi");
+const types_1 = require("koishi-plugin-chatluna/lib/llm-core/platform/types");
+function apply(ctx, config) {
+    ctx.on('chatluna/model-added', async (service) => {
+        ctx.schema.set('model', koishi_1.Schema.union(await getModelNames(service)));
+    });
+    ctx.on('chatluna/model-removed', async (service) => {
+        ctx.schema.set('model', koishi_1.Schema.union(await getModelNames(service)));
+    });
+}
+exports.apply = apply;
+async function getModelNames(service) {
+    return service.getAllModels(types_1.ModelType.llm).map((m) => koishi_1.Schema.const(m));
+}

package/lib/plugins/filter.d.ts

@@ -0,0 +1,8 @@
+import { Context } from 'koishi';
+import { Config } from '..';
+export declare const groupInfos: Record<string, GroupInfo>;
+export declare function apply(ctx: Context, config: Config): Promise<void>;
+export interface GroupInfo {
+    messageCount: number;
+    messageSendProbability: number;
+}

package/lib/plugins/filter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply = exports.groupInfos = void 0;
+const __1 = require("..");
+exports.groupInfos = {};
+async function apply(ctx, config) {
+    const maxMessages = config.messageInterval;
+    const selectedPreset = await __1.preset.getPreset(config.defaultPreset);
+    __1.service.addFilter((session, message) => {
+        const info = exports.groupInfos[session.guildId] || {
+            messageCount: 0,
+            messageSendProbability: 1
+        };
+        let { messageCount, messageSendProbability } = info;
+        // 在计算之前先检查是否需要禁言。
+        if (config.isForceMute && selectedPreset.mute_keyword?.length > 0) {
+            const needMute = selectedPreset.mute_keyword.some((value) => message.content.includes(value));
+            if (needMute) {
+                __1.logger.debug(`mute content: ${message.content}`);
+                __1.service.mute(session, config.muteTime);
+            }
+        }
+        // 保底必出
+        if ((messageCount > maxMessages ||
+            messageSendProbability > 1 ||
+            session.stripped.appel ||
+            (config.isNickname &&
+                selectedPreset.nick_name.some((value) => message.content.startsWith(value)))) &&
+            !__1.service.isMute(session)) {
+            info.messageCount = 0;
+            info.messageSendProbability = 1;
+            exports.groupInfos[session.guildId] = info;
+            return true;
+        }
+        // 按照概率出
+        if (Math.random() > messageSendProbability &&
+            !__1.service.isMute(session)) {
+            info.messageCount = 0;
+            info.messageSendProbability = 1;
+            exports.groupInfos[session.guildId] = info;
+            return true;
+        }
+        __1.logger.debug(`messageCount: ${messageCount}, messageSendProbability: ${messageSendProbability}. content: ${JSON.stringify(message)}`);
+        messageCount++;
+        messageSendProbability -= (1 / maxMessages) * 0.15;
+        info.messageCount = messageCount;
+        info.messageSendProbability = messageSendProbability;
+        exports.groupInfos[session.guildId] = info;
+        return false;
+    });
+}
+exports.apply = apply;

package/lib/plugins/interception.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+import { Config } from '..';
+export declare function apply(ctx: Context, config: Config): void;

package/lib/plugins/interception.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply = void 0;
+function apply(ctx, config) {
+    ctx.on('chatluna/before-check-sender', async (session) => {
+        return (((session.stripped.appel && !session.isDirect) ||
+            !session.isDirect) &&
+            config.applyGroup.some((group) => group === session.guildId) &&
+            config.disableChatHub);
+    });
+}
+exports.apply = apply;

package/lib/preset.d.ts

@@ -0,0 +1,16 @@
+import { Context } from 'koishi';
+import { PresetTemplate } from './types';
+export declare class Preset {
+    private readonly ctx;
+    private readonly _presets;
+    constructor(ctx: Context);
+    loadAllPreset(): Promise<void>;
+    getPreset(triggerKeyword: string, loadForDisk?: boolean, throwError?: boolean): Promise<PresetTemplate>;
+    getDefaultPreset(): Promise<PresetTemplate>;
+    getAllPreset(): Promise<string[]>;
+    resetDefaultPreset(): Promise<void>;
+    resolvePresetDir(): string;
+    private _checkPresetDir;
+    private _copyDefaultPresets;
+}
+export declare function loadPreset(text: string): PresetTemplate;