evolcore 0.0.1 → 0.0.2

package/dist/core/message/items-formatter.js

@@ -0,0 +1,76 @@
+/**
+ * 把结构化 ThoughtItem 数组降级为人类可读的纯文本。
+ * 用于不支持 thought 能力的渠道（Feishu/WeChat/DingTalk/QQBot/WeCom），
+ * 在 send() 中收到 activity.batch 后调用。
+ */
+export function formatItemsAsText(items) {
+    if (!items || items.length === 0)
+        return ''; // early exit
+    const lines = [];
+    for (const item of items) {
+        const line = formatItem(item);
+        if (line)
+            lines.push(line);
+    }
+    return lines.join('\n');
+}
+function formatItem(item) {
+    switch (item.kind) {
+        case 'text':
+            return item.text;
+        case 'reasoning':
+            return `💭 ${item.text}`;
+        case 'tool_call': {
+            const desc = item.text || summarizeArgs(item.arguments);
+            if (!desc)
+                return `🔧 ${item.name}`;
+            // 多行 desc（如 Edit diff）：第一行跟工具名同行，代码块从新行开始
+            if (desc.includes('\n')) {
+                const nlIdx = desc.indexOf('\n');
+                return `🔧 ${item.name}  ${desc.slice(0, nlIdx)}\n${desc.slice(nlIdx + 1)}`;
+            }
+            return `🔧 ${item.name}: ${desc}`;
+        }
+        case 'tool_result': {
+            if (!item.ok) {
+                const errMsg = item.error || (typeof item.result === 'string' ? item.result : '执行失败');
+                return `⚠️ ${item.name}: ${capChars(errMsg, 200)}`;
+            }
+            return item.text ? `✓ ${item.name}: ${item.text}` : `✓ ${item.name}`;
+        }
+        case 'progress':
+            return `⏳ ${item.text}`;
+        case 'notice':
+            return item.severity === 'warn' ? `⚠️ ${item.text}` : item.text;
+        case 'summary':
+            return item.is_error ? `❌ ${item.text}` : item.text;
+        default:
+            return '';
+    }
+}
+/** 把文本截断到最多 maxChars 个字符，超出部分用省略提示替代。用于工具报错输出，避免刷屏。 */
+function capChars(text, maxChars) {
+    const chars = Array.from(text);
+    if (chars.length <= maxChars)
+        return text;
+    const omitted = chars.length - maxChars;
+    return chars.slice(0, maxChars).join('') + `\n…(省略 ${omitted} 字)`;
+}
+function summarizeArgs(args) {
+    if (!args || typeof args !== 'object')
+        return '';
+    const a = args;
+    if (typeof a.description === 'string')
+        return a.description;
+    if (typeof a.file_path === 'string')
+        return a.file_path;
+    if (typeof a.pattern === 'string')
+        return a.pattern;
+    if (typeof a.command === 'string')
+        return a.command.substring(0, 80);
+    if (typeof a.prompt === 'string')
+        return a.prompt.substring(0, 80);
+    if (typeof a.query === 'string')
+        return a.query.substring(0, 80);
+    return '';
+}

package/dist/core/message/logical-queue-bridge.js

@@ -0,0 +1,123 @@
+/**
+ * Logical Queue Bridge
+ *
+ * 桥接物理队列（MessageQueue 的 QueuedMessage[]）与逻辑队列（响应模式的出队策略）。
+ *
+ * 职责分离：
+ *   - 物理队列：消息存储、持久化、去重、中断（MessageQueue 现有职责，不变）
+ *   - 逻辑队列：仅决定出队顺序（FIFO/LIFO/Priority/Custom，由响应模式提供）
+ *
+ * 桥接原理：
+ *   - enqueue 时：物理数组 push + 逻辑队列记录 messageId 顺序
+ *   - 出队时：逻辑队列给出下一个 messageId，桥接器据此在物理数组中定位并前移到队首
+ *   - 这样 dequeueGreedy 的 queue.shift() 取到的就是逻辑队列选定的消息
+ *
+ * 默认行为：无逻辑队列时退化为纯 FIFO（与重构前一致）。
+ */
+import { FIFOQueue } from '../../response-system/queues/fifo-queue.js';
+export class LogicalQueueBridge {
+    /** queueKey → 逻辑队列实例 */
+    queues = new Map();
+    /** 工厂：按 queueKey 创建逻辑队列（默认 FIFO，未来由响应模式 resolver 注入） */
+    factory;
+    constructor(factory) {
+        this.factory = factory ?? (() => new FIFOQueue());
+    }
+    /** 设置队列工厂（响应模式系统接入时调用） */
+    setFactory(factory) {
+        this.factory = factory;
+    }
+    /** 为指定会话替换逻辑队列（切换响应模式时调用） */
+    setQueue(queueKey, queue) {
+        this.queues.set(queueKey, queue);
+    }
+    /** 获取指定会话的逻辑队列（用于同步） */
+    getQueue(queueKey) {
+        return this.queues.get(queueKey);
+    }
+    /** 入队：记录 messageId 到逻辑队列的顺序索引 */
+    enqueue(queueKey, message) {
+        const queue = this.getOrCreate(queueKey);
+        queue.enqueue(this.toInbound(message));
+    }
+    /**
+     * 按逻辑队列顺序重排物理数组（原地修改）。
+     * dequeueGreedy 在 shift 前调用此方法，确保队首是逻辑队列选定的消息。
+     *
+     * @returns true 表示完成重排，false 表示无逻辑队列（保持 FIFO）
+     */
+    reorderPhysical(queueKey, physical) {
+        const queue = this.queues.get(queueKey);
+        if (!queue || physical.length <= 1)
+            return false;
+        // 逻辑队列给出下一个 messageId（使用 peek 避免提前移除）
+        let next;
+        if (queue.size() > 0) {
+            next = queue.peekSync?.();
+            // 兼容旧的内置 FIFO 实现形状；自定义队列应实现 peekSync，避免这里出队。
+            if (!next)
+                next = queue.queue?.[0];
+            if (!next) {
+                // 兜底：如果没有内部 queue 数组，使用 dequeueSync（旧行为）
+                next = queue.dequeueSync();
+            }
+        }
+        if (!next?.messageId)
+            return false;
+        // 在物理数组中定位该消息，前移到队首
+        const idx = physical.findIndex(item => this.messageIdOf(item.message) === next.messageId);
+        if (idx <= 0)
+            return idx === 0; // 已在队首或未找到（未找到时保持原序）
+        const [picked] = physical.splice(idx, 1);
+        physical.unshift(picked);
+        return true;
+    }
+    /** 移除逻辑队列中已处理的消息（供 dequeueGreedy 合并后调用） */
+    removeProcessed(queueKey, messageIds) {
+        const queue = this.queues.get(queueKey);
+        if (!queue)
+            return;
+        for (const msgId of messageIds) {
+            // 从队首依次匹配并移除
+            if (queue.size() > 0) {
+                const head = queue.peekSync?.() ?? queue.queue?.[0];
+                if (head?.messageId === msgId) {
+                    queue.dequeueSync();
+                }
+            }
+        }
+    }
+    /** 清空指定会话的逻辑队列 */
+    clear(queueKey) {
+        this.queues.get(queueKey)?.clear();
+    }
+    /** 移除指定会话的逻辑队列（会话结束时） */
+    remove(queueKey) {
+        this.queues.delete(queueKey);
+    }
+    // ─── 内部辅助 ───
+    getOrCreate(queueKey) {
+        let queue = this.queues.get(queueKey);
+        if (!queue) {
+            queue = this.factory(queueKey);
+            this.queues.set(queueKey, queue);
+        }
+        return queue;
+    }
+    toInbound(message) {
+        return {
+            messageId: this.messageIdOf(message),
+            peerId: message.peerId,
+            content: message.content,
+            chatType: message.chatType ?? 'private',
+            isMentioned: message.isMentioned,
+            mentionAids: message.mentionAids,
+        };
+    }
+    /** 稳定的 messageId：优先用消息自带 ID，否则用 peerId+timestamp 合成 */
+    messageIdOf(message) {
+        if (message.messageId)
+            return message.messageId;
+        return `${message.peerId}_${message.timestamp ?? 0}`;
+    }
+}