mioku-plugin-chat 2.0.0

package/humanize/memory.ts

@@ -0,0 +1,131 @@
+import type { AIInstance } from "mioku";
+import { logger } from "mioki";
+import type { ChatDatabase } from "../db";
+import type { ChatConfig, ChatMessage } from "../types";
+
+export interface MemoryUserHistoryChunk {
+  userId: number;
+  messages: ChatMessage[];
+}
+
+export interface MemoryRecallInput {
+  sessionId: string;
+  question: string;
+  groupHistoryMessages?: ChatMessage[];
+  userHistories?: MemoryUserHistoryChunk[];
+  nowTimestamp?: number;
+}
+
+export class MemoryRetrieval {
+  private ai: AIInstance;
+  private config: ChatConfig;
+  private db: ChatDatabase;
+
+  constructor(ai: AIInstance, config: ChatConfig, db: ChatDatabase) {
+    this.ai = ai;
+    this.config = config;
+    this.db = db;
+  }
+
+  async retrieveByQuestion(input: MemoryRecallInput): Promise<string | null> {
+    if (!this.config.memory?.enabled) return null;
+
+    const question = String(input.question || "").trim();
+    if (!question) return null;
+
+    const nowTs = input.nowTimestamp ?? Date.now();
+    const nowText = this.formatTimestamp(nowTs);
+    const recentContext = this.formatSessionMessages(
+      this.db.getMessages(input.sessionId, 30),
+    );
+    const groupHistory = this.formatGroupHistory(input.groupHistoryMessages || []);
+    const userHistory = this.formatUserHistories(input.userHistories || []);
+
+    try {
+      const result = await this.ai.generateText({
+        prompt: `You are the memory worker model. You receive a recall question from the main chat model.
+Current time: ${nowText}
+
+Recall question:
+${question}
+
+Important:
+- All provided records are historical logs, NOT messages sent just now.
+- Every log already contains its send time/date. Use those timestamps carefully.
+- If evidence is insufficient, clearly say what is missing instead of guessing.
+
+Recent in-context chat snapshot (for orientation only):
+${recentContext}
+
+Group history fetched via message_id pagination (historical):
+${groupHistory}
+
+User history chunks (historical):
+${userHistory}
+
+Output requirements:
+- Give one concise recall result for the main chat model.
+- If useful evidence exists, summarize key facts with timestamps.
+- If no useful memory exists, output exactly: NO_USEFUL_MEMORY_FOUND`,
+        messages: [],
+        model: this.config.workingModel || this.config.model,
+        temperature: 0.2,
+        max_tokens: 700,
+      });
+
+      const text = String(result || "").trim();
+      if (!text || text.includes("NO_USEFUL_MEMORY_FOUND")) {
+        return null;
+      }
+      return text;
+    } catch (err) {
+      logger.warn(`[MemoryRetrieval] Worker retrieval failed: ${err}`);
+      return null;
+    }
+  }
+
+  private formatSessionMessages(messages: ChatMessage[]): string {
+    if (!messages.length) return "(none)";
+    return messages
+      .map((m) => {
+        const name = m.userName || "unknown";
+        return `[历史消息 | ${this.formatTimestamp(m.timestamp)}] ${name}: ${m.content}（不是刚刚发送）`;
+      })
+      .join("\n");
+  }
+
+  private formatGroupHistory(messages: ChatMessage[]): string {
+    if (!messages.length) return "(none)";
+    return messages
+      .map((m) => {
+        const name = m.userName || "unknown";
+        const messageId = m.messageId ?? "unknown";
+        return `[历史群聊 | ${this.formatTimestamp(m.timestamp)} | message_id:${messageId}] ${name}: ${m.content}（不是刚刚发送）`;
+      })
+      .join("\n");
+  }
+
+  private formatUserHistories(chunks: MemoryUserHistoryChunk[]): string {
+    if (!chunks.length) return "(none)";
+
+    const sections = chunks.map((chunk) => {
+      if (!chunk.messages.length) {
+        return `User ${chunk.userId}: (no historical messages)`;
+      }
+
+      const lines = chunk.messages.map((m) => {
+        const name = m.userName || `user:${chunk.userId}`;
+        const messageId = m.messageId ?? "unknown";
+        return `[历史用户消息 | ${this.formatTimestamp(m.timestamp)} | message_id:${messageId}] ${name}: ${m.content}（不是刚刚发送）`;
+      });
+
+      return `User ${chunk.userId} history:\n${lines.join("\n")}`;
+    });
+
+    return sections.join("\n\n");
+  }
+
+  private formatTimestamp(timestamp: number): string {
+    return new Date(timestamp).toLocaleString("zh-CN", { hour12: false });
+  }
+}

package/humanize/planner.ts

@@ -0,0 +1,249 @@
+import type { AIInstance } from "mioku";
+import { logger } from "mioki";
+import type {
+  ChatConfig,
+  ChatMessage,
+  PlannerAction,
+  PlannerResult,
+} from "../types";
+
+export class ActionPlanner {
+  private ai: AIInstance;
+  private config: ChatConfig;
+  private actionHistory: Map<
+    string,
+    { action: PlannerAction; time: number }[]
+  > = new Map();
+  private pendingPlans: Map<string, Promise<PlannerResult>> = new Map();
+
+  constructor(ai: AIInstance, config: ChatConfig) {
+    this.ai = ai;
+    this.config = config;
+  }
+
+  async plan(
+    sessionId: string,
+    botName: string,
+    recentHistory: ChatMessage[],
+    lastTriggerMessage: string,
+    isIdleCheck: boolean = false,
+  ): Promise<PlannerResult> {
+    if (!this.config.planner?.enabled) {
+      return { action: "reply", reason: "planner disabled" };
+    }
+
+    // Guard: if a plan call is already in-flight for this session, wait for it
+    const existing = this.pendingPlans.get(sessionId);
+    if (existing) {
+      logger.info(`[ActionPlanner] Session ${sessionId} has a plan already in-flight, waiting...`);
+      return existing;
+    }
+
+    const planPromise = this.doPlan(sessionId, botName, recentHistory, lastTriggerMessage, isIdleCheck);
+    this.pendingPlans.set(sessionId, planPromise);
+
+    try {
+      return await planPromise;
+    } finally {
+      this.pendingPlans.delete(sessionId);
+    }
+  }
+
+  private async doPlan(
+    sessionId: string,
+    botName: string,
+    recentHistory: ChatMessage[],
+    lastTriggerMessage: string,
+    isIdleCheck: boolean,
+  ): Promise<PlannerResult> {
+    if (!this.config.planner?.enabled) {
+      return { action: "reply", reason: "planner disabled" };
+    }
+
+    const history = this.actionHistory.get(sessionId) ?? [];
+    const recentActions = history.slice(-10);
+    const actionsBlock = recentActions
+      .map((a) => `[${new Date(a.time).toLocaleTimeString()}] ${a.action}`)
+      .join("\n");
+
+    const chatBlock = recentHistory
+      .slice(-100)
+      .map((m) => {
+        const time = new Date(m.timestamp);
+        const timeStr = `${String(time.getHours()).padStart(2, "0")}:${String(time.getMinutes()).padStart(2, "0")}`;
+        return `[${timeStr}] ${m.userName || (m.role === "assistant" ? botName : "unknown")}: ${m.content}`;
+      })
+      .join("\n");
+
+    const now = new Date();
+    const timeStr = `${now.getFullYear()}/${String(now.getMonth() + 1).padStart(2, "0")}/${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+
+    let prompt: string;
+
+    if (isIdleCheck) {
+      // 空闲检测模式：没有明确触发消息，观察群友聊天并决定是否要融入对话
+      prompt = `It is ${timeStr}. Your name is ${botName}.
+
+Here is the recent chat content (from oldest to most recent):
+${chatBlock || "(no chat history)"}
+
+IMPORTANT: There is no specific trigger message this time. You are being proactively invited to observe the group chat and decide whether to speak up.
+
+REPLY when ANY of these is true:
+- The conversation mentions ${botName} (you), AI, or any topic you know about
+- There's any question unanswered
+- The conversation is about school, life, tech, or anything you can contribute to
+- Even fragmented/random messages - you can start a new topic or comment on something!
+
+WAIT only when:
+- The conversation is clearly done and everyone left
+- There's absolutely nothing you can think of to say
+
+IMPORTANT: When in doubt, REPLY! Group chats are often casual and fragmented - that's okay! Your message doesn't need to be perfect, just be natural and friendly.
+
+Available actions:
+
+reply - Send a message to naturally join the conversation (1-2 sentences max, be concise!)
+
+wait - Stay silent and continue observing
+
+complete - The chat is dead, no one is talking
+
+IMPORTANT: You MUST output ONLY valid JSON, no other text. The JSON must be in this exact format:
+{"action": "reply", "reason": "your reason here", "wait_seconds": 0}
+
+OR for wait:
+{"action": "wait", "reason": "your reason here", "wait_seconds": 60}
+
+OR for complete:
+{"action": "complete", "reason": "your reason here", "wait_seconds": 0}
+
+DO NOT include any explanation, markdown formatting, or additional text. Only output the JSON.`;
+    } else {
+      // 正常模式：由触发消息驱动的 planner
+      prompt = `It is ${timeStr}. Your name is ${botName}.
+
+Here is the chat content:
+${chatBlock}
+
+Action history:
+${actionsBlock || "(none)"}
+
+Message that triggered you: ${lastTriggerMessage}
+
+Available actions:
+
+reply - Respond ONLY when truly necessary:
+- Someone directly asked you a question
+- Someone mentioned you specifically
+- Something needs explanation or clarification
+- There's an obvious opportunity to add real value
+
+wait - DEFAULT choice. Stay silent when:
+- You have nothing meaningful to add
+- The conversation doesn't need you
+- Someone else is already handling it
+- You're just being polite but have nothing to say
+
+complete - The chat is over, no activity for a while
+
+IMPORTANT: Silence is golden. When in doubt, WAIT. Don't speak just because you can.
+
+IMPORTANT: You MUST output ONLY valid JSON, no other text. The JSON must be in this exact format:
+{"action": "reply", "reason": "your reason here", "wait_seconds": 0}
+
+OR for wait:
+{"action": "wait", "reason": "your reason here", "wait_seconds": 30}
+
+OR for complete:
+{"action": "complete", "reason": "your reason here", "wait_seconds": 0}
+
+DO NOT include any explanation, markdown formatting, or additional text. Only output the JSON.`;
+    }
+
+    try {
+      logger.info(
+        `[ActionPlanner] Planning action for session ${sessionId}, last message: "${lastTriggerMessage.substring(0, 50)}...", isIdleCheck: ${isIdleCheck}`,
+      );
+
+      const content = await this.ai.generateText({
+        prompt,
+        messages: [],
+        model: this.config.workingModel || this.config.model,
+        temperature: isIdleCheck ? 0.3 : 0.2,
+        max_tokens: isIdleCheck ? 300 : 500,
+      });
+
+      // 如果返回内容为空，使用默认值
+      if (!content || !content.trim()) {
+        logger.warn(
+          `[ActionPlanner] Empty response from AI, using default reply`,
+        );
+        return { action: "reply", reason: "empty response" };
+      }
+
+      // 尝试提取 JSON 块
+      let jsonStr = "";
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        jsonStr = jsonMatch[0];
+      }
+
+      if (!jsonStr) {
+        logger.warn(
+          `[ActionPlanner] Failed to find JSON in response: ${content.substring(0, 100)}`,
+        );
+        return { action: "reply", reason: "parse failed" };
+      }
+
+      // 尝试解析 JSON
+      let parsed: any;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        // 尝试修复常见的 JSON 错误
+        try {
+          // 移除可能存在的尾随逗号
+          jsonStr = jsonStr.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]");
+          parsed = JSON.parse(jsonStr);
+        } catch (e) {
+          logger.warn(
+            `[ActionPlanner] Failed to parse JSON: ${jsonStr.substring(0, 100)}`,
+          );
+          return { action: "reply", reason: "parse failed" };
+        }
+      }
+      const action: PlannerAction =
+        parsed.action === "wait"
+          ? "wait"
+          : parsed.action === "complete"
+            ? "complete"
+            : "reply";
+
+      const result: PlannerResult = {
+        action,
+        reason: parsed.reason || "",
+        waitMs:
+          action === "wait"
+            ? Math.min(
+                Math.max((parsed.wait_seconds || 30) * 1000, 10000),
+                300000,
+              )
+            : undefined,
+      };
+
+      const actions = this.actionHistory.get(sessionId) ?? [];
+      actions.push({ action, time: Date.now() });
+      if (actions.length > 20) actions.splice(0, actions.length - 20);
+      this.actionHistory.set(sessionId, actions);
+
+      logger.info(
+        `[ActionPlanner] Session ${sessionId}: action=${action}, reason="${result.reason}"${result.waitMs ? `, waitMs=${result.waitMs}` : ""}`,
+      );
+      return result;
+    } catch (err) {
+      logger.error(`[ActionPlanner] Error: ${err}`);
+      return { action: "reply", reason: "error fallback" };
+    }
+  }
+}

package/humanize/topic.ts

@@ -0,0 +1,205 @@
+import type { AIInstance } from "mioku";
+import { logger } from "mioki";
+import type { ChatDatabase } from "../db";
+import type { ChatConfig } from "../types";
+
+export class TopicTracker {
+  private ai: AIInstance;
+  private config: ChatConfig;
+  private db: ChatDatabase;
+  private lastAnalyzedWindowEnd: Map<string, number> = new Map();
+
+  constructor(ai: AIInstance, config: ChatConfig, db: ChatDatabase) {
+    this.ai = ai;
+    this.config = config;
+    this.db = db;
+  }
+
+  async onMessage(sessionId: string): Promise<void> {
+    if (!this.config.topic?.enabled) return;
+    if (!sessionId.startsWith("group:")) return;
+
+    const windowMs = this.getWindowMs();
+    const completedWindowEnd = Math.floor(Date.now() / windowMs) * windowMs;
+    if (completedWindowEnd <= 0) return;
+
+    const lastAnalyzedEnd = this.lastAnalyzedWindowEnd.get(sessionId) ?? 0;
+    if (completedWindowEnd <= lastAnalyzedEnd) {
+      return;
+    }
+
+    this.lastAnalyzedWindowEnd.set(sessionId, completedWindowEnd);
+    const windowStartAt = completedWindowEnd - windowMs;
+
+    this.analyzeWindow(sessionId, windowStartAt, completedWindowEnd).catch(
+      (err) => logger.warn(`[TopicTracker] Analysis failed: ${err}`),
+    );
+  }
+
+  getTopicContext(sessionId: string, historyStartAt?: number): string {
+    if (!this.config.topic?.enabled) return "";
+    if (!sessionId.startsWith("group:")) return "";
+    if (!historyStartAt) return "";
+
+    const windowMs = this.getWindowMs();
+    const windowCount = this.getHistoryWindowCount();
+    const firstWindowEnd = Math.floor(historyStartAt / windowMs) * windowMs;
+    if (firstWindowEnd <= 0) return "";
+
+    const lines: string[] = [];
+    for (let i = 0; i < windowCount; i++) {
+      const windowEndAt = firstWindowEnd - i * windowMs;
+      const windowStartAt = windowEndAt - windowMs;
+      if (windowStartAt <= 0) break;
+
+      const topic = this.db.getTopicByWindow(sessionId, windowStartAt, windowEndAt);
+      if (!topic?.summary) continue;
+
+      const keywords = this.parseKeywords(topic.keywords);
+      const timeRange = `${this.formatTime(windowStartAt)} ~ ${this.formatTime(windowEndAt)}`;
+      const keywordsLine =
+        keywords.length > 0 ? ` | 关键词: ${keywords.join(", ")}` : "";
+      lines.push(
+        `- ${timeRange}: ${topic.summary.trim()}${keywordsLine}`,
+      );
+    }
+
+    if (lines.length === 0) return "";
+
+    return [
+      "## Background Topics Outside Visible History (Reference Only)",
+      "These summaries are rough references about older group discussions.",
+      "Do not proactively bring them up unless users explicitly ask.",
+      ...lines,
+    ].join("\n");
+  }
+
+  private async analyzeWindow(
+    sessionId: string,
+    windowStartAt: number,
+    windowEndAt: number,
+  ): Promise<void> {
+    if (windowEndAt <= windowStartAt) return;
+
+    const userMessages = this.db
+      .getMessagesByTimeRange(sessionId, windowStartAt, windowEndAt)
+      .filter((message) => message.role === "user" && message.content.trim());
+
+    if (userMessages.length < 5) return;
+
+    const existing = this.db.getTopicByWindow(sessionId, windowStartAt, windowEndAt);
+    const messagesBlock = userMessages
+      .map((message, index) => {
+        const time = this.formatTime(message.timestamp);
+        return `[${index + 1}][${time}] ${message.userName || "unknown"}: ${message.content}`;
+      })
+      .join("\n");
+
+    try {
+      const content = await this.ai.generateText({
+        prompt: `You are a concise topic summarization assistant.
+
+Only summarize the provided chat log within this exact time window:
+${this.formatTime(windowStartAt)} ~ ${this.formatTime(windowEndAt)}
+
+Rules:
+1. Use ONLY messages from this log. Do not infer anything outside this 5-hour window.
+2. The topic must be high-level, abstract, and concise.
+3. The summary must be brief, not detailed.
+4. Keep the output in the same language as the chat log.
+
+Chat log:
+${messagesBlock}
+
+Output strictly in JSON format:
+{
+  "title": "short topic title",
+  "keywords": ["keyword1", "keyword2"],
+  "summary": "one concise abstract summary sentence"
+}`,
+        messages: [],
+        model: this.config.workingModel || this.config.model,
+        temperature: 0.2,
+        max_tokens: 300,
+      });
+
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return;
+
+      const parsed = JSON.parse(jsonMatch[0]);
+      const summary = String(parsed.summary || "").trim();
+      if (!summary) return;
+
+      const keywords = this.normalizeKeywords(parsed.keywords);
+      const title =
+        String(parsed.title || "").trim() ||
+        `${this.formatTime(windowStartAt)} 话题概览`;
+
+      if (existing?.id) {
+        this.db.updateTopic(existing.id, {
+          summary,
+          keywords: JSON.stringify(keywords),
+          messageCount: userMessages.length,
+          updatedAt: windowEndAt,
+        });
+      } else {
+        this.db.saveTopic({
+          sessionId,
+          title,
+          keywords: JSON.stringify(keywords),
+          summary,
+          messageCount: userMessages.length,
+          windowStartAt,
+          windowEndAt,
+          createdAt: windowEndAt,
+          updatedAt: windowEndAt,
+        });
+      }
+
+      logger.info(
+        `[TopicTracker] Session ${sessionId}: summarized window ${this.formatTime(windowStartAt)} ~ ${this.formatTime(windowEndAt)} (${userMessages.length} user messages)`,
+      );
+    } catch (err) {
+      logger.warn(`[TopicTracker] Analysis failed: ${err}`);
+    }
+  }
+
+  private getWindowMs(): number {
+    const hours = Number(this.config.topic?.windowHours);
+    const safeHours = Number.isFinite(hours) && hours > 0 ? hours : 5;
+    return Math.max(1, Math.floor(safeHours)) * 3600_000;
+  }
+
+  private getHistoryWindowCount(): number {
+    const count = Number(this.config.topic?.historyWindowCount);
+    if (!Number.isFinite(count) || count <= 0) return 3;
+    return Math.max(1, Math.floor(count));
+  }
+
+  private normalizeKeywords(input: unknown): string[] {
+    if (!Array.isArray(input)) return [];
+    const cleaned = input
+      .map((item) => String(item || "").trim())
+      .filter(Boolean);
+    return [...new Set(cleaned)].slice(0, 8);
+  }
+
+  private parseKeywords(raw: string): string[] {
+    try {
+      const parsed = JSON.parse(raw);
+      return this.normalizeKeywords(parsed);
+    } catch {
+      return [];
+    }
+  }
+
+  private formatTime(timestamp: number): string {
+    const date = new Date(timestamp);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hour = String(date.getHours()).padStart(2, "0");
+    const minute = String(date.getMinutes()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hour}:${minute}`;
+  }
+}

package/humanize/utils.ts

@@ -0,0 +1,28 @@
+import type { ChatConfig } from "../types";
+
+export function pickReplyStyle(config: ChatConfig): string {
+  const { replyStyle } = config;
+  if (!replyStyle) return "";
+
+  const base = replyStyle.baseStyle || "";
+  const styles = replyStyle.multipleStyles || [];
+  const prob = replyStyle.multipleProbability ?? 0;
+
+  if (styles.length > 0 && prob > 0 && Math.random() < prob) {
+    return styles[Math.floor(Math.random() * styles.length)];
+  }
+  return base;
+}
+
+export function pickPersonalityState(config: ChatConfig): string | null {
+  const { personality } = config;
+  if (!personality) return null;
+
+  const states = personality.states || [];
+  const prob = personality.stateProbability ?? 0;
+
+  if (states.length > 0 && prob > 0 && Math.random() < prob) {
+    return states[Math.floor(Math.random() * states.length)];
+  }
+  return null;
+}